mne.io.Raw¶

class mne.io.Raw(fname, allow_maxshield=False, preload=False, verbose=None)[source]¶

Raw data in FIF format.

Parameters:

Parameters:	fname : str The raw file to load. For files that have automatically been split, the split part will be automatically loaded. Filenames should end with raw.fif, raw.fif.gz, raw_sss.fif, raw_sss.fif.gz, raw_tsss.fif or raw_tsss.fif.gz. allow_maxshield : bool \| str (default False) If True, allow loading of data that has been recorded with internal active compensation (MaxShield). Data recorded with MaxShield should generally not be loaded directly, but should first be processed using SSS/tSSS to remove the compensation signals that may also affect brain activity. Can also be “yes” to load without eliciting a warning. preload : bool or str (default False) Preload data into memory for data manipulation and faster indexing. If True, the data will be preloaded into memory (fast, requires large amount of memory). If preload is a string, preload is the file name of a memory-mapped file which is used to store the data on the hard drive (slower, requires less memory). verbose : bool, str, int, or None If not None, override default verbose level (see `mne.verbose()` and Logging documentation for more).
Attributes:	info : dict `Measurement info`. `ch_names` : list of string Channel names. `n_times` : int Number of time points. `times` : ndarray Time points. preload : bool Indicates whether raw data are in memory. verbose : bool, str, int, or None See above.

fname : str: The raw file to load. For files that have automatically been split, the split part will be automatically loaded. Filenames should end with raw.fif, raw.fif.gz, raw_sss.fif, raw_sss.fif.gz, raw_tsss.fif or raw_tsss.fif.gz.
allow_maxshield : bool | str (default False): If True, allow loading of data that has been recorded with internal active compensation (MaxShield). Data recorded with MaxShield should generally not be loaded directly, but should first be processed using SSS/tSSS to remove the compensation signals that may also affect brain activity. Can also be “yes” to load without eliciting a warning.
preload : bool or str (default False): Preload data into memory for data manipulation and faster indexing. If True, the data will be preloaded into memory (fast, requires large amount of memory). If preload is a string, preload is the file name of a memory-mapped file which is used to store the data on the hard drive (slower, requires less memory).
verbose : bool, str, int, or None: If not None, override default verbose level (see mne.verbose() and Logging documentation for more).

Attributes:

info : dict: Measurement info.
ch_names : list of string: Channel names.
n_times : int: Number of time points.
times : ndarray: Time points.
preload : bool: Indicates whether raw data are in memory.
verbose : bool, str, int, or None: See above.

Methods

`__contains__`(ch_type)	Check channel type membership.
`__getitem__`(item)	Get raw data and times.
`__hash__`()	Hash the object.
`__len__`()	Return the number of time points.
`add_channels`(add_list[, force_update_info])	Append new channels to the instance.
`add_events`(events[, stim_channel])	Add events to stim channel.
`add_proj`(projs[, remove_existing, verbose])	Add SSP projection vectors.
`anonymize`()	Anonymize measurement information in place.
`append`(raws[, preload])	Concatenate raw instances as if they were continuous.
`apply_function`(fun[, picks, dtype, n_jobs])	Apply a function to a subset of channels.
`apply_gradient_compensation`(grade[, verbose])	Apply CTF gradient compensation.
`apply_hilbert`([picks, envelope, n_jobs, …])	Compute analytic signal or envelope for a subset of channels.
`apply_proj`()	Apply the signal space projection (SSP) operators to the data.
`close`()	Clean up the object.
`copy`()	Return copy of Raw instance.
`crop`([tmin, tmax])	Crop raw data file.
`del_proj`([idx])	Remove SSP projection vector.
`drop_channels`(ch_names)	Drop some channels.
`estimate_rank`([tstart, tstop, tol, …])	Estimate rank of the raw data.
`filter`(l_freq, h_freq[, picks, …])	Filter a subset of channels.
`fix_mag_coil_types`()	Fix Elekta magnetometer coil types.
`get_data`([picks, start, stop, …])	Get data in the given range.
`interpolate_bads`([reset_bads, mode, verbose])	Interpolate bad MEG and EEG channels.
`load_bad_channels`([bad_file, force])	Mark channels as bad from a text file.
`load_data`([verbose])	Load raw data.
`notch_filter`(freqs[, picks, filter_length, …])	Notch filter a subset of channels.
`pick_channels`(ch_names)	Pick some channels.
`pick_types`([meg, eeg, stim, eog, ecg, emg, …])	Pick some channels by type and names.
`plot`([events, duration, start, n_channels, …])	Plot raw data.
`plot_projs_topomap`([ch_type, layout, axes])	Plot SSP vector.
`plot_psd`([tmin, tmax, fmin, fmax, proj, …])	Plot the power spectral density across channels.
`plot_psd_topo`([tmin, tmax, fmin, fmax, …])	Plot channel-wise frequency spectra as topography.
`plot_sensors`([kind, ch_type, title, …])	Plot sensor positions.
`rename_channels`(mapping)	Rename channels.
`reorder_channels`(ch_names)	Reorder channels.
`resample`(sfreq[, npad, window, stim_picks, …])	Resample all channels.
`save`(fname[, picks, tmin, tmax, …])	Save raw data to file.
`set_channel_types`(mapping)	Define the sensor type of channels.
`set_eeg_reference`([ref_channels, …])	Specify which reference to use for EEG data.
`set_montage`(montage[, set_dig, verbose])	Set EEG sensor configuration and head digitization.
`time_as_index`(times[, use_rounding])	Convert time to indices.
`to_data_frame`([picks, index, scaling_time, …])	Export data in tabular structure as a pandas DataFrame.

__contains__(ch_type)[source]¶

Check channel type membership.

Parameters:	ch_type : str Channel type to check for. Can be e.g. ‘meg’, ‘eeg’, ‘stim’, etc.
Returns:	in : bool Whether or not the instance contains the given channel type.

Examples

Channel type membership can be tested as:

>>> 'meg' in inst  
True
>>> 'seeg' in inst  
False

__getitem__(item)[source]¶

Get raw data and times.

Parameters:	item : tuple or array-like See below for use cases.
Returns:	data : ndarray, shape (n_channels, n_times) The raw data. times : ndarray, shape (n_times,) The times associated with the data.

Examples

Generally raw data is accessed as:

>>> data, times = raw[picks, time_slice]  

To get all data, you can thus do either of:

>>> data, times = raw[:]  

Which will be equivalent to:

>>> data, times = raw[:, :]  

To get only the good MEG data from 10-20 seconds, you could do:

>>> picks = mne.pick_types(raw.info, meg=True, exclude='bads')  
>>> t_idx = raw.time_as_index([10., 20.])  
>>> data, times = raw[picks, t_idx[0]:t_idx[1]]  

__hash__()[source]¶

Hash the object.

Returns:	hash : int The hash

__len__()[source]¶

Return the number of time points.

Returns:	len : int The number of time points.

Examples

This can be used as:

>>> len(raw)  
1000

acqparser¶: The AcqParserFIF for the measurement info.

See also

mne.AcqParserFIF

add_channels(add_list, force_update_info=False)[source]¶

Append new channels to the instance.

Parameters:	add_list : list A list of objects to append to self. Must contain all the same type as the current object force_update_info : bool If True, force the info for objects to be appended to match the values in self. This should generally only be used when adding stim channels for which important metadata won’t be overwritten. New in version 0.12.
Returns:	inst : instance of Raw, Epochs, or Evoked The modified instance.

See also

drop_channels

add_events(events, stim_channel=None)[source]¶

Add events to stim channel.

Parameters:

Parameters:	events : ndarray, shape (n_events, 3) Events to add. The first column specifies the sample number of each event, the second column is ignored, and the third column provides the event value. If events already exist in the Raw instance at the given sample numbers, the event values will be added together. stim_channel : str \| None Name of the stim channel to add to. If None, the config variable ‘MNE_STIM_CHANNEL’ is used. If this is not found, it will default to ‘STI 014’.

events : ndarray, shape (n_events, 3): Events to add. The first column specifies the sample number of each event, the second column is ignored, and the third column provides the event value. If events already exist in the Raw instance at the given sample numbers, the event values will be added together.
stim_channel : str | None: Name of the stim channel to add to. If None, the config variable ‘MNE_STIM_CHANNEL’ is used. If this is not found, it will default to ‘STI 014’.

Notes

Data must be preloaded in order to add events.

add_proj(projs, remove_existing=False, verbose=None)[source]¶

Add SSP projection vectors.

Parameters:	projs : list List with projection vectors. remove_existing : bool Remove the projection vectors currently in the file. verbose : bool, str, int, or None If not None, override default verbose level (see `mne.verbose()` and Logging documentation for more).
Returns:	self : instance of Raw \| Epochs \| Evoked The data container.

annotations¶: Annotations for marking segments of data.

anonymize()[source]¶

Anonymize measurement information in place.

Reset ‘subject_info’, ‘meas_date’, ‘file_id’, and ‘meas_id’ keys if they exist in info.

Returns:	info : instance of Info Measurement information for the dataset.

Notes

Operates in place.

New in version 0.13.0.

append(raws, preload=None)[source]¶

Concatenate raw instances as if they were continuous.

Note

Boundaries of the raw files are annotated bad. If you wish to use the data as continuous recording, you can remove the boundary annotations after concatenation (see mne.Annotations.delete()).

Parameters:

Parameters:	raws : list, or Raw instance list of Raw instances to concatenate to the current instance (in order), or a single raw instance to concatenate. preload : bool, str, or None (default None) Preload data into memory for data manipulation and faster indexing. If True, the data will be preloaded into memory (fast, requires large amount of memory). If preload is a string, preload is the file name of a memory-mapped file which is used to store the data on the hard drive (slower, requires less memory). If preload is None, preload=True or False is inferred using the preload status of the raw files passed in.

raws : list, or Raw instance: list of Raw instances to concatenate to the current instance (in order), or a single raw instance to concatenate.
preload : bool, str, or None (default None): Preload data into memory for data manipulation and faster indexing. If True, the data will be preloaded into memory (fast, requires large amount of memory). If preload is a string, preload is the file name of a memory-mapped file which is used to store the data on the hard drive (slower, requires less memory). If preload is None, preload=True or False is inferred using the preload status of the raw files passed in.

apply_function(fun, picks=None, dtype=None, n_jobs=1, *args, **kwargs)[source]¶

Apply a function to a subset of channels.

The function “fun” is applied to the channels defined in “picks”. The data of the Raw object is modified inplace. If the function returns a different data type (e.g. numpy.complex) it must be specified using the dtype parameter, which causes the data type used for representing the raw data to change.

The Raw object has to have the data loaded e.g. with preload=True or self.load_data().

Note

If n_jobs > 1, more memory is required as len(picks) * n_times additional time points need to be temporaily stored in memory.

Note

If the data type changes (dtype != None), more memory is required since the original and the converted data needs to be stored in memory.

Parameters:

Parameters:	fun : function A function to be applied to the channels. The first argument of fun has to be a timeseries (numpy.ndarray). The function must return an numpy.ndarray with the same size as the input. picks : array-like of int (default: None) Indices of channels to apply the function to. If None, all data channels are used. dtype : numpy.dtype (default: None) Data type to use for raw data after applying the function. If None the data type is not modified. n_jobs: int (default: 1) Number of jobs to run in parallel. args : Additional positional arguments to pass to fun (first pos. argument of fun is the timeseries of a channel). *kwargs : Keyword arguments to pass to fun. Note that if “verbose” is passed as a member of `kwargs`, it will be consumed and will override the default mne-python verbose level (see `mne.verbose()` and Logging documentation for more).
Returns:	self : instance of Raw The raw object with transformed data.

fun : function: A function to be applied to the channels. The first argument of fun has to be a timeseries (numpy.ndarray). The function must return an numpy.ndarray with the same size as the input.
picks : array-like of int (default: None): Indices of channels to apply the function to. If None, all data channels are used.
dtype : numpy.dtype (default: None): Data type to use for raw data after applying the function. If None the data type is not modified.
n_jobs: int (default: 1): Number of jobs to run in parallel.
*args :: Additional positional arguments to pass to fun (first pos. argument of fun is the timeseries of a channel).
**kwargs :: Keyword arguments to pass to fun. Note that if “verbose” is passed as a member of kwargs, it will be consumed and will override the default mne-python verbose level (see mne.verbose() and Logging documentation for more).

Returns:

self : instance of Raw: The raw object with transformed data.

apply_gradient_compensation(grade, verbose=None)[source]¶

Apply CTF gradient compensation.

Warning

The compensation matrices are stored with single precision, so repeatedly switching between different of compensation (e.g., 0->1->3->2) can increase numerical noise, especially if data are saved to disk in between changing grades. It is thus best to only use a single gradient compensation level in final analyses.

Parameters:	grade : int CTF gradient compensation level. verbose : bool, str, int, or None If not None, override default verbose level (see `mne.verbose()` and Logging documentation for more).
Returns:	raw : instance of Raw The modified Raw instance. Works in-place.

apply_hilbert(picks=None, envelope=False, n_jobs=1, n_fft='auto', verbose=None)[source]¶

Compute analytic signal or envelope for a subset of channels.

If envelope=False, the analytic signal for the channels defined in “picks” is computed and the data of the Raw object is converted to a complex representation (the analytic signal is complex valued).

If envelope=True, the absolute value of the analytic signal for the channels defined in “picks” is computed, resulting in the envelope signal.

Note

If envelope=False, more memory is required since the original raw data as well as the analytic signal have temporarily to be stored in memory.

Note

If n_jobs > 1, more memory is required as len(picks) * n_times additional time points need to be temporaily stored in memory.

Parameters:

Parameters:	picks : array-like of int (default: None) Indices of channels to apply the function to. If None, all data channels are used. envelope : bool (default: False) Compute the envelope signal of each channel. n_jobs: int Number of jobs to run in parallel. n_fft : int \| None \| str Points to use in the FFT for Hilbert transformation. The signal will be padded with zeros before computing Hilbert, then cut back to original length. If None, n == self.n_times. If ‘auto’, the next highest fast FFT length will be use. 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:	self : instance of Raw The raw object with transformed data.

picks : array-like of int (default: None): Indices of channels to apply the function to. If None, all data channels are used.
envelope : bool (default: False): Compute the envelope signal of each channel.
n_jobs: int: Number of jobs to run in parallel.
n_fft : int | None | str: Points to use in the FFT for Hilbert transformation. The signal will be padded with zeros before computing Hilbert, then cut back to original length. If None, n == self.n_times. If ‘auto’, the next highest fast FFT length will be use.
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:

self : instance of Raw: The raw object with transformed data.

Notes

The analytic signal “x_a(t)” of “x(t)” is:

x_a = F^{-1}(F(x) 2U) = x + i y

where “F” is the Fourier transform, “U” the unit step function, and “y” the Hilbert transform of “x”. One usage of the analytic signal is the computation of the envelope signal, which is given by “e(t) = abs(x_a(t))”. Due to the linearity of Hilbert transform and the MNE inverse solution, the enevlope in source space can be obtained by computing the analytic signal in sensor space, applying the MNE inverse, and computing the envelope in source space.

Also note that the n_fft parameter will allow you to pad the signal with zeros before performing the Hilbert transform. This padding is cut off, but it may result in a slightly different result (particularly around the edges). Use at your own risk.

apply_proj()[source]¶

Apply the signal space projection (SSP) operators to the data.

Returns:	self : instance of Raw \| Epochs \| Evoked The instance.

Notes

Once the projectors have been applied, they can no longer be removed. It is usually not recommended to apply the projectors at too early stages, as they are applied automatically later on (e.g. when computing inverse solutions). Hint: using the copy method individual projection vectors can be tested without affecting the original data. With evoked data, consider the following example:

projs_a = mne.read_proj('proj_a.fif')
projs_b = mne.read_proj('proj_b.fif')
# add the first, copy, apply and see ...
evoked.add_proj(a).copy().apply_proj().plot()
# add the second, copy, apply and see ...
evoked.add_proj(b).copy().apply_proj().plot()
# drop the first and see again
evoked.copy().del_proj(0).apply_proj().plot()
evoked.apply_proj()  # finally keep both

ch_names¶: Channel names.

close()[source]¶

Clean up the object.

Does nothing for objects that close their file descriptors. Things like RawFIF will override this method.

compensation_grade¶: The current gradient compensation grade.

copy()[source]¶: Return copy of Raw instance.

crop(tmin=0.0, tmax=None)[source]¶

Crop raw data file.

Limit the data from the raw file to go between specific times. Note that the new tmin is assumed to be t=0 for all subsequently called functions (e.g., time_as_index, or Epochs). New first_samp and last_samp are set accordingly.

Thus function operates in-place on the instance. Use mne.io.Raw.copy() if operation on a copy is desired.

Parameters:	tmin : float New start time in seconds (must be >= 0). tmax : float \| None New end time in seconds of the data (cannot exceed data duration).
Returns:	raw : instance of Raw The cropped raw object, modified in-place.

del_proj(idx='all')[source]¶

Remove SSP projection vector.

Note: The projection vector can only be removed if it is inactive: (has not been applied to the data).

Parameters:	idx : int \| list of int \| str Index of the projector to remove. Can also be “all” (default) to remove all projectors.
Returns:	self : instance of Raw \| Epochs \| Evoked

drop_channels(ch_names)[source]¶

Drop some channels.

Parameters:	ch_names : list List of the names of the channels to remove.
Returns:	inst : instance of Raw, Epochs, or Evoked The modified instance.

Notes

New in version 0.9.0.

estimate_rank(tstart=0.0, tstop=30.0, tol=0.0001, return_singular=False, picks=None, scalings='norm')[source]¶

Estimate rank of the raw data.

This function is meant to provide a reasonable estimate of the rank. The true rank of the data depends on many factors, so use at your own risk.

Parameters:

Parameters:	tstart : float Start time to use for rank estimation. Default is 0.0. tstop : float \| None End time to use for rank estimation. Default is 30.0. If None, the end time of the raw file is used. tol : float Tolerance for singular values to consider non-zero in calculating the rank. The singular values are calculated in this method such that independent data are expected to have singular value around one. return_singular : bool If True, also return the singular values that were used to determine the rank. picks : array_like of int, shape (n_selected_channels,) The channels to be considered for rank estimation. If None (default) meg and eeg channels are included. scalings : dict \| ‘norm’ To achieve reliable rank estimation on multiple sensors, sensors have to be rescaled. This parameter controls the rescaling. If dict, it will update the following dict of defaults: dict(mag=1e11, grad=1e9, eeg=1e5) If ‘norm’ data will be scaled by internally computed channel-wise norms. Defaults to ‘norm’.
Returns:	rank : int Estimated rank of the data. s : array If return_singular is True, the singular values that were thresholded to determine the rank are also returned.

tstart : float

Start time to use for rank estimation. Default is 0.0.

tstop : float | None

End time to use for rank estimation. Default is 30.0. If None, the end time of the raw file is used.

tol : float

Tolerance for singular values to consider non-zero in calculating the rank. The singular values are calculated in this method such that independent data are expected to have singular value around one.

return_singular : bool

If True, also return the singular values that were used to determine the rank.

picks : array_like of int, shape (n_selected_channels,)

The channels to be considered for rank estimation. If None (default) meg and eeg channels are included.

scalings : dict | ‘norm’

To achieve reliable rank estimation on multiple sensors, sensors have to be rescaled. This parameter controls the rescaling. If dict, it will update the following dict of defaults:

dict(mag=1e11, grad=1e9, eeg=1e5)

If ‘norm’ data will be scaled by internally computed channel-wise norms. Defaults to ‘norm’.

Returns:

rank : int: Estimated rank of the data.
s : array: If return_singular is True, the singular values that were thresholded to determine the rank are also returned.

Notes

If data are not pre-loaded, the appropriate data will be loaded by this function (can be memory intensive).

Projectors are not taken into account unless they have been applied to the data using apply_proj(), since it is not always possible to tell whether or not projectors have been applied previously.

Bad channels will be excluded from calculations.

filenames¶: The filenames used.

filter(l_freq, h_freq, picks=None, filter_length='auto', l_trans_bandwidth='auto', h_trans_bandwidth='auto', n_jobs=1, method='fir', iir_params=None, phase='zero', fir_window='hamming', fir_design='firwin', skip_by_annotation=('edge', 'bad_acq_skip'), pad='reflect_limited', verbose=None)[source]¶

Filter a subset of channels.

Applies a zero-phase low-pass, high-pass, band-pass, or band-stop filter to the channels selected by picks. By default the data of the Raw object is modified inplace.

The Raw object has to have the data loaded e.g. with preload=True or self.load_data().

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

self.info['lowpass'] and self.info['highpass'] are only updated with picks=None.

Note

If n_jobs > 1, more memory is required as len(picks) * n_times additional time points need to be temporaily stored in memory.

Parameters:

Parameters:	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. picks : array-like of int \| None Indices of channels to filter. If None only the data (MEG/EEG) channels will be filtered. filter_length : str \| int Length of the FIR filter to use (if applicable): ‘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’ and fir_design=”firwin2”, and half that for “firwin”). 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"`. int: specified length in samples. For fir_design=”firwin”, this should not be used. 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) to use a multiple of `h_freq`: min(max(h_freq * 0.25, 2.), info['sfreq'] / 2. - h_freq) Only used for `method='fir'`. n_jobs : int \| str Number of jobs to run in parallel. Can be ‘cuda’ if scikits.cuda is installed properly, CUDA is initialized, and 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” (default in 0.13), or “blackman”. New in version 0.13. fir_design : str Can be “firwin” (default) to use `scipy.signal.firwin()`, or “firwin2” to use `scipy.signal.firwin2()`. “firwin” uses a time-domain design technique that generally gives improved attenuation using fewer samples than “firwin2”. New in version 0.15. skip_by_annotation : str \| list of str If a string (or list of str), any annotation segment that begins with the given string will not be included in filtering, and segments on either side of the given excluded annotated segment will be filtered separately (i.e., as independent signals). The default (`('edge', 'bad_acq_skip')` will separately filter any segments that were concatenated by `mne.concatenate_raws()` or `mne.io.Raw.append()`, or separated during acquisition. To disable, provide an empty list. New in version 0.16.. pad : str The type of padding to use. Supports all `numpy.pad()` `mode` options. Can also be “reflect_limited” (default), which pads with a reflected version of each vector mirrored on the first and last values of the vector, followed by zeros. Only used for `method='fir'`. New in version 0.15. 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:	raw : instance of Raw The raw instance with filtered data.

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.

picks : array-like of int | None

Indices of channels to filter. If None only the data (MEG/EEG) channels will be filtered.

filter_length : str | int

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

‘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’ and fir_design=”firwin2”, and half that for “firwin”).
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".
int: specified length in samples. For fir_design=”firwin”, this should not be used.

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) to use a multiple of h_freq:

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

Only used for method='fir'.

n_jobs : int | str

Number of jobs to run in parallel. Can be ‘cuda’ if scikits.cuda is installed properly, CUDA is initialized, and 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” (default in 0.13), or “blackman”.

New in version 0.13.

fir_design : str

Can be “firwin” (default) to use scipy.signal.firwin(), or “firwin2” to use scipy.signal.firwin2(). “firwin” uses a time-domain design technique that generally gives improved attenuation using fewer samples than “firwin2”.

New in version 0.15.

skip_by_annotation : str | list of str

