def run_inverse(subject):
print("processing subject: %s" % subject)
meg_subject_dir = op.join(config.meg_dir, subject)
fname_ave = op.join(meg_subject_dir, '%s-ave.fif' % subject)
fname_fwd = op.join(meg_subject_dir,
'%s-%s-fwd.fif' % (subject, config.spacing))
fname_cov = op.join(meg_subject_dir, '%s-cov.fif' % subject)
fname_inv = op.join(meg_subject_dir,
'%s-%s-inv.fif' % (subject, config.spacing))
evokeds = mne.read_evokeds(fname_ave)
cov = mne.read_cov(fname_cov)
forward = mne.read_forward_solution(fname_fwd)
info = evokeds[0].info
inverse_operator = make_inverse_operator(info,
forward,
cov,
loose=0.2,
depth=0.8)
write_inverse_operator(fname_inv, inverse_operator)
# Apply inverse
snr = 3.0
lambda2 = 1.0 / snr**2
for condition, evoked in zip(config.conditions, evokeds):
stc = apply_inverse(evoked,
inverse_operator,
lambda2,
"dSPM",
pick_ori=None)
stc.save(
op.join(meg_subject_dir,
'mne_dSPM_inverse-%s' % condition.replace(op.sep, '')))
def save(var, typ, subject='fsaverage', analysis='analysis', block=999,
upload=aws, overwrite=False):
"""Auxiliary saving function."""
# get file name
fname = paths(typ, subject=subject, analysis=analysis, block=block)
# check if file exists
if op.exists(fname) and not overwrite:
print('%s already exists. Skipped' % fname)
return False
# different data format depending file type
if typ in ['epo_block', 'epochs', 'epochs_decim', 'cov', 'epochs_vhp']:
var.save(fname)
elif typ in ['evoked', 'decod', 'decod_tfr', 'score', 'score_tfr',
'evoked_source']:
with open(fname, 'wb') as f:
pickle.dump(var, f)
elif typ in ['inv']:
from mne.minimum_norm import write_inverse_operator
write_inverse_operator(fname, var)
elif typ in ['fwd']:
from mne import write_forward_solution
write_forward_solution(fname, var)
elif typ == 'morph':
np.savez(fname, data=var.data, indices=var.indices,
indptr=var.indptr, shape=var.shape)
elif typ in ['score_source', 'score_pval']:
np.save(fname, var)
else:
raise NotImplementedError()
if upload:
client.upload(fname)
return True
def apply_inverse_ave(fnevo, min_subject='fsaverage'):
from mne import make_forward_solution
from mne.minimum_norm import write_inverse_operator
fnlist = get_files_from_list(fnevo)
# loop across all filenames
for fname in fnlist:
fn_path = os.path.split(fname)[0]
name = os.path.basename(fname)
#fn_inv = fname[:fname.rfind('-ave.fif')] + ',ave-inv.fif'
subject = name.split('_')[0]
fn_inv = fn_path + '/%s_fibp1-45,ave-inv.fif' %subject
subject_path = subjects_dir + '/%s' %subject
#min_dir = subjects_dir + '/%s' %min_subject
fn_trans = fn_path + '/%s-trans.fif' % subject
#fn_cov = fn_path + '/%s_empty,nr,fibp1-45-cov.fif' % subject
fn_cov = fn_path + '/%s_empty,fibp1-45-cov.fif' %subject
fn_src = subject_path + '/bem/%s-oct-6-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
[evoked] = mne.read_evokeds(fname)
evoked.pick_types(meg=True, ref_meg=False)
noise_cov = mne.read_cov(fn_cov)
#noise_cov = mne.cov.regularize(noise_cov, evoked.info,
# mag=0.05, grad=0.05, proj=True)
fwd = make_forward_solution(evoked.info, fn_trans, fn_src, fn_bem)
fwd['surf_ori'] = True
inv = mne.minimum_norm.make_inverse_operator(evoked.info, fwd, noise_cov, loose=0.2,
depth=0.8, limit_depth_chs=False)
write_inverse_operator(fn_inv, inv)
def run_inverse(subject_id):
subject = "sub%03d" % subject_id
print("processing subject: %s" % subject)
data_path = op.join(meg_dir, subject)
fname_ave = op.join(data_path, '%s-ave.fif' % subject)
fname_cov = op.join(data_path, '%s-cov.fif' % subject)
fname_fwd = op.join(data_path, '%s-meg-%s-fwd.fif' % (subject, spacing))
fname_inv = op.join(data_path, '%s-meg-%s-inv.fif' % (subject, spacing))
evokeds = mne.read_evokeds(fname_ave, condition=[0, 1, 2, 3, 4, 5])
cov = mne.read_cov(fname_cov)
# cov = mne.cov.regularize(cov, evokeds[0].info,
# mag=0.05, grad=0.05, eeg=0.1, proj=True)
forward = mne.read_forward_solution(fname_fwd, surf_ori=True)
# forward = mne.pick_types_forward(forward, meg=True, eeg=False)
# make an M/EEG, MEG-only, and EEG-only inverse operators
info = evokeds[0].info
inverse_operator = make_inverse_operator(info, forward, cov,
loose=0.2, depth=0.8)
write_inverse_operator(fname_inv, inverse_operator)
# Compute inverse solution
snr = 3.0
lambda2 = 1.0 / snr ** 2
for evoked in evokeds:
stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM",
pick_ori=None)
stc.save(op.join(data_path, 'mne_dSPM_inverse-%s' % evoked.comment))
def test_apply_inverse_sphere(evoked):
"""Test applying an inverse with a sphere model (rank-deficient)."""
evoked.pick_channels(evoked.ch_names[:306:8])
evoked.info['projs'] = []
cov = make_ad_hoc_cov(evoked.info)
sphere = make_sphere_model('auto', 'auto', evoked.info)
fwd = read_forward_solution(fname_fwd)
vertices = [fwd['src'][0]['vertno'][::5],
fwd['src'][1]['vertno'][::5]]
stc = SourceEstimate(np.zeros((sum(len(v) for v in vertices), 1)),
vertices, 0., 1.)
fwd = restrict_forward_to_stc(fwd, stc)
fwd = make_forward_solution(evoked.info, fwd['mri_head_t'], fwd['src'],
sphere, mindist=5.)
evoked = EvokedArray(fwd['sol']['data'].copy(), evoked.info)
assert fwd['sol']['nrow'] == 39
assert fwd['nsource'] == 101
assert fwd['sol']['ncol'] == 303
tempdir = _TempDir()
temp_fname = op.join(tempdir, 'temp-inv.fif')
inv = make_inverse_operator(evoked.info, fwd, cov, loose=1.)
# This forces everything to be float32
write_inverse_operator(temp_fname, inv)
inv = read_inverse_operator(temp_fname)
stc = apply_inverse(evoked, inv, method='eLORETA',
method_params=dict(eps=1e-2))
# assert zero localization bias
assert_array_equal(np.argmax(stc.data, axis=0),
np.repeat(np.arange(101), 3))
def test_io_inverse_operator():
"""Test IO of inverse_operator."""
tempdir = _TempDir()
inverse_operator = read_inverse_operator(fname_inv)
x = repr(inverse_operator)
assert (x)
assert (isinstance(inverse_operator['noise_cov'], Covariance))
# just do one example for .gz, as it should generalize
_compare_io(inverse_operator, '.gz')
# test warnings on bad filenames
inv_badname = op.join(tempdir, 'test-bad-name.fif.gz')
with pytest.warns(RuntimeWarning, match='-inv.fif'):
write_inverse_operator(inv_badname, inverse_operator)
with pytest.warns(RuntimeWarning, match='-inv.fif'):
read_inverse_operator(inv_badname)
# make sure we can write and read
inv_fname = op.join(tempdir, 'test-inv.fif')
args = (10, 1. / 9., 'dSPM')
inv_prep = prepare_inverse_operator(inverse_operator, *args)
write_inverse_operator(inv_fname, inv_prep)
inv_read = read_inverse_operator(inv_fname)
_compare(inverse_operator, inv_read)
inv_read_prep = prepare_inverse_operator(inv_read, *args)
_compare(inv_prep, inv_read_prep)
inv_prep_prep = prepare_inverse_operator(inv_prep, *args)
_compare(inv_prep, inv_prep_prep)
def run_inverse(subject, session=None):
print("Processing subject: %s" % subject)
# Construct the search path for the data file. `sub` is mandatory
subject_path = op.join('sub-{}'.format(subject))
# `session` is optional
if session is not None:
subject_path = op.join(subject_path, 'ses-{}'.format(session))
subject_path = op.join(subject_path, config.kind)
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.task,
acquisition=config.acq,
run=None,
processing=config.proc,
recording=config.rec,
space=config.space)
fpath_deriv = op.join(config.bids_root, 'derivatives',
config.PIPELINE_NAME, subject_path)
fname_ave = \
op.join(fpath_deriv, bids_basename + '-ave.fif')
fname_fwd = \
op.join(fpath_deriv, bids_basename + '-fwd.fif')
fname_cov = \
op.join(fpath_deriv, bids_basename + '-cov.fif')
fname_inv = \
op.join(fpath_deriv, bids_basename + '-inv.fif')
evokeds = mne.read_evokeds(fname_ave)
cov = mne.read_cov(fname_cov)
forward = mne.read_forward_solution(fname_fwd)
info = evokeds[0].info
inverse_operator = make_inverse_operator(info,
forward,
cov,
loose=0.2,
depth=0.8)
write_inverse_operator(fname_inv, inverse_operator)
# Apply inverse
snr = 3.0
lambda2 = 1.0 / snr**2
for condition, evoked in zip(config.conditions, evokeds):
stc = apply_inverse(evoked,
inverse_operator,
lambda2,
"dSPM",
pick_ori=None)
stc.save(
op.join(
fpath_deriv, '%s_%s_mne_dSPM_inverse-%s' %
(config.study_name, subject, condition.replace(op.sep, ''))))
def calc_inverse_operator(events_id, epochs_fn, fwd_sub_fn, inv_fn, min_crop_t=None, max_crop_t=0):
for cond in events_id.keys():
epochs = mne.read_epochs(epochs_fn.format(cond=cond))
noise_cov = mne.compute_covariance(epochs.crop(min_crop_t, max_crop_t, copy=True))
forward_sub = mne.read_forward_solution(fwd_sub_fn.format(cond=cond))
inverse_operator_sub = make_inverse_operator(epochs.info, forward_sub, noise_cov,
loose=None, depth=None)
write_inverse_operator(inv_fn.format(cond=cond), inverse_operator_sub)
def run_inverse(subject, session=None):
bids_path = BIDSPath(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=None,
recording=config.rec,
space=config.space,
extension='.fif',
datatype=config.get_datatype(),
root=config.deriv_root,
check=False)
fname_ave = bids_path.copy().update(suffix='ave')
fname_fwd = bids_path.copy().update(suffix='fwd')
fname_cov = bids_path.copy().update(suffix='cov')
fname_inv = bids_path.copy().update(suffix='inv')
evokeds = mne.read_evokeds(fname_ave)
cov = mne.read_cov(fname_cov)
forward = mne.read_forward_solution(fname_fwd)
info = evokeds[0].info
inverse_operator = make_inverse_operator(info,
forward,
cov,
loose=0.2,
depth=0.8,
rank='info')
write_inverse_operator(fname_inv, inverse_operator)
# Apply inverse
snr = 3.0
lambda2 = 1.0 / snr**2
if isinstance(config.conditions, dict):
conditions = list(config.conditions.keys())
else:
conditions = config.conditions
for condition, evoked in zip(conditions, evokeds):
method = config.inverse_method
pick_ori = None
cond_str = config.sanitize_cond_name(condition)
inverse_str = method
hemi_str = 'hemi' # MNE will auto-append '-lh' and '-rh'.
fname_stc = bids_path.copy().update(
suffix=f'{cond_str}+{inverse_str}+{hemi_str}', extension=None)
if "eeg" in config.ch_types:
evoked.set_eeg_reference('average', projection=True)
stc = apply_inverse(evoked=evoked,
inverse_operator=inverse_operator,
lambda2=lambda2,
method=method,
pick_ori=pick_ori)
stc.save(fname_stc)
def run():
args = sys.argv
if len(args) <= 1:
print 'Usage: run_anatomy_tutorial.sh <sample data directory>'
return
sample_dir = args[1]
subjects_dir = join(sample_dir, 'subjects')
meg_dir = join(sample_dir, 'MEG', 'sample')
os.environ['SUBJECTS_DIR'] = subjects_dir
os.environ['MEG_DIR'] = meg_dir
subject = 'sample'
bem = join(subjects_dir, subject, 'bem', 'sample-5120-bem-sol.fif')
mri = join(subjects_dir, subject, 'mri', 'T1.mgz')
fname = join(subjects_dir, subject, 'bem', 'volume-7mm-src.fif')
src = setup_volume_source_space(subject,
fname=fname,
pos=7,
mri=mri,
bem=bem,
overwrite=True,
subjects_dir=subjects_dir)
###############################################################################
# Compute forward solution a.k.a. lead field
raw = mne.io.Raw(join(meg_dir, 'sample_audvis_raw.fif'))
fwd_fname = join(meg_dir, 'sample_audvis-meg-vol-7-fwd.fif')
trans = join(meg_dir, 'sample_audvis_raw-trans.fif')
# for MEG only
fwd = make_forward_solution(raw.info,
trans=trans,
src=src,
bem=bem,
fname=fwd_fname,
meg=True,
eeg=False,
overwrite=True)
# Make a sensitivity map
smap = mne.sensitivity_map(fwd, ch_type='grad', mode='free')
smap.save(join(meg_dir, 'sample_audvis-grad-vol-7-fwd-sensmap'), ftype='w')
###############################################################################
# Compute MNE inverse operators
#
# Note: The MEG/EEG forward solution could be used for all
#
noise_cov = mne.read_cov(join(meg_dir, 'sample_audvis-cov.fif'))
inv = make_inverse_operator(raw.info, fwd, noise_cov)
fname = join(meg_dir, 'sample_audvis-meg-vol-7-meg-inv.fif')
write_inverse_operator(fname, inv)
def run_inverse(subject, session=None):
deriv_path = config.get_subject_deriv_path(subject=subject,
session=session,
kind=config.get_kind())
bids_basename = BIDSPath(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=None,
recording=config.rec,
space=config.space,
prefix=deriv_path,
extension='.fif',
check=False)
fname_ave = bids_basename.copy().update(kind='ave')
fname_fwd = bids_basename.copy().update(kind='fwd')
fname_cov = bids_basename.copy().update(kind='cov')
fname_inv = bids_basename.copy().update(kind='inv')
evokeds = mne.read_evokeds(fname_ave)
cov = mne.read_cov(fname_cov)
forward = mne.read_forward_solution(fname_fwd)
info = evokeds[0].info
inverse_operator = make_inverse_operator(info,
forward,
cov,
loose=0.2,
depth=0.8,
rank='info')
write_inverse_operator(fname_inv, inverse_operator)
# Apply inverse
snr = 3.0
lambda2 = 1.0 / snr**2
for condition, evoked in zip(config.conditions, evokeds):
method = config.inverse_method
pick_ori = None
cond_str = condition.replace(op.sep, '').replace('_', '')
inverse_str = method
hemi_str = 'hemi' # MNE will auto-append '-lh' and '-rh'.
fname_stc = bids_basename.copy().update(
kind=f'{cond_str}+{inverse_str}+{hemi_str}', extension=None)
stc = apply_inverse(evoked=evoked,
inverse_operator=inverse_operator,
lambda2=lambda2,
method=method,
pick_ori=pick_ori)
stc.save(fname_stc)
def run_inverse(subject, session=None):
deriv_path = config.get_subject_deriv_path(subject=subject,
session=session,
kind=config.get_kind())
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=None,
processing=config.proc,
recording=config.rec,
space=config.space)
fname_ave = op.join(deriv_path, bids_basename + '-ave.fif')
fname_fwd = op.join(deriv_path, bids_basename + '-fwd.fif')
fname_cov = op.join(deriv_path, bids_basename + '-cov.fif')
fname_inv = op.join(deriv_path, bids_basename + '-inv.fif')
evokeds = mne.read_evokeds(fname_ave)
cov = mne.read_cov(fname_cov)
forward = mne.read_forward_solution(fname_fwd)
info = evokeds[0].info
inverse_operator = make_inverse_operator(info,
forward,
cov,
loose=0.2,
depth=0.8,
rank='info')
write_inverse_operator(fname_inv, inverse_operator)
# Apply inverse
snr = 3.0
lambda2 = 1.0 / snr**2
for condition, evoked in zip(config.conditions, evokeds):
method = config.inverse_method
pick_ori = None
cond_str = 'cond-%s' % condition.replace(op.sep, '')
inverse_str = 'inverse-%s' % method
hemi_str = 'hemi' # MNE will auto-append '-lh' and '-rh'.
fname_stc = op.join(
deriv_path,
'_'.join([bids_basename, cond_str, inverse_str, hemi_str]))
stc = apply_inverse(evoked=evoked,
inverse_operator=inverse_operator,
lambda2=lambda2,
method=method,
pick_ori=pick_ori)
stc.save(fname_stc)
def mne_inv_operator(self, overwrite=False):
from mne.minimum_norm import (read_inverse_operator,
make_inverse_operator,
write_inverse_operator)
fname = self.subject + '_' + self.experiment + '_mne-inv.fif.gz'
out_fname = op.join(self.out_srcData, fname)
if op.exists(out_fname) and not overwrite:
print('Reading inverse operator from file')
self.inv = read_inverse_operator(out_fname)
else:
self.inv = make_inverse_operator(self.epochs.info, self.fwd,
self.ncov, loose=0.2, depth=0.8)
write_inverse_operator(out_fname, self.inv)
def run_inverse(subject_id):
subject = "sub%03d" % subject_id
print("processing subject: %s" % subject)
data_path = op.join(meg_dir, subject)
fname_ave = op.join(data_path,
'%s_highpass-%sHz-ave.fif' % (subject, l_freq))
fname_cov = op.join(data_path,
'%s_highpass-%sHz-cov.fif' % (subject, l_freq))
fname_fwd = op.join(data_path,
'%s-meg-eeg-%s-fwd.fif' % (subject, spacing))
fname_inv = op.join(
data_path,
'%s_highpass-%sHz-meg-eeg-%s-inv.fif' % (subject, l_freq, spacing))
evokeds = mne.read_evokeds(fname_ave,
condition=[
'scrambled', 'unfamiliar', 'famous',
'faces', 'contrast', 'faces_eq',
'scrambled_eq'
])
cov = mne.read_cov(fname_cov)
forward = mne.read_forward_solution(fname_fwd)
# This will be an MEG-only inverse because the 3-layer BEMs are not
# reliable, so our forward only has MEG channels.
info = evokeds[0].info
inverse_operator = make_inverse_operator(info,
forward,
cov,
loose=0.2,
depth=0.8)
write_inverse_operator(fname_inv, inverse_operator)
# Apply inverse
snr = 3.0
lambda2 = 1.0 / snr**2
for evoked in evokeds:
stc = apply_inverse(evoked,
inverse_operator,
lambda2,
"dSPM",
pick_ori='vector')
stc.save(
op.join(
data_path, 'mne_dSPM_inverse_highpass-%sHz-%s' %
(l_freq, evoked.comment)))
def _compare_io(inv_op, out_file_ext='.fif'):
"""Compare inverse IO."""
tempdir = _TempDir()
if out_file_ext == '.fif':
out_file = op.join(tempdir, 'test-inv.fif')
elif out_file_ext == '.gz':
out_file = op.join(tempdir, 'test-inv.fif.gz')
else:
raise ValueError('IO test could not complete')
out_file = Path(out_file)
# Test io operations
inv_init = copy.deepcopy(inv_op)
write_inverse_operator(out_file, inv_op)
read_inv_op = read_inverse_operator(out_file)
_compare(inv_init, read_inv_op)
_compare(inv_init, inv_op)
def run():
args = sys.argv
if len(args) <= 1:
print 'Usage: run_anatomy_tutorial.sh <sample data directory>'
return
sample_dir = args[1]
subjects_dir = join(sample_dir, 'subjects')
meg_dir = join(sample_dir, 'MEG', 'sample')
os.environ['SUBJECTS_DIR'] = subjects_dir
os.environ['MEG_DIR'] = meg_dir
subject = 'sample'
bem = join(subjects_dir, subject, 'bem', 'sample-5120-bem-sol.fif')
mri = join(subjects_dir, subject, 'mri', 'T1.mgz')
fname = join(subjects_dir, subject, 'bem', 'volume-7mm-src.fif')
src = setup_volume_source_space(subject, fname=fname, pos=7, mri=mri,
bem=bem, overwrite=True,
subjects_dir=subjects_dir)
###############################################################################
# Compute forward solution a.k.a. lead field
raw = mne.io.Raw(join(meg_dir, 'sample_audvis_raw.fif'))
fwd_fname = join(meg_dir, 'sample_audvis-meg-vol-7-fwd.fif')
trans = join(meg_dir, 'sample_audvis_raw-trans.fif')
# for MEG only
fwd = make_forward_solution(raw.info, trans=trans, src=src, bem=bem,
fname=fwd_fname, meg=True, eeg=False,
overwrite=True)
# Make a sensitivity map
smap = mne.sensitivity_map(fwd, ch_type='grad', mode='free')
smap.save(join(meg_dir, 'sample_audvis-grad-vol-7-fwd-sensmap'), ftype='w')
###############################################################################
# Compute MNE inverse operators
#
# Note: The MEG/EEG forward solution could be used for all
#
noise_cov = mne.read_cov(join(meg_dir, 'sample_audvis-cov.fif'))
inv = make_inverse_operator(raw.info, fwd, noise_cov)
fname = join(meg_dir, 'sample_audvis-meg-vol-7-meg-inv.fif')
write_inverse_operator(fname, inv)
def estimate_inverse_solution(info,
noise_cov_mat,
fwd_sol=None,
fname_fwd=None,
fname_inv=None):
""""Estimates inverse solution for the given data set."""
if fwd_sol is not None:
pass
elif fname_fwd is not None:
fwd_sol = mne.read_forward_solution(fname_fwd,
surf_ori=True)
else:
print "ERROR: Neither a forward solution given nor the filename of one!"
sys.exit()
# restrict forward solution as necessary for MEG
fwd = mne.fiff.pick_types_forward(fwd_sol,
meg=True,
eeg=False)
# # regularize noise covariance
# # --> not necessary as the data set to estimate the
# # noise-covariance matrix is quiet long, i.e.
# # the noise-covariance matrix is robust
# noise_cov_mat = mne.cov.regularize(noise_cov_mat,
# info,
# mag=0.1,
# proj=True,
# verbose=verbose)
# create the MEG inverse operators
print ">>>> estimate inverse operator..."
inverse_operator = min_norm.make_inverse_operator(info,
fwd,
noise_cov_mat,
loose=0.2,
depth=0.8)
if fname_inv is not None:
min_norm.write_inverse_operator(fname_inv, inverse_operator)
return inverse_operator
def inverse_function(sub_id, session):
""" Will calculate the inverse model based dSPM
"""
data_path = "/media/mje/My_Book/Data/MEG/MEG_libet/sub_2_tests"
fname = "sub_%d_%s_tsss_mc" % (sub_id, session)
fname_epochs = data_path + fname + "_epochs.fif"
fname_fwd_meg = data_path + fname + "_fwd.fif"
fname_cov = data_path + fname + "_cov.fif"
fname_inv = data_path + fname + "_inv.fif"
fname_stcs = fname + "_mne_dSPM_inverse"
epochs = mne.read_epochs(fname_epochs)
evoked = epochs.average()
snr = 3.0
lambda2 = 1.0 / snr ** 2
# Load data
forward_meg = mne.read_forward_solution(fname_fwd_meg, surf_ori=True)
noise_cov = mne.read_cov(fname_cov)
# regularize noise covariance
noise_cov = mne.cov.regularize(noise_cov, evoked.info,
mag=0.05, grad=0.05, eeg=0.1, proj=True)
# Restrict forward solution as necessary for MEG
forward_meg = mne.fiff.pick_types_forward(forward_meg, meg=True, eeg=False)
# make an M/EEG, MEG-only, and EEG-only inverse operators
info = evoked.info
inverse_operator_meg = make_inverse_operator(info, forward_meg, noise_cov,
loose=0.2, depth=0.8)
write_inverse_operator(fname_inv, inverse_operator_meg)
# Compute inverse solution
stc = apply_inverse(evoked, inverse_operator_meg, lambda2, "dSPM",
pick_normal=False)
# Save result in stc files
stc.save(fname_stcs)
def apply_inverse_ave(fnevo, subjects_dir):
''' Make individual inverse operator.
Parameter
---------
fnevo: string or list
The evoked file with ECG, EOG and environmental noise free.
subjects_dir: The total bath of all the subjects.
'''
from mne import make_forward_solution
from mne.minimum_norm import make_inverse_operator, write_inverse_operator
fnlist = get_files_from_list(fnevo)
# loop across all filenames
for fname in fnlist:
fn_path = os.path.split(fname)[0]
name = os.path.basename(fname)
subject = name.split('_')[0]
fn_inv = fn_path + '/%s_fibp1-45,ave-inv.fif' % subject
subject_path = subjects_dir + '/%s' % subject
fn_trans = fn_path + '/%s-trans.fif' % subject
fn_cov = fn_path + '/%s_empty,fibp1-45-cov.fif' % subject
fn_src = subject_path + '/bem/%s-ico-5-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
[evoked] = mne.read_evokeds(fname)
evoked.pick_types(meg=True, ref_meg=False)
noise_cov = mne.read_cov(fn_cov)
# noise_cov = dSPM.cov.regularize(noise_cov, evoked.info,
# mag=0.05, grad=0.05, proj=True)
fwd = make_forward_solution(evoked.info, fn_trans, fn_src, fn_bem)
fwd['surf_ori'] = True
inv = make_inverse_operator(evoked.info,
fwd,
noise_cov,
loose=0.2,
depth=0.8,
limit_depth_chs=False)
write_inverse_operator(fn_inv, inv)
def estimate_inverse_solution(info,
noise_cov_mat,
fwd_sol=None,
fname_fwd=None,
fname_inv=None):
""""Estimates inverse solution for the given data set."""
if fwd_sol is not None:
pass
elif fname_fwd is not None:
fwd_sol = mne.read_forward_solution(fname_fwd, surf_ori=True)
else:
print "ERROR: Neither a forward solution given nor the filename of one!"
sys.exit()
# restrict forward solution as necessary for MEG
fwd = mne.fiff.pick_types_forward(fwd_sol, meg=True, eeg=False)
# # regularize noise covariance
# # --> not necessary as the data set to estimate the
# # noise-covariance matrix is quiet long, i.e.
# # the noise-covariance matrix is robust
# noise_cov_mat = mne.cov.regularize(noise_cov_mat,
# info,
# mag=0.1,
# proj=True,
# verbose=verbose)
# create the MEG inverse operators
print ">>>> estimate inverse operator..."
inverse_operator = min_norm.make_inverse_operator(info,
fwd,
noise_cov_mat,
loose=0.2,
depth=0.8)
if fname_inv is not None:
min_norm.write_inverse_operator(fname_inv, inverse_operator)
return inverse_operator
def _calc_inverse(params):
subject, epochs, overwrite = params
epo = op.join(REMOTE_ROOT_DIR, 'ave', '{}_ecr_nTSSS_conflict-epo.fif'.format(subject))
fwd = op.join(REMOTE_ROOT_DIR, 'fwd', '{}_ecr-fwd.fif'.format(subject))
local_inv_file_name = op.join(LOCAL_ROOT_DIR, 'inv', '{}_ecr_nTSSS_conflict-inv.fif'.format(subject))
if os.path.isfile(local_inv_file_name) and not overwrite:
inverse_operator = read_inverse_operator(local_inv_file_name)
print('inv already calculated for {}'.format(subject))
else:
if epochs is None:
epochs = mne.read_epochs(epo)
noise_cov = mne.compute_covariance(epochs.crop(None, 0, copy=True))
inverse_operator = None
if not os.path.isfile(fwd):
print('no fwd for {}'.format(subject))
else:
forward = mne.read_forward_solution(fwd)
inverse_operator = make_inverse_operator(epochs.info, forward, noise_cov,
loose=None, depth=None)
write_inverse_operator(local_inv_file_name, inverse_operator)
return inverse_operator
def apply_inverse_oper(fnepo, tmin=-0.2, tmax=0.8, subjects_dir=None):
'''
Apply inverse operator
Parameter
---------
fnepo: string or list
The epochs file with ECG, EOG and environmental noise free.
tmax, tmax:float
The time period (second) of each epoch.
'''
# Get the default subjects_dir
from mne import make_forward_solution
from mne.minimum_norm import make_inverse_operator, write_inverse_operator
fnlist = get_files_from_list(fnepo)
# loop across all filenames
for fname in fnlist:
fn_path = os.path.split(fname)[0]
name = os.path.basename(fname)
subject = name.split('_')[0]
subject_path = subjects_dir + '/%s' % subject
fn_trans = fn_path + '/%s-trans.fif' % subject
fn_cov = fn_path + '/%s_empty-cov.fif' % subject
fn_src = subject_path + '/bem/%s-oct-6-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
fn_inv = fn_path + '/%s_epo-inv.fif' % subject
epochs = mne.read_epochs(fname)
epochs.crop(tmin, tmax)
epochs.pick_types(meg=True, ref_meg=False)
noise_cov = mne.read_cov(fn_cov)
fwd = make_forward_solution(epochs.info, fn_trans, fn_src, fn_bem)
fwd['surf_ori'] = True
inv = make_inverse_operator(epochs.info, fwd, noise_cov, loose=0.2,
depth=0.8, limit_depth_chs=False)
write_inverse_operator(fn_inv, inv)
def apply_inverse_ave(fnevo, subjects_dir):
''' Make individual inverse operator.
Parameter
---------
fnevo: string or list
The evoked file with ECG, EOG and environmental noise free.
subjects_dir: The total bath of all the subjects.
'''
from mne import make_forward_solution
from mne.minimum_norm import make_inverse_operator, write_inverse_operator
fnlist = get_files_from_list(fnevo)
# loop across all filenames
for fname in fnlist:
fn_path = os.path.split(fname)[0]
name = os.path.basename(fname)
subject = name.split('_')[0]
fn_inv = fn_path + '/%s_fibp1-45,ave-inv.fif' % subject
subject_path = subjects_dir + '/%s' % subject
fn_trans = fn_path + '/%s-trans.fif' % subject
fn_cov = fn_path + '/%s_empty,fibp1-45-cov.fif' % subject
fn_src = subject_path + '/bem/%s-oct-6-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
[evoked] = mne.read_evokeds(fname)
evoked.pick_types(meg=True, ref_meg=False)
noise_cov = mne.read_cov(fn_cov)
# noise_cov = mne.cov.regularize(noise_cov, evoked.info,
# mag=0.05, grad=0.05, proj=True)
fwd = make_forward_solution(evoked.info, fn_trans, fn_src, fn_bem)
fwd['surf_ori'] = True
inv = make_inverse_operator(evoked.info, fwd, noise_cov, loose=0.2,
depth=0.8, limit_depth_chs=False)
write_inverse_operator(fn_inv, inv)
def test_channel_name_limit(tmp_path, monkeypatch, fname):
"""Test that our remapping works properly."""
#
# raw
#
if fname.endswith('fif'):
raw = read_raw_fif(fname)
raw.pick_channels(raw.ch_names[:3])
ref_names = []
data_names = raw.ch_names
else:
assert fname.endswith('.ds')
raw = read_raw_ctf(fname)
ref_names = [
raw.ch_names[pick]
for pick in pick_types(raw.info, meg=False, ref_meg=True)
]
data_names = raw.ch_names[32:35]
proj = dict(data=np.ones((1, len(data_names))),
col_names=data_names[:2].copy(),
row_names=None,
nrow=1)
proj = Projection(data=proj,
active=False,
desc='test',
kind=0,
explained_var=0.)
raw.add_proj(proj, remove_existing=True)
raw.info.normalize_proj()
raw.pick_channels(data_names + ref_names).crop(0, 2)
long_names = ['123456789abcdefg' + name for name in raw.ch_names]
fname = tmp_path / 'test-raw.fif'
with catch_logging() as log:
raw.save(fname)
log = log.getvalue()
assert 'truncated' not in log
rename = dict(zip(raw.ch_names, long_names))
long_data_names = [rename[name] for name in data_names]
long_proj_names = long_data_names[:2]
raw.rename_channels(rename)
for comp in raw.info['comps']:
for key in ('row_names', 'col_names'):
for name in comp['data'][key]:
assert name in raw.ch_names
if raw.info['comps']:
assert raw.compensation_grade == 0
raw.apply_gradient_compensation(3)
assert raw.compensation_grade == 3
assert len(raw.info['projs']) == 1
assert raw.info['projs'][0]['data']['col_names'] == long_proj_names
raw.info['bads'] = bads = long_data_names[2:3]
good_long_data_names = [
name for name in long_data_names if name not in bads
]
with catch_logging() as log:
raw.save(fname, overwrite=True, verbose=True)
log = log.getvalue()
assert 'truncated to 15' in log
for name in raw.ch_names:
assert len(name) > 15
# first read the full way
with catch_logging() as log:
raw_read = read_raw_fif(fname, verbose=True)
log = log.getvalue()
assert 'Reading extended channel information' in log
for ra in (raw, raw_read):
assert ra.ch_names == long_names
assert raw_read.info['projs'][0]['data']['col_names'] == long_proj_names
del raw_read
# next read as if no longer names could be read
monkeypatch.setattr(meas_info, '_read_extended_ch_info',
lambda x, y, z: None)
with catch_logging() as log:
raw_read = read_raw_fif(fname, verbose=True)
log = log.getvalue()
assert 'extended' not in log
if raw.info['comps']:
assert raw_read.compensation_grade == 3
raw_read.apply_gradient_compensation(0)
assert raw_read.compensation_grade == 0
monkeypatch.setattr( # restore
meas_info, '_read_extended_ch_info', _read_extended_ch_info)
short_proj_names = [
f'{name[:13 - bool(len(ref_names))]}-{len(ref_names) + ni}'
for ni, name in enumerate(long_data_names[:2])
]
assert raw_read.info['projs'][0]['data']['col_names'] == short_proj_names
#
# epochs
#
epochs = Epochs(raw, make_fixed_length_events(raw))
fname = tmp_path / 'test-epo.fif'
epochs.save(fname)
epochs_read = read_epochs(fname)
for ep in (epochs, epochs_read):
assert ep.info['ch_names'] == long_names
assert ep.ch_names == long_names
del raw, epochs_read
# cov
epochs.info['bads'] = []
cov = compute_covariance(epochs, verbose='error')
fname = tmp_path / 'test-cov.fif'
write_cov(fname, cov)
cov_read = read_cov(fname)
for co in (cov, cov_read):
assert co['names'] == long_data_names
assert co['bads'] == []
del cov_read
#
# evoked
#
evoked = epochs.average()
evoked.info['bads'] = bads
assert evoked.nave == 1
fname = tmp_path / 'test-ave.fif'
evoked.save(fname)
evoked_read = read_evokeds(fname)[0]
for ev in (evoked, evoked_read):
assert ev.ch_names == long_names
assert ev.info['bads'] == bads
del evoked_read, epochs
#
# forward
#
with _record_warnings(): # not enough points for CTF
sphere = make_sphere_model('auto', 'auto', evoked.info)
src = setup_volume_source_space(
pos=dict(rr=[[0, 0, 0.04]], nn=[[0, 1., 0.]]))
fwd = make_forward_solution(evoked.info, None, src, sphere)
fname = tmp_path / 'temp-fwd.fif'
write_forward_solution(fname, fwd)
fwd_read = read_forward_solution(fname)
for fw in (fwd, fwd_read):
assert fw['sol']['row_names'] == long_data_names
assert fw['info']['ch_names'] == long_data_names
assert fw['info']['bads'] == bads
del fwd_read
#
# inv
#
inv = make_inverse_operator(evoked.info, fwd, cov)
fname = tmp_path / 'test-inv.fif'
write_inverse_operator(fname, inv)
inv_read = read_inverse_operator(fname)
for iv in (inv, inv_read):
assert iv['info']['ch_names'] == good_long_data_names
apply_inverse(evoked, inv) # smoke test
fwd = make_forward_solution(raw_crop.info,
trans=trans,
src=src,
bem=bem,
meg=True,
eeg=False,
mindist=0.0,
n_jobs=3)
write_forward_solution(fwdFile, fwd, overwrite=True)
else:
fwd = read_forward_solution(fwdFile)
# Make (or read) inverse operator
if not op.isfile(invFile) or overwrite_pre:
inv = make_inverse_operator(raw_crop.info, fwd, noise_cov)
write_inverse_operator(invFile, inv)
else:
inv = read_inverse_operator(invFile)
# Do source recon
t0 = time.time()
stc_dSPM = apply_inverse_raw(raw_crop, inv, lambda2, method="dSPM")
# stc_MNE = apply_inverse_raw(raw_crop, inv, lambda2, method="MNE")
dt = time.time() - t0
print('Time elapsed: ' + str(dt / 60.0) + ' min')
# Save
stc_dSPM.save(outFile_dSPM)
# stc_MNE.save(outFile_MNE)
#END
fwd20,
noise_cov30,
loose=0.2,
depth=0.8)
inverse_operator30 = make_inverse_operator(info30,
fwd30,
noise_cov30,
loose=0.2,
depth=0.8)
inverse_operator40 = make_inverse_operator(info40,
fwd40,
noise_cov40,
loose=0.2,
depth=0.8)
write_inverse_operator(inv20_fname, inverse_operator20)
write_inverse_operator(inv30_fname, inverse_operator30)
write_inverse_operator(inv40_fname, inverse_operator40)
method = "dSPM"
snr = 1.
lambda2 = 1. / snr**2
stc40 = apply_inverse(evoked40,
inverse_operator40,
lambda2,
method=method,
pick_ori=None)
stc30 = apply_inverse(evoked30,
inverse_operator30,
lambda2,
noise_cov = mne.compute_covariance(epochs, tmax=0.,
method=['shrunk', 'empirical'])
fig_cov, fig_spectra = mne.viz.plot_cov(noise_cov, raw.info)
name_temp = data_evoked_directory + bloc + '/' + nip + '/' + stimulus + '_noise-cov.fif'
noise_cov.save(name_temp)
###################################################################
###################### Make inverse operator ######################
###################################################################
# Load forward solution
fname = data_forward_directory + nip + '/FM_trans_sss_MEG-ico5-fwd.fif'
fwd = mne.read_forward_solution(fname, surf_ori=True)
fwd = mne.pick_types_forward(fwd, meg=True, eeg=False)
# Compute inverse operator
info = evoked.info
inverse_operator = make_inverse_operator(info, fwd, noise_cov,
loose=0.2, depth=0.8)
# Save inverse operator
name_temp = data_evoked_directory + bloc + '/' + nip + '/' + stimulus + '-inv.fif'
write_inverse_operator(name_temp, inverse_operator)
# Save HTML report
report.save(os.getcwd() + '/2_buildEvokedPerBlock.html', overwrite=True,
open_browser=False)
def aud_dataset(self):
print 'Treat: ', self.treat
###############################################################################
# Setup for reading the raw data
data_path = sample.data_path()
raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif'
event_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif'
tmin = -0.2 # start of each epoch (200ms before the trigger)
tmax = 0.5 # end of each epoch (500ms after the trigger)
self.subject='sample'
raw = mne.io.read_raw_fif(raw_fname, add_eeg_ref=False, preload=True,verbose=False)
#raw.set_eeg_reference() # set EEG average reference
baseline = (None, 0) # means from the first instant to t = 0
reject = dict(mag=4e-12, eog=150e-6)
events = mne.read_events(event_fname)
picks = mne.pick_types(raw.info, meg='mag', eeg=True, eog=True,
exclude='bads') #for simplicity ignore grad channels
raw.rename_channels(mapping={'EOG 061': 'EOG'})
event_id = {'left/auditory': 1, 'right/auditory': 2,
'left/visual': 3, 'right/visual': 4}
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks,
baseline=baseline, reject=reject, add_eeg_ref=False, preload=True,verbose=False)
if self.treat is not None:
self.epochs_eeg = epochs[self.treat].copy().pick_types(eeg=True,meg=False)
self.epochs_meg = epochs[self.treat].copy().pick_types(meg=True,eeg=False)
else:
self.epochs_eeg = epochs.copy().pick_types(eeg=True,meg=False)
self.epochs_meg = epochs.copy().pick_types(meg=True,eeg=False)
noise_cov = mne.compute_covariance(
epochs, tmax=0., method=['shrunk', 'empirical'],verbose=False)
###############################################################################
# Inverse modeling: MNE/dSPM on evoked and raw data
# -------------------------------------------------
# Read the forward solution and compute the inverse operator
fname_fwd = data_path + '/MEG/sample/sample_audvis-meg-oct-5-fwd.fif'
fwd = mne.read_forward_solution(fname_fwd, surf_ori=True,verbose=False)
# Restrict forward solution as necessary
fwd = mne.pick_types_forward(fwd, meg=True, eeg=True)
# make an inverse operator
info = epochs.info
inverse_operator = make_inverse_operator(info, fwd, noise_cov,
loose=0.2, depth=0.8,verbose=False)
write_inverse_operator('sample_audvis-meg-oct-5-inv.fif',
inverse_operator,verbose=False)
###############################################################################
# Compute inverse solution
# ------------------------
method = "MNE"
snr = 3.
lambda2 = 1. / snr ** 2
if self.treat is not None:
self.stc = apply_inverse_epochs(epochs[self.treat], inverse_operator, lambda2,
method=method, pick_ori=None,verbose=False)
else:
self.stc = apply_inverse_epochs(epochs, inverse_operator, lambda2,
method=method, pick_ori=None,verbose=False)
if self.Wt is None:
print 'Precalculate PCA weights:'
#weight PCA matrix. Uses 'self.treat' - so to apply across all treatments, use treat=None
self.Wt=Wt_calc(self.stc,self.epochs_eeg,self.epochs_meg)
#stc.save('sample_audvis-source-epochs')
self.prepro()
snr = 3.0
lambda2 = 1.0 / snr ** 2
# Load data
evoked = Evoked(fname_evoked, setno=0, baseline=(None, 0))
forward = mne.read_forward_solution(fname_fwd, surf_ori=True)
noise_cov = mne.read_cov(fname_cov)
# regularize noise covariance
noise_cov = mne.cov.regularize(noise_cov, evoked.info, mag=0.05, grad=0.05, eeg=0.1, proj=True)
inverse_operator = make_inverse_operator(evoked.info, forward, noise_cov, loose=0.2, depth=0.8)
# Save inverse operator to vizualize with mne_analyze
write_inverse_operator("sample_audvis-eeg-oct-6-eeg-inv.fif", inverse_operator)
# Compute inverse solution
stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM", pick_normal=False)
# Save result in stc files
stc.save("mne_dSPM_inverse")
###############################################################################
# View activation time-series
pl.close("all")
pl.plot(1e3 * stc.times, stc.data[::150, :].T)
pl.xlabel("time (ms)")
pl.ylabel("dSPM value")
pl.show()
# for evoked data use noise cov based on epochs, however,
# if there is no baseline, e.g., in resting state data
# there is no stimulus, use empty room noise cov
fn_cov = fn_epo.split('-epo.fif')[0] + '-cov.fif'
fn_inv = fn_epo.rsplit('-epo.fif')[0] + '-inv.fif'
# to read forward solution and noise_cov
noise_cov = mne.read_cov(fn_cov)
if not op.isfile(fn_inv):
# compute the inverse operator (mne_do_inverse_operator)
inv = make_inverse_operator(epochs.info, fwd, noise_cov, loose=0.2,
depth=0.8, limit_depth_chs=False)
write_inverse_operator(fn_inv, inv)
else:
inv = read_inverse_operator(fn_inv)
evoked = epochs.average()
# Compute inverse solution for evoked data
fn_stc = fn_epo.rsplit('-epo.fif')[0] + ',ave'
if not op.isfile(fn_stc + '-lh.stc'):
stc = apply_inverse(evoked, inv, lambda2, method, pick_ori=None)
stc.save(fn_stc)
print('Saved...', fn_stc + '-lh.stc')
if plot_stc:
def run():
args = sys.argv
if len(args) <= 1:
print 'Usage: run_meg_tutorial.sh <sample data directory>'
return
sample_dir = args[1]
subjects_dir = join(sample_dir, 'subjects')
meg_dir = join(sample_dir, 'MEG', 'sample')
os.environ['SUBJECTS_DIR'] = subjects_dir
os.environ['MEG_DIR'] = meg_dir
subject = 'sample'
src = setup_source_space(subject, fname=True, spacing='oct6', n_jobs=2,
overwrite=True)
# If one wanted to use other source spaces, these types of options are
# available
src_fsaverage = setup_source_space('fsaverage', fname=True, spacing='ico5',
n_jobs=2, overwrite=True,
add_dist=False)
morph_source_spaces(src_fsaverage, subject_to='sample')
setup_source_space(subject, fname=True, spacing='all', overwrite=True,
n_jobs=2, add_dist=False)
# Add distances to source space (if desired, takes a long time)
bem_dir = join(subjects_dir, join('sample', 'bem'))
os.rename(join(bem_dir, 'sample-oct-6-src.fif'),
join(bem_dir, 'sample-oct-6-orig-src.fif'))
new_src = add_source_space_distances(src, dist_limit=0.007)
new_src.save(join(bem_dir, 'sample-oct-6-src.fif'))
# Preprocessing
raw = mne.io.Raw(join(meg_dir, 'sample_audvis_raw.fif'), preload=True)
raw.info['bads'] = ['MEG 2443', 'EEG 053']
reject = dict(grad=3000e-13, mag=4000e-15, eeg=100e-6)
ecg_proj, _ = mne.preprocessing.compute_proj_ecg(raw, l_freq=1, h_freq=100,
ch_name='MEG 1531',
reject=reject)
eog_proj, _ = mne.preprocessing.compute_proj_eog(raw, l_freq=1, h_freq=35,
reject=reject,
no_proj=True)
events = mne.find_events(raw)
mne.write_events(join(meg_dir, 'sample_audvis_raw-eve.fif'), events)
event_id = [1, 2, 3, 4]
tmin, tmax = -0.2, 0.5
picks = mne.pick_types(raw.info, meg=True, eeg=True, stim=True, eog=True)
# Average with no filter
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks)
evoked = epochs.average()
evoked.save(join(meg_dir, 'sample_audvis-no-filter-ave.fif'))
raw.filter(l_freq=None, h_freq=40)
raw_resampled = raw.resample(150)
raw_resampled.save(join(meg_dir, 'sample_audvis_filt-0-40_raw.fif'),
overwrite=True)
raw.add_proj(ecg_proj)
raw.add_proj(eog_proj)
resampled_events = mne.find_events(raw_resampled)
mne.write_events(join(meg_dir, 'sample_audvis_filt-0-40_raw-eve.fif'),
resampled_events)
# Average with filter
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks)
evoked = epochs.average()
evoked.save(join(meg_dir, 'sample_audvis-ave.fif'))
# Compute the noise covariance matrix
noise_cov = mne.compute_raw_data_covariance(raw, picks=picks)
noise_cov.save(join(meg_dir, 'audvis.cov'))
# Compute the empty-room noise covariance matrix
ernoise_raw = mne.io.Raw(join(meg_dir, 'ernoise_raw.fif'), preload=True)
ernoise_raw.info['bads'] = ['MEG 2443']
ernoise_raw.filter(l_freq=None, h_freq=40)
picks = mne.pick_types(ernoise_raw.info, meg=True, eeg=True, stim=True,
eog=True)
ernoise_cov = mne.compute_raw_data_covariance(ernoise_raw, picks=picks)
ernoise_cov.save(join(meg_dir, 'ernoise.cov'))
###############################################################################
# Compute forward solution a.k.a. lead field
trans = join(meg_dir, 'sample_audvis_raw-trans.fif')
bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-bem-sol.fif')
# for MEG only
fname = join(meg_dir, 'sample_audvis-meg-oct-6-fwd.fif')
fwd_meg = mne.make_forward_solution(raw.info, trans, src, bem,
fname=fname, meg=True, eeg=False,
mindist=5.0, n_jobs=2, overwrite=True)
# for EEG only
bem = join(subjects_dir, 'sample', 'bem',
'sample-5120-5120-5120-bem-sol.fif')
fname = join(meg_dir, 'sample_audvis-eeg-oct-6-fwd.fif')
fwd_eeg = mne.make_forward_solution(raw.info, trans, src, bem,
fname=fname, meg=False, eeg=True,
mindist=5.0, n_jobs=2, overwrite=True)
# for both EEG and MEG
fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-fwd.fif')
fwd = mne.make_forward_solution(raw.info, trans, src, bem,
fname=fname, meg=True, eeg=True,
mindist=5.0, n_jobs=2, overwrite=True)
# Create various sensitivity maps
grad_map = mne.sensitivity_map(fwd, ch_type='grad', mode='free')
grad_map.save(join(meg_dir, 'sample_audvis-grad-oct-6-fwd-sensmap'),
ftype='w')
mag_map = mne.sensitivity_map(fwd, ch_type='mag', mode='free')
mag_map.save(join(meg_dir, 'sample_audvis-mag-oct-6-fwd-sensmap'),
ftype='w')
eeg_map = mne.sensitivity_map(fwd, ch_type='eeg', mode='free')
eeg_map.save(join(meg_dir, 'sample_audvis-eeg-oct-6-fwd-sensmap'),
ftype='w')
grad_map2 = mne.sensitivity_map(fwd, ch_type='grad', mode='fixed')
grad_map2.save(join(meg_dir, 'sample_audvis-grad-oct-6-fwd-sensmap-2'),
ftype='w')
mag_map2 = mne.sensitivity_map(fwd, ch_type='mag', mode='ratio')
mag_map2.save(join(meg_dir, 'sample_audvis-mag-oct-6-fwd-sensmap-3'),
ftype='w')
# Compute some with the EOG + ECG projectors
projs = ecg_proj + eog_proj + raw.info['projs']
for map_type in ['radiality', 'angle', 'remaining', 'dampening']:
eeg_map = mne.sensitivity_map(fwd, projs=projs, ch_type='eeg',
mode=map_type)
eeg_map.save(join(meg_dir,
'sample_audvis-eeg-oct-6-fwd-sensmap-' + map_type))
###############################################################################
# Compute MNE inverse operators
#
# Note: The MEG/EEG forward solution could be used for all
#
inv_meg = make_inverse_operator(raw.info, fwd_meg, noise_cov, loose=0.2)
fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-inv.fif')
write_inverse_operator(fname, inv_meg)
inv_eeg = make_inverse_operator(raw.info, fwd_eeg, noise_cov, loose=0.2)
fname = join(meg_dir, 'sample_audvis-eeg-oct-6-eeg-inv.fif')
write_inverse_operator(fname, inv_eeg)
inv = make_inverse_operator(raw.info, fwd, noise_cov, loose=0.2)
fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-meg-eeg-inv.fif')
write_inverse_operator(fname, inv)
# inverse operator with fixed orientation (for testing). Not implemented
#inv_fixed = make_inverse_operator(raw.info, fwd_meg, noise_cov,
# depth=None, fixed=True)
#fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-nodepth-fixed-inv.fif')
#write_inverse_operator(fname, inv_fixed)
# produce two with diagonal noise (for testing)
diag = noise_cov.as_diag()
inv_meg_diag = make_inverse_operator(raw.info, fwd_meg, diag, loose=0.2)
fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-diagnoise-inv.fif')
write_inverse_operator(fname, inv_meg_diag)
inv_eeg_diag = make_inverse_operator(raw.info, fwd, diag, loose=0.2)
fname = join(meg_dir,
'sample_audvis-meg-eeg-oct-6-meg-eeg-diagnoise-inv.fif')
write_inverse_operator(fname, inv_eeg_diag)
# Produce stc files
evoked.crop(0, 0.25)
stc_meg = apply_inverse(evoked, inv_meg, method='MNE')
stc_meg.save(join(meg_dir, 'sample_audvis-meg'))
stc_eeg = apply_inverse(evoked, inv_eeg, method='MNE')
stc_eeg.save(join(meg_dir, 'sample_audvis-eeg'))
stc = apply_inverse(evoked, inv, method='MNE')
stc.save(join(meg_dir, 'sample_audvis-meg-eeg'))
# let's also morph to fsaverage
stc_to = stc_meg.morph('fsaverage', grade=3, smooth=12)
stc_to.save(join(meg_dir, 'fsaverage_audvis-meg'))
stc_to = stc_eeg.morph('fsaverage', grade=3, smooth=12)
stc_to.save(join(meg_dir, 'fsaverage_audvis-eeg'))
stc_to = stc.morph('fsaverage', grade=3, smooth=12)
stc_to.save(join(meg_dir, 'fsaverage_audvis-meg-eeg'))
###############################################################################
# Do one dipole fitting
evoked = evoked.pick_types(meg=True, eeg=False)
evoked.crop(0.04, 0.095)
bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-bem-sol.fif')
dip, _ = mne.fit_dipole(evoked, noise_cov, bem, trans)
dip.save(join(meg_dir, 'sample_audvis_set1.dip'))
def EpochAndAverage_eq(condnames,datasource,ListSubj,listRunPerSubj,EEGbadlist,nbtrial,LKMEG,LKEEG,LKMEEG):
#ipython --pylab
import mne
import matplotlib.pyplot as pl
import numpy as np
import random
from scipy import io
from copy import deepcopy
import os
os.chdir('/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/SCRIPTS/MNE_PYTHON')
import MatchEventsFT2MNE as match
import time
from mne.minimum_norm import (make_inverse_operator, apply_inverse, write_inverse_operator)
os.environ['SUBJECTS_DIR'] = '/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/mri'
os.environ['MNE_ROOT'] = '/neurospin/local/mne'
wdir = "/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/"
#wdir = "/media/bgauthie/Seagate Backup Plus Drive/TMP_MEG_SOURCE/MEG/"
for i in range(len(ListSubj)):
# open a text logfile
logfile = open(wdir+ListSubj[i]+"/mne_python/logfile_preproc.txt", "w")
logfile.write(time.strftime("%d/%m/%Y")+"\n")
logfile.write(time.strftime("%H:%M:%S")+"\n")
fname_fwd_eeg = (wdir+ListSubj[i]+"/mne_python/run3_ico-5_eegonly_-fwd.fif")
fname_fwd_meg = (wdir+ListSubj[i]+"/mne_python/run3_ico-5_megonly_-fwd.fif")
fname_fwd_meeg = (wdir+ListSubj[i]+"/mne_python/run3_ico-5_meeg_-fwd.fif")
for j in range(len(listRunPerSubj[i])):
print(j)
print(i)
# load trans_sss data
raw = mne.io.Raw(wdir+ListSubj[i]+"/mne_python/preproc_"+listRunPerSubj[i][j]+"_trans_sss_raw.fif", preload = True)
# band-pass filter 1-35Hz
raw.filter(l_freq = 1, h_freq=35, method = 'iir',n_jobs=3)
# Specify bad channels
raw.info['bads'] += EEGbadlist[i]
# define events : import trial definition from fieldtrip and with mne_function
tmp = str(j+1)
fileE = io.loadmat("/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/From_laptop/Subjects/"+ListSubj[i]+"/PsychData/events"+tmp+".mat")
eventsFT = fileE['fullsubj']
eventsMNE = mne.find_events(raw, stim_channel=['STI101'],consecutive = False)
print "%d events found" %len(eventsMNE)
logfile.write("" "\n")
logfile.write("processing subject " +ListSubj[i]+""+listRunPerSubj[i][j]+"\n")
logfile.write("%d mne events found " %len(eventsMNE)+"\n")
logfile.write("%d ft events found " %len(eventsFT)+"\n")
logfile.write("" "\n")
# find events corresponding to FT run j
itemindex = np.where(eventsFT[:,7]==(j+1))
eventsFT = eventsFT[itemindex[0],:]
# set the "zero point" to a target event in MNE event (Ft to MNE sample matching strategy, because different zero time convention))
initsampmne = eventsMNE[np.where(eventsMNE[:,2] == 18)[0][0],0]
for l in range(eventsMNE.shape[0]):
eventsMNE[l,0] = eventsMNE[l,0] - initsampmne
# set the "zero point" to a target event in FT event
initsampft = eventsFT[np.where(eventsFT[:,6] == 18)[0][0],0]
for l in range(eventsFT.shape[0]):
eventsFT[l,0] = eventsFT[l,0] - initsampft
# Select original event before recoding according to the condition and the source dataset
if datasource == 'EVT':
origevent = [16,20,24,28,32,17,21,25,29,33]
# find events corresponding to "Historical events" stimuli
init = np.where(eventsFT[:,6]== origevent[0])
for k in origevent[1:]:
init = np.append(init,np.where(eventsFT[:,6]== k)[0])
eventsFT = eventsFT[init,:]
del init
elif datasource == 'EVS':
origevent = [18,22,26,30,34,19,23,27,31,35]
# find events corresponding to "Historical events" stimuli
init = np.where(eventsFT[:,6]== origevent[0])
for k in origevent[1:]:
init = np.append(init,np.where(eventsFT[:,6]== k)[0])
eventsFT = eventsFT[init,:]
del init
elif datasource == 'QTT':
origevent = [6,8,10,12,14]
# find events corresponding to "Historical events" stimuli
init = np.where(eventsFT[:,6]== origevent[0])
for k in origevent[1:]:
init = np.append(init,np.where(eventsFT[:,6]== k)[0])
eventsFT = eventsFT[init,:]
del init
elif datasource == 'QTS':
origevent = [7,9,11,13,15]
# find events corresponding to "Historical events" stimuli
init = np.where(eventsFT[:,6]== origevent[0])
for k in origevent[1:]:
init = np.append(init,np.where(eventsFT[:,6]== k)[0])
eventsFT = eventsFT[init,:]
del init
# reject bad data based on fieldtrip "ft_rejectvisual"
good_meg = np.where(eventsFT[:,8]== 1)
good_eeg = np.where(eventsFT[:,9]== 1)
good_meeg = np.where(np.multiply(eventsFT[:,8],eventsFT[:,9])==1)
eventsFT_meg = eventsFT[good_meg[0],:]
eventsFT_eeg = eventsFT[good_eeg[0],:]
eventsFT_meeg = eventsFT[good_meeg[0],:]
# get the FT event in MNE events (should be the same but a small sample of events isn't matched
# (FIXME)
SelEve_meg = match.MatchEventsFT2MNE(eventsMNE,eventsFT_meg)
SelEve_eeg = match.MatchEventsFT2MNE(eventsMNE,eventsFT_eeg)
SelEve_meeg = match.MatchEventsFT2MNE(eventsMNE,eventsFT_meeg)
# get back to the original timing
for m in range(SelEve_meg.shape[0]):
SelEve_meg[m,0] = SelEve_meg[m,0] + initsampmne
for n in range(SelEve_eeg.shape[0]):
SelEve_eeg[n,0] = SelEve_eeg[n,0] + initsampmne
for k in range(SelEve_meeg.shape[0]):
SelEve_meeg[k,0] = SelEve_meeg[k,0] + initsampmne
# correct for photodelay
for m in range(SelEve_meg.shape[0]):
SelEve_meg[m,0] = SelEve_meg[m,0] + 60
for n in range(SelEve_eeg.shape[0]):
SelEve_eeg[n,0] = SelEve_eeg[n,0] + 60
for k in range(SelEve_meeg.shape[0]):
SelEve_meeg[k,0] = SelEve_meeg[k,0] + 60
TMPset1 = io.loadmat("/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/From_laptop/Scripts/event_def_for_mne/"+condnames+".mat")
DATASET1 = TMPset1['cond']
logfile.write("%d selected final meg events" %len(SelEve_meg)+"\n")
logfile.write("%d selected final eeg events" %len(SelEve_eeg)+"\n")
logfile.write("%d selected final meeg events" %len(SelEve_meeg)+"\n")
# process cond1
ev_meg = np.intersect1d(SelEve_meg[:,2].astype(int).tolist(),DATASET1[:,0].tolist())
ev_eeg = np.intersect1d(SelEve_eeg[:,2].astype(int).tolist(),DATASET1[:,0].tolist())
ev_meeg = np.intersect1d(SelEve_meeg[:,2].astype(int).tolist(),DATASET1[:,0].tolist())
event_id1_meg , tmin, tmax = ev_meg.tolist(), -0.2, 1.1
event_id1_eeg , tmin, tmax = ev_eeg.tolist(), -0.2, 1.1
event_id1_meeg, tmin, tmax = ev_meeg.tolist(), -0.2, 1.1
# epoched data
picksmeg = mne.pick_types(raw.info, meg=True, eeg=False, stim=True , eog=False, include=[], exclude='bads')
pickseeg = mne.pick_types(raw.info, meg=False, eeg=True, stim=True , eog=False, include=[], exclude='bads')
picksmeeg = mne.pick_types(raw.info, meg=True , eeg=True, stim=True , eog=False, include=[], exclude='bads')
epochs_cond1_meg = mne.Epochs(raw, SelEve_meg, event_id1_meg, tmin, tmax, baseline=(-0.2, 0),picks = picksmeg,preload = True,decim=4,reject = None,on_missing = 'warning')
epochs_cond1_eeg = mne.Epochs(raw, SelEve_eeg, event_id1_eeg, tmin, tmax, baseline=(-0.2, 0),picks = pickseeg,preload = True,decim=4,reject = None,on_missing = 'warning')
epochs_cond1_meeg= mne.Epochs(raw, SelEve_meeg, event_id1_meeg,tmin, tmax, baseline=(-0.2, 0),picks = picksmeeg,preload = True,decim=4,reject= None,on_missing = 'warning')
baseline_cond1_meg = mne.Epochs(raw, SelEve_meg, event_id1_meg, -0.2, 0, baseline=(None, 0),picks = picksmeg,preload = True,reject = None,on_missing = 'warning')
baseline_cond1_eeg = mne.Epochs(raw, SelEve_eeg, event_id1_eeg, -0.2, 0, baseline=(None, 0),picks = pickseeg,preload = True,reject = None,on_missing = 'warning')
baseline_cond1_meeg= mne.Epochs(raw, SelEve_meeg, event_id1_meeg, -0.2, 0, baseline=(None, 0),picks= picksmeeg,preload = True,reject = None,on_missing = 'warning')
# Drop epochs for nb trial equalization (impacts SNR and so final source amplitude)
# to do this: remove (actual nb trial - (ideal nb trial)*(% trial kept overall for the subject - 5%))
n_event_meg = epochs_cond1_meg.events.shape[0]
n_event_eeg = epochs_cond1_eeg.events.shape[0]
n_event_meeg = epochs_cond1_meeg.events.shape[0]
n_event_toremove_meg = n_event_meg -np.floor(nbtrial*(LKMEG[i]-0.05))
n_event_toremove_eeg = n_event_eeg -np.floor(nbtrial*(LKEEG[i]-0.05))
n_event_toremove_meeg = n_event_meeg -np.floor(nbtrial*(LKMEEG[i]-0.05))
# if there is not enough events, don't remove any trial (FIXME)
if n_event_toremove_meg > 0:
event_toremove_ind_meg = random.sample(range(n_event_meg), n_event_toremove_meg.astype(int))
epochs_cond1_meg.drop_epochs(event_toremove_ind_meg)
baseline_cond1_meg.drop_epochs(event_toremove_ind_meg)
if n_event_toremove_eeg > 0:
event_toremove_ind_eeg = random.sample(range(n_event_eeg), n_event_toremove_eeg.astype(int))
epochs_cond1_eeg.drop_epochs(event_toremove_ind_eeg)
baseline_cond1_eeg.drop_epochs(event_toremove_ind_eeg)
if n_event_toremove_meeg > 0:
event_toremove_ind_meeg = random.sample(range(n_event_meeg), n_event_toremove_meeg.astype(int))
epochs_cond1_meeg.drop_epochs(event_toremove_ind_meeg)
baseline_cond1_meeg.drop_epochs(event_toremove_ind_meeg)
# compute noise covariance matrix from baseline epochs #
evokedcond1_meg = epochs_cond1_meg.average()
evokedcond1_eeg = epochs_cond1_eeg.average()
evokedcond1_meeg= epochs_cond1_meeg.average()
noise_cov1_meg = mne.compute_covariance(baseline_cond1_meg, keep_sample_mean=True, tmin=-0.2, tmax=0)
noise_cov1_eeg = mne.compute_covariance(baseline_cond1_eeg, keep_sample_mean=True, tmin=-0.2, tmax=0)
noise_cov1_meeg = mne.compute_covariance(baseline_cond1_meeg,keep_sample_mean=True, tmin=-0.2, tmax=0)
noise_cov1_meg = mne.cov.regularize(noise_cov1_meg, evokedcond1_meg.info, grad=0.1, mag=0.1, eeg=0.1)
noise_cov1_eeg = mne.cov.regularize(noise_cov1_eeg, evokedcond1_eeg.info, grad=0.1, mag=0.1, eeg=0.1)
noise_cov1_meeg = mne.cov.regularize(noise_cov1_meeg, evokedcond1_meeg.info, grad=0.1, mag=0.1, eeg=0.1)
data_cov1_meg = mne.compute_covariance(epochs_cond1_meg, keep_sample_mean=True, tmin=0, tmax=1.1)
data_cov1_eeg = mne.compute_covariance(epochs_cond1_eeg, keep_sample_mean=True, tmin=0, tmax=1.1)
data_cov1_meeg = mne.compute_covariance(epochs_cond1_meeg,keep_sample_mean=True, tmin=0, tmax=1.1)
data_cov1_meg = mne.cov.regularize(noise_cov1_meg, evokedcond1_meg.info, grad=0.1, mag=0.1, eeg=0.1)
data_cov1_eeg = mne.cov.regularize(noise_cov1_eeg, evokedcond1_eeg.info, grad=0.1, mag=0.1, eeg=0.1)
data_cov1_meeg = mne.cov.regularize(noise_cov1_meeg, evokedcond1_meeg.info, grad=0.1, mag=0.1, eeg=0.1)
logfile.write("computing average on run" + listRunPerSubj[i][j] +"\n")
logfile.write("computing noise convariance on baseline period on run + listRunPerSubj[i][j]" +"\n")
logfile.write("computing data convariance on activation period on run + listRunPerSubj[i][j]" +"\n")
# append subject's meg runs
if j == 0:
epochs_tot_cond1_meg = deepcopy(epochs_cond1_meg)
epochs_tot_base1_meg = deepcopy(baseline_cond1_meg)
COV1_meg = noise_cov1_meg
COV_MEGdata = data_cov1_meg
else:
epochs_tmp_cond1_meg = epochs_cond1_meg
epochs_tmp_base1_meg = baseline_cond1_meg
COV1_meg['data'] += noise_cov1_meg['data']
COV1_meg['nfree'] += noise_cov1_meg['nfree']
COV1_meg = COV1_meg + noise_cov1_meg
COV_MEGdata['data'] += data_cov1_meg['data']
COV_MEGdata['nfree'] += data_cov1_meg['nfree']
COV_MEGdata = COV_MEGdata + data_cov1_meg
epochs_tot_cond1_meg._data = np.vstack((epochs_tot_cond1_meg._data,epochs_tmp_cond1_meg._data))
epochs_tot_cond1_meg.events = np.vstack((epochs_tot_cond1_meg.events,epochs_tmp_cond1_meg.events))
#epochs_tot_cond1.selection = np.concatenate((epochs_tot_cond1.selection,epochs_tmp_cond1.selection))
epochs_tot_base1_meg._data = np.vstack((epochs_tot_base1_meg._data,epochs_tmp_base1_meg._data))
epochs_tot_base1_meg.events = np.vstack((epochs_tot_base1_meg.events,epochs_tmp_base1_meg.events))
#epochs_tot_base1.selection = np.concatenate((epochs_tot_base1.selection,epochs_tmp_base1.selection))
SelEve = None
# save evoked data
evokedcond1_meg = epochs_tot_cond1_meg.average()
mne.write_evokeds(wdir+ListSubj[i]+"/mne_python/MEG_"+condnames+"_"+ListSubj[i]+"-ave.fif",evokedcond1_meg)
logfile.write("saving all runs MEG evoked data" +"\n")
#compute noise covariance matrix from emptyroom epochs #
NOISE_COV1_meg = mne.cov.regularize(COV1_meg, evokedcond1_meg.info, grad=0.1, mag=0.1, eeg=0.1)
NOISE_COV1_meg.save(wdir+ListSubj[i]+"/mne_python/MEGnoisecov_"+condnames+"_"+ListSubj[i]+"-cov.fif")
COV_MEGdata.save(wdir+ListSubj[i]+"/mne_python/MEGdatacov_"+condnames+"_"+ListSubj[i]+"-cov.fif")
logfile.write("regularizing MEG noise covariance matrix from all runs" +"\n")
logfile.write("saving MEG noise covariance matrix " +"\n")
logfile.write("saving MEG data covariance matrix from all runs" +"\n")
# append subject's eeg runs
if j == 0:
epochs_tot_cond1_eeg = deepcopy(epochs_cond1_eeg)
epochs_tot_base1_eeg = deepcopy(baseline_cond1_eeg)
COV1_eeg = noise_cov1_eeg
COV_EEGdata = data_cov1_eeg
else:
epochs_tmp_cond1_eeg = epochs_cond1_eeg
epochs_tmp_base1_eeg = baseline_cond1_eeg
COV1_eeg['data'] += noise_cov1_eeg['data']
COV1_eeg['nfree'] += noise_cov1_eeg['nfree']
COV1_eeg = COV1_eeg + noise_cov1_eeg
COV_EEGdata['data'] += data_cov1_eeg['data']
COV_EEGdata['nfree'] += data_cov1_eeg['nfree']
COV_EEGdata = COV_EEGdata + data_cov1_eeg
epochs_tot_cond1_eeg._data = np.vstack((epochs_tot_cond1_eeg._data,epochs_tmp_cond1_eeg._data))
epochs_tot_cond1_eeg.events = np.vstack((epochs_tot_cond1_eeg.events,epochs_tmp_cond1_eeg.events))
#epochs_tot_cond1.selection = np.concatenate((epochs_tot_cond1.selection,epochs_tmp_cond1.selection))
epochs_tot_base1_eeg._data = np.vstack((epochs_tot_base1_eeg._data,epochs_tmp_base1_eeg._data))
epochs_tot_base1_eeg.events = np.vstack((epochs_tot_base1_eeg.events,epochs_tmp_base1_eeg.events))
#epochs_tot_base1.selection = np.concatenate((epochs_tot_base1.selection,epochs_tmp_base1.selection))
# save evoked data
evokedcond1_eeg = epochs_tot_cond1_eeg.average()
mne.write_evokeds(wdir+ListSubj[i]+"/mne_python/EEG_"+condnames+"_"+ListSubj[i]+"-ave.fif",evokedcond1_eeg)
logfile.write("saving all runs EEG evoked data" +"\n")
#compute noise covariance matrix from emptyroom epochs #
NOISE_COV1_eeg = mne.cov.regularize(COV1_eeg, evokedcond1_eeg.info, grad=0.1, mag=0.1, eeg=0.1)
NOISE_COV1_eeg.save(wdir+ListSubj[i]+"/mne_python/EEGnoisecov_"+condnames+"_"+ListSubj[i]+"-cov.fif")
COV_EEGdata.save(wdir+ListSubj[i]+"/mne_python/EEGdatacov_"+condnames+"_"+ListSubj[i]+"-cov.fif")
logfile.write("regularizing EEG noise covariance matrix from all runs" +"\n")
logfile.write("saving EEG noise covariance matrix " +"\n")
logfile.write("saving EEG data covariance matrix from all runs" +"\n")
# append subject's meeg runs
if j == 0:
epochs_tot_cond1_meeg = deepcopy(epochs_cond1_meeg)
epochs_tot_base1_meeg = deepcopy(baseline_cond1_meeg)
COV1_meeg = noise_cov1_meeg
COV_MEEGdata = data_cov1_meeg
else:
epochs_tmp_cond1_meeg = epochs_cond1_meeg
epochs_tmp_base1_meeg = baseline_cond1_meeg
COV1_meeg['data'] += noise_cov1_meeg['data']
COV1_meeg['nfree'] += noise_cov1_meeg['nfree']
COV1_meeg = COV1_meeg + noise_cov1_meeg
COV_MEEGdata['data'] += data_cov1_meeg['data']
COV_MEEGdata['nfree'] += data_cov1_meeg['nfree']
COV_MEEGdata = COV_MEEGdata + data_cov1_meeg
epochs_tot_cond1_meeg._data = np.vstack((epochs_tot_cond1_meeg._data,epochs_tmp_cond1_meeg._data))
epochs_tot_cond1_meeg.events = np.vstack((epochs_tot_cond1_meeg.events,epochs_tmp_cond1_meeg.events))
#epochs_tot_cond1.selection = np.concatenate((epochs_tot_cond1.selection,epochs_tmp_cond1.selection))
epochs_tot_base1_meeg._data = np.vstack((epochs_tot_base1_meeg._data,epochs_tmp_base1_meeg._data))
epochs_tot_base1_meeg.events = np.vstack((epochs_tot_base1_meeg.events,epochs_tmp_base1_meeg.events))
#epochs_tot_base1.selection = np.concatenate((epochs_tot_base1.selection,epochs_tmp_base1.selection))
# save evoked data
evokedcond1_meeg = epochs_tot_cond1_meeg.average()
mne.write_evokeds(wdir+ListSubj[i]+"/mne_python/MEEG_"+condnames+"_"+ListSubj[i]+"-ave.fif",evokedcond1_meeg)
logfile.write("saving all runs MEEG evoked data" +"\n")
#compute noise covariance matrix from emptyroom epochs #
NOISE_COV1_meeg = mne.cov.regularize(COV1_meeg, evokedcond1_meeg.info, grad=0.1, mag=0.1, eeg=0.1)
NOISE_COV1_meeg.save(wdir+ListSubj[i]+"/mne_python/MEEGnoisecov_"+condnames+"_"+ListSubj[i]+"-cov.fif")
COV_MEEGdata.save(wdir+ListSubj[i]+"/mne_python/MEEGdatacov_"+condnames+"_"+ListSubj[i]+"-cov.fif")
logfile.write("regularizing MEEG noise covariance matrix from all runs" +"\n")
logfile.write("saving MEEG noise covariance matrix " +"\n")
logfile.write("saving MEEG data covariance matrix from all runs" +"\n")
# compute and save inverse operators
forward_meeg = mne.read_forward_solution(fname_fwd_meeg,surf_ori=True)
forward_eeg = mne.read_forward_solution(fname_fwd_eeg,surf_ori=True)
forward_meg = mne.read_forward_solution(fname_fwd_meg,surf_ori=True)
inverse_operator1_meg = make_inverse_operator(evokedcond1_meg.info, forward_meg, NOISE_COV1_meg, loose=0.2, depth=0.8)
inverse_operator1_eeg = make_inverse_operator(evokedcond1_eeg.info, forward_eeg, NOISE_COV1_eeg, loose=0.2, depth=0.8)
inverse_operator1_meeg = make_inverse_operator(evokedcond1_meeg.info, forward_meeg, NOISE_COV1_meeg, loose=0.2, depth=0.8)
write_inverse_operator(wdir+ListSubj[i]+"/mne_python/"+condnames+"_meg_ico5-inv",inverse_operator1_meg)
write_inverse_operator(wdir+ListSubj[i]+"/mne_python/"+condnames+"_eeg_ico5-inv",inverse_operator1_eeg)
write_inverse_operator(wdir+ListSubj[i]+"/mne_python/"+condnames+"_meeg_ico5-inv",inverse_operator1_meeg)
logfile.write("compute and save MEG inverse operator from all runs" +"\n")
logfile.write("compute and save EEG inverse operator from all runs" +"\n")
logfile.write("compute and save MEEG inverse operator from all runs" +"\n")
print(NOISE_COV1_meeg)
# Show covariance
mne.viz.plot_cov(NOISE_COV1_meeg, raw.info, colorbar=True, proj=True,show_svd=False,show=False)
logfile.write("print and save M/E/EG noise covariance matrices from all runs" +"\n")
logfile.close()
## results I showed you using the epochs method
#noise_cov = mne.compute_raw_covariance(raw_empty_room, tmin=0, tmax=None)
noise_cov = mne.compute_covariance(
epochs, tmax=0., method=['shrunk', 'empirical'])
mne.write_cov('fingerpress-cov.fif', noise_cov)
fig_cov, fig_spectra = mne.viz.plot_cov(noise_cov, raw.info)
## Pick specific types of fwd operator - not really needed
fwd = mne.pick_types_forward(fwd, meg=True , eeg=True)
info = evoked.info
### Computing inverse operator
inverse_operator = make_inverse_operator(info, fwd, noise_cov,
loose=0.2, depth=0.8)
## Writing inverse operator
write_inverse_operator('fingerpress-inv.fif',
inverse_operator)
### Computing inverse solution
method = "dSPM"
snr = 3.
lambda2 = 1. / snr ** 2
stc = apply_inverse(evoked, inverse_operator, lambda2,
method=method, pick_ori=None)
stc.times
## Visualization of time series activation
plt.plot(1e3 * stc.times, stc.data[::100, :].T)
ts_show = -30 # show the 40 largest responses
plt.plot(stc.times,
stc.data[np.argsort(stc.data.max(axis=1))[ts_show:]].T)
plt.xlabel('time (ms)')
plt.ylabel('%s value' % method)
plt.show()
parser = ArgumentParser(description=__doc__)
parser.add_argument("subject", help="subject id")
subj = parser.parse_args().subject
json_path = bp.root_json.fpath(subject=subj, task="rest", run=None)
with open(json_path, "r") as f:
er_relpath = json.load(f)["AssociatedEmptyRoom"]
er_path = dirs.bids_root / er_relpath
er_raw = read_raw_fif(er_path, preload=True)
# remove ICA components marked for 'quesitions' data from ER data
ica_sol_path = bp.ica_sol.fpath(subject=subj, task="questions")
ica_bads_path = bp.ica_bads.fpath(subject=subj, task="questions")
ica = read_ica(ica_sol_path)
ica.exclude = read_ica_bads(ica_bads_path, logger)
logger.info(f"Excluding ICs {ica.exclude} from ER data")
ica.apply(er_raw)
noise_cov = compute_raw_covariance(er_raw, method="auto")
del er_raw
info = read_info(bp.epochs.fpath(subject=subj))
fwd = read_forward_solution(bp.fwd.fpath(subject=subj))
inv_path = bp.inv.fpath(subject=subj)
inverse_operator = make_inverse_operator(info, fwd, noise_cov, rank="info")
write_inverse_operator(inv_path, inverse_operator)
fname_fwd = data_path + '/MEG/sample/sample_audvis-meg-oct-6-fwd.fif'
fwd = mne.read_forward_solution(fname_fwd, surf_ori=True)
# Restrict forward solution as necessary for MEG
fwd = mne.pick_types_forward(fwd, meg=True, eeg=False)
# make an MEG inverse operator
info = evoked.info
inverse_operator = make_inverse_operator(info,
fwd,
noise_cov,
loose=0.2,
depth=0.8)
write_inverse_operator('sample_audvis-meg-oct-6-inv.fif', inverse_operator)
###############################################################################
# Compute inverse solution
# ------------------------
method = "dSPM"
snr = 3.
lambda2 = 1. / snr**2
stc = apply_inverse(evoked,
inverse_operator,
lambda2,
method=method,
pick_ori=None)
del fwd, inverse_operator, epochs # to save memory
def run():
args = sys.argv
if len(args) <= 1:
print 'Usage: run_meg_tutorial.sh <sample data directory>'
return
sample_dir = args[1]
subjects_dir = join(sample_dir, 'subjects')
meg_dir = join(sample_dir, 'MEG', 'sample')
os.environ['SUBJECTS_DIR'] = subjects_dir
os.environ['MEG_DIR'] = meg_dir
subject = 'sample'
src = setup_source_space(subject,
fname=True,
spacing='oct6',
n_jobs=2,
overwrite=True)
# If one wanted to use other source spaces, these types of options are
# available
src_fsaverage = setup_source_space('fsaverage',
fname=True,
spacing='ico5',
n_jobs=2,
overwrite=True,
add_dist=False)
morph_source_spaces(src_fsaverage, subject_to='sample')
setup_source_space(subject,
fname=True,
spacing='all',
overwrite=True,
n_jobs=2,
add_dist=False)
# Add distances to source space (if desired, takes a long time)
bem_dir = join(subjects_dir, join('sample', 'bem'))
os.rename(join(bem_dir, 'sample-oct-6-src.fif'),
join(bem_dir, 'sample-oct-6-orig-src.fif'))
new_src = add_source_space_distances(src, dist_limit=0.007)
new_src.save(join(bem_dir, 'sample-oct-6-src.fif'))
# Preprocessing
raw = mne.io.Raw(join(meg_dir, 'sample_audvis_raw.fif'), preload=True)
raw.info['bads'] = ['MEG 2443', 'EEG 053']
reject = dict(grad=3000e-13, mag=4000e-15, eeg=100e-6)
ecg_proj, _ = mne.preprocessing.compute_proj_ecg(raw,
l_freq=1,
h_freq=100,
ch_name='MEG 1531',
reject=reject)
eog_proj, _ = mne.preprocessing.compute_proj_eog(raw,
l_freq=1,
h_freq=35,
reject=reject,
no_proj=True)
events = mne.find_events(raw)
mne.write_events(join(meg_dir, 'sample_audvis_raw-eve.fif'), events)
event_id = [1, 2, 3, 4]
tmin, tmax = -0.2, 0.5
picks = mne.pick_types(raw.info, meg=True, eeg=True, stim=True, eog=True)
# Average with no filter
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks)
evoked = epochs.average()
evoked.save(join(meg_dir, 'sample_audvis-no-filter-ave.fif'))
raw.filter(l_freq=None, h_freq=40)
raw_resampled = raw.resample(150)
raw_resampled.save(join(meg_dir, 'sample_audvis_filt-0-40_raw.fif'),
overwrite=True)
raw.add_proj(ecg_proj)
raw.add_proj(eog_proj)
resampled_events = mne.find_events(raw_resampled)
mne.write_events(join(meg_dir, 'sample_audvis_filt-0-40_raw-eve.fif'),
resampled_events)
# Average with filter
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks)
evoked = epochs.average()
evoked.save(join(meg_dir, 'sample_audvis-ave.fif'))
# Compute the noise covariance matrix
noise_cov = mne.compute_raw_data_covariance(raw, picks=picks)
noise_cov.save(join(meg_dir, 'audvis.cov'))
# Compute the empty-room noise covariance matrix
ernoise_raw = mne.io.Raw(join(meg_dir, 'ernoise_raw.fif'), preload=True)
ernoise_raw.info['bads'] = ['MEG 2443']
ernoise_raw.filter(l_freq=None, h_freq=40)
picks = mne.pick_types(ernoise_raw.info,
meg=True,
eeg=True,
stim=True,
eog=True)
ernoise_cov = mne.compute_raw_data_covariance(ernoise_raw, picks=picks)
ernoise_cov.save(join(meg_dir, 'ernoise.cov'))
###############################################################################
# Compute forward solution a.k.a. lead field
trans = join(meg_dir, 'sample_audvis_raw-trans.fif')
bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-bem-sol.fif')
# for MEG only
fname = join(meg_dir, 'sample_audvis-meg-oct-6-fwd.fif')
fwd_meg = mne.make_forward_solution(raw.info,
trans,
src,
bem,
fname=fname,
meg=True,
eeg=False,
mindist=5.0,
n_jobs=2,
overwrite=True)
# for EEG only
bem = join(subjects_dir, 'sample', 'bem',
'sample-5120-5120-5120-bem-sol.fif')
fname = join(meg_dir, 'sample_audvis-eeg-oct-6-fwd.fif')
fwd_eeg = mne.make_forward_solution(raw.info,
trans,
src,
bem,
fname=fname,
meg=False,
eeg=True,
mindist=5.0,
n_jobs=2,
overwrite=True)
# for both EEG and MEG
fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-fwd.fif')
fwd = mne.make_forward_solution(raw.info,
trans,
src,
bem,
fname=fname,
meg=True,
eeg=True,
mindist=5.0,
n_jobs=2,
overwrite=True)
# Create various sensitivity maps
grad_map = mne.sensitivity_map(fwd, ch_type='grad', mode='free')
grad_map.save(join(meg_dir, 'sample_audvis-grad-oct-6-fwd-sensmap'),
ftype='w')
mag_map = mne.sensitivity_map(fwd, ch_type='mag', mode='free')
mag_map.save(join(meg_dir, 'sample_audvis-mag-oct-6-fwd-sensmap'),
ftype='w')
eeg_map = mne.sensitivity_map(fwd, ch_type='eeg', mode='free')
eeg_map.save(join(meg_dir, 'sample_audvis-eeg-oct-6-fwd-sensmap'),
ftype='w')
grad_map2 = mne.sensitivity_map(fwd, ch_type='grad', mode='fixed')
grad_map2.save(join(meg_dir, 'sample_audvis-grad-oct-6-fwd-sensmap-2'),
ftype='w')
mag_map2 = mne.sensitivity_map(fwd, ch_type='mag', mode='ratio')
mag_map2.save(join(meg_dir, 'sample_audvis-mag-oct-6-fwd-sensmap-3'),
ftype='w')
# Compute some with the EOG + ECG projectors
projs = ecg_proj + eog_proj + raw.info['projs']
for map_type in ['radiality', 'angle', 'remaining', 'dampening']:
eeg_map = mne.sensitivity_map(fwd,
projs=projs,
ch_type='eeg',
mode=map_type)
eeg_map.save(
join(meg_dir, 'sample_audvis-eeg-oct-6-fwd-sensmap-' + map_type))
###############################################################################
# Compute MNE inverse operators
#
# Note: The MEG/EEG forward solution could be used for all
#
inv_meg = make_inverse_operator(raw.info, fwd_meg, noise_cov, loose=0.2)
fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-inv.fif')
write_inverse_operator(fname, inv_meg)
inv_eeg = make_inverse_operator(raw.info, fwd_eeg, noise_cov, loose=0.2)
fname = join(meg_dir, 'sample_audvis-eeg-oct-6-eeg-inv.fif')
write_inverse_operator(fname, inv_eeg)
inv = make_inverse_operator(raw.info, fwd, noise_cov, loose=0.2)
fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-meg-eeg-inv.fif')
write_inverse_operator(fname, inv)
# inverse operator with fixed orientation (for testing). Not implemented
#inv_fixed = make_inverse_operator(raw.info, fwd_meg, noise_cov,
# depth=None, fixed=True)
#fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-nodepth-fixed-inv.fif')
#write_inverse_operator(fname, inv_fixed)
# produce two with diagonal noise (for testing)
diag = noise_cov.as_diag()
inv_meg_diag = make_inverse_operator(raw.info, fwd_meg, diag, loose=0.2)
fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-diagnoise-inv.fif')
write_inverse_operator(fname, inv_meg_diag)
inv_eeg_diag = make_inverse_operator(raw.info, fwd, diag, loose=0.2)
fname = join(meg_dir,
'sample_audvis-meg-eeg-oct-6-meg-eeg-diagnoise-inv.fif')
write_inverse_operator(fname, inv_eeg_diag)
# Produce stc files
evoked.crop(0, 0.25)
stc_meg = apply_inverse(evoked, inv_meg, method='MNE')
stc_meg.save(join(meg_dir, 'sample_audvis-meg'))
stc_eeg = apply_inverse(evoked, inv_eeg, method='MNE')
stc_eeg.save(join(meg_dir, 'sample_audvis-eeg'))
stc = apply_inverse(evoked, inv, method='MNE')
stc.save(join(meg_dir, 'sample_audvis-meg-eeg'))
# let's also morph to fsaverage
stc_to = stc_meg.morph('fsaverage', grade=3, smooth=12)
stc_to.save(join(meg_dir, 'fsaverage_audvis-meg'))
stc_to = stc_eeg.morph('fsaverage', grade=3, smooth=12)
stc_to.save(join(meg_dir, 'fsaverage_audvis-eeg'))
stc_to = stc.morph('fsaverage', grade=3, smooth=12)
stc_to.save(join(meg_dir, 'fsaverage_audvis-meg-eeg'))
###############################################################################
# Do one dipole fitting
evoked = evoked.pick_types(meg=True, eeg=False)
evoked.crop(0.04, 0.095)
bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-bem-sol.fif')
dip, _ = mne.fit_dipole(evoked, noise_cov, bem, trans)
dip.save(join(meg_dir, 'sample_audvis_set1.dip'))
# Restrict forward solution as necessary for MEG
forward_meg = mne.fiff.pick_types_forward(forward_meeg, meg=True, eeg=False)
# Alternatively, you can just load a forward solution that is restricted
forward_eeg = mne.read_forward_solution(fname_fwd_eeg, surf_ori=True)
# make an M/EEG, MEG-only, and EEG-only inverse operators
info = evoked.info
inverse_operator_meeg = make_inverse_operator(info, forward_meeg, noise_cov,
loose=0.2, depth=0.8)
inverse_operator_meg = make_inverse_operator(info, forward_meg, noise_cov,
loose=0.2, depth=0.8)
inverse_operator_eeg = make_inverse_operator(info, forward_eeg, noise_cov,
loose=0.2, depth=0.8)
write_inverse_operator('sample_audvis-meeg-oct-6-inv.fif',
inverse_operator_meeg)
write_inverse_operator('sample_audvis-meg-oct-6-inv.fif',
inverse_operator_meg)
write_inverse_operator('sample_audvis-eeg-oct-6-inv.fif',
inverse_operator_eeg)
# Compute inverse solution
stcs = dict()
stcs['meeg'] = apply_inverse(evoked, inverse_operator_meeg, lambda2, "dSPM",
pick_normal=False)
stcs['meg'] = apply_inverse(evoked, inverse_operator_meg, lambda2, "dSPM",
pick_normal=False)
stcs['eeg'] = apply_inverse(evoked, inverse_operator_eeg, lambda2, "dSPM",
pick_normal=False)
# Save result in stc files
import sys
import mne
from mne.minimum_norm import make_inverse_operator, write_inverse_operator
from my_settings import (mne_folder, conditions, ica_folder)
subject = sys.argv[1]
for condition in conditions:
fwd = mne.read_forward_solution(
mne_folder + "%s_%s_ar-fwd.fif" % (subject, condition), surf_ori=False)
epochs = mne.read_epochs(ica_folder + "%s_%s_ar_ica-epo.fif" % (
subject, condition))
cov = mne.read_cov(mne_folder + "%s_%s_ar-cov.fif" % (subject, condition))
evoked = epochs.average()
# make an MEG inverse operator
inverse_operator = make_inverse_operator(
evoked.info, fwd, cov, loose=0.2, depth=0.8)
write_inverse_operator(mne_folder + "%s_%s_ar-inv.fif" %
(subject, condition), inverse_operator)
import sys
import mne
from mne.minimum_norm import make_inverse_operator, write_inverse_operator
from my_settings import (mne_folder, conditions, ica_folder)
subject = sys.argv[1]
for condition in conditions:
fwd = mne.read_forward_solution(mne_folder + "%s_%s_ar-fwd.fif" %
(subject, condition),
surf_ori=False)
epochs = mne.read_epochs(ica_folder + "%s_%s_ar_ica-epo.fif" %
(subject, condition))
cov = mne.read_cov(mne_folder + "%s_%s_ar-cov.fif" % (subject, condition))
evoked = epochs.average()
# make an MEG inverse operator
inverse_operator = make_inverse_operator(evoked.info,
fwd,
cov,
loose=0.2,
depth=0.8)
write_inverse_operator(
mne_folder + "%s_%s_ar-inv.fif" % (subject, condition),
inverse_operator)
info_mat = scipy.io.loadmat(datapath + 'Results_Alpha_and_Gamma/' +
subject + '/' + subject + '_info.mat')
good_epo = info_mat['ALLINFO']['ep_order_num'][0][0][0] - 1
info_file = info_mat['ALLINFO']['stim_type_previous_tr'][0][0][0]
goodevents = relevantevents[good_epo]
goodevents[:, 2] = info_file
# Define epochs
allepochs = mne.Epochs(raw,
goodevents,
events_id,
tmin=presim_sec,
tmax=poststim_sec,
baseline=(None, 0),
proj=False,
preload=True)
# Resample epochs
if allepochs.info['sfreq'] > 500:
allepochs.resample(500)
#inverse operator
inv = make_inverse_operator(allepochs.info,
fwd,
noise_cov,
loose=0.2,
depth=0.8,
verbose=True)
write_inverse_operator(savepath + subject + '/' + subject + '_inv',
inv,
verbose=None)
bem_fname,
meg=True,
ignore_ref=True)
print("Converting forward solution...")
fwd_fixed = convert_forward_solution(fwd, force_fixed=False, surf_ori=True)
write_forward_solution(fwd_fname, fwd_fixed, overwrite=True)
# else:
# fwd = read_forward_solution(fwd_fname)
print("Making inverse operator...")
inverse_operator = make_inverse_operator(epochs.info,
fwd_fixed,
noise_cov,
fixed=True,
loose=0.0)
write_inverse_operator(inv_fname, inverse_operator)
print("Done with %s!" % (subject))
###############################################################################
################# MAKE EPOCHS STCS, SAVE AVG OF 4 LABELS #####################
###############################################################################
snr = 2.0 # Standard assumption for single trial
lambda2 = 1.0 / snr**2
mri_dir = '/Volumes/Server/MORPHLAB/Users/Ellie/Shepard/mri'
# params
for subject in subjects:
# Forward model
fwd = mne.make_forward_solution(raw.info, fname_trans, src, bem_sol_file)
mne.write_forward_solution(fwd_file, fwd)
# Restrict forward solution as necessary for MEG
fwd = mne.pick_types_forward(fwd, meg=True, eeg=False)
# make an inverse operator
info = evoked.info
inverse_operator = make_inverse_operator(info, fwd, noise_cov,
loose=0.2, depth=0.8)
write_inverse_operator(inverse_file,
inverse_operator)
# Compute inverse solution
method = "dSPM"
snr = 3.
lambda2 = 1. / snr ** 2
stc = apply_inverse(evoked, inverse_operator, lambda2,
method=method, pick_ori=None,verbose=1)
# visualize
_, peak_time = stc.get_peak(hemi='lh')
brain = stc.plot(initial_time=peak_time, surface='inflated', hemi='lh', subjects_dir=subj_dir)
sph_bem = make_sphere_model(r0='auto', head_radius='auto', info=subj_info)
###########################################################
# Create foward solution
# Read source space and trans (mri->head) for foward computation
src = read_source_spaces(fname_load_src)
if generic_sph is True:
# Use this trans if using generic fsaverage head model
trans = read_trans(fname_load_trans)
else:
# Use this trans if using individual's head model
trans = model_inv['mri_head_t']
fwd = make_forward_solution(info=subj_info, trans=trans, src=src,
bem=sph_bem, fname=fname_save_fwd, meg=False,
eeg=True, overwrite=True, n_jobs=n_jobs)
# Fix orientation
convert_forward_solution(fwd, surf_ori=True, force_fixed=True, copy=False)
###########################################################
# Create and save inverse solution
noise_cov = model_inv['noise_cov']
# EEG only, so depth weighting not needed
sph_inv = make_inverse_operator(subj_info, fwd, noise_cov, depth=None,
fixed=True)
write_inverse_operator(fname_save_inv, sph_inv)
n_jobs = 1
else:
data_path = "/projects/MINDLAB2015_MEG-CorticalAlphaAttention/scratch/"
n_jobs = 1
subjects_dir = data_path + "fs_subjects_dir/"
fname_fwd = data_path + '0001-fwd.fif'
fname_cov = data_path + '0001-cov.fif'
fname_evoked = data_path + "0001_p_03_filter_ds_ica-mc_raw_tsss-ave.fif"
snr = 1.0
lambda2 = 1.0 / snr ** 2
# Load data
evoked = mne.read_evokeds(fname_evoked, condition=0, baseline=(None, 0))
forward_meeg = mne.read_forward_solution(fname_fwd, surf_ori=True)
noise_cov = mne.read_cov(fname_cov)
# Restrict forward solution as necessary for MEG
forward_meg = mne.pick_types_forward(forward_meeg, meg=True, eeg=False)
# Alternatively, you can just load a forward solution that is restricted
# make an M/EEG, MEG-only, and EEG-only inverse operators
inverse_operator_meg = make_inverse_operator(evoked.info, forward_meg,
noise_cov,
loose=0.2, depth=0.8)
write_inverse_operator('0001-meg-oct-6-inv.fif',
inverse_operator_meg)
