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