def _get_data():
"""Read in data used in tests."""
# read forward model
forward = mne.read_forward_solution(fname_fwd)
# read data
raw = mne.io.read_raw_fif(fname_raw, preload=True)
events = mne.read_events(fname_event)
event_id, tmin, tmax = 1, -0.1, 0.15
# decimate for speed
left_temporal_channels = read_vectorview_selection('Left-temporal')
picks = mne.pick_types(raw.info,
meg=True,
selection=left_temporal_channels)
picks = picks[::2]
raw.pick_channels([raw.ch_names[ii] for ii in picks])
del picks
raw.info.normalize_proj() # avoid projection warnings
epochs = mne.Epochs(raw,
events,
event_id,
tmin,
tmax,
proj=True,
baseline=(None, 0.),
preload=True,
reject=reject)
noise_cov = mne.compute_covariance(epochs, tmin=None, tmax=0.)
data_cov = mne.compute_covariance(epochs, tmin=0.01, tmax=0.15)
return epochs, data_cov, noise_cov, forward
def _select_channels(epochs):
"""
Select a subset of channels based on location in helmet
:param epochs: pandas DataFrame, df of epochs
:return:
"""
right_chs = mne.read_vectorview_selection(['Right-occipital'])
idx_right = [epochs.columns.get_loc(s.replace(' ', '')) for s in right_chs]
left_chs = mne.read_vectorview_selection(['Left-occipital'])
idx_left = [epochs.columns.get_loc(s.replace(' ', '')) for s in left_chs]
idx_left = [186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
199, 200, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
224, 234, 235, 236, 237, 238, 239, 246, 247, 248]
idx_right = [231, 232, 233, 240, 241, 242, 243, 244, 245, 261, 262, 263,
264, 265, 266, 267, 268, 269, 270, 271, 272, 279, 280, 281,
285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296]
def test_read_vectorview_selection():
"""Test reading of Neuromag Vector View channel selections."""
# test one channel for each selection
ch_names = [
'MEG 2211', 'MEG 0223', 'MEG 1312', 'MEG 0412', 'MEG 1043', 'MEG 2042',
'MEG 2032', 'MEG 0522', 'MEG 1031'
]
sel_names = [
'Vertex', 'Left-temporal', 'Right-temporal', 'Left-parietal',
'Right-parietal', 'Left-occipital', 'Right-occipital', 'Left-frontal',
'Right-frontal'
]
raw = read_raw_fif(raw_fname)
for i, name in enumerate(sel_names):
sel = read_vectorview_selection(name)
assert ch_names[i] in sel
sel_info = read_vectorview_selection(name, info=raw.info)
assert sel == sel_info
# test some combinations
all_ch = read_vectorview_selection(['L', 'R'])
left = read_vectorview_selection('L')
right = read_vectorview_selection('R')
assert len(all_ch) == len(left) + len(right)
assert len(set(left).intersection(set(right))) == 0
frontal = read_vectorview_selection('frontal')
occipital = read_vectorview_selection('Right-occipital')
assert len(set(frontal).intersection(set(occipital))) == 0
ch_names_new = [ch.replace(' ', '') for ch in ch_names]
raw_new = read_raw_fif(raw_new_fname)
for i, name in enumerate(sel_names):
sel = read_vectorview_selection(name, info=raw_new.info)
assert ch_names_new[i] in sel
with pytest.raises(TypeError, match='must be an instance of Info or None'):
read_vectorview_selection(name, info='foo')
def _get_data(tmin=-0.1,
tmax=0.15,
all_forward=True,
epochs=True,
epochs_preload=True,
data_cov=True,
proj=True):
"""Read in data used in tests."""
label = mne.read_label(fname_label)
events = mne.read_events(fname_event)
raw = mne.io.read_raw_fif(fname_raw, preload=True)
forward = mne.read_forward_solution(fname_fwd)
if all_forward:
forward_surf_ori = _read_forward_solution_meg(fname_fwd, surf_ori=True)
forward_fixed = _read_forward_solution_meg(fname_fwd,
force_fixed=True,
surf_ori=True,
use_cps=False)
forward_vol = _read_forward_solution_meg(fname_fwd_vol)
else:
forward_surf_ori = None
forward_fixed = None
forward_vol = None
event_id, tmin, tmax = 1, tmin, tmax
# Setup for reading the raw data
raw.info['bads'] = ['MEG 2443', 'EEG 053'] # 2 bad channels
# Set up pick list: MEG - bad channels
left_temporal_channels = read_vectorview_selection('Left-temporal')
picks = mne.pick_types(raw.info,
meg=True,
selection=left_temporal_channels)
picks = picks[::2] # decimate for speed
# add a couple channels we will consider bad
bad_picks = [100, 101]
bads = [raw.ch_names[pick] for pick in bad_picks]
assert not any(pick in picks for pick in bad_picks)
picks = np.concatenate([picks, bad_picks])
raw.pick_channels([raw.ch_names[ii] for ii in picks])
del picks
raw.info['bads'] = bads # add more bads
if proj:
raw.info.normalize_proj() # avoid projection warnings
else:
raw.del_proj()
if epochs:
# Read epochs
epochs = mne.Epochs(raw,
events,
event_id,
tmin,
tmax,
proj=True,
baseline=(None, 0),
preload=epochs_preload,
reject=reject)
if epochs_preload:
epochs.resample(200, npad=0)
epochs.crop(0, None)
evoked = epochs.average()
info = evoked.info
else:
epochs = None
evoked = None
info = raw.info
noise_cov = mne.read_cov(fname_cov)
noise_cov['projs'] = [] # avoid warning
noise_cov = mne.cov.regularize(noise_cov,
info,
mag=0.05,
grad=0.05,
eeg=0.1,
proj=True,
rank=None)
if data_cov:
data_cov = mne.compute_covariance(epochs,
tmin=0.04,
tmax=0.145,
verbose='error') # baseline warning
else:
data_cov = None
return raw, epochs, evoked, data_cov, noise_cov, label, forward,\
forward_surf_ori, forward_fixed, forward_vol
include=include,
exclude='bads')
# Load condition 1
event_id = 1
epochs = mne.Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True,
reject=dict(grad=4000e-13, eog=150e-6))
# just use right temporal sensors for speed
epochs.pick_channels(mne.read_vectorview_selection('Right-temporal'))
evoked = epochs.average()
# Factor to down-sample the temporal dimension of the TFR computed by
# tfr_morlet. Decimation occurs after frequency decomposition and can
# be used to reduce memory usage (and possibly computational time of downstream
# operations such as nonparametric statistics) if you don't need high
# spectrotemporal resolution.
decim = 5
freqs = np.arange(8, 40, 2) # define frequencies of interest
sfreq = raw.info['sfreq'] # sampling in Hz
tfr_epochs = tfr_morlet(epochs,
freqs,
n_cycles=4.,
decim=decim,
average=False,
events = mne.find_events(raw, initial_event=True)
tmax = (len(stc_signal.times) - 1) / sfreq
epochs = mne.Epochs(raw,
events,
event_id=dict(signal=1, noise=2),
tmin=0,
tmax=tmax,
baseline=None,
preload=True)
assert len(epochs) == 2 # ensure that we got the two expected events
# Plot some of the channels of the simulated data that are situated above one
# of our simulated sources.
picks = mne.pick_channels(epochs.ch_names,
mne.read_vectorview_selection('Left-frontal'))
epochs.plot(picks=picks)
###############################################################################
# Power mapping
# -------------
# With our simulated dataset ready, we can now pretend to be researchers that
# have just recorded this from a real subject and are going to study what parts
# of the brain communicate with each other.
#
# First, we'll create a source estimate of the MEG data. We'll use both a
# straightforward MNE-dSPM inverse solution for this, and the DICS beamformer
# which is specifically designed to work with oscillatory data.
###############################################################################
# Computing the inverse using MNE-dSPM:
noise_fname = data_path + '/MEG/sample/ernoise_raw.fif'
event_fname = data_path + '/MEG/sample/sample_audvis_raw-eve.fif'
fname_fwd = data_path + '/MEG/sample/sample_audvis-meg-eeg-oct-6-fwd.fif'
subjects_dir = data_path + '/subjects'
label_name = 'Aud-lh'
fname_label = data_path + '/MEG/sample/labels/%s.label' % label_name
###############################################################################
# Read raw data
raw = mne.io.read_raw_fif(raw_fname, preload=True)
raw.info['bads'] = ['MEG 2443'] # 1 bad MEG channel
# Pick a selection of magnetometer channels. A subset of all channels was used
# to speed up the example. For a solution based on all MEG channels use
# meg=True, selection=None and add mag=4e-12 to the reject dictionary.
left_temporal_channels = mne.read_vectorview_selection('Left-temporal')
picks = mne.pick_types(raw.info,
meg='mag',
eeg=False,
eog=False,
stim=False,
exclude='bads',
selection=left_temporal_channels)
raw.pick_channels([raw.ch_names[pick] for pick in picks])
reject = dict(mag=4e-12)
# Re-normalize our empty-room projectors, which should be fine after
# subselection
raw.info.normalize_proj()
# Setting time windows. Note that tmin and tmax are set so that time-frequency
# beamforming will be performed for a wider range of time points than will
