def test_lcmv():
"""Test LCMV with evoked data and single trials
"""
raw, epochs, evoked, data_cov, noise_cov, label, forward,\
forward_surf_ori, forward_fixed, forward_vol = _get_data()
for fwd in [forward, forward_vol]:
stc = lcmv(evoked, fwd, noise_cov, data_cov, reg=0.01)
if fwd is forward:
assert_true(isinstance(stc, SourceEstimate))
else:
assert_true(isinstance(stc, VolSourceEstimate))
stc_pow = np.sum(stc.data, axis=1)
idx = np.argmax(stc_pow)
max_stc = stc.data[idx]
tmax = stc.times[np.argmax(max_stc)]
assert_true(0.09 < tmax < 0.105)
assert_true(1.9 < np.max(max_stc) < 3.)
if fwd is forward:
# Test picking normal orientation (surface source space only)
stc_normal = lcmv(evoked,
forward_surf_ori,
noise_cov,
data_cov,
reg=0.01,
pick_ori="normal")
stc_pow = np.sum(np.abs(stc_normal.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_normal.data[idx]
tmax = stc_normal.times[np.argmax(max_stc)]
assert_true(0.09 < tmax < 0.11)
assert_true(1. < np.max(max_stc) < 2.)
# The amplitude of normal orientation results should always be
# smaller than free orientation results
assert_true((np.abs(stc_normal.data) <= stc.data).all())
# Test picking source orientation maximizing output source power
stc_max_power = lcmv(evoked,
fwd,
noise_cov,
data_cov,
reg=0.01,
pick_ori="max-power")
stc_pow = np.sum(stc_max_power.data, axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_max_power.data[idx]
tmax = stc.times[np.argmax(max_stc)]
assert_true(0.09 < tmax < 0.1)
assert_true(2. < np.max(max_stc) < 3.)
# Maximum output source power orientation results should be similar to
# free orientation results
assert_true((stc_max_power.data - stc.data < 0.5).all())
# Test if fixed forward operator is detected when picking normal or
# max-power orientation
assert_raises(ValueError,
lcmv,
evoked,
forward_fixed,
noise_cov,
data_cov,
reg=0.01,
pick_ori="normal")
assert_raises(ValueError,
lcmv,
evoked,
forward_fixed,
noise_cov,
data_cov,
reg=0.01,
pick_ori="max-power")
# Test if non-surface oriented forward operator is detected when picking
# normal orientation
assert_raises(ValueError,
lcmv,
evoked,
forward,
noise_cov,
data_cov,
reg=0.01,
pick_ori="normal")
# Test if volume forward operator is detected when picking normal
# orientation
assert_raises(ValueError,
lcmv,
evoked,
forward_vol,
noise_cov,
data_cov,
reg=0.01,
pick_ori="normal")
# Now test single trial using fixed orientation forward solution
# so we can compare it to the evoked solution
stcs = lcmv_epochs(epochs, forward_fixed, noise_cov, data_cov, reg=0.01)
stcs_ = lcmv_epochs(epochs,
forward_fixed,
noise_cov,
data_cov,
reg=0.01,
return_generator=True)
assert_array_equal(stcs[0].data, advance_iterator(stcs_).data)
epochs.drop_bad_epochs()
assert_true(len(epochs.events) == len(stcs))
# average the single trial estimates
stc_avg = np.zeros_like(stcs[0].data)
for this_stc in stcs:
stc_avg += this_stc.data
stc_avg /= len(stcs)
# compare it to the solution using evoked with fixed orientation
stc_fixed = lcmv(evoked, forward_fixed, noise_cov, data_cov, reg=0.01)
assert_array_almost_equal(stc_avg, stc_fixed.data)
# use a label so we have few source vertices and delayed computation is
# not used
stcs_label = lcmv_epochs(epochs,
forward_fixed,
noise_cov,
data_cov,
reg=0.01,
label=label)
assert_array_almost_equal(stcs_label[0].data, stcs[0].in_label(label).data)
def test_apply_dics_timeseries():
"""Test DICS applied to timeseries data."""
fwd_free, fwd_surf, fwd_fixed, fwd_vol, label = _load_forward()
epochs, evoked, csd, source_vertno = _simulate_data(fwd_fixed)
vertices = np.intersect1d(label.vertices, fwd_free['src'][0]['vertno'])
source_ind = vertices.tolist().index(source_vertno)
reg = 5 # Lots of regularization for our toy dataset
multiple_filters = make_dics(evoked.info, fwd_surf, csd, label=label,
reg=reg)
# Sanity checks on the resulting STC after applying DICS on evoked
stcs = apply_dics(evoked, multiple_filters)
assert isinstance(stcs, list)
assert len(stcs) == len(multiple_filters['weights'])
assert_array_equal(stcs[0].vertices[0], multiple_filters['vertices'][0])
assert_array_equal(stcs[0].vertices[1], multiple_filters['vertices'][1])
assert_allclose(stcs[0].times, evoked.times)
# Applying filters for multiple frequencies on epoch data should fail
raises(ValueError, apply_dics_epochs, epochs, multiple_filters)
# From now on, only apply filters with a single frequency (20 Hz).
csd20 = csd.pick_frequency(20)
filters = make_dics(evoked.info, fwd_surf, csd20, label=label, reg=reg)
# Sanity checks on the resulting STC after applying DICS on epochs.
# Also test here that no warnings are thrown - implemented to check whether
# src should not be None warning occurs
with pytest.warns(None) as w:
stcs = apply_dics_epochs(epochs, filters)
assert len(w) == 0
assert isinstance(stcs, list)
assert len(stcs) == 1
assert_array_equal(stcs[0].vertices[0], filters['vertices'][0])
assert_array_equal(stcs[0].vertices[1], filters['vertices'][1])
assert_allclose(stcs[0].times, epochs.times)
# Did we find the source?
stc = (stcs[0] ** 2).mean()
assert np.argmax(stc.data) == source_ind
# Apply filters to evoked
stc = apply_dics(evoked, filters)
stc = (stc ** 2).mean()
assert np.argmax(stc.data) == source_ind
# Test if wrong channel selection is detected in application of filter
evoked_ch = cp.deepcopy(evoked)
evoked_ch.pick_channels(evoked_ch.ch_names[:-1])
raises(ValueError, apply_dics, evoked_ch, filters)
# Test whether projections are applied, by adding a custom projection
filters_noproj = make_dics(evoked.info, fwd_surf, csd20, label=label)
stc_noproj = apply_dics(evoked, filters_noproj)
evoked_proj = evoked.copy()
p = compute_proj_evoked(evoked_proj, n_grad=1, n_mag=0, n_eeg=0)
proj_matrix = make_projector(p, evoked_proj.ch_names)[0]
evoked_proj.info['projs'] += p
filters_proj = make_dics(evoked_proj.info, fwd_surf, csd20, label=label)
assert_array_equal(filters_proj['proj'], proj_matrix)
stc_proj = apply_dics(evoked_proj, filters_proj)
assert np.any(np.not_equal(stc_noproj.data, stc_proj.data))
# Test detecting incompatible projections
filters_proj['proj'] = filters_proj['proj'][:-1, :-1]
raises(ValueError, apply_dics, evoked_proj, filters_proj)
# Test returning a generator
stcs = apply_dics_epochs(epochs, filters, return_generator=False)
stcs_gen = apply_dics_epochs(epochs, filters, return_generator=True)
assert_array_equal(stcs[0].data, advance_iterator(stcs_gen).data)
# Test computing timecourses on a volume source space
filters_vol = make_dics(evoked.info, fwd_vol, csd20, reg=reg)
stc = apply_dics(evoked, filters_vol)
stc = (stc ** 2).mean()
assert np.argmax(stc.data) == 3851 # TODO: don't make this hard coded
# check whether a filters object without src_type throws expected warning
del filters_vol['src_type'] # emulate 0.16 behaviour to cause warning
with pytest.warns(RuntimeWarning, match='spatial filter does not contain '
'src_type'):
apply_dics_epochs(epochs, filters_vol)
def test_dics():
"""Test DICS with evoked data and single trials
"""
raw, epochs, evoked, data_csd, noise_csd, label, forward,\
forward_surf_ori, forward_fixed, forward_vol = _get_data()
stc = dics(evoked, forward, noise_csd=noise_csd, data_csd=data_csd,
label=label)
stc.crop(0, None)
stc_pow = np.sum(stc.data, axis=1)
idx = np.argmax(stc_pow)
max_stc = stc.data[idx]
tmax = stc.times[np.argmax(max_stc)]
# Incorrect due to limited number of epochs
assert_true(0.04 < tmax < 0.05)
assert_true(10 < np.max(max_stc) < 13)
# Test picking normal orientation
stc_normal = dics(evoked, forward_surf_ori, noise_csd, data_csd,
pick_ori="normal", label=label)
stc_normal.crop(0, None)
# The amplitude of normal orientation results should always be smaller than
# free orientation results
assert_true((np.abs(stc_normal.data) <= stc.data).all())
# Test if fixed forward operator is detected when picking normal
# orientation
assert_raises(ValueError, dics_epochs, epochs, forward_fixed, noise_csd,
data_csd, pick_ori="normal")
# Test if non-surface oriented forward operator is detected when picking
# normal orientation
assert_raises(ValueError, dics_epochs, epochs, forward, noise_csd,
data_csd, pick_ori="normal")
# Test if volume forward operator is detected when picking normal
# orientation
assert_raises(ValueError, dics_epochs, epochs, forward_vol, noise_csd,
data_csd, pick_ori="normal")
# Now test single trial using fixed orientation forward solution
# so we can compare it to the evoked solution
stcs = dics_epochs(epochs, forward_fixed, noise_csd, data_csd, reg=0.01,
label=label)
# Testing returning of generator
stcs_ = dics_epochs(epochs, forward_fixed, noise_csd, data_csd, reg=0.01,
return_generator=True, label=label)
assert_array_equal(stcs[0].data, advance_iterator(stcs_).data)
# Test whether correct number of trials was returned
epochs.drop_bad()
assert_true(len(epochs.events) == len(stcs))
# Average the single trial estimates
stc_avg = np.zeros_like(stc.data)
for this_stc in stcs:
stc_avg += this_stc.crop(0, None).data
stc_avg /= len(stcs)
idx = np.argmax(np.max(stc_avg, axis=1))
max_stc = stc_avg[idx]
tmax = stc.times[np.argmax(max_stc)]
assert_true(0.045 < tmax < 0.06) # incorrect due to limited # of epochs
assert_true(12 < np.max(max_stc) < 18.5)
def test_lcmv():
"""Test LCMV with evoked data and single trials
"""
raw, epochs, evoked, data_cov, noise_cov, label, forward,\
forward_surf_ori, forward_fixed, forward_vol = _get_data()
for fwd in [forward, forward_vol]:
stc = lcmv(evoked, fwd, noise_cov, data_cov, reg=0.01)
if fwd is forward:
assert_true(isinstance(stc, SourceEstimate))
else:
assert_true(isinstance(stc, VolSourceEstimate))
stc_pow = np.sum(stc.data, axis=1)
idx = np.argmax(stc_pow)
max_stc = stc.data[idx]
tmax = stc.times[np.argmax(max_stc)]
assert_true(0.09 < tmax < 0.105)
assert_true(1.9 < np.max(max_stc) < 3.)
if fwd is forward:
# Test picking normal orientation (surface source space only)
stc_normal = lcmv(evoked, forward_surf_ori, noise_cov, data_cov,
reg=0.01, pick_ori="normal")
stc_pow = np.sum(np.abs(stc_normal.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_normal.data[idx]
tmax = stc_normal.times[np.argmax(max_stc)]
assert_true(0.09 < tmax < 0.11)
assert_true(1. < np.max(max_stc) < 2.)
# The amplitude of normal orientation results should always be
# smaller than free orientation results
assert_true((np.abs(stc_normal.data) <= stc.data).all())
# Test picking source orientation maximizing output source power
stc_max_power = lcmv(evoked, fwd, noise_cov, data_cov, reg=0.01,
pick_ori="max-power")
stc_pow = np.sum(stc_max_power.data, axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_max_power.data[idx]
tmax = stc.times[np.argmax(max_stc)]
assert_true(0.09 < tmax < 0.1)
assert_true(2. < np.max(max_stc) < 3.)
# Maximum output source power orientation results should be similar to
# free orientation results
assert_true((stc_max_power.data - stc.data < 0.5).all())
# Test if fixed forward operator is detected when picking normal or
# max-power orientation
assert_raises(ValueError, lcmv, evoked, forward_fixed, noise_cov, data_cov,
reg=0.01, pick_ori="normal")
assert_raises(ValueError, lcmv, evoked, forward_fixed, noise_cov, data_cov,
reg=0.01, pick_ori="max-power")
# Test if non-surface oriented forward operator is detected when picking
# normal orientation
assert_raises(ValueError, lcmv, evoked, forward, noise_cov, data_cov,
reg=0.01, pick_ori="normal")
# Test if volume forward operator is detected when picking normal
# orientation
assert_raises(ValueError, lcmv, evoked, forward_vol, noise_cov, data_cov,
reg=0.01, pick_ori="normal")
# Now test single trial using fixed orientation forward solution
# so we can compare it to the evoked solution
stcs = lcmv_epochs(epochs, forward_fixed, noise_cov, data_cov, reg=0.01)
stcs_ = lcmv_epochs(epochs, forward_fixed, noise_cov, data_cov, reg=0.01,
return_generator=True)
assert_array_equal(stcs[0].data, advance_iterator(stcs_).data)
epochs.drop_bad_epochs()
assert_true(len(epochs.events) == len(stcs))
# average the single trial estimates
stc_avg = np.zeros_like(stcs[0].data)
for this_stc in stcs:
stc_avg += this_stc.data
stc_avg /= len(stcs)
# compare it to the solution using evoked with fixed orientation
stc_fixed = lcmv(evoked, forward_fixed, noise_cov, data_cov, reg=0.01)
assert_array_almost_equal(stc_avg, stc_fixed.data)
# use a label so we have few source vertices and delayed computation is
# not used
stcs_label = lcmv_epochs(epochs, forward_fixed, noise_cov, data_cov,
reg=0.01, label=label)
assert_array_almost_equal(stcs_label[0].data, stcs[0].in_label(label).data)
def test_dics():
"""Test DICS with evoked data and single trials
"""
raw, epochs, evoked, data_csd, noise_csd, label, forward,\
forward_surf_ori, forward_fixed, forward_vol = _get_data()
stc = dics(evoked,
forward,
noise_csd=noise_csd,
data_csd=data_csd,
label=label)
stc.crop(0, None)
stc_pow = np.sum(stc.data, axis=1)
idx = np.argmax(stc_pow)
max_stc = stc.data[idx]
tmax = stc.times[np.argmax(max_stc)]
# Incorrect due to limited number of epochs
assert_true(0.04 < tmax < 0.05)
assert_true(10 < np.max(max_stc) < 13)
# Test picking normal orientation
stc_normal = dics(evoked,
forward_surf_ori,
noise_csd,
data_csd,
pick_ori="normal",
label=label)
stc_normal.crop(0, None)
# The amplitude of normal orientation results should always be smaller than
# free orientation results
assert_true((np.abs(stc_normal.data) <= stc.data).all())
# Test if fixed forward operator is detected when picking normal
# orientation
assert_raises(ValueError,
dics_epochs,
epochs,
forward_fixed,
noise_csd,
data_csd,
pick_ori="normal")
# Test if non-surface oriented forward operator is detected when picking
# normal orientation
assert_raises(ValueError,
dics_epochs,
epochs,
forward,
noise_csd,
data_csd,
pick_ori="normal")
# Test if volume forward operator is detected when picking normal
# orientation
assert_raises(ValueError,
dics_epochs,
epochs,
forward_vol,
noise_csd,
data_csd,
pick_ori="normal")
# Now test single trial using fixed orientation forward solution
# so we can compare it to the evoked solution
stcs = dics_epochs(epochs,
forward_fixed,
noise_csd,
data_csd,
reg=0.01,
label=label)
# Testing returning of generator
stcs_ = dics_epochs(epochs,
forward_fixed,
noise_csd,
data_csd,
reg=0.01,
return_generator=True,
label=label)
assert_array_equal(stcs[0].data, advance_iterator(stcs_).data)
# Test whether correct number of trials was returned
epochs.drop_bad_epochs()
assert_true(len(epochs.events) == len(stcs))
# Average the single trial estimates
stc_avg = np.zeros_like(stc.data)
for this_stc in stcs:
stc_avg += this_stc.crop(0, None).data
stc_avg /= len(stcs)
idx = np.argmax(np.max(stc_avg, axis=1))
max_stc = stc_avg[idx]
tmax = stc.times[np.argmax(max_stc)]
assert_true(0.045 < tmax < 0.06) # incorrect due to limited # of epochs
assert_true(12 < np.max(max_stc) < 18.5)
def test_lcmv():
"""Test LCMV with evoked data and single trials."""
raw, epochs, evoked, data_cov, noise_cov, label, forward,\
forward_surf_ori, forward_fixed, forward_vol = _get_data()
for fwd in [forward, forward_vol]:
filters = make_lcmv(evoked.info,
fwd,
data_cov,
reg=0.01,
noise_cov=noise_cov)
stc = apply_lcmv(evoked, filters, max_ori_out='signed')
stc.crop(0.02, None)
stc_pow = np.sum(np.abs(stc.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = stc.data[idx]
tmax = stc.times[np.argmax(max_stc)]
assert 0.09 < tmax < 0.12, tmax
assert 0.9 < np.max(max_stc) < 3., np.max(max_stc)
if fwd is forward:
# Test picking normal orientation (surface source space only)
filters = make_lcmv(evoked.info,
forward_surf_ori,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='normal')
stc_normal = apply_lcmv(evoked, filters, max_ori_out='signed')
stc_normal.crop(0.02, None)
stc_pow = np.sum(np.abs(stc_normal.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_normal.data[idx]
tmax = stc_normal.times[np.argmax(max_stc)]
assert 0.04 < tmax < 0.12, tmax
assert 0.4 < np.max(max_stc) < 2., np.max(max_stc)
# The amplitude of normal orientation results should always be
# smaller than free orientation results
assert (np.abs(stc_normal.data) <= stc.data).all()
# Test picking source orientation maximizing output source power
filters = make_lcmv(evoked.info,
fwd,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='max-power')
stc_max_power = apply_lcmv(evoked, filters, max_ori_out='signed')
stc_max_power.crop(0.02, None)
stc_pow = np.sum(np.abs(stc_max_power.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = np.abs(stc_max_power.data[idx])
tmax = stc.times[np.argmax(max_stc)]
assert 0.08 < tmax < 0.12, tmax
assert 0.8 < np.max(max_stc) < 3., np.max(max_stc)
stc_max_power.data[:, :] = np.abs(stc_max_power.data)
if fwd is forward:
# Maximum output source power orientation results should be
# similar to free orientation results in areas with channel
# coverage
label = mne.read_label(fname_label)
mean_stc = stc.extract_label_time_course(label,
fwd['src'],
mode='mean')
mean_stc_max_pow = \
stc_max_power.extract_label_time_course(label, fwd['src'],
mode='mean')
assert_array_less(np.abs(mean_stc - mean_stc_max_pow), 0.6)
# Test NAI weight normalization:
filters = make_lcmv(evoked.info,
fwd,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='max-power',
weight_norm='nai')
stc_nai = apply_lcmv(evoked, filters, max_ori_out='signed')
stc_nai.crop(0.02, None)
# Test whether unit-noise-gain solution is a scaled version of NAI
pearsoncorr = np.corrcoef(np.concatenate(np.abs(stc_nai.data)),
np.concatenate(stc_max_power.data))
assert_almost_equal(pearsoncorr[0, 1], 1.)
# Test sphere head model with unit-noise gain beamformer and orientation
# selection and rank reduction of the leadfield
sphere = mne.make_sphere_model(r0=(0., 0., 0.), head_radius=0.080)
src = mne.setup_volume_source_space(subject=None,
pos=15.,
mri=None,
sphere=(0.0, 0.0, 0.0, 80.0),
bem=None,
mindist=5.0,
exclude=2.0)
fwd_sphere = mne.make_forward_solution(evoked.info,
trans=None,
src=src,
bem=sphere,
eeg=False,
meg=True)
# Test that we get an error if not reducing rank
pytest.raises(ValueError,
make_lcmv,
evoked.info,
fwd_sphere,
data_cov,
reg=0.1,
noise_cov=noise_cov,
weight_norm='unit-noise-gain',
pick_ori='max-power',
reduce_rank=False)
# Now let's reduce it
filters = make_lcmv(evoked.info,
fwd_sphere,
data_cov,
reg=0.1,
noise_cov=noise_cov,
weight_norm='unit-noise-gain',
pick_ori='max-power',
reduce_rank=True)
stc_sphere = apply_lcmv(evoked, filters, max_ori_out='signed')
stc_sphere = np.abs(stc_sphere)
stc_sphere.crop(0.02, None)
stc_pow = np.sum(stc_sphere.data, axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_sphere.data[idx]
tmax = stc_sphere.times[np.argmax(max_stc)]
assert 0.08 < tmax < 0.15, tmax
assert 0.4 < np.max(max_stc) < 2., np.max(max_stc)
# Test if fixed forward operator is detected when picking normal or
# max-power orientation
pytest.raises(ValueError,
make_lcmv,
evoked.info,
forward_fixed,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='normal')
pytest.raises(ValueError,
make_lcmv,
evoked.info,
forward_fixed,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='max-power')
# Test if non-surface oriented forward operator is detected when picking
# normal orientation
pytest.raises(ValueError,
make_lcmv,
evoked.info,
forward,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='normal')
# Test if volume forward operator is detected when picking normal
# orientation
pytest.raises(ValueError,
make_lcmv,
evoked.info,
forward_vol,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='normal')
# Test if missing of noise covariance matrix is detected when more than
# one channel type is present in the data
pytest.raises(ValueError,
make_lcmv,
evoked.info,
forward_vol,
data_cov=data_cov,
reg=0.01,
noise_cov=None,
pick_ori='max-power')
# Test if not-yet-implemented orientation selections raise error with
# neural activity index
pytest.raises(NotImplementedError,
make_lcmv,
evoked.info,
forward_surf_ori,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='normal',
weight_norm='nai')
pytest.raises(NotImplementedError,
make_lcmv,
evoked.info,
forward_vol,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori=None,
weight_norm='nai')
# Test if no weight-normalization and max-power source orientation throws
# an error
pytest.raises(NotImplementedError,
make_lcmv,
evoked.info,
forward_vol,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='max-power',
weight_norm=None)
# Test if wrong channel selection is detected in application of filter
evoked_ch = deepcopy(evoked)
evoked_ch.pick_channels(evoked_ch.ch_names[1:])
filters = make_lcmv(evoked.info,
forward_vol,
data_cov,
reg=0.01,
noise_cov=noise_cov)
pytest.raises(ValueError,
apply_lcmv,
evoked_ch,
filters,
max_ori_out='signed')
# Test if discrepancies in channel selection of data and fwd model are
# handled correctly in apply_lcmv
# make filter with data where first channel was removed
filters = make_lcmv(evoked_ch.info,
forward_vol,
data_cov,
reg=0.01,
noise_cov=noise_cov)
# applying that filter to the full data set should automatically exclude
# this channel from the data
stc = apply_lcmv(evoked, filters, max_ori_out='signed')
# the result should be equal to applying this filter to a dataset without
# this channel:
stc_ch = apply_lcmv(evoked_ch, filters, max_ori_out='signed')
assert_array_almost_equal(stc.data, stc_ch.data)
# Test if non-matching SSP projection is detected in application of filter
raw_proj = deepcopy(raw)
raw_proj.del_proj()
pytest.raises(ValueError,
apply_lcmv_raw,
raw_proj,
filters,
max_ori_out='signed')
# Test if setting reduce_rank to True returns a NotImplementedError
# when no orientation selection is done or pick_ori='normal'
pytest.raises(NotImplementedError,
make_lcmv,
evoked.info,
forward_vol,
data_cov,
noise_cov=noise_cov,
pick_ori=None,
weight_norm='nai',
reduce_rank=True)
pytest.raises(NotImplementedError,
make_lcmv,
evoked.info,
forward_surf_ori,
data_cov,
noise_cov=noise_cov,
pick_ori='normal',
weight_norm='nai',
reduce_rank=True)
# Now test single trial using fixed orientation forward solution
# so we can compare it to the evoked solution
filters = make_lcmv(epochs.info,
forward_fixed,
data_cov,
reg=0.01,
noise_cov=noise_cov)
stcs = apply_lcmv_epochs(epochs, filters, max_ori_out='signed')
stcs_ = apply_lcmv_epochs(epochs,
filters,
return_generator=True,
max_ori_out='signed')
assert_array_equal(stcs[0].data, advance_iterator(stcs_).data)
epochs.drop_bad()
assert (len(epochs.events) == len(stcs))
# average the single trial estimates
stc_avg = np.zeros_like(stcs[0].data)
for this_stc in stcs:
stc_avg += this_stc.data
stc_avg /= len(stcs)
# compare it to the solution using evoked with fixed orientation
filters = make_lcmv(evoked.info,
forward_fixed,
data_cov,
reg=0.01,
noise_cov=noise_cov)
stc_fixed = apply_lcmv(evoked, filters, max_ori_out='signed')
assert_array_almost_equal(stc_avg, stc_fixed.data)
# use a label so we have few source vertices and delayed computation is
# not used
filters = make_lcmv(epochs.info,
forward_fixed,
data_cov,
reg=0.01,
noise_cov=noise_cov,
label=label)
stcs_label = apply_lcmv_epochs(epochs, filters, max_ori_out='signed')
assert_array_almost_equal(stcs_label[0].data, stcs[0].in_label(label).data)
def test_make_lcmv(tmpdir):
"""Test LCMV with evoked data and single trials."""
raw, epochs, evoked, data_cov, noise_cov, label, forward,\
forward_surf_ori, forward_fixed, forward_vol = _get_data()
for fwd in [forward, forward_vol]:
filters = make_lcmv(evoked.info,
fwd,
data_cov,
reg=0.01,
noise_cov=noise_cov)
stc = apply_lcmv(evoked, filters, max_ori_out='signed')
stc.crop(0.02, None)
stc_pow = np.sum(np.abs(stc.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = stc.data[idx]
tmax = stc.times[np.argmax(max_stc)]
assert 0.09 < tmax < 0.12, tmax
assert 0.9 < np.max(max_stc) < 3., np.max(max_stc)
if fwd is forward:
# Test picking normal orientation (surface source space only).
filters = make_lcmv(evoked.info,
forward_surf_ori,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='normal',
weight_norm=None)
stc_normal = apply_lcmv(evoked, filters, max_ori_out='signed')
stc_normal.crop(0.02, None)
stc_pow = np.sum(np.abs(stc_normal.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_normal.data[idx]
tmax = stc_normal.times[np.argmax(max_stc)]
assert 0.04 < tmax < 0.13, tmax
assert 3e-7 < np.max(max_stc) < 5e-7, np.max(max_stc)
# No weight normalization was applied, so the amplitude of normal
# orientation results should always be smaller than free
# orientation results.
assert (np.abs(stc_normal.data) <= stc.data).all()
# Test picking source orientation maximizing output source power
filters = make_lcmv(evoked.info,
fwd,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='max-power')
stc_max_power = apply_lcmv(evoked, filters, max_ori_out='signed')
stc_max_power.crop(0.02, None)
stc_pow = np.sum(np.abs(stc_max_power.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = np.abs(stc_max_power.data[idx])
tmax = stc.times[np.argmax(max_stc)]
assert 0.08 < tmax < 0.12, tmax
assert 0.8 < np.max(max_stc) < 3., np.max(max_stc)
stc_max_power.data[:, :] = np.abs(stc_max_power.data)
if fwd is forward:
# Maximum output source power orientation results should be
# similar to free orientation results in areas with channel
# coverage
label = mne.read_label(fname_label)
mean_stc = stc.extract_label_time_course(label,
fwd['src'],
mode='mean')
mean_stc_max_pow = \
stc_max_power.extract_label_time_course(label, fwd['src'],
mode='mean')
assert_array_less(np.abs(mean_stc - mean_stc_max_pow), 0.6)
# Test NAI weight normalization:
filters = make_lcmv(evoked.info,
fwd,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='max-power',
weight_norm='nai')
stc_nai = apply_lcmv(evoked, filters, max_ori_out='signed')
stc_nai.crop(0.02, None)
# Test whether unit-noise-gain solution is a scaled version of NAI
pearsoncorr = np.corrcoef(np.concatenate(np.abs(stc_nai.data)),
np.concatenate(stc_max_power.data))
assert_almost_equal(pearsoncorr[0, 1], 1.)
# Test sphere head model with unit-noise gain beamformer and orientation
# selection and rank reduction of the leadfield
sphere = mne.make_sphere_model(r0=(0., 0., 0.), head_radius=0.080)
src = mne.setup_volume_source_space(subject=None,
pos=15.,
mri=None,
sphere=(0.0, 0.0, 0.0, 80.0),
bem=None,
mindist=5.0,
exclude=2.0)
fwd_sphere = mne.make_forward_solution(evoked.info,
trans=None,
src=src,
bem=sphere,
eeg=False,
meg=True)
# Test that we get an error if not reducing rank
with pytest.raises(ValueError): # Singular matrix or complex spectrum
make_lcmv(evoked.info,
fwd_sphere,
data_cov,
reg=0.1,
noise_cov=noise_cov,
weight_norm='unit-noise-gain',
pick_ori='max-power',
reduce_rank=False,
rank='full')
# Now let's reduce it
filters = make_lcmv(evoked.info,
fwd_sphere,
data_cov,
reg=0.1,
noise_cov=noise_cov,
weight_norm='unit-noise-gain',
pick_ori='max-power',
reduce_rank=True)
stc_sphere = apply_lcmv(evoked, filters, max_ori_out='signed')
stc_sphere = np.abs(stc_sphere)
stc_sphere.crop(0.02, None)
stc_pow = np.sum(stc_sphere.data, axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_sphere.data[idx]
tmax = stc_sphere.times[np.argmax(max_stc)]
assert 0.08 < tmax < 0.15, tmax
assert 0.4 < np.max(max_stc) < 2., np.max(max_stc)
# Test if spatial filter contains src_type
assert 'src_type' in filters
# __repr__
assert 'LCMV' in repr(filters)
assert 'unknown subject' not in repr(filters)
assert '484' in repr(filters)
assert '20' in repr(filters)
assert 'rank 17' in repr(filters)
# I/O
fname = op.join(str(tmpdir), 'filters.h5')
with pytest.warns(RuntimeWarning, match='-lcmv.h5'):
filters.save(fname)
filters_read = read_beamformer(fname)
assert isinstance(filters, Beamformer)
assert isinstance(filters_read, Beamformer)
# deal with object_diff strictness
filters_read['rank'] = int(filters_read['rank'])
filters['rank'] = int(filters['rank'])
assert object_diff(filters, filters_read) == ''
# Test if fixed forward operator is detected when picking normal or
# max-power orientation
pytest.raises(ValueError,
make_lcmv,
evoked.info,
forward_fixed,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='normal')
pytest.raises(ValueError,
make_lcmv,
evoked.info,
forward_fixed,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='max-power')
# Test if non-surface oriented forward operator is detected when picking
# normal orientation
pytest.raises(ValueError,
make_lcmv,
evoked.info,
forward,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='normal')
# Test if volume forward operator is detected when picking normal
# orientation
pytest.raises(ValueError,
make_lcmv,
evoked.info,
forward_vol,
data_cov,
reg=0.01,
noise_cov=noise_cov,
pick_ori='normal')
# Test if missing of noise covariance matrix is detected when more than
# one channel type is present in the data
pytest.raises(ValueError,
make_lcmv,
evoked.info,
forward_vol,
data_cov=data_cov,
reg=0.01,
noise_cov=None,
pick_ori='max-power')
# Test if wrong channel selection is detected in application of filter
evoked_ch = deepcopy(evoked)
evoked_ch.pick_channels(evoked_ch.ch_names[1:])
filters = make_lcmv(evoked.info,
forward_vol,
data_cov,
reg=0.01,
noise_cov=noise_cov)
pytest.raises(ValueError,
apply_lcmv,
evoked_ch,
filters,
max_ori_out='signed')
# Test if discrepancies in channel selection of data and fwd model are
# handled correctly in apply_lcmv
# make filter with data where first channel was removed
filters = make_lcmv(evoked_ch.info,
forward_vol,
data_cov,
reg=0.01,
noise_cov=noise_cov)
# applying that filter to the full data set should automatically exclude
# this channel from the data
# also test here that no warnings are thrown - implemented to check whether
# src should not be None warning occurs
with pytest.warns(None) as w:
stc = apply_lcmv(evoked, filters, max_ori_out='signed')
assert len(w) == 0
# the result should be equal to applying this filter to a dataset without
# this channel:
stc_ch = apply_lcmv(evoked_ch, filters, max_ori_out='signed')
assert_array_almost_equal(stc.data, stc_ch.data)
# Test if non-matching SSP projection is detected in application of filter
raw_proj = deepcopy(raw)
raw_proj.del_proj()
pytest.raises(ValueError,
apply_lcmv_raw,
raw_proj,
filters,
max_ori_out='signed')
# Test if setting reduce_rank to True returns a NotImplementedError
# when no orientation selection is done or pick_ori='normal'
pytest.raises(NotImplementedError,
make_lcmv,
evoked.info,
forward_vol,
data_cov,
noise_cov=noise_cov,
pick_ori=None,
weight_norm='nai',
reduce_rank=True)
pytest.raises(NotImplementedError,
make_lcmv,
evoked.info,
forward_surf_ori,
data_cov,
noise_cov=noise_cov,
pick_ori='normal',
weight_norm='nai',
reduce_rank=True)
# Test if spatial filter contains src_type
assert 'src_type' in filters
# check whether a filters object without src_type throws expected warning
del filters['src_type'] # emulate 0.16 behaviour to cause warning
with pytest.warns(RuntimeWarning,
match='spatial filter does not contain '
'src_type'):
apply_lcmv(evoked, filters, max_ori_out='signed')
# Now test single trial using fixed orientation forward solution
# so we can compare it to the evoked solution
filters = make_lcmv(epochs.info,
forward_fixed,
data_cov,
reg=0.01,
noise_cov=noise_cov)
stcs = apply_lcmv_epochs(epochs, filters, max_ori_out='signed')
stcs_ = apply_lcmv_epochs(epochs,
filters,
return_generator=True,
max_ori_out='signed')
assert_array_equal(stcs[0].data, advance_iterator(stcs_).data)
epochs.drop_bad()
assert (len(epochs.events) == len(stcs))
# average the single trial estimates
stc_avg = np.zeros_like(stcs[0].data)
for this_stc in stcs:
stc_avg += this_stc.data
stc_avg /= len(stcs)
# compare it to the solution using evoked with fixed orientation
filters = make_lcmv(evoked.info,
forward_fixed,
data_cov,
reg=0.01,
noise_cov=noise_cov)
stc_fixed = apply_lcmv(evoked, filters, max_ori_out='signed')
assert_array_almost_equal(stc_avg, stc_fixed.data)
# use a label so we have few source vertices and delayed computation is
# not used
filters = make_lcmv(epochs.info,
forward_fixed,
data_cov,
reg=0.01,
noise_cov=noise_cov,
label=label)
stcs_label = apply_lcmv_epochs(epochs, filters, max_ori_out='signed')
assert_array_almost_equal(stcs_label[0].data, stcs[0].in_label(label).data)
# Test condition where the filters weights are zero. There should not be
# any divide-by-zero errors
zero_cov = data_cov.copy()
zero_cov['data'][:] = 0
filters = make_lcmv(epochs.info,
forward_fixed,
zero_cov,
reg=0.01,
noise_cov=noise_cov)
assert_array_equal(filters['weights'], 0)
def test_lcmv():
"""Test LCMV with evoked data and single trials."""
raw, epochs, evoked, data_cov, noise_cov, label, forward,\
forward_surf_ori, forward_fixed, forward_vol = _get_data()
for fwd in [forward, forward_vol]:
stc = lcmv(evoked,
fwd,
noise_cov,
data_cov,
reg=0.01,
max_ori_out='signed')
stc.crop(0.02, None)
stc_pow = np.sum(np.abs(stc.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = stc.data[idx]
tmax = stc.times[np.argmax(max_stc)]
assert_true(0.09 < tmax < 0.105, tmax)
assert_true(0.9 < np.max(max_stc) < 3., np.max(max_stc))
if fwd is forward:
# Test picking normal orientation (surface source space only)
stc_normal = lcmv(evoked,
forward_surf_ori,
noise_cov,
data_cov,
reg=0.01,
pick_ori="normal")
stc_normal.crop(0.02, None)
stc_pow = np.sum(np.abs(stc_normal.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_normal.data[idx]
tmax = stc_normal.times[np.argmax(max_stc)]
assert_true(0.04 < tmax < 0.11, tmax)
assert_true(0.4 < np.max(max_stc) < 2., np.max(max_stc))
# The amplitude of normal orientation results should always be
# smaller than free orientation results
assert_true((np.abs(stc_normal.data) <= stc.data).all())
# Test picking source orientation maximizing output source power
stc_max_power = lcmv(evoked,
fwd,
noise_cov,
data_cov,
reg=0.01,
pick_ori="max-power",
max_ori_out='signed')
stc_max_power.crop(0.02, None)
stc_pow = np.sum(np.abs(stc_max_power.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = np.abs(stc_max_power.data[idx])
tmax = stc.times[np.argmax(max_stc)]
assert_true(0.08 < tmax < 0.11, tmax)
assert_true(0.8 < np.max(max_stc) < 3., np.max(max_stc))
stc_max_power.data[:, :] = np.abs(stc_max_power.data)
if fwd is forward:
# Maximum output source power orientation results should be
# similar to free orientation results in areas with channel
# coverage
label = mne.read_label(fname_label)
mean_stc = stc.extract_label_time_course(label,
fwd['src'],
mode='mean')
mean_stc_max_pow = \
stc_max_power.extract_label_time_course(label, fwd['src'],
mode='mean')
assert_true((np.abs(mean_stc - mean_stc_max_pow) < 0.5).all())
# Test NAI weight normalization:
stc_nai = lcmv(evoked,
fwd,
noise_cov=noise_cov,
data_cov=data_cov,
reg=0.01,
pick_ori='max-power',
weight_norm='nai',
max_ori_out='signed')
stc_nai.crop(0.02, None)
# Test whether unit-noise-gain solution is a scaled version of NAI
pearsoncorr = np.corrcoef(np.concatenate(np.abs(stc_nai.data)),
np.concatenate(stc_max_power.data))
assert_almost_equal(pearsoncorr[0, 1], 1.)
# Test if fixed forward operator is detected when picking normal or
# max-power orientation
assert_raises(ValueError,
lcmv,
evoked,
forward_fixed,
noise_cov,
data_cov,
reg=0.01,
pick_ori="normal")
assert_raises(ValueError,
lcmv,
evoked,
forward_fixed,
noise_cov,
data_cov,
reg=0.01,
pick_ori="max-power",
max_ori_out='signed')
# Test if non-surface oriented forward operator is detected when picking
# normal orientation
assert_raises(ValueError,
lcmv,
evoked,
forward,
noise_cov,
data_cov,
reg=0.01,
pick_ori="normal")
# Test if volume forward operator is detected when picking normal
# orientation
assert_raises(ValueError,
lcmv,
evoked,
forward_vol,
noise_cov,
data_cov,
reg=0.01,
pick_ori="normal")
# Test if missing of data covariance matrix is detected
assert_raises(ValueError,
lcmv,
evoked,
forward_vol,
noise_cov=noise_cov,
data_cov=None,
reg=0.01,
pick_ori="max-power",
max_ori_out='signed')
# Test if missing of noise covariance matrix is detected when more than
# one channel type is present in the data
assert_raises(ValueError,
lcmv,
evoked,
forward_vol,
noise_cov=None,
data_cov=data_cov,
reg=0.01,
pick_ori="max-power",
max_ori_out='signed')
# Test if not-yet-implemented orientation selections raise error with
# neural activity index
assert_raises(NotImplementedError,
lcmv,
evoked,
forward_surf_ori,
noise_cov,
data_cov,
reg=0.01,
pick_ori="normal",
weight_norm='nai')
assert_raises(NotImplementedError,
lcmv,
evoked,
forward_vol,
noise_cov,
data_cov,
reg=0.01,
pick_ori=None,
weight_norm='nai')
# Test if no weight-normalization and max-power source orientation throw
# an error
assert_raises(NotImplementedError,
lcmv,
evoked,
forward_vol,
noise_cov,
data_cov,
reg=0.01,
pick_ori="max-power",
weight_norm=None,
max_ori_out='signed')
# Test if wrong channel selection is detected in application of filter
evoked_ch = deepcopy(evoked)
evoked_ch.pick_channels(evoked_ch.ch_names[:-1])
filters = make_lcmv(evoked.info,
forward_vol,
data_cov,
reg=0.01,
noise_cov=noise_cov)
assert_raises(ValueError,
apply_lcmv,
evoked_ch,
filters,
max_ori_out='signed')
# Test if non-matching SSP projection is detected in application of filter
raw_proj = deepcopy(raw)
raw_proj.del_proj()
assert_raises(ValueError,
apply_lcmv_raw,
raw_proj,
filters,
max_ori_out='signed')
# Now test single trial using fixed orientation forward solution
# so we can compare it to the evoked solution
stcs = lcmv_epochs(epochs, forward_fixed, noise_cov, data_cov, reg=0.01)
stcs_ = lcmv_epochs(epochs,
forward_fixed,
noise_cov,
data_cov,
reg=0.01,
return_generator=True)
assert_array_equal(stcs[0].data, advance_iterator(stcs_).data)
epochs.drop_bad()
assert_true(len(epochs.events) == len(stcs))
# average the single trial estimates
stc_avg = np.zeros_like(stcs[0].data)
for this_stc in stcs:
stc_avg += this_stc.data
stc_avg /= len(stcs)
# compare it to the solution using evoked with fixed orientation
stc_fixed = lcmv(evoked, forward_fixed, noise_cov, data_cov, reg=0.01)
assert_array_almost_equal(stc_avg, stc_fixed.data)
# use a label so we have few source vertices and delayed computation is
# not used
stcs_label = lcmv_epochs(epochs,
forward_fixed,
noise_cov,
data_cov,
reg=0.01,
label=label)
assert_array_almost_equal(stcs_label[0].data, stcs[0].in_label(label).data)
def test_lcmv():
"""Test LCMV with evoked data and single trials."""
raw, epochs, evoked, data_cov, noise_cov, label, forward,\
forward_surf_ori, forward_fixed, forward_vol = _get_data()
for fwd in [forward, forward_vol]:
filters = make_lcmv(evoked.info, fwd, data_cov, reg=0.01,
noise_cov=noise_cov)
stc = apply_lcmv(evoked, filters, max_ori_out='signed')
stc.crop(0.02, None)
stc_pow = np.sum(np.abs(stc.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = stc.data[idx]
tmax = stc.times[np.argmax(max_stc)]
assert 0.09 < tmax < 0.12, tmax
assert 0.9 < np.max(max_stc) < 3., np.max(max_stc)
if fwd is forward:
# Test picking normal orientation (surface source space only)
filters = make_lcmv(evoked.info, forward_surf_ori, data_cov,
reg=0.01, noise_cov=noise_cov,
pick_ori='normal')
stc_normal = apply_lcmv(evoked, filters, max_ori_out='signed')
stc_normal.crop(0.02, None)
stc_pow = np.sum(np.abs(stc_normal.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_normal.data[idx]
tmax = stc_normal.times[np.argmax(max_stc)]
assert 0.04 < tmax < 0.12, tmax
assert 0.4 < np.max(max_stc) < 2., np.max(max_stc)
# The amplitude of normal orientation results should always be
# smaller than free orientation results
assert (np.abs(stc_normal.data) <= stc.data).all()
# Test picking source orientation maximizing output source power
filters = make_lcmv(evoked.info, fwd, data_cov, reg=0.01,
noise_cov=noise_cov, pick_ori='max-power')
stc_max_power = apply_lcmv(evoked, filters, max_ori_out='signed')
stc_max_power.crop(0.02, None)
stc_pow = np.sum(np.abs(stc_max_power.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = np.abs(stc_max_power.data[idx])
tmax = stc.times[np.argmax(max_stc)]
assert 0.08 < tmax < 0.12, tmax
assert 0.8 < np.max(max_stc) < 3., np.max(max_stc)
stc_max_power.data[:, :] = np.abs(stc_max_power.data)
if fwd is forward:
# Maximum output source power orientation results should be
# similar to free orientation results in areas with channel
# coverage
label = mne.read_label(fname_label)
mean_stc = stc.extract_label_time_course(label, fwd['src'],
mode='mean')
mean_stc_max_pow = \
stc_max_power.extract_label_time_course(label, fwd['src'],
mode='mean')
assert_array_less(np.abs(mean_stc - mean_stc_max_pow), 0.6)
# Test NAI weight normalization:
filters = make_lcmv(evoked.info, fwd, data_cov, reg=0.01,
noise_cov=noise_cov, pick_ori='max-power',
weight_norm='nai')
stc_nai = apply_lcmv(evoked, filters, max_ori_out='signed')
stc_nai.crop(0.02, None)
# Test whether unit-noise-gain solution is a scaled version of NAI
pearsoncorr = np.corrcoef(np.concatenate(np.abs(stc_nai.data)),
np.concatenate(stc_max_power.data))
assert_almost_equal(pearsoncorr[0, 1], 1.)
# Test sphere head model with unit-noise gain beamformer and orientation
# selection and rank reduction of the leadfield
sphere = mne.make_sphere_model(r0=(0., 0., 0.), head_radius=0.080)
src = mne.setup_volume_source_space(subject=None, pos=15., mri=None,
sphere=(0.0, 0.0, 0.0, 80.0),
bem=None, mindist=5.0, exclude=2.0)
fwd_sphere = mne.make_forward_solution(evoked.info, trans=None, src=src,
bem=sphere, eeg=False, meg=True)
# Test that we get an error if not reducing rank
pytest.raises(ValueError, make_lcmv, evoked.info, fwd_sphere, data_cov,
reg=0.1, noise_cov=noise_cov, weight_norm='unit-noise-gain',
pick_ori='max-power', reduce_rank=False)
# Now let's reduce it
filters = make_lcmv(evoked.info, fwd_sphere, data_cov, reg=0.1,
noise_cov=noise_cov, weight_norm='unit-noise-gain',
pick_ori='max-power', reduce_rank=True)
stc_sphere = apply_lcmv(evoked, filters, max_ori_out='signed')
stc_sphere = np.abs(stc_sphere)
stc_sphere.crop(0.02, None)
stc_pow = np.sum(stc_sphere.data, axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_sphere.data[idx]
tmax = stc_sphere.times[np.argmax(max_stc)]
assert 0.08 < tmax < 0.15, tmax
assert 0.4 < np.max(max_stc) < 2., np.max(max_stc)
# Test if spatial filter contains src_type
assert 'src_type' in filters
# Test if fixed forward operator is detected when picking normal or
# max-power orientation
pytest.raises(ValueError, make_lcmv, evoked.info, forward_fixed, data_cov,
reg=0.01, noise_cov=noise_cov, pick_ori='normal')
pytest.raises(ValueError, make_lcmv, evoked.info, forward_fixed, data_cov,
reg=0.01, noise_cov=noise_cov, pick_ori='max-power')
# Test if non-surface oriented forward operator is detected when picking
# normal orientation
pytest.raises(ValueError, make_lcmv, evoked.info, forward, data_cov,
reg=0.01, noise_cov=noise_cov, pick_ori='normal')
# Test if volume forward operator is detected when picking normal
# orientation
pytest.raises(ValueError, make_lcmv, evoked.info, forward_vol, data_cov,
reg=0.01, noise_cov=noise_cov, pick_ori='normal')
# Test if missing of noise covariance matrix is detected when more than
# one channel type is present in the data
pytest.raises(ValueError, make_lcmv, evoked.info, forward_vol,
data_cov=data_cov, reg=0.01, noise_cov=None,
pick_ori='max-power')
# Test if not-yet-implemented orientation selections raise error with
# neural activity index
pytest.raises(NotImplementedError, make_lcmv, evoked.info,
forward_surf_ori, data_cov, reg=0.01, noise_cov=noise_cov,
pick_ori='normal', weight_norm='nai')
pytest.raises(NotImplementedError, make_lcmv, evoked.info, forward_vol,
data_cov, reg=0.01, noise_cov=noise_cov, pick_ori=None,
weight_norm='nai')
# Test if no weight-normalization and max-power source orientation throws
# an error
pytest.raises(NotImplementedError, make_lcmv, evoked.info, forward_vol,
data_cov, reg=0.01, noise_cov=noise_cov,
pick_ori='max-power', weight_norm=None)
# Test if wrong channel selection is detected in application of filter
evoked_ch = deepcopy(evoked)
evoked_ch.pick_channels(evoked_ch.ch_names[1:])
filters = make_lcmv(evoked.info, forward_vol, data_cov, reg=0.01,
noise_cov=noise_cov)
pytest.raises(ValueError, apply_lcmv, evoked_ch, filters,
max_ori_out='signed')
# Test if discrepancies in channel selection of data and fwd model are
# handled correctly in apply_lcmv
# make filter with data where first channel was removed
filters = make_lcmv(evoked_ch.info, forward_vol, data_cov, reg=0.01,
noise_cov=noise_cov)
# applying that filter to the full data set should automatically exclude
# this channel from the data
# also test here that no warnings are thrown - implemented to check whether
# src should not be None warning occurs
with pytest.warns(None) as w:
stc = apply_lcmv(evoked, filters, max_ori_out='signed')
assert len(w) == 0
# the result should be equal to applying this filter to a dataset without
# this channel:
stc_ch = apply_lcmv(evoked_ch, filters, max_ori_out='signed')
assert_array_almost_equal(stc.data, stc_ch.data)
# Test if non-matching SSP projection is detected in application of filter
raw_proj = deepcopy(raw)
raw_proj.del_proj()
pytest.raises(ValueError, apply_lcmv_raw, raw_proj, filters,
max_ori_out='signed')
# Test if setting reduce_rank to True returns a NotImplementedError
# when no orientation selection is done or pick_ori='normal'
pytest.raises(NotImplementedError, make_lcmv, evoked.info, forward_vol,
data_cov, noise_cov=noise_cov, pick_ori=None,
weight_norm='nai', reduce_rank=True)
pytest.raises(NotImplementedError, make_lcmv, evoked.info,
forward_surf_ori, data_cov, noise_cov=noise_cov,
pick_ori='normal', weight_norm='nai', reduce_rank=True)
# Test if spatial filter contains src_type
assert 'src_type' in filters
# check whether a filters object without src_type throws expected warning
del filters['src_type'] # emulate 0.16 behaviour to cause warning
with pytest.warns(RuntimeWarning, match='spatial filter does not contain '
'src_type'):
apply_lcmv(evoked, filters, max_ori_out='signed')
# Now test single trial using fixed orientation forward solution
# so we can compare it to the evoked solution
filters = make_lcmv(epochs.info, forward_fixed, data_cov, reg=0.01,
noise_cov=noise_cov)
stcs = apply_lcmv_epochs(epochs, filters, max_ori_out='signed')
stcs_ = apply_lcmv_epochs(epochs, filters, return_generator=True,
max_ori_out='signed')
assert_array_equal(stcs[0].data, advance_iterator(stcs_).data)
epochs.drop_bad()
assert (len(epochs.events) == len(stcs))
# average the single trial estimates
stc_avg = np.zeros_like(stcs[0].data)
for this_stc in stcs:
stc_avg += this_stc.data
stc_avg /= len(stcs)
# compare it to the solution using evoked with fixed orientation
filters = make_lcmv(evoked.info, forward_fixed, data_cov, reg=0.01,
noise_cov=noise_cov)
stc_fixed = apply_lcmv(evoked, filters, max_ori_out='signed')
assert_array_almost_equal(stc_avg, stc_fixed.data)
# use a label so we have few source vertices and delayed computation is
# not used
filters = make_lcmv(epochs.info, forward_fixed, data_cov, reg=0.01,
noise_cov=noise_cov, label=label)
stcs_label = apply_lcmv_epochs(epochs, filters, max_ori_out='signed')
assert_array_almost_equal(stcs_label[0].data, stcs[0].in_label(label).data)
def test_dics():
"""Test DICS with evoked data and single trials."""
raw, epochs, evoked, data_csd, noise_csd, label, forward,\
forward_surf_ori, forward_fixed, forward_vol = _get_data()
epochs.crop(0, None)
reg = 0.5 # Heavily regularize due to low SNR
for real_filter in (True, False):
stc = dics(evoked, forward, noise_csd=noise_csd, data_csd=data_csd,
label=label, real_filter=real_filter, reg=reg)
stc_pow = np.sum(stc.data, axis=1)
idx = np.argmax(stc_pow)
max_stc = stc.data[idx]
tmax = stc.times[np.argmax(max_stc)]
# Incorrect due to limited number of epochs
assert 0.04 < tmax < 0.06
assert 3. < np.max(max_stc) < 6.
# Test picking normal orientation
stc_normal = dics(evoked, forward_surf_ori, noise_csd, data_csd,
pick_ori="normal", label=label, real_filter=True,
reg=reg)
assert stc_normal.data.min() < 0 # this doesn't take abs
stc_normal = dics(evoked, forward_surf_ori, noise_csd, data_csd,
pick_ori="normal", label=label, reg=reg)
assert stc_normal.data.min() >= 0 # this does take abs
# The amplitude of normal orientation results should always be smaller than
# free orientation results
assert (np.abs(stc_normal.data) <= stc.data).all()
# Test if fixed forward operator is detected when picking normal
# orientation
raises(ValueError, dics_epochs, epochs, forward_fixed, noise_csd, data_csd,
pick_ori="normal")
# Test if non-surface oriented forward operator is detected when picking
# normal orientation
raises(ValueError, dics_epochs, epochs, forward, noise_csd, data_csd,
pick_ori="normal")
# Test if volume forward operator is detected when picking normal
# orientation
raises(ValueError, dics_epochs, epochs, forward_vol, noise_csd, data_csd,
pick_ori="normal")
# Now test single trial using fixed orientation forward solution
# so we can compare it to the evoked solution
stcs = dics_epochs(epochs, forward_fixed, noise_csd, data_csd, label=label)
# Testing returning of generator
stcs_ = dics_epochs(epochs, forward_fixed, noise_csd, data_csd,
return_generator=True, label=label)
assert_array_equal(stcs[0].data, advance_iterator(stcs_).data)
# Test whether correct number of trials was returned
epochs.drop_bad()
assert len(epochs.events) == len(stcs)
# Average the single trial estimates
stc_avg = np.zeros_like(stc.data)
for this_stc in stcs:
stc_avg += this_stc.data
stc_avg /= len(stcs)
idx = np.argmax(np.max(stc_avg, axis=1))
max_stc = stc_avg[idx]
tmax = stc.times[np.argmax(max_stc)]
assert 0.120 < tmax < 0.150 # incorrect due to limited #
assert 12 < np.max(max_stc) < 18.5
def test_apply_dics_timeseries():
"""Test DICS applied to timeseries data."""
fwd_free, fwd_surf, fwd_fixed, fwd_vol, label = _load_forward()
epochs, evoked, csd, source_vertno = _simulate_data(fwd_fixed)
vertices = np.intersect1d(label.vertices, fwd_free['src'][0]['vertno'])
source_ind = vertices.tolist().index(source_vertno)
reg = 5 # Lots of regularization for our toy dataset
multiple_filters = make_dics(evoked.info, fwd_surf, csd, label=label,
reg=reg)
# Sanity checks on the resulting STC after applying DICS on evoked
stcs = apply_dics(evoked, multiple_filters)
assert isinstance(stcs, list)
assert len(stcs) == len(multiple_filters['weights'])
assert_array_equal(stcs[0].vertices[0], multiple_filters['vertices'][0])
assert_array_equal(stcs[0].vertices[1], multiple_filters['vertices'][1])
assert_allclose(stcs[0].times, evoked.times)
# Applying filters for multiple frequencies on epoch data should fail
raises(ValueError, apply_dics_epochs, epochs, multiple_filters)
# From now on, only apply filters with a single frequency (20 Hz).
csd20 = csd.pick_frequency(20)
filters = make_dics(evoked.info, fwd_surf, csd20, label=label, reg=reg)
# Sanity checks on the resulting STC after applying DICS on epochs.
stcs = apply_dics_epochs(epochs, filters)
assert isinstance(stcs, list)
assert len(stcs) == 1
assert_array_equal(stcs[0].vertices[0], filters['vertices'][0])
assert_array_equal(stcs[0].vertices[1], filters['vertices'][1])
assert_allclose(stcs[0].times, epochs.times)
# Did we find the source?
stc = (stcs[0] ** 2).mean()
assert np.argmax(stc.data) == source_ind
# Apply filters to evoked
stc = apply_dics(evoked, filters)
stc = (stc ** 2).mean()
assert np.argmax(stc.data) == source_ind
# Test if wrong channel selection is detected in application of filter
evoked_ch = cp.deepcopy(evoked)
evoked_ch.pick_channels(evoked_ch.ch_names[:-1])
raises(ValueError, apply_dics, evoked_ch, filters)
# Test whether projections are applied, by adding a custom projection
filters_noproj = make_dics(evoked.info, fwd_surf, csd20, label=label)
stc_noproj = apply_dics(evoked, filters_noproj)
evoked_proj = evoked.copy()
p = compute_proj_evoked(evoked_proj, n_grad=1, n_mag=0, n_eeg=0)
proj_matrix = make_projector(p, evoked_proj.ch_names)[0]
evoked_proj.info['projs'] += p
filters_proj = make_dics(evoked_proj.info, fwd_surf, csd20, label=label)
assert_array_equal(filters_proj['proj'], proj_matrix)
stc_proj = apply_dics(evoked_proj, filters_proj)
assert np.any(np.not_equal(stc_noproj.data, stc_proj.data))
# Test detecting incompatible projections
filters_proj['proj'] = filters_proj['proj'][:-1, :-1]
raises(ValueError, apply_dics, evoked_proj, filters_proj)
# Test returning a generator
stcs = apply_dics_epochs(epochs, filters, return_generator=False)
stcs_gen = apply_dics_epochs(epochs, filters, return_generator=True)
assert_array_equal(stcs[0].data, advance_iterator(stcs_gen).data)
# Test computing timecourses on a volume source space
filters_vol = make_dics(evoked.info, fwd_vol, csd20, reg=reg)
stc = apply_dics(evoked, filters_vol)
stc = (stc ** 2).mean()
assert np.argmax(stc.data) == 3851 # TODO: don't make this hard coded
def test_lcmv():
"""Test LCMV with evoked data and single trials."""
raw, epochs, evoked, data_cov, noise_cov, label, forward,\
forward_surf_ori, forward_fixed, forward_vol = _get_data()
for fwd in [forward, forward_vol]:
stc = lcmv(evoked, fwd, noise_cov, data_cov, reg=0.01,
max_ori_out='signed')
stc.crop(0.02, None)
stc_pow = np.sum(np.abs(stc.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = stc.data[idx]
tmax = stc.times[np.argmax(max_stc)]
assert_true(0.09 < tmax < 0.105, tmax)
assert_true(0.9 < np.max(max_stc) < 3., np.max(max_stc))
if fwd is forward:
# Test picking normal orientation (surface source space only)
stc_normal = lcmv(evoked, forward_surf_ori, noise_cov,
data_cov, reg=0.01, pick_ori="normal",
max_ori_out='signed')
stc_normal.crop(0.02, None)
stc_pow = np.sum(np.abs(stc_normal.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_normal.data[idx]
tmax = stc_normal.times[np.argmax(max_stc)]
assert_true(0.04 < tmax < 0.11, tmax)
assert_true(0.4 < np.max(max_stc) < 2., np.max(max_stc))
# The amplitude of normal orientation results should always be
# smaller than free orientation results
assert_true((np.abs(stc_normal.data) <= stc.data).all())
# Test picking source orientation maximizing output source power
stc_max_power = lcmv(evoked, fwd, noise_cov, data_cov, reg=0.01,
pick_ori="max-power", max_ori_out='signed')
stc_max_power.crop(0.02, None)
stc_pow = np.sum(np.abs(stc_max_power.data), axis=1)
idx = np.argmax(stc_pow)
max_stc = np.abs(stc_max_power.data[idx])
tmax = stc.times[np.argmax(max_stc)]
assert_true(0.08 < tmax < 0.11, tmax)
assert_true(0.8 < np.max(max_stc) < 3., np.max(max_stc))
stc_max_power.data[:, :] = np.abs(stc_max_power.data)
if fwd is forward:
# Maximum output source power orientation results should be
# similar to free orientation results in areas with channel
# coverage
label = mne.read_label(fname_label)
mean_stc = stc.extract_label_time_course(label, fwd['src'],
mode='mean')
mean_stc_max_pow = \
stc_max_power.extract_label_time_course(label, fwd['src'],
mode='mean')
assert_true((np.abs(mean_stc - mean_stc_max_pow) < 0.5).all())
# Test NAI weight normalization:
stc_nai = lcmv(evoked, fwd, noise_cov=noise_cov, data_cov=data_cov,
reg=0.01, pick_ori='max-power', weight_norm='nai',
max_ori_out='signed')
stc_nai.crop(0.02, None)
# Test whether unit-noise-gain solution is a scaled version of NAI
pearsoncorr = np.corrcoef(np.concatenate(np.abs(stc_nai.data)),
np.concatenate(stc_max_power.data))
assert_almost_equal(pearsoncorr[0, 1], 1.)
# Test sphere head model with unit-noise gain beamformer and orientation
# selection and rank reduction of the leadfield
sphere = mne.make_sphere_model(r0=(0., 0., 0.), head_radius=0.080)
src = mne.setup_volume_source_space(subject=None, pos=15., mri=None,
sphere=(0.0, 0.0, 0.0, 80.0),
bem=None, mindist=5.0, exclude=2.0)
fwd_sphere = mne.make_forward_solution(evoked.info, trans=None, src=src,
bem=sphere, eeg=False, meg=True)
# Test that we get an error is not reducing rank
assert_raises(ValueError, lcmv, evoked, fwd_sphere, noise_cov, data_cov,
reg=0.1, weight_norm='unit-noise-gain', pick_ori="max-power",
reduce_rank=False)
# Now let's reduce it
stc_sphere = lcmv(evoked, fwd_sphere, noise_cov, data_cov, reg=0.1,
weight_norm='unit-noise-gain', pick_ori="max-power",
reduce_rank=True, max_ori_out='signed')
stc_sphere = np.abs(stc_sphere)
stc_sphere.crop(0.02, None)
stc_pow = np.sum(stc_sphere.data, axis=1)
idx = np.argmax(stc_pow)
max_stc = stc_sphere.data[idx]
tmax = stc_sphere.times[np.argmax(max_stc)]
assert_true(0.08 < tmax < 0.11, tmax)
assert_true(0.4 < np.max(max_stc) < 2., np.max(max_stc))
# Test if fixed forward operator is detected when picking normal or
# max-power orientation
assert_raises(ValueError, lcmv, evoked, forward_fixed, noise_cov, data_cov,
reg=0.01, pick_ori="normal")
assert_raises(ValueError, lcmv, evoked, forward_fixed, noise_cov, data_cov,
reg=0.01, pick_ori="max-power", max_ori_out='signed')
# Test if non-surface oriented forward operator is detected when picking
# normal orientation
assert_raises(ValueError, lcmv, evoked, forward, noise_cov, data_cov,
reg=0.01, pick_ori="normal")
# Test if volume forward operator is detected when picking normal
# orientation
assert_raises(ValueError, lcmv, evoked, forward_vol, noise_cov, data_cov,
reg=0.01, pick_ori="normal")
# Test if missing of data covariance matrix is detected
assert_raises(ValueError, lcmv, evoked, forward_vol, noise_cov=noise_cov,
data_cov=None, reg=0.01, pick_ori="max-power",
max_ori_out='signed')
# Test if missing of noise covariance matrix is detected when more than
# one channel type is present in the data
assert_raises(ValueError, lcmv, evoked, forward_vol, noise_cov=None,
data_cov=data_cov, reg=0.01, pick_ori="max-power",
max_ori_out='signed')
# Test if not-yet-implemented orientation selections raise error with
# neural activity index
assert_raises(NotImplementedError, lcmv, evoked, forward_surf_ori,
noise_cov, data_cov, reg=0.01, pick_ori="normal",
weight_norm='nai')
assert_raises(NotImplementedError, lcmv, evoked, forward_vol, noise_cov,
data_cov, reg=0.01, pick_ori=None, weight_norm='nai')
# Test if no weight-normalization and max-power source orientation throw
# an error
assert_raises(NotImplementedError, lcmv, evoked, forward_vol, noise_cov,
data_cov, reg=0.01, pick_ori="max-power", weight_norm=None,
max_ori_out='signed')
# Test if wrong channel selection is detected in application of filter
evoked_ch = deepcopy(evoked)
evoked_ch.pick_channels(evoked_ch.ch_names[:-1])
filters = make_lcmv(evoked.info, forward_vol, data_cov, reg=0.01,
noise_cov=noise_cov)
assert_raises(ValueError, apply_lcmv, evoked_ch, filters,
max_ori_out='signed')
# Test if non-matching SSP projection is detected in application of filter
raw_proj = deepcopy(raw)
raw_proj.del_proj()
assert_raises(ValueError, apply_lcmv_raw, raw_proj, filters,
max_ori_out='signed')
# Test if setting reduce_rank to True returns a NotImplementedError
# when no orientation selection is done or pick_ori='normal'
assert_raises(NotImplementedError, lcmv, evoked, forward_vol, noise_cov,
data_cov, pick_ori=None, weight_norm='nai', reduce_rank=True,
max_ori_out='signed')
assert_raises(NotImplementedError, lcmv, evoked, forward_surf_ori,
noise_cov, data_cov, pick_ori='normal', weight_norm='nai',
reduce_rank=True, max_ori_out='signed')
# Now test single trial using fixed orientation forward solution
# so we can compare it to the evoked solution
stcs = lcmv_epochs(epochs, forward_fixed, noise_cov, data_cov,
reg=0.01, max_ori_out='signed')
stcs_ = lcmv_epochs(epochs, forward_fixed, noise_cov, data_cov,
reg=0.01, return_generator=True,
max_ori_out='signed')
assert_array_equal(stcs[0].data, advance_iterator(stcs_).data)
epochs.drop_bad()
assert_true(len(epochs.events) == len(stcs))
# average the single trial estimates
stc_avg = np.zeros_like(stcs[0].data)
for this_stc in stcs:
stc_avg += this_stc.data
stc_avg /= len(stcs)
# compare it to the solution using evoked with fixed orientation
stc_fixed = lcmv(evoked, forward_fixed, noise_cov, data_cov, reg=0.01,
max_ori_out='signed')
assert_array_almost_equal(stc_avg, stc_fixed.data)
# use a label so we have few source vertices and delayed computation is
# not used
stcs_label = lcmv_epochs(epochs, forward_fixed, noise_cov, data_cov,
reg=0.01, label=label, max_ori_out='signed')
assert_array_almost_equal(stcs_label[0].data, stcs[0].in_label(label).data)
def test_dics():
"""Test DICS with evoked data and single trials."""
raw, epochs, evoked, data_csd, noise_csd, label, forward,\
forward_surf_ori, forward_fixed, forward_vol = _get_data()
epochs.crop(0, None)
reg = 0.5 # Heavily regularize due to low SNR
for real_filter in (True, False):
stc = dics(evoked,
forward,
noise_csd=noise_csd,
data_csd=data_csd,
label=label,
real_filter=real_filter,
reg=reg)
stc_pow = np.sum(stc.data, axis=1)
idx = np.argmax(stc_pow)
max_stc = stc.data[idx]
tmax = stc.times[np.argmax(max_stc)]
# Incorrect due to limited number of epochs
assert 0.04 < tmax < 0.06
assert 3. < np.max(max_stc) < 6.
# Test picking normal orientation
stc_normal = dics(evoked,
forward_surf_ori,
noise_csd,
data_csd,
pick_ori="normal",
label=label,
real_filter=True,
reg=reg)
assert stc_normal.data.min() < 0 # this doesn't take abs
stc_normal = dics(evoked,
forward_surf_ori,
noise_csd,
data_csd,
pick_ori="normal",
label=label,
reg=reg)
assert stc_normal.data.min() >= 0 # this does take abs
# The amplitude of normal orientation results should always be smaller than
# free orientation results
assert (np.abs(stc_normal.data) <= stc.data).all()
# Test if fixed forward operator is detected when picking normal
# orientation
raises(ValueError,
dics_epochs,
epochs,
forward_fixed,
noise_csd,
data_csd,
pick_ori="normal")
# Test if non-surface oriented forward operator is detected when picking
# normal orientation
raises(ValueError,
dics_epochs,
epochs,
forward,
noise_csd,
data_csd,
pick_ori="normal")
# Test if volume forward operator is detected when picking normal
# orientation
raises(ValueError,
dics_epochs,
epochs,
forward_vol,
noise_csd,
data_csd,
pick_ori="normal")
# Now test single trial using fixed orientation forward solution
# so we can compare it to the evoked solution
stcs = dics_epochs(epochs, forward_fixed, noise_csd, data_csd, label=label)
# Testing returning of generator
stcs_ = dics_epochs(epochs,
forward_fixed,
noise_csd,
data_csd,
return_generator=True,
label=label)
assert_array_equal(stcs[0].data, advance_iterator(stcs_).data)
# Test whether correct number of trials was returned
epochs.drop_bad()
assert len(epochs.events) == len(stcs)
# Average the single trial estimates
stc_avg = np.zeros_like(stc.data)
for this_stc in stcs:
stc_avg += this_stc.data
stc_avg /= len(stcs)
idx = np.argmax(np.max(stc_avg, axis=1))
max_stc = stc_avg[idx]
tmax = stc.times[np.argmax(max_stc)]
assert 0.120 < tmax < 0.150 # incorrect due to limited #
assert 12 < np.max(max_stc) < 18.5
