def run_ssp(subject):
print("Processing subject: %s" % subject)
meg_subject_dir = op.join(config.meg_dir, subject)
print(" Loading one run to compute SSPs")
# compute SSP on first run of raw
run = config.runs[0]
if config.use_maxwell_filter:
extension = run + '_sss_raw'
else:
extension = run + '_filt_raw'
raw_fname_in = op.join(meg_subject_dir,
config.base_fname.format(**locals()))
extension = run + '_ssp-proj'
proj_fname_out = op.join(meg_subject_dir,
config.base_fname.format(**locals()))
print("Input: ", raw_fname_in)
print("Output: ", proj_fname_out)
raw = mne.io.read_raw_fif(raw_fname_in)
# XXX : n_xxx should be options in config
print(" Computing SSPs for ECG")
ecg_projs, ecg_events = \
compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True)
print(" Computing SSPs for EOG")
eog_projs, eog_events = \
compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True)
mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
def run_ssp(subject):
print("processing subject: %s" % subject)
meg_subject_dir = op.join(config.meg_dir, subject)
print(" Loading runs")
for run in config.runs:
extension = run + '_sss_raw'
raw_fname_in = op.join(meg_subject_dir,
config.base_fname.format(**locals()))
proj_fname_out = op.splitext(raw_fname_in)[0] + '-proj.fif'
eve_ecg_fname_out = op.splitext(raw_fname_in)[0] + '_ecg-eve.fif'
eve_eog_fname_out = op.splitext(raw_fname_in)[0] + '_eog-eve.fif'
print("Input: ", raw_fname_in)
print("Output: ", proj_fname_out)
print("Output: ", eve_ecg_fname_out)
print("Output: ", eve_eog_fname_out)
raw = mne.io.read_raw_fif(raw_fname_in)
ecg_projs, ecg_events = \
compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True)
eog_projs, eog_events = \
compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True)
mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
mne.write_events(eve_ecg_fname_out, ecg_events)
mne.write_events(eve_eog_fname_out, eog_events)
def save_proj(projs, proj_save_loc, proj_fname, kind):
"""
:param kind: SSP projection channel kind (EOG, ECG)
"""
replace_dict = {'kind': kind}
proj_save_name = format_variable_names(replace_dict, proj_fname)
mne.write_proj(join(proj_save_loc, proj_save_name), projs)
def run_ssp(subject, session=None):
# compute SSP on first run of raw
run = config.get_runs()[0]
bids_path = BIDSPath(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=run,
recording=config.rec,
space=config.space,
extension='.fif',
datatype=config.get_datatype(),
root=config.deriv_root)
# Prepare a name to save the data
raw_fname_in = bids_path.copy().update(processing='filt',
suffix='raw',
check=False)
# when saving proj, use run=None
proj_fname_out = bids_path.copy().update(run=None,
suffix='proj',
check=False)
msg = f'Input: {raw_fname_in}, Output: {proj_fname_out}'
logger.info(
gen_log_message(message=msg, step=4, subject=subject, session=session))
if raw_fname_in.copy().update(split='01').fpath.exists():
raw_fname_in.update(split='01')
raw = mne.io.read_raw_fif(raw_fname_in)
# XXX : n_xxx should be options in config
msg = 'Computing SSPs for ECG'
logger.debug(
gen_log_message(message=msg, step=4, subject=subject, session=session))
ecg_projs, ecg_events = compute_proj_ecg(raw,
n_grad=1,
n_mag=1,
n_eeg=0,
average=True)
msg = 'Computing SSPs for EOG'
logger.debug(
gen_log_message(message=msg, step=4, subject=subject, session=session))
if config.eog_channels:
assert all(
[ch_name in raw.ch_names for ch_name in config.eog_channels])
ch_name = ','.join(config.eog_channels)
else:
ch_name = None
eog_projs, eog_events = compute_proj_eog(raw,
ch_name=ch_name,
n_grad=1,
n_mag=1,
n_eeg=1,
average=True)
mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
def run_ssp(subject, session=None):
print("Processing subject: %s" % subject)
print(" Loading one run to compute SSPs")
# Construct the search path for the data file. `sub` is mandatory
subject_path = op.join('sub-{}'.format(subject))
# `session` is optional
if session is not None:
subject_path = op.join(subject_path, 'ses-{}'.format(session))
subject_path = op.join(subject_path, config.kind)
# compute SSP on first run of raw
run = config.runs[0]
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.task,
acquisition=config.acq,
run=run,
processing=config.proc,
recording=config.rec,
space=config.space)
# Prepare a name to save the data
fpath_deriv = op.join(config.bids_root, 'derivatives',
config.PIPELINE_NAME, subject_path)
raw_fname_in = \
op.join(fpath_deriv, bids_basename + '_filt_raw.fif')
# when saving proj, use bids_basename=None
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.task,
acquisition=config.acq,
run=None,
processing=config.proc,
recording=config.rec,
space=config.space)
proj_fname_out = op.join(fpath_deriv, bids_basename + '_ssp-proj.fif')
print("Input: ", raw_fname_in)
print("Output: ", proj_fname_out)
raw = mne.io.read_raw_fif(raw_fname_in)
# XXX : n_xxx should be options in config
print(" Computing SSPs for ECG")
ecg_projs, ecg_events = \
compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True)
print(" Computing SSPs for EOG")
eog_projs, eog_events = \
compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True)
mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
def _compute_erm_proj(p,
subj,
projs,
kind,
bad_file,
remove_existing=False,
disp_files=None):
disp_files = p.disp_files if disp_files is None else disp_files
assert kind in ('sss', 'raw')
proj_nums = _proj_nums(p, subj)
proj_kwargs, p_sl = _get_proj_kwargs(p)
empty_names = get_raw_fnames(p, subj, kind, 'only')
fir_kwargs, _ = _get_fir_kwargs(p.fir_design)
flat = _handle_dict(p.flat, subj)
raw = _raw_LRFCP(raw_names=empty_names,
sfreq=p.proj_sfreq,
l_freq=p.cont_hp,
h_freq=p.cont_lp,
n_jobs=p.n_jobs_fir,
apply_proj=not remove_existing,
n_jobs_resample=p.n_jobs_resample,
projs=projs,
bad_file=bad_file,
disp_files=disp_files,
method='fir',
filter_length=p.filter_length,
force_bads=True,
l_trans=p.cont_hp_trans,
h_trans=p.cont_lp_trans,
phase=p.phase,
fir_window=p.fir_window,
skip_by_annotation='edge',
**fir_kwargs)
if remove_existing:
raw.del_proj()
raw.pick_types(meg=True, eeg=False, exclude=()) # remove EEG
use_reject = p.cont_reject
if use_reject is None:
use_reject = p.reject
use_reject, use_flat = _restrict_reject_flat(
_handle_dict(use_reject, subj), flat, raw)
pr = compute_proj_raw(raw,
duration=1,
n_grad=proj_nums[2][0],
n_mag=proj_nums[2][1],
n_eeg=proj_nums[2][2],
reject=use_reject,
flat=use_flat,
n_jobs=p.n_jobs_mkl,
**proj_kwargs)
assert len(pr) == np.sum(proj_nums[2][::p_sl])
# When doing eSSS it's a bit weird to put this in pca_dir but why not
pca_dir = _get_pca_dir(p, subj)
cont_proj = op.join(pca_dir, 'preproc_cont-proj.fif')
write_proj(cont_proj, pr)
return pr
def fit_ssp_ecg(raw, ecg_chs, savefile=None, verbose=False):
ecg_projs, ecg_events = mne.preprocessing.compute_proj_ecg(raw,
n_grad=1,
n_mag=1,
n_eeg=0,
no_proj=True,
ch_name=ecg_chs,
event_id=988,
verbose=verbose)
if savefile:
mne.write_proj(savefile, ecg_projs)
return ecg_projs, ecg_events
def _compute_add_eog(p, subj, raw_orig, projs, eog_nums, kind, pca_dir,
flat, extra_proj, old_kwargs, p_sl):
assert kind in ('EOG', 'HEOG', 'VEOG')
bk = dict(EOG='blink').get(kind, kind.lower())
eog_eve = op.join(pca_dir, f'preproc_{bk}-eve.fif')
eog_epo = op.join(pca_dir, f'preproc_{bk}-epo.fif')
eog_proj = op.join(pca_dir, f'preproc_{bk}-proj.fif')
eog_t_lims = _handle_dict(getattr(p, f'{kind.lower()}_t_lims'), subj)
eog_f_lims = _handle_dict(getattr(p, f'{kind.lower()}_f_lims'), subj)
eog_channel = _handle_dict(getattr(p, f'{kind.lower()}_channel'), subj)
thresh = _handle_dict(getattr(p, f'{kind.lower()}_thresh'), subj)
if eog_channel is None and kind != 'EOG':
eog_channel = 'EOG061' if kind == 'HEOG' else 'EOG062'
if eog_nums.any():
if p.disp_files:
print(f' Computing {kind} projectors...', end='')
raw = raw_orig.copy()
raw.filter(eog_f_lims[0], eog_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()
eog_events = find_eog_events(
raw, ch_name=eog_channel, reject_by_annotation=True,
thresh=thresh)
use_reject, use_flat = _restrict_reject_flat(
_handle_dict(p.ssp_eog_reject, subj), flat, raw)
eog_epochs = Epochs(
raw, eog_events, 998, eog_t_lims[0], eog_t_lims[1],
baseline=None, reject=use_reject, flat=use_flat, preload=True)
print(' obtained %d epochs from %d events.' % (len(eog_epochs),
len(eog_events)))
del eog_events
if len(eog_epochs) >= 5:
write_events(eog_eve, eog_epochs.events)
eog_epochs.save(eog_epo, **_get_epo_kwargs())
desc_prefix = f'{kind}-%s-%s' % tuple(eog_t_lims)
pr = compute_proj_wrap(
eog_epochs, p.proj_ave, n_grad=eog_nums[0],
n_mag=eog_nums[1], n_eeg=eog_nums[2],
desc_prefix=desc_prefix, **extra_proj)
assert len(pr) == np.sum(eog_nums[::p_sl])
write_proj(eog_proj, pr)
projs.extend(pr)
else:
warnings.warn('Only %d usable EOG events!' % len(eog_epochs))
_safe_remove([eog_proj, eog_eve, eog_epo])
del raw, eog_epochs
else:
_safe_remove([eog_proj, eog_eve, eog_epo])
def run_ssp(subject, session=None):
deriv_path = config.get_subject_deriv_path(subject=subject,
session=session,
kind=config.get_kind())
# compute SSP on first run of raw
run = config.get_runs()[0]
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=run,
processing=config.proc,
recording=config.rec,
space=config.space)
# Prepare a name to save the data
raw_fname_in = op.join(deriv_path, bids_basename + '_filt_raw.fif')
# when saving proj, use bids_basename=None
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=None,
processing=config.proc,
recording=config.rec,
space=config.space)
proj_fname_out = op.join(deriv_path, bids_basename + '_ssp-proj.fif')
msg = f'Input: {raw_fname_in}, Output: {proj_fname_out}'
logger.info(
gen_log_message(message=msg, step=4, subject=subject, session=session))
raw = mne.io.read_raw_fif(raw_fname_in)
# XXX : n_xxx should be options in config
msg = 'Computing SSPs for ECG'
logger.debug(
gen_log_message(message=msg, step=4, subject=subject, session=session))
ecg_projs, ecg_events = \
compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True)
msg = 'Computing SSPs for EOG'
logger.debug(
gen_log_message(message=msg, step=4, subject=subject, session=session))
eog_projs, eog_events = \
compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True)
mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
def run_ssp(subject, session=None):
deriv_path = config.get_subject_deriv_path(subject=subject,
session=session,
kind=config.get_kind())
# compute SSP on first run of raw
run = config.get_runs()[0]
bids_basename = BIDSPath(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=run,
recording=config.rec,
space=config.space,
prefix=deriv_path)
# Prepare a name to save the data
raw_fname_in = bids_basename.copy().update(processing='filt',
kind=config.get_kind(),
extension='.fif')
# when saving proj, use run=None
proj_fname_out = bids_basename.copy().update(run=None,
kind='proj',
extension='.fif',
check=False)
msg = f'Input: {raw_fname_in}, Output: {proj_fname_out}'
logger.info(
gen_log_message(message=msg, step=4, subject=subject, session=session))
raw = mne.io.read_raw_fif(raw_fname_in)
# XXX : n_xxx should be options in config
msg = 'Computing SSPs for ECG'
logger.debug(
gen_log_message(message=msg, step=4, subject=subject, session=session))
ecg_projs, ecg_events = \
compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True)
msg = 'Computing SSPs for EOG'
logger.debug(
gen_log_message(message=msg, step=4, subject=subject, session=session))
eog_projs, eog_events = \
compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True)
mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
def preproc_gen_ssp(subj_fold, raw, hcp_params, annots):
"""Helper to apply artifact removal on raw data
NOTE: Only use this on one run of data to create projectors. Subsequent
runs should load and apply the same projectors. This is required to make
sure machine learning algorithm isn't classifying differences in projectors
(like the ICA projectors shipped with HCP) instead of differences in
activity."""
proj_dir = op.join(hcp_path, subj_fold, 'ssp_pca_fif')
check_and_create_dir(proj_dir)
# Compute EOG and ECG projectors
# XXX Note: do not add these to raw obj, as all raw files need to use the
# same projectors. Instead, save and then reapply later
preproc.set_eog_ecg_channels(raw)
proj_eog1, eog_events1 = compute_proj_eog(raw, ch_name='HEOG', n_jobs=-1)
proj_eog2, eog_events2 = compute_proj_eog(raw, ch_name='VEOG', n_jobs=-1)
proj_ecg, ecg_events = compute_proj_ecg(raw, ch_name='ECG', n_jobs=-1)
# Save to disk so these can be used in future processing
all_projs = proj_eog1 + proj_eog2 + proj_ecg
write_proj(op.join(proj_dir, 'preproc_all-proj.fif'), all_projs)
def fit_ssp_eog(raw, eog_chs, savefile=None, verbose=False):
eog_projs_source1, eog_events_source1 = mne.preprocessing.compute_proj_eog(
raw,
n_grad=1,
n_mag=1,
n_eeg=0,
no_proj=True,
ch_name=eog_chs[0],
event_id=990,
verbose=verbose)
eog_projs_source2, eog_events_source2 = mne.preprocessing.compute_proj_eog(
raw,
n_grad=1,
n_mag=1,
n_eeg=0,
no_proj=True,
ch_name=eog_chs[1],
event_id=991,
verbose=verbose)
eog_projs = eog_projs_source1 + eog_projs_source2
eog_events = np.vstack((eog_events_source1, eog_events_source2))
if savefile:
mne.write_proj(savefile, eog_projs)
return eog_projs, eog_events
reject=reject,
flat=flat,
bads=bads,
avg_ref=avg_ref,
no_proj=no_proj,
event_id=event_id,
eog_l_freq=eog_l_freq,
eog_h_freq=eog_h_freq,
tstart=tstart,
ch_name=ch_name,
copy=False)
raw.close()
if raw_event_fname is not None:
raw_event.close()
if proj_fname is not None:
print('Including SSP projections from : %s' % proj_fname)
# append the eog projs, so they are last in the list
projs = mne.read_proj(proj_fname) + projs
if isinstance(preload, string_types) and os.path.exists(preload):
os.remove(preload)
print("Writing EOG projections in %s" % eog_proj_fname)
mne.write_proj(eog_proj_fname, projs)
print("Writing EOG events in %s" % eog_event_fname)
mne.write_events(eog_event_fname, events)
def run():
"""Run command."""
from mne.commands.utils import get_optparser
parser = get_optparser(__file__)
parser.add_option("-i", "--in", dest="raw_in",
help="Input raw FIF file", metavar="FILE")
parser.add_option("--tmin", dest="tmin", type="float",
help="Time before event in seconds",
default=-0.2)
parser.add_option("--tmax", dest="tmax", type="float",
help="Time after event in seconds",
default=0.4)
parser.add_option("-g", "--n-grad", dest="n_grad", type="int",
help="Number of SSP vectors for gradiometers",
default=2)
parser.add_option("-m", "--n-mag", dest="n_mag", type="int",
help="Number of SSP vectors for magnetometers",
default=2)
parser.add_option("-e", "--n-eeg", dest="n_eeg", type="int",
help="Number of SSP vectors for EEG",
default=2)
parser.add_option("--l-freq", dest="l_freq", type="float",
help="Filter low cut-off frequency in Hz",
default=1)
parser.add_option("--h-freq", dest="h_freq", type="float",
help="Filter high cut-off frequency in Hz",
default=100)
parser.add_option("--ecg-l-freq", dest="ecg_l_freq", type="float",
help="Filter low cut-off frequency in Hz used "
"for ECG event detection",
default=5)
parser.add_option("--ecg-h-freq", dest="ecg_h_freq", type="float",
help="Filter high cut-off frequency in Hz used "
"for ECG event detection",
default=35)
parser.add_option("-p", "--preload", dest="preload",
help="Temporary file used during computation "
"(to save memory)",
default=True)
parser.add_option("-a", "--average", dest="average", action="store_true",
help="Compute SSP after averaging",
default=False) # XXX: change to default=True in 0.17
parser.add_option("--proj", dest="proj",
help="Use SSP projections from a fif file.",
default=None)
parser.add_option("--filtersize", dest="filter_length", type="int",
help="Number of taps to use for filtering",
default=2048)
parser.add_option("-j", "--n-jobs", dest="n_jobs", type="int",
help="Number of jobs to run in parallel",
default=1)
parser.add_option("-c", "--channel", dest="ch_name",
help="Channel to use for ECG detection "
"(Required if no ECG found)",
default=None)
parser.add_option("--rej-grad", dest="rej_grad", type="float",
help="Gradiometers rejection parameter "
"in fT/cm (peak to peak amplitude)",
default=2000)
parser.add_option("--rej-mag", dest="rej_mag", type="float",
help="Magnetometers rejection parameter "
"in fT (peak to peak amplitude)",
default=3000)
parser.add_option("--rej-eeg", dest="rej_eeg", type="float",
help="EEG rejection parameter in uV "
"(peak to peak amplitude)",
default=50)
parser.add_option("--rej-eog", dest="rej_eog", type="float",
help="EOG rejection parameter in uV "
"(peak to peak amplitude)",
default=250)
parser.add_option("--avg-ref", dest="avg_ref", action="store_true",
help="Add EEG average reference proj",
default=False)
parser.add_option("--no-proj", dest="no_proj", action="store_true",
help="Exclude the SSP projectors currently "
"in the fiff file",
default=False)
parser.add_option("--bad", dest="bad_fname",
help="Text file containing bad channels list "
"(one per line)",
default=None)
parser.add_option("--event-id", dest="event_id", type="int",
help="ID to use for events",
default=999)
parser.add_option("--event-raw", dest="raw_event_fname",
help="raw file to use for event detection",
default=None)
parser.add_option("--tstart", dest="tstart", type="float",
help="Start artifact detection after tstart seconds",
default=0.)
parser.add_option("--qrsthr", dest="qrs_threshold", type="string",
help="QRS detection threshold. Between 0 and 1. Can "
"also be 'auto' for automatic selection",
default='auto')
options, args = parser.parse_args()
raw_in = options.raw_in
if raw_in is None:
parser.print_help()
sys.exit(1)
tmin = options.tmin
tmax = options.tmax
n_grad = options.n_grad
n_mag = options.n_mag
n_eeg = options.n_eeg
l_freq = options.l_freq
h_freq = options.h_freq
ecg_l_freq = options.ecg_l_freq
ecg_h_freq = options.ecg_h_freq
average = options.average
preload = options.preload
filter_length = options.filter_length
n_jobs = options.n_jobs
ch_name = options.ch_name
reject = dict(grad=1e-13 * float(options.rej_grad),
mag=1e-15 * float(options.rej_mag),
eeg=1e-6 * float(options.rej_eeg),
eog=1e-6 * float(options.rej_eog))
avg_ref = options.avg_ref
no_proj = options.no_proj
bad_fname = options.bad_fname
event_id = options.event_id
proj_fname = options.proj
raw_event_fname = options.raw_event_fname
tstart = options.tstart
qrs_threshold = options.qrs_threshold
if qrs_threshold != 'auto':
try:
qrs_threshold = float(qrs_threshold)
except ValueError:
raise ValueError('qrsthr must be "auto" or a float')
if bad_fname is not None:
with open(bad_fname, 'r') as fid:
bads = [w.rstrip() for w in fid.readlines()]
print('Bad channels read : %s' % bads)
else:
bads = []
if raw_in.endswith('_raw.fif') or raw_in.endswith('-raw.fif'):
prefix = raw_in[:-8]
else:
prefix = raw_in[:-4]
ecg_event_fname = prefix + '_ecg-eve.fif'
if average:
ecg_proj_fname = prefix + '_ecg_avg-proj.fif'
else:
ecg_proj_fname = prefix + '_ecg-proj.fif'
raw = mne.io.read_raw_fif(raw_in, preload=preload)
if raw_event_fname is not None:
raw_event = mne.io.read_raw_fif(raw_event_fname)
else:
raw_event = raw
flat = None # XXX : not exposed to the user
projs, events = mne.preprocessing.compute_proj_ecg(
raw, raw_event, tmin, tmax, n_grad, n_mag, n_eeg, l_freq, h_freq,
average, filter_length, n_jobs, ch_name, reject, flat, bads, avg_ref,
no_proj, event_id, ecg_l_freq, ecg_h_freq, tstart, qrs_threshold,
copy=False)
raw.close()
if raw_event_fname is not None:
raw_event.close()
if proj_fname is not None:
print('Including SSP projections from : %s' % proj_fname)
# append the ecg projs, so they are last in the list
projs = mne.read_proj(proj_fname) + projs
if isinstance(preload, str) and os.path.exists(preload):
os.remove(preload)
print("Writing ECG projections in %s" % ecg_proj_fname)
mne.write_proj(ecg_proj_fname, projs)
print("Writing ECG events in %s" % ecg_event_fname)
mne.write_events(ecg_event_fname, events)
def compute_proj_eog(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg, l_freq, h_freq, average, filter_length, n_jobs, ch_name, reject, avg_ref, bads, preload):
#####Defining filenames
if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'):
prefix = in_fif_fname[:-8]
else:
prefix = in_fif_fname[:-4]
eog_event_fname = in_path + 'ssp/'+ prefix + '_PYeog-eve.fif'
if average:
eog_proj_fname = in_path + 'ssp/' + prefix + '_eog_avg_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_eog_avg_proj_raw.fif'
else:
eog_proj_fname = in_path + 'ssp/' + prefix + '_PYeog_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_PYeog_proj_raw.fif'
####Reading in raw data
in_fif_fname = in_path + in_fif_fname
raw = mne.fiff.Raw(in_fif_fname, preload=preload)
print 'Running EOG SSP computation'
eog_events, _= mne.artifacts.find_eog_events(raw) # since our copy of the mne.artifacts.events.py script returns two parameters.
print "Writing EOG events in %s" % eog_event_fname
mne.write_events(eog_event_fname, eog_events)
make_lingua(eog_event_fname)
print 'Computing EOG projector'
# Handler rejection parameters
if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False, ecg=False)) == 0:
del reject['grad']
if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False, ecg=False)) == 0:
del reject['mag']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, ecg=False)) == 0:
del reject['eeg']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, ecg=True)) == 0:
del reject['ecg']
picks_eog = mne.fiff.pick_types(raw.info, meg=True, eeg=True, ecg=True,
exclude=raw.info['bads'] + bads)
if l_freq is None and h_freq is not None:
raw.high_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is None:
raw.low_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is not None:
raw.band_pass_filter(picks_eog, l_freq, h_freq, filter_length, n_jobs)
epochs_eog = mne.Epochs(raw, eog_events, None, tmin, tmax, baseline=None,
picks=picks_eog, reject=reject, proj=True)
projs_init = raw.info['projs']
if average:
evoked_eog = epochs_eog.average()
projs_eog = mne.compute_proj_evoked(evoked_eog, n_grad=n_grad, n_mag=n_mag,
n_eeg=n_eeg)
else:
print epochs_eog, n_grad, n_mag, n_eeg
projs_eog = mne.compute_proj_epochs(epochs_eog, n_grad=n_grad, n_mag=n_mag,
n_eeg=n_eeg)
print "Writing EOG projections in %s" % eog_proj_fname
mne.write_proj(eog_proj_fname, projs_eog)
return in_fif_fname, eog_proj_fname, out_fif_fname
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)
def compute_proj_eog(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg,
l_freq, h_freq, average, filter_length, n_jobs, ch_name,
reject, avg_ref, bads, preload):
#####Defining filenames
if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'):
prefix = in_fif_fname[:-8]
else:
prefix = in_fif_fname[:-4]
eog_event_fname = in_path + 'ssp/' + prefix + '_PYeog-eve.fif'
if average:
eog_proj_fname = in_path + 'ssp/' + prefix + '_eog_avg_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_eog_avg_proj_raw.fif'
else:
eog_proj_fname = in_path + 'ssp/' + prefix + '_PYeog_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_PYeog_proj_raw.fif'
####Reading in raw data
in_fif_fname = in_path + in_fif_fname
raw = mne.fiff.Raw(in_fif_fname, preload=preload)
print 'Running EOG SSP computation'
eog_events, _ = mne.artifacts.find_eog_events(
raw
) # since our copy of the mne.artifacts.events.py script returns two parameters.
print "Writing EOG events in %s" % eog_event_fname
mne.write_events(eog_event_fname, eog_events)
make_lingua(eog_event_fname)
print 'Computing EOG projector'
# Handler rejection parameters
if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False,
ecg=False)) == 0:
del reject['grad']
if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False,
ecg=False)) == 0:
del reject['mag']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, ecg=False)) == 0:
del reject['eeg']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, ecg=True)) == 0:
del reject['ecg']
picks_eog = mne.fiff.pick_types(raw.info,
meg=True,
eeg=True,
ecg=True,
exclude=raw.info['bads'] + bads)
if l_freq is None and h_freq is not None:
raw.high_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is None:
raw.low_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is not None:
raw.band_pass_filter(picks_eog, l_freq, h_freq, filter_length, n_jobs)
epochs_eog = mne.Epochs(raw,
eog_events,
None,
tmin,
tmax,
baseline=None,
picks=picks_eog,
reject=reject,
proj=True)
projs_init = raw.info['projs']
if average:
evoked_eog = epochs_eog.average()
projs_eog = mne.compute_proj_evoked(evoked_eog,
n_grad=n_grad,
n_mag=n_mag,
n_eeg=n_eeg)
else:
print epochs_eog, n_grad, n_mag, n_eeg
projs_eog = mne.compute_proj_epochs(epochs_eog,
n_grad=n_grad,
n_mag=n_mag,
n_eeg=n_eeg)
print "Writing EOG projections in %s" % eog_proj_fname
mne.write_proj(eog_proj_fname, projs_eog)
return in_fif_fname, eog_proj_fname, out_fif_fname
def compute_proj_ecg(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg,
l_freq, h_freq, average, filter_length, n_jobs, ch_name,
reject, avg_ref, bads, preload, flat):
"""Compute SSP/PCA projections for ECG/EOG artifacts
Parameters
----------
in_fif_fname: string
Raw fif File
XXX
"""
if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'):
prefix = in_fif_fname[:-8]
else:
prefix = in_fif_fname[:-4]
ecg_event_fname = in_path + 'ssp/' + prefix + '_ecg-eve.fif'
if average:
ecg_proj_fname = in_path + 'ssp/' + prefix + '_ecg_avg_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_ecg_avg_proj_raw.fif'
else:
ecg_proj_fname = in_path + 'ssp/' + prefix + '_ecg_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_ecg_proj_raw.fif'
print 'Reading fif File'
in_fif_fname = in_path + in_fif_fname
raw = mne.fiff.Raw(in_fif_fname, preload=preload)
# if (in_path == '/cluster/kuperberg/SemPrMM/MEG/data/ya30/'):
# save after 84s of MEG data in FIF file
# raw = raw[: , 84:]
#raw.save('sample_audvis_meg_raw.fif', tmin=84)
print 'Running ECG SSP computation'
ecg_events, _, _ = mne.artifacts.find_ecg_events(raw, ch_name=ch_name)
print "Writing ECG events in %s" % ecg_event_fname
mne.write_events(ecg_event_fname, ecg_events)
make_lingua(ecg_event_fname)
if avg_ref:
print "Adding average EEG reference projection."
eeg_proj = mne.fiff.proj.make_eeg_average_ref_proj(raw.info)
raw.info['projs'].append(eeg_proj)
print 'Computing ECG projector'
# Handler rejection parameters
if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False,
eog=False)) == 0:
del reject['grad']
if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False,
eog=False)) == 0:
del reject['mag']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, eog=False)) == 0:
del reject['eeg']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, eog=True)) == 0:
del reject['eog']
picks = mne.fiff.pick_types(raw.info,
meg=True,
eeg=True,
eog=True,
exclude=raw.info['bads'] + bads)
if l_freq is None and h_freq is not None:
raw.high_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is None:
raw.low_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is not None:
raw.band_pass_filter(picks, l_freq, h_freq, filter_length, n_jobs)
epochs_ecg = mne.Epochs(raw,
ecg_events,
None,
tmin,
tmax,
baseline=None,
picks=picks,
reject=reject,
proj=True)
print epochs_ecg
projs_init = raw.info['projs']
if average:
evoked_ecg = epochs_ecg.average()
projs_ecg = mne.compute_proj_evoked(evoked_ecg,
n_grad=n_grad,
n_mag=n_mag,
n_eeg=n_eeg)
else:
print epochs_ecg, n_grad, n_mag, n_eeg
projs_ecg = mne.compute_proj_epochs(epochs_ecg,
n_grad=n_grad,
n_mag=n_mag,
n_eeg=n_eeg)
print "Writing ECG projections in %s" % ecg_proj_fname
mne.write_proj(
ecg_proj_fname, projs_ecg + projs_init
) ## Original Projections written along with the ecg projections.
print "Writing ECG projections in %s" % ecg_proj_fname
mne.write_proj(ecg_proj_fname, projs_ecg)
return in_fif_fname, ecg_proj_fname, out_fif_fname
def run():
from mne.commands.utils import get_optparser
parser = get_optparser(__file__)
parser.add_option("-i",
"--in",
dest="raw_in",
help="Input raw FIF file",
metavar="FILE")
parser.add_option("--tmin",
dest="tmin",
type="float",
help="Time before event in seconds",
default=-0.2)
parser.add_option("--tmax",
dest="tmax",
type="float",
help="Time after event in seconds",
default=0.2)
parser.add_option("-g",
"--n-grad",
dest="n_grad",
type="int",
help="Number of SSP vectors for gradiometers",
default=2)
parser.add_option("-m",
"--n-mag",
dest="n_mag",
type="int",
help="Number of SSP vectors for magnetometers",
default=2)
parser.add_option("-e",
"--n-eeg",
dest="n_eeg",
type="int",
help="Number of SSP vectors for EEG",
default=2)
parser.add_option("--l-freq",
dest="l_freq",
type="float",
help="Filter low cut-off frequency in Hz",
default=1)
parser.add_option("--h-freq",
dest="h_freq",
type="float",
help="Filter high cut-off frequency in Hz",
default=35)
parser.add_option("--eog-l-freq",
dest="eog_l_freq",
type="float",
help="Filter low cut-off frequency in Hz used for "
"EOG event detection",
default=1)
parser.add_option("--eog-h-freq",
dest="eog_h_freq",
type="float",
help="Filter high cut-off frequency in Hz used for "
"EOG event detection",
default=10)
parser.add_option("-p",
"--preload",
dest="preload",
help="Temporary file used during computation (to "
"save memory)",
default=True)
parser.add_option("-a",
"--average",
dest="average",
action="store_true",
help="Compute SSP after averaging",
default=False)
parser.add_option("--proj",
dest="proj",
help="Use SSP projections from a fif file.",
default=None)
parser.add_option("--filtersize",
dest="filter_length",
type="int",
help="Number of taps to use for filtering",
default=2048)
parser.add_option("-j",
"--n-jobs",
dest="n_jobs",
type="int",
help="Number of jobs to run in parallel",
default=1)
parser.add_option("--rej-grad",
dest="rej_grad",
type="float",
help="Gradiometers rejection parameter in fT/cm (peak "
"to peak amplitude)",
default=2000)
parser.add_option("--rej-mag",
dest="rej_mag",
type="float",
help="Magnetometers rejection parameter in fT (peak to "
"peak amplitude)",
default=3000)
parser.add_option("--rej-eeg",
dest="rej_eeg",
type="float",
help="EEG rejection parameter in uV (peak to peak "
"amplitude)",
default=50)
parser.add_option("--rej-eog",
dest="rej_eog",
type="float",
help="EOG rejection parameter in uV (peak to peak "
"amplitude)",
default=1e9)
parser.add_option("--avg-ref",
dest="avg_ref",
action="store_true",
help="Add EEG average reference proj",
default=False)
parser.add_option("--no-proj",
dest="no_proj",
action="store_true",
help="Exclude the SSP projectors currently in the "
"fiff file",
default=False)
parser.add_option("--bad",
dest="bad_fname",
help="Text file containing bad channels list "
"(one per line)",
default=None)
parser.add_option("--event-id",
dest="event_id",
type="int",
help="ID to use for events",
default=998)
parser.add_option("--event-raw",
dest="raw_event_fname",
help="raw file to use for event detection",
default=None)
parser.add_option("--tstart",
dest="tstart",
type="float",
help="Start artifact detection after tstart seconds",
default=0.)
parser.add_option("-c",
"--channel",
dest="ch_name",
type="string",
help="Custom EOG channel(s), comma separated",
default=None)
options, args = parser.parse_args()
raw_in = options.raw_in
if raw_in is None:
parser.print_help()
sys.exit(1)
tmin = options.tmin
tmax = options.tmax
n_grad = options.n_grad
n_mag = options.n_mag
n_eeg = options.n_eeg
l_freq = options.l_freq
h_freq = options.h_freq
eog_l_freq = options.eog_l_freq
eog_h_freq = options.eog_h_freq
average = options.average
preload = options.preload
filter_length = options.filter_length
n_jobs = options.n_jobs
reject = dict(grad=1e-13 * float(options.rej_grad),
mag=1e-15 * float(options.rej_mag),
eeg=1e-6 * float(options.rej_eeg),
eog=1e-6 * float(options.rej_eog))
avg_ref = options.avg_ref
no_proj = options.no_proj
bad_fname = options.bad_fname
event_id = options.event_id
proj_fname = options.proj
raw_event_fname = options.raw_event_fname
tstart = options.tstart
ch_name = options.ch_name
if bad_fname is not None:
with open(bad_fname, 'r') as fid:
bads = [w.rstrip() for w in fid.readlines()]
print('Bad channels read : %s' % bads)
else:
bads = []
if raw_in.endswith('_raw.fif') or raw_in.endswith('-raw.fif'):
prefix = raw_in[:-8]
else:
prefix = raw_in[:-4]
eog_event_fname = prefix + '_eog-eve.fif'
if average:
eog_proj_fname = prefix + '_eog_avg-proj.fif'
else:
eog_proj_fname = prefix + '_eog-proj.fif'
raw = mne.io.Raw(raw_in, preload=preload)
if raw_event_fname is not None:
raw_event = mne.io.Raw(raw_event_fname)
else:
raw_event = raw
flat = None # XXX : not exposed to the user
projs, events = mne.preprocessing.compute_proj_eog(
raw=raw,
raw_event=raw_event,
tmin=tmin,
tmax=tmax,
n_grad=n_grad,
n_mag=n_mag,
n_eeg=n_eeg,
l_freq=l_freq,
h_freq=h_freq,
average=average,
filter_length=filter_length,
n_jobs=n_jobs,
reject=reject,
flat=flat,
bads=bads,
avg_ref=avg_ref,
no_proj=no_proj,
event_id=event_id,
eog_l_freq=eog_l_freq,
eog_h_freq=eog_h_freq,
tstart=tstart,
ch_name=ch_name,
copy=False)
raw.close()
if raw_event_fname is not None:
raw_event.close()
if proj_fname is not None:
print('Including SSP projections from : %s' % proj_fname)
# append the eog projs, so they are last in the list
projs = mne.read_proj(proj_fname) + projs
if isinstance(preload, string_types) and os.path.exists(preload):
os.remove(preload)
print("Writing EOG projections in %s" % eog_proj_fname)
mne.write_proj(eog_proj_fname, projs)
print("Writing EOG events in %s" % eog_event_fname)
mne.write_events(eog_event_fname, events)
def run():
"""Run command."""
from mne.commands.utils import get_optparser
parser = get_optparser(__file__)
parser.add_option("-i", "--in", dest="raw_in",
help="Input raw FIF file", metavar="FILE")
parser.add_option("--tmin", dest="tmin", type="float",
help="Time before event in seconds", default=-0.2)
parser.add_option("--tmax", dest="tmax", type="float",
help="Time after event in seconds", default=0.2)
parser.add_option("-g", "--n-grad", dest="n_grad", type="int",
help="Number of SSP vectors for gradiometers",
default=2)
parser.add_option("-m", "--n-mag", dest="n_mag", type="int",
help="Number of SSP vectors for magnetometers",
default=2)
parser.add_option("-e", "--n-eeg", dest="n_eeg", type="int",
help="Number of SSP vectors for EEG", default=2)
parser.add_option("--l-freq", dest="l_freq", type="float",
help="Filter low cut-off frequency in Hz",
default=1)
parser.add_option("--h-freq", dest="h_freq", type="float",
help="Filter high cut-off frequency in Hz",
default=35)
parser.add_option("--eog-l-freq", dest="eog_l_freq", type="float",
help="Filter low cut-off frequency in Hz used for "
"EOG event detection", default=1)
parser.add_option("--eog-h-freq", dest="eog_h_freq", type="float",
help="Filter high cut-off frequency in Hz used for "
"EOG event detection", default=10)
parser.add_option("-p", "--preload", dest="preload",
help="Temporary file used during computation (to "
"save memory)", default=True)
parser.add_option("-a", "--average", dest="average", action="store_true",
help="Compute SSP after averaging",
default=False) # XXX: change to default=True in 0.17
parser.add_option("--proj", dest="proj",
help="Use SSP projections from a fif file.",
default=None)
parser.add_option("--filtersize", dest="filter_length", type="int",
help="Number of taps to use for filtering",
default=2048)
parser.add_option("-j", "--n-jobs", dest="n_jobs", type="int",
help="Number of jobs to run in parallel", default=1)
parser.add_option("--rej-grad", dest="rej_grad", type="float",
help="Gradiometers rejection parameter in fT/cm (peak "
"to peak amplitude)", default=2000)
parser.add_option("--rej-mag", dest="rej_mag", type="float",
help="Magnetometers rejection parameter in fT (peak to "
"peak amplitude)", default=3000)
parser.add_option("--rej-eeg", dest="rej_eeg", type="float",
help="EEG rejection parameter in uV (peak to peak "
"amplitude)", default=50)
parser.add_option("--rej-eog", dest="rej_eog", type="float",
help="EOG rejection parameter in uV (peak to peak "
"amplitude)", default=1e9)
parser.add_option("--avg-ref", dest="avg_ref", action="store_true",
help="Add EEG average reference proj",
default=False)
parser.add_option("--no-proj", dest="no_proj", action="store_true",
help="Exclude the SSP projectors currently in the "
"fiff file", default=False)
parser.add_option("--bad", dest="bad_fname",
help="Text file containing bad channels list "
"(one per line)", default=None)
parser.add_option("--event-id", dest="event_id", type="int",
help="ID to use for events", default=998)
parser.add_option("--event-raw", dest="raw_event_fname",
help="raw file to use for event detection", default=None)
parser.add_option("--tstart", dest="tstart", type="float",
help="Start artifact detection after tstart seconds",
default=0.)
parser.add_option("-c", "--channel", dest="ch_name", type="string",
help="Custom EOG channel(s), comma separated",
default=None)
options, args = parser.parse_args()
raw_in = options.raw_in
if raw_in is None:
parser.print_help()
sys.exit(1)
tmin = options.tmin
tmax = options.tmax
n_grad = options.n_grad
n_mag = options.n_mag
n_eeg = options.n_eeg
l_freq = options.l_freq
h_freq = options.h_freq
eog_l_freq = options.eog_l_freq
eog_h_freq = options.eog_h_freq
average = options.average
preload = options.preload
filter_length = options.filter_length
n_jobs = options.n_jobs
reject = dict(grad=1e-13 * float(options.rej_grad),
mag=1e-15 * float(options.rej_mag),
eeg=1e-6 * float(options.rej_eeg),
eog=1e-6 * float(options.rej_eog))
avg_ref = options.avg_ref
no_proj = options.no_proj
bad_fname = options.bad_fname
event_id = options.event_id
proj_fname = options.proj
raw_event_fname = options.raw_event_fname
tstart = options.tstart
ch_name = options.ch_name
if bad_fname is not None:
with open(bad_fname, 'r') as fid:
bads = [w.rstrip() for w in fid.readlines()]
print('Bad channels read : %s' % bads)
else:
bads = []
if raw_in.endswith('_raw.fif') or raw_in.endswith('-raw.fif'):
prefix = raw_in[:-8]
else:
prefix = raw_in[:-4]
eog_event_fname = prefix + '_eog-eve.fif'
if average:
eog_proj_fname = prefix + '_eog_avg-proj.fif'
else:
eog_proj_fname = prefix + '_eog-proj.fif'
raw = mne.io.read_raw_fif(raw_in, preload=preload)
if raw_event_fname is not None:
raw_event = mne.io.read_raw_fif(raw_event_fname)
else:
raw_event = raw
flat = None # XXX : not exposed to the user
projs, events = mne.preprocessing.compute_proj_eog(
raw=raw, raw_event=raw_event, tmin=tmin, tmax=tmax, n_grad=n_grad,
n_mag=n_mag, n_eeg=n_eeg, l_freq=l_freq, h_freq=h_freq,
average=average, filter_length=filter_length,
n_jobs=n_jobs, reject=reject, flat=flat, bads=bads,
avg_ref=avg_ref, no_proj=no_proj, event_id=event_id,
eog_l_freq=eog_l_freq, eog_h_freq=eog_h_freq,
tstart=tstart, ch_name=ch_name, copy=False)
raw.close()
if raw_event_fname is not None:
raw_event.close()
if proj_fname is not None:
print('Including SSP projections from : %s' % proj_fname)
# append the eog projs, so they are last in the list
projs = mne.read_proj(proj_fname) + projs
if isinstance(preload, string_types) and os.path.exists(preload):
os.remove(preload)
print("Writing EOG projections in %s" % eog_proj_fname)
mne.write_proj(eog_proj_fname, projs)
print("Writing EOG events in %s" % eog_event_fname)
mne.write_events(eog_event_fname, events)
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 compute_proj_ecg(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg, l_freq, h_freq, average, filter_length, n_jobs, ch_name, reject, avg_ref, bads, preload, flat):
"""Compute SSP/PCA projections for ECG/EOG artifacts
Parameters
----------
in_fif_fname: string
Raw fif File
XXX
"""
if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'):
prefix = in_fif_fname[:-8]
else:
prefix = in_fif_fname[:-4]
ecg_event_fname = in_path + 'ssp/' + prefix + '_ecg-eve.fif'
if average:
ecg_proj_fname = in_path + 'ssp/' + prefix + '_ecg_avg_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_ecg_avg_proj_raw.fif'
else:
ecg_proj_fname = in_path + 'ssp/' + prefix + '_ecg_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_ecg_proj_raw.fif'
print 'Reading fif File'
in_fif_fname = in_path + in_fif_fname
raw = mne.fiff.Raw(in_fif_fname, preload=preload)
# if (in_path == '/cluster/kuperberg/SemPrMM/MEG/data/ya30/'):
# save after 84s of MEG data in FIF file
# raw = raw[: , 84:]
#raw.save('sample_audvis_meg_raw.fif', tmin=84)
print 'Running ECG SSP computation'
ecg_events, _, _ = mne.artifacts.find_ecg_events(raw, ch_name=ch_name)
print "Writing ECG events in %s" % ecg_event_fname
mne.write_events(ecg_event_fname, ecg_events)
make_lingua(ecg_event_fname)
if avg_ref:
print "Adding average EEG reference projection."
eeg_proj = mne.fiff.proj.make_eeg_average_ref_proj(raw.info)
raw.info['projs'].append(eeg_proj)
print 'Computing ECG projector'
# Handler rejection parameters
if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False, eog=False)) == 0:
del reject['grad']
if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False, eog=False)) == 0:
del reject['mag']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, eog=False)) == 0:
del reject['eeg']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, eog=True)) == 0:
del reject['eog']
picks = mne.fiff.pick_types(raw.info, meg=True, eeg=True, eog=True,
exclude=raw.info['bads'] + bads)
if l_freq is None and h_freq is not None:
raw.high_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is None:
raw.low_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is not None:
raw.band_pass_filter(picks, l_freq, h_freq, filter_length, n_jobs)
epochs_ecg = mne.Epochs(raw, ecg_events, None, tmin, tmax, baseline=None,
picks=picks, reject=reject, proj=True)
print epochs_ecg
projs_init = raw.info['projs']
if average:
evoked_ecg = epochs_ecg.average()
projs_ecg = mne.compute_proj_evoked(evoked_ecg, n_grad=n_grad, n_mag=n_mag,
n_eeg=n_eeg)
else:
print epochs_ecg, n_grad, n_mag, n_eeg
projs_ecg = mne.compute_proj_epochs(epochs_ecg, n_grad=n_grad, n_mag=n_mag,
n_eeg=n_eeg)
print "Writing ECG projections in %s" % ecg_proj_fname
mne.write_proj(ecg_proj_fname, projs_ecg + projs_init) ## Original Projections written along with the ecg projections.
print "Writing ECG projections in %s" % ecg_proj_fname
mne.write_proj(ecg_proj_fname, projs_ecg)
return in_fif_fname, ecg_proj_fname, out_fif_fname
def _compute_erm_proj(p,
subj,
projs,
kind,
bad_file,
remove_existing=False,
disp_files=None):
disp_files = p.disp_files if disp_files is None else disp_files
assert kind in ('sss', 'raw')
proj_nums = _proj_nums(p, subj)
proj_kwargs, p_sl = _get_proj_kwargs(p)
empty_names = get_raw_fnames(p, subj, kind, 'only')
fir_kwargs, _ = _get_fir_kwargs(p.fir_design)
flat = _handle_dict(p.flat, subj)
raw = _raw_LRFCP(raw_names=empty_names,
sfreq=p.proj_sfreq,
l_freq=p.cont_hp,
h_freq=p.cont_lp,
n_jobs=p.n_jobs_fir,
apply_proj=not remove_existing,
n_jobs_resample=p.n_jobs_resample,
projs=projs,
bad_file=bad_file,
disp_files=disp_files,
method='fir',
filter_length=p.filter_length,
force_bads=True,
l_trans=p.cont_hp_trans,
h_trans=p.cont_lp_trans,
phase=p.phase,
fir_window=p.fir_window,
skip_by_annotation='edge',
**fir_kwargs)
if remove_existing:
raw.del_proj()
raw.pick_types(meg=True, eeg=False, exclude=()) # remove EEG
use_reject, reject_kind = p.cont_reject, 'p.cont_reject'
if use_reject is None:
use_reject, reject_kind = p.reject, 'p.reject'
use_reject, use_flat = _restrict_reject_flat(
_handle_dict(use_reject, subj), flat, raw)
bad = False
pr = []
try:
pr = compute_proj_raw(raw,
duration=1,
n_grad=proj_nums[2][0],
n_mag=proj_nums[2][1],
n_eeg=proj_nums[2][2],
reject=use_reject,
flat=use_flat,
n_jobs=p.n_jobs_mkl,
**proj_kwargs)
except RuntimeError as exc:
if 'No good epochs' not in str(exc):
raise
bad = True
if bad:
events = make_fixed_length_events(raw)
epochs = Epochs(raw,
events,
tmin=0,
tmax=1. - 1. / raw.info['sfreq'],
proj=False,
baseline=None,
reject=use_reject,
flat=use_flat).drop_bad()
_raise_bad_epochs(
raw,
epochs,
events,
f'1-sec empty room via {reject_kind} = {use_reject} (consider '
f'changing p.cont_reject)',
plot=p.plot_drop_logs)
assert len(pr) == np.sum(proj_nums[2][::p_sl])
# When doing eSSS it's a bit weird to put this in pca_dir but why not
pca_dir = _get_pca_dir(p, subj)
cont_proj = op.join(pca_dir, 'preproc_cont-proj.fif')
write_proj(cont_proj, pr)
return pr
rep_group.add_figs_to_section(fig, '%s: Evoked, Before and After PCA'
% subject, 'Evoked, Before and After')
# 2. plot PCA topos
p = mne.viz.plot_projs_topomap(projs, evoked.info, show=False,
extrapolate='head')
rep_group.add_figs_to_section(p, '%s: PCA topos' % subject,
'Topos')
# 3. plot evoked - each proj
for ii, ev in enumerate(evokeds):
exp_var = ev.info['projs'][0]['explained_var'] * 100
title = 'PC %d: %2.2f%% Explained Variance' % (ii, exp_var)
tab = 'PC %d' % ii
fig = plt.figure(figsize=(12, 6))
gs = gridspec.GridSpec(1, 2, width_ratios=[3, 1])
axes = [plt.subplot(gs[0]), plt.subplot(gs[1])]
e = ev.plot(titles={'mag': title},
show=False, axes=axes[0])
p = mne.viz.plot_projs_topomap(ev.info['projs'], ev.info,
show=False, axes=axes[1],
extrapolate='head')
rep_group.add_figs_to_section(fig, '%s: Evoked w/o PC %d'
% (subject, ii), tab)
# save projs
mne.write_proj(fname_proj, projs)
# cleanup
del epochs
rep_group.save(fname_rep_group, open_browser=False, overwrite=True)
def run():
from mne.commands.utils import get_optparser
parser = get_optparser(__file__)
parser.add_option("-i", "--in", dest="raw_in",
help="Input raw FIF file", metavar="FILE")
parser.add_option("--tmin", dest="tmin", type="float",
help="Time before event in seconds",
default=-0.2)
parser.add_option("--tmax", dest="tmax", type="float",
help="Time after event in seconds",
default=0.4)
parser.add_option("-g", "--n-grad", dest="n_grad", type="int",
help="Number of SSP vectors for gradiometers",
default=2)
parser.add_option("-m", "--n-mag", dest="n_mag", type="int",
help="Number of SSP vectors for magnetometers",
default=2)
parser.add_option("-e", "--n-eeg", dest="n_eeg", type="int",
help="Number of SSP vectors for EEG",
default=2)
parser.add_option("--l-freq", dest="l_freq", type="float",
help="Filter low cut-off frequency in Hz",
default=1)
parser.add_option("--h-freq", dest="h_freq", type="float",
help="Filter high cut-off frequency in Hz",
default=100)
parser.add_option("--ecg-l-freq", dest="ecg_l_freq", type="float",
help="Filter low cut-off frequency in Hz used "
"for ECG event detection",
default=5)
parser.add_option("--ecg-h-freq", dest="ecg_h_freq", type="float",
help="Filter high cut-off frequency in Hz used "
"for ECG event detection",
default=35)
parser.add_option("-p", "--preload", dest="preload",
help="Temporary file used during computation "
"(to save memory)",
default=True)
parser.add_option("-a", "--average", dest="average", action="store_true",
help="Compute SSP after averaging",
default=False)
parser.add_option("--proj", dest="proj",
help="Use SSP projections from a fif file.",
default=None)
parser.add_option("--filtersize", dest="filter_length", type="int",
help="Number of taps to use for filtering",
default=2048)
parser.add_option("-j", "--n-jobs", dest="n_jobs", type="int",
help="Number of jobs to run in parallel",
default=1)
parser.add_option("-c", "--channel", dest="ch_name",
help="Channel to use for ECG detection "
"(Required if no ECG found)",
default=None)
parser.add_option("--rej-grad", dest="rej_grad", type="float",
help="Gradiometers rejection parameter "
"in fT/cm (peak to peak amplitude)",
default=2000)
parser.add_option("--rej-mag", dest="rej_mag", type="float",
help="Magnetometers rejection parameter "
"in fT (peak to peak amplitude)",
default=3000)
parser.add_option("--rej-eeg", dest="rej_eeg", type="float",
help="EEG rejection parameter in uV "
"(peak to peak amplitude)",
default=50)
parser.add_option("--rej-eog", dest="rej_eog", type="float",
help="EOG rejection parameter in uV "
"(peak to peak amplitude)",
default=250)
parser.add_option("--avg-ref", dest="avg_ref", action="store_true",
help="Add EEG average reference proj",
default=False)
parser.add_option("--no-proj", dest="no_proj", action="store_true",
help="Exclude the SSP projectors currently "
"in the fiff file",
default=False)
parser.add_option("--bad", dest="bad_fname",
help="Text file containing bad channels list "
"(one per line)",
default=None)
parser.add_option("--event-id", dest="event_id", type="int",
help="ID to use for events",
default=999)
parser.add_option("--event-raw", dest="raw_event_fname",
help="raw file to use for event detection",
default=None)
parser.add_option("--tstart", dest="tstart", type="float",
help="Start artifact detection after tstart seconds",
default=0.)
parser.add_option("--qrsthr", dest="qrs_threshold", type="string",
help="QRS detection threshold. Between 0 and 1. Can "
"also be 'auto' for automatic selection",
default='auto')
options, args = parser.parse_args()
raw_in = options.raw_in
if raw_in is None:
parser.print_help()
sys.exit(1)
tmin = options.tmin
tmax = options.tmax
n_grad = options.n_grad
n_mag = options.n_mag
n_eeg = options.n_eeg
l_freq = options.l_freq
h_freq = options.h_freq
ecg_l_freq = options.ecg_l_freq
ecg_h_freq = options.ecg_h_freq
average = options.average
preload = options.preload
filter_length = options.filter_length
n_jobs = options.n_jobs
ch_name = options.ch_name
reject = dict(grad=1e-13 * float(options.rej_grad),
mag=1e-15 * float(options.rej_mag),
eeg=1e-6 * float(options.rej_eeg),
eog=1e-6 * float(options.rej_eog))
avg_ref = options.avg_ref
no_proj = options.no_proj
bad_fname = options.bad_fname
event_id = options.event_id
proj_fname = options.proj
raw_event_fname = options.raw_event_fname
tstart = options.tstart
qrs_threshold = options.qrs_threshold
if qrs_threshold != 'auto':
try:
qrs_threshold = float(qrs_threshold)
except ValueError:
raise ValueError('qrsthr must be "auto" or a float')
if bad_fname is not None:
with open(bad_fname, 'r') as fid:
bads = [w.rstrip() for w in fid.readlines()]
print('Bad channels read : %s' % bads)
else:
bads = []
if raw_in.endswith('_raw.fif') or raw_in.endswith('-raw.fif'):
prefix = raw_in[:-8]
else:
prefix = raw_in[:-4]
ecg_event_fname = prefix + '_ecg-eve.fif'
if average:
ecg_proj_fname = prefix + '_ecg_avg-proj.fif'
else:
ecg_proj_fname = prefix + '_ecg-proj.fif'
raw = mne.io.read_raw_fif(raw_in, preload=preload)
if raw_event_fname is not None:
raw_event = mne.io.read_raw_fif(raw_event_fname)
else:
raw_event = raw
flat = None # XXX : not exposed to the user
cpe = mne.preprocessing.compute_proj_ecg
projs, events = cpe(raw, raw_event, tmin, tmax, n_grad, n_mag, n_eeg,
l_freq, h_freq, average, filter_length, n_jobs,
ch_name, reject, flat, bads, avg_ref, no_proj,
event_id, ecg_l_freq, ecg_h_freq, tstart,
qrs_threshold, copy=False)
raw.close()
if raw_event_fname is not None:
raw_event.close()
if proj_fname is not None:
print('Including SSP projections from : %s' % proj_fname)
# append the ecg projs, so they are last in the list
projs = mne.read_proj(proj_fname) + projs
if isinstance(preload, string_types) and os.path.exists(preload):
os.remove(preload)
print("Writing ECG projections in %s" % ecg_proj_fname)
mne.write_proj(ecg_proj_fname, projs)
print("Writing ECG events in %s" % ecg_event_fname)
mne.write_events(ecg_event_fname, events)
def compute_proj_ecg(in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg, l_freq,
h_freq, average, preload, filter_length, n_jobs, ch_name,
reject, avg_ref, bads):
"""Compute SSP/PCA projections for ECG artifacts
Parameters
----------
in_fif_fname: string
Raw fif File
XXX
"""
# Reading fif File
raw = mne.fiff.Raw(in_fif_fname, preload=preload)
if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'):
prefix = in_fif_fname[:-8]
else:
prefix = in_fif_fname[:-4]
ecg_event_fname = prefix + '_ecg-eve.fif'
if average:
ecg_proj_fname = prefix + '_ecg_avg_proj.fif'
else:
ecg_proj_fname = prefix + '_ecg_proj.fif'
print 'Running ECG SSP computation'
ecg_events, _, _ = mne.artifacts.find_ecg_events(raw, ch_name=ch_name)
print "Writing ECG events in %s" % ecg_event_fname
mne.write_events(ecg_event_fname, ecg_events)
if avg_ref:
print "Adding average EEG reference projection."
eeg_proj = mne.fiff.proj.make_eeg_average_ref_proj(raw.info)
raw.info['projs'].append(eeg_proj)
print 'Computing ECG projector'
# Handler rejection parameters
if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False, eog=False)) == 0:
del reject['grad']
if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False, eog=False)) == 0:
del reject['mag']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, eog=False)) == 0:
del reject['eeg']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, eog=True)) == 0:
del reject['eog']
picks = mne.fiff.pick_types(raw.info, meg=True, eeg=True, eog=True,
exclude=raw.info['bads'] + bads)
if l_freq is None and h_freq is not None:
raw.high_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is None:
raw.low_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is not None:
raw.band_pass_filter(picks, l_freq, h_freq, filter_length, n_jobs)
epochs = mne.Epochs(raw, ecg_events, None, tmin, tmax, baseline=None,
picks=picks, reject=reject, proj=True)
projs_init = raw.info['projs']
if average:
evoked = epochs.average()
projs = mne.compute_proj_evoked(evoked, n_grad=n_grad, n_mag=n_mag,
n_eeg=n_eeg)
else:
projs = mne.compute_proj_epochs(epochs, n_grad=n_grad, n_mag=n_mag,
n_eeg=n_eeg)
if preload is not None and os.path.exists(preload):
os.remove(preload)
print "Writing ECG projections in %s" % ecg_proj_fname
mne.write_proj(ecg_proj_fname, projs + projs_init)
print 'Done.'
def run_ssp(*, cfg, subject, session=None):
# compute SSP on first run of raw
bids_path = BIDSPath(subject=subject,
session=session,
task=cfg.task,
acquisition=cfg.acq,
run=cfg.runs[0],
recording=cfg.rec,
space=cfg.space,
extension='.fif',
datatype=cfg.datatype,
root=cfg.deriv_root)
# Prepare a name to save the data
raw_fname_in = bids_path.copy().update(processing='filt', suffix='raw',
check=False)
# when saving proj, use run=None
proj_fname_out = bids_path.copy().update(run=None, suffix='proj',
check=False)
msg = f'Input: {raw_fname_in}, Output: {proj_fname_out}'
logger.info(**gen_log_kwargs(message=msg, subject=subject,
session=session))
if raw_fname_in.copy().update(split='01').fpath.exists():
raw_fname_in.update(split='01')
raw = mne.io.read_raw_fif(raw_fname_in)
msg = 'Computing SSPs for ECG'
logger.debug(**gen_log_kwargs(message=msg, subject=subject,
session=session))
ecg_projs = []
ecg_epochs = create_ecg_epochs(raw)
if len(ecg_epochs) >= config.min_ecg_epochs:
if cfg.ssp_reject_ecg == 'autoreject_global':
reject_ecg_ = config.get_ssp_reject(
ssp_type='ecg',
epochs=ecg_epochs)
ecg_projs, _ = compute_proj_ecg(raw,
average=cfg.ecg_proj_from_average,
reject=reject_ecg_,
**cfg.n_proj_ecg)
else:
reject_ecg_ = config.get_ssp_reject(
ssp_type='ecg',
epochs=None)
ecg_projs, _ = compute_proj_ecg(raw,
average=cfg.ecg_proj_from_average,
reject=reject_ecg_,
**cfg.n_proj_ecg)
if not ecg_projs:
msg = ('Not enough ECG events could be found. No ECG projectors are '
'computed.')
logger.info(**gen_log_kwargs(message=msg, subject=subject,
session=session))
msg = 'Computing SSPs for EOG'
logger.debug(**gen_log_kwargs(message=msg, subject=subject,
session=session))
if cfg.eog_channels:
ch_names = cfg.eog_channels
assert all([ch_name in raw.ch_names for ch_name in ch_names])
else:
ch_names = None
eog_projs = []
eog_epochs = create_eog_epochs(raw)
if len(eog_epochs) >= config.min_eog_epochs:
if cfg.ssp_reject_eog == 'autoreject_global':
reject_eog_ = config.get_ssp_reject(
ssp_type='eog',
epochs=eog_epochs)
eog_projs, _ = compute_proj_eog(raw,
average=cfg.eog_proj_from_average,
reject=reject_eog_,
**cfg.n_proj_eog)
else:
reject_eog_ = config.get_ssp_reject(
ssp_type='eog',
epochs=None)
eog_projs, _ = compute_proj_eog(raw,
average=cfg.eog_proj_from_average,
reject=reject_eog_,
**cfg.n_proj_eog)
if not eog_projs:
msg = ('Not enough EOG events could be found. No EOG projectors are '
'computed.')
logger.info(**gen_log_kwargs(message=msg, subject=subject,
session=session))
mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
raw_event = raw
flat = None # XXX : not exposed to the user
projs, events = mne.preprocessing.compute_proj_eog(raw=raw,
raw_event=raw_event, tmin=tmin, tmax=tmax, n_grad=n_grad,
n_mag=n_mag, n_eeg=n_eeg, l_freq=l_freq, h_freq=h_freq,
average=average, filter_length=filter_length,
n_jobs=n_jobs, reject=reject, flat=flat, bads=bads,
avg_ref=avg_ref, no_proj=no_proj, event_id=event_id,
eog_l_freq=eog_l_freq, eog_h_freq=eog_h_freq,
tstart=tstart, ch_name=ch_name, copy=False)
raw.close()
if raw_event_fname is not None:
raw_event.close()
if proj_fname is not None:
print('Including SSP projections from : %s' % proj_fname)
# append the eog projs, so they are last in the list
projs = mne.read_proj(proj_fname) + projs
if isinstance(preload, string_types) and os.path.exists(preload):
os.remove(preload)
print("Writing EOG projections in %s" % eog_proj_fname)
mne.write_proj(eog_proj_fname, projs)
print("Writing EOG events in %s" % eog_event_fname)
mne.write_events(eog_event_fname, events)
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
