def test_plot_cov():
"""Test plotting of covariances
"""
raw = _get_raw()
cov = read_cov(cov_fname)
plot_cov(cov, raw.info, proj=True)
plt.close('all')
def test_plot_cov():
"""Test plotting of covariances
"""
raw = _get_raw()
cov = read_cov(cov_fname)
plot_cov(cov, raw.info, proj=True)
plt.close('all')
def test_plot_cov():
"""Test plotting of covariances
"""
raw = _get_raw()
cov = read_cov(cov_fname)
fig1, fig2 = plot_cov(cov, raw.info, proj=True, exclude=raw.ch_names[6:])
plt.close('all')
def test_plot_cov():
"""Test plotting of covariances
"""
raw = _get_raw()
cov = read_cov(cov_fname)
fig1, fig2 = plot_cov(cov, raw.info, proj=True, exclude=raw.ch_names[6:])
plt.close('all')
def test_plot_cov():
"""Test plotting of covariances
"""
cov = read_cov(cov_fname)
plot_cov(cov, raw.info, proj=True)
def gen_covariances(p, subjects, run_indices, decim):
"""Generate forward solutions
Can only complete successfully once preprocessing is performed.
Parameters
----------
p : instance of Parameters
Analysis parameters.
subjects : list of str
Subject names to analyze (e.g., ['Eric_SoP_001', ...]).
run_indices : array-like | None
Run indices to include.
decim : list of int
The subject decimations.
"""
for si, subj in enumerate(subjects):
print(' Subject %2d/%2d...' % (si + 1, len(subjects)), end='')
cov_dir = op.join(p.work_dir, subj, p.cov_dir)
if not op.isdir(cov_dir):
os.mkdir(cov_dir)
has_rank_arg = 'rank' in get_args(compute_covariance)
kwargs = dict()
kwargs_erm = dict()
if p.cov_rank == 'full': # backward compat
if has_rank_arg:
kwargs['rank'] = 'full'
else:
if not has_rank_arg:
raise RuntimeError(
'There is no "rank" argument of compute_covariance, '
'you need to update MNE-Python')
if p.cov_rank is None:
assert p.compute_rank # otherwise this is weird
kwargs['rank'] = _compute_rank(p, subj, run_indices[si])
else:
kwargs['rank'] = p.cov_rank
kwargs_erm['rank'] = kwargs['rank']
if p.force_erm_cov_rank_full and has_rank_arg:
kwargs_erm['rank'] = 'full'
# Use the same thresholds we used for primary Epochs
if p.autoreject_thresholds:
reject = get_epochs_evokeds_fnames(p, subj, [])[0][1]
reject = reject.replace('-epo.fif', '-reject.h5')
reject = read_hdf5(reject)
else:
reject = _handle_dict(p.reject, subj)
flat = _handle_dict(p.flat, subj)
# Make empty room cov
if p.runs_empty:
if len(p.runs_empty) > 1:
raise ValueError('Too many empty rooms; undefined output!')
new_run = safe_inserter(p.runs_empty[0], subj)
empty_cov_name = op.join(
cov_dir, new_run + p.pca_extra + p.inv_tag + '-cov.fif')
empty_fif = get_raw_fnames(p, subj, 'pca', 'only', False)[0]
raw = read_raw_fif(empty_fif, preload=True)
raw.pick_types(meg=True, eog=True, exclude='bads')
use_reject, use_flat = _restrict_reject_flat(reject, flat, raw)
if 'eeg' in use_reject:
del use_reject['eeg']
if 'eeg' in use_flat:
del use_flat['eeg']
cov = compute_raw_covariance(raw,
reject=use_reject,
flat=use_flat,
method=p.cov_method,
**kwargs_erm)
write_cov(empty_cov_name, cov)
# Make evoked covariances
for ii, (inv_name, inv_run) in enumerate(zip(p.inv_names, p.inv_runs)):
cov_name = op.join(
cov_dir,
safe_inserter(inv_name, subj) + ('-%d' % p.lp_cut) +
p.inv_tag + '-cov.fif')
if run_indices[si] is None:
ridx = inv_run
else:
ridx = np.intersect1d(run_indices[si], inv_run)
# read in raw files
raw_fnames = get_raw_fnames(p, subj, 'pca', False, False, ridx)
raws = []
first_samps = []
last_samps = []
for raw_fname in raw_fnames:
raws.append(read_raw_fif(raw_fname, preload=False))
first_samps.append(raws[-1]._first_samps[0])
last_samps.append(raws[-1]._last_samps[-1])
_fix_raw_eog_cals(raws) # safe b/c cov only needs MEEG
raw = concatenate_raws(raws)
# read in events
events = _read_events(p, subj, ridx, raw)
if p.pick_events_cov is not None:
old_count = sum(len(e) for e in events)
if callable(p.pick_events_cov):
picker = p.pick_events_cov
else:
picker = p.pick_events_cov[ii]
events = picker(events)
new_count = len(events)
print(' Using %s/%s events for %s' %
(new_count, old_count, op.basename(cov_name)))
# create epochs
use_reject, use_flat = _restrict_reject_flat(reject, flat, raw)
baseline = _get_baseline(p)
epochs = Epochs(
raw,
events,
event_id=None,
tmin=baseline[0],
tmax=baseline[1],
baseline=(None, None),
proj=False,
reject=use_reject,
flat=use_flat,
preload=True,
decim=decim[si],
verbose='error', # ignore decim-related warnings
on_missing=p.on_missing,
reject_by_annotation=p.reject_epochs_by_annot)
epochs.pick_types(meg=True, eeg=True, exclude=[])
cov = compute_covariance(epochs, method=p.cov_method, **kwargs)
if kwargs.get('rank', None) not in (None, 'full'):
want_rank = sum(kwargs['rank'].values())
out_rank = compute_whitener(cov,
epochs.info,
return_rank=True,
verbose='error')[2]
if want_rank != out_rank:
# Hopefully we never hit this code path, but let's keep
# some debugging stuff around just in case
plot_cov(cov, epochs.info)
epochs_fnames, _ = get_epochs_evokeds_fnames(
p, subj, p.analyses)
epochs2 = read_epochs(epochs_fnames[1], preload=True)
idx = np.searchsorted(epochs.events[:, 0],
epochs2.events[:, 0])
assert len(np.unique(idx)) == len(idx)
epochs = epochs[idx]
assert np.array_equal(epochs.events[:, 0],
epochs2.events[:, 0])
epochs2.pick_types(meg=True, eeg=True, exclude=[])
import matplotlib.pyplot as plt
plt.figure()
for eps in (epochs, epochs2):
eps = eps.get_data().transpose([1, 0, 2])
eps = eps.reshape(len(eps), -1)
plt.plot(
np.log10(np.maximum(linalg.svdvals(eps), 1e-50)))
epochs.plot()
baseline = _get_baseline(p)
epochs2.copy().crop(*baseline).plot()
raise RuntimeError('Error computing rank')
write_cov(cov_name, cov)
print()
def test_plot_cov():
"""Test plotting of covariances
"""
cov = read_cov(cov_fname)
plot_cov(cov, raw.info, proj=True)
