def forward_pipeline(raw_fname,
subject,
fwd_fname=None,
trans_fname=None,
subjects_dir=None,
overwrite=False):
import os.path as op
from mne.utils import get_config
if subjects_dir is None:
subjects_dir = get_config('SUBJECTS_DIR')
# Setup paths
save_dir = '/'.join(raw_fname.split('/')[:-1])
bem_dir = op.join(subjects_dir, subject, 'bem')
bem_sol_fname = op.join(subjects_dir, subject, 'bem',
subject + '-5120-bem-sol.fif')
oct_fname = op.join(subjects_dir, subject, 'bem',
subject + '-oct-6-src.fif')
src_fname = op.join(bem_dir, subject + '-oct-6-src.fif')
bem_sol_fname = op.join(bem_dir, subject + '-5120-bem-sol.fif')
if trans_fname is None:
trans_fname = op.join(save_dir, subject + '-trans.fif')
if fwd_fname is None:
fwd_fname = op.join(save_dir, subject + '-meg-fwd.fif')
# 0. Checks Freesurfer segmentation and compute watershed bem
miss_anatomy = not op.isfile(src_fname) or not op.exists(bem_sol_fname)
for fname in [bem_sol_fname, oct_fname]:
if not op.isfile(op.join(subjects_dir, subject, 'bem', fname)):
miss_anatomy = True
if miss_anatomy:
raise RuntimeError('Could not find BEM (%s, %s), relaunch '
'pipeline_anatomy()' % (bem_sol_fname, oct_fname))
# 1. Manual coregisteration head markers with coils
if not op.isfile(trans_fname):
raise RuntimeError('Could not find trans (%s), launch'
'coregistration.' % trans_fname)
# 2. Forward solution
if overwrite or not op.isfile(fwd_fname):
from mne import (make_forward_solution, convert_forward_solution,
write_forward_solution)
fwd = make_forward_solution(info=raw_fname,
trans=trans_fname,
src=oct_fname,
bem=bem_sol_fname,
fname=None,
meg=True,
eeg=False,
mindist=5.0,
overwrite=True,
ignore_ref=True)
# Convert to surface orientation for better visualization
fwd = convert_forward_solution(fwd, surf_ori=True)
# save
write_forward_solution(fwd_fname, fwd, overwrite=True)
return
def test_average_forward_solution():
"""Test averaging forward solutions
"""
fwd = read_forward_solution(fname)
# input not a list
assert_raises(TypeError, average_forward_solutions, 1)
# list is too short
assert_raises(ValueError, average_forward_solutions, [])
# negative weights
assert_raises(ValueError, average_forward_solutions, [fwd, fwd], [-1, 0])
# all zero weights
assert_raises(ValueError, average_forward_solutions, [fwd, fwd], [0, 0])
# weights not same length
assert_raises(ValueError, average_forward_solutions, [fwd, fwd], [0, 0, 0])
# list does not only have all dict()
assert_raises(TypeError, average_forward_solutions, [1, fwd])
# try an easy case
fwd_copy = average_forward_solutions([fwd])
assert_array_equal(fwd['sol']['data'], fwd_copy['sol']['data'])
# modify a fwd solution, save it, use MNE to average with old one
fwd_copy['sol']['data'] *= 0.5
fname_copy = op.join(temp_dir, 'fwd.fif')
write_forward_solution(fname_copy, fwd_copy, overwrite=True)
cmd = ('mne_average_forward_solutions', '--fwd', fname, '--fwd',
fname_copy, '--out', fname_copy)
run_subprocess(cmd)
# now let's actually do it, with one filename and one fwd
fwd_ave = average_forward_solutions([fwd, fwd_copy])
assert_array_equal(0.75 * fwd['sol']['data'], fwd_ave['sol']['data'])
def run_forward(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_trans = op.join(meg_subject_dir, '%s_audvis_raw-trans.fif' % subject)
src = mne.setup_source_space(subject, spacing=config.spacing,
subjects_dir=config.subjects_dir,
add_dist=False)
evoked = mne.read_evokeds(fname_ave, condition=0)
# Here we only use 1-layer BEM because the 3-layer is unreliable
if 'eeg' in evoked:
fname_bem = op.join(config.subjects_dir, subject, 'bem',
'%s-5120-5120-5120-bem-sol.fif' % subject)
else:
fname_bem = op.join(config.subjects_dir, subject, 'bem',
'%s-5120-bem-sol.fif' % subject)
# Because we use a 1-layer BEM, we do MEG only
fwd = mne.make_forward_solution(evoked.info, fname_trans, src, fname_bem,
mindist=config.mindist)
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def run_forward(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_fwd = op.join(data_path,
'%s-meg-eeg-%s-fwd.fif' % (subject, spacing))
fname_trans = op.join(study_path, 'ds117', subject, 'MEG',
'%s-trans.fif' % subject)
fname_src = op.join(subjects_dir, subject, 'bem',
'%s-%s-src.fif' % (subject, spacing))
# Here we only use 1-layer BEM because the 3-layer is unreliable
fname_bem = op.join(subjects_dir, subject, 'bem',
'%s-5120-bem-sol.fif' % subject)
info = mne.io.read_info(fname_ave)
# Because we use a 1-layer BEM, we do MEG only
fwd = mne.make_forward_solution(info,
fname_trans,
fname_src,
fname_bem,
meg=True,
eeg=False,
mindist=mindist)
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def get_fwd(base_path):
# They all have approximately the same dev_head_t
if "phantom_aston" in base_path:
info = mne.io.read_info(base_path +
'/Amp1000_IASoff/Amp1000_Dip5_IASoff.fif')
else:
info = mne.io.read_info(base_path + '/1000nAm/dip05_1000nAm.fif')
sphere = mne.make_sphere_model(r0=(0., 0., 0.), head_radius=0.080)
src_fname = op.join(base_path, 'phantom-src.fif')
if not op.isfile(src_fname):
mne.setup_volume_source_space(subject=None,
pos=5.,
mri=None,
sphere=(0.0, 0.0, 0.0, 80.0),
bem=None,
mindist=5.0,
exclude=2.0).save(src_fname)
src = mne.read_source_spaces(src_fname)
fwd_fname = op.join(base_path, 'phantom-fwd.fif')
if not op.isfile(fwd_fname):
mne.write_forward_solution(
fwd_fname,
mne.make_forward_solution(info,
trans=None,
src=src,
bem=sphere,
eeg=False,
meg=True))
fwd = mne.read_forward_solution(fwd_fname)
return src, fwd
def run_forward(*, cfg, subject, session=None):
bids_path = BIDSPath(subject=subject,
session=session,
task=cfg.task,
acquisition=cfg.acq,
run=None,
recording=cfg.rec,
space=cfg.space,
extension='.fif',
datatype=cfg.datatype,
root=cfg.deriv_root,
check=False)
fname_info = bids_path.copy().update(**cfg.source_info_path_update)
fname_trans = bids_path.copy().update(suffix='trans')
fname_fwd = bids_path.copy().update(suffix='fwd')
if cfg.use_template_mri:
src, trans, bem_sol = _prepare_forward_fsaverage(cfg)
else:
src, trans, bem_sol = _prepare_forward(cfg, bids_path, fname_trans)
# Finally, calculate and save the forward solution.
msg = 'Calculating forward solution'
logger.info(
**gen_log_kwargs(message=msg, subject=subject, session=session))
info = mne.io.read_info(fname_info)
fwd = mne.make_forward_solution(info,
trans=trans,
src=src,
bem=bem_sol,
mindist=cfg.mindist)
mne.write_trans(fname_trans, fwd['mri_head_t'], overwrite=True)
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def gen_forward_files(x, y, z, bem, info, trans, verbose=True):
if verbose:
msg = (f'Processing forward solution for dipole location: '
f'x={x}, y={y}, z={z} [m, MNE Head]')
print(msg)
pos = np.array([x, y, z])
try:
fwd = gen_forward_solution(pos=pos,
bem=bem,
info=info,
trans=head_to_mri_t,
verbose=False)
success = True
except RuntimeError as e:
if 'No points left in source space ' in str(e):
if verbose:
print('… skipping (location outside skull)')
success = False
else:
raise e
if success:
fwd_fname = fwd_dir / (f'{subject}-'
f'{pos[0]:.3f}-'
f'{pos[1]:.3f}-'
f'{pos[2]:.3f}-fwd.fif')
mne.write_forward_solution(fwd_fname,
fwd,
overwrite=True,
verbose=False)
if verbose:
print('… done.')
return dict(x=x, y=y, z=z, success=success)
def test_average_forward_solution():
"""Test averaging forward solutions
"""
fwd = read_forward_solution(fname)
# input not a list
assert_raises(TypeError, average_forward_solutions, 1)
# list is too short
assert_raises(ValueError, average_forward_solutions, [])
# negative weights
assert_raises(ValueError, average_forward_solutions, [fwd, fwd], [-1, 0])
# all zero weights
assert_raises(ValueError, average_forward_solutions, [fwd, fwd], [0, 0])
# weights not same length
assert_raises(ValueError, average_forward_solutions, [fwd, fwd], [0, 0, 0])
# list does not only have all dict()
assert_raises(TypeError, average_forward_solutions, [1, fwd])
# try an easy case
fwd_copy = average_forward_solutions([fwd])
assert_array_equal(fwd['sol']['data'], fwd_copy['sol']['data'])
# modify a fwd solution, save it, use MNE to average with old one
fwd_copy['sol']['data'] *= 0.5
fname_copy = op.join(temp_dir, 'fwd.fif')
write_forward_solution(fname_copy, fwd_copy, overwrite=True)
cmd = ('mne_average_forward_solutions', '--fwd', fname, '--fwd',
fname_copy, '--out', fname_copy)
run_subprocess(cmd)
# now let's actually do it, with one filename and one fwd
fwd_ave = average_forward_solutions([fwd, fwd_copy])
assert_array_equal(0.75 * fwd['sol']['data'], fwd_ave['sol']['data'])
def make_forward_solution(events_id,
src_fn,
fwd_sub_fn,
epochs_fn,
cor_fn,
bem_fn,
sub_corticals_codes_file,
usingEEG=True,
n_jobs=4):
# The cortical surface source space can be setup if doens't exist
# src = mne.setup_source_space(MRI_SUBJECT, surface='pial', overwrite=True) # overwrite=True)
fwd_with_subcortical = None
src = mne.read_source_spaces(src_fn)
sub_corticals = read_sub_corticals_code_file(sub_corticals_codes_file)
for cond in events_id.keys():
if len(sub_corticals) > 0:
# add a subcortical volumes
src_with_subcortical = add_subcortical_volumes(src, sub_corticals)
fwd_with_subcortical = _make_forward_solution(src,
epochs_fn,
cor_fn,
bem_fn,
usingEEG=usingEEG,
n_jobs=n_jobs)
mne.write_forward_solution(fwd_sub_fn.format(cond=cond),
fwd_with_subcortical,
overwrite=True)
return fwd_with_subcortical
def make_fwd_solution(cond_fname, fs_subj, study_path):
eeg_epo = mne.read_epochs(cond_fname)
img_type = 'anony' if fs_subj.find('_an') > 0 else 'orig'
subj = fs_subj.strip('_an')
trans_fname = op.join(study_path, 'source_stim', subj, 'source_files',
img_type, '%s_fid-trans.fif' % fs_subj)
src_fname = op.join(study_path, 'source_stim', subj, 'source_files',
img_type, '%s-oct5-src.fif' % fs_subj)
bem_fname = op.join(subjects_dir, fs_subj, 'bem',
'%s-bem-sol.fif' % fs_subj)
fwd = mne.make_forward_solution(eeg_epo.info, trans_fname, src_fname,
bem_fname)
trans = mne.read_trans(trans_fname)
mne.viz.plot_alignment(eeg_epo.info,
trans,
subject=subj,
surfaces=['head', 'brain'],
subjects_dir=subjects_dir)
# mlab.show()
mne.write_forward_solution(op.join(study_path, 'source_stim', subj,
'source_files', img_type,
'%s-fwd.fif' % fs_subj),
fwd,
overwrite=True)
return fwd
def run_forward(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_fwd = op.join(data_path, '%s-meg-%s-fwd.fif' % (subject, spacing))
fname_trans = op.join(study_path, 'ds117', subject, 'MEG', '%s-trans.fif' % subject)
src = mne.setup_source_space(subject, spacing=spacing,
subjects_dir=subjects_dir, overwrite=True,
n_jobs=1, add_dist=False)
src_fname = op.join(subjects_dir, subject, '%s-src.fif' % spacing)
mne.write_source_spaces(src_fname, src)
bem_model = mne.make_bem_model(subject, ico=4, subjects_dir=subjects_dir,
conductivity=(0.3,))
bem = mne.make_bem_solution(bem_model)
info = mne.read_evokeds(fname_ave, condition=0).info
fwd = mne.make_forward_solution(info, trans=fname_trans, src=src, bem=bem,
fname=None, meg=True, eeg=False,
mindist=mindist, n_jobs=1, overwrite=True)
fwd = mne.convert_forward_solution(fwd, surf_ori=True)
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def forward_solution(subject, fsMRI_dir, remap_grads=False):
print('Subject ' + subject + ': forward_solution ======================')
meg_subject_dir = op.join(config.meg_dir, subject)
# Load some evoked data (just for info?)
fname_evoked = op.join(meg_subject_dir, 'evoked_cleaned', 'items_standard_all-ave.fif')
evoked = mne.read_evokeds(fname_evoked)
evoked = evoked[0]
######### REMOVE EEG (from object used for info) ########
if config.noEEG:
evoked = evoked.pick_types( meg=True, eeg=False, eog=False)
######### REMAP GRADS TO MAG ########
if remap_grads:
print('Remapping grads to mags')
evoked = evoked.as_type('mag')
#############################
# BEM solution
fname_bem = op.join(meg_subject_dir, '%s-5120-5120-5120-bem-sol.fif' % subject)
# Coregistration file
fname_trans = fname_trans = op.join(config.meg_dir, subject, subject + '-trans.fif')
# Source space
src = mne.read_source_spaces(op.join(meg_subject_dir, subject + '-oct6-src.fif'))
# Forward solution
print('Computing forward solution')
fwd = mne.make_forward_solution(evoked.info, fname_trans, src, fname_bem, mindist=config.mindist)
if remap_grads:
extension = '_%s-fwd-remapped' % (config.spacing)
else:
extension = '_%s-fwd' % (config.spacing)
fname_fwd = op.join(meg_subject_dir, subject + config.base_fname.format(**locals()))
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def make_forward_solution(subject, subjects_dir, dir_base):
import glob
import mayavi.mlab as mlab
files_epochs = glob.glob(
op.join(dir_base, 'data', 'fif', '%s*' % subject.replace('anony', '')))
epo = mne.read_epochs(files_epochs[0])
trans_fname = op.join(dir_base, 'spatial', 'fwd', '%s-trans.fif' % subject)
src_fname = op.join(dir_base, 'spatial', 'fwd', '%s-src.fif' % subject)
bem_fname = op.join(dir_base, 'spatial', 'fwd', '%s-bem.fif' % subject)
fwd = mne.make_forward_solution(epo.info, trans_fname, src_fname,
bem_fname)
trans = mne.read_trans(trans_fname)
mne.viz.plot_alignment(epo.info,
trans,
subject=subject,
surfaces=['head', 'brain'],
subjects_dir=subjects_dir)
mlab.show()
mne.write_forward_solution(
op.join(dir_base, 'spatial', 'fwd', '%s-fwd.fif' % subject), fwd)
def run_forward(subject):
evoked_fname = op.join(meg_dir, subject,
f'{subject}_audvis-filt-sss-ave.fif')
fwd_fname = op.join(meg_dir, subject,
f'{subject}_audvis-{spacing}-ico{bem_ico}-fwd.fif')
# If coregistration was done manually, change it to the file name
# If use the provided trans file from sample dataset, remember to put the
# trans file in MEG/
trans_fname = op.join(meg_dir, subject, f'{subject}_audvis_raw-trans.fif')
# If you follow the step in 2_setup_source_space.py
src_fname = op.join(subjects_dir, subject, 'bem',
f'{subject}-{spacing}-src.fif')
bem_fname = op.join(subjects_dir, subject, 'bem',
f'{subject}-ico{bem_ico}-bem-sol.fif')
# If you are practicing with the sample dataset
# src_fname = op.join(subjects_dir, subject, 'bem',
# f'{subject}-oct-6-src.fif')
# bem_fname = op.join(subjects_dir, subject, 'bem',
# f'{subject}-5120-5120-5120-bem-sol.fif')
info = mne.io.read_info(evoked_fname)
fwd = mne.make_forward_solution(info,
trans_fname,
src_fname,
bem_fname,
meg=True,
eeg=False)
mne.write_forward_solution(fwd_fname, fwd, overwrite=True)
print(f'Computed forward solution for {subject}')
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 test_io_forward():
"""Test IO for forward solutions
"""
fwd = read_forward_solution(fname)
fwd = read_forward_solution(fname, surf_ori=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (306, 22494))
assert_equal(len(fwd['sol']['row_names']), 306)
fname_temp = op.join(temp_dir, 'fwd.fif')
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd = read_forward_solution(fname, surf_ori=True)
fwd_read = read_forward_solution(fname_temp, surf_ori=True)
leadfield = fwd_read['sol']['data']
assert_equal(leadfield.shape, (306, 22494))
assert_equal(len(fwd_read['sol']['row_names']), 306)
assert_equal(len(fwd_read['info']['chs']), 306)
assert_true('dev_head_t' in fwd_read['info'])
assert_true('mri_head_t' in fwd_read)
assert_array_almost_equal(fwd['sol']['data'], fwd_read['sol']['data'])
fwd = read_forward_solution(fname, force_fixed=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (306, 22494 / 3))
assert_equal(len(fwd['sol']['row_names']), 306)
assert_equal(len(fwd['info']['chs']), 306)
assert_true('dev_head_t' in fwd['info'])
assert_true('mri_head_t' in fwd)
def make_forward(self, tsss=None):
dir_name = op.join(self.preprocessed_data, 'forward')
for directory in [dir_name]:
if not op.isdir(directory):
os.makedirs(directory)
if tsss:
fname_ave = op.join(self.preprocessed_data, 'evoked',
'%s_tsss_%d-ave.fif' % (self.subj_id, tsss))
else:
fname_ave = op.join(
self.preprocessed_data, 'evoked',
'%s_highpass_%sHz-ave.fif' % (self.subj_id, self.l_cutoff))
fname_fwd = op.join(
self.preprocessed_data, 'forward',
'%s-meg-eeg-%s-fwd.fif' % (self.subj_id, self.spacing))
fname_trans = op.join(self.data_path, '%s-trans.fif' % self.subj_id)
fname_src = op.join(self.res_path, 'subjects', self.subj_id, 'bem',
'%s-%s-src.fif' % (self.subj_id, self.spacing))
# Here we only use 1-layer BEM because the 3-layer is unreliable
fname_bem = op.join(self.res_path, 'subjects', self.subj_id, 'bem',
'%s-5120-bem-sol.fif' % self.subj_id)
info = mne.io.read_info(fname_ave)
# Because we use a 1-layer BEM, we do MEG only
fwd = mne.make_forward_solution(info,
fname_trans,
fname_src,
fname_bem,
meg=True,
eeg=False,
mindist=5)
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def make_anony_fwd(subject,
dir_base,
subjects_dir,
conductivity=(0.3, 0.006, 0.3),
ico=4):
import os.path as op
from mne.io.constants import FIFF
from mne.bem import _surfaces_to_bem, _check_bem_size
import glob
import mayavi.mlab as mlab
for m in ['anonymi', 'defaced', 'mf']:
print('Preparing fwd - method: %s' % m)
bem_dir = op.join(dir_base, 'spatial', 'bems', m)
inner_skull = op.join(bem_dir,
'%s_%s_inner_skull_surface' % (subject, m))
outer_skull = op.join(bem_dir,
'%s_%s_outer_skull_surface' % (subject, m))
outer_skin = op.join(bem_dir,
'%s_%s_outer_skin_surface' % (subject, m))
surfaces = [inner_skull, outer_skull, outer_skin]
ids = [
FIFF.FIFFV_BEM_SURF_ID_BRAIN, FIFF.FIFFV_BEM_SURF_ID_SKULL,
FIFF.FIFFV_BEM_SURF_ID_HEAD
]
surfaces = _surfaces_to_bem(surfaces, ids, conductivity, ico)
_check_bem_size(surfaces)
bem = mne.make_bem_solution(surfaces)
bem_fname = op.join(dir_base, 'spatial', 'bems', m,
'%s_%s-bem.fif' % (subject, m))
mne.write_bem_solution(bem_fname, bem)
files_epochs = glob.glob(
op.join(dir_base, 'data', 'fif', '%s*' % subject))
epo = mne.read_epochs(files_epochs[0])
trans_fname = op.join(dir_base, 'spatial', 'fwd',
'%s-trans.fif' % subject)
src_fname = op.join(dir_base, 'spatial', 'fwd', '%s-src.fif' % subject)
fwd = mne.make_forward_solution(epo.info, trans_fname, src_fname,
bem_fname)
trans = mne.read_trans(trans_fname)
mne.viz.plot_alignment(epo.info,
trans,
subject=subject,
surfaces=['head', 'brain'],
bem=bem,
subjects_dir=subjects_dir)
mlab.show()
mne.write_forward_solution(
op.join(dir_base, 'spatial', 'bems', m,
'%s_%s-fwd.fif' % (subject, m)), fwd)
def _compute_fwd_sol(raw_fname, trans_fname, src, bem, fwd_filename):
"""Compute leadfield matrix by BEM."""
mindist = 5. # ignore sources <= 0mm from inner skull
fwd = mne.make_forward_solution(raw_fname, trans_fname, src, bem,
mindist=mindist, meg=True, eeg=False,
n_jobs=2)
mne.write_forward_solution(fwd_filename, fwd, overwrite=True)
print(('\n*** FWD file {} written!!!\n'.format(fwd_filename)))
def test_restrict_forward_to_stc():
"""Test restriction of source space to source SourceEstimate
"""
start = 0
stop = 5
n_times = stop - start - 1
sfreq = 10.0
t_start = 0.123
fwd = read_forward_solution(fname_meeg)
fwd = convert_forward_solution(fwd,
surf_ori=True,
force_fixed=True,
use_cps=True)
fwd = pick_types_forward(fwd, meg=True)
vertno = [fwd['src'][0]['vertno'][0:15], fwd['src'][1]['vertno'][0:5]]
stc_data = np.ones((len(vertno[0]) + len(vertno[1]), n_times))
stc = SourceEstimate(stc_data, vertno, tmin=t_start, tstep=1.0 / sfreq)
fwd_out = restrict_forward_to_stc(fwd, stc)
assert_true(isinstance(fwd_out, Forward))
assert_equal(fwd_out['sol']['ncol'], 20)
assert_equal(fwd_out['src'][0]['nuse'], 15)
assert_equal(fwd_out['src'][1]['nuse'], 5)
assert_equal(fwd_out['src'][0]['vertno'], fwd['src'][0]['vertno'][0:15])
assert_equal(fwd_out['src'][1]['vertno'], fwd['src'][1]['vertno'][0:5])
fwd = read_forward_solution(fname_meeg)
fwd = convert_forward_solution(fwd, surf_ori=True, force_fixed=False)
fwd = pick_types_forward(fwd, meg=True)
vertno = [fwd['src'][0]['vertno'][0:15], fwd['src'][1]['vertno'][0:5]]
stc_data = np.ones((len(vertno[0]) + len(vertno[1]), n_times))
stc = SourceEstimate(stc_data, vertno, tmin=t_start, tstep=1.0 / sfreq)
fwd_out = restrict_forward_to_stc(fwd, stc)
assert_equal(fwd_out['sol']['ncol'], 60)
assert_equal(fwd_out['src'][0]['nuse'], 15)
assert_equal(fwd_out['src'][1]['nuse'], 5)
assert_equal(fwd_out['src'][0]['vertno'], fwd['src'][0]['vertno'][0:15])
assert_equal(fwd_out['src'][1]['vertno'], fwd['src'][1]['vertno'][0:5])
# Test saving the restricted forward object. This only works if all fields
# are properly accounted for.
temp_dir = _TempDir()
fname_copy = op.join(temp_dir, 'copy-fwd.fif')
with warnings.catch_warnings(record=True):
warnings.simplefilter('always')
write_forward_solution(fname_copy, fwd_out, overwrite=True)
fwd_out_read = read_forward_solution(fname_copy)
fwd_out_read = convert_forward_solution(fwd_out_read,
surf_ori=True,
force_fixed=False)
compare_forwards(fwd_out, fwd_out_read)
def run_forward(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_evoked = op.join(deriv_path, bids_basename + '-ave.fif')
fname_trans = op.join(deriv_path, 'sub-{}'.format(subject) + '-trans.fif')
fname_fwd = op.join(deriv_path, bids_basename + '-fwd.fif')
msg = f'Input: {fname_evoked}, Output: {fname_fwd}'
logger.info(gen_log_message(message=msg, step=10, subject=subject,
session=session))
# Find the raw data file
# XXX : maybe simplify
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=config.get_runs()[0],
processing=config.proc,
recording=config.rec,
space=config.space)
trans = get_head_mri_trans(bids_basename=bids_basename,
bids_root=config.bids_root)
mne.write_trans(fname_trans, trans)
src = mne.setup_source_space(subject, spacing=config.spacing,
subjects_dir=config.get_fs_subjects_dir(),
add_dist=False)
evoked = mne.read_evokeds(fname_evoked, condition=0)
# Here we only use 3-layers BEM only if EEG is available.
if 'eeg' in config.ch_types:
model = mne.make_bem_model(subject, ico=4,
conductivity=(0.3, 0.006, 0.3),
subjects_dir=config.get_fs_subjects_dir())
else:
model = mne.make_bem_model(subject, ico=4, conductivity=(0.3,),
subjects_dir=config.get_fs_subjects_dir())
bem = mne.make_bem_solution(model)
fwd = mne.make_forward_solution(evoked.info, trans, src, bem,
mindist=config.mindist)
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def run_forward(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,
check=False)
fname_evoked = bids_basename.copy().update(kind='ave', extension='.fif')
fname_trans = bids_basename.copy().update(kind='trans', extension='.fif')
fname_fwd = bids_basename.copy().update(kind='fwd', extension='.fif')
msg = f'Input: {fname_evoked}, Output: {fname_fwd}'
logger.info(
gen_log_message(message=msg, step=10, subject=subject,
session=session))
# Find the raw data file
trans = get_head_mri_trans(bids_basename=(bids_basename.copy().update(
run=config.get_runs()[0], prefix=None)),
bids_root=config.bids_root)
mne.write_trans(fname_trans, trans)
src = mne.setup_source_space(subject,
spacing=config.spacing,
subjects_dir=config.get_fs_subjects_dir(),
add_dist=False)
evoked = mne.read_evokeds(fname_evoked, condition=0)
# Here we only use 3-layers BEM only if EEG is available.
if 'eeg' in config.ch_types:
model = mne.make_bem_model(subject,
ico=4,
conductivity=(0.3, 0.006, 0.3),
subjects_dir=config.get_fs_subjects_dir())
else:
model = mne.make_bem_model(subject,
ico=4,
conductivity=(0.3, ),
subjects_dir=config.get_fs_subjects_dir())
bem = mne.make_bem_solution(model)
fwd = mne.make_forward_solution(evoked.info,
trans,
src,
bem,
mindist=config.mindist)
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def run_forward(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_evoked = bids_path.copy().update(suffix='ave')
fname_trans = bids_path.copy().update(suffix='trans')
fname_fwd = bids_path.copy().update(suffix='fwd')
msg = f'Input: {fname_evoked}, Output: {fname_fwd}'
logger.info(
gen_log_message(message=msg, step=10, subject=subject,
session=session))
# Retrieve the head -> MRI transformation matrix from the MRI sidecar file
# in the input data, and save it to an MNE "trans" file in the derivatives
# folder.
trans = get_head_mri_trans(bids_path.copy().update(
run=config.get_runs()[0], root=config.bids_root))
mne.write_trans(fname_trans, trans)
src = mne.setup_source_space(subject,
spacing=config.spacing,
subjects_dir=config.get_fs_subjects_dir(),
add_dist=False)
evoked = mne.read_evokeds(fname_evoked, condition=0)
# Here we only use 3-layers BEM only if EEG is available.
if 'eeg' in config.ch_types:
model = mne.make_bem_model(subject,
ico=4,
conductivity=(0.3, 0.006, 0.3),
subjects_dir=config.get_fs_subjects_dir())
else:
model = mne.make_bem_model(subject,
ico=4,
conductivity=(0.3, ),
subjects_dir=config.get_fs_subjects_dir())
bem = mne.make_bem_solution(model)
fwd = mne.make_forward_solution(evoked.info,
trans,
src,
bem,
mindist=config.mindist)
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def make_forward_solution(experiment,
subject,
spacing,
process_slug=DEFAULT_PROC):
struct = sub_to_struct[experiment][subject]
if struct == 'NA':
raise IOError(
'Freesurfer Reconstruction has not yet been done for this subject. See the Freesurfer Recommended Reconstruction page.')
trans_fname = TRANS_FNAME.format(experiment=experiment, subject=subject, struct=struct)
if not os.path.isfile(trans_fname):
raise IOError(
'Coregistration has not yet been done for this subject. Use mne_analyze on big-brain and follow MNE handbook chapter 7.')
trans = mne.read_trans(trans_fname)
fwd_path = FWD_PATH.format(experiment=experiment, subject=subject)
if not os.path.exists(fwd_path):
try:
os.mkdir(fwd_path)
except:
os.mkdir(FWD_PATH.format(experiment=experiment, subject=''))
os.mkdir(fwd_path)
fwd_fname = FWD_FNAME.format(fwd_path=fwd_path, subject=subject, experiment=experiment, process_slug=process_slug,
struct=struct, spacing=spacing)
raw = mne.io.Raw(PROC_FNAME.format(experiment=experiment, subject=subject, process_slug=process_slug))
bem_path = [fn for fn in os.listdir(BEM_PATH.format(struct=struct)) if fnmatch.fnmatch(fn, '*-bem-sol.fif')]
if len(bem_path) == 0:
raise IOError('BEM has not yet been done for this subject. See MNE_pipeline_2018.sh')
bem_fname = pjoin(BEM_PATH.format(struct=struct), bem_path[0])
src_file = SRC_FNAME.format(struct=struct, spacing=spacing)
mne.set_config('SUBJECTS_DIR', SUBJ_DIR)
# Not sure how to make sure this runs effectively
if os.path.isfile(src_file):
src = mne.read_source_spaces(src_file)
else:
src = mne.setup_source_space(struct, spacing='oct6')
mne.write_source_spaces(src_file, src)
fwd = mne.make_forward_solution(raw.info, trans,
src=src,
bem=bem_fname)
mne.write_forward_solution(fwd_fname, fwd)
return fwd
def forward_model(subject, subjects_dir, fname_meg, trans, src, fwd_fname):
#conductivity = (0.3, 0.006, 0.3) # for three layers
conductivity = (0.3,) # for single layer
model = mne.make_bem_model(subject=subject, ico=4,
conductivity=conductivity,
subjects_dir=subjects_dir)
bem = mne.make_bem_solution(model)
fwd = mne.make_forward_solution(fname_meg, trans=trans, src=src, bem=bem,
meg=True, eeg=False, mindist=5.06)
# print(fwd)
mne.write_forward_solution(fwd_fname, fwd, overwrite=True, verbose=None)
def test_restrict_forward_to_stc():
"""Test restriction of source space to source SourceEstimate
"""
start = 0
stop = 5
n_times = stop - start - 1
sfreq = 10.0
t_start = 0.123
fwd = read_forward_solution(fname_meeg)
fwd = convert_forward_solution(fwd, surf_ori=True, force_fixed=True,
use_cps=True)
fwd = pick_types_forward(fwd, meg=True)
vertno = [fwd['src'][0]['vertno'][0:15], fwd['src'][1]['vertno'][0:5]]
stc_data = np.ones((len(vertno[0]) + len(vertno[1]), n_times))
stc = SourceEstimate(stc_data, vertno, tmin=t_start, tstep=1.0 / sfreq)
fwd_out = restrict_forward_to_stc(fwd, stc)
assert_true(isinstance(fwd_out, Forward))
assert_equal(fwd_out['sol']['ncol'], 20)
assert_equal(fwd_out['src'][0]['nuse'], 15)
assert_equal(fwd_out['src'][1]['nuse'], 5)
assert_equal(fwd_out['src'][0]['vertno'], fwd['src'][0]['vertno'][0:15])
assert_equal(fwd_out['src'][1]['vertno'], fwd['src'][1]['vertno'][0:5])
fwd = read_forward_solution(fname_meeg)
fwd = convert_forward_solution(fwd, surf_ori=True, force_fixed=False)
fwd = pick_types_forward(fwd, meg=True)
vertno = [fwd['src'][0]['vertno'][0:15], fwd['src'][1]['vertno'][0:5]]
stc_data = np.ones((len(vertno[0]) + len(vertno[1]), n_times))
stc = SourceEstimate(stc_data, vertno, tmin=t_start, tstep=1.0 / sfreq)
fwd_out = restrict_forward_to_stc(fwd, stc)
assert_equal(fwd_out['sol']['ncol'], 60)
assert_equal(fwd_out['src'][0]['nuse'], 15)
assert_equal(fwd_out['src'][1]['nuse'], 5)
assert_equal(fwd_out['src'][0]['vertno'], fwd['src'][0]['vertno'][0:15])
assert_equal(fwd_out['src'][1]['vertno'], fwd['src'][1]['vertno'][0:5])
# Test saving the restricted forward object. This only works if all fields
# are properly accounted for.
temp_dir = _TempDir()
fname_copy = op.join(temp_dir, 'copy-fwd.fif')
with warnings.catch_warnings(record=True):
warnings.simplefilter('always')
write_forward_solution(fname_copy, fwd_out, overwrite=True)
fwd_out_read = read_forward_solution(fname_copy)
fwd_out_read = convert_forward_solution(fwd_out_read, surf_ori=True,
force_fixed=False)
compare_forwards(fwd_out, fwd_out_read)
def test_restrict_forward_to_stc(tmpdir):
"""Test restriction of source space to source SourceEstimate."""
start = 0
stop = 5
n_times = stop - start - 1
sfreq = 10.0
t_start = 0.123
fwd = read_forward_solution(fname_meeg)
fwd = convert_forward_solution(fwd,
surf_ori=True,
force_fixed=True,
use_cps=True)
fwd = pick_types_forward(fwd, meg=True)
vertno = [fwd['src'][0]['vertno'][0:15], fwd['src'][1]['vertno'][0:5]]
stc_data = np.ones((len(vertno[0]) + len(vertno[1]), n_times))
stc = SourceEstimate(stc_data, vertno, tmin=t_start, tstep=1.0 / sfreq)
fwd_out = restrict_forward_to_stc(fwd, stc)
assert (isinstance(fwd_out, Forward))
assert_equal(fwd_out['sol']['ncol'], 20)
assert_equal(fwd_out['src'][0]['nuse'], 15)
assert_equal(fwd_out['src'][1]['nuse'], 5)
assert_equal(fwd_out['src'][0]['vertno'], fwd['src'][0]['vertno'][0:15])
assert_equal(fwd_out['src'][1]['vertno'], fwd['src'][1]['vertno'][0:5])
fwd = read_forward_solution(fname_meeg)
fwd = convert_forward_solution(fwd, surf_ori=True, force_fixed=False)
fwd = pick_types_forward(fwd, meg=True)
vertno = [fwd['src'][0]['vertno'][0:15], fwd['src'][1]['vertno'][0:5]]
stc_data = np.ones((len(vertno[0]) + len(vertno[1]), n_times))
stc = SourceEstimate(stc_data, vertno, tmin=t_start, tstep=1.0 / sfreq)
fwd_out = restrict_forward_to_stc(fwd, stc)
assert_equal(fwd_out['sol']['ncol'], 60)
assert_equal(fwd_out['src'][0]['nuse'], 15)
assert_equal(fwd_out['src'][1]['nuse'], 5)
assert_equal(fwd_out['src'][0]['vertno'], fwd['src'][0]['vertno'][0:15])
assert_equal(fwd_out['src'][1]['vertno'], fwd['src'][1]['vertno'][0:5])
# Test saving the restricted forward object. This only works if all fields
# are properly accounted for.
fname_copy = tmpdir.join('copy-fwd.fif')
with pytest.warns(RuntimeWarning, match='stored on disk'):
write_forward_solution(fname_copy, fwd_out, overwrite=True)
fwd_out_read = read_forward_solution(fname_copy)
fwd_out_read = convert_forward_solution(fwd_out_read,
surf_ori=True,
force_fixed=False)
compare_forwards(fwd_out, fwd_out_read)
def forward_pipeline(raw_fname, subject, fwd_fname=None, trans_fname=None,
subjects_dir=None, overwrite=False, ignore_ref=True):
import os.path as op
from mne.utils import get_config
if subjects_dir is None:
subjects_dir = get_config('SUBJECTS_DIR')
# Setup paths
save_dir = raw_fname.split('/')
save_dir = ('/'.join(save_dir[:-1])
if isinstance(save_dir, list) else save_dir)
bem_dir = op.join(subjects_dir, subject, 'bem')
bem_sol_fname = op.join(subjects_dir, subject, 'bem',
subject + '-5120-bem-sol.fif')
oct_fname = op.join(subjects_dir, subject, 'bem',
subject + '-oct-6-src.fif')
src_fname = op.join(bem_dir, subject + '-oct-6-src.fif')
bem_sol_fname = op.join(bem_dir, subject + '-5120-bem-sol.fif')
if trans_fname is None:
trans_fname = op.join(save_dir, subject + '-trans.fif')
if fwd_fname is None:
fwd_fname = op.join(save_dir, subject + '-meg-fwd.fif')
# 0. Checks Freesurfer segmentation and compute watershed bem
miss_anatomy = not op.isfile(src_fname) or not op.exists(bem_sol_fname)
for fname in [bem_sol_fname, oct_fname]:
if not op.isfile(op.join(subjects_dir, subject, 'bem', fname)):
miss_anatomy = True
if miss_anatomy:
raise RuntimeError('Could not find BEM (%s, %s), relaunch '
'pipeline_anatomy()' % (bem_sol_fname, oct_fname))
# 1. Manual coregisteration head markers with coils
if not op.isfile(trans_fname):
raise RuntimeError('Could not find trans (%s), launch'
'coregistration.' % trans_fname)
# 2. Forward solution
if overwrite or not op.isfile(fwd_fname):
from mne import (make_forward_solution, convert_forward_solution,
write_forward_solution)
fwd = make_forward_solution(
info=raw_fname, trans=trans_fname, src=oct_fname,
bem=bem_sol_fname, fname=None, meg=True, eeg=False, mindist=5.0,
overwrite=True, ignore_ref=ignore_ref)
# Convert to surface orientation for better visualization
fwd = convert_forward_solution(fwd, surf_ori=True)
# save
write_forward_solution(fwd_fname, fwd, overwrite=True)
return
def test_make_forward_no_meg(tmpdir):
"""Test that we can make and I/O forward solution with no MEG channels."""
pos = dict(rr=[[0.05, 0, 0]], nn=[[0, 0, 1.]])
src = setup_volume_source_space(pos=pos)
bem = make_sphere_model()
trans = None
montage = make_standard_montage('standard_1020')
info = create_info(['Cz'], 1000., 'eeg').set_montage(montage)
fwd = make_forward_solution(info, trans, src, bem)
fname = tmpdir.join('test-fwd.fif')
write_forward_solution(fname, fwd)
fwd_read = read_forward_solution(fname)
assert_allclose(fwd['sol']['data'], fwd_read['sol']['data'])
def make_forward_solution(events_id, src_fn, fwd_sub_fn, epochs_fn, cor_fn, bem_fn, sub_corticals_codes_file, usingEEG=True, n_jobs=4):
# The cortical surface source space can be setup if doens't exist
# src = mne.setup_source_space(MRI_SUBJECT, surface='pial', overwrite=True) # overwrite=True)
fwd_with_subcortical = None
src = mne.read_source_spaces(src_fn)
sub_corticals = read_sub_corticals_code_file(sub_corticals_codes_file)
for cond in events_id.keys():
if len(sub_corticals) > 0:
# add a subcortical volumes
src_with_subcortical = add_subcortical_volumes(src, sub_corticals)
fwd_with_subcortical = _make_forward_solution(src, epochs_fn, cor_fn, bem_fn, usingEEG=usingEEG, n_jobs=n_jobs)
mne.write_forward_solution(fwd_sub_fn.format(cond=cond), fwd_with_subcortical, overwrite=True)
return fwd_with_subcortical
def forward_pipeline(raw_fname, freesurfer_dir, subject,
trans_fname=None, fwd_fname=None, oct_fname=None,
bem_sol_fname=None, save_dir=None, overwrite=False):
import os.path as op
from jr.meg import check_freesurfer, mne_anatomy
# Setup paths
if save_dir is None:
save_dir = '/'.join(raw_fname.split('/')[:-1])
print('Save/read directory: %s' % save_dir)
if trans_fname is None:
trans_fname = op.join(save_dir, subject + '-trans.fif')
bem_sol_fname = op.join(freesurfer_dir, subject, 'bem',
subject + '-5120-bem-sol.fif')
oct_fname = op.join(freesurfer_dir, subject, 'bem',
subject + '-oct-6-src.fif')
fwd_fname = op.join(save_dir, subject + '-meg-fwd.fif')
# Checks Freesurfer segmentation and compute watershed bem
if check_freesurfer(subjects_dir=freesurfer_dir,
subject=subject):
mne_anatomy(subjects_dir=freesurfer_dir, subject=subject,
overwrite=overwrite)
# Manual coregisteration head markers with coils
if overwrite or not op.isfile(trans_fname):
from mne.gui import coregistration
coregistration(subject=subject, subjects_dir=freesurfer_dir,
inst=raw_fname)
# Forward solution
if overwrite or not op.exists(fwd_fname):
from mne import (make_forward_solution, convert_forward_solution,
write_forward_solution)
fwd = make_forward_solution(
raw_fname, trans_fname, oct_fname, bem_sol_fname,
fname=None, meg=True, eeg=False, mindist=5.0,
overwrite=True, ignore_ref=True)
# convert to surface orientation for better visualization
fwd = convert_forward_solution(fwd, surf_ori=True)
# save
write_forward_solution(fwd_fname, fwd, overwrite=True)
else:
from mne import read_forward_solution
fwd = read_forward_solution(fwd_fname, surf_ori=True)
return fwd
def get_forward_sol(self, info, meg=False, eeg=True, force_fixed=True):
blnOverwrite = self.blnOverwrite
srcfile = self.srcfile
transfile = self.transfile
bemfile = self.bemfile
meeg_sfx = get_meeg_suffix(bln_eeg=eeg, bln_meg=meg)
fwdfile = get_fwdfile(self.mne_outputpath, self.filebasestr,
self.spacing_string, meeg_sfx)
#
# Compute forward solution
#
log.info('Reading the source space')
src = mne.read_source_spaces(srcfile, patch_stats=True, verbose=None)
if not blnOverwrite and op.isfile(fwdfile):
log.info('Loading the forward solution')
fwd = mne.read_forward_solution(fwdfile,
include=[],
exclude=[],
verbose=None)
else:
log.info('Making the forward solution')
fwd = mne.make_forward_solution(info,
transfile,
src,
bemfile,
meg=meg,
eeg=eeg,
mindist=5.0,
ignore_ref=False)
mne.write_forward_solution(fwdfile, fwd, overwrite=blnOverwrite)
fwd = mne.convert_forward_solution(fwd,
surf_ori=True,
force_fixed=force_fixed,
copy=False,
use_cps=True,
verbose=None)
log.info('[Done]')
return src, fwd
def test_io_forward():
"""Test IO for forward solutions
"""
# test M/EEG
fwd_meeg = read_forward_solution(fname_meeg)
leadfield = fwd_meeg['sol']['data']
assert_equal(leadfield.shape, (366, 22494))
assert_equal(len(fwd_meeg['sol']['row_names']), 366)
fname_temp = op.join(temp_dir, 'fwd.fif')
write_forward_solution(fname_temp, fwd_meeg, overwrite=True)
fwd_meeg = read_forward_solution(fname_temp)
assert_allclose(leadfield, fwd_meeg['sol']['data'])
assert_equal(len(fwd_meeg['sol']['row_names']), 366)
# now do extensive tests with MEG
fwd = read_forward_solution(fname)
fwd = read_forward_solution(fname, surf_ori=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (306, 22494))
assert_equal(len(fwd['sol']['row_names']), 306)
fname_temp = op.join(temp_dir, 'fwd.fif')
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd = read_forward_solution(fname, surf_ori=True)
fwd_read = read_forward_solution(fname_temp, surf_ori=True)
leadfield = fwd_read['sol']['data']
assert_equal(leadfield.shape, (306, 22494))
assert_equal(len(fwd_read['sol']['row_names']), 306)
assert_equal(len(fwd_read['info']['chs']), 306)
assert_true('dev_head_t' in fwd_read['info'])
assert_true('mri_head_t' in fwd_read)
assert_array_almost_equal(fwd['sol']['data'], fwd_read['sol']['data'])
fwd = read_forward_solution(fname, force_fixed=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (306, 22494 / 3))
assert_equal(len(fwd['sol']['row_names']), 306)
assert_equal(len(fwd['info']['chs']), 306)
assert_true('dev_head_t' in fwd['info'])
assert_true('mri_head_t' in fwd)
assert_true(fwd['surf_ori'])
def test_io_forward():
"""Test IO for forward solutions
"""
# test M/EEG
fwd_meeg = read_forward_solution(fname_meeg)
leadfield = fwd_meeg['sol']['data']
assert_equal(leadfield.shape, (366, 22494))
assert_equal(len(fwd_meeg['sol']['row_names']), 366)
fname_temp = op.join(temp_dir, 'fwd.fif')
write_forward_solution(fname_temp, fwd_meeg, overwrite=True)
fwd_meeg = read_forward_solution(fname_temp)
assert_allclose(leadfield, fwd_meeg['sol']['data'])
assert_equal(len(fwd_meeg['sol']['row_names']), 366)
# now do extensive tests with MEG
fwd = read_forward_solution(fname)
fwd = read_forward_solution(fname, surf_ori=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (306, 22494))
assert_equal(len(fwd['sol']['row_names']), 306)
fname_temp = op.join(temp_dir, 'fwd.fif')
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd = read_forward_solution(fname, surf_ori=True)
fwd_read = read_forward_solution(fname_temp, surf_ori=True)
leadfield = fwd_read['sol']['data']
assert_equal(leadfield.shape, (306, 22494))
assert_equal(len(fwd_read['sol']['row_names']), 306)
assert_equal(len(fwd_read['info']['chs']), 306)
assert_true('dev_head_t' in fwd_read['info'])
assert_true('mri_head_t' in fwd_read)
assert_array_almost_equal(fwd['sol']['data'], fwd_read['sol']['data'])
fwd = read_forward_solution(fname, force_fixed=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (306, 22494 / 3))
assert_equal(len(fwd['sol']['row_names']), 306)
assert_equal(len(fwd['info']['chs']), 306)
assert_true('dev_head_t' in fwd['info'])
assert_true('mri_head_t' in fwd)
assert_true(fwd['surf_ori'])
def make_fwd_solution(cond_fname, subj, study_path):
eeg_epo = mne.read_epochs(cond_fname + '-epo.fif')
trans_fname = op.join(study_path, 'source_stim', 'images', subj, '%s_coreg-trans.fif' % subj)
src_fname = op.join(study_path, 'source_stim', 'images', subj, '%s-oct5-src.fif' % subj)
bem_fname = op.join(study_path, 'freesurfer_subjects', '%s' % subj, 'bem', '%s-bem-sol.fif' % subj)
fwd = mne.make_forward_solution(eeg_epo.info, trans_fname, src_fname, bem_fname)
mne.viz.plot_bem(subject='S1', subjects_dir=subjects_dir, src=src_fname)
mne.viz.plot_bem(subject='S3', subjects_dir=subjects_dir)
# trans = mne.read_trans(trans_fname)
# mne.viz.plot_alignment(eeg_epo.info, trans, subject='%s' % subj, subjects_dir=op.join(study_path, 'freesurfer_subjects'))
# mlab.show()
# mne.scale_bem('%s_coreg' % subj, 'bem-sol', subjects_dir=subjects_dir)
mne.write_forward_solution(op.join(study_path, 'source_stim', 'images', subj, '%s-fwd.fif' % subj), fwd, overwrite=True)
return fwd
def create_forward_solution(name, save_dir, subject, subjects_dir,
overwrite):
forward_name = name + '-fwd.fif'
forward_path = join(save_dir, forward_name)
if overwrite or not isfile(forward_path):
info = io.read_info(name, save_dir)
trans = io.read_transformation(name, save_dir)
bem = io.read_bem_solution(subject, subjects_dir)
source_space = io.read_source_space(subject, subjects_dir)
forward = mne.make_forward_solution(info, trans, source_space, bem,
n_jobs=1)
mne.write_forward_solution(forward_path, forward, overwrite)
else:
print('forward solution: ' + forward_path + ' already exists')
def test_io_forward():
"""Test IO for forward solutions
"""
# test M/EEG
fwd_meeg = read_forward_solution(fname_meeg)
leadfield = fwd_meeg["sol"]["data"]
assert_equal(leadfield.shape, (366, 22494))
assert_equal(len(fwd_meeg["sol"]["row_names"]), 366)
fname_temp = op.join(temp_dir, "fwd.fif")
write_forward_solution(fname_temp, fwd_meeg, overwrite=True)
fwd_meeg = read_forward_solution(fname_temp)
assert_allclose(leadfield, fwd_meeg["sol"]["data"])
assert_equal(len(fwd_meeg["sol"]["row_names"]), 366)
# now do extensive tests with MEG
fwd = read_forward_solution(fname)
fwd = read_forward_solution(fname, surf_ori=True)
leadfield = fwd["sol"]["data"]
assert_equal(leadfield.shape, (306, 22494))
assert_equal(len(fwd["sol"]["row_names"]), 306)
fname_temp = op.join(temp_dir, "fwd.fif")
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd = read_forward_solution(fname, surf_ori=True)
fwd_read = read_forward_solution(fname_temp, surf_ori=True)
leadfield = fwd_read["sol"]["data"]
assert_equal(leadfield.shape, (306, 22494))
assert_equal(len(fwd_read["sol"]["row_names"]), 306)
assert_equal(len(fwd_read["info"]["chs"]), 306)
assert_true("dev_head_t" in fwd_read["info"])
assert_true("mri_head_t" in fwd_read)
assert_array_almost_equal(fwd["sol"]["data"], fwd_read["sol"]["data"])
fwd = read_forward_solution(fname, force_fixed=True)
leadfield = fwd["sol"]["data"]
assert_equal(leadfield.shape, (306, 22494 / 3))
assert_equal(len(fwd["sol"]["row_names"]), 306)
assert_equal(len(fwd["info"]["chs"]), 306)
assert_true("dev_head_t" in fwd["info"])
assert_true("mri_head_t" in fwd)
def make_vol_fwd(epochs, fs_subj, study_path, subjects_dir):
cond = epochs.info['description']
bem_fname = op.join(subjects_dir, fs_subj, 'bem', '%s-bem-sol.fif' % fs_subj)
trans_fname = op.join(study_path, 'source_stim', subj, 'source_files', img_type, '%s_fid-trans.fif' % fs_subj)
mri_file = op.join(subjects_dir, subj, 'mri', 'T1.mgz')
v_source = mne.setup_volume_source_space(subject=fs_subj, mri=mri_file, bem=bem_fname, subjects_dir=subjects_dir,
pos=5.)
mne.viz.plot_alignment(epochs.info, trans=trans_fname, subject=fs_subj, subjects_dir=subjects_dir,
surfaces=['seghead', 'brain'], bem=bem_fname, coord_frame='mri') #, src=v_source
fwd = mne.make_forward_solution(epochs.info, trans_fname, v_source, bem_fname,
mindist=5.0, # ignore sources<=5mm from innerskull
meg=False, eeg=True,
n_jobs=3)
mne.write_forward_solution(op.join(study_path, 'source_stim', subj, 'source_files', img_type,
'%s_vol_source_space_5mm-fwd.fif' % subj), fwd, overwrite=True)
return fwd
def test_average_forward_solution():
"""Test averaging forward solutions
"""
temp_dir = _TempDir()
fwd = read_forward_solution(fname_meeg)
# input not a list
assert_raises(TypeError, average_forward_solutions, 1)
# list is too short
assert_raises(ValueError, average_forward_solutions, [])
# negative weights
assert_raises(ValueError, average_forward_solutions, [fwd, fwd], [-1, 0])
# all zero weights
assert_raises(ValueError, average_forward_solutions, [fwd, fwd], [0, 0])
# weights not same length
assert_raises(ValueError, average_forward_solutions, [fwd, fwd], [0, 0, 0])
# list does not only have all dict()
assert_raises(TypeError, average_forward_solutions, [1, fwd])
# try an easy case
fwd_copy = average_forward_solutions([fwd])
assert_true(isinstance(fwd_copy, Forward))
assert_array_equal(fwd["sol"]["data"], fwd_copy["sol"]["data"])
# modify a fwd solution, save it, use MNE to average with old one
fwd_copy["sol"]["data"] *= 0.5
fname_copy = op.join(temp_dir, "copy-fwd.fif")
write_forward_solution(fname_copy, fwd_copy, overwrite=True)
cmd = ("mne_average_forward_solutions", "--fwd", fname_meeg, "--fwd", fname_copy, "--out", fname_copy)
run_subprocess(cmd)
# now let's actually do it, with one filename and one fwd
fwd_ave = average_forward_solutions([fwd, fwd_copy])
assert_array_equal(0.75 * fwd["sol"]["data"], fwd_ave["sol"]["data"])
# fwd_ave_mne = read_forward_solution(fname_copy)
# assert_array_equal(fwd_ave_mne['sol']['data'], fwd_ave['sol']['data'])
# with gradient
fwd = read_forward_solution(fname_meeg_grad)
fwd_ave = average_forward_solutions([fwd, fwd])
compare_forwards(fwd, fwd_ave)
def test_average_forward_solution():
"""Test averaging forward solutions."""
temp_dir = _TempDir()
fwd = read_forward_solution(fname_meeg)
# input not a list
pytest.raises(TypeError, average_forward_solutions, 1)
# list is too short
pytest.raises(ValueError, average_forward_solutions, [])
# negative weights
pytest.raises(ValueError, average_forward_solutions, [fwd, fwd], [-1, 0])
# all zero weights
pytest.raises(ValueError, average_forward_solutions, [fwd, fwd], [0, 0])
# weights not same length
pytest.raises(ValueError, average_forward_solutions, [fwd, fwd], [0, 0, 0])
# list does not only have all dict()
pytest.raises(TypeError, average_forward_solutions, [1, fwd])
# try an easy case
fwd_copy = average_forward_solutions([fwd])
assert (isinstance(fwd_copy, Forward))
assert_array_equal(fwd['sol']['data'], fwd_copy['sol']['data'])
# modify a fwd solution, save it, use MNE to average with old one
fwd_copy['sol']['data'] *= 0.5
fname_copy = op.join(temp_dir, 'copy-fwd.fif')
write_forward_solution(fname_copy, fwd_copy, overwrite=True)
cmd = ('mne_average_forward_solutions', '--fwd', fname_meeg, '--fwd',
fname_copy, '--out', fname_copy)
run_subprocess(cmd)
# now let's actually do it, with one filename and one fwd
fwd_ave = average_forward_solutions([fwd, fwd_copy])
assert_array_equal(0.75 * fwd['sol']['data'], fwd_ave['sol']['data'])
# fwd_ave_mne = read_forward_solution(fname_copy)
# assert_array_equal(fwd_ave_mne['sol']['data'], fwd_ave['sol']['data'])
# with gradient
fwd = read_forward_solution(fname_meeg_grad)
fwd_ave = average_forward_solutions([fwd, fwd])
compare_forwards(fwd, fwd_ave)
def compute_forward(info, bem, src, trans_fname, read_from_disk=False,
fwd_fname=None, save_to_disk=False):
"""Compute forward solution.
Reads or computes forward solution.
Parameters:
-----------
info : dict
info from epoch, contains channel positions etc.
bem : headmodel or path
BEM model or path to BEM model.
src : source space
source grid.
trans_fname : path
path to transformation matrix.
read_from_disk : bool
if True, read pre-computed fwd model from disk.
fwd_fname : path
path to fwd model on disk, either for saving or reading.
save_to_disk : bool
whether fwd model should be saved to disk.
Returns
-------
fwd : dict.
MNE forward operator
"""
if read_from_disk is True:
fwd = mne.read_forward_solution(fwd_fname)
else:
fwd = mne.make_forward_solution(info, trans=trans_fname,
src=src, bem=bem, meg=True,
eeg=False, n_jobs=1)
if save_to_disk is True:
mne.write_forward_solution(fwd_fname, fwd, overwrite=True)
return fwd
def test_io_forward():
"""Test IO for forward solutions
"""
# test M/EEG
fwd_meeg = read_forward_solution(fname_meeg)
assert_true(isinstance(fwd_meeg, Forward))
leadfield = fwd_meeg['sol']['data']
assert_equal(leadfield.shape, (366, 22494))
assert_equal(len(fwd_meeg['sol']['row_names']), 366)
fname_temp = op.join(temp_dir, 'test-fwd.fif')
write_forward_solution(fname_temp, fwd_meeg, overwrite=True)
fwd_meeg = read_forward_solution(fname_temp)
assert_allclose(leadfield, fwd_meeg['sol']['data'])
assert_equal(len(fwd_meeg['sol']['row_names']), 366)
# now do extensive tests with MEG
fwd = read_forward_solution(fname)
fwd = read_forward_solution(fname, surf_ori=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (306, 22494))
assert_equal(len(fwd['sol']['row_names']), 306)
fname_temp = op.join(temp_dir, 'test-fwd.fif')
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd = read_forward_solution(fname, surf_ori=True)
fwd_read = read_forward_solution(fname_temp, surf_ori=True)
leadfield = fwd_read['sol']['data']
assert_equal(leadfield.shape, (306, 22494))
assert_equal(len(fwd_read['sol']['row_names']), 306)
assert_equal(len(fwd_read['info']['chs']), 306)
assert_true('dev_head_t' in fwd_read['info'])
assert_true('mri_head_t' in fwd_read)
assert_array_almost_equal(fwd['sol']['data'], fwd_read['sol']['data'])
fwd = read_forward_solution(fname, force_fixed=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (306, 22494 / 3))
assert_equal(len(fwd['sol']['row_names']), 306)
assert_equal(len(fwd['info']['chs']), 306)
assert_true('dev_head_t' in fwd['info'])
assert_true('mri_head_t' in fwd)
assert_true(fwd['surf_ori'])
# test warnings on bad filenames
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
fwd_badname = op.join(temp_dir, 'test-bad-name.fif.gz')
write_forward_solution(fwd_badname, fwd_meeg)
read_forward_solution(fwd_badname)
assert_true(len(w) == 2)
def test_io_forward():
"""Test IO for forward solutions
"""
temp_dir = _TempDir()
# do extensive tests with MEEG + grad
n_channels, n_src = 366, 108
fwd = read_forward_solution(fname_meeg_grad)
assert_true(isinstance(fwd, Forward))
fwd = read_forward_solution(fname_meeg_grad, surf_ori=True)
leadfield = fwd["sol"]["data"]
assert_equal(leadfield.shape, (n_channels, n_src))
assert_equal(len(fwd["sol"]["row_names"]), n_channels)
fname_temp = op.join(temp_dir, "test-fwd.fif")
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd = read_forward_solution(fname_meeg_grad, surf_ori=True)
fwd_read = read_forward_solution(fname_temp, surf_ori=True)
leadfield = fwd_read["sol"]["data"]
assert_equal(leadfield.shape, (n_channels, n_src))
assert_equal(len(fwd_read["sol"]["row_names"]), n_channels)
assert_equal(len(fwd_read["info"]["chs"]), n_channels)
assert_true("dev_head_t" in fwd_read["info"])
assert_true("mri_head_t" in fwd_read)
assert_array_almost_equal(fwd["sol"]["data"], fwd_read["sol"]["data"])
fwd = read_forward_solution(fname_meeg_grad, force_fixed=True)
leadfield = fwd["sol"]["data"]
assert_equal(leadfield.shape, (n_channels, n_src / 3))
assert_equal(len(fwd["sol"]["row_names"]), n_channels)
assert_equal(len(fwd["info"]["chs"]), n_channels)
assert_true("dev_head_t" in fwd["info"])
assert_true("mri_head_t" in fwd)
assert_true(fwd["surf_ori"])
# test warnings on bad filenames
fwd = read_forward_solution(fname_meeg_grad)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
fwd_badname = op.join(temp_dir, "test-bad-name.fif.gz")
write_forward_solution(fwd_badname, fwd)
read_forward_solution(fwd_badname)
assert_naming(w, "test_forward.py", 2)
fwd = read_forward_solution(fname_meeg)
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd_read = read_forward_solution(fname_temp)
compare_forwards(fwd, fwd_read)
def test_io_forward():
"""Test IO for forward solutions
"""
temp_dir = _TempDir()
# do extensive tests with MEEG + grad
n_channels, n_src = 366, 108
fwd = read_forward_solution(fname_meeg_grad)
assert_true(isinstance(fwd, Forward))
fwd = read_forward_solution(fname_meeg_grad, surf_ori=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (n_channels, n_src))
assert_equal(len(fwd['sol']['row_names']), n_channels)
fname_temp = op.join(temp_dir, 'test-fwd.fif')
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd = read_forward_solution(fname_meeg_grad, surf_ori=True)
fwd_read = read_forward_solution(fname_temp, surf_ori=True)
leadfield = fwd_read['sol']['data']
assert_equal(leadfield.shape, (n_channels, n_src))
assert_equal(len(fwd_read['sol']['row_names']), n_channels)
assert_equal(len(fwd_read['info']['chs']), n_channels)
assert_true('dev_head_t' in fwd_read['info'])
assert_true('mri_head_t' in fwd_read)
assert_array_almost_equal(fwd['sol']['data'], fwd_read['sol']['data'])
fwd = read_forward_solution(fname_meeg_grad, force_fixed=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (n_channels, n_src / 3))
assert_equal(len(fwd['sol']['row_names']), n_channels)
assert_equal(len(fwd['info']['chs']), n_channels)
assert_true('dev_head_t' in fwd['info'])
assert_true('mri_head_t' in fwd)
assert_true(fwd['surf_ori'])
# test warnings on bad filenames
fwd = read_forward_solution(fname_meeg_grad)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
fwd_badname = op.join(temp_dir, 'test-bad-name.fif.gz')
write_forward_solution(fwd_badname, fwd)
read_forward_solution(fwd_badname)
assert_true(len(w) == 2)
fwd = read_forward_solution(fname_meeg)
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd_read = read_forward_solution(fname_temp)
compare_forwards(fwd, fwd_read)
def test_io_forward():
"""Test IO for forward solutions."""
temp_dir = _TempDir()
# do extensive tests with MEEG + grad
n_channels, n_src = 366, 108
fwd = read_forward_solution(fname_meeg_grad)
assert (isinstance(fwd, Forward))
fwd = read_forward_solution(fname_meeg_grad)
fwd = convert_forward_solution(fwd, surf_ori=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (n_channels, n_src))
assert_equal(len(fwd['sol']['row_names']), n_channels)
fname_temp = op.join(temp_dir, 'test-fwd.fif')
with pytest.warns(RuntimeWarning, match='stored on disk'):
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd = read_forward_solution(fname_meeg_grad)
fwd = convert_forward_solution(fwd, surf_ori=True)
fwd_read = read_forward_solution(fname_temp)
fwd_read = convert_forward_solution(fwd_read, surf_ori=True)
leadfield = fwd_read['sol']['data']
assert_equal(leadfield.shape, (n_channels, n_src))
assert_equal(len(fwd_read['sol']['row_names']), n_channels)
assert_equal(len(fwd_read['info']['chs']), n_channels)
assert ('dev_head_t' in fwd_read['info'])
assert ('mri_head_t' in fwd_read)
assert_array_almost_equal(fwd['sol']['data'], fwd_read['sol']['data'])
fwd = read_forward_solution(fname_meeg)
fwd = convert_forward_solution(fwd, surf_ori=True, force_fixed=True,
use_cps=False)
with pytest.warns(RuntimeWarning, match='stored on disk'):
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd_read = read_forward_solution(fname_temp)
fwd_read = convert_forward_solution(fwd_read, surf_ori=True,
force_fixed=True, use_cps=False)
assert (repr(fwd_read))
assert (isinstance(fwd_read, Forward))
assert (is_fixed_orient(fwd_read))
compare_forwards(fwd, fwd_read)
fwd = convert_forward_solution(fwd, surf_ori=True, force_fixed=True,
use_cps=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (n_channels, 1494 / 3))
assert_equal(len(fwd['sol']['row_names']), n_channels)
assert_equal(len(fwd['info']['chs']), n_channels)
assert ('dev_head_t' in fwd['info'])
assert ('mri_head_t' in fwd)
assert (fwd['surf_ori'])
with pytest.warns(RuntimeWarning, match='stored on disk'):
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd_read = read_forward_solution(fname_temp)
fwd_read = convert_forward_solution(fwd_read, surf_ori=True,
force_fixed=True, use_cps=True)
assert (repr(fwd_read))
assert (isinstance(fwd_read, Forward))
assert (is_fixed_orient(fwd_read))
compare_forwards(fwd, fwd_read)
fwd = read_forward_solution(fname_meeg_grad)
fwd = convert_forward_solution(fwd, surf_ori=True, force_fixed=True,
use_cps=True)
leadfield = fwd['sol']['data']
assert_equal(leadfield.shape, (n_channels, n_src / 3))
assert_equal(len(fwd['sol']['row_names']), n_channels)
assert_equal(len(fwd['info']['chs']), n_channels)
assert ('dev_head_t' in fwd['info'])
assert ('mri_head_t' in fwd)
assert (fwd['surf_ori'])
with pytest.warns(RuntimeWarning, match='stored on disk'):
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd_read = read_forward_solution(fname_temp)
fwd_read = convert_forward_solution(fwd_read, surf_ori=True,
force_fixed=True, use_cps=True)
assert (repr(fwd_read))
assert (isinstance(fwd_read, Forward))
assert (is_fixed_orient(fwd_read))
compare_forwards(fwd, fwd_read)
# test warnings on bad filenames
fwd = read_forward_solution(fname_meeg_grad)
fwd_badname = op.join(temp_dir, 'test-bad-name.fif.gz')
with pytest.warns(RuntimeWarning, match='end with'):
write_forward_solution(fwd_badname, fwd)
with pytest.warns(RuntimeWarning, match='end with'):
read_forward_solution(fwd_badname)
fwd = read_forward_solution(fname_meeg)
write_forward_solution(fname_temp, fwd, overwrite=True)
fwd_read = read_forward_solution(fname_temp)
compare_forwards(fwd, fwd_read)
import sys
import glob
from my_settings import (save_folder, mne_folder, subjects_dir)
subject = sys.argv[1]
raw_fname = save_folder + "%s_filtered_ica_mc_raw_tsss.fif" % subject
trans_fname = mne_folder + "%s-trans.fif" % subject
cov = mne.read_cov(mne_folder + "%s-cov.fif" % subject)
bem = glob.glob(mne_folder + "%s-8192-8192*sol.fif" % subject)[0]
src = subjects_dir + "%s/bem/%s-oct-6-src.fif" % (subject, subject)
raw = mne.io.Raw(raw_fname)
raw.del_proj(0)
raw.set_eeg_reference()
# src = mne.setup_source_space(subject,
# mne_folder + "%s-all-src.fif" % subject,
# spacing="all",
# subjects_dir=subjects_dir,
# n_jobs=1,
# overwrite=True) # 1 for each hemispere
fwd = mne.make_forward_solution(
raw_fname, trans=trans_fname, src=src, bem=bem, meg=True, eeg=True)
mne.write_forward_solution(
mne_folder + "%s-fwd.fif" % subject, fwd, overwrite=True)
# Create BEM model
conductivity = (0.3,) # for single layer
#conductivity = (0.3, 0.006, 0.3) # for three layers
model = mne.make_bem_model(subject=subject, ico=5, # 5=20484, 4=5120
conductivity=conductivity,
subjects_dir=fs_dir)
bem = mne.make_bem_solution(model)
fn = session1[n] + '-bem-sol.fif'
mne.write_bem_solution(fn,bem)
# Now create forward model
fwd = mne.make_forward_solution(info, trans=trans, src=src, bem=bem,
fname=None, meg=True, eeg=False,
mindist=3.0, n_jobs=18)
fn = session1[n] + '-fwd.fif'
mne.write_forward_solution(fn,fwd,overwrite=True)
#Inverse here
os.chdir('../covariance')
fn = session1[n] + '-40-sss-cov.fif'
cov = mne.read_cov(fn)
os.chdir('../inverse')
inv = mne.minimum_norm.make_inverse_operator(info, fwd, cov, loose=0.2, depth=0.8)
fn = session1[n] + '-inv-ico5.fif'
mne.minimum_norm.write_inverse_operator(fn,inv)
def test_make_forward_solution_kit():
"""Test making fwd using KIT, BTI, and CTF (compensated) files."""
kit_dir = op.join(op.dirname(__file__), '..', '..', 'io', 'kit',
'tests', 'data')
sqd_path = op.join(kit_dir, 'test.sqd')
mrk_path = op.join(kit_dir, 'test_mrk.sqd')
elp_path = op.join(kit_dir, 'test_elp.txt')
hsp_path = op.join(kit_dir, 'test_hsp.txt')
trans_path = op.join(kit_dir, 'trans-sample.fif')
fname_kit_raw = op.join(kit_dir, 'test_bin_raw.fif')
bti_dir = op.join(op.dirname(__file__), '..', '..', 'io', 'bti',
'tests', 'data')
bti_pdf = op.join(bti_dir, 'test_pdf_linux')
bti_config = op.join(bti_dir, 'test_config_linux')
bti_hs = op.join(bti_dir, 'test_hs_linux')
fname_bti_raw = op.join(bti_dir, 'exported4D_linux_raw.fif')
fname_ctf_raw = op.join(op.dirname(__file__), '..', '..', 'io', 'tests',
'data', 'test_ctf_comp_raw.fif')
# first set up a small testing source space
temp_dir = _TempDir()
fname_src_small = op.join(temp_dir, 'sample-oct-2-src.fif')
src = setup_source_space('sample', 'oct2', subjects_dir=subjects_dir,
add_dist=False)
write_source_spaces(fname_src_small, src) # to enable working with MNE-C
n_src = 108 # this is the resulting # of verts in fwd
# first use mne-C: convert file, make forward solution
fwd = _do_forward_solution('sample', fname_kit_raw, src=fname_src_small,
bem=fname_bem_meg, mri=trans_path,
eeg=False, meg=True, subjects_dir=subjects_dir)
assert (isinstance(fwd, Forward))
# now let's use python with the same raw file
fwd_py = make_forward_solution(fname_kit_raw, trans_path, src,
fname_bem_meg, eeg=False, meg=True)
_compare_forwards(fwd, fwd_py, 157, n_src)
assert (isinstance(fwd_py, Forward))
# now let's use mne-python all the way
raw_py = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path)
# without ignore_ref=True, this should throw an error:
pytest.raises(NotImplementedError, make_forward_solution, raw_py.info,
src=src, eeg=False, meg=True,
bem=fname_bem_meg, trans=trans_path)
# check that asking for eeg channels (even if they don't exist) is handled
meg_only_info = pick_info(raw_py.info, pick_types(raw_py.info, meg=True,
eeg=False))
fwd_py = make_forward_solution(meg_only_info, src=src, meg=True, eeg=True,
bem=fname_bem_meg, trans=trans_path,
ignore_ref=True)
_compare_forwards(fwd, fwd_py, 157, n_src,
meg_rtol=1e-3, meg_atol=1e-7)
# BTI python end-to-end versus C
fwd = _do_forward_solution('sample', fname_bti_raw, src=fname_src_small,
bem=fname_bem_meg, mri=trans_path,
eeg=False, meg=True, subjects_dir=subjects_dir)
raw_py = read_raw_bti(bti_pdf, bti_config, bti_hs, preload=False)
fwd_py = make_forward_solution(raw_py.info, src=src, eeg=False, meg=True,
bem=fname_bem_meg, trans=trans_path)
_compare_forwards(fwd, fwd_py, 248, n_src)
# now let's test CTF w/compensation
fwd_py = make_forward_solution(fname_ctf_raw, fname_trans, src,
fname_bem_meg, eeg=False, meg=True)
fwd = _do_forward_solution('sample', fname_ctf_raw, mri=fname_trans,
src=fname_src_small, bem=fname_bem_meg,
eeg=False, meg=True, subjects_dir=subjects_dir)
_compare_forwards(fwd, fwd_py, 274, n_src)
# CTF with compensation changed in python
ctf_raw = read_raw_fif(fname_ctf_raw)
ctf_raw.info['bads'] = ['MRO24-2908'] # test that it works with some bads
ctf_raw.apply_gradient_compensation(2)
fwd_py = make_forward_solution(ctf_raw.info, fname_trans, src,
fname_bem_meg, eeg=False, meg=True)
fwd = _do_forward_solution('sample', ctf_raw, mri=fname_trans,
src=fname_src_small, bem=fname_bem_meg,
eeg=False, meg=True,
subjects_dir=subjects_dir)
_compare_forwards(fwd, fwd_py, 274, n_src)
temp_dir = _TempDir()
fname_temp = op.join(temp_dir, 'test-ctf-fwd.fif')
write_forward_solution(fname_temp, fwd_py)
fwd_py2 = read_forward_solution(fname_temp)
_compare_forwards(fwd_py, fwd_py2, 274, n_src)
repr(fwd_py)
sys.exit()
subjects_dir = '/home/qdong/freesurfer/subjects/'
subject_path = subjects_dir + subject#Set the data path of the subject
fname_evoked = subject_path + '/MEG/ave_' + subject + '_audi_cued-raw_cle_%s.fif' %trigger#MEG data
evoked = Evoked(fname_evoked, setno=0, baseline=(None, 0))
mri = subject_path + '/MEG/' + subject + '-trans.fif'#Set the path of coordinates trans data
src = subject_path + '/bem/' + subject + '-ico-4-src.fif'#Set the path of src including dipole locations and orientations
bem = subject_path + '/bem/' + subject + '-5120-5120-5120-bem-sol.fif'#Set the path of file including the triangulation and conducivity\
#information together with the BEM
fname_cov = subject_path + '/MEG/' + subject + '_emptyroom_cov.fif'#Empty room noise covariance
fwd = mne.make_forward_solution(evoked.info, mri=mri, src=src, bem=bem,
fname=None, meg=True, eeg=False, mindist=5.0,
n_jobs=2, overwrite=True)
fwd = mne.convert_forward_solution(fwd, surf_ori=True)
mne.write_forward_solution(subject_path+'/%s_%s-fwd.fif' %(subject, trigger), fwd, overwrite=True)
#############################################################################
# make_inverse_operator #
#############################################################################
snr = 3.0
lambda2 = 1.0 / snr ** 2
noise_cov = mne.read_cov(fname_cov)
# regularize noise covariance
noise_cov = mne.read_cov(fname_cov)
noise_cov = mne.cov.regularize(noise_cov, evoked.info,
mag=0.05, proj=True)
def get_mne_sample(tmin=-0.1, tmax=0.4, baseline=(None, 0), sns=False,
src=None, sub="modality=='A'", ori='free', snr=2,
method='dSPM', rm=False, stc=False, hpf=0):
"""Load events and epochs from the MNE sample data
Parameters
----------
tmin : scalar
Relative time of the first sample of the epoch.
tmax : scalar
Relative time of the last sample of the epoch.
baseline : {None, tuple of 2 {scalar, None}}
Period for baseline correction.
sns : bool | str
Add sensor space data as NDVar as ``ds['meg']`` (default ``False``).
Set to ``'grad'`` to load gradiometer data.
src : False | 'ico' | 'vol'
Add source space data as NDVar as ``ds['src']`` (default ``False``).
sub : str | list | None
Expression for subset of events to load. For a very small dataset use e.g.
``[0,1]``.
ori : 'free' | 'fixed' | 'vector'
Orientation of sources.
snr : scalar
MNE inverse parameter.
method : str
MNE inverse parameter.
rm : bool
Pretend to be a repeated measures dataset (adds 'subject' variable).
stc : bool
Add mne SourceEstimate for source space data as ``ds['stc']`` (default
``False``).
hpf : scalar
High pass filter cutoff.
Returns
-------
ds : Dataset
Dataset with epochs from the MNE sample dataset in ``ds['epochs']``.
"""
if ori == 'free':
loose = 1
fixed = False
pick_ori = None
elif ori == 'fixed':
loose = 0
fixed = True
pick_ori = None
elif ori == 'vector':
if LooseVersion(mne.__version__) < LooseVersion('0.17'):
raise RuntimeError(f'mne version {mne.__version__}; vector source estimates require mne 0.17')
loose = 1
fixed = False
pick_ori = 'vector'
else:
raise ValueError(f"ori={ori!r}")
data_dir = mne.datasets.sample.data_path()
meg_dir = os.path.join(data_dir, 'MEG', 'sample')
raw_file = os.path.join(meg_dir, 'sample_audvis_filt-0-40_raw.fif')
event_file = os.path.join(meg_dir, 'sample_audvis_filt-0-40-eve.fif')
subjects_dir = os.path.join(data_dir, 'subjects')
subject = 'sample'
label_path = os.path.join(subjects_dir, subject, 'label', '%s.label')
if not os.path.exists(event_file):
raw = mne.io.Raw(raw_file)
events = mne.find_events(raw, stim_channel='STI 014')
mne.write_events(event_file, events)
ds = load.fiff.events(raw_file, events=event_file)
if hpf:
ds.info['raw'].load_data()
ds.info['raw'].filter(hpf, None)
ds.index()
ds.info['subjects_dir'] = subjects_dir
ds.info['subject'] = subject
ds.info['label'] = label_path
# get the trigger variable form the dataset for eaier access
trigger = ds['trigger']
# use trigger to add various labels to the dataset
ds['condition'] = Factor(trigger, labels={
1: 'LA', 2: 'RA', 3: 'LV', 4: 'RV', 5: 'smiley', 32: 'button'})
ds['side'] = Factor(trigger, labels={
1: 'L', 2: 'R', 3: 'L', 4: 'R', 5: 'None', 32: 'None'})
ds['modality'] = Factor(trigger, labels={
1: 'A', 2: 'A', 3: 'V', 4: 'V', 5: 'None', 32: 'None'})
if rm:
ds = ds.sub('trigger < 5')
ds = ds.equalize_counts('side % modality')
subject_f = ds.eval('side % modality').enumerate_cells()
ds['subject'] = subject_f.as_factor('s%r', random=True)
if sub:
ds = ds.sub(sub)
load.fiff.add_mne_epochs(ds, tmin, tmax, baseline)
if sns:
ds['meg'] = load.fiff.epochs_ndvar(ds['epochs'],
data='mag' if sns is True else sns,
sysname='neuromag')
if not src:
return ds
elif src == 'ico':
src_tag = 'ico-4'
elif src == 'vol':
src_tag = 'vol-10'
else:
raise ValueError("src = %r" % src)
epochs = ds['epochs']
# get inverse operator
inv_file = os.path.join(meg_dir, f'sample_eelbrain_{src_tag}-inv.fif')
if os.path.exists(inv_file):
inv = mne.minimum_norm.read_inverse_operator(inv_file)
else:
fwd_file = os.path.join(meg_dir, 'sample-%s-fwd.fif' % src_tag)
bem_dir = os.path.join(subjects_dir, subject, 'bem')
bem_file = os.path.join(bem_dir, 'sample-5120-5120-5120-bem-sol.fif')
trans_file = os.path.join(meg_dir, 'sample_audvis_raw-trans.fif')
if os.path.exists(fwd_file):
fwd = mne.read_forward_solution(fwd_file)
else:
src_ = _mne_source_space(subject, src_tag, subjects_dir)
fwd = mne.make_forward_solution(epochs.info, trans_file, src_, bem_file)
mne.write_forward_solution(fwd_file, fwd)
cov_file = os.path.join(meg_dir, 'sample_audvis-cov.fif')
cov = mne.read_cov(cov_file)
inv = mn.make_inverse_operator(epochs.info, fwd, cov, loose=loose,
depth=None, fixed=fixed)
mne.minimum_norm.write_inverse_operator(inv_file, inv)
ds.info['inv'] = inv
stcs = mn.apply_inverse_epochs(epochs, inv, 1. / (snr ** 2), method,
pick_ori=pick_ori)
ds['src'] = load.fiff.stc_ndvar(stcs, subject, src_tag, subjects_dir,
method, fixed)
if stc:
ds['stc'] = stcs
return ds
def test_restrict_forward_to_label():
"""Test restriction of source space to label
"""
fwd = read_forward_solution(fname_meeg)
fwd = convert_forward_solution(fwd, surf_ori=True, force_fixed=True,
use_cps=True)
fwd = pick_types_forward(fwd, meg=True)
label_path = op.join(data_path, 'MEG', 'sample', 'labels')
labels = ['Aud-lh', 'Vis-rh']
label_lh = read_label(op.join(label_path, labels[0] + '.label'))
label_rh = read_label(op.join(label_path, labels[1] + '.label'))
fwd_out = restrict_forward_to_label(fwd, [label_lh, label_rh])
src_sel_lh = np.intersect1d(fwd['src'][0]['vertno'], label_lh.vertices)
src_sel_lh = np.searchsorted(fwd['src'][0]['vertno'], src_sel_lh)
vertno_lh = fwd['src'][0]['vertno'][src_sel_lh]
nuse_lh = fwd['src'][0]['nuse']
src_sel_rh = np.intersect1d(fwd['src'][1]['vertno'], label_rh.vertices)
src_sel_rh = np.searchsorted(fwd['src'][1]['vertno'], src_sel_rh)
vertno_rh = fwd['src'][1]['vertno'][src_sel_rh]
src_sel_rh += nuse_lh
assert_equal(fwd_out['sol']['ncol'], len(src_sel_lh) + len(src_sel_rh))
assert_equal(fwd_out['src'][0]['nuse'], len(src_sel_lh))
assert_equal(fwd_out['src'][1]['nuse'], len(src_sel_rh))
assert_equal(fwd_out['src'][0]['vertno'], vertno_lh)
assert_equal(fwd_out['src'][1]['vertno'], vertno_rh)
fwd = read_forward_solution(fname_meeg)
fwd = pick_types_forward(fwd, meg=True)
label_path = op.join(data_path, 'MEG', 'sample', 'labels')
labels = ['Aud-lh', 'Vis-rh']
label_lh = read_label(op.join(label_path, labels[0] + '.label'))
label_rh = read_label(op.join(label_path, labels[1] + '.label'))
fwd_out = restrict_forward_to_label(fwd, [label_lh, label_rh])
src_sel_lh = np.intersect1d(fwd['src'][0]['vertno'], label_lh.vertices)
src_sel_lh = np.searchsorted(fwd['src'][0]['vertno'], src_sel_lh)
vertno_lh = fwd['src'][0]['vertno'][src_sel_lh]
nuse_lh = fwd['src'][0]['nuse']
src_sel_rh = np.intersect1d(fwd['src'][1]['vertno'], label_rh.vertices)
src_sel_rh = np.searchsorted(fwd['src'][1]['vertno'], src_sel_rh)
vertno_rh = fwd['src'][1]['vertno'][src_sel_rh]
src_sel_rh += nuse_lh
assert_equal(fwd_out['sol']['ncol'],
3 * (len(src_sel_lh) + len(src_sel_rh)))
assert_equal(fwd_out['src'][0]['nuse'], len(src_sel_lh))
assert_equal(fwd_out['src'][1]['nuse'], len(src_sel_rh))
assert_equal(fwd_out['src'][0]['vertno'], vertno_lh)
assert_equal(fwd_out['src'][1]['vertno'], vertno_rh)
# Test saving the restricted forward object. This only works if all fields
# are properly accounted for.
temp_dir = _TempDir()
fname_copy = op.join(temp_dir, 'copy-fwd.fif')
write_forward_solution(fname_copy, fwd_out, overwrite=True)
fwd_out_read = read_forward_solution(fname_copy)
compare_forwards(fwd_out, fwd_out_read)
def apply_inverse(fn_epo, event_id=1,ctmin=0.05, ctmax=0.25, fmin=4, fmax=8,
min_subject='fsaverage', save_forward=False):
"""
Inverse evokes into source space using DICS method.
----------
fn_epo : epochs of raw data.
event_id: event id related with epochs.
ctmin: the min time for computing CSD
ctmax: the max time for computing CSD
fmin: min value of the interest frequency band
fmax: max value of the interest frequency band
min_subject: the subject for the common brain space.
save_forward: Whether save the forward solution or not.
"""
from mne import Epochs, pick_types
from mne.io import Raw
from mne.event import make_fixed_length_events
fnlist = get_files_from_list(fn_epo)
# loop across all filenames
for fname in fnlist:
subjects_dir = os.environ['SUBJECTS_DIR']
# extract the subject infromation from the file name
meg_path = os.path.split(fname)[0]
name = os.path.basename(fname)
stc_name = name[:name.rfind('-epo.fif')]
subject = name.split('_')[0]
subject_path = subjects_dir + '/%s' %subject
min_dir = subjects_dir + '/%s' %min_subject
fn_trans = meg_path + '/%s-trans.fif' % subject
fn_src = subject_path + '/bem/%s-ico-4-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
# Make sure the target path is exist
stc_path = min_dir + '/DICS_ROIs/%s' % subject
set_directory(stc_path)
# Read the MNI source space
epochs = mne.read_epochs(fname)
tmin = epochs.times.min()
tmax = epochs.times.max()
fn_empty = meg_path + '/%s_empty,nr-raw.fif' % subject
raw_noise = Raw(fn_empty, preload=True)
epochs.info['bads'] = raw_noise.info['bads']
picks_noise = pick_types(raw_noise.info, meg='mag', exclude='bads')
events_noise = make_fixed_length_events(raw_noise, event_id, duration=1.)
epochs_noise = Epochs(raw_noise, events_noise, event_id, tmin,
tmax, proj=True, picks=picks_noise,
baseline=None, preload=True, reject=None)
# Make sure the number of noise epochs is the same as data epochs
epochs_noise = epochs_noise[:len(epochs.events)]
evoked = epochs.average()
forward = mne.make_forward_solution(epochs.info, trans=fn_trans,
src=fn_src, bem=fn_bem,
fname=None, meg=True, eeg=False,
mindist=5.0, n_jobs=2,
overwrite=True)
forward = mne.convert_forward_solution(forward, surf_ori=True)
if save_forward == True:
fn_fwd = fname[:fname.rfind('-epo.fif')] + '-fwd.fif'
mne.write_forward_solution(fn_fwd, forward, overwrite=True)
from mne.time_frequency import compute_epochs_csd
from mne.beamformer import dics
data_csd = compute_epochs_csd(epochs, mode='multitaper', tmin=ctmin, tmax=ctmax,
fmin=fmin, fmax=fmax)
noise_csd = compute_epochs_csd(epochs_noise, mode='multitaper', tmin=ctmin, tmax=ctmax,
fmin=fmin, fmax=fmax)
stc = dics(evoked, forward, noise_csd, data_csd)
from mne import morph_data
stc_morph = morph_data(subject, min_subject, stc, grade=4, smooth=4)
stc_morph.save(stc_path + '/%s_%d_%d' % (stc_name, fmin, fmax), ftype='stc')
