def test_make_forward_solution_sphere(): """Test making a forward solution with a sphere model""" 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) out_name = op.join(temp_dir, "tmp-fwd.fif") run_subprocess( [ "mne_forward_solution", "--meg", "--eeg", "--meas", fname_raw, "--src", fname_src_small, "--mri", fname_trans, "--fwd", out_name, ] ) fwd = read_forward_solution(out_name) sphere = make_sphere_model(verbose=True) fwd_py = make_forward_solution(fname_raw, fname_trans, src, sphere, meg=True, eeg=True, verbose=True) _compare_forwards(fwd, fwd_py, 366, 108, meg_rtol=5e-1, meg_atol=1e-6, eeg_rtol=5e-1, eeg_atol=5e-1) # Since the above is pretty lax, let's check a different way for meg, eeg in zip([True, False], [False, True]): fwd_ = pick_types_forward(fwd, meg=meg, eeg=eeg) fwd_py_ = pick_types_forward(fwd, meg=meg, eeg=eeg) assert_allclose(np.corrcoef(fwd_["sol"]["data"].ravel(), fwd_py_["sol"]["data"].ravel())[0, 1], 1.0, rtol=1e-3)
def test_make_forward_solution_sphere(): """Test making a forward solution with a sphere model.""" 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 out_name = op.join(temp_dir, 'tmp-fwd.fif') run_subprocess(['mne_forward_solution', '--meg', '--eeg', '--meas', fname_raw, '--src', fname_src_small, '--mri', fname_trans, '--fwd', out_name]) fwd = read_forward_solution(out_name) sphere = make_sphere_model(verbose=True) fwd_py = make_forward_solution(fname_raw, fname_trans, src, sphere, meg=True, eeg=True, verbose=True) _compare_forwards(fwd, fwd_py, 366, 108, meg_rtol=5e-1, meg_atol=1e-6, eeg_rtol=5e-1, eeg_atol=5e-1) # Since the above is pretty lax, let's check a different way for meg, eeg in zip([True, False], [False, True]): fwd_ = pick_types_forward(fwd, meg=meg, eeg=eeg) fwd_py_ = pick_types_forward(fwd, meg=meg, eeg=eeg) assert_allclose(np.corrcoef(fwd_['sol']['data'].ravel(), fwd_py_['sol']['data'].ravel())[0, 1], 1.0, rtol=1e-3)
def test_make_forward_solution_sphere(): """Test making a forward solution with a sphere model.""" 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 out_name = op.join(temp_dir, 'tmp-fwd.fif') run_subprocess([ 'mne_forward_solution', '--meg', '--eeg', '--meas', fname_raw, '--src', fname_src_small, '--mri', fname_trans, '--fwd', out_name ]) fwd = read_forward_solution(out_name) sphere = make_sphere_model(verbose=True) fwd_py = make_forward_solution(fname_raw, fname_trans, src, sphere, meg=True, eeg=True, verbose=True) _compare_forwards(fwd, fwd_py, 366, 108, meg_rtol=5e-1, meg_atol=1e-6, eeg_rtol=5e-1, eeg_atol=5e-1) # Since the above is pretty lax, let's check a different way for meg, eeg in zip([True, False], [False, True]): fwd_ = pick_types_forward(fwd, meg=meg, eeg=eeg) fwd_py_ = pick_types_forward(fwd, meg=meg, eeg=eeg) assert_allclose(np.corrcoef(fwd_['sol']['data'].ravel(), fwd_py_['sol']['data'].ravel())[0, 1], 1.0, rtol=1e-3) # Number of layers in the sphere model doesn't matter for MEG # (as long as no sources are omitted due to distance) assert len(sphere['layers']) == 4 fwd = make_forward_solution(fname_raw, fname_trans, src, sphere, meg=True, eeg=False) sphere_1 = make_sphere_model(head_radius=None) assert len(sphere_1['layers']) == 0 assert_array_equal(sphere['r0'], sphere_1['r0']) fwd_1 = make_forward_solution(fname_raw, fname_trans, src, sphere, meg=True, eeg=False) _compare_forwards(fwd, fwd_1, 306, 108, meg_rtol=1e-12, meg_atol=1e-12)
def test_make_forward_solution_discrete(tmpdir): """Test making and converting a forward solution with discrete src.""" # smoke test for depth weighting and discrete source spaces src = setup_source_space('sample', 'oct2', subjects_dir=subjects_dir, add_dist=False) src = src + setup_volume_source_space( pos=dict(rr=src[0]['rr'][src[0]['vertno'][:3]].copy(), nn=src[0]['nn'][src[0]['vertno'][:3]].copy())) sphere = make_sphere_model() fwd = make_forward_solution(fname_raw, fname_trans, src, sphere, meg=True, eeg=False) convert_forward_solution(fwd, surf_ori=True)
def test_make_forward_solution_sphere(): """Test making a forward solution with a sphere model.""" 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 out_name = op.join(temp_dir, 'tmp-fwd.fif') run_subprocess(['mne_forward_solution', '--meg', '--eeg', '--meas', fname_raw, '--src', fname_src_small, '--mri', fname_trans, '--fwd', out_name]) fwd = read_forward_solution(out_name) sphere = make_sphere_model(verbose=True) fwd_py = make_forward_solution(fname_raw, fname_trans, src, sphere, meg=True, eeg=True, verbose=True) _compare_forwards(fwd, fwd_py, 366, 108, meg_rtol=5e-1, meg_atol=1e-6, eeg_rtol=5e-1, eeg_atol=5e-1) # Since the above is pretty lax, let's check a different way for meg, eeg in zip([True, False], [False, True]): fwd_ = pick_types_forward(fwd, meg=meg, eeg=eeg) fwd_py_ = pick_types_forward(fwd, meg=meg, eeg=eeg) assert_allclose(np.corrcoef(fwd_['sol']['data'].ravel(), fwd_py_['sol']['data'].ravel())[0, 1], 1.0, rtol=1e-3) # Number of layers in the sphere model doesn't matter for MEG # (as long as no sources are omitted due to distance) assert len(sphere['layers']) == 4 fwd = make_forward_solution(fname_raw, fname_trans, src, sphere, meg=True, eeg=False) sphere_1 = make_sphere_model(head_radius=None) assert len(sphere_1['layers']) == 0 assert_array_equal(sphere['r0'], sphere_1['r0']) fwd_1 = make_forward_solution(fname_raw, fname_trans, src, sphere, meg=True, eeg=False) _compare_forwards(fwd, fwd_1, 306, 108, meg_rtol=1e-12, meg_atol=1e-12) # Homogeneous model sphere = make_sphere_model(head_radius=None) with pytest.raises(RuntimeError, match='zero shells.*EEG'): make_forward_solution(fname_raw, fname_trans, src, sphere)
def test_make_forward_solution_sphere(): """Test making a forward solution with a sphere model""" 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) out_name = op.join(temp_dir, 'tmp-fwd.fif') run_subprocess([ 'mne_forward_solution', '--meg', '--eeg', '--meas', fname_raw, '--src', fname_src_small, '--mri', fname_trans, '--fwd', out_name ]) fwd = read_forward_solution(out_name) sphere = make_sphere_model(verbose=True) fwd_py = make_forward_solution(fname_raw, fname_trans, src, sphere, meg=True, eeg=True, verbose=True) _compare_forwards(fwd, fwd_py, 366, 108, meg_rtol=5e-1, meg_atol=1e-6, eeg_rtol=5e-1, eeg_atol=5e-1) # Since the above is pretty lax, let's check a different way for meg, eeg in zip([True, False], [False, True]): fwd_ = pick_types_forward(fwd, meg=meg, eeg=eeg) fwd_py_ = pick_types_forward(fwd, meg=meg, eeg=eeg) assert_allclose(np.corrcoef(fwd_['sol']['data'].ravel(), fwd_py_['sol']['data'].ravel())[0, 1], 1.0, rtol=1e-3)
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_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 = read_raw_fif(fname_ctf_raw) ctf_raw.apply_gradient_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_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)
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) fwd_py = make_forward_solution(raw_py.info, src=src, eeg=False, meg=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) 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_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 run(): args = sys.argv if len(args) <= 1: print 'Usage: run_meg_tutorial.sh <sample data directory>' return sample_dir = args[1] subjects_dir = join(sample_dir, 'subjects') meg_dir = join(sample_dir, 'MEG', 'sample') os.environ['SUBJECTS_DIR'] = subjects_dir os.environ['MEG_DIR'] = meg_dir subject = 'sample' src = setup_source_space(subject, fname=True, spacing='oct6', n_jobs=2, overwrite=True) # If one wanted to use other source spaces, these types of options are # available src_fsaverage = setup_source_space('fsaverage', fname=True, spacing='ico5', n_jobs=2, overwrite=True, add_dist=False) morph_source_spaces(src_fsaverage, subject_to='sample') setup_source_space(subject, fname=True, spacing='all', overwrite=True, n_jobs=2, add_dist=False) # Add distances to source space (if desired, takes a long time) bem_dir = join(subjects_dir, join('sample', 'bem')) os.rename(join(bem_dir, 'sample-oct-6-src.fif'), join(bem_dir, 'sample-oct-6-orig-src.fif')) new_src = add_source_space_distances(src, dist_limit=0.007) new_src.save(join(bem_dir, 'sample-oct-6-src.fif')) # Preprocessing raw = mne.io.Raw(join(meg_dir, 'sample_audvis_raw.fif'), preload=True) raw.info['bads'] = ['MEG 2443', 'EEG 053'] reject = dict(grad=3000e-13, mag=4000e-15, eeg=100e-6) ecg_proj, _ = mne.preprocessing.compute_proj_ecg(raw, l_freq=1, h_freq=100, ch_name='MEG 1531', reject=reject) eog_proj, _ = mne.preprocessing.compute_proj_eog(raw, l_freq=1, h_freq=35, reject=reject, no_proj=True) events = mne.find_events(raw) mne.write_events(join(meg_dir, 'sample_audvis_raw-eve.fif'), events) event_id = [1, 2, 3, 4] tmin, tmax = -0.2, 0.5 picks = mne.pick_types(raw.info, meg=True, eeg=True, stim=True, eog=True) # Average with no filter epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks) evoked = epochs.average() evoked.save(join(meg_dir, 'sample_audvis-no-filter-ave.fif')) raw.filter(l_freq=None, h_freq=40) raw_resampled = raw.resample(150) raw_resampled.save(join(meg_dir, 'sample_audvis_filt-0-40_raw.fif'), overwrite=True) raw.add_proj(ecg_proj) raw.add_proj(eog_proj) resampled_events = mne.find_events(raw_resampled) mne.write_events(join(meg_dir, 'sample_audvis_filt-0-40_raw-eve.fif'), resampled_events) # Average with filter epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks) evoked = epochs.average() evoked.save(join(meg_dir, 'sample_audvis-ave.fif')) # Compute the noise covariance matrix noise_cov = mne.compute_raw_data_covariance(raw, picks=picks) noise_cov.save(join(meg_dir, 'audvis.cov')) # Compute the empty-room noise covariance matrix ernoise_raw = mne.io.Raw(join(meg_dir, 'ernoise_raw.fif'), preload=True) ernoise_raw.info['bads'] = ['MEG 2443'] ernoise_raw.filter(l_freq=None, h_freq=40) picks = mne.pick_types(ernoise_raw.info, meg=True, eeg=True, stim=True, eog=True) ernoise_cov = mne.compute_raw_data_covariance(ernoise_raw, picks=picks) ernoise_cov.save(join(meg_dir, 'ernoise.cov')) ############################################################################### # Compute forward solution a.k.a. lead field trans = join(meg_dir, 'sample_audvis_raw-trans.fif') bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-bem-sol.fif') # for MEG only fname = join(meg_dir, 'sample_audvis-meg-oct-6-fwd.fif') fwd_meg = mne.make_forward_solution(raw.info, trans, src, bem, fname=fname, meg=True, eeg=False, mindist=5.0, n_jobs=2, overwrite=True) # for EEG only bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-5120-5120-bem-sol.fif') fname = join(meg_dir, 'sample_audvis-eeg-oct-6-fwd.fif') fwd_eeg = mne.make_forward_solution(raw.info, trans, src, bem, fname=fname, meg=False, eeg=True, mindist=5.0, n_jobs=2, overwrite=True) # for both EEG and MEG fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-fwd.fif') fwd = mne.make_forward_solution(raw.info, trans, src, bem, fname=fname, meg=True, eeg=True, mindist=5.0, n_jobs=2, overwrite=True) # Create various sensitivity maps grad_map = mne.sensitivity_map(fwd, ch_type='grad', mode='free') grad_map.save(join(meg_dir, 'sample_audvis-grad-oct-6-fwd-sensmap'), ftype='w') mag_map = mne.sensitivity_map(fwd, ch_type='mag', mode='free') mag_map.save(join(meg_dir, 'sample_audvis-mag-oct-6-fwd-sensmap'), ftype='w') eeg_map = mne.sensitivity_map(fwd, ch_type='eeg', mode='free') eeg_map.save(join(meg_dir, 'sample_audvis-eeg-oct-6-fwd-sensmap'), ftype='w') grad_map2 = mne.sensitivity_map(fwd, ch_type='grad', mode='fixed') grad_map2.save(join(meg_dir, 'sample_audvis-grad-oct-6-fwd-sensmap-2'), ftype='w') mag_map2 = mne.sensitivity_map(fwd, ch_type='mag', mode='ratio') mag_map2.save(join(meg_dir, 'sample_audvis-mag-oct-6-fwd-sensmap-3'), ftype='w') # Compute some with the EOG + ECG projectors projs = ecg_proj + eog_proj + raw.info['projs'] for map_type in ['radiality', 'angle', 'remaining', 'dampening']: eeg_map = mne.sensitivity_map(fwd, projs=projs, ch_type='eeg', mode=map_type) eeg_map.save( join(meg_dir, 'sample_audvis-eeg-oct-6-fwd-sensmap-' + map_type)) ############################################################################### # Compute MNE inverse operators # # Note: The MEG/EEG forward solution could be used for all # inv_meg = make_inverse_operator(raw.info, fwd_meg, noise_cov, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-inv.fif') write_inverse_operator(fname, inv_meg) inv_eeg = make_inverse_operator(raw.info, fwd_eeg, noise_cov, loose=0.2) fname = join(meg_dir, 'sample_audvis-eeg-oct-6-eeg-inv.fif') write_inverse_operator(fname, inv_eeg) inv = make_inverse_operator(raw.info, fwd, noise_cov, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-meg-eeg-inv.fif') write_inverse_operator(fname, inv) # inverse operator with fixed orientation (for testing). Not implemented #inv_fixed = make_inverse_operator(raw.info, fwd_meg, noise_cov, # depth=None, fixed=True) #fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-nodepth-fixed-inv.fif') #write_inverse_operator(fname, inv_fixed) # produce two with diagonal noise (for testing) diag = noise_cov.as_diag() inv_meg_diag = make_inverse_operator(raw.info, fwd_meg, diag, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-diagnoise-inv.fif') write_inverse_operator(fname, inv_meg_diag) inv_eeg_diag = make_inverse_operator(raw.info, fwd, diag, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-meg-eeg-diagnoise-inv.fif') write_inverse_operator(fname, inv_eeg_diag) # Produce stc files evoked.crop(0, 0.25) stc_meg = apply_inverse(evoked, inv_meg, method='MNE') stc_meg.save(join(meg_dir, 'sample_audvis-meg')) stc_eeg = apply_inverse(evoked, inv_eeg, method='MNE') stc_eeg.save(join(meg_dir, 'sample_audvis-eeg')) stc = apply_inverse(evoked, inv, method='MNE') stc.save(join(meg_dir, 'sample_audvis-meg-eeg')) # let's also morph to fsaverage stc_to = stc_meg.morph('fsaverage', grade=3, smooth=12) stc_to.save(join(meg_dir, 'fsaverage_audvis-meg')) stc_to = stc_eeg.morph('fsaverage', grade=3, smooth=12) stc_to.save(join(meg_dir, 'fsaverage_audvis-eeg')) stc_to = stc.morph('fsaverage', grade=3, smooth=12) stc_to.save(join(meg_dir, 'fsaverage_audvis-meg-eeg')) ############################################################################### # Do one dipole fitting evoked = evoked.pick_types(meg=True, eeg=False) evoked.crop(0.04, 0.095) bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-bem-sol.fif') dip, _ = mne.fit_dipole(evoked, noise_cov, bem, trans) dip.save(join(meg_dir, 'sample_audvis_set1.dip'))
def 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') 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 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=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, src=src, eeg=False, meg=True, bem=fname_bem_meg, mri=mri_path) _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, mri=mri_path) fwd_py = make_forward_solution(raw_py.info, src=src, eeg=False, meg=True, bem=fname_bem_meg, mri=mri_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=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, src=src, eeg=False, meg=True, bem=fname_bem_meg, mri=mri_path) _compare_forwards(fwd, fwd_py, 248, n_src) # now let's test CTF w/compensation fwd_py = make_forward_solution(fname_ctf_raw, src=src, eeg=False, meg=True, bem=fname_bem_meg, mri=fname_mri) fwd = do_forward_solution('sample', fname_ctf_raw, src=fname_src_small, bem=fname_bem_meg, mri=fname_mri, 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, src=src, eeg=False, meg=True, bem=fname_bem_meg, mri=fname_mri) with warnings.catch_warnings(record=True): fwd = do_forward_solution('sample', ctf_raw, src=fname_src_small, bem=fname_bem_meg, mri=fname_mri, eeg=False, meg=True, subjects_dir=subjects_dir) _compare_forwards(fwd, fwd_py, 274, n_src)
def run(): args = sys.argv if len(args) <= 1: print 'Usage: run_meg_tutorial.sh <sample data directory>' return sample_dir = args[1] subjects_dir = join(sample_dir, 'subjects') meg_dir = join(sample_dir, 'MEG', 'sample') os.environ['SUBJECTS_DIR'] = subjects_dir os.environ['MEG_DIR'] = meg_dir subject = 'sample' src = setup_source_space(subject, fname=True, spacing='oct6', n_jobs=2, overwrite=True) # If one wanted to use other source spaces, these types of options are # available src_fsaverage = setup_source_space('fsaverage', fname=True, spacing='ico5', n_jobs=2, overwrite=True, add_dist=False) morph_source_spaces(src_fsaverage, subject_to='sample') setup_source_space(subject, fname=True, spacing='all', overwrite=True, n_jobs=2, add_dist=False) # Add distances to source space (if desired, takes a long time) bem_dir = join(subjects_dir, join('sample', 'bem')) os.rename(join(bem_dir, 'sample-oct-6-src.fif'), join(bem_dir, 'sample-oct-6-orig-src.fif')) new_src = add_source_space_distances(src, dist_limit=0.007) new_src.save(join(bem_dir, 'sample-oct-6-src.fif')) # Preprocessing raw = mne.io.Raw(join(meg_dir, 'sample_audvis_raw.fif'), preload=True) raw.info['bads'] = ['MEG 2443', 'EEG 053'] reject = dict(grad=3000e-13, mag=4000e-15, eeg=100e-6) ecg_proj, _ = mne.preprocessing.compute_proj_ecg(raw, l_freq=1, h_freq=100, ch_name='MEG 1531', reject=reject) eog_proj, _ = mne.preprocessing.compute_proj_eog(raw, l_freq=1, h_freq=35, reject=reject, no_proj=True) events = mne.find_events(raw) mne.write_events(join(meg_dir, 'sample_audvis_raw-eve.fif'), events) event_id = [1, 2, 3, 4] tmin, tmax = -0.2, 0.5 picks = mne.pick_types(raw.info, meg=True, eeg=True, stim=True, eog=True) # Average with no filter epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks) evoked = epochs.average() evoked.save(join(meg_dir, 'sample_audvis-no-filter-ave.fif')) raw.filter(l_freq=None, h_freq=40) raw_resampled = raw.resample(150) raw_resampled.save(join(meg_dir, 'sample_audvis_filt-0-40_raw.fif'), overwrite=True) raw.add_proj(ecg_proj) raw.add_proj(eog_proj) resampled_events = mne.find_events(raw_resampled) mne.write_events(join(meg_dir, 'sample_audvis_filt-0-40_raw-eve.fif'), resampled_events) # Average with filter epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks) evoked = epochs.average() evoked.save(join(meg_dir, 'sample_audvis-ave.fif')) # Compute the noise covariance matrix noise_cov = mne.compute_raw_data_covariance(raw, picks=picks) noise_cov.save(join(meg_dir, 'audvis.cov')) # Compute the empty-room noise covariance matrix ernoise_raw = mne.io.Raw(join(meg_dir, 'ernoise_raw.fif'), preload=True) ernoise_raw.info['bads'] = ['MEG 2443'] ernoise_raw.filter(l_freq=None, h_freq=40) picks = mne.pick_types(ernoise_raw.info, meg=True, eeg=True, stim=True, eog=True) ernoise_cov = mne.compute_raw_data_covariance(ernoise_raw, picks=picks) ernoise_cov.save(join(meg_dir, 'ernoise.cov')) ############################################################################### # Compute forward solution a.k.a. lead field trans = join(meg_dir, 'sample_audvis_raw-trans.fif') bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-bem-sol.fif') # for MEG only fname = join(meg_dir, 'sample_audvis-meg-oct-6-fwd.fif') fwd_meg = mne.make_forward_solution(raw.info, trans, src, bem, fname=fname, meg=True, eeg=False, mindist=5.0, n_jobs=2, overwrite=True) # for EEG only bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-5120-5120-bem-sol.fif') fname = join(meg_dir, 'sample_audvis-eeg-oct-6-fwd.fif') fwd_eeg = mne.make_forward_solution(raw.info, trans, src, bem, fname=fname, meg=False, eeg=True, mindist=5.0, n_jobs=2, overwrite=True) # for both EEG and MEG fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-fwd.fif') fwd = mne.make_forward_solution(raw.info, trans, src, bem, fname=fname, meg=True, eeg=True, mindist=5.0, n_jobs=2, overwrite=True) # Create various sensitivity maps grad_map = mne.sensitivity_map(fwd, ch_type='grad', mode='free') grad_map.save(join(meg_dir, 'sample_audvis-grad-oct-6-fwd-sensmap'), ftype='w') mag_map = mne.sensitivity_map(fwd, ch_type='mag', mode='free') mag_map.save(join(meg_dir, 'sample_audvis-mag-oct-6-fwd-sensmap'), ftype='w') eeg_map = mne.sensitivity_map(fwd, ch_type='eeg', mode='free') eeg_map.save(join(meg_dir, 'sample_audvis-eeg-oct-6-fwd-sensmap'), ftype='w') grad_map2 = mne.sensitivity_map(fwd, ch_type='grad', mode='fixed') grad_map2.save(join(meg_dir, 'sample_audvis-grad-oct-6-fwd-sensmap-2'), ftype='w') mag_map2 = mne.sensitivity_map(fwd, ch_type='mag', mode='ratio') mag_map2.save(join(meg_dir, 'sample_audvis-mag-oct-6-fwd-sensmap-3'), ftype='w') # Compute some with the EOG + ECG projectors projs = ecg_proj + eog_proj + raw.info['projs'] for map_type in ['radiality', 'angle', 'remaining', 'dampening']: eeg_map = mne.sensitivity_map(fwd, projs=projs, ch_type='eeg', mode=map_type) eeg_map.save(join(meg_dir, 'sample_audvis-eeg-oct-6-fwd-sensmap-' + map_type)) ############################################################################### # Compute MNE inverse operators # # Note: The MEG/EEG forward solution could be used for all # inv_meg = make_inverse_operator(raw.info, fwd_meg, noise_cov, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-inv.fif') write_inverse_operator(fname, inv_meg) inv_eeg = make_inverse_operator(raw.info, fwd_eeg, noise_cov, loose=0.2) fname = join(meg_dir, 'sample_audvis-eeg-oct-6-eeg-inv.fif') write_inverse_operator(fname, inv_eeg) inv = make_inverse_operator(raw.info, fwd, noise_cov, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-meg-eeg-inv.fif') write_inverse_operator(fname, inv) # inverse operator with fixed orientation (for testing). Not implemented #inv_fixed = make_inverse_operator(raw.info, fwd_meg, noise_cov, # depth=None, fixed=True) #fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-nodepth-fixed-inv.fif') #write_inverse_operator(fname, inv_fixed) # produce two with diagonal noise (for testing) diag = noise_cov.as_diag() inv_meg_diag = make_inverse_operator(raw.info, fwd_meg, diag, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-diagnoise-inv.fif') write_inverse_operator(fname, inv_meg_diag) inv_eeg_diag = make_inverse_operator(raw.info, fwd, diag, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-meg-eeg-diagnoise-inv.fif') write_inverse_operator(fname, inv_eeg_diag) # Produce stc files evoked.crop(0, 0.25) stc_meg = apply_inverse(evoked, inv_meg, method='MNE') stc_meg.save(join(meg_dir, 'sample_audvis-meg')) stc_eeg = apply_inverse(evoked, inv_eeg, method='MNE') stc_eeg.save(join(meg_dir, 'sample_audvis-eeg')) stc = apply_inverse(evoked, inv, method='MNE') stc.save(join(meg_dir, 'sample_audvis-meg-eeg')) # let's also morph to fsaverage stc_to = stc_meg.morph('fsaverage', grade=3, smooth=12) stc_to.save(join(meg_dir, 'fsaverage_audvis-meg')) stc_to = stc_eeg.morph('fsaverage', grade=3, smooth=12) stc_to.save(join(meg_dir, 'fsaverage_audvis-eeg')) stc_to = stc.morph('fsaverage', grade=3, smooth=12) stc_to.save(join(meg_dir, 'fsaverage_audvis-meg-eeg')) ############################################################################### # Do one dipole fitting evoked = evoked.pick_types(meg=True, eeg=False) evoked.crop(0.04, 0.095) bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-bem-sol.fif') dip, _ = mne.fit_dipole(evoked, noise_cov, bem, trans) dip.save(join(meg_dir, 'sample_audvis_set1.dip'))