def transform(self, X):
from mne.beamformer import apply_lcmv_epochs
mne.set_log_level('WARNING')
epochs = mne.EpochsArray(X, self.info, verbose=False)
epochs.filter(self.filter_specs['lp'],
self.filter_specs['hp'],
fir_design='firwin',
n_jobs=self.n_jobs)
stcs = apply_lcmv_epochs(epochs,
self.filters,
return_generator=True,
max_ori_out='signed',
verbose=False)
stcs_mat = np.ones((X.shape[0], self.fwd['nsource'], X.shape[2]))
for trial in range(X.shape[0]):
stcs_mat[trial, :, :] = next(stcs).data
# make an epoch
# epochs_stcs = source2epoch(stcs_mat, self.fwd['nsource'],
# self.info['sfreq'])
# epochs_stcs.filter(self.filter_specs['lp'], self.filter_specs['hp'],
# n_jobs=self.n_jobs)
if self.power_win is None:
self.power_win = self.t_win
time_idx = epochs.time_as_index(self.power_win)
# stcs_mat is [trials, grid points, time points]
return np.sum(stcs_mat[:, :, time_idx[0]:time_idx[1]]**2, axis=2)
def run_lcmv_epochs(epochs, fwd, data_cov, reg, noise_cov=None,
pick_ori='max-power', weight_norm='nai', verbose=False):
"""Run LCMV on epochs.
Run weight-normalized LCMV beamformer on epoch data, will return matrix of
trials or stc object.
Parameters:
-----------
epochs : MNE epochs
epochs to source reconstruct.
fwd : MNE forward model
forward model.
data_cov : MNE covariance estimate
data covariance matrix
reg : float
regularization parameter
noise_cov : MNE covariance estimate
noise covariance matrix, optional
verbose : bool
overrides default verbose level, defaults to False, i.e., no logger
info.
Returns
-------
stcs_mat : numpy array
matrix with all source trials
stc : MNE stc
single trial stc object (last trial)
filters : dict
spatial filter used in computation
"""
filters = make_lcmv(epochs.info, fwd, data_cov=data_cov,
noise_cov=noise_cov, pick_ori=pick_ori, reg=reg,
weight_norm=weight_norm, verbose=verbose)
# apply that filter to epochs
stcs = apply_lcmv_epochs(epochs, filters, return_generator=True,
max_ori_out='signed', verbose=verbose)
# preallocate matrix
stcs_mat = np.ones((epochs._data.shape[0], fwd['nsource'],
len(epochs.times)))
if verbose is False:
mne.set_log_level('WARNING')
# resolve generator
for trial in range(epochs._data.shape[0]):
# last time: also save stc
if trial == 0:
stc = next(stcs)
stcs_mat[trial, :, :] = stc.data
else:
stcs_mat[trial, :, :] = next(stcs).data
return stcs_mat, stc, filters
def transform(self, X):
from mne.beamformer import apply_lcmv_epochs
mne.set_log_level('WARNING')
epochs = mne.EpochsArray(X, self.info, tmin=self.tmin, verbose=False)
stcs = apply_lcmv_epochs(epochs,
self.filters,
return_generator=True,
max_ori_out='signed',
verbose=False)
stcs_mat = np.ones((X.shape[0], self.fwd['nsource'], X.shape[2]))
for trial in range(X.shape[0]):
stcs_mat[trial, :, :] = next(stcs).data
# stcs_mat is [trials, grid points, time points]
if self.erp is False:
time_idx_a = epochs.time_as_index(self.power_win[0])
time_idx_b = epochs.time_as_index(self.power_win[1])
return np.mean((stcs_mat[:, :, time_idx_a[0]:time_idx_b[0]]**2),
axis=2)
else:
return np.squeeze(stcs_mat[:, :, self.time_idx])
def transform(self, X):
from scipy import signal
from mne.beamformer import apply_lcmv_epochs
mne.set_log_level('WARNING')
hilbert_X = np.abs(signal.hilbert(X))
epochs = mne.EpochsArray(hilbert_X, self.info, verbose=False)
stcs = apply_lcmv_epochs(epochs,
self.filters,
return_generator=True,
max_ori_out='signed',
verbose=False)
stcs_mat = np.ones((X.shape[0], self.fwd['nsource'], X.shape[2]))
for trial in range(X.shape[0]):
stcs_mat[trial, :, :] = next(stcs).data
# stcs_mat is [trials, grid points, time points]
if self.power_win is None:
self.power_win = self.t_win
time_idx = epochs.time_as_index(self.power_win)
return np.mean(stcs_mat[:, :, time_idx[0]:time_idx[1]]**2, axis=2)
def test_make_lcmv(tmpdir, reg, proj):
"""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(proj=proj)
for fwd in [forward, forward_vol]:
filters = make_lcmv(evoked.info, fwd, data_cov, reg=reg,
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.08 < tmax < 0.15, tmax
assert 0.9 < np.max(max_stc) < 3.5, 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=reg, 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)]
lower = 0.04 if proj else 0.025
assert lower < tmax < 0.14, tmax
lower = 3e-7 if proj else 2e-7
assert lower < np.max(max_stc) < 3e-6, 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=reg,
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)]
lower = 0.08 if proj else 0.04
assert lower < tmax < 0.15, 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), 1.0)
# Test NAI weight normalization:
filters = make_lcmv(evoked.info, fwd, data_cov, reg=reg,
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 if spatial filter contains src_type
assert 'src_type' in filters
# __repr__
assert len(evoked.ch_names) == 22
assert len(evoked.info['projs']) == (3 if proj else 0)
assert len(evoked.info['bads']) == 2
rank = 17 if proj else 20
assert 'LCMV' in repr(filters)
assert 'unknown subject' not in repr(filters)
assert '4157 vert' in repr(filters)
assert '20 ch' in repr(filters)
assert 'rank %s' % rank 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
if proj:
raw_proj = deepcopy(raw)
raw_proj.del_proj()
with pytest.raises(ValueError, match='do not match the projections'):
apply_lcmv_raw(raw_proj, filters, max_ori_out='signed')
# 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, next(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)
# Test condition where one channel type is picked
# (avoid "grad data rank (13) did not match the noise rank (None)")
data_cov_grad = pick_channels_cov(
data_cov, [ch_name for ch_name in epochs.info['ch_names']
if ch_name.endswith(('2', '3'))])
assert len(data_cov_grad['names']) > 4
make_lcmv(epochs.info, forward_fixed, data_cov_grad, reg=0.01,
noise_cov=noise_cov)
data_cov = mne.compute_covariance(epochs)
filters = make_lcmv(epochs.info,
fwd,
data_cov,
0.05,
cov,
pick_ori='max-power',
weight_norm='nai')
del fwd
##############################################################################
# Compute label time series and do envelope correlation
# -----------------------------------------------------
epochs.apply_hilbert() # faster to do in sensor space
stcs = apply_lcmv_epochs(epochs, filters, return_generator=True)
corr = envelope_correlation(stcs, verbose=True)
##############################################################################
# Compute the degree and plot it
# ------------------------------
degree = mne.connectivity.degree(corr, 0.15)
stc = mne.VolSourceEstimate(degree, src[0]['vertno'], 0, 1, 'bst_resting')
brain = stc.plot(src,
clim=dict(kind='percent', lims=[75, 85, 95]),
colormap='gnuplot',
subjects_dir=subjects_dir,
mode='glass_brain')
##############################################################################
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]:
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 run_correlation(subjects_dir, subject, volume_spacing, freq, ortho_bool):
num_threads(8)
ortho_flag = str(ortho_bool)
frequency = str(freq)
DATA_DIR = Path(f'{subjects_dir}', f'{subject}', 'mne_files')
eye_proj1 = f'{DATA_DIR}/{subject}_eyes1-proj.fif.gz'
eye_proj2 = f'{DATA_DIR}/{subject}_eyes2-proj.fif.gz'
fname_meg = f'{DATA_DIR}/{subject}_ses-rest_task-rest.fif'
t1_fname = os.path.join(subjects_dir, subject, 'mri', 'T1.mgz')
heartbeat_proj = f'{DATA_DIR}/{subject}_heartbeat-proj.fif.gz'
fwd_fname = f'{DATA_DIR}/{subject}_{volume_spacing}-fwd.fif.gz'
src_fname = f'{DATA_DIR}/{subject}_{volume_spacing}-src.fif.gz'
cov_fname = f'{DATA_DIR}/{subject}-cov_{volume_spacing}.fif.gz'
raw_cov_fname = f'{DATA_DIR}/{subject}-rawcov_{volume_spacing}.fif.gz'
raw_proj = f'{DATA_DIR}/{subject}_ses-rest_task-rest_proj.fif.gz'
source_voxel_coords = f'{DATA_DIR}/{subject}_coords_{volume_spacing}.pkl'
corr_file_acLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_acLeft.npy'
corr_file_scLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_scLeft.npy'
corr_file_vcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_vcLeft.npy'
corr_file_mtLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mtLeft.npy'
corr_file_mtlLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mtlLeft.npy'
corr_file_smcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_smcLeft.npy'
corr_file_lpcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_lpcLeft.npy'
corr_file_dpfcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_dpfcLeft.npy'
corr_file_tmpcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_tmpcLeft.npy'
corr_file_acRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_acRight.npy'
corr_file_scRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_scRight.npy'
corr_file_vcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_vcRight.npy'
corr_file_mtRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mtRight.npy'
corr_file_mtlRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mtlRight.npy'
corr_file_smcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_smcRight.npy'
corr_file_lpcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_lpcRight.npy'
corr_file_dpfcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_dpfcRight.npy'
corr_file_tmpcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_tmpcRight.npy'
corr_file_mpfc = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mpfc.npy'
corr_file_sma = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_sma.npy'
check_for_files = []
check_for_files.append(corr_file_acLeft)
check_for_files.append(corr_file_scLeft)
check_for_files.append(corr_file_vcLeft)
check_for_files.append(corr_file_mtLeft)
check_for_files.append(corr_file_mtlLeft)
check_for_files.append(corr_file_smcLeft)
check_for_files.append(corr_file_lpcLeft)
check_for_files.append(corr_file_dpfcLeft)
check_for_files.append(corr_file_tmpcLeft)
check_for_files.append(corr_file_acRight)
check_for_files.append(corr_file_scRight)
check_for_files.append(corr_file_vcRight)
check_for_files.append(corr_file_mtRight)
check_for_files.append(corr_file_mtlRight)
check_for_files.append(corr_file_smcRight)
check_for_files.append(corr_file_lpcRight)
check_for_files.append(corr_file_dpfcRight)
check_for_files.append(corr_file_tmpcRight)
check_for_files.append(corr_file_mpfc)
check_for_files.append(corr_file_sma)
file_exist = [f for f in check_for_files if os.path.isfile(f)]
file_not_exist = list(set(file_exist) ^ set(check_for_files))
if not file_not_exist:
print('SC, AC, VC correlation files exists...')
else:
trans = f'/home/senthilp/caesar/camcan/cc700/camcan_coreg-master/trans/{subject}-trans.fif' # The transformation file obtained by coregistration
file_trans = pathlib.Path(trans)
file_ss = pathlib.Path(src_fname)
file_fm = pathlib.Path(fwd_fname)
file_proj = pathlib.Path(raw_proj)
file_cov = pathlib.Path(cov_fname)
file_rawcov = pathlib.Path(raw_cov_fname)
t1 = nib.load(t1_fname)
if not file_trans.exists():
print (f'{trans} File doesnt exist...')
sys.exit(0)
#info = mne.io.read_info(fname_meg)
# plot_registration(info, trans, subject, subjects_dir)
if not file_ss.exists():
src = compute_SourceSpace(subject, subjects_dir, src_fname, source_voxel_coords, plot=True, ss='volume',
volume_spacing=volume_spacing)
seed_l_sc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SSC_Left'])
seed_r_sc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SSC_Right'])
seed_l_ac = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['AC_Left'])
seed_r_ac = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['AC_Right'])
seed_l_vc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['VC_Left'])
seed_r_vc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['VC_Right'])
seed_l_mt = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MT+_Left'])
seed_r_mt = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MT+_Right'])
seed_l_mtl = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MTL_Left'])
seed_r_mtl = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MTL_Right'])
seed_l_smc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SMC_Left'])
seed_r_smc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SMC_Right'])
seed_l_lpc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['LPC_Left'])
seed_r_lpc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['LPC_Right'])
seed_l_dpfc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['DPFC_Left'])
seed_r_dpfc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['DPFC_Right'])
seed_l_tmpc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['TMPC_Left'])
seed_r_tmpc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['TMPC_Right'])
seed_mpfc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MPFC_MidBrain'])
seed_sma = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SMA_MidBrain'])
src_inuse = np.where(src[0]['inuse'] == 1)
loc_l_sc = src_inuse[0][0]
loc_r_sc = src_inuse[0][1]
loc_l_ac = src_inuse[0][2]
loc_r_ac = src_inuse[0][3]
loc_l_vc = src_inuse[0][4]
loc_r_vc = src_inuse[0][5]
loc_l_mt = src_inuse[0][6]
loc_r_mt = src_inuse[0][7]
loc_l_mtl = src_inuse[0][8]
loc_r_mtl = src_inuse[0][9]
loc_l_smc = src_inuse[0][10]
loc_r_smc = src_inuse[0][11]
loc_l_lpc = src_inuse[0][12]
loc_r_lpc = src_inuse[0][13]
loc_l_dpfc = src_inuse[0][14]
loc_r_dpfc = src_inuse[0][15]
loc_l_tmpc = src_inuse[0][16]
loc_r_tmpc = src_inuse[0][17]
loc_mpfc = src_inuse[0][18]
loc_sma = src_inuse[0][19]
src[0]['rr'][loc_l_sc] = seed_l_sc
src[0]['rr'][loc_r_sc] = seed_r_sc
src[0]['rr'][loc_l_ac] = seed_l_ac
src[0]['rr'][loc_r_ac] = seed_r_ac
src[0]['rr'][loc_l_vc] = seed_l_vc
src[0]['rr'][loc_r_vc] = seed_r_vc
src[0]['rr'][loc_l_mt] = seed_l_mt
src[0]['rr'][loc_r_mt] = seed_r_mt
src[0]['rr'][loc_l_mtl] = seed_l_mtl
src[0]['rr'][loc_r_mtl] = seed_r_mtl
src[0]['rr'][loc_l_smc] = seed_l_smc
src[0]['rr'][loc_r_smc] = seed_r_smc
src[0]['rr'][loc_l_lpc] = seed_l_lpc
src[0]['rr'][loc_r_lpc] = seed_r_lpc
src[0]['rr'][loc_l_dpfc] = seed_l_dpfc
src[0]['rr'][loc_r_dpfc] = seed_r_dpfc
src[0]['rr'][loc_l_tmpc] = seed_l_tmpc
src[0]['rr'][loc_r_tmpc] = seed_r_tmpc
src[0]['rr'][loc_mpfc] = seed_mpfc
src[0]['rr'][loc_sma] = seed_sma
src.save(src_fname, overwrite=True)
src = mne.read_source_spaces(src_fname)
#view_SS_brain(subject, subjects_dir, src)
if not file_fm.exists():
forward_model(subject, subjects_dir, fname_meg, trans, src, fwd_fname)
fwd = mne.read_forward_solution(fwd_fname)
# sensitivty_plot(subject, subjects_dir, fwd)
raw = mne.io.read_raw_fif(fname_meg, verbose='error', preload=True)
srate = raw.info['sfreq']
n_time_samps = raw.n_times
time_secs = raw.times
ch_names = raw.ch_names
n_chan = len(ch_names)
freq_res = srate/n_time_samps
print('\n')
print('-------------------------- Data summary-------------------------------')
print(f'Subject {subject}')
print(f"Frequency resolution {freq_res} Hz")
print(f"The first few channel names are {ch_names[:3]}")
print(f"The last time sample at {time_secs[-1]} seconds.")
print(f"Sampling Frequency (No of time points/sec) {srate} Hz")
print(f"Miscellaneous acquisition info {raw.info['description']}")
print(f"Bad channels marked during data acquisition {raw.info['bads']}")
print(f"Convert time in sec ( 60s ) to ingeter index {raw.time_as_index(60)}") # Convert time to indices
print(f"The raw data object has {n_time_samps} time samples and {n_chan} channels.")
print('------------------------------------------------------------------------')
print('\n')
# raw.plot(n_channels=10, scalings='auto', title='Data from arrays', show=True, block=True)
if not file_proj.exists():
projs_ecg, _ = compute_proj_ecg(raw, n_grad=1, n_mag=2, ch_name='ECG063')
projs_eog1, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='EOG061')
projs_eog2, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='EOG062')
if projs_ecg is not None:
mne.write_proj(heartbeat_proj, projs_ecg) # Saving projectors
raw.info['projs'] += projs_ecg
if projs_eog1 is not None:
mne.write_proj(eye_proj1, projs_eog1)
raw.info['projs'] += projs_eog1
if projs_eog2 is not None:
mne.write_proj(eye_proj2, projs_eog2)
raw.info['projs'] += projs_eog2
raw.apply_proj()
raw.save(raw_proj, proj=True, overwrite=True)
print(raw_proj)
raw_proj_applied = mne.io.read_raw_fif(raw_proj, verbose='error', preload=True)
print(f'High-pass filtering data at 0.5 Hz')
raw_proj_applied.filter(l_freq=0.5, h_freq=None, method='iir')
if not file_cov.exists():
cov = mne.compute_raw_covariance(raw_proj_applied) # compute before band-pass of interest
mne.write_cov(cov_fname, cov)
cov = mne.read_cov(cov_fname)
# cov.plot(raw.info, proj=True, exclude='bads', show_svd=False
# raw_proj_applied.crop(tmax=10)
do_epochs = False
l_freq = freq-2.0
h_freq = freq+2.0
print(f'Band pass filter data [{l_freq}, {h_freq}]')
raw_proj_filtered = raw_proj_applied.filter(l_freq=l_freq, h_freq=h_freq)
if do_epochs:
print('Segmenting raw data...')
events = mne.make_fixed_length_events(raw_proj_filtered, duration=5.)
raw_proj_filtered = mne.Epochs(raw_proj_filtered, events=events, tmin=0, tmax=5.,
baseline=None, preload=True)
data_cov = mne.compute_covariance(raw_proj_filtered)
else:
if not file_rawcov.exists():
data_cov = mne.compute_raw_covariance(raw_proj_filtered)
mne.write_cov(raw_cov_fname, data_cov)
else:
data_cov = mne.read_cov(file_rawcov)
filters = make_lcmv(raw_proj_filtered.info, fwd, data_cov, 0.05, cov,
pick_ori='max-power', weight_norm='nai')
raw_proj_filtered_comp = raw_proj_filtered.apply_hilbert()
if do_epochs:
stcs = apply_lcmv_epochs(raw_proj_filtered_comp, filters, return_generator=False)
else:
stcs = apply_lcmv_raw(raw_proj_filtered_comp, filters, verbose=True)
stcs = [stcs]
# Power Envelope Correlation
print(f'Computing Power Envelope Correlation for {subject}....Orthogonalize {ortho_flag}')
all_corr = envelope_correlation(stcs, combine=None, orthogonalize=False,
log=False, absolute=True, verbose=None)
np.save(corr_file_scLeft, all_corr[seed_left_sc])
np.save(corr_file_acLeft, all_corr[seed_left_ac])
np.save(corr_file_vcLeft, all_corr[seed_left_vc])
np.save(corr_file_mtLeft, all_corr[seed_left_mt])
np.save(corr_file_mtlLeft, all_corr[seed_left_mtl])
np.save(corr_file_smcLeft, all_corr[seed_left_smc])
np.save(corr_file_lpcLeft, all_corr[seed_left_lpc])
np.save(corr_file_dpfcLeft, all_corr[seed_left_dpfc])
np.save(corr_file_tmpcLeft, all_corr[seed_left_tmpc])
np.save(corr_file_scRight, all_corr[seed_right_sc])
np.save(corr_file_acRight, all_corr[seed_right_ac])
np.save(corr_file_vcRight, all_corr[seed_right_vc])
np.save(corr_file_mtRight, all_corr[seed_right_mt])
np.save(corr_file_mtlRight, all_corr[seed_right_mtl])
np.save(corr_file_smcRight, all_corr[seed_right_smc])
np.save(corr_file_lpcRight, all_corr[seed_right_lpc])
np.save(corr_file_dpfcRight, all_corr[seed_right_dpfc])
np.save(corr_file_tmpcRight, all_corr[seed_right_tmpc])
np.save(corr_file_mpfc, all_corr[seed_mpfc_index])
np.save(corr_file_sma, all_corr[seed_sma_index])
del stcs
epochs.pick_types(meg=True, ref_meg=False)
# inv = make_inverse_operator(epochs.info, fwd, noise_cov,
# loose=0.2, depth=0.8)
method = 'beamformer' # use of beamformer method
# reconstruct source signal at the single trial
data_cov = mne.compute_covariance(epochs, tmin=0.04)
if not target_baseline:
noise_cov = mne.compute_covariance(epochs, tmax=0)
filters = make_lcmv(epochs.info,
fwd,
noise_cov=noise_cov,
data_cov=data_cov,
reg=0.05,
pick_ori='max-power')
stcs = apply_lcmv_epochs(epochs, filters, max_ori_out='signed')
n_times = len(epochs.times)
n_vertices = len(stcs[0].data)
n_epochs = len(epochs.events)
X_data = np.zeros([n_epochs, n_vertices, n_times])
for jj, stc in enumerate(stcs):
X_data[jj] = stc.data
X = mne.time_frequency.tfr_array_morlet(X_data,
sfreq=epochs.info['sfreq'],
freqs=freqs,
output='power',
n_cycles=n_cycles,
n_jobs=24)
n_epochs, n_channels, n_freqs, n_times = X.shape
X = X.reshape(n_epochs, n_channels, -1) # collapse freqs and time
# considerations here
pos = 15. # 1.5 cm is very broad, done here for speed!
src = mne.setup_volume_source_space('bst_resting', pos, bem=bem,
subjects_dir=subjects_dir, verbose=True)
fwd = mne.make_forward_solution(epochs.info, trans, src, bem)
data_cov = mne.compute_covariance(epochs)
filters = make_lcmv(epochs.info, fwd, data_cov, 0.05, cov,
pick_ori='max-power', weight_norm='nai')
del fwd
##############################################################################
# Compute label time series and do envelope correlation
# -----------------------------------------------------
epochs.apply_hilbert() # faster to do in sensor space
stcs = apply_lcmv_epochs(epochs, filters, return_generator=True)
corr = envelope_correlation(stcs, verbose=True)
##############################################################################
# Compute the degree and plot it
# ------------------------------
degree = mne.connectivity.degree(corr, 0.15)
stc = mne.VolSourceEstimate(degree, src[0]['vertno'], 0, 1, 'bst_resting')
brain = stc.plot(
src, clim=dict(kind='percent', lims=[75, 85, 95]), colormap='gnuplot',
subjects_dir=subjects_dir, mode='glass_brain')
##############################################################################
# References
# ----------
GA_break = []
GA_diff = []
for meg, mri in sub_dict.items():
epo = mne.read_epochs("{}{}-analysis-epo.fif".format(meg_dir,meg))
fwd = mne.read_forward_solution("{}{}_vol-fwd.fif".format(meg_dir,meg))
epo.filter(fmin, fmax, n_jobs='cuda')
data_cov = mne.compute_covariance(epo, tmin=0, tmax=None, rank=None, n_jobs=8)
noise_cov = mne.compute_covariance(epo, tmin=None, tmax=0, rank=None, n_jobs=8)
filters = make_lcmv(epo.info, fwd, data_cov=data_cov,
noise_cov=noise_cov, pick_ori='max-power',
weight_norm='unit-noise-gain', reg=0.05, rank=None)
filters.save('{}{}_alpha_vol-lcmv.h5'.format(meg_dir,meg),overwrite=True)
epo.apply_hilbert(n_jobs=1, envelope=False)
stcs_cont = apply_lcmv_epochs(epo['cont'], filters, max_ori_out='signed')
stcs_break = apply_lcmv_epochs(epo['break'], filters, max_ori_out='signed')
del epo, noise_cov, data_cov
# envelope data (absolute) for both conditions
for stc in stcs_cont:
stc.data[:, :] = np.abs(stc.data)
with warnings.catch_warnings():
warnings.simplefilter('ignore')
stc.data = np.array(stc.data, 'float64')
for stc in stcs_break:
stc.data[:, :] = np.abs(stc.data)
with warnings.catch_warnings():
warnings.simplefilter('ignore')
stc.data = np.array(stc.data, 'float64')
# average across epochs per condition
mean_cont = np.mean([stc.data for stc in stcs_cont], axis=0)
def run_correlation(subjects_dir, subject, volume_spacing, freq):
num_threads(8)
frequency = str(freq)
DATA_DIR = Path(f'{subjects_dir}', f'{subject}', 'mne_files')
eye_proj1 = f'{DATA_DIR}/{subject}_eyes1-proj.fif.gz'
eye_proj2 = f'{DATA_DIR}/{subject}_eyes2-proj.fif.gz'
fname_meg = f'{DATA_DIR}/{subject}_ses-rest_task-rest.fif'
t1_fname = os.path.join(subjects_dir, subject, 'mri', 'T1.mgz')
heartbeat_proj = f'{DATA_DIR}/{subject}_heartbeat-proj.fif.gz'
fwd_fname = f'{DATA_DIR}/{subject}_{volume_spacing}-fwd-label.fif.gz'
src_fname = f'{DATA_DIR}/{subject}_{volume_spacing}-src-label.fif.gz'
cov_fname = f'{DATA_DIR}/{subject}-cov_{volume_spacing}-label.fif.gz'
raw_cov_fname = f'{DATA_DIR}/{subject}-rawcov_{volume_spacing}-label.fif.gz'
raw_proj = f'{DATA_DIR}/{subject}_ses-rest_task-rest_proj-label.fif.gz'
source_voxel_coords = f'{DATA_DIR}/{subject}_coords_{volume_spacing}.pkl'
freesurfer_label = f'{DATA_DIR}/{subject}_freesurferlabel_{volume_spacing}-label.pkl'
corr_true_file_label = f'{DATA_DIR}/{subject}_corr_ortho_true_{volume_spacing}_{frequency}_label.npy'
check_for_files = []
check_for_files.append(corr_true_file_label)
file_exist = [f for f in check_for_files if os.path.isfile(f)]
file_not_exist = list(set(file_exist) ^ set(check_for_files))
if not file_not_exist:
print('correlation files exists...')
else:
trans = f'/home/senthilp/caesar/camcan/cc700/camcan_coreg-master/trans/{subject}-trans.fif' # The transformation file obtained by coregistration
file_trans = pathlib.Path(trans)
file_ss = pathlib.Path(src_fname)
file_fm = pathlib.Path(fwd_fname)
file_proj = pathlib.Path(raw_proj)
file_cov = pathlib.Path(cov_fname)
file_rawcov = pathlib.Path(raw_cov_fname)
t1 = nib.load(t1_fname)
if not file_trans.exists():
print (f'{trans} File doesnt exist...')
sys.exit(0)
info = mne.io.read_info(fname_meg)
# plot_registration(info, trans, subject, subjects_dir)
print(file_ss)
if not file_ss.exists():
src = compute_SourceSpace(subject, subjects_dir, src_fname, source_voxel_coords, plot=True, ss='volume',
volume_spacing=volume_spacing)
src.save(src_fname, overwrite=True)
src = mne.read_source_spaces(src_fname)
#view_SS_brain(subject, subjects_dir, src)
if not file_fm.exists():
forward_model(subject, subjects_dir, fname_meg, trans, src, fwd_fname)
fwd = mne.read_forward_solution(fwd_fname)
# sensitivty_plot(subject, subjects_dir, fwd)
raw = mne.io.read_raw_fif(fname_meg, verbose='error', preload=True)
srate = raw.info['sfreq']
n_time_samps = raw.n_times
time_secs = raw.times
ch_names = raw.ch_names
n_chan = len(ch_names)
freq_res = srate/n_time_samps
print('\n')
print('-------------------------- Data summary-------------------------------')
print(f'Subject {subject}')
print(f"Frequency resolution {freq_res} Hz")
print(f"The first few channel names are {ch_names[:3]}")
print(f"The last time sample at {time_secs[-1]} seconds.")
print(f"Sampling Frequency (No of time points/sec) {srate} Hz")
print(f"Miscellaneous acquisition info {raw.info['description']}")
print(f"Bad channels marked during data acquisition {raw.info['bads']}")
print(f"Convert time in sec ( 60s ) to ingeter index {raw.time_as_index(60)}") # Convert time to indices
print(f"The raw data object has {n_time_samps} time samples and {n_chan} channels.")
print('------------------------------------------------------------------------')
print('\n')
# raw.plot(n_channels=10, scalings='auto', title='Data from arrays', show=True, block=True)
if not file_proj.exists():
projs_ecg, _ = compute_proj_ecg(raw, n_grad=1, n_mag=2, ch_name='ECG063')
projs_eog1, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='EOG061')
projs_eog2, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='EOG062')
if projs_ecg is not None:
mne.write_proj(heartbeat_proj, projs_ecg) # Saving projectors
raw.info['projs'] += projs_ecg
if projs_eog1 is not None:
mne.write_proj(eye_proj1, projs_eog1)
raw.info['projs'] += projs_eog1
if projs_eog2 is not None:
mne.write_proj(eye_proj2, projs_eog2)
raw.info['projs'] += projs_eog2
raw.apply_proj()
raw.save(raw_proj, proj=True, overwrite=True)
print(raw_proj)
raw_proj_applied = mne.io.read_raw_fif(raw_proj, verbose='error', preload=True)
print(f'High-pass filtering data at 0.5 Hz')
raw_proj_applied.filter(l_freq=0.5, h_freq=None, method='iir')
if not file_cov.exists():
cov = mne.compute_raw_covariance(raw_proj_applied) # compute before band-pass of interest
mne.write_cov(cov_fname, cov)
cov = mne.read_cov(cov_fname)
# cov.plot(raw.info, proj=True, exclude='bads', show_svd=False
# raw_proj_applied.crop(tmax=10)
do_epochs = False
l_freq = freq-2.0
h_freq = freq+2.0
print(f'Band pass filter data [{l_freq}, {h_freq}]')
raw_proj_filtered = raw_proj_applied.filter(l_freq=l_freq, h_freq=h_freq)
if do_epochs:
print('Segmenting raw data...')
events = mne.make_fixed_length_events(raw_proj_filtered, duration=5.)
raw_proj_filtered = mne.Epochs(raw_proj_filtered, events=events, tmin=0, tmax=5.,
baseline=None, preload=True)
data_cov = mne.compute_covariance(raw_proj_filtered)
else:
if not file_rawcov.exists():
data_cov = mne.compute_raw_covariance(raw_proj_filtered)
mne.write_cov(raw_cov_fname, data_cov)
else:
data_cov = mne.read_cov(file_rawcov)
filters = make_lcmv(raw_proj_filtered.info, fwd, data_cov, 0.05, cov,
pick_ori='max-power', weight_norm='nai')
raw_proj_filtered_comp = raw_proj_filtered.apply_hilbert()
if do_epochs:
stcs = apply_lcmv_epochs(raw_proj_filtered_comp, filters, return_generator=False)
else:
stcs = apply_lcmv_raw(raw_proj_filtered_comp, filters, verbose=True)
print('Extracting label time course...')
atlas = f'{subjects_dir}/{subject}/mri/aparc.a2009s+aseg.mgz'
label_ts = mne.extract_label_time_course(stcs, atlas, fwd['src'], return_generator=False)
label_ts = [label_ts]
# Power Envelope Correlation
print(f'Computing Power Envelope Correlation for {subject}....Orthogonalize True')
all_corr = envelope_correlation(label_ts, combine=None, orthogonalize="pairwise",
log=True, absolute=True, verbose=None)
print(f'Correlation saved to {corr_true_file_label}')
np.save(corr_true_file_label, all_corr)
del stcs
def main(filename=None, subjid=None, trans=None, info=None, line_freq=None,
emptyroom_filename=None, subjects_dir=None):
raw = hcp.read_raw(subjid, 'rest', hcp_path='/data/EnigmaMeg/HCP/HCP_MEG')
raw.load_data()
eraw = hcp.read_raw(subjid, 'noise_empty_room',hcp_path='/data/EnigmaMeg/HCP/HCP_MEG')
eraw.load_data()
hcp.preprocessing.apply_ref_correction(raw)
hcp.preprocessing.apply_ref_correction(eraw)
#Below may be useful for testing ICA components
#ica_mat = hcp.read_ica(subjid, 'rest')
#annotations_dict=hcp.read_annot(subjid, 'rest')
#hcp.preprocessing.apply_ica_hcp(raw, ica_mat, annotations_dict['ica']['ecg_eog_ic'])
## Load and prefilter continuous data
#raw=load_data(filename)
#eraw=load_data(emptyroom_filename)
if type(raw)==mne.io.ctf.ctf.RawCTF:
raw.apply_gradient_compensation(3)
## Test SSS bad channel detection for non-Elekta data
# !!!!!!!!!!! Currently no finecal or crosstalk used !!!!!!!!!!!!!!!
# if filename[-3:]=='fif':
# raw_bads_dict = assess_bads(filename)
# eraw_bads_dict = assess_bads(emptyroom_filename, is_eroom=True)
# raw.info['bads']=raw_bads_dict['noisy'] + raw_bads_dict['flat']
# eraw.info['bads']=eraw_bads_dict['noisy'] + eraw_bads_dict['flat']
resample_freq=300
raw.resample(resample_freq)
eraw.resample(resample_freq)
raw.filter(0.5, 140)
eraw.filter(0.5, 140)
if line_freq==None:
try:
line_freq = raw.info['line_freq'] # this isn't present in all files
except:
raise(ValueError('Could not determine line_frequency'))
notch_freqs = np.arange(line_freq,
resample_freq/2,
line_freq)
raw.notch_filter(notch_freqs)
## Create Epochs and covariance
epochs = mne.make_fixed_length_epochs(raw, duration=4.0, preload=True)
epochs.apply_baseline(baseline=(0,None))
cov = mne.compute_covariance(epochs)
er_epochs=mne.make_fixed_length_epochs(eraw, duration=4.0, preload=True)
er_epochs.apply_baseline(baseline=(0,None))
er_cov = mne.compute_covariance(er_epochs)
os.environ['SUBJECTS_DIR']=subjects_dir
src = mne.read_source_spaces(info.src_filename)
bem = mne.read_bem_solution(info.bem_sol_filename)
fwd = mne.make_forward_solution(epochs.info, trans, src, bem)
data_info = epochs.info
from mne.beamformer import make_lcmv, apply_lcmv_epochs
filters = make_lcmv(epochs.info, fwd, cov, reg=0.01,
noise_cov=er_cov, pick_ori='max-power',
weight_norm='unit-noise-gain', rank=None)
labels_lh=mne.read_labels_from_annot(subjid, parc='aparc_sub',
subjects_dir=subjects_dir, hemi='lh')
labels_rh=mne.read_labels_from_annot(subjid, parc='aparc_sub',
subjects_dir=subjects_dir, hemi='rh')
labels=labels_lh + labels_rh
results_stcs = apply_lcmv_epochs(epochs, filters, return_generator=True)#, max_ori_out='max_power')
#Monkey patch of mne.source_estimate to perform 15 component SVD
label_ts = mod_source_estimate.extract_label_time_course(results_stcs,
labels,
fwd['src'],
mode='pca15_multitaper')
#Convert list of numpy arrays to ndarray (Epoch/Label/Sample)
label_stack = np.stack(label_ts)
#HACK HARDCODED FREQ BINS
freq_bins = np.linspace(1,45,177) ######################################3######### FIX
#Initialize
label_power = np.zeros([len(labels), len(freq_bins)])
alpha_peak = np.zeros(len(labels))
#Create PSD for each label
for label_idx in range(len(labels)):
print(str(label_idx))
current_psd = label_stack[:,label_idx, :].mean(axis=0)
label_power[label_idx,:] = current_psd
spectral_image_path = os.path.join(info.outfolder, 'Spectra_'+
labels[label_idx].name + '.png')
try:
tmp_fmodel = calc_spec_peak(freq_bins, current_psd,
out_image_path=spectral_image_path)
#FIX FOR MULTIPLE ALPHA PEAKS
potential_alpha_idx = np.where((8.0 <= tmp_fmodel.peak_params[:,0] ) & \
(tmp_fmodel.peak_params[:,0] <= 12.0 ) )[0]
if len(potential_alpha_idx) != 1:
alpha_peak[label_idx] = np.nan #############FIX ###########################3 FIX
else:
alpha_peak[label_idx] = tmp_fmodel.peak_params[potential_alpha_idx[0]][0]
except:
alpha_peak[label_idx] = np.nan #Fix <<<<<<<<<<<<<<
#Save the label spectrum to assemble the relative power
freq_bin_names=[str(binval) for binval in freq_bins]
label_spectra_dframe = pd.DataFrame(label_power, columns=[freq_bin_names])
label_spectra_dframe.to_csv( os.path.join(info.outfolder, 'label_spectra.csv') , index=False)
# with open(os.path.join(info.outfolder, 'label_spectra.npy'), 'wb') as f:
# np.save(f, label_power)
relative_power = label_power / label_power.sum(axis=1, keepdims=True)
#Define bands
bands = [[1,3], [3,6], [8,12], [13,35], [35,55]]
band_idxs = get_freq_idx(bands, freq_bins)
#initialize output
band_means = np.zeros([len(labels), len(bands)])
#Loop over all bands, select the indexes assocaited with the band and average
for mean_band, band_idx in enumerate(band_idxs):
band_means[:, mean_band] = relative_power[:, band_idx].mean(axis=1)
output_filename = os.path.join(info.outfolder, 'Band_rel_power.csv')
bands_str = [str(i) for i in bands]
label_names = [i.name for i in labels]
output_dframe = pd.DataFrame(band_means, columns=bands_str,
index=label_names)
output_dframe['AlphaPeak'] = alpha_peak
output_dframe.to_csv(output_filename, sep='\t')
def test_beamformer():
#Load filenames from test datasets
from enigmeg.test_data.get_test_data import datasets
test_dat = datasets().ctf
meg_filename = test_dat['meg_rest']
subjid = test_dat['subject']
subjects_dir = test_dat['SUBJECTS_DIR']
trans_fname = test_dat['trans']
src_fname = test_dat['src']
bem = test_dat['bem']
outfolder = './tmp' #<<< Change this ############################
raw = mne.io.read_raw_ctf(meg_filename, preload=True)
trans = mne.read_trans(trans_fname)
# info.subjid, info.subjects_dir = subjid, subjects_dir
raw.apply_gradient_compensation(3)
raw.resample(300)
raw.filter(1.0, None)
raw.notch_filter([60,120])
eraw.notch_filter([60,120])
epochs = mne.make_fixed_length_epochs(raw, duration=4.0, preload=True)
data_cov = mne.compute_covariance(epochs, method='empirical')
eroom_filename = test_dat['meg_eroom']
eroom_raw = mne.io.read_raw_ctf(eroom_filename, preload=True)
eroom_raw.resample(300)
eroom_raw.notch_filter([60,120])
eroom_raw.filter(1.0, None)
eroom_epochs = mne.make_fixed_length_epochs(eroom_raw, duration=4.0)
noise_cov = mne.compute_covariance(eroom_epochs)
fwd = mne.make_forward_solution(epochs.info, trans, src_fname,
bem)
from mne.beamformer import make_lcmv, apply_lcmv_epochs
filters = make_lcmv(epochs.info, fwd, data_cov, reg=0.01,
noise_cov=noise_cov, pick_ori='max-power',
weight_norm='unit-noise-gain', rank=None)
labels_lh=mne.read_labels_from_annot(subjid, parc='aparc',
subjects_dir=subjects_dir, hemi='lh')
labels_rh=mne.read_labels_from_annot(subjid, parc='aparc',
subjects_dir=subjects_dir, hemi='rh')
labels=labels_lh + labels_rh
# labels[1].center_of_mass()
results_stcs = apply_lcmv_epochs(epochs, filters, return_generator=True)#, max_ori_out='max_power')
#Monkey patch of mne.source_estimate to perform 15 component SVD
label_ts = mod_source_estimate.extract_label_time_course(results_stcs, labels,
fwd['src'],
mode='pca15_multitaper')
#Convert list of numpy arrays to ndarray (Epoch/Label/Sample)
label_stack = np.stack(label_ts)
# label_stack = np.mean(label_stack, axis=0)
# freq_bins, _ = label_psd(label_stack[:,0, :], raw.info['sfreq'])
freq_bins = np.linspace(1,45,177) ######################################3######### FIX
#Initialize
label_power = np.zeros([len(labels), len(freq_bins)])
alpha_peak = np.zeros(len(labels))
#Create PSD for each label
for label_idx in range(len(labels)):
print(str(label_idx))
current_psd = label_stack[:,label_idx, :].mean(axis=0)
label_power[label_idx,:] = current_psd
spectral_image_path = os.path.join(outfolder, 'Spectra_'+
labels[label_idx].name + '.png')
try:
tmp_fmodel = calc_spec_peak(freq_bins, current_psd,
out_image_path=spectral_image_path)
#FIX FOR MULTIPLE ALPHA PEAKS
potential_alpha_idx = np.where((8.0 <= tmp_fmodel.peak_params[:,0] ) & \
(tmp_fmodel.peak_params[:,0] <= 12.0 ) )[0]
if len(potential_alpha_idx) != 1:
alpha_peak[label_idx] = np.nan #############FIX ###########################3 FIX
else:
alpha_peak[label_idx] = tmp_fmodel.peak_params[potential_alpha_idx[0]][0]
except:
alpha_peak[label_idx] = np.nan #Fix <<<<<<<<<<<<<<