If a string (or list of str), any annotation segment that begins with the given string will not be included in filtering, and segments on either side of the given excluded annotated segment will be filtered separately (i.e., as independent signals). The default (('edge', 'bad_acq_skip') will separately filter any segments that were concatenated by mne.concatenate_raws() or mne.io.Raw.append(), or separated during acquisition. To disable, provide an empty list.

New in version 0.16..

pad : str

The type of padding to use. Supports all numpy.pad() mode options. Can also be “reflect_limited” (default), which pads with a reflected version of each vector mirrored on the first and last values of the vector, followed by zeros. Only used for method='fir'.

New in version 0.15.

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:

raw : instance of Raw: The raw instance with filtered data.

Notes

For more information, see the tutorials Background information on filtering and Filtering and resampling data.

first_samp¶: The first data sample.

fix_mag_coil_types()[source]¶

Fix Elekta magnetometer coil types.

Returns:	raw : instance of Raw The raw object. Operates in place.

Notes

This function changes magnetometer coil types 3022 (T1: SQ20483N) and 3023 (T2: SQ20483-A) to 3024 (T3: SQ20950N) in the channel definition records in the info structure.

Neuromag Vectorview systems can contain magnetometers with two different coil sizes (3022 and 3023 vs. 3024). The systems incorporating coils of type 3024 were introduced last and are used at the majority of MEG sites. At some sites with 3024 magnetometers, the data files have still defined the magnetometers to be of type 3022 to ensure compatibility with older versions of Neuromag software. In the MNE software as well as in the present version of Neuromag software coil type 3024 is fully supported. Therefore, it is now safe to upgrade the data files to use the true coil type.

Note

The effect of the difference between the coil sizes on the current estimates computed by the MNE software is very small. Therefore the use of mne_fix_mag_coil_types is not mandatory.

get_data(picks=None, start=0, stop=None, reject_by_annotation=None, return_times=False)[source]¶

Get data in the given range.

Parameters:

Parameters:	picks : array-like of int \| None Indices of channels to get data from. If None, data from all channels is returned start : int The first sample to include. Defaults to 0. stop : int \| None End sample (first not to include). If None (default), the end of the data is used. reject_by_annotation : None \| ‘omit’ \| ‘NaN’ Whether to reject by annotation. If None (default), no rejection is done. If ‘omit’, segments annotated with description starting with ‘bad’ are omitted. If ‘NaN’, the bad samples are filled with NaNs. return_times : bool Whether to return times as well. Defaults to False.
Returns:	data : ndarray, shape (n_channels, n_times) Copy of the data in the given range. times : ndarray, shape (n_times,) Times associated with the data samples. Only returned if return_times=True.

picks : array-like of int | None: Indices of channels to get data from. If None, data from all channels is returned
start : int: The first sample to include. Defaults to 0.
stop : int | None: End sample (first not to include). If None (default), the end of the data is used.
reject_by_annotation : None | ‘omit’ | ‘NaN’: Whether to reject by annotation. If None (default), no rejection is done. If ‘omit’, segments annotated with description starting with ‘bad’ are omitted. If ‘NaN’, the bad samples are filled with NaNs.
return_times : bool: Whether to return times as well. Defaults to False.

Returns:

data : ndarray, shape (n_channels, n_times): Copy of the data in the given range.
times : ndarray, shape (n_times,): Times associated with the data samples. Only returned if return_times=True.

Notes

New in version 0.14.0.

interpolate_bads(reset_bads=True, mode='accurate', verbose=None)[source]¶

Interpolate bad MEG and EEG channels.

Operates in place.

Parameters:	reset_bads : bool If True, remove the bads from info. mode : str Either `'accurate'` or `'fast'`, determines the quality of the Legendre polynomial expansion used for interpolation of MEG channels. verbose : bool, str, int, or None If not None, override default verbose level (see `mne.verbose()` and Logging documentation for more).
Returns:	inst : instance of Raw, Epochs, or Evoked The modified instance.

Notes

New in version 0.9.0.

last_samp¶: The last data sample.

load_bad_channels(bad_file=None, force=False)[source]¶

Mark channels as bad from a text file.

This function operates mostly in the style of the C function mne_mark_bad_channels.

Parameters:	bad_file : string File name of the text file containing bad channels If bad_file = None, bad channels are cleared, but this is more easily done directly as raw.info[‘bads’] = []. force : boolean Whether or not to force bad channel marking (of those that exist) if channels are not found, instead of raising an error.

load_data(verbose=None)[source]¶

Load raw data.

Parameters:	verbose : bool, str, int, or None If not None, override default verbose level (see `mne.verbose()` and Logging documentation for more).
Returns:	raw : instance of Raw The raw object with data.

Notes

This function will load raw data if it was not already preloaded. If data were already preloaded, it will do nothing.

New in version 0.10.0.

n_times¶: Number of time points.

notch_filter(freqs, picks=None, filter_length='auto', notch_widths=None, trans_bandwidth=1.0, n_jobs=1, method='fft', iir_params=None, mt_bandwidth=None, p_value=0.05, phase='zero', fir_window='hamming', fir_design='firwin', pad='reflect_limited', verbose=None)[source]¶

Notch filter a subset of channels.

Applies a zero-phase notch filter to the channels selected by “picks”. By default the data of the Raw object is modified inplace.

The Raw object has to have the data loaded e.g. with preload=True or self.load_data().

Note

If n_jobs > 1, more memory is required as len(picks) * n_times additional time points need to be temporaily stored in memory.

Parameters:

Parameters:	freqs : float \| array of float \| None Specific frequencies to filter out from data, e.g., np.arange(60, 241, 60) in the US or np.arange(50, 251, 50) in Europe. None can only be used with the mode ‘spectrum_fit’, where an F test is used to find sinusoidal components. picks : array-like of int \| None Indices of channels to filter. If None only the data (MEG/EEG) channels will be filtered. 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"`. notch_widths : float \| array of float \| None Width of each stop band (centred at each freq in freqs) in Hz. If None, freqs / 200 is used. trans_bandwidth : float Width of the transition band in Hz. Only used for `method='fir'`. n_jobs : int \| str Number of jobs to run in parallel. Can be ‘cuda’ if scikits.cuda is installed properly, CUDA is initialized, and method=’fir’. method : str ‘fir’ will use overlap-add FIR filtering, ‘iir’ will use IIR forward-backward filtering (via filtfilt). ‘spectrum_fit’ will use multi-taper estimation of sinusoidal components. 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. mt_bandwidth : float \| None The bandwidth of the multitaper windowing function in Hz. Only used in ‘spectrum_fit’ mode. p_value : float p-value to use in F-test thresholding to determine significant sinusoidal components to remove when method=’spectrum_fit’ and freqs=None. Note that this will be Bonferroni corrected for the number of frequencies, so large p-values may be justified. 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. fir_design : str Can be “firwin” (default) to use `scipy.signal.firwin()`, or “firwin2” to use `scipy.signal.firwin2()`. “firwin” uses a time-domain design technique that generally gives improved attenuation using fewer samples than “firwin2”. ..versionadded:: 0.15 pad : str The type of padding to use. Supports all `numpy.pad()` `mode` options. Can also be “reflect_limited” (default), which pads with a reflected version of each vector mirrored on the first and last values of the vector, followed by zeros. Only used for `method='fir'`. New in version 0.15. 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:	raw : instance of Raw The raw instance with filtered data.

freqs : float | array of float | None

Specific frequencies to filter out from data, e.g., np.arange(60, 241, 60) in the US or np.arange(50, 251, 50) in Europe. None can only be used with the mode ‘spectrum_fit’, where an F test is used to find sinusoidal components.

picks : array-like of int | None

Indices of channels to filter. If None only the data (MEG/EEG) channels will be filtered.

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

notch_widths : float | array of float | None

Width of each stop band (centred at each freq in freqs) in Hz. If None, freqs / 200 is used.

trans_bandwidth : float

Width of the transition band in Hz. Only used for method='fir'.

n_jobs : int | str

Number of jobs to run in parallel. Can be ‘cuda’ if scikits.cuda is installed properly, CUDA is initialized, and method=’fir’.

method : str

‘fir’ will use overlap-add FIR filtering, ‘iir’ will use IIR forward-backward filtering (via filtfilt). ‘spectrum_fit’ will use multi-taper estimation of sinusoidal components.

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.

mt_bandwidth : float | None

The bandwidth of the multitaper windowing function in Hz. Only used in ‘spectrum_fit’ mode.

p_value : float

p-value to use in F-test thresholding to determine significant sinusoidal components to remove when method=’spectrum_fit’ and freqs=None. Note that this will be Bonferroni corrected for the number of frequencies, so large p-values may be justified.

phase : str

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.

fir_design : str

..versionadded:: 0.15

pad : str

New in version 0.15.

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:

raw : instance of Raw: The raw instance with filtered data.

See also

mne.io.Raw.filter

Notes

For details, see mne.filter.notch_filter().

pick_channels(ch_names)[source]¶

Pick some channels.

Parameters:	ch_names : list The list of channels to select.
Returns:	inst : instance of Raw, Epochs, or Evoked The modified instance.

Notes

The channel names given are assumed to be a set, i.e. the order does not matter. The original order of the channels is preserved. You can use reorder_channels to set channel order if necessary.

New in version 0.9.0.

pick_types(meg=True, eeg=False, stim=False, eog=False, ecg=False, emg=False, ref_meg='auto', misc=False, resp=False, chpi=False, exci=False, ias=False, syst=False, seeg=False, dipole=False, gof=False, bio=False, ecog=False, fnirs=False, include=(), exclude='bads', selection=None, verbose=None)[source]¶

Pick some channels by type and names.

Parameters:

Parameters:	meg : bool \| str If True include all MEG channels. If False include None If string it can be ‘mag’, ‘grad’, ‘planar1’ or ‘planar2’ to select only magnetometers, all gradiometers, or a specific type of gradiometer. eeg : bool If True include EEG channels. stim : bool If True include stimulus channels. eog : bool If True include EOG channels. ecg : bool If True include ECG channels. emg : bool If True include EMG channels. ref_meg: bool \| str If True include CTF / 4D reference channels. If ‘auto’, the reference channels are only included if compensations are present. misc : bool If True include miscellaneous analog channels. resp : bool If True include response-trigger channel. For some MEG systems this is separate from the stim channel. chpi : bool If True include continuous HPI coil channels. exci : bool Flux excitation channel used to be a stimulus channel. ias : bool Internal Active Shielding data (maybe on Triux only). syst : bool System status channel information (on Triux systems only). seeg : bool Stereotactic EEG channels. dipole : bool Dipole time course channels. gof : bool Dipole goodness of fit channels. bio : bool Bio channels. ecog : bool Electrocorticography channels. fnirs : bool \| str Functional near-infrared spectroscopy channels. If True include all fNIRS channels. If False (default) include none. If string it can be ‘hbo’ (to include channels measuring oxyhemoglobin) or ‘hbr’ (to include channels measuring deoxyhemoglobin). include : list of string List of additional channels to include. If empty do not include any. exclude : list of string \| str List of channels to exclude. If ‘bads’ (default), exclude channels in `info['bads']`. selection : list of string Restrict sensor channels (MEG, EEG) to this list of channel names. verbose : bool, str, int, or None If not None, override default verbose level (see `mne.verbose()` and Logging documentation for more).
Returns:	inst : instance of Raw, Epochs, or Evoked The modified instance.

meg : bool | str: If True include all MEG channels. If False include None If string it can be ‘mag’, ‘grad’, ‘planar1’ or ‘planar2’ to select only magnetometers, all gradiometers, or a specific type of gradiometer.
eeg : bool: If True include EEG channels.
stim : bool: If True include stimulus channels.
eog : bool: If True include EOG channels.
ecg : bool: If True include ECG channels.
emg : bool: If True include EMG channels.
ref_meg: bool | str: If True include CTF / 4D reference channels. If ‘auto’, the reference channels are only included if compensations are present.
misc : bool: If True include miscellaneous analog channels.
resp : bool: If True include response-trigger channel. For some MEG systems this is separate from the stim channel.
chpi : bool: If True include continuous HPI coil channels.
exci : bool: Flux excitation channel used to be a stimulus channel.
ias : bool: Internal Active Shielding data (maybe on Triux only).
syst : bool: System status channel information (on Triux systems only).
seeg : bool: Stereotactic EEG channels.
dipole : bool: Dipole time course channels.
gof : bool: Dipole goodness of fit channels.
bio : bool: Bio channels.
ecog : bool: Electrocorticography channels.
fnirs : bool | str: Functional near-infrared spectroscopy channels. If True include all fNIRS channels. If False (default) include none. If string it can be ‘hbo’ (to include channels measuring oxyhemoglobin) or ‘hbr’ (to include channels measuring deoxyhemoglobin).
include : list of string: List of additional channels to include. If empty do not include any.
exclude : list of string | str: List of channels to exclude. If ‘bads’ (default), exclude channels in info['bads'].
selection : list of string: Restrict sensor channels (MEG, EEG) to this list of channel names.
verbose : bool, str, int, or None: If not None, override default verbose level (see mne.verbose() and Logging documentation for more).

Returns:

inst : instance of Raw, Epochs, or Evoked: The modified instance.

See also

pick_channels

Notes

New in version 0.9.0.

plot(events=None, duration=10.0, start=0.0, n_channels=20, bgcolor='w', color=None, bad_color=(0.8, 0.8, 0.8), event_color='cyan', scalings=None, remove_dc=True, order=None, show_options=False, title=None, show=True, block=False, highpass=None, lowpass=None, filtorder=4, clipping=None, show_first_samp=False, proj=True, group_by='type', butterfly=False, decim='auto', noise_cov=None, event_id=None)[source]¶

Plot raw data.

Parameters:

Parameters:	events : array \| None Events to show with vertical bars. duration : float Time window (s) to plot. The lesser of this value and the duration of the raw file will be used. start : float Initial time to show (can be changed dynamically once plotted). If show_first_samp is True, then it is taken relative to `raw.first_samp`. n_channels : int Number of channels to plot at once. Defaults to 20. Has no effect if `order` is ‘position’, ‘selection’ or ‘butterfly’. bgcolor : color object Color of the background. color : dict \| color object \| None Color for the data traces. If None, defaults to: dict(mag='darkblue', grad='b', eeg='k', eog='k', ecg='m', emg='k', ref_meg='steelblue', misc='k', stim='k', resp='k', chpi='k') bad_color : color object Color to make bad channels. event_color : color object \| dict Color to use for events. Can also be a dict with `{event_number: color}` pairings. Use `event_number==-1` for any event numbers in the events list that are not in the dictionary. scalings : dict \| None Scaling factors for the traces. If any fields in scalings are ‘auto’, the scaling factor is set to match the 99.5th percentile of a subset of the corresponding data. If scalings == ‘auto’, all scalings fields are set to ‘auto’. If any fields are ‘auto’ and data is not preloaded, a subset of times up to 100mb will be loaded. If None, defaults to: dict(mag=1e-12, grad=4e-11, eeg=20e-6, eog=150e-6, ecg=5e-4, emg=1e-3, ref_meg=1e-12, misc=1e-3, stim=1, resp=1, chpi=1e-4, whitened=1e2) remove_dc : bool If True remove DC component when plotting data. order : array of int \| None Order in which to plot data. If the array is shorter than the number of channels, only the given channels are plotted. If None (default), all channels are plotted. If `group_by` is `'position'` or `'selection'`, the `order` parameter is used only for selecting the channels to be plotted. show_options : bool If True, a dialog for options related to projection is shown. title : str \| None The title of the window. If None, and either the filename of the raw object or ‘<unknown>’ will be displayed as title. show : bool Show figure if True. block : bool Whether to halt program execution until the figure is closed. Useful for setting bad channels on the fly by clicking on a line. May not work on all systems / platforms. highpass : float \| None Highpass to apply when displaying data. lowpass : float \| None Lowpass to apply when displaying data. filtorder : int Filtering order. Note that for efficiency and simplicity, filtering during plotting uses forward-backward IIR filtering, so the effective filter order will be twice `filtorder`. Filtering the lines for display may also produce some edge artifacts (at the left and right edges) of the signals during display. Filtering requires scipy >= 0.10. clipping : str \| None If None, channels are allowed to exceed their designated bounds in the plot. If “clamp”, then values are clamped to the appropriate range for display, creating step-like artifacts. If “transparent”, then excessive values are not shown, creating gaps in the traces. show_first_samp : bool If True, show time axis relative to the `raw.first_samp`. proj : bool Whether to apply projectors prior to plotting (default is `True`). Individual projectors can be enabled/disabled interactively (see Notes). This argument only affects the plot; use `raw.apply_proj()` to modify the data stored in the Raw object. group_by : str How to group channels. `'type'` groups by channel type, `'original'` plots in the order of ch_names, `'selection'` uses Elekta’s channel groupings (only works for Neuromag data), `'position'` groups the channels by the positions of the sensors. `'selection'` and `'position'` modes allow custom selections by using lasso selector on the topomap. Pressing `ctrl` key while selecting allows appending to the current selection. Channels marked as bad appear with red edges on the topomap. `'type'` and `'original'` groups the channels by type in butterfly mode whereas `'selection'` and `'position'` use regional grouping. `'type'` and `'original'` modes are overrided with `order` keyword. butterfly : bool Whether to start in butterfly mode. Defaults to False. decim : int \| ‘auto’ Amount to decimate the data during display for speed purposes. You should only decimate if the data are sufficiently low-passed, otherwise aliasing can occur. The ‘auto’ mode (default) uses the decimation that results in a sampling rate least three times larger than `min(info['lowpass'], lowpass)` (e.g., a 40 Hz lowpass will result in at least a 120 Hz displayed sample rate). noise_cov : instance of Covariance \| str \| None Noise covariance used to whiten the data while plotting. Whitened data channels are scaled by `scalings['whitened']`, and their channel names are shown in italic. Can be a string to load a covariance from disk. See also `mne.Evoked.plot_white()` for additional inspection of noise covariance properties when whitening evoked data. For data processed with SSS, the effective dependence between magnetometers and gradiometers may introduce differences in scaling, consider using `mne.Evoked.plot_white()`. New in version 0.16.0. event_id : dict \| None Event IDs used to show at event markers (default None shows theh event numbers). New in version 0.16.0.
Returns:	fig : Instance of matplotlib.figure.Figure Raw traces.

events : array | None

Events to show with vertical bars.

duration : float

Time window (s) to plot. The lesser of this value and the duration of the raw file will be used.

start : float

Initial time to show (can be changed dynamically once plotted). If show_first_samp is True, then it is taken relative to raw.first_samp.

n_channels : int

Number of channels to plot at once. Defaults to 20. Has no effect if order is ‘position’, ‘selection’ or ‘butterfly’.

bgcolor : color object

Color of the background.

color : dict | color object | None

Color for the data traces. If None, defaults to:

dict(mag='darkblue', grad='b', eeg='k', eog='k', ecg='m',
     emg='k', ref_meg='steelblue', misc='k', stim='k',
     resp='k', chpi='k')

bad_color : color object

Color to make bad channels.

event_color : color object | dict

Color to use for events. Can also be a dict with {event_number: color} pairings. Use event_number==-1 for any event numbers in the events list that are not in the dictionary.

scalings : dict | None

Scaling factors for the traces. If any fields in scalings are ‘auto’, the scaling factor is set to match the 99.5th percentile of a subset of the corresponding data. If scalings == ‘auto’, all scalings fields are set to ‘auto’. If any fields are ‘auto’ and data is not preloaded, a subset of times up to 100mb will be loaded. If None, defaults to:

dict(mag=1e-12, grad=4e-11, eeg=20e-6, eog=150e-6, ecg=5e-4,
     emg=1e-3, ref_meg=1e-12, misc=1e-3, stim=1,
     resp=1, chpi=1e-4, whitened=1e2)

remove_dc : bool

If True remove DC component when plotting data.

order : array of int | None

Order in which to plot data. If the array is shorter than the number of channels, only the given channels are plotted. If None (default), all channels are plotted. If group_by is 'position' or 'selection', the order parameter is used only for selecting the channels to be plotted.

show_options : bool

If True, a dialog for options related to projection is shown.

title : str | None

The title of the window. If None, and either the filename of the raw object or ‘<unknown>’ will be displayed as title.

show : bool

Show figure if True.

block : bool

Whether to halt program execution until the figure is closed. Useful for setting bad channels on the fly by clicking on a line. May not work on all systems / platforms.

highpass : float | None

Highpass to apply when displaying data.

lowpass : float | None

Lowpass to apply when displaying data.

filtorder : int

Filtering order. Note that for efficiency and simplicity, filtering during plotting uses forward-backward IIR filtering, so the effective filter order will be twice filtorder. Filtering the lines for display may also produce some edge artifacts (at the left and right edges) of the signals during display. Filtering requires scipy >= 0.10.

clipping : str | None

If None, channels are allowed to exceed their designated bounds in the plot. If “clamp”, then values are clamped to the appropriate range for display, creating step-like artifacts. If “transparent”, then excessive values are not shown, creating gaps in the traces.

show_first_samp : bool

If True, show time axis relative to the raw.first_samp.

proj : bool

Whether to apply projectors prior to plotting (default is True). Individual projectors can be enabled/disabled interactively (see Notes). This argument only affects the plot; use raw.apply_proj() to modify the data stored in the Raw object.

group_by : str

How to group channels. 'type' groups by channel type, 'original' plots in the order of ch_names, 'selection' uses Elekta’s channel groupings (only works for Neuromag data), 'position' groups the channels by the positions of the sensors. 'selection' and 'position' modes allow custom selections by using lasso selector on the topomap. Pressing ctrl key while selecting allows appending to the current selection. Channels marked as bad appear with red edges on the topomap. 'type' and 'original' groups the channels by type in butterfly mode whereas 'selection' and 'position' use regional grouping. 'type' and 'original' modes are overrided with order keyword.

butterfly : bool

Whether to start in butterfly mode. Defaults to False.

decim : int | ‘auto’

Amount to decimate the data during display for speed purposes. You should only decimate if the data are sufficiently low-passed, otherwise aliasing can occur. The ‘auto’ mode (default) uses the decimation that results in a sampling rate least three times larger than min(info['lowpass'], lowpass) (e.g., a 40 Hz lowpass will result in at least a 120 Hz displayed sample rate).

noise_cov : instance of Covariance | str | None

Noise covariance used to whiten the data while plotting. Whitened data channels are scaled by scalings['whitened'], and their channel names are shown in italic. Can be a string to load a covariance from disk. See also mne.Evoked.plot_white() for additional inspection of noise covariance properties when whitening evoked data. For data processed with SSS, the effective dependence between magnetometers and gradiometers may introduce differences in scaling, consider using mne.Evoked.plot_white().

New in version 0.16.0.

event_id : dict | None

Event IDs used to show at event markers (default None shows theh event numbers).

New in version 0.16.0.

Returns:

fig : Instance of matplotlib.figure.Figure: Raw traces.

Notes

The arrow keys (up/down/left/right) can typically be used to navigate between channels and time ranges, but this depends on the backend matplotlib is configured to use (e.g., mpl.use(‘TkAgg’) should work). The left/right arrows will scroll by 25% of duration, whereas shift+left/shift+right will scroll by 100% of duration. The scaling can be adjusted with - and + (or =) keys. The viewport dimensions can be adjusted with page up/page down and home/end keys. Full screen mode can be toggled with the F11 key. To mark or un-mark a channel as bad, click on a channel label or a channel trace. The changes will be reflected immediately in the raw object’s raw.info['bads'] entry.

If projectors are present, a button labelled “Proj” in the lower right corner of the plot window opens a secondary control window, which allows enabling/disabling specific projectors individually. This provides a means of interactively observing how each projector would affect the raw data if it were applied.

Annotation mode is toggled by pressing ‘a’, butterfly mode by pressing ‘b’, and whitening mode (when noise_cov is not None) by pressing ‘w’.

plot_projs_topomap(ch_type=None, layout=None, axes=None)[source]¶

Plot SSP vector.

Parameters:

Parameters:	ch_type : ‘mag’ \| ‘grad’ \| ‘planar1’ \| ‘planar2’ \| ‘eeg’ \| None \| List The channel type to plot. For ‘grad’, the gradiometers are collec- ted in pairs and the RMS for each pair is plotted. If None (default), it will return all channel types present. If a list of ch_types is provided, it will return multiple figures. layout : None \| Layout \| List of Layouts Layout instance specifying sensor positions (does not need to be specified for Neuromag data). If possible, the correct layout file is inferred from the data; if no appropriate layout file was found, the layout is automatically generated from the sensor locations. Or a list of Layout if projections are from different sensor types. axes : instance of Axes \| list \| None The axes to plot to. If list, the list must be a list of Axes of the same length as the number of projectors. If instance of Axes, there must be only one projector. Defaults to None.
Returns:	fig : instance of matplotlib figure Figure distributing one image per channel across sensor topography.

ch_type : ‘mag’ | ‘grad’ | ‘planar1’ | ‘planar2’ | ‘eeg’ | None | List: The channel type to plot. For ‘grad’, the gradiometers are collec- ted in pairs and the RMS for each pair is plotted. If None (default), it will return all channel types present. If a list of ch_types is provided, it will return multiple figures.
layout : None | Layout | List of Layouts: Layout instance specifying sensor positions (does not need to be specified for Neuromag data). If possible, the correct layout file is inferred from the data; if no appropriate layout file was found, the layout is automatically generated from the sensor locations. Or a list of Layout if projections are from different sensor types.
axes : instance of Axes | list | None: The axes to plot to. If list, the list must be a list of Axes of the same length as the number of projectors. If instance of Axes, there must be only one projector. Defaults to None.

Returns:

fig : instance of matplotlib figure: Figure distributing one image per channel across sensor topography.

plot_psd(tmin=0.0, tmax=inf, fmin=0, fmax=inf, proj=False, n_fft=None, picks=None, ax=None, color='black', area_mode='std', area_alpha=0.33, n_overlap=0, dB=True, estimate='auto', average=None, show=True, n_jobs=1, line_alpha=None, spatial_colors=None, xscale='linear', reject_by_annotation=True, verbose=None)[source]¶

Plot the power spectral density across channels.

Different channel types are drawn in sub-plots. When the data has been processed with a bandpass, lowpass or highpass filter, dashed lines indicate the boundaries of the filter (–). The line noise frequency is also indicated with a dashed line (-.).

Parameters:

Parameters:	tmin : float Start time for calculations. tmax : float End time for calculations. fmin : float Start frequency to consider. fmax : float End frequency to consider. proj : bool Apply projection. n_fft : int \| None Number of points to use in Welch FFT calculations. Default is None, which uses the minimum of 2048 and the number of time points. picks : array-like of int \| None List of channels to use. Cannot be None if ax is supplied. If both picks and ax are None, separate subplots will be created for each standard channel type (mag, grad, and eeg). ax : instance of matplotlib Axes \| None Axes to plot into. If None, axes will be created. color : str \| tuple A matplotlib-compatible color to use. Has no effect when spatial_colors=True. area_mode : str \| None Mode for plotting area. If ‘std’, the mean +/- 1 STD (across channels) will be plotted. If ‘range’, the min and max (across channels) will be plotted. Bad channels will be excluded from these calculations. If None, no area will be plotted. If average=False, no area is plotted. area_alpha : float Alpha for the area. n_overlap : int The number of points of overlap between blocks. The default value is 0 (no overlap). dB : bool Plot Power Spectral Density (PSD), in units (amplitude2/Hz (dB)) if `dB=True`, and `estimate='power'` or `estimate='auto'`. Plot PSD in units (amplitude2/Hz) if `dB=False` and, `estimate='power'`. Plot Amplitude Spectral Density (ASD), in units (amplitude/sqrt(Hz)), if `dB=False` and `estimate='amplitude'` or `estimate='auto'`. Plot ASD, in units (amplitude/sqrt(Hz) (db)), if `dB=True` and `estimate='amplitude'`. estimate : str, {‘auto’, ‘power’, ‘amplitude’} Can be “power” for power spectral density (PSD), “amplitude” for amplitude spectrum density (ASD), or “auto” (default), which uses “power” when dB is True and “amplitude” otherwise. average : bool If False (default), the PSDs of all channels is displayed. No averaging is done and parameters area_mode and area_alpha are ignored. When False, it is possible to paint an area (hold left mouse button and drag) to plot a topomap. show : bool Show figure if True. n_jobs : int Number of jobs to run in parallel. line_alpha : float \| None Alpha for the PSD line. Can be None (default) to use 1.0 when `average=True` and 0.1 when `average=False`. spatial_colors : bool Whether to use spatial colors. Only used when `average=False`. xscale : str Can be ‘linear’ (default) or ‘log’. reject_by_annotation : bool Whether to omit bad segments from the data while computing the PSD. If True, annotated segments with a description that starts with ‘bad’ are omitted. Has no effect if `inst` is an Epochs or Evoked object. Defaults to True. New in version 0.15.0. verbose : bool, str, int, or None If not None, override default verbose level (see `mne.verbose()` and Logging documentation for more).
Returns:	fig : instance of matplotlib figure Figure with frequency spectra of the data channels.

tmin : float: Start time for calculations.
tmax : float: End time for calculations.
fmin : float: Start frequency to consider.
fmax : float: End frequency to consider.
proj : bool: Apply projection.
n_fft : int | None: Number of points to use in Welch FFT calculations. Default is None, which uses the minimum of 2048 and the number of time points.
picks : array-like of int | None: List of channels to use. Cannot be None if ax is supplied. If both picks and ax are None, separate subplots will be created for each standard channel type (mag, grad, and eeg).
ax : instance of matplotlib Axes | None: Axes to plot into. If None, axes will be created.
color : str | tuple: A matplotlib-compatible color to use. Has no effect when spatial_colors=True.
area_mode : str | None: Mode for plotting area. If ‘std’, the mean +/- 1 STD (across channels) will be plotted. If ‘range’, the min and max (across channels) will be plotted. Bad channels will be excluded from these calculations. If None, no area will be plotted. If average=False, no area is plotted.
area_alpha : float: Alpha for the area.
n_overlap : int: The number of points of overlap between blocks. The default value is 0 (no overlap).
dB : bool: Plot Power Spectral Density (PSD), in units (amplitude**2/Hz (dB)) if dB=True, and estimate='power' or estimate='auto'. Plot PSD in units (amplitude**2/Hz) if dB=False and, estimate='power'. Plot Amplitude Spectral Density (ASD), in units (amplitude/sqrt(Hz)), if dB=False and estimate='amplitude' or estimate='auto'. Plot ASD, in units (amplitude/sqrt(Hz) (db)), if dB=True and estimate='amplitude'.
estimate : str, {‘auto’, ‘power’, ‘amplitude’}: Can be “power” for power spectral density (PSD), “amplitude” for amplitude spectrum density (ASD), or “auto” (default), which uses “power” when dB is True and “amplitude” otherwise.
average : bool: If False (default), the PSDs of all channels is displayed. No averaging is done and parameters area_mode and area_alpha are ignored. When False, it is possible to paint an area (hold left mouse button and drag) to plot a topomap.
show : bool: Show figure if True.
n_jobs : int: Number of jobs to run in parallel.
line_alpha : float | None: Alpha for the PSD line. Can be None (default) to use 1.0 when average=True and 0.1 when average=False.
spatial_colors : bool: Whether to use spatial colors. Only used when average=False.
xscale : str: Can be ‘linear’ (default) or ‘log’.
reject_by_annotation : bool: Whether to omit bad segments from the data while computing the PSD. If True, annotated segments with a description that starts with ‘bad’ are omitted. Has no effect if inst is an Epochs or Evoked object. Defaults to True.

New in version 0.15.0.
verbose : bool, str, int, or None: If not None, override default verbose level (see mne.verbose() and Logging documentation for more).

Returns:

fig : instance of matplotlib figure: Figure with frequency spectra of the data channels.

plot_psd_topo(tmin=0.0, tmax=None, fmin=0, fmax=100, proj=False, n_fft=2048, n_overlap=0, layout=None, color='w', fig_facecolor='k', axis_facecolor='k', dB=True, show=True, block=False, n_jobs=1, axes=None, verbose=None)[source]¶

Plot channel-wise frequency spectra as topography.

Parameters:

Parameters:	tmin : float Start time for calculations. Defaults to zero. tmax : float \| None End time for calculations. If None (default), the end of data is used. fmin : float Start frequency to consider. Defaults to zero. fmax : float End frequency to consider. Defaults to 100. proj : bool Apply projection. Defaults to False. n_fft : int Number of points to use in Welch FFT calculations. Defaults to 2048. n_overlap : int The number of points of overlap between blocks. Defaults to 0 (no overlap). layout : instance of Layout \| None Layout instance specifying sensor positions (does not need to be specified for Neuromag data). If None (default), the correct layout is inferred from the data. color : str \| tuple A matplotlib-compatible color to use for the curves. Defaults to white. fig_facecolor : str \| tuple A matplotlib-compatible color to use for the figure background. Defaults to black. axis_facecolor : str \| tuple A matplotlib-compatible color to use for the axis background. Defaults to black. dB : bool If True, transform data to decibels. Defaults to True. show : bool Show figure if True. Defaults to True. block : bool Whether to halt program execution until the figure is closed. May not work on all systems / platforms. Defaults to False. n_jobs : int Number of jobs to run in parallel. Defaults to 1. axes : instance of matplotlib Axes \| None Axes to plot into. If None, axes will be created. verbose : bool, str, int, or None If not None, override default verbose level (see `mne.verbose()` and Logging documentation for more).
Returns:	fig : instance of matplotlib figure Figure distributing one image per channel across sensor topography.

tmin : float: Start time for calculations. Defaults to zero.
tmax : float | None: End time for calculations. If None (default), the end of data is used.
fmin : float: Start frequency to consider. Defaults to zero.
fmax : float: End frequency to consider. Defaults to 100.
proj : bool: Apply projection. Defaults to False.
n_fft : int: Number of points to use in Welch FFT calculations. Defaults to 2048.
n_overlap : int: The number of points of overlap between blocks. Defaults to 0 (no overlap).
layout : instance of Layout | None: Layout instance specifying sensor positions (does not need to be specified for Neuromag data). If None (default), the correct layout is inferred from the data.
color : str | tuple: A matplotlib-compatible color to use for the curves. Defaults to white.
fig_facecolor : str | tuple: A matplotlib-compatible color to use for the figure background. Defaults to black.
axis_facecolor : str | tuple: A matplotlib-compatible color to use for the axis background. Defaults to black.
dB : bool: If True, transform data to decibels. Defaults to True.
show : bool: Show figure if True. Defaults to True.
block : bool: Whether to halt program execution until the figure is closed. May not work on all systems / platforms. Defaults to False.
n_jobs : int: Number of jobs to run in parallel. Defaults to 1.
axes : instance of matplotlib Axes | None: Axes to plot into. If None, axes will be created.
verbose : bool, str, int, or None: If not None, override default verbose level (see mne.verbose() and Logging documentation for more).

Returns:

fig : instance of matplotlib figure: Figure distributing one image per channel across sensor topography.

plot_sensors(kind='topomap', ch_type=None, title=None, show_names=False, ch_groups=None, to_sphere=True, axes=None, block=False, show=True)[source]¶

Plot sensor positions.

Parameters:

Parameters:	kind : str Whether to plot the sensors as 3d, topomap or as an interactive sensor selection dialog. Available options ‘topomap’, ‘3d’, ‘select’. If ‘select’, a set of channels can be selected interactively by using lasso selector or clicking while holding control key. The selected channels are returned along with the figure instance. Defaults to ‘topomap’. ch_type : None \| str The channel type to plot. Available options ‘mag’, ‘grad’, ‘eeg’, ‘seeg’, ‘ecog’, ‘all’. If `'all'`, all the available mag, grad, eeg, seeg and ecog channels are plotted. If None (default), then channels are chosen in the order given above. title : str \| None Title for the figure. If None (default), equals to `'Sensor positions (%s)' % ch_type`. show_names : bool \| array of str Whether to display all channel names. If an array, only the channel names in the array are shown. Defaults to False. ch_groups : ‘position’ \| array of shape (ch_groups, picks) \| None Channel groups for coloring the sensors. If None (default), default coloring scheme is used. If ‘position’, the sensors are divided into 8 regions. See `order` kwarg of `mne.viz.plot_raw()`. If array, the channels are divided by picks given in the array. New in version 0.13.0. to_sphere : bool Whether to project the 3d locations to a sphere. When False, the sensor array appears similar as to looking downwards straight above the subject’s head. Has no effect when kind=‘3d’. Defaults to True. New in version 0.14.0. axes : instance of Axes \| instance of Axes3D \| None Axes to draw the sensors to. If `kind='3d'`, axes must be an instance of Axes3D. If None (default), a new axes will be created. New in version 0.13.0. block : bool Whether to halt program execution until the figure is closed. Defaults to False. New in version 0.13.0. show : bool Show figure if True. Defaults to True.
Returns:	fig : instance of matplotlib figure Figure containing the sensor topography. selection : list A list of selected channels. Only returned if `kind=='select'`.

kind : str: Whether to plot the sensors as 3d, topomap or as an interactive sensor selection dialog. Available options ‘topomap’, ‘3d’, ‘select’. If ‘select’, a set of channels can be selected interactively by using lasso selector or clicking while holding control key. The selected channels are returned along with the figure instance. Defaults to ‘topomap’.
ch_type : None | str: The channel type to plot. Available options ‘mag’, ‘grad’, ‘eeg’, ‘seeg’, ‘ecog’, ‘all’. If 'all', all the available mag, grad, eeg, seeg and ecog channels are plotted. If None (default), then channels are chosen in the order given above.
title : str | None: Title for the figure. If None (default), equals to 'Sensor positions (%s)' % ch_type.
show_names : bool | array of str: Whether to display all channel names. If an array, only the channel names in the array are shown. Defaults to False.
ch_groups : ‘position’ | array of shape (ch_groups, picks) | None: Channel groups for coloring the sensors. If None (default), default coloring scheme is used. If ‘position’, the sensors are divided into 8 regions. See order kwarg of mne.viz.plot_raw(). If array, the channels are divided by picks given in the array.

New in version 0.13.0.
to_sphere : bool: Whether to project the 3d locations to a sphere. When False, the sensor array appears similar as to looking downwards straight above the subject’s head. Has no effect when kind=‘3d’. Defaults to True.

New in version 0.14.0.
axes : instance of Axes | instance of Axes3D | None: Axes to draw the sensors to. If kind='3d', axes must be an instance of Axes3D. If None (default), a new axes will be created.

New in version 0.13.0.
block : bool: Whether to halt program execution until the figure is closed. Defaults to False.

New in version 0.13.0.
show : bool: Show figure if True. Defaults to True.

Returns:

fig : instance of matplotlib figure: Figure containing the sensor topography.
selection : list: A list of selected channels. Only returned if kind=='select'.

See also

mne.viz.plot_layout

Notes

This function plots the sensor locations from the info structure using matplotlib. For drawing the sensors using mayavi see mne.viz.plot_alignment().

New in version 0.12.0.

proj¶: Whether or not projections are active.

rename_channels(mapping)[source]¶

Rename channels.

Parameters:	mapping : dict \| callable a dictionary mapping the old channel to a new channel name e.g. {‘EEG061’ : ‘EEG161’}. Can also be a callable function that takes and returns a string (new in version 0.10.0).

Notes

New in version 0.9.0.

reorder_channels(ch_names)[source]¶

Reorder channels.

Parameters:	ch_names : list The desired channel order.
Returns:	inst : instance of Raw, Epochs, or Evoked The modified instance.

Notes

Channel names must be unique. Channels that are not in ch_names are dropped.

New in version 0.16.0.

resample(sfreq, npad='auto', window='boxcar', stim_picks=None, n_jobs=1, events=None, pad='reflect_limited', verbose=None)[source]¶

Resample all channels.

The Raw object has to have the data loaded e.g. with preload=True or self.load_data().

Warning

The intended purpose of this function is primarily to speed up computations (e.g., projection calculation) when precise timing of events is not required, as downsampling raw data effectively jitters trigger timings. It is generally recommended not to epoch downsampled data, but instead epoch and then downsample, as epoching downsampled data jitters triggers. For more, see this illustrative gist.

If resampling the continuous data is desired, it is recommended to construct events using the original data. The event onsets can be jointly resampled with the raw data using the ‘events’ parameter (a resampled copy is returned).

Parameters:

Parameters:	sfreq : float New sample rate to use. npad : int \| str Amount to pad the start and end of the data. Can also be “auto” to use a padding that will result in a power-of-two size (can be much faster). window : string or tuple Frequency-domain window to use in resampling. See `scipy.signal.resample()`. stim_picks : array of int \| None Stim channels. These channels are simply subsampled or supersampled (without applying any filtering). This reduces resampling artifacts in stim channels, but may lead to missing triggers. If None, stim channels are automatically chosen using `mne.pick_types()`. n_jobs : int \| str Number of jobs to run in parallel. Can be ‘cuda’ if scikits.cuda is installed properly and CUDA is initialized. events : 2D array, shape (n_events, 3) \| None An optional event matrix. When specified, the onsets of the events are resampled jointly with the data. NB: The input events are not modified, but a new array is returned with the raw instead. pad : str The type of padding to use. Supports all `numpy.pad()` `mode` options. Can also be “reflect_limited” (default), which pads with a reflected version of each vector mirrored on the first and last values of the vector, followed by zeros. New in version 0.15. 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:	raw : instance of Raw The resampled version of the raw object. events : 2D array, shape (n_events, 3) \| None If events are jointly resampled, these are returned with the raw.

sfreq : float: New sample rate to use.
npad : int | str: Amount to pad the start and end of the data. Can also be “auto” to use a padding that will result in a power-of-two size (can be much faster).
window : string or tuple: Frequency-domain window to use in resampling. See scipy.signal.resample().
stim_picks : array of int | None: Stim channels. These channels are simply subsampled or supersampled (without applying any filtering). This reduces resampling artifacts in stim channels, but may lead to missing triggers. If None, stim channels are automatically chosen using mne.pick_types().
n_jobs : int | str: Number of jobs to run in parallel. Can be ‘cuda’ if scikits.cuda is installed properly and CUDA is initialized.
events : 2D array, shape (n_events, 3) | None: An optional event matrix. When specified, the onsets of the events are resampled jointly with the data. NB: The input events are not modified, but a new array is returned with the raw instead.
pad : str: The type of padding to use. Supports all numpy.pad() mode options. Can also be “reflect_limited” (default), which pads with a reflected version of each vector mirrored on the first and last values of the vector, followed by zeros.

New in version 0.15.
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:

raw : instance of Raw: The resampled version of the raw object.
events : 2D array, shape (n_events, 3) | None: If events are jointly resampled, these are returned with the raw.

Notes

For some data, it may be more accurate to use npad=0 to reduce artifacts. This is dataset dependent – check your data!

save(fname, picks=None, tmin=0, tmax=None, buffer_size_sec=None, drop_small_buffer=False, proj=False, fmt='single', overwrite=False, split_size='2GB', verbose=None)[source]¶

Save raw data to file.

Parameters:

Parameters:	fname : string File name of the new dataset. This has to be a new filename unless data have been preloaded. Filenames should end with raw.fif, raw.fif.gz, raw_sss.fif, raw_sss.fif.gz, raw_tsss.fif or raw_tsss.fif.gz. picks : array-like of int \| None Indices of channels to include. If None all channels are kept. tmin : float \| None Time in seconds of first sample to save. If None first sample is used. tmax : float \| None Time in seconds of last sample to save. If None last sample is used. buffer_size_sec : float \| None Size of data chunks in seconds. If None (default), the buffer size of the original file is used. drop_small_buffer : bool Drop or not the last buffer. It is required by maxfilter (SSS) that only accepts raw files with buffers of the same size. proj : bool If True the data is saved with the projections applied (active). Note If `apply_proj()` was used to apply the projections, the projectons will be active even if `proj` is False. fmt : str Format to use to save raw data. Valid options are ‘double’, ‘single’, ‘int’, and ‘short’ for 64- or 32-bit float, or 32- or 16-bit integers, respectively. It is strongly recommended to use ‘single’, as this is backward-compatible, and is standard for maintaining precision. Note that using ‘short’ or ‘int’ may result in loss of precision, complex data cannot be saved as ‘short’, and neither complex data types nor real data stored as ‘double’ can be loaded with the MNE command-line tools. See raw.orig_format to determine the format the original data were stored in. overwrite : bool If True, the destination file (if it exists) will be overwritten. If False (default), an error will be raised if the file exists. To overwrite original file (the same one that was loaded), data must be preloaded upon reading. split_size : string \| int Large raw files are automatically split into multiple pieces. This parameter specifies the maximum size of each piece. If the parameter is an integer, it specifies the size in Bytes. It is also possible to pass a human-readable string, e.g., 100MB. Note Due to FIFF file limitations, the maximum split size is 2GB. 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.

fname : string: File name of the new dataset. This has to be a new filename unless data have been preloaded. Filenames should end with raw.fif, raw.fif.gz, raw_sss.fif, raw_sss.fif.gz, raw_tsss.fif or raw_tsss.fif.gz.
picks : array-like of int | None: Indices of channels to include. If None all channels are kept.
tmin : float | None: Time in seconds of first sample to save. If None first sample is used.
tmax : float | None: Time in seconds of last sample to save. If None last sample is used.
buffer_size_sec : float | None: Size of data chunks in seconds. If None (default), the buffer size of the original file is used.
drop_small_buffer : bool: Drop or not the last buffer. It is required by maxfilter (SSS) that only accepts raw files with buffers of the same size.
proj : bool: If True the data is saved with the projections applied (active).

Note

If apply_proj() was used to apply the projections, the projectons will be active even if proj is False.
fmt : str: Format to use to save raw data. Valid options are ‘double’, ‘single’, ‘int’, and ‘short’ for 64- or 32-bit float, or 32- or 16-bit integers, respectively. It is strongly recommended to use ‘single’, as this is backward-compatible, and is standard for maintaining precision. Note that using ‘short’ or ‘int’ may result in loss of precision, complex data cannot be saved as ‘short’, and neither complex data types nor real data stored as ‘double’ can be loaded with the MNE command-line tools. See raw.orig_format to determine the format the original data were stored in.
overwrite : bool: If True, the destination file (if it exists) will be overwritten. If False (default), an error will be raised if the file exists. To overwrite original file (the same one that was loaded), data must be preloaded upon reading.
split_size : string | int: Large raw files are automatically split into multiple pieces. This parameter specifies the maximum size of each piece. If the parameter is an integer, it specifies the size in Bytes. It is also possible to pass a human-readable string, e.g., 100MB.

Note

Due to FIFF file limitations, the maximum split size is 2GB.
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.

Notes

If Raw is a concatenation of several raw files, be warned that only the measurement information from the first raw file is stored. This likely means that certain operations with external tools may not work properly on a saved concatenated file (e.g., probably some or all forms of SSS). It is recommended not to concatenate and then save raw files for this reason.

set_channel_types(mapping)[source]¶

Define the sensor type of channels.

Note: The following sensor types are accepted:: ecg, eeg, emg, eog, exci, ias, misc, resp, seeg, stim, syst, ecog, hbo, hbr

Parameters:	mapping : dict a dictionary mapping a channel to a sensor type (str) {‘EEG061’: ‘eog’}.

Notes

New in version 0.9.0.

set_eeg_reference(ref_channels='average', projection=None, verbose=None)[source]¶

Specify which reference to use for EEG data.

By default, MNE-Python will automatically re-reference the EEG signal to use an average reference (see below). Use this function to explicitly specify the desired reference for EEG. This can be either an existing electrode or a new virtual channel. This function will re-reference the data according to the desired reference and prevent MNE-Python from automatically adding an average reference projection.

Some common referencing schemes and the corresponding value for the ref_channels parameter:

No re-referencing:: If the EEG data is already using the proper reference, set ref_channels=[]. This will prevent MNE-Python from automatically adding an average reference projection.
Average reference:: A new virtual reference electrode is created by averaging the current EEG signal by setting ref_channels='average'. Bad EEG channels are automatically excluded if they are properly set in info['bads'].
A single electrode:: Set ref_channels to a list containing the name of the channel that will act as the new reference, for example ref_channels=['Cz'].
The mean of multiple electrodes:: A new virtual reference electrode is created by computing the average of the current EEG signal recorded from two or more selected channels. Set ref_channels to a list of channel names, indicating which channels to use. For example, to apply an average mastoid reference, when using the 10-20 naming scheme, set ref_channels=['M1', 'M2'].

Note

In case of ref_channels='average' in combination with projection=True, the reference is added as a projection and it is not applied automatically. For it to take effect, apply with method apply_proj. Other references are directly applied (this behavior will change in MNE 0.16).

Parameters:

Parameters:	ref_channels : list of str \| str The name(s) of the channel(s) used to construct the reference. To apply an average reference, specify `'average'` here (default). If an empty list is specified, the data is assumed to already have a proper reference and MNE will not attempt any re-referencing of the data. Defaults to an average reference. projection : bool \| None If `ref_channels='average'` this argument specifies if the average reference should be computed as a projection (True) or not (False). If `projection=True`, the average reference is added as a projection and is not applied to the data (it can be applied afterwards with the `apply_proj` method). If `projection=False`, the average reference is directly applied to the data. Defaults to None, which means `projection=True`, but will change to `projection=False` in the next release. If `ref_channels` is not `'average'`, `projection` must be set to `False` (the default in this case). verbose : bool, str, int, or None If not None, override default verbose level (see `mne.verbose()` and Logging documentation for more).
Returns:	inst : instance of Raw \| Epochs \| Evoked Data with EEG channels re-referenced. If `ref_channels='average'` and `projection=True` a projection will be added instead of directly re-referencing the data.

ref_channels : list of str | str: The name(s) of the channel(s) used to construct the reference. To apply an average reference, specify 'average' here (default). If an empty list is specified, the data is assumed to already have a proper reference and MNE will not attempt any re-referencing of the data. Defaults to an average reference.
projection : bool | None: If ref_channels='average' this argument specifies if the average reference should be computed as a projection (True) or not (False). If projection=True, the average reference is added as a projection and is not applied to the data (it can be applied afterwards with the apply_proj method). If projection=False, the average reference is directly applied to the data. Defaults to None, which means projection=True, but will change to projection=False in the next release. If ref_channels is not 'average', projection must be set to False (the default in this case).
verbose : bool, str, int, or None: If not None, override default verbose level (see mne.verbose() and Logging documentation for more).

Returns:

inst : instance of Raw | Epochs | Evoked: Data with EEG channels re-referenced. If ref_channels='average' and projection=True a projection will be added instead of directly re-referencing the data.

See also

mne.set_bipolar_reference: Convenience function for creating bipolar references.

Notes

If a reference is requested that is not the average reference, this function removes any pre-existing average reference projections.
During source localization, the EEG signal should have an average reference.
In order to apply a reference, the data must be preloaded. This is not necessary if ref_channels='average' and projection=True.
For an average reference, bad EEG channels are automatically excluded if they are properly set in info['bads'].

New in version 0.9.0.

set_montage(montage, set_dig=True, verbose=None)[source]¶

Set EEG sensor configuration and head digitization.

Parameters:

Parameters:	montage : instance of Montage \| instance of DigMontage \| str \| None The montage to use (None removes any location information). set_dig : bool If True, update the digitization information (`info['dig']`) in addition to the channel positions (`info['chs'][idx]['loc']`). verbose : bool, str, int, or None If not None, override default verbose level (see `mne.verbose()` and Logging documentation for more).

montage : instance of Montage | instance of DigMontage | str | None: The montage to use (None removes any location information).
set_dig : bool: If True, update the digitization information (info['dig']) in addition to the channel positions (info['chs'][idx]['loc']).
verbose : bool, str, int, or None: If not None, override default verbose level (see mne.verbose() and Logging documentation for more).

Notes

Operates in place.

New in version 0.9.0.

time_as_index(times, use_rounding=False)[source]¶

Convert time to indices.

Parameters:	times : list-like \| float \| int List of numbers or a number representing points in time. use_rounding : boolean If True, use rounding (instead of truncation) when converting times to indices. This can help avoid non-unique indices.
Returns:	index : ndarray Indices corresponding to the times supplied.

times¶: Time points.

to_data_frame(picks=None, index=None, scaling_time=1000.0, scalings=None, copy=True, start=None, stop=None)[source]¶

Export data in tabular structure as a pandas DataFrame.

Columns and indices will depend on the object being converted. Generally this will include as much relevant information as possible for the data type being converted. This makes it easy to convert data for use in packages that utilize dataframes, such as statsmodels or seaborn.

Parameters:

Parameters:	picks : array-like of int \| None If None only MEG and EEG channels are kept otherwise the channels indices in picks are kept. index : tuple of str \| None Column to be used as index for the data. Valid string options are ‘epoch’, ‘time’ and ‘condition’. If None, all three info columns will be included in the table as categorial data. scaling_time : float Scaling to be applied to time units. scalings : dict \| None Scaling to be applied to the channels picked. If None, defaults to `scalings=dict(eeg=1e6, grad=1e13, mag=1e15, misc=1.0)`. copy : bool If true, data will be copied. Else data may be modified in place. start : int \| None If it is a Raw object, this defines a starting index for creating the dataframe from a slice. The times will be interpolated from the index and the sampling rate of the signal. stop : int \| None If it is a Raw object, this defines a stop index for creating the dataframe from a slice. The times will be interpolated from the index and the sampling rate of the signal.
Returns:	df : instance of pandas.core.DataFrame A dataframe suitable for usage with other statistical/plotting/analysis packages. Column/Index values will depend on the object type being converted, but should be human-readable.

picks : array-like of int | None: If None only MEG and EEG channels are kept otherwise the channels indices in picks are kept.
index : tuple of str | None: Column to be used as index for the data. Valid string options are ‘epoch’, ‘time’ and ‘condition’. If None, all three info columns will be included in the table as categorial data.
scaling_time : float: Scaling to be applied to time units.
scalings : dict | None: Scaling to be applied to the channels picked. If None, defaults to scalings=dict(eeg=1e6, grad=1e13, mag=1e15, misc=1.0).
copy : bool: If true, data will be copied. Else data may be modified in place.
start : int | None: If it is a Raw object, this defines a starting index for creating the dataframe from a slice. The times will be interpolated from the index and the sampling rate of the signal.
stop : int | None: If it is a Raw object, this defines a stop index for creating the dataframe from a slice. The times will be interpolated from the index and the sampling rate of the signal.

Returns:

df : instance of pandas.core.DataFrame: A dataframe suitable for usage with other statistical/plotting/analysis packages. Column/Index values will depend on the object type being converted, but should be human-readable.