def compute_forward_solution(fname_raw,
subjects_dir=None,
spacing='ico4',
mindist=5,
eeg=False,
overwrite=False):
'''Performs forward solution computation using mne_do_foward_solution
(uses MNE-C binaries).
Requires bem sol files, and raw meas file)
Input
-----
fname_raw : str or list
List of raw files for which to compute the forward operator.
Returns
-------
None. Forward operator -fwd.fif will be saved.
'''
from mne import do_forward_solution
fnames = get_files_from_list(fname_raw)
subjects_dir = check_env_variables(subjects_dir, key='SUBJECTS_DIR')
for fname in fnames:
print('Computing fwd solution for %s' % (fname))
basename = os.path.basename(fname).split('-raw.fif')[0]
subject = basename.split('_')[0]
meas_fname = os.path.basename(fname)
fwd_fname = meas_fname.rsplit('-raw.fif')[0] + '-fwd.fif'
src_fname = subject + '-ico-4-src.fif'
bem_fname = subject + '-5120-5120-5120-bem-sol.fif'
trans_fname = subject + '-trans.fif'
fwd = do_forward_solution(subject,
meas_fname,
fname=fwd_fname,
src=src_fname,
spacing=spacing,
mindist=mindist,
bem=bem_fname,
mri=trans_fname,
eeg=eeg,
overwrite=overwrite,
subjects_dir=subjects_dir)
# fwd['surf_ori'] = True
# to read forward solutions
# fwd = mne.read_forward_solution(fwd_fname)
print('Forward operator saved in file %s' % (fwd_fname))
def compute_forward_solution(fname_raw, subjects_dir=None, spacing='ico4',
mindist=5, eeg=False, overwrite=False):
'''Performs forward solution computation using mne_do_foward_solution
(uses MNE-C binaries).
Requires bem sol files, and raw meas file)
Input
-----
fname_raw : str or list
List of raw files for which to compute the forward operator.
Returns
-------
None. Forward operator -fwd.fif will be saved.
'''
from mne import do_forward_solution
fnames = get_files_from_list(fname_raw)
if subjects_dir is None and 'SUBJECTS_DIR' in os.environ:
subjects_dir = os.environ['SUBJECTS_DIR']
else:
print 'Please set SUBJECTS_DIR.'
for fname in fnames:
print 'Computing fwd solution for %s' % (fname)
basename = os.path.basename(fname).split('-raw.fif')[0]
subject = basename.split('_')[0]
meas_fname = os.path.basename(fname)
fwd_fname = meas_fname.rsplit('-raw.fif')[0] + '-fwd.fif'
src_fname = subject + '-ico-4-src.fif'
bem_fname = subject + '-5120-5120-5120-bem-sol.fif'
trans_fname = subject + '-trans.fif'
fwd = do_forward_solution(subject, meas_fname, fname=fwd_fname, src=src_fname,
spacing=spacing, mindist=mindist, bem=bem_fname, mri=trans_fname,
eeg=eeg, overwrite=overwrite, subjects_dir=subjects_dir)
# fwd['surf_ori'] = True
# to read forward solutions
# fwd = mne.read_forward_solution(fwd_fname)
print 'Forward operator saved in file %s' % (fwd_fname)
def test_make_forward_solution_compensation():
"""Test making forward solution from python with compensation
"""
fname_ctf_raw = op.join(op.dirname(__file__), '..', '..', 'fiff', 'tests',
'data', 'test_ctf_comp_raw.fif')
fname_bem = op.join(subjects_dir, 'sample', 'bem',
'sample-5120-bem-sol.fif')
fname_src = op.join(temp_dir, 'oct2-src.fif')
src = setup_source_space('sample', fname_src, 'oct2',
subjects_dir=subjects_dir)
fwd_py = make_forward_solution(fname_ctf_raw, mindist=0.0,
src=src, eeg=False, meg=True,
bem=fname_bem, mri=fname_mri)
fwd = do_forward_solution('sample', fname_ctf_raw, src=fname_src,
mindist=0.0, bem=fname_bem, mri=fname_mri,
eeg=False, meg=True, subjects_dir=subjects_dir)
_compare_forwards(fwd, fwd_py, 274, 108)
def test_make_forward_solution_compensation():
"""Test making forward solution from python with compensation
"""
fname_ctf_raw = op.join(op.dirname(__file__), '..', '..', 'fiff', 'tests',
'data', 'test_ctf_comp_raw.fif')
fname_bem = op.join(subjects_dir, 'sample', 'bem',
'sample-5120-bem-sol.fif')
fname_src = op.join(temp_dir, 'oct2-src.fif')
src = setup_source_space('sample', fname_src, 'oct2',
subjects_dir=subjects_dir)
fwd_py = make_forward_solution(fname_ctf_raw, mindist=0.0,
src=src, eeg=False, meg=True,
bem=fname_bem, mri=fname_mri)
fwd = do_forward_solution('sample', fname_ctf_raw, src=fname_src,
mindist=0.0, bem=fname_bem, mri=fname_mri,
eeg=False, meg=True, subjects_dir=subjects_dir)
_compare_forwards(fwd, fwd_py, 274, 108)
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',
fname_src_small,
'oct2',
subjects_dir=subjects_dir,
add_dist=False)
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_true(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_true(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:
assert_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 = Raw(fname_ctf_raw, compensation=2)
fwd_py = make_forward_solution(ctf_raw.info,
fname_trans,
src,
fname_bem_meg,
eeg=False,
meg=True)
with warnings.catch_warnings(record=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)
def test_do_forward_solution():
"""Test wrapping forward solution from python
"""
raw = Raw(fname_raw)
mri = read_trans(fname_mri)
fname_fake = op.join(temp_dir, 'no_have.fif')
# ## Error checks
# bad subject
assert_raises(ValueError, do_forward_solution, 1, fname_raw,
subjects_dir=subjects_dir)
# bad meas
assert_raises(ValueError, do_forward_solution, 'sample', 1,
subjects_dir=subjects_dir)
# meas doesn't exist
assert_raises(IOError, do_forward_solution, 'sample', fname_fake,
subjects_dir=subjects_dir)
# don't specify trans and meas
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
subjects_dir=subjects_dir)
# specify both trans and meas
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
trans='me', mri='you', subjects_dir=subjects_dir)
# specify non-existent trans
assert_raises(IOError, do_forward_solution, 'sample', fname_raw,
trans=fname_fake, subjects_dir=subjects_dir)
# specify non-existent mri
assert_raises(IOError, do_forward_solution, 'sample', fname_raw,
mri=fname_fake, subjects_dir=subjects_dir)
# specify non-string mri
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
mri=1, subjects_dir=subjects_dir)
# specify non-string trans
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
trans=1, subjects_dir=subjects_dir)
# test specifying an actual trans in python space -- this should work but
# the transform I/O reduces our accuracy -- so we'll just hack a test here
# by making it bomb with eeg=False and meg=False
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
mri=mri, eeg=False, meg=False, subjects_dir=subjects_dir)
# mindist as non-integer
assert_raises(TypeError, do_forward_solution, 'sample', fname_raw,
mri=fname_mri, mindist=dict(), subjects_dir=subjects_dir)
# mindist as string but not 'all'
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
mri=fname_mri, eeg=False, mindist='yall',
subjects_dir=subjects_dir)
# src, spacing, and bem as non-str
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
mri=fname_mri, src=1, subjects_dir=subjects_dir)
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
mri=fname_mri, spacing=1, subjects_dir=subjects_dir)
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
mri=fname_mri, bem=1, subjects_dir=subjects_dir)
# no overwrite flag
assert_raises(IOError, do_forward_solution, 'sample', fname_raw,
existing_file, mri=fname_mri, subjects_dir=subjects_dir)
# let's catch an MNE error, this time about trans being wrong
assert_raises(CalledProcessError, do_forward_solution, 'sample',
fname_raw, existing_file, trans=fname_mri, overwrite=True,
spacing='oct-6', subjects_dir=subjects_dir)
# ## Actually calculate one and check
# make a meas from raw (tests all steps in creating evoked),
# don't do EEG or 5120-5120-5120 BEM because they're ~3x slower
fwd_py = do_forward_solution('sample', raw, mindist=5, spacing='oct-6',
bem='sample-5120', mri=fname_mri, eeg=False,
subjects_dir=subjects_dir)
fwd = read_forward_solution(fname)
assert_allclose(fwd['sol']['data'], fwd_py['sol']['data'],
rtol=1e-5, atol=1e-8)
assert_equal(fwd_py['sol']['data'].shape, (306, 22494))
assert_equal(len(fwd['sol']['row_names']), 306)
def test_make_forward_solution_kit():
"""Test making fwd using KIT, BTI, and CTF (compensated) files
"""
fname_bem = op.join(subjects_dir, 'sample', 'bem',
'sample-5120-bem-sol.fif')
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')
mri_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 testing source space
fname_src = op.join(temp_dir, 'oct2-src.fif')
src = setup_source_space('sample', fname_src, 'oct2',
subjects_dir=subjects_dir)
# first use mne-C: convert file, make forward solution
fwd = do_forward_solution('sample', fname_kit_raw, src=fname_src,
mindist=0.0, bem=fname_bem, mri=mri_path,
eeg=False, meg=True, subjects_dir=subjects_dir)
assert_true(isinstance(fwd, Forward))
# now let's use python with the same raw file
fwd_py = make_forward_solution(fname_kit_raw, mindist=0.0,
src=src, eeg=False, meg=True,
bem=fname_bem, mri=mri_path)
_compare_forwards(fwd, fwd_py, 157, 108)
assert_true(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:
assert_raises(NotImplementedError, make_forward_solution, raw_py.info,
mindist=0.0, src=src, eeg=False, meg=True,
bem=fname_bem, mri=mri_path)
fwd_py = make_forward_solution(raw_py.info, mindist=0.0,
src=src, eeg=False, meg=True,
bem=fname_bem, mri=mri_path,
ignore_ref=True)
_compare_forwards(fwd, fwd_py, 157, 108,
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,
mindist=0.0, bem=fname_bem, mri=mri_path,
eeg=False, meg=True, subjects_dir=subjects_dir)
raw_py = read_raw_bti(bti_pdf, bti_config, bti_hs)
fwd_py = make_forward_solution(raw_py.info, mindist=0.0,
src=src, eeg=False, meg=True,
bem=fname_bem, mri=mri_path)
_compare_forwards(fwd, fwd_py, 248, 108)
# now let's test CTF w/compensation
fwd_py = make_forward_solution(fname_ctf_raw, mindist=0.0,
src=src, eeg=False, meg=True,
bem=fname_bem, mri=fname_mri)
fwd = do_forward_solution('sample', fname_ctf_raw, src=fname_src,
mindist=0.0, bem=fname_bem, mri=fname_mri,
eeg=False, meg=True, subjects_dir=subjects_dir)
_compare_forwards(fwd, fwd_py, 274, 108)
# CTF with compensation changed in python
ctf_raw = Raw(fname_ctf_raw, compensation=2)
fwd_py = make_forward_solution(ctf_raw.info, mindist=0.0,
src=src, eeg=False, meg=True,
bem=fname_bem, mri=fname_mri)
with warnings.catch_warnings(record=True):
fwd = do_forward_solution('sample', ctf_raw, src=fname_src,
mindist=0.0, bem=fname_bem, mri=fname_mri,
eeg=False, meg=True,
subjects_dir=subjects_dir)
_compare_forwards(fwd, fwd_py, 274, 108)
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', fname_src_small, 'oct2',
subjects_dir=subjects_dir, add_dist=False)
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_true(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_true(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:
assert_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)
with warnings.catch_warnings(record=True): # weight tables
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 = Raw(fname_ctf_raw, compensation=2)
fwd_py = make_forward_solution(ctf_raw.info, fname_trans, src,
fname_bem_meg, eeg=False, meg=True)
with warnings.catch_warnings(record=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)
def test_do_forward_solution():
"""Test making forward solution from python
"""
subjects_dir = os.path.join(data_path, 'subjects')
raw = Raw(fname_raw)
mri = read_trans(fname_mri)
fname_fake = op.join(temp_dir, 'no_have.fif')
# ## Error checks
# bad subject
assert_raises(ValueError, do_forward_solution, 1, fname_raw,
subjects_dir=subjects_dir)
# bad meas
assert_raises(ValueError, do_forward_solution, 'sample', 1,
subjects_dir=subjects_dir)
# meas doesn't exist
assert_raises(IOError, do_forward_solution, 'sample', fname_fake,
subjects_dir=subjects_dir)
# don't specify trans and meas
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
subjects_dir=subjects_dir)
# specify both trans and meas
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
trans='me', mri='you', subjects_dir=subjects_dir)
# specify non-existent trans
assert_raises(IOError, do_forward_solution, 'sample', fname_raw,
trans=fname_fake, subjects_dir=subjects_dir)
# specify non-existent mri
assert_raises(IOError, do_forward_solution, 'sample', fname_raw,
mri=fname_fake, subjects_dir=subjects_dir)
# specify non-string mri
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
mri=1, subjects_dir=subjects_dir)
# specify non-string trans
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
trans=1, subjects_dir=subjects_dir)
# test specifying an actual trans in python space -- this should work but
# the transform I/O reduces our accuracy -- so we'll just hack a test here
# by making it bomb with eeg=False and meg=False
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
mri=mri, eeg=False, meg=False, subjects_dir=subjects_dir)
# mindist as non-integer
assert_raises(TypeError, do_forward_solution, 'sample', fname_raw,
mri=fname_mri, mindist=dict(), subjects_dir=subjects_dir)
# mindist as string but not 'all'
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
mri=fname_mri, eeg=False, mindist='yall',
subjects_dir=subjects_dir)
# src, spacing, and bem as non-str
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
mri=fname_mri, src=1, subjects_dir=subjects_dir)
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
mri=fname_mri, spacing=1, subjects_dir=subjects_dir)
assert_raises(ValueError, do_forward_solution, 'sample', fname_raw,
mri=fname_mri, bem=1, subjects_dir=subjects_dir)
# no overwrite flag
assert_raises(IOError, do_forward_solution, 'sample', fname_raw,
existing_file, mri=fname_mri, subjects_dir=subjects_dir)
# let's catch an MNE error, this time about trans being wrong
assert_raises(CalledProcessError, do_forward_solution, 'sample', fname_raw,
existing_file, trans=fname_mri, overwrite=True,
spacing='oct-6', subjects_dir=subjects_dir)
# ## Actually calculate one and check
# make a meas from raw (tests all steps in creating evoked),
# don't do EEG or 5120-5120-5120 BEM because they're ~3x slower
fwd_py = do_forward_solution('sample', raw, mindist=5, spacing='oct-6',
bem='sample-5120', mri=fname_mri, eeg=False,
subjects_dir=subjects_dir)
fwd = read_forward_solution(fname)
assert_allclose(fwd['sol']['data'], fwd_py['sol']['data'],
rtol=1e-5, atol=1e-8)
assert_equal(fwd_py['sol']['data'].shape, (306, 22494))
assert_equal(len(fwd['sol']['row_names']), 306)
