def test_resolution_matrix():
"""Test make_resolution_matrix() function."""
# read forward solution
forward = mne.read_forward_solution(fname_fwd)
# forward operator with fixed source orientations
forward_fxd = mne.convert_forward_solution(forward,
surf_ori=True,
force_fixed=True)
# noise covariance matrix
noise_cov = mne.read_cov(fname_cov)
# evoked data for info
evoked = mne.read_evokeds(fname_evoked, 0)
# make inverse operator from forward solution
# free source orientation
inverse_operator = mne.minimum_norm.make_inverse_operator(
info=evoked.info,
forward=forward,
noise_cov=noise_cov,
loose=1.,
depth=None)
# fixed source orientation
inverse_operator_fxd = mne.minimum_norm.make_inverse_operator(
info=evoked.info,
forward=forward,
noise_cov=noise_cov,
loose=0.,
depth=None,
fixed=True)
# regularisation parameter based on SNR
snr = 3.0
lambda2 = 1.0 / snr**2
# resolution matrices for free source orientation
# compute resolution matrix for MNE with free source orientations
rm_mne_free = make_resolution_matrix(forward,
inverse_operator,
method='MNE',
lambda2=lambda2)
# compute resolution matrix for MNE, fwd fixed and inv free
rm_mne_fxdfree = make_resolution_matrix(forward_fxd,
inverse_operator,
method='MNE',
lambda2=lambda2)
# resolution matrices for fixed source orientation
# compute resolution matrix for MNE
rm_mne = make_resolution_matrix(forward_fxd,
inverse_operator_fxd,
method='MNE',
lambda2=lambda2)
# compute resolution matrix for sLORETA
rm_lor = make_resolution_matrix(forward_fxd,
inverse_operator_fxd,
method='sLORETA',
lambda2=lambda2)
# rectify resolution matrix for sLORETA before determining maxima
rm_lor_abs = np.abs(rm_lor)
# get maxima per column
maxidxs = rm_lor_abs.argmax(axis=0)
# create array with the expected stepwise increase in maximum indices
goodidxs = np.arange(0, len(maxidxs), 1)
# Tests
# Does sLORETA have zero dipole localization error for columns/PSFs?
assert_array_equal(maxidxs, goodidxs)
# MNE resolution matrices symmetric?
assert_array_almost_equal(rm_mne, rm_mne.T)
assert_array_almost_equal(rm_mne_free, rm_mne_free.T)
# Test conversion to STC
idx = [1, 100, 400]
stc_psf = get_point_spread(rm_mne, forward_fxd['src'], idx, norm=True)
stc_ctf = get_cross_talk(rm_mne, forward_fxd['src'], idx, norm=True)
assert_array_almost_equal(stc_psf.data, stc_ctf.data)
# Test application of free inv to fixed fwd
assert_equal(rm_mne_fxdfree.shape, (3 * rm_mne.shape[0], rm_mne.shape[0]))
def test_resolution_matrix():
"""Test make_inverse_resolution_matrix() function."""
# read forward solution
forward = mne.read_forward_solution(fname_fwd)
# forward operator with fixed source orientations
forward_fxd = mne.convert_forward_solution(forward,
surf_ori=True,
force_fixed=True)
# noise covariance matrix
noise_cov = mne.read_cov(fname_cov)
# evoked data for info
evoked = mne.read_evokeds(fname_evoked, 0)
# make inverse operator from forward solution
# free source orientation
inverse_operator = mne.minimum_norm.make_inverse_operator(
info=evoked.info,
forward=forward,
noise_cov=noise_cov,
loose=1.,
depth=None)
# fixed source orientation
inverse_operator_fxd = mne.minimum_norm.make_inverse_operator(
info=evoked.info,
forward=forward,
noise_cov=noise_cov,
loose=0.,
depth=None,
fixed=True)
# regularisation parameter based on SNR
snr = 3.0
lambda2 = 1.0 / snr**2
# resolution matrices for free source orientation
# compute resolution matrix for MNE with free source orientations
rm_mne_free = make_inverse_resolution_matrix(forward,
inverse_operator,
method='MNE',
lambda2=lambda2)
# compute resolution matrix for MNE, fwd fixed and inv free
rm_mne_fxdfree = make_inverse_resolution_matrix(forward_fxd,
inverse_operator,
method='MNE',
lambda2=lambda2)
# resolution matrices for fixed source orientation
# compute resolution matrix for MNE
rm_mne = make_inverse_resolution_matrix(forward_fxd,
inverse_operator_fxd,
method='MNE',
lambda2=lambda2)
# compute resolution matrix for sLORETA
rm_lor = make_inverse_resolution_matrix(forward_fxd,
inverse_operator_fxd,
method='sLORETA',
lambda2=lambda2)
# rectify resolution matrix for sLORETA before determining maxima
rm_lor_abs = np.abs(rm_lor)
# get maxima per column
maxidxs = rm_lor_abs.argmax(axis=0)
# create array with the expected stepwise increase in maximum indices
goodidxs = np.arange(0, len(maxidxs), 1)
# Tests
# Does sLORETA have zero dipole localization error for columns/PSFs?
assert_array_equal(maxidxs, goodidxs)
# MNE resolution matrices symmetric?
assert_array_almost_equal(rm_mne, rm_mne.T)
assert_array_almost_equal(rm_mne_free, rm_mne_free.T)
# Some arbitrary vertex numbers
idx = [1, 100, 400]
# check various summary and normalisation options
for mode in [None, 'sum', 'mean', 'maxval', 'maxnorm', 'pca']:
n_comps = [1, 3]
if mode in [None, 'sum', 'mean']:
n_comps = [1]
for n_comp in n_comps:
for norm in [None, 'max', 'norm', True]:
stc_psf = get_point_spread(rm_mne,
forward_fxd['src'],
idx,
mode=mode,
n_comp=n_comp,
norm='norm',
return_pca_vars=False)
stc_ctf = get_cross_talk(rm_mne,
forward_fxd['src'],
idx,
mode=mode,
n_comp=n_comp,
norm='norm',
return_pca_vars=False)
# for MNE, PSF/CTFs for same vertices should be the same
assert_array_almost_equal(stc_psf.data, stc_ctf.data)
# check SVD variances
stc_psf, s_vars_psf = get_point_spread(rm_mne,
forward_fxd['src'],
idx,
mode=mode,
n_comp=n_comp,
norm='norm',
return_pca_vars=True)
stc_ctf, s_vars_ctf = get_cross_talk(rm_mne,
forward_fxd['src'],
idx,
mode=mode,
n_comp=n_comp,
norm='norm',
return_pca_vars=True)
assert_array_almost_equal(s_vars_psf, s_vars_ctf)
# variances for SVD components should be ordered
assert s_vars_psf[0] > s_vars_psf[1] > s_vars_psf[2]
# all variances should sum up to 100
assert_allclose(s_vars_psf.sum(), 100.)
# Test application of free inv to fixed fwd
assert_equal(rm_mne_fxdfree.shape, (3 * rm_mne.shape[0], rm_mne.shape[0]))
# Test PSF/CTF for labels
label = mne.read_label(fname_label)
# must be list of Label
label = [label]
label2 = 2 * label
# get relevant vertices in source space
verts = _vertices_for_get_psf_ctf(label, forward_fxd['src'])[0]
stc_psf_label = get_point_spread(rm_mne,
forward_fxd['src'],
label,
norm='max')
# for list of indices
stc_psf_idx = get_point_spread(rm_mne,
forward_fxd['src'],
verts,
norm='max')
stc_ctf_label = get_cross_talk(rm_mne,
forward_fxd['src'],
label,
norm='max')
# For MNE, PSF and CTF for same vertices should be the same
assert_array_almost_equal(stc_psf_label.data, stc_ctf_label.data)
# test multiple labels
stc_psf_label2 = get_point_spread(rm_mne,
forward_fxd['src'],
label2,
norm='max')
m, n = stc_psf_label.data.shape
assert_array_equal(stc_psf_label.data, stc_psf_label2[0].data)
assert_array_equal(stc_psf_label.data, stc_psf_label2[1].data)
assert_array_equal(stc_psf_label.data, stc_psf_idx.data)