class mne.Info[source]

Measurement information.

This data structure behaves like a dictionary. It contains all metadata that is available for a recording.

This class should not be instantiated directly. To create a measurement information strucure, use mne.create_info().

The only entries that should be manually changed by the user are info['bads'] and info['description']. All other entries should be considered read-only, or should be modified by functions or methods.


acq_pars : str | None

MEG system acquition parameters. See mne.AcqParserFIF for details.

acq_stim : str | None

MEG system stimulus parameters.

bads : list of str

List of bad (noisy/broken) channels, by name. These channels will by default be ignored by many processing steps.

buffer_size_sec : float | None

Buffer size (in seconds) when reading the raw data in chunks.

ch_names : list of str

The names of the channels.

chs : list of dict

A list of channel information dictionaries, one per channel. See Notes for more information.

comps : list of dict

CTF software gradient compensation data. See Notes for more information.

ctf_head_t : dict | None

The transformation from 4D/CTF head coordinates to Neuromag head coordinates. This is only present in 4D/CTF data.

custom_ref_applied : bool

Whether a custom (=other than average) reference has been applied to the EEG data. This flag is checked by some algorithms that require an average reference to be set.

description : str | None

String description of the recording.

dev_ctf_t : dict | None

The transformation from device coordinates to 4D/CTF head coordinates. This is only present in 4D/CTF data.

dev_head_t : dict | None

The device to head transformation.

dig : list of dict | None

The Polhemus digitization data in head coordinates. See Notes for more information.

events : list of dict

Event list, sometimes extracted from the stim channels by Neuromag systems. In general this should not be used and mne.find_events() should be used for event processing. See Notes for more information.

experimenter : str | None

Name of the person that ran the experiment.

file_id : dict | None

The FIF globally unique ID. See Notes for more information.

highpass : float | None

Highpass corner frequency in Hertz. Zero indicates a DC recording.

hpi_meas : list of dict

HPI measurements that were taken at the start of the recording (e.g. coil frequencies). See Notes for details.

hpi_results : list of dict

Head position indicator (HPI) digitization points and fit information (e.g., the resulting transform). See Notes for details.

hpi_subsystem : dict | None

Information about the HPI subsystem that was used (e.g., event channel used for cHPI measurements). See Notes for details.

line_freq : float | None

Frequency of the power line in Hertz.

lowpass : float | None

Lowpass corner frequency in Hertz.

meas_date : list of int

The first element of this list is a POSIX timestamp (milliseconds since 1970-01-01 00:00:00) denoting the date and time at which the measurement was taken. The second element is the number of microseconds.

meas_id : dict | None

The ID assigned to this measurement by the acquisition system or during file conversion. Follows the same format as file_id.

nchan : int

Number of channels.

proc_history : list of dict

The MaxFilter processing history. See Notes for details.

proj_id : int | None

ID number of the project the experiment belongs to.

proj_name : str | None

Name of the project the experiment belongs to.

projs : list of Projection

List of SSP operators that operate on the data. See mne.Projection for details.

sfreq : float

Sampling frequency in Hertz.

subject_info : dict | None

Information about the subject. See Notes for details.

See also



The following parameters have a nested structure.

  • chs list of dict:

    cal : float

    The calibration factor to bring the channels to physical units. Used in product with range to scale the data read from disk.

    ch_name : str

    The channel name.

    coil_type : int

    Coil type, e.g. FIFFV_COIL_MEG.

    coord_frame : int

    The coordinate frame used, e.g. FIFFV_COORD_HEAD.

    kind : int

    The kind of channel, e.g. FIFFV_EEG_CH.

    loc : array, shape (12,)

    Channel location. For MEG this is the position plus the normal given by a 3x3 rotation matrix. For EEG this is the position followed by reference position (with 6 unused). The values are specified in device coordinates for MEG and in head coordinates for EEG channels, respectively.

    logno : int

    Logical channel number, conventions in the usage of this number vary.

    range : float

    The hardware-oriented part of the calibration factor. This should be only applied to the continuous raw data. Used in product with cal to scale data read from disk.

    scanno : int

    Scanning order number, starting from 1.

    unit : int

    The unit to use, e.g. FIFF_UNIT_T_M.

    unit_mul : int

    Unit multipliers, most commontly FIFF_UNITM_NONE.

  • comps list of dict:

    ctfkind : int

    CTF compensation grade.

    colcals : ndarray

    Column calibrations.

    mat : dict

    A named matrix dictionary (with entries “data”, “col_names”, etc.) containing the compensation matrix.

    rowcals : ndarray

    Row calibrations.

    save_calibrated : bool

    Were the compensation data saved in calibrated form.

  • dig dict:

    kind : int

    Digitization kind, e.g. FIFFV_POINT_EXTRA.

    ident : int


    r : ndarary, shape (3,)


    coord_frame : int

    Coordinate frame, e.g. FIFFV_COORD_HEAD.

  • events list of dict:

    channels : list of int

    Channel indices for the events.

    list : ndarray, shape (n_events * 3,)

    Events in triplets as number of samples, before, after.

  • file_id dict:

    version : int

    FIF format version, i.e. FIFFC_VERSION.

    machid : ndarray, shape (2,)

    Unique machine ID, usually derived from the MAC address.

    secs : int

    Time in seconds.

    usecs : int

    Time in microseconds.

  • hpi_meas list of dict:

    creator : str

    Program that did the measurement.

    sfreq : float

    Sample rate.

    nchan : int

    Number of channels used.

    nave : int

    Number of averages used.

    ncoil : int

    Number of coils used.

    first_samp : int

    First sample used.

    last_samp : int

    Last sample used.

    hpi_coils : list of dict

    Coils, containing:

    number: int

    Coil number

    epoch : ndarray

    Buffer containing one epoch and channel.

    slopes : ndarray, shape (n_channels,)

    HPI data.

    corr_coeff : ndarray, shape (n_channels,)

    HPI curve fit correlations.

    coil_freq : float

    HPI coil excitation frequency

  • hpi_results list of dict:

    dig_points : list

    Digitization points (see dig definition) for the HPI coils.

    order : ndarray, shape (ncoil,)

    The determined digitization order.

    used : ndarray, shape (nused,)

    The indices of the used coils.

    moments : ndarray, shape (ncoil, 3)

    The coil moments.

    goodness : ndarray, shape (ncoil,)

    The goodness of fits.

    good_limit : float

    The goodness of fit limit.

    dist_limit : float

    The distance limit.

    accept : int

    Whether or not the fit was accepted.

    coord_trans : instance of Transformation

    The resulting MEG<->head transformation.

  • hpi_subsystem dict:

    ncoil : int

    The number of coils.

    event_channel : str

    The event channel used to encode cHPI status (e.g., STI201).

    hpi_coils : list of ndarray

    List of length ncoil, each 4-element ndarray contains the event bits used on the event channel to indicate cHPI status (using the first element of these arrays is typically sufficient).

  • proc_history list of dict:

    block_id : dict

    See id above.

    date : ndarray, shape (2,)

    2-element tuple of seconds and microseconds.

    experimenter : str

    Name of the person who ran the program.

    creator : str

    Program that did the processing.

    max_info : dict

    Maxwel filtering info, can contain:

    sss_info : dict

    SSS processing information.


    tSSS processing information.

    sss_ctc : dict

    Cross-talk processing information.

    sss_cal : dict

    Fine-calibration information.

    smartshield : dict

    MaxShield information. This dictionary is (always?) empty, but its presence implies that MaxShield was used during acquisiton.

  • subject_info dict:

    id : int

    Integer subject identifier.

    his_id : str

    String subject identifier.

    last_name : str

    Last name.

    first_name : str

    First name.

    middle_name : str

    Middle name.

    birthday : tuple of int

    Birthday in (year, month, day) format.

    sex : int

    Subject sex (0=unknown, 1=male, 2=female).

    hand : int

    Handedness (1=right, 2=left).


__contains__((k) -> True if D has a key k, …)
__getitem__ x.__getitem__(y) <==> x[y]
__iter__() <==> iter(x)
__len__() <==> len(x)
clear(() -> None.  Remove all items from D.)
copy() Copy the instance.
fromkeys(…) v defaults to None.
get((k[,d]) -> D[k] if k in D, …)
has_key((k) -> True if D has a key k, else False)
items(() -> list of D’s (key, value) pairs, …)
iteritems(() -> an iterator over the (key, …)
iterkeys(() -> an iterator over the keys of D)
keys(() -> list of D’s keys)
normalize_proj() (Re-)Normalize projection vectors after subselection.
pop((k[,d]) -> v, …) If key is not found, d is returned if given, otherwise KeyError is raised
popitem(() -> (k, v), …) 2-tuple; but raise KeyError if D is empty.
setdefault((k[,d]) -> D.get(k,d), …)
update(([E, …) If E present and has a .keys() method, does: for k in E: D[k] = E[k]
values(() -> list of D’s values)
__contains__(k) → True if D has a key k, else False

x.__getitem__(y) <==> x[y]

__iter__() <==> iter(x)
__len__() <==> len(x)
clear() → None. Remove all items from D.

Copy the instance.


info : instance of Info

The copied info.

fromkeys(S[, v]) → New dict with keys from S and values equal to v.

v defaults to None.

get(k[, d]) → D[k] if k in D, else d. d defaults to None.
has_key(k) → True if D has a key k, else False
items() → list of D's (key, value) pairs, as 2-tuples
iteritems() → an iterator over the (key, value) items of D
iterkeys() → an iterator over the keys of D
itervalues() → an iterator over the values of D
keys() → list of D's keys

(Re-)Normalize projection vectors after subselection.

Applying projection after sub-selecting a set of channels that were originally used to compute the original projection vectors can be dangerous (e.g., if few channels remain, most power was in channels that are no longer picked, etc.). By default, mne will emit a warning when this is done.

This function will re-normalize projectors to use only the remaining channels, thus avoiding that warning. Only use this function if you’re confident that the projection vectors still adequately capture the original signal of interest.

pop(k[, d]) → v, remove specified key and return the corresponding value.

If key is not found, d is returned if given, otherwise KeyError is raised

popitem() → (k, v), remove and return some (key, value) pair as a

2-tuple; but raise KeyError if D is empty.

setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D
update([E, ]**F) → None. Update D from dict/iterable E and F.

If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

values() → list of D's values
viewitems() → a set-like object providing a view on D's items
viewkeys() → a set-like object providing a view on D's keys
viewvalues() → an object providing a view on D's values