def test_make_inverse_operator_fixed(): """Test MNE inverse computation (fixed orientation) """ fwd_op = read_forward_solution(fname_fwd, surf_ori=True) fwd_1 = read_forward_solution(fname_fwd, surf_ori=False, force_fixed=False) fwd_2 = read_forward_solution(fname_fwd, surf_ori=False, force_fixed=True) evoked = _get_evoked() noise_cov = read_cov(fname_cov) # can't make depth-weighted fixed inv without surf ori fwd assert_raises(ValueError, make_inverse_operator, evoked.info, fwd_1, noise_cov, depth=0.8, loose=None, fixed=True) # can't make fixed inv with depth weighting without free ori fwd assert_raises(ValueError, make_inverse_operator, evoked.info, fwd_2, noise_cov, depth=0.8, loose=None, fixed=True) # compare to C solution w/fixed inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, depth=0.8, loose=None, fixed=True) _compare_io(inv_op) inverse_operator_fixed = read_inverse_operator(fname_inv_fixed) _compare_inverses_approx(inverse_operator_fixed, inv_op, evoked, 2) # Inverse has 306 channels - 4 proj = 302 assert_true(compute_rank_inverse(inverse_operator_fixed) == 302) # now compare to C solution # note that the forward solution must not be surface-oriented # to get equivalency (surf_ori=True changes the normals) inv_op = make_inverse_operator(evoked.info, fwd_2, noise_cov, depth=None, loose=None, fixed=True) inverse_operator_nodepth = read_inverse_operator(fname_inv_nodepth) _compare_inverses_approx(inverse_operator_nodepth, inv_op, evoked, 2) # Inverse has 306 channels - 4 proj = 302 assert_true(compute_rank_inverse(inverse_operator_fixed) == 302)
def test_make_inverse_operator_fixed(): """Test MNE inverse computation (fixed orientation).""" fwd = read_forward_solution_meg(fname_fwd) evoked = _get_evoked() noise_cov = read_cov(fname_cov) # can't make fixed inv with depth weighting without free ori fwd fwd_fixed = convert_forward_solution(fwd, force_fixed=True, use_cps=True) assert_raises(ValueError, make_inverse_operator, evoked.info, fwd_fixed, noise_cov, depth=0.8, fixed=True) # now compare to C solution # note that the forward solution must not be surface-oriented # to get equivalency (surf_ori=True changes the normals) inv_op = make_inverse_operator(evoked.info, fwd, noise_cov, depth=None, fixed=True, use_cps=False) assert 'EEG channels: 0' in repr(inv_op) assert 'MEG channels: 305' in repr(inv_op) del fwd_fixed inverse_operator_nodepth = read_inverse_operator(fname_inv_fixed_nodepth) # XXX We should have this but we don't (MNE-C doesn't restrict info): # assert 'EEG channels: 0' in repr(inverse_operator_nodepth) assert 'MEG channels: 305' in repr(inverse_operator_nodepth) _compare_inverses_approx(inverse_operator_nodepth, inv_op, evoked, rtol=1e-5, atol=1e-4) # Inverse has 306 channels - 6 proj = 302 assert_true(compute_rank_inverse(inverse_operator_nodepth) == 302) # Now with depth fwd_surf = convert_forward_solution(fwd, surf_ori=True) # not fixed for kwargs, use_fwd in zip( [dict(fixed=True), dict(loose=0.)], [fwd, fwd_surf]): # Should be equiv. inv_op_depth = make_inverse_operator(evoked.info, use_fwd, noise_cov, depth=0.8, use_cps=True, **kwargs) inverse_operator_depth = read_inverse_operator(fname_inv_fixed_depth) # Normals should be the adjusted ones assert_allclose(inverse_operator_depth['source_nn'], fwd_surf['source_nn'][2::3], atol=1e-5) _compare_inverses_approx(inverse_operator_depth, inv_op_depth, evoked, rtol=1e-3, atol=1e-4)
def test_make_inverse_operator_fixed(self): """Test MNE inverse computation w/ fixed orientation (& no depth weighting) """ # can't make fixed inv without surf ori fwd assert_raises(ValueError, make_inverse_operator, evoked.info, self.fwd_1, noise_cov, depth=0.8, loose=None, fixed=True) # can't make fixed inv with depth weighting without free ori fwd assert_raises(ValueError, make_inverse_operator, evoked.info, self.fwd_2, noise_cov, depth=0.8, loose=None, fixed=True) inv_op = make_inverse_operator(evoked.info, self.fwd_op, noise_cov, depth=0.8, loose=None, fixed=True) _compare_io(inv_op) inverse_operator_fixed = read_inverse_operator(fname_inv_fixed) _compare_inverses_approx(inverse_operator_fixed, inv_op, evoked, 2) # Inverse has 306 channels - 4 proj = 302 assert_true(compute_rank_inverse(inverse_operator_fixed) == 302) # Now without depth weighting, these should be equivalent inv_op = make_inverse_operator(evoked.info, self.fwd_2, noise_cov, depth=None, loose=None, fixed=True) inv_2 = make_inverse_operator(evoked.info, self.fwd_op, noise_cov, depth=None, loose=None, fixed=True) _compare_inverses_approx(inv_op, inv_2, evoked, 2) _compare_io(inv_op) # now compare to C solution inverse_operator_nodepth = read_inverse_operator(fname_inv_nodepth) _compare_inverses_approx(inverse_operator_nodepth, inv_op, evoked, 2) # Inverse has 306 channels - 4 proj = 302 assert_true(compute_rank_inverse(inverse_operator_fixed) == 302)
def test_io_inverse_operator(): """Test IO of inverse_operator.""" tempdir = _TempDir() inverse_operator = read_inverse_operator(fname_inv) x = repr(inverse_operator) assert (x) assert (isinstance(inverse_operator['noise_cov'], Covariance)) # just do one example for .gz, as it should generalize _compare_io(inverse_operator, '.gz') # test warnings on bad filenames inv_badname = op.join(tempdir, 'test-bad-name.fif.gz') with pytest.warns(RuntimeWarning, match='-inv.fif'): write_inverse_operator(inv_badname, inverse_operator) with pytest.warns(RuntimeWarning, match='-inv.fif'): read_inverse_operator(inv_badname) # make sure we can write and read inv_fname = op.join(tempdir, 'test-inv.fif') args = (10, 1. / 9., 'dSPM') inv_prep = prepare_inverse_operator(inverse_operator, *args) write_inverse_operator(inv_fname, inv_prep) inv_read = read_inverse_operator(inv_fname) _compare(inverse_operator, inv_read) inv_read_prep = prepare_inverse_operator(inv_read, *args) _compare(inv_prep, inv_read_prep) inv_prep_prep = prepare_inverse_operator(inv_prep, *args) _compare(inv_prep, inv_prep_prep)
def test_io_inverse_operator(): """Test IO of inverse_operator """ tempdir = _TempDir() inverse_operator = read_inverse_operator(fname_inv) x = repr(inverse_operator) assert_true(x) assert_true(isinstance(inverse_operator['noise_cov'], Covariance)) # just do one example for .gz, as it should generalize _compare_io(inverse_operator, '.gz') # test warnings on bad filenames with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') inv_badname = op.join(tempdir, 'test-bad-name.fif.gz') write_inverse_operator(inv_badname, inverse_operator) read_inverse_operator(inv_badname) assert_true(len(w) == 2) # make sure we can write and read inv_fname = op.join(tempdir, 'test-inv.fif') args = (10, 1. / 9., 'dSPM') inv_prep = prepare_inverse_operator(inverse_operator, *args) write_inverse_operator(inv_fname, inv_prep) inv_read = read_inverse_operator(inv_fname) _compare(inverse_operator, inv_read) inv_read_prep = prepare_inverse_operator(inv_read, *args) _compare(inv_prep, inv_read_prep) inv_prep_prep = prepare_inverse_operator(inv_prep, *args) _compare(inv_prep, inv_prep_prep)
def test_io_inverse_operator(): """Test IO of inverse_operator """ tempdir = _TempDir() inverse_operator = read_inverse_operator(fname_inv) x = repr(inverse_operator) assert_true(x) assert_true(isinstance(inverse_operator['noise_cov'], Covariance)) # just do one example for .gz, as it should generalize _compare_io(inverse_operator, '.gz') # test warnings on bad filenames with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') inv_badname = op.join(tempdir, 'test-bad-name.fif.gz') write_inverse_operator(inv_badname, inverse_operator) read_inverse_operator(inv_badname) assert_naming(w, 'test_inverse.py', 2) # make sure we can write and read inv_fname = op.join(tempdir, 'test-inv.fif') args = (10, 1. / 9., 'dSPM') inv_prep = prepare_inverse_operator(inverse_operator, *args) write_inverse_operator(inv_fname, inv_prep) inv_read = read_inverse_operator(inv_fname) _compare(inverse_operator, inv_read) inv_read_prep = prepare_inverse_operator(inv_read, *args) _compare(inv_prep, inv_read_prep) inv_prep_prep = prepare_inverse_operator(inv_prep, *args) _compare(inv_prep, inv_prep_prep)
def test_io_inverse_operator(): """Test IO of inverse_operator with GZip """ inverse_operator = read_inverse_operator(fname_inv) # just do one example for .gz, as it should generalize _compare_io(inverse_operator, '.gz') # test warnings on bad filenames with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') inv_badname = op.join(tempdir, 'test-bad-name.fif.gz') write_inverse_operator(inv_badname, inverse_operator) read_inverse_operator(inv_badname) assert_true(len(w) == 2)
def test_apply_mne_inverse_raw(): """Test MNE with precomputed inverse operator on Raw """ start = 3 stop = 10 raw = fiff.Raw(fname_raw) label_lh = read_label(fname_label % 'Aud-lh') _, times = raw[0, start:stop] inverse_operator = read_inverse_operator(fname_inv) for pick_ori in [None, "normal"]: stc = apply_inverse_raw(raw, inverse_operator, lambda2, "dSPM", label=label_lh, start=start, stop=stop, nave=1, pick_ori=pick_ori, buffer_size=None) stc2 = apply_inverse_raw(raw, inverse_operator, lambda2, "dSPM", label=label_lh, start=start, stop=stop, nave=1, pick_ori=pick_ori, buffer_size=3) if pick_ori is None: assert_true(np.all(stc.data > 0)) assert_true(np.all(stc2.data > 0)) assert_true(stc.subject == 'sample') assert_true(stc2.subject == 'sample') assert_array_almost_equal(stc.times, times) assert_array_almost_equal(stc2.times, times) assert_array_almost_equal(stc.data, stc2.data)
def test_make_inverse_operator_loose(evoked): """Test MNE inverse computation (precomputed and non-precomputed).""" # Test old version of inverse computation starting from forward operator noise_cov = read_cov(fname_cov) inverse_operator = read_inverse_operator(fname_inv) fwd_op = convert_forward_solution(read_forward_solution_meg(fname_fwd), surf_ori=True, copy=False) with catch_logging() as log: with pytest.deprecated_call(): # limit_depth_chs my_inv_op = make_inverse_operator( evoked.info, fwd_op, noise_cov, loose=0.2, depth=0.8, limit_depth_chs=False, verbose=True) log = log.getvalue() assert 'MEG: rank 302 computed' in log assert 'limit = 1/%d' % fwd_op['nsource'] in log _compare_io(my_inv_op) assert_equal(inverse_operator['units'], 'Am') _compare_inverses_approx(my_inv_op, inverse_operator, evoked, rtol=1e-2, atol=1e-5, depth_atol=1e-3) # Test MNE inverse computation starting from forward operator with catch_logging() as log: my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose='auto', depth=0.8, fixed=False, verbose=True) log = log.getvalue() assert 'MEG: rank 302 computed from 305' in log _compare_io(my_inv_op) _compare_inverses_approx(my_inv_op, inverse_operator, evoked, rtol=1e-3, atol=1e-5) assert ('dev_head_t' in my_inv_op['info']) assert ('mri_head_t' in my_inv_op)
def test_make_inverse_operator(): """Test MNE inverse computation (precomputed and non-precomputed).""" # Test old version of inverse computation starting from forward operator evoked = _get_evoked() noise_cov = read_cov(fname_cov) inverse_operator = read_inverse_operator(fname_inv) fwd_op = convert_forward_solution(read_forward_solution_meg(fname_fwd), surf_ori=True, copy=False) with catch_logging() as log: my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=0.2, depth=0.8, limit_depth_chs=False, verbose=True) log = log.getvalue() assert 'rank 302 (3 small eigenvalues omitted)' in log _compare_io(my_inv_op) assert_equal(inverse_operator['units'], 'Am') _compare_inverses_approx(my_inv_op, inverse_operator, evoked, rtol=1e-2, atol=1e-5, depth_atol=1e-3) # Test MNE inverse computation starting from forward operator with catch_logging() as log: my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=0.2, depth=0.8, verbose=True) log = log.getvalue() assert 'rank 302 (3 small eigenvalues omitted)' in log _compare_io(my_inv_op) _compare_inverses_approx(my_inv_op, inverse_operator, evoked, rtol=1e-3, atol=1e-5) assert ('dev_head_t' in my_inv_op['info']) assert ('mri_head_t' in my_inv_op)
def test_apply_inverse_sphere(): """Test applying an inverse with a sphere model (rank-deficient).""" evoked = _get_evoked() evoked.pick_channels(evoked.ch_names[:306:8]) evoked.info['projs'] = [] cov = make_ad_hoc_cov(evoked.info) sphere = make_sphere_model('auto', 'auto', evoked.info) fwd = read_forward_solution(fname_fwd) vertices = [fwd['src'][0]['vertno'][::5], fwd['src'][1]['vertno'][::5]] stc = SourceEstimate(np.zeros((sum(len(v) for v in vertices), 1)), vertices, 0., 1.) fwd = restrict_forward_to_stc(fwd, stc) fwd = make_forward_solution(evoked.info, fwd['mri_head_t'], fwd['src'], sphere, mindist=5.) evoked = EvokedArray(fwd['sol']['data'].copy(), evoked.info) assert fwd['sol']['nrow'] == 39 assert fwd['nsource'] == 101 assert fwd['sol']['ncol'] == 303 tempdir = _TempDir() temp_fname = op.join(tempdir, 'temp-inv.fif') inv = make_inverse_operator(evoked.info, fwd, cov, loose=1.) # This forces everything to be float32 write_inverse_operator(temp_fname, inv) inv = read_inverse_operator(temp_fname) stc = apply_inverse(evoked, inv, method='eLORETA', method_params=dict(eps=1e-2)) # assert zero localization bias assert_array_equal(np.argmax(stc.data, axis=0), np.repeat(np.arange(101), 3))
def test_apply_mne_inverse_raw(): """Test MNE with precomputed inverse operator on Raw.""" start = 3 stop = 10 raw = read_raw_fif(fname_raw) label_lh = read_label(fname_label % 'Aud-lh') _, times = raw[0, start:stop] inverse_operator = read_inverse_operator(fname_full) inverse_operator = prepare_inverse_operator(inverse_operator, nave=1, lambda2=lambda2, method="dSPM") for pick_ori in [None, "normal", "vector"]: stc = apply_inverse_raw(raw, inverse_operator, lambda2, "dSPM", label=label_lh, start=start, stop=stop, nave=1, pick_ori=pick_ori, buffer_size=None, prepared=True) stc2 = apply_inverse_raw(raw, inverse_operator, lambda2, "dSPM", label=label_lh, start=start, stop=stop, nave=1, pick_ori=pick_ori, buffer_size=3, prepared=True) if pick_ori is None: assert_true(np.all(stc.data > 0)) assert_true(np.all(stc2.data > 0)) assert_true(stc.subject == 'sample') assert_true(stc2.subject == 'sample') assert_array_almost_equal(stc.times, times) assert_array_almost_equal(stc2.times, times) assert_array_almost_equal(stc.data, stc2.data)
def test_make_inverse_operator_loose(evoked): """Test MNE inverse computation (precomputed and non-precomputed).""" # Test old version of inverse computation starting from forward operator noise_cov = read_cov(fname_cov) inverse_operator = read_inverse_operator(fname_inv) fwd_op = convert_forward_solution(read_forward_solution_meg(fname_fwd), surf_ori=True, copy=False) with catch_logging() as log: my_inv_op = make_inverse_operator( evoked.info, fwd_op, noise_cov, loose=0.2, depth=dict(exp=0.8, limit_depth_chs=False), verbose=True) log = log.getvalue() assert 'MEG: rank 302 computed' in log assert 'limit = 1/%d' % fwd_op['nsource'] in log _compare_io(my_inv_op) assert_equal(inverse_operator['units'], 'Am') _compare_inverses_approx(my_inv_op, inverse_operator, evoked, rtol=1e-2, atol=1e-5, depth_atol=1e-3) # Test MNE inverse computation starting from forward operator with catch_logging() as log: my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose='auto', depth=0.8, fixed=False, verbose=True) log = log.getvalue() assert 'MEG: rank 302 computed from 305' in log _compare_io(my_inv_op) _compare_inverses_approx(my_inv_op, inverse_operator, evoked, rtol=1e-3, atol=1e-5) assert ('dev_head_t' in my_inv_op['info']) assert ('mri_head_t' in my_inv_op)
def test_source_psd(): """Test source PSD computation in label.""" raw = read_raw_fif(fname_data) inverse_operator = read_inverse_operator(fname_inv) tmin, tmax = 0, 20 # seconds fmin, fmax = 55, 65 # Hz n_fft = 2048 assert_equal(inverse_operator['source_ori'], FIFF.FIFFV_MNE_FREE_ORI) for pick_ori in ('normal', None): stc = compute_source_psd(raw, inverse_operator, lambda2=1. / 9., method="dSPM", tmin=tmin, tmax=tmax, fmin=fmin, fmax=fmax, pick_ori=pick_ori, n_fft=n_fft, overlap=0.1) assert_equal(stc.shape[0], inverse_operator['nsource']) assert_true(stc.times[0] >= fmin * 1e-3) assert_true(stc.times[-1] <= fmax * 1e-3) # Time max at line frequency (60 Hz in US) assert_true( 58e-3 <= stc.times[np.argmax(np.sum(stc.data, axis=0))] <= 61e-3)
def test_tfr_with_inverse_operator(): """Test time freq with MNE inverse computation""" tmin, tmax, event_id = -0.2, 0.5, 1 # Setup for reading the raw data raw = io.Raw(fname_data) events = find_events(raw, stim_channel='STI 014') inverse_operator = read_inverse_operator(fname_inv) inv = prepare_inverse_operator(inverse_operator, nave=1, lambda2=1. / 9., method="dSPM") raw.info['bads'] += ['MEG 2443', 'EEG 053'] # bads + 2 more # picks MEG gradiometers picks = pick_types(raw.info, meg=True, eeg=False, eog=True, stim=False, exclude='bads') # Load condition 1 event_id = 1 events3 = events[:3] # take 3 events to keep the computation time low epochs = Epochs(raw, events3, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=dict(grad=4000e-13, eog=150e-6), preload=True) # Compute a source estimate per frequency band bands = dict(alpha=[10, 10]) label = read_label(fname_label) stcs = source_band_induced_power(epochs, inv, bands, n_cycles=2, use_fft=False, pca=True, label=label, prepared=True) stc = stcs['alpha'] assert_true(len(stcs) == len(list(bands.keys()))) assert_true(np.all(stc.data > 0)) assert_array_almost_equal(stc.times, epochs.times) stcs_no_pca = source_band_induced_power(epochs, inv, bands, n_cycles=2, use_fft=False, pca=False, label=label, prepared=True) assert_array_almost_equal(stcs['alpha'].data, stcs_no_pca['alpha'].data) # Compute a source estimate per frequency band epochs = Epochs(raw, events[:10], event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=dict(grad=4000e-13, eog=150e-6), preload=True) frequencies = np.arange(7, 30, 2) # define frequencies of interest power, phase_lock = source_induced_power(epochs, inv, frequencies, label, baseline=(-0.1, 0), baseline_mode='percent', n_cycles=2, n_jobs=1, prepared=True) assert_true(np.all(phase_lock > 0)) assert_true(np.all(phase_lock <= 1)) assert_true(np.max(power) > 10)
def test_make_inverse_operator(): """Test MNE inverse computation (precomputed and non-precomputed) """ # Test old version of inverse computation starting from forward operator evoked = _get_evoked() noise_cov = read_cov(fname_cov) inverse_operator = read_inverse_operator(fname_inv) fwd_op = read_forward_solution_meg(fname_fwd, surf_ori=True) my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=0.2, depth=0.8, limit_depth_chs=False) _compare_io(my_inv_op) assert_true(inverse_operator['units'] == 'Am') _compare_inverses_approx(my_inv_op, inverse_operator, evoked, 1e-2, 1e-2, check_depth=False) # Test MNE inverse computation starting from forward operator my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=0.2, depth=0.8) _compare_io(my_inv_op) _compare_inverses_approx(my_inv_op, inverse_operator, evoked, 1e-2, 1e-2) assert_true('dev_head_t' in my_inv_op['info']) assert_true('mri_head_t' in my_inv_op)
def test_apply_mne_inverse_raw(): """Test MNE with precomputed inverse operator on Raw.""" start = 3 stop = 10 raw = read_raw_fif(fname_raw) label_lh = read_label(fname_label % 'Aud-lh') _, times = raw[0, start:stop] inverse_operator = read_inverse_operator(fname_full) with pytest.raises(ValueError, match='has not been prepared'): apply_inverse_raw(raw, inverse_operator, lambda2, prepared=True) inverse_operator = prepare_inverse_operator(inverse_operator, nave=1, lambda2=lambda2, method="dSPM") for pick_ori in [None, "normal", "vector"]: stc = apply_inverse_raw(raw, inverse_operator, lambda2, "dSPM", label=label_lh, start=start, stop=stop, nave=1, pick_ori=pick_ori, buffer_size=None, prepared=True) stc2 = apply_inverse_raw(raw, inverse_operator, lambda2, "dSPM", label=label_lh, start=start, stop=stop, nave=1, pick_ori=pick_ori, buffer_size=3, prepared=True) if pick_ori is None: assert (np.all(stc.data > 0)) assert (np.all(stc2.data > 0)) assert (stc.subject == 'sample') assert (stc2.subject == 'sample') assert_array_almost_equal(stc.times, times) assert_array_almost_equal(stc2.times, times) assert_array_almost_equal(stc.data, stc2.data)
def test_source_psd(): """Test source PSD computation in label""" raw = io.Raw(fname_data) inverse_operator = read_inverse_operator(fname_inv) label = read_label(fname_label) tmin, tmax = 0, 20 # seconds fmin, fmax = 55, 65 # Hz n_fft = 2048 stc = compute_source_psd(raw, inverse_operator, lambda2=1. / 9., method="dSPM", tmin=tmin, tmax=tmax, fmin=fmin, fmax=fmax, pick_ori="normal", n_fft=n_fft, label=label, overlap=0.1) assert_true(stc.times[0] >= fmin * 1e-3) assert_true(stc.times[-1] <= fmax * 1e-3) # Time max at line frequency (60 Hz in US) assert_true( 59e-3 <= stc.times[np.argmax(np.sum(stc.data, axis=0))] <= 61e-3)
def test_apply_inverse_sphere(evoked): """Test applying an inverse with a sphere model (rank-deficient).""" evoked.pick_channels(evoked.ch_names[:306:8]) evoked.info['projs'] = [] cov = make_ad_hoc_cov(evoked.info) sphere = make_sphere_model('auto', 'auto', evoked.info) fwd = read_forward_solution(fname_fwd) vertices = [fwd['src'][0]['vertno'][::5], fwd['src'][1]['vertno'][::5]] stc = SourceEstimate(np.zeros((sum(len(v) for v in vertices), 1)), vertices, 0., 1.) fwd = restrict_forward_to_stc(fwd, stc) fwd = make_forward_solution(evoked.info, fwd['mri_head_t'], fwd['src'], sphere, mindist=5.) evoked = EvokedArray(fwd['sol']['data'].copy(), evoked.info) assert fwd['sol']['nrow'] == 39 assert fwd['nsource'] == 101 assert fwd['sol']['ncol'] == 303 tempdir = _TempDir() temp_fname = op.join(tempdir, 'temp-inv.fif') inv = make_inverse_operator(evoked.info, fwd, cov, loose=1.) # This forces everything to be float32 write_inverse_operator(temp_fname, inv) inv = read_inverse_operator(temp_fname) stc = apply_inverse(evoked, inv, method='eLORETA', method_params=dict(eps=1e-2)) # assert zero localization bias assert_array_equal(np.argmax(stc.data, axis=0), np.repeat(np.arange(101), 3))
def test_make_inverse_operator_fixed(): """Test MNE inverse computation (fixed orientation).""" fwd = read_forward_solution_meg(fname_fwd) evoked = _get_evoked() noise_cov = read_cov(fname_cov) # can't make fixed inv with depth weighting without free ori fwd fwd_fixed = convert_forward_solution(fwd, force_fixed=True, use_cps=True) pytest.raises(ValueError, make_inverse_operator, evoked.info, fwd_fixed, noise_cov, depth=0.8, fixed=True) # now compare to C solution # note that the forward solution must not be surface-oriented # to get equivalency (surf_ori=True changes the normals) with catch_logging() as log: inv_op = make_inverse_operator( # test depth=0. alias for depth=None evoked.info, fwd, noise_cov, depth=0., fixed=True, use_cps=False, verbose=True) log = log.getvalue() assert 'rank 302 (3 small eigenvalues omitted)' in log assert 'EEG channels: 0' in repr(inv_op) assert 'MEG channels: 305' in repr(inv_op) del fwd_fixed inverse_operator_nodepth = read_inverse_operator(fname_inv_fixed_nodepth) # XXX We should have this but we don't (MNE-C doesn't restrict info): # assert 'EEG channels: 0' in repr(inverse_operator_nodepth) assert 'MEG channels: 305' in repr(inverse_operator_nodepth) _compare_inverses_approx(inverse_operator_nodepth, inv_op, evoked, rtol=1e-5, atol=1e-4) # Inverse has 306 channels - 6 proj = 302 assert (compute_rank_inverse(inverse_operator_nodepth) == 302) # Now with depth fwd_surf = convert_forward_solution(fwd, surf_ori=True) # not fixed for kwargs, use_fwd in zip([dict(fixed=True), dict(loose=0.)], [fwd, fwd_surf]): # Should be equiv. inv_op_depth = make_inverse_operator( evoked.info, use_fwd, noise_cov, depth=0.8, use_cps=True, **kwargs) inverse_operator_depth = read_inverse_operator(fname_inv_fixed_depth) # Normals should be the adjusted ones assert_allclose(inverse_operator_depth['source_nn'], fwd_surf['source_nn'][2::3], atol=1e-5) _compare_inverses_approx(inverse_operator_depth, inv_op_depth, evoked, rtol=1e-3, atol=1e-4)
def test_source_psd_epochs(): """Test multi-taper source PSD computation in label from epochs""" raw = fiff.Raw(fname_data) inverse_operator = read_inverse_operator(fname_inv) label = read_label(fname_label) event_id, tmin, tmax = 1, -0.2, 0.5 lambda2, method = 1. / 9., 'dSPM' bandwidth = 8. fmin, fmax = 0, 100 picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True, ecg=True, eog=True, include=['STI 014'], exclude='bads') reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6) events = find_events(raw) epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=reject) # only look at one epoch epochs.drop_bad_epochs() one_epochs = epochs[:1] # return list stc_psd = compute_source_psd_epochs(one_epochs, inverse_operator, lambda2=lambda2, method=method, pick_normal=True, label=label, bandwidth=bandwidth, fmin=fmin, fmax=fmax)[0] # return generator stcs = compute_source_psd_epochs(one_epochs, inverse_operator, lambda2=lambda2, method=method, pick_normal=True, label=label, bandwidth=bandwidth, fmin=fmin, fmax=fmax, return_generator=True) for stc in stcs: stc_psd_gen = stc assert_array_almost_equal(stc_psd.data, stc_psd_gen.data) # compare with direct computation stc = apply_inverse_epochs(one_epochs, inverse_operator, lambda2=lambda2, method=method, pick_normal=True, label=label)[0] sfreq = epochs.info['sfreq'] psd, freqs = multitaper_psd(stc.data, sfreq=sfreq, bandwidth=bandwidth, fmin=fmin, fmax=fmax) assert_array_almost_equal(psd, stc_psd.data) assert_array_almost_equal(freqs, stc_psd.times)
def test_io_inverse_operator(): """Test IO of inverse_operator """ for inv in [inverse_operator, inverse_operator_vol]: inv_init = copy.deepcopy(inv) write_inverse_operator('test-inv.fif', inv) this_inv = read_inverse_operator('test-inv.fif') _compare(inv, inv_init) _compare(inv, this_inv)
def test_apply_inverse_operator(): """Test MNE inverse application """ inverse_operator = read_inverse_operator(fname_full) evoked = _get_evoked() # Inverse has 306 channels - 4 proj = 302 assert_true(compute_rank_inverse(inverse_operator) == 302) # Inverse has 306 channels - 4 proj = 302 assert_true(compute_rank_inverse(inverse_operator) == 302) stc = apply_inverse(evoked, inverse_operator, lambda2, "MNE") assert_true(stc.subject == 'sample') assert_true(stc.data.min() > 0) assert_true(stc.data.max() < 10e-9) assert_true(stc.data.mean() > 1e-11) # test if using prepared and not prepared inverse operator give the same # result inv_op = prepare_inverse_operator(inverse_operator, nave=evoked.nave, lambda2=lambda2, method="MNE") stc2 = apply_inverse(evoked, inv_op, lambda2, "MNE") assert_array_almost_equal(stc.data, stc2.data) assert_array_almost_equal(stc.times, stc2.times) stc = apply_inverse(evoked, inverse_operator, lambda2, "sLORETA") assert_true(stc.subject == 'sample') assert_true(stc.data.min() > 0) assert_true(stc.data.max() < 10.0) assert_true(stc.data.mean() > 0.1) stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM") assert_true(stc.subject == 'sample') assert_true(stc.data.min() > 0) assert_true(stc.data.max() < 35) assert_true(stc.data.mean() > 0.1) # test without using a label (so delayed computation is used) label = read_label(fname_label % 'Aud-lh') stc = apply_inverse(evoked, inv_op, lambda2, "MNE") stc_label = apply_inverse(evoked, inv_op, lambda2, "MNE", label=label) assert_equal(stc_label.subject, 'sample') label_stc = stc.in_label(label) assert_true(label_stc.subject == 'sample') assert_array_almost_equal(stc_label.data, label_stc.data) # Test we get errors when using custom ref or no average proj is present evoked.info['custom_ref_applied'] = True assert_raises(ValueError, apply_inverse, evoked, inv_op, lambda2, "MNE") evoked.info['custom_ref_applied'] = False evoked.info['projs'] = [] # remove EEG proj assert_raises(ValueError, apply_inverse, evoked, inv_op, lambda2, "MNE")
def test_io_inverse_operator(): """Test IO of inverse_operator """ for inv in [inverse_operator, inverse_operator_vol]: inv_init = copy.deepcopy(inv) for out_file in ['test-inv.fif', 'test-inv.fif.gz']: write_inverse_operator(out_file, inv) this_inv = read_inverse_operator(out_file) _compare(inv, inv_init) _compare(inv, this_inv)
def test_inverse_operator_volume(): """Test MNE inverse computation on volume source space""" evoked = fiff.Evoked(fname_data, setno=0, baseline=(None, 0)) inverse_operator_vol = read_inverse_operator(fname_vol_inv) stc = apply_inverse(evoked, inverse_operator_vol, lambda2, "dSPM") stc.save('tmp-vl.stc') stc2 = read_source_estimate('tmp-vl.stc') assert_true(np.all(stc.data > 0)) assert_true(np.all(stc.data < 35)) assert_array_almost_equal(stc.data, stc2.data) assert_array_almost_equal(stc.times, stc2.times)
def getInversionKernel(fname_inv, nave=1, lambda2=1. / 9., method='MNE', label=None, pick_ori=None): inverse_operator = read_inverse_operator(fname_inv) inv = prepare_inverse_operator(inverse_operator, nave, lambda2, method) K, noise_norm, vertno = _assemble_kernel(inv, label, 'MNE', pick_ori) is_free_ori = inverse_operator['source_ori'] == FIFF.FIFFV_MNE_FREE_ORI return K, noise_norm, vertno, is_free_ori
def test_make_inverse_operator_diag(): """Test MNE inverse computation with diagonal noise cov """ fwd_op = read_forward_solution(fname_fwd, surf_ori=True) inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov.as_diag(), loose=0.2, depth=0.8) _compare_io(inv_op) inverse_operator_diag = read_inverse_operator(fname_inv_diag) # This one's only good to zero decimal places, roundoff error (?) _compare_inverses_approx(inverse_operator_diag, inv_op, evoked, 0) # Inverse has 306 channels - 4 proj = 302 assert_true(compute_rank_inverse(inverse_operator_diag) == 302)
def test_make_inverse_operator_diag(self): """Test MNE inverse computation with diagonal noise cov """ inv_op = make_inverse_operator(evoked.info, self.fwd_op, noise_cov.as_diag(), loose=0.2, depth=0.8) _compare_io(inv_op) inverse_operator_diag = read_inverse_operator(fname_inv_diag) # This one's only good to zero decimal places, roundoff error (?) _compare_inverses_approx(inverse_operator_diag, inv_op, evoked, 0) # Inverse has 306 channels - 4 proj = 302 assert_true(compute_rank_inverse(inverse_operator_diag) == 302)
def test_apply_inverse_operator(): """Test MNE inverse computation (precomputed and non-precomputed) """ inverse_operator = read_inverse_operator(fname_inv) evoked = _get_evoked() noise_cov = read_cov(fname_cov) # Test old version of inverse computation starting from forward operator fwd_op = read_forward_solution(fname_fwd, surf_ori=True) my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=0.2, depth=0.8, limit_depth_chs=False) _compare_io(my_inv_op) assert_true(inverse_operator['units'] == 'Am') _compare_inverses_approx(my_inv_op, inverse_operator, evoked, 2, check_depth=False) # Inverse has 306 channels - 4 proj = 302 assert_true(compute_rank_inverse(inverse_operator) == 302) # Test MNE inverse computation starting from forward operator my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=0.2, depth=0.8) _compare_io(my_inv_op) _compare_inverses_approx(my_inv_op, inverse_operator, evoked, 2) # Inverse has 306 channels - 4 proj = 302 assert_true(compute_rank_inverse(inverse_operator) == 302) stc = apply_inverse(evoked, inverse_operator, lambda2, "MNE") assert_true(stc.subject == 'sample') assert_true(stc.data.min() > 0) assert_true(stc.data.max() < 10e-10) assert_true(stc.data.mean() > 1e-11) stc = apply_inverse(evoked, inverse_operator, lambda2, "sLORETA") assert_true(stc.subject == 'sample') assert_true(stc.data.min() > 0) assert_true(stc.data.max() < 10.0) assert_true(stc.data.mean() > 0.1) stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM") assert_true(stc.subject == 'sample') assert_true(stc.data.min() > 0) assert_true(stc.data.max() < 35) assert_true(stc.data.mean() > 0.1) my_stc = apply_inverse(evoked, my_inv_op, lambda2, "dSPM") assert_true('dev_head_t' in my_inv_op['info']) assert_true('mri_head_t' in my_inv_op) assert_true(my_stc.subject == 'sample') assert_equal(stc.times, my_stc.times) assert_array_almost_equal(stc.data, my_stc.data, 2)
def test_inverse_operator_volume(): """Test MNE inverse computation on volume source space """ inverse_operator_vol = read_inverse_operator(fname_vol_inv) _compare_io(inverse_operator_vol) stc = apply_inverse(evoked, inverse_operator_vol, lambda2, "dSPM") stc.save(op.join(tempdir, 'tmp-vl.stc')) stc2 = read_source_estimate(op.join(tempdir, 'tmp-vl.stc')) assert_true(np.all(stc.data > 0)) assert_true(np.all(stc.data < 35)) assert_array_almost_equal(stc.data, stc2.data) assert_array_almost_equal(stc.times, stc2.times)
def _compare_io(inv_op, out_file_ext='.fif'): if out_file_ext == '.fif': out_file = op.join(tempdir, 'test-inv.fif') elif out_file_ext == '.gz': out_file = op.join(tempdir, 'test-inv.fif.gz') else: raise ValueError('IO test could not complete') # Test io operations inv_init = copy.deepcopy(inv_op) write_inverse_operator(out_file, inv_op) read_inv_op = read_inverse_operator(out_file) _compare(inv_init, read_inv_op) _compare(inv_init, inv_op)
def test_apply_mne_inverse_epochs(): """Test MNE with precomputed inverse operator on Epochs """ inverse_operator = read_inverse_operator(fname_inv) label_lh = read_label(fname_label % 'Aud-lh') label_rh = read_label(fname_label % 'Aud-rh') event_id, tmin, tmax = 1, -0.2, 0.5 raw = fiff.Raw(fname_raw) picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True, ecg=True, eog=True, include=['STI 014'], exclude='bads') reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6) flat = dict(grad=1e-15, mag=1e-15) events = read_events(fname_event)[:15] epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=reject, flat=flat) stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM", label=label_lh, pick_ori="normal") assert_true(len(stcs) == 4) assert_true(3 < stcs[0].data.max() < 10) assert_true(stcs[0].subject == 'sample') data = sum(stc.data for stc in stcs) / len(stcs) flip = label_sign_flip(label_lh, inverse_operator['src']) label_mean = np.mean(data, axis=0) label_mean_flip = np.mean(flip[:, np.newaxis] * data, axis=0) assert_true(label_mean.max() < label_mean_flip.max()) # test extracting a BiHemiLabel stcs_rh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM", label=label_rh, pick_ori="normal") stcs_bh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM", label=label_lh + label_rh, pick_ori="normal") n_lh = len(stcs[0].data) assert_array_almost_equal(stcs[0].data, stcs_bh[0].data[:n_lh]) assert_array_almost_equal(stcs_rh[0].data, stcs_bh[0].data[n_lh:]) # test without using a label (so delayed computation is used) stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM", pick_ori="normal") assert_true(stcs[0].subject == 'sample') label_stc = stcs[0].in_label(label_rh) assert_true(label_stc.subject == 'sample') assert_array_almost_equal(stcs_rh[0].data, label_stc.data)
def test_make_inverse_operator_diag(evoked, noise_cov): """Test MNE inverse computation with diagonal noise cov.""" noise_cov = noise_cov.as_diag() fwd_op = convert_forward_solution(read_forward_solution(fname_fwd), surf_ori=True) inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=0.2, depth=0.8) _compare_io(inv_op) inverse_operator_diag = read_inverse_operator(fname_inv_meeg_diag) # This one is pretty bad _compare_inverses_approx(inverse_operator_diag, inv_op, evoked, rtol=1e-1, atol=1e-1, ctol=0.99, check_K=False) # Inverse has 366 channels - 6 proj = 360 assert (compute_rank_inverse(inverse_operator_diag) == 360)
def test_make_inverse_operator_diag(): """Test MNE inverse computation with diagonal noise cov """ evoked = _get_evoked() noise_cov = read_cov(fname_cov) fwd_op = read_forward_solution(fname_fwd, surf_ori=True) inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov.as_diag(), loose=0.2, depth=0.8) _compare_io(inv_op) inverse_operator_diag = read_inverse_operator(fname_inv_meeg_diag) # This one's only good to zero decimal places, roundoff error (?) _compare_inverses_approx(inverse_operator_diag, inv_op, evoked, 0, 1e0) # Inverse has 366 channels - 6 proj = 360 assert_true(compute_rank_inverse(inverse_operator_diag) == 360)
def test_make_inverse_operator_diag(): """Test MNE inverse computation with diagonal noise cov """ evoked = _get_evoked() noise_cov = read_cov(fname_cov).as_diag(copy=False) fwd_op = read_forward_solution(fname_fwd, surf_ori=True) inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=0.2, depth=0.8) _compare_io(inv_op) inverse_operator_diag = read_inverse_operator(fname_inv_meeg_diag) # This one's only good to zero decimal places, roundoff error (?) _compare_inverses_approx(inverse_operator_diag, inv_op, evoked, 0, 1e0) # Inverse has 366 channels - 6 proj = 360 assert_true(compute_rank_inverse(inverse_operator_diag) == 360)
def test_inverse_operator_volume(): """Test MNE inverse computation on volume source space """ inverse_operator_vol = read_inverse_operator(fname_vol_inv) _compare_io(inverse_operator_vol) stc = apply_inverse(evoked, inverse_operator_vol, lambda2, "dSPM") # volume inverses don't have associated subject IDs assert_true(stc.subject is None) stc.save(op.join(tempdir, 'tmp-vl.stc')) stc2 = read_source_estimate(op.join(tempdir, 'tmp-vl.stc')) assert_true(np.all(stc.data > 0)) assert_true(np.all(stc.data < 35)) assert_array_almost_equal(stc.data, stc2.data) assert_array_almost_equal(stc.times, stc2.times)
def test_inverse_operator_volume(): """Test MNE inverse computation on volume source space """ evoked = _get_evoked() inverse_operator_vol = read_inverse_operator(fname_vol_inv) _compare_io(inverse_operator_vol) stc = apply_inverse(evoked, inverse_operator_vol, lambda2, "dSPM") assert_true(isinstance(stc, VolSourceEstimate)) # volume inverses don't have associated subject IDs assert_true(stc.subject is None) stc.save(op.join(tempdir, 'tmp-vl.stc')) stc2 = read_source_estimate(op.join(tempdir, 'tmp-vl.stc')) assert_true(np.all(stc.data > 0)) assert_true(np.all(stc.data < 35)) assert_array_almost_equal(stc.data, stc2.data) assert_array_almost_equal(stc.times, stc2.times)
def test_inverse_residual(evoked): """Test MNE inverse application.""" # use fname_inv as it will be faster than fname_full (fewer verts and chs) evoked = evoked.pick_types() inv = read_inverse_operator(fname_inv_fixed_depth) fwd = read_forward_solution(fname_fwd) pick_channels_forward(fwd, evoked.ch_names, copy=False) fwd = convert_forward_solution(fwd, force_fixed=True, surf_ori=True) matcher = re.compile(r'.* ([0-9]?[0-9]?[0-9]?\.[0-9])% variance.*') for method in ('MNE', 'dSPM', 'sLORETA'): with catch_logging() as log: stc, residual = apply_inverse(evoked, inv, method=method, return_residual=True, verbose=True) log = log.getvalue() match = matcher.match(log.replace('\n', ' ')) assert match is not None match = float(match.group(1)) assert 45 < match < 50 if method == 'MNE': # must be first! recon = apply_forward(fwd, stc, evoked.info) proj_op = make_projector(evoked.info['projs'], evoked.ch_names)[0] recon.data[:] = np.dot(proj_op, recon.data) residual_fwd = evoked.copy() residual_fwd.data -= recon.data corr = np.corrcoef(residual_fwd.data.ravel(), residual.data.ravel())[0, 1] assert corr > 0.999 with catch_logging() as log: _, residual = apply_inverse(evoked, inv, 0., 'MNE', return_residual=True, verbose=True) log = log.getvalue() match = matcher.match(log.replace('\n', ' ')) assert match is not None match = float(match.group(1)) assert match == 100. assert_array_less(np.abs(residual.data), 1e-15) # Degenerate: we don't have the right representation for eLORETA for this with pytest.raises(ValueError, match='eLORETA does not .* support .*'): apply_inverse(evoked, inv, method="eLORETA", return_residual=True)
def test_source_psd(): """Test source PSD computation from raw.""" raw = read_raw_fif(fname_data) raw.crop(0, 5).load_data() inverse_operator = read_inverse_operator(fname_inv) fmin, fmax = 40, 65 # Hz n_fft = 512 assert inverse_operator['source_ori'] == FIFF.FIFFV_MNE_FREE_ORI stcs = list() for pick_ori, method in zip((None, 'normal', 'normal'), ('dSPM', 'dSPM', 'MNE')): stc, ev = compute_source_psd(raw, inverse_operator, lambda2=1. / 9., method=method, fmin=fmin, fmax=fmax, pick_ori=pick_ori, n_fft=n_fft, overlap=0., return_sensor=True, dB=True) assert ev.data.shape == (len(ev.info['ch_names']), len(stc.times)) assert ev.times[0] >= fmin assert ev.times[-1] <= fmax # Time max at line frequency (60 Hz in US) assert 58 <= ev.times[np.argmax(np.sum(ev.data, axis=0))] <= 61 assert ev.nave == 2 assert stc.shape[0] == inverse_operator['nsource'] assert stc.times[0] >= fmin assert stc.times[-1] <= fmax assert 58 <= stc.times[np.argmax(np.sum(stc.data, axis=0))] <= 61 stcs.append(stc) stc_dspm = stcs[-2] stc_mne = stcs[-1] # normalize each source point by its power after undoing the dB stc_dspm.data = 10**(stc_dspm.data / 10.) stc_dspm /= stc_dspm.mean() stc_mne.data = 10**(stc_mne.data / 10.) stc_mne /= stc_mne.mean() assert_allclose(stc_dspm.data, stc_mne.data, atol=1e-4)
def test_inverse_operator_volume(): """Test MNE inverse computation on volume source space """ tempdir = _TempDir() evoked = _get_evoked() inverse_operator_vol = read_inverse_operator(fname_vol_inv) assert_true(repr(inverse_operator_vol)) stc = apply_inverse(evoked, inverse_operator_vol, lambda2, "dSPM") assert_true(isinstance(stc, VolSourceEstimate)) # volume inverses don't have associated subject IDs assert_true(stc.subject is None) stc.save(op.join(tempdir, 'tmp-vl.stc')) stc2 = read_source_estimate(op.join(tempdir, 'tmp-vl.stc')) assert_true(np.all(stc.data > 0)) assert_true(np.all(stc.data < 35)) assert_array_almost_equal(stc.data, stc2.data) assert_array_almost_equal(stc.times, stc2.times)
def test_source_psd(): """Test source PSD computation in label.""" raw = read_raw_fif(fname_data) inverse_operator = read_inverse_operator(fname_inv) label = read_label(fname_label) tmin, tmax = 0, 20 # seconds fmin, fmax = 55, 65 # Hz n_fft = 2048 stc = compute_source_psd(raw, inverse_operator, lambda2=1. / 9., method="dSPM", tmin=tmin, tmax=tmax, fmin=fmin, fmax=fmax, pick_ori="normal", n_fft=n_fft, label=label, overlap=0.1) assert_true(stc.times[0] >= fmin * 1e-3) assert_true(stc.times[-1] <= fmax * 1e-3) # Time max at line frequency (60 Hz in US) assert_true(59e-3 <= stc.times[np.argmax(np.sum(stc.data, axis=0))] <= 61e-3)
def test_inverse_operator_volume(evoked): """Test MNE inverse computation on volume source space.""" tempdir = _TempDir() inv_vol = read_inverse_operator(fname_vol_inv) assert (repr(inv_vol)) stc = apply_inverse(evoked, inv_vol, lambda2, 'dSPM') assert (isinstance(stc, VolSourceEstimate)) # volume inverses don't have associated subject IDs assert (stc.subject is None) stc.save(op.join(tempdir, 'tmp-vl.stc')) stc2 = read_source_estimate(op.join(tempdir, 'tmp-vl.stc')) assert (np.all(stc.data > 0)) assert (np.all(stc.data < 35)) assert_array_almost_equal(stc.data, stc2.data) assert_array_almost_equal(stc.times, stc2.times) # vector source estimate stc_vec = apply_inverse(evoked, inv_vol, lambda2, 'dSPM', 'vector') assert (repr(stc_vec)) assert_allclose(np.linalg.norm(stc_vec.data, axis=1), stc.data)
def test_apply_inverse_operator(): """Test MNE inverse computation With and without precomputed inverse operator. """ evoked = fiff.Evoked(fname_data, setno=0, baseline=(None, 0)) stc = apply_inverse(evoked, inverse_operator, lambda2, "MNE") assert_true(stc.data.min() > 0) assert_true(stc.data.max() < 10e-10) assert_true(stc.data.mean() > 1e-11) stc = apply_inverse(evoked, inverse_operator, lambda2, "sLORETA") assert_true(stc.data.min() > 0) assert_true(stc.data.max() < 9.0) assert_true(stc.data.mean() > 0.1) stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM") assert_true(stc.data.min() > 0) assert_true(stc.data.max() < 35) assert_true(stc.data.mean() > 0.1) # Test MNE inverse computation starting from forward operator evoked = fiff.Evoked(fname_data, setno=0, baseline=(None, 0)) fwd_op = read_forward_solution(fname_fwd, surf_ori=True) my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=0.2, depth=0.8) write_inverse_operator('test-inv.fif', my_inv_op) read_my_inv_op = read_inverse_operator('test-inv.fif') _compare(my_inv_op, read_my_inv_op) my_stc = apply_inverse(evoked, my_inv_op, lambda2, "dSPM") assert_true('dev_head_t' in my_inv_op['info']) assert_true('mri_head_t' in my_inv_op) assert_equal(stc.times, my_stc.times) assert_array_almost_equal(stc.data, my_stc.data, 2)
def test_inverse_residual(): """Test MNE inverse application.""" # use fname_inv as it will be faster than fname_full (fewer verts and chs) evoked = _get_evoked().pick_types() inv = read_inverse_operator(fname_inv_fixed_depth) fwd = read_forward_solution(fname_fwd) fwd = convert_forward_solution(fwd, force_fixed=True, surf_ori=True) fwd = pick_channels_forward(fwd, evoked.ch_names) matcher = re.compile(r'.* ([0-9]?[0-9]?[0-9]?\.[0-9])% variance.*') for method in ('MNE', 'dSPM', 'sLORETA'): with catch_logging() as log: stc, residual = apply_inverse( evoked, inv, method=method, return_residual=True, verbose=True) log = log.getvalue() match = matcher.match(log.replace('\n', ' ')) assert match is not None match = float(match.group(1)) assert 45 < match < 50 if method == 'MNE': # must be first! recon = apply_forward(fwd, stc, evoked.info) proj_op = make_projector(evoked.info['projs'], evoked.ch_names)[0] recon.data[:] = np.dot(proj_op, recon.data) residual_fwd = evoked.copy() residual_fwd.data -= recon.data corr = np.corrcoef(residual_fwd.data.ravel(), residual.data.ravel())[0, 1] assert corr > 0.999 with catch_logging() as log: _, residual = apply_inverse( evoked, inv, 0., 'MNE', return_residual=True, verbose=True) log = log.getvalue() match = matcher.match(log.replace('\n', ' ')) assert match is not None match = float(match.group(1)) assert match == 100. assert_array_less(np.abs(residual.data), 1e-15) # Degenerate: we don't have the right representation for eLORETA for this with pytest.raises(ValueError, match='eLORETA does not .* support .*'): apply_inverse(evoked, inv, method="eLORETA", return_residual=True)
def test_source_psd(): """Test source PSD computation in label.""" raw = read_raw_fif(fname_data) inverse_operator = read_inverse_operator(fname_inv) tmin, tmax = 0, 20 # seconds fmin, fmax = 55, 65 # Hz n_fft = 2048 assert_equal(inverse_operator['source_ori'], FIFF.FIFFV_MNE_FREE_ORI) for pick_ori in ('normal', None): stc = compute_source_psd(raw, inverse_operator, lambda2=1. / 9., method="dSPM", tmin=tmin, tmax=tmax, fmin=fmin, fmax=fmax, pick_ori=pick_ori, n_fft=n_fft, overlap=0.1) assert_equal(stc.shape[0], inverse_operator['nsource']) assert stc.times[0] >= fmin * 1e-3 assert stc.times[-1] <= fmax * 1e-3 # Time max at line frequency (60 Hz in US) assert 58e-3 <= stc.times[np.argmax(np.sum(stc.data, axis=0))] <= 61e-3