def _raise_bad_epochs(raw, epochs, events, kind=None, plot=True):
extra = '' if kind is None else f' of type {kind} '
if plot:
plot_drop_log(epochs.drop_log)
raw.plot(events=events)
raise RuntimeError(
f'Only {len(epochs)}/{len(events)} good epochs found{extra}')
def test_plot_drop_log():
"""Test plotting a drop log
"""
plot_drop_log(epochs.drop_log)
plot_drop_log([["One"], [], []])
plot_drop_log([["One"], ["Two"], []])
plot_drop_log([["One"], ["One", "Two"], []])
def test_plot_drop_log():
"""Test plotting a drop log
"""
plot_drop_log(epochs.drop_log)
plot_drop_log([['One'], [], []])
plot_drop_log([['One'], ['Two'], []])
plot_drop_log([['One'], ['One', 'Two'], []])
def test_plot_drop_log():
"""Test plotting a drop log
"""
plot_drop_log(epochs.drop_log)
plot_drop_log([['One'], [], []])
plot_drop_log([['One'], ['Two'], []])
plot_drop_log([['One'], ['One', 'Two'], []])
def test_plot_drop_log():
"""Test plotting a drop log
"""
epochs = _get_epochs()
epochs.drop_bad_epochs()
plot_drop_log(epochs.drop_log)
plot_drop_log([['One'], [], []])
plot_drop_log([['One'], ['Two'], []])
plot_drop_log([['One'], ['One', 'Two'], []])
plt.close('all')
def test_plot_drop_log():
"""Test plotting a drop log
"""
epochs = _get_epochs()
epochs.drop_bad_epochs()
plot_drop_log(epochs.drop_log)
plot_drop_log([['One'], [], []])
plot_drop_log([['One'], ['Two'], []])
plot_drop_log([['One'], ['One', 'Two'], []])
plt.close('all')
def test_plot_drop_log():
"""Test plotting a drop log."""
epochs = _get_epochs()
pytest.raises(ValueError, epochs.plot_drop_log)
epochs.drop_bad()
epochs.plot_drop_log()
plot_drop_log((('One', ), (), ()))
plot_drop_log((('One', ), ('Two', ), ()))
plot_drop_log((('One', ), ('One', 'Two'), ()))
for arg in ([], ([], ), (1, )):
with pytest.raises(TypeError, match='tuple of tuple of str'):
plot_drop_log(arg)
plt.close('all')
def test_plot_drop_log(epochs_unloaded):
"""Test plotting a drop log."""
with pytest.raises(ValueError, match='bad epochs have not yet been'):
epochs_unloaded.plot_drop_log()
epochs_unloaded.drop_bad()
epochs_unloaded.plot_drop_log()
plot_drop_log((('One', ), (), ()))
plot_drop_log((('One', ), ('Two', ), ()))
plot_drop_log((('One', ), ('One', 'Two'), ()))
for arg in ([], ([], ), (1, )):
with pytest.raises(TypeError, match='tuple of tuple of str'):
plot_drop_log(arg)
plt.close('all')
def test_plot_drop_log():
"""Test plotting a drop log."""
epochs = _get_epochs()
pytest.raises(ValueError, epochs.plot_drop_log)
epochs.drop_bad()
epochs.plot_drop_log()
plot_drop_log([['One'], [], []])
plot_drop_log([['One'], ['Two'], []])
plot_drop_log([['One'], ['One', 'Two'], []])
plt.close('all')
def test_plot_drop_log():
"""Test plotting a drop log."""
epochs = _get_epochs()
pytest.raises(ValueError, epochs.plot_drop_log)
epochs.drop_bad()
epochs.plot_drop_log()
plot_drop_log([['One'], [], []])
plot_drop_log([['One'], ['Two'], []])
plot_drop_log([['One'], ['One', 'Two'], []])
plt.close('all')
def test_plot_drop_log():
"""Test plotting a drop log
"""
epochs = _get_epochs()
epochs.drop_bad_epochs()
epochs.plot_drop_log()
plot_drop_log([["One"], [], []])
plot_drop_log([["One"], ["Two"], []])
plot_drop_log([["One"], ["One", "Two"], []])
plt.close("all")
def test_plot_drop_log():
"""Test plotting a drop log
"""
epochs = _get_epochs()
epochs.drop_bad_epochs()
warnings.simplefilter("always", UserWarning)
with warnings.catch_warnings(record=True):
epochs.plot_drop_log()
plot_drop_log([["One"], [], []])
plot_drop_log([["One"], ["Two"], []])
plot_drop_log([["One"], ["One", "Two"], []])
plt.close("all")
def test_plot_drop_log():
"""Test plotting a drop log
"""
epochs = _get_epochs()
epochs.drop_bad_epochs()
warnings.simplefilter('always', UserWarning)
with warnings.catch_warnings(record=True):
epochs.plot_drop_log()
plot_drop_log([['One'], [], []])
plot_drop_log([['One'], ['Two'], []])
plot_drop_log([['One'], ['One', 'Two'], []])
plt.close('all')
def test_plot_drop_log():
"""Test plotting a drop log
"""
epochs = _get_epochs()
epochs.drop_bad_epochs()
warnings.simplefilter('always', UserWarning)
with warnings.catch_warnings(record=True):
epochs.plot_drop_log()
plot_drop_log([['One'], [], []])
plot_drop_log([['One'], ['Two'], []])
plot_drop_log([['One'], ['One', 'Two'], []])
plt.close('all')
def test_plot_drop_log():
"""Test plotting a drop log."""
import matplotlib.pyplot as plt
epochs = _get_epochs()
assert_raises(ValueError, epochs.plot_drop_log)
epochs.drop_bad()
warnings.simplefilter('always', UserWarning)
with warnings.catch_warnings(record=True):
epochs.plot_drop_log()
plot_drop_log([['One'], [], []])
plot_drop_log([['One'], ['Two'], []])
plot_drop_log([['One'], ['One', 'Two'], []])
plt.close('all')
def test_plot_drop_log():
"""Test plotting a drop log."""
import matplotlib.pyplot as plt
epochs = _get_epochs()
assert_raises(ValueError, epochs.plot_drop_log)
epochs.drop_bad()
warnings.simplefilter('always', UserWarning)
with warnings.catch_warnings(record=True):
epochs.plot_drop_log()
plot_drop_log([['One'], [], []])
plot_drop_log([['One'], ['Two'], []])
plot_drop_log([['One'], ['One', 'Two'], []])
plt.close('all')
def test_plot_drop_log():
"""Test plotting a drop log
"""
import matplotlib.pyplot as plt
epochs = _get_epochs()
assert_raises(ValueError, epochs.plot_drop_log)
epochs.drop_bad_epochs()
warnings.simplefilter("always", UserWarning)
with warnings.catch_warnings(record=True):
epochs.plot_drop_log()
plot_drop_log([["One"], [], []])
plot_drop_log([["One"], ["Two"], []])
plot_drop_log([["One"], ["One", "Two"], []])
plt.close("all")
# Set up pick list: EEG + STI 014 - bad channels (modify to your needs)
include = [] # or stim channels ['STI 014']
raw.info['bads'] += ['EEG 053'] # bads + 1 more
# pick EEG channels
picks = fiff.pick_types(raw.info, meg=False, eeg=True, stim=False, eog=True,
include=include, exclude='bads')
# Read epochs
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=dict(eeg=80e-6, eog=150e-6))
evoked = epochs.average() # average epochs and get an Evoked dataset.
evoked.save('sample_audvis_eeg-ave.fif') # save evoked data to disk
###############################################################################
# View evoked response
times = 1e3 * epochs.times # time in miliseconds
import pylab as pl
pl.figure()
evoked.plot()
pl.xlim([times[0], times[-1]])
pl.xlabel('time (ms)')
pl.ylabel('Potential (uV)')
pl.title('EEG evoked potential')
pl.show()
# Look at channels that caused dropped events, showing that the subject's
# blinks were likely to blame for most epochs being dropped
epochs.drop_bad_epochs()
plot_drop_log(epochs.drop_log, subject='sample')
def save_epochs(p, subjects, in_names, in_numbers, analyses, out_names,
out_numbers, must_match, decim, run_indices):
"""Generate epochs from raw data based on events
Can only complete after preprocessing is complete.
Parameters
----------
p : instance of Parameters
Analysis parameters.
subjects : list of str
Subject names to analyze (e.g., ['Eric_SoP_001', ...]).
in_names : list of str
Names of input events.
in_numbers : list of list of int
Event numbers (in scored event files) associated with each name.
analyses : list of str
Lists of analyses of interest.
out_names : list of list of str
Event types to make out of old ones.
out_numbers : list of list of int
Event numbers to convert to (e.g., [[1, 1, 2, 3, 3], ...] would create
three event types, where the first two and last two event types from
the original list get collapsed over).
must_match : list of int
Indices from the original in_names that must match in event counts
before collapsing. Should eventually be expanded to allow for
ratio-based collapsing.
decim : int | list of int
Amount to decimate.
run_indices : array-like | None
Run indices to include.
"""
in_names = np.asanyarray(in_names)
old_dict = dict()
for n, e in zip(in_names, in_numbers):
old_dict[n] = e
# let's do some sanity checks
if len(in_names) != len(in_numbers):
raise RuntimeError('in_names (%d) must have same length as '
'in_numbers (%d)' %
(len(in_names), len(in_numbers)))
if np.any(np.array(in_numbers) <= 0):
raise ValueError('in_numbers must all be > 0')
if len(out_names) != len(out_numbers):
raise RuntimeError('out_names must have same length as out_numbers')
for name, num in zip(out_names, out_numbers):
num = np.array(num)
if len(name) != len(np.unique(num[num > 0])):
raise RuntimeError('each entry in out_names must have length '
'equal to the number of unique elements in the '
'corresponding entry in out_numbers:\n%s\n%s' %
(name, np.unique(num[num > 0])))
if len(num) != len(in_names):
raise RuntimeError('each entry in out_numbers must have the same '
'length as in_names')
if (np.array(num) == 0).any():
raise ValueError('no element of out_numbers can be zero')
ch_namess = list()
drop_logs = list()
sfreqs = set()
for si, subj in enumerate(subjects):
if p.disp_files:
print(' Loading raw files for subject %s.' % subj)
epochs_dir = op.join(p.work_dir, subj, p.epochs_dir)
if not op.isdir(epochs_dir):
os.mkdir(epochs_dir)
evoked_dir = op.join(p.work_dir, subj, p.inverse_dir)
if not op.isdir(evoked_dir):
os.mkdir(evoked_dir)
# read in raw files
raw_names = get_raw_fnames(p, subj, 'pca', False, False,
run_indices[si])
first_samps = []
last_samps = []
for raw_fname in raw_names:
raw = read_raw_fif(raw_fname, preload=False)
first_samps.append(raw._first_samps[0])
last_samps.append(raw._last_samps[-1])
raw = [read_raw_fif(fname, preload=False) for fname in raw_names]
_fix_raw_eog_cals(raw) # EOG epoch scales might be bad!
raw = concatenate_raws(raw)
# read in events
events = _read_events(p, subj, run_indices[si], raw)
this_decim = _handle_decim(decim[si], raw.info['sfreq'])
new_sfreq = raw.info['sfreq'] / this_decim
if p.disp_files:
print(' Epoching data (decim=%s -> sfreq=%0.1f Hz).' %
(this_decim, new_sfreq))
if new_sfreq not in sfreqs:
if len(sfreqs) > 0:
warnings.warn('resulting new sampling frequency %s not equal '
'to previous values %s' % (new_sfreq, sfreqs))
sfreqs.add(new_sfreq)
epochs_fnames, evoked_fnames = get_epochs_evokeds_fnames(
p, subj, analyses)
mat_file, fif_file = epochs_fnames
if p.autoreject_thresholds:
assert len(p.autoreject_types) > 0
assert all(a in ('mag', 'grad', 'eeg', 'ecg', 'eog')
for a in p.autoreject_types)
from autoreject import get_rejection_threshold
print(' Computing autoreject thresholds', end='')
rtmin = p.reject_tmin if p.reject_tmin is not None else p.tmin
rtmax = p.reject_tmax if p.reject_tmax is not None else p.tmax
temp_epochs = Epochs(raw,
events,
event_id=None,
tmin=rtmin,
tmax=rtmax,
baseline=_get_baseline(p),
proj=True,
reject=None,
flat=None,
preload=True,
decim=this_decim,
reject_by_annotation=p.reject_epochs_by_annot)
kwargs = dict()
if 'verbose' in get_args(get_rejection_threshold):
kwargs['verbose'] = False
new_dict = get_rejection_threshold(temp_epochs, **kwargs)
use_reject = dict()
msgs = list()
for k in p.autoreject_types:
msgs.append('%s=%d %s' % (k, DEFAULTS['scalings'][k] *
new_dict[k], DEFAULTS['units'][k]))
use_reject[k] = new_dict[k]
print(': ' + ', '.join(msgs))
hdf5_file = fif_file.replace('-epo.fif', '-reject.h5')
assert hdf5_file.endswith('.h5')
write_hdf5(hdf5_file, use_reject, overwrite=True)
else:
use_reject = _handle_dict(p.reject, subj)
# create epochs
flat = _handle_dict(p.flat, subj)
use_reject, use_flat = _restrict_reject_flat(use_reject, flat, raw)
epochs = Epochs(raw,
events,
event_id=old_dict,
tmin=p.tmin,
tmax=p.tmax,
baseline=_get_baseline(p),
reject=use_reject,
flat=use_flat,
proj=p.epochs_proj,
preload=True,
decim=this_decim,
on_missing=p.on_missing,
reject_tmin=p.reject_tmin,
reject_tmax=p.reject_tmax,
reject_by_annotation=p.reject_epochs_by_annot)
del raw
if epochs.events.shape[0] < 1:
epochs.plot_drop_log()
raise ValueError('No valid epochs')
drop_logs.append(epochs.drop_log)
ch_namess.append(epochs.ch_names)
# only kept trials that were not dropped
sfreq = epochs.info['sfreq']
# now deal with conditions to save evoked
if p.disp_files:
print(' Matching trial counts and saving data to disk.')
for var, name in ((out_names, 'out_names'), (out_numbers,
'out_numbers'),
(must_match, 'must_match'), (evoked_fnames,
'evoked_fnames')):
if len(var) != len(analyses):
raise ValueError('len(%s) (%s) != len(analyses) (%s)' %
(name, len(var), len(analyses)))
for analysis, names, numbers, match, fn in zip(analyses, out_names,
out_numbers, must_match,
evoked_fnames):
# do matching
numbers = np.asanyarray(numbers)
nn = numbers[numbers >= 0]
new_numbers = []
for num in numbers:
if num > 0 and num not in new_numbers:
# Eventually we could relax this requirement, but not
# having it in place is likely to cause people pain...
if any(num < n for n in new_numbers):
raise RuntimeError('each list of new_numbers must be '
' monotonically increasing')
new_numbers.append(num)
new_numbers = np.array(new_numbers)
in_names_match = in_names[match]
# use some variables to allow safe name re-use
offset = max(epochs.events[:, 2].max(), new_numbers.max()) + 1
safety_str = '__mnefun_copy__'
assert len(new_numbers) == len(names) # checked above
if p.match_fun is None:
# first, equalize trial counts (this will make a copy)
e = epochs[list(in_names[numbers > 0])]
if len(in_names_match) > 1:
e.equalize_event_counts(in_names_match)
# second, collapse relevant types
for num, name in zip(new_numbers, names):
collapse = [
x for x in in_names[num == numbers] if x in e.event_id
]
combine_event_ids(e,
collapse,
{name + safety_str: num + offset},
copy=False)
for num, name in zip(new_numbers, names):
e.events[e.events[:, 2] == num + offset, 2] -= offset
e.event_id[name] = num
del e.event_id[name + safety_str]
else: # custom matching
e = p.match_fun(epochs.copy(), analysis, nn, in_names_match,
names)
# now make evoked for each out type
evokeds = list()
n_standard = 0
kinds = ['standard']
if p.every_other:
kinds += ['even', 'odd']
for kind in kinds:
for name in names:
this_e = e[name]
if kind == 'even':
this_e = this_e[::2]
elif kind == 'odd':
this_e = this_e[1::2]
else:
assert kind == 'standard'
if len(this_e) > 0:
ave = this_e.average(picks='all')
stde = this_e.standard_error(picks='all')
if kind != 'standard':
ave.comment += ' %s' % (kind, )
stde.comment += ' %s' % (kind, )
evokeds.append(ave)
evokeds.append(stde)
if kind == 'standard':
n_standard += 2
write_evokeds(fn, evokeds)
naves = [
str(n) for n in sorted(
set([evoked.nave for evoked in evokeds[:n_standard]]))
]
naves = ', '.join(naves)
if p.disp_files:
print(' Analysis "%s": %s epochs / condition' %
(analysis, naves))
if p.disp_files:
print(' Saving epochs to disk.')
if 'mat' in p.epochs_type:
spio.savemat(mat_file,
dict(epochs=epochs.get_data(),
events=epochs.events,
sfreq=sfreq,
drop_log=epochs.drop_log),
do_compression=True,
oned_as='column')
if 'fif' in p.epochs_type:
epochs.save(fif_file, **_get_epo_kwargs())
if p.plot_drop_logs:
for subj, drop_log in zip(subjects, drop_logs):
plot_drop_log(drop_log, threshold=p.drop_thresh, subject=subj)
def do_preprocessing_combined(p, subjects, run_indices):
"""Do preprocessing on all raw files together.
Calculates projection vectors to use to clean data.
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.
"""
drop_logs = list()
for si, subj in enumerate(subjects):
proj_nums = _proj_nums(p, subj)
ecg_channel = _handle_dict(p.ecg_channel, subj)
flat = _handle_dict(p.flat, subj)
if p.disp_files:
print(' Preprocessing subject %g/%g (%s).' %
(si + 1, len(subjects), subj))
pca_dir = _get_pca_dir(p, subj)
bad_file = get_bad_fname(p, subj, check_exists=False)
# Create SSP projection vectors after marking bad channels
raw_names = get_raw_fnames(p, subj, 'sss', False, False,
run_indices[si])
empty_names = get_raw_fnames(p, subj, 'sss', 'only')
for r in raw_names + empty_names:
if not op.isfile(r):
raise NameError('File not found (' + r + ')')
fir_kwargs, old_kwargs = _get_fir_kwargs(p.fir_design)
if isinstance(p.auto_bad, float):
print(' Creating post SSS bad channel file:\n'
' %s' % bad_file)
# do autobad
raw = _raw_LRFCP(raw_names,
p.proj_sfreq,
None,
None,
p.n_jobs_fir,
p.n_jobs_resample,
list(),
None,
p.disp_files,
method='fir',
filter_length=p.filter_length,
apply_proj=False,
force_bads=False,
l_trans=p.hp_trans,
h_trans=p.lp_trans,
phase=p.phase,
fir_window=p.fir_window,
pick=True,
skip_by_annotation='edge',
**fir_kwargs)
events = fixed_len_events(p, raw)
rtmin = p.reject_tmin \
if p.reject_tmin is not None else p.tmin
rtmax = p.reject_tmax \
if p.reject_tmax is not None else p.tmax
# do not mark eog channels bad
meg, eeg = 'meg' in raw, 'eeg' in raw
picks = pick_types(raw.info,
meg=meg,
eeg=eeg,
eog=False,
exclude=[])
assert p.auto_bad_flat is None or isinstance(p.auto_bad_flat, dict)
assert p.auto_bad_reject is None or \
isinstance(p.auto_bad_reject, dict) or \
p.auto_bad_reject == 'auto'
if p.auto_bad_reject == 'auto':
print(' Auto bad channel selection active. '
'Will try using Autoreject module to '
'compute rejection criterion.')
try:
from autoreject import get_rejection_threshold
except ImportError:
raise ImportError(' Autoreject module not installed.\n'
' Noisy channel detection parameter '
' not defined. To use autobad '
' channel selection either define '
' rejection criteria or install '
' Autoreject module.\n')
print(' Computing thresholds.\n', end='')
temp_epochs = Epochs(raw,
events,
event_id=None,
tmin=rtmin,
tmax=rtmax,
baseline=_get_baseline(p),
proj=True,
reject=None,
flat=None,
preload=True,
decim=1)
kwargs = dict()
if 'verbose' in get_args(get_rejection_threshold):
kwargs['verbose'] = False
reject = get_rejection_threshold(temp_epochs, **kwargs)
reject = {kk: vv for kk, vv in reject.items()}
elif p.auto_bad_reject is None and p.auto_bad_flat is None:
raise RuntimeError('Auto bad channel detection active. Noisy '
'and flat channel detection '
'parameters not defined. '
'At least one criterion must be defined.')
else:
reject = p.auto_bad_reject
if 'eog' in reject.keys():
reject.pop('eog', None)
epochs = Epochs(raw,
events,
None,
tmin=rtmin,
tmax=rtmax,
baseline=_get_baseline(p),
picks=picks,
reject=reject,
flat=p.auto_bad_flat,
proj=True,
preload=True,
decim=1,
reject_tmin=rtmin,
reject_tmax=rtmax)
# channel scores from drop log
drops = Counter([ch for d in epochs.drop_log for ch in d])
# get rid of non-channel reasons in drop log
scores = {
kk: vv
for kk, vv in drops.items() if kk in epochs.ch_names
}
ch_names = np.array(list(scores.keys()))
# channel scores expressed as percentile and rank ordered
counts = (100 * np.array([scores[ch] for ch in ch_names], float) /
len(epochs.drop_log))
order = np.argsort(counts)[::-1]
# boolean array masking out channels with <= % epochs dropped
mask = counts[order] > p.auto_bad
badchs = ch_names[order[mask]]
if len(badchs) > 0:
# Make sure we didn't get too many bad MEG or EEG channels
for m, e, thresh in zip(
[True, False], [False, True],
[p.auto_bad_meg_thresh, p.auto_bad_eeg_thresh]):
picks = pick_types(epochs.info, meg=m, eeg=e, exclude=[])
if len(picks) > 0:
ch_names = [epochs.ch_names[pp] for pp in picks]
n_bad_type = sum(ch in ch_names for ch in badchs)
if n_bad_type > thresh:
stype = 'meg' if m else 'eeg'
raise RuntimeError('Too many bad %s channels '
'found: %s > %s' %
(stype, n_bad_type, thresh))
print(' The following channels resulted in greater than '
'{:.0f}% trials dropped:\n'.format(p.auto_bad * 100))
print(badchs)
with open(bad_file, 'w') as f:
f.write('\n'.join(badchs))
if not op.isfile(bad_file):
print(' Clearing bad channels (no file %s)' %
op.sep.join(bad_file.split(op.sep)[-3:]))
bad_file = None
ecg_t_lims = _handle_dict(p.ecg_t_lims, subj)
ecg_f_lims = p.ecg_f_lims
ecg_eve = op.join(pca_dir, 'preproc_ecg-eve.fif')
ecg_epo = op.join(pca_dir, 'preproc_ecg-epo.fif')
ecg_proj = op.join(pca_dir, 'preproc_ecg-proj.fif')
all_proj = op.join(pca_dir, 'preproc_all-proj.fif')
get_projs_from = _handle_dict(p.get_projs_from, subj)
if get_projs_from is None:
get_projs_from = np.arange(len(raw_names))
pre_list = [
r for ri, r in enumerate(raw_names) if ri in get_projs_from
]
projs = list()
raw_orig = _raw_LRFCP(raw_names=pre_list,
sfreq=p.proj_sfreq,
l_freq=None,
h_freq=None,
n_jobs=p.n_jobs_fir,
n_jobs_resample=p.n_jobs_resample,
projs=projs,
bad_file=bad_file,
disp_files=p.disp_files,
method='fir',
filter_length=p.filter_length,
force_bads=False,
l_trans=p.hp_trans,
h_trans=p.lp_trans,
phase=p.phase,
fir_window=p.fir_window,
pick=True,
skip_by_annotation='edge',
**fir_kwargs)
# Apply any user-supplied extra projectors
if p.proj_extra is not None:
if p.disp_files:
print(' Adding extra projectors from "%s".' % p.proj_extra)
projs.extend(read_proj(op.join(pca_dir, p.proj_extra)))
proj_kwargs, p_sl = _get_proj_kwargs(p)
#
# Calculate and apply ERM projectors
#
if not p.cont_as_esss:
if any(proj_nums[2]):
assert proj_nums[2][2] == 0 # no EEG projectors for ERM
if len(empty_names) == 0:
raise RuntimeError('Cannot compute empty-room projectors '
'from continuous raw data')
if p.disp_files:
print(' Computing continuous projectors using ERM.')
# Use empty room(s), but processed the same way
projs.extend(_compute_erm_proj(p, subj, projs, 'sss',
bad_file))
else:
cont_proj = op.join(pca_dir, 'preproc_cont-proj.fif')
_safe_remove(cont_proj)
#
# Calculate and apply the ECG projectors
#
if any(proj_nums[0]):
if p.disp_files:
print(' Computing ECG projectors...', end='')
raw = raw_orig.copy()
raw.filter(ecg_f_lims[0],
ecg_f_lims[1],
n_jobs=p.n_jobs_fir,
method='fir',
filter_length=p.filter_length,
l_trans_bandwidth=0.5,
h_trans_bandwidth=0.5,
phase='zero-double',
fir_window='hann',
skip_by_annotation='edge',
**old_kwargs)
raw.add_proj(projs)
raw.apply_proj()
find_kwargs = dict()
if 'reject_by_annotation' in get_args(find_ecg_events):
find_kwargs['reject_by_annotation'] = True
elif len(raw.annotations) > 0:
print(' WARNING: ECG event detection will not make use of '
'annotations, please update MNE-Python')
# We've already filtered the data channels above, but this
# filters the ECG channel
ecg_events = find_ecg_events(raw,
999,
ecg_channel,
0.,
ecg_f_lims[0],
ecg_f_lims[1],
qrs_threshold='auto',
return_ecg=False,
**find_kwargs)[0]
use_reject, use_flat = _restrict_reject_flat(
_handle_dict(p.ssp_ecg_reject, subj), flat, raw)
ecg_epochs = Epochs(raw,
ecg_events,
999,
ecg_t_lims[0],
ecg_t_lims[1],
baseline=None,
reject=use_reject,
flat=use_flat,
preload=True)
print(' obtained %d epochs from %d events.' %
(len(ecg_epochs), len(ecg_events)))
if len(ecg_epochs) >= 20:
write_events(ecg_eve, ecg_epochs.events)
ecg_epochs.save(ecg_epo, **_get_epo_kwargs())
desc_prefix = 'ECG-%s-%s' % tuple(ecg_t_lims)
pr = compute_proj_wrap(ecg_epochs,
p.proj_ave,
n_grad=proj_nums[0][0],
n_mag=proj_nums[0][1],
n_eeg=proj_nums[0][2],
desc_prefix=desc_prefix,
**proj_kwargs)
assert len(pr) == np.sum(proj_nums[0][::p_sl])
write_proj(ecg_proj, pr)
projs.extend(pr)
else:
plot_drop_log(ecg_epochs.drop_log)
raw.plot(events=ecg_epochs.events)
raise RuntimeError('Only %d/%d good ECG epochs found' %
(len(ecg_epochs), len(ecg_events)))
del raw, ecg_epochs, ecg_events
else:
_safe_remove([ecg_proj, ecg_eve, ecg_epo])
#
# Next calculate and apply the EOG projectors
#
for idx, kind in ((1, 'EOG'), (3, 'HEOG'), (4, 'VEOG')):
_compute_add_eog(p, subj, raw_orig, projs, proj_nums[idx], kind,
pca_dir, flat, proj_kwargs, old_kwargs, p_sl)
del proj_nums
# save the projectors
write_proj(all_proj, projs)
#
# Look at raw_orig for trial DQs now, it will be quick
#
raw_orig.filter(p.hp_cut,
p.lp_cut,
n_jobs=p.n_jobs_fir,
method='fir',
filter_length=p.filter_length,
l_trans_bandwidth=p.hp_trans,
phase=p.phase,
h_trans_bandwidth=p.lp_trans,
fir_window=p.fir_window,
skip_by_annotation='edge',
**fir_kwargs)
raw_orig.add_proj(projs)
raw_orig.apply_proj()
# now let's epoch with 1-sec windows to look for DQs
events = fixed_len_events(p, raw_orig)
reject = _handle_dict(p.reject, subj)
use_reject, use_flat = _restrict_reject_flat(reject, flat, raw_orig)
epochs = Epochs(raw_orig,
events,
None,
p.tmin,
p.tmax,
preload=False,
baseline=_get_baseline(p),
reject=use_reject,
flat=use_flat,
proj=True)
try:
epochs.drop_bad()
except AttributeError: # old way
epochs.drop_bad_epochs()
drop_logs.append(epochs.drop_log)
del raw_orig
del epochs
if p.plot_drop_logs:
for subj, drop_log in zip(subjects, drop_logs):
plot_drop_log(drop_log, p.drop_thresh, subject=subj)
