def process_hcp_runs(): for run_index in range(3): raw = hcp.read_raw(subject=subject, data_type='rest', hcp_path=data_folder, run_index=run_index) # duration in seconds duration = int(raw.n_times / raw.info['sfreq']) start: float = 0.0 for end in range(epoch_size, min(duration, 400), epoch_size): raw.crop(tmin=start, tmax=end).load_data() features.append(spectral_features(raw)) labels.append("{}-{}-{}".format(subject, run_index, int(end / epoch_size))) start = end # re-read the signal - faster than copying in-memory version raw = hcp.read_raw(subject=subject, data_type='rest', hcp_path=data_folder, run_index=run_index) # progress... print('.', end='', flush=True) print('|', end='', flush=True) return labels, features
def compute_noise_cov(subject, hcp_path, noise_cov_fname=''): if noise_cov_fname == '': noise_cov_fname = meg.NOISE_COV.format(cond='empty_room') if op.isfile(noise_cov_fname): noise_cov = mne.read_cov(noise_cov_fname) return noise_cov utils.make_dir(utils.get_parent_fol(noise_cov_fname)) raw_noise = hcp.read_raw(subject=subject, hcp_path=hcp_path, data_type='noise_empty_room') raw_noise.load_data() # apply ref channel correction and drop ref channels preproc.apply_ref_correction(raw_noise) raw_noise.filter(0.50, None, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=1) raw_noise.filter(None, 60, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=1) ############################################################################## # Note that using the empty room noise covariance will inflate the SNR of the # evkoked and renders comparisons to `baseline` rather uninformative. noise_cov = mne.compute_raw_covariance(raw_noise, method='empirical') noise_cov.save(noise_cov_fname) return noise_cov
def read_raw_data(run_index, hcp_params, lfreq=0.5, hfreq=60): raw = hcp.read_raw(run_index=run_index, **hcp_params) raw.load_data() # apply ref channel correction and drop ref channels # preproc.apply_ref_correction(raw) annots = hcp.read_annot(run_index=run_index, **hcp_params) # construct MNE annotations bad_seg = (annots['segments']['all']) / raw.info['sfreq'] annotations = mne.Annotations( bad_seg[:, 0], (bad_seg[:, 1] - bad_seg[:, 0]), description='bad') raw.annotations = annotations raw.info['bads'].extend(annots['channels']['all']) raw.pick_types(meg=True, ref_meg=False) raw.filter(lfreq, None, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=1) raw.filter(None, hfreq, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=1) # read ICA and remove EOG ECG # note that the HCP ICA assumes that bad channels have already been removed ica_mat = hcp.read_ica(run_index=run_index, **hcp_params) # We will select the brain ICs only exclude = annots['ica']['ecg_eog_ic'] preproc.apply_ica_hcp(raw, ica_mat=ica_mat, exclude=exclude) return raw
def test_apply_ica(): """Test ICA application.""" raw = hcp.read_raw(data_type='rest', verbose='error', **hcp_params) annots = hcp.read_annot(data_type='rest', **hcp_params) # construct MNE annotations bad_seg = (annots['segments']['all']) / raw.info['sfreq'] annotations = mne.Annotations(bad_seg[:, 0], (bad_seg[:, 1] - bad_seg[:, 0]), description='bad') raw.annotations = annotations raw.info['bads'].extend(annots['channels']['all']) ica_mat = hcp.read_ica(data_type='rest', **hcp_params) exclude = [ ii for ii in range(annots['ica']['total_ic_number'][0]) if ii not in annots['ica']['brain_ic_vs'] ] assert_raises(RuntimeError, apply_ica_hcp, raw, ica_mat=ica_mat, exclude=exclude) # XXX right now this is just a smoke test, should really check some # values... with warnings.catch_warnings(record=True): raw.crop(0, 1).load_data() apply_ica_hcp(raw, ica_mat=ica_mat, exclude=exclude)
def test_set_eog_ecg_channels(): """Test setting of EOG and ECG channels.""" raw = hcp.read_raw(data_type='rest', **hcp_params) raw.crop(0, 1).load_data() assert_equal(len(mne.pick_types(raw.info, meg=False, eog=True)), 0) assert_equal(len(mne.pick_types(raw.info, meg=False, ecg=True)), 13) set_eog_ecg_channels(raw) # XXX Probably shouldn't still have 8 ECG channels! assert_equal(len(mne.pick_types(raw.info, meg=False, eog=True)), 2) assert_equal(len(mne.pick_types(raw.info, meg=False, ecg=True)), 8)
def read_hcp(subject: str, data_folder: str, run_index: int) -> mne.io.Raw: """ Read a data file from the HCP dataset, return a Raw instance """ raw = hcp.read_raw(subject=subject, data_type='rest', hcp_path=data_folder, run_index=run_index) return raw
def test_read_raw_noise(): """Test reading raw for empty room noise""" for run_index in tconf.run_inds[:tconf.max_runs][:2]: for data_type in tconf.noise_types: if run_index == 1: assert_raises( ValueError, hcp.read_raw, data_type=data_type, run_index=run_index, **hcp_params) continue raw = hcp.read_raw( data_type=data_type, run_index=run_index, **hcp_params) _basic_raw_checks(raw=raw)
def test_read_raw_task(): """Test reading raw for tasks""" for run_index in tconf.run_inds[:tconf.max_runs]: for data_type in tconf.task_types: if run_index == 2: assert_raises( ValueError, hcp.read_raw, data_type=data_type, run_index=run_index, **hcp_params) continue raw = hcp.read_raw( data_type=data_type, run_index=run_index, **hcp_params) _basic_raw_checks(raw=raw)
def test_apply_ref_correction(): """Test reference correction.""" raw = hcp.read_raw(data_type='rest', run_index=0, **hcp_params) # raw.crop(0, 10).load_data() raw.load_data() # XXX terrible hack to have more samples. # The test files are too short. raw.append(raw.copy()) meg_picks = mne.pick_types(raw.info, meg=True, ref_meg=False) orig = raw[meg_picks[0]][0][0] apply_ref_correction(raw) proc = raw[meg_picks[0]][0][0] assert_true(np.linalg.norm(orig) > np.linalg.norm(proc))
def test_interpolate_missing(): """Test interpolation of missing channels.""" data_type = 'task_working_memory' raw = hcp.read_raw(data_type='task_working_memory', run_index=0, **hcp_params) raw.load_data() n_chan = len(raw.ch_names) raw.drop_channels(['A1']) assert_equal(len(raw.ch_names), n_chan - 1) raw = interpolate_missing(raw, data_type=data_type, **hcp_params) assert_equal(len(raw.ch_names), n_chan) evoked = hcp.read_evokeds(data_type=data_type, **hcp_params)[0] assert_equal(len(evoked.ch_names), 243) evoked_int = interpolate_missing(evoked, data_type=data_type, **hcp_params) assert_equal(len(evoked_int.ch_names), 248)
def test_apply_ica(): """Test ICA application.""" raw = hcp.read_raw(data_type='rest', verbose='error', **hcp_params) annots = hcp.read_annot(data_type='rest', **hcp_params) # construct MNE annotations bad_seg = (annots['segments']['all']) / raw.info['sfreq'] annotations = mne.Annotations( bad_seg[:, 0], (bad_seg[:, 1] - bad_seg[:, 0]), description='bad') raw.annotations = annotations raw.info['bads'].extend(annots['channels']['all']) ica_mat = hcp.read_ica(data_type='rest', **hcp_params) exclude = [ii for ii in range(annots['ica']['total_ic_number'][0]) if ii not in annots['ica']['brain_ic_vs']] assert_raises(RuntimeError, apply_ica_hcp, raw, ica_mat=ica_mat, exclude=exclude) # XXX right now this is just a smoke test, should really check some # values... with warnings.catch_warnings(record=True): raw.crop(0, 1).load_data() apply_ica_hcp(raw, ica_mat=ica_mat, exclude=exclude)
def load_one_record(data_type, subject, run_index, sfreq=300, epoch=None, filter_params=[5., None], n_jobs=1): # Load the record and correct the sensor space to get proper visualization print(f"subject={subject}, data_type={data_type}, run_index={run_index}, " f"hcp_path={HCP_DIR}") raw = hcp.read_raw(subject, data_type=data_type, run_index=run_index, hcp_path=HCP_DIR, verbose=0) raw.load_data() hcp.preprocessing.map_ch_coords_to_mne(raw) raw.pick_types(meg='mag', eog=False, stim=True) # filter the electrical and low frequency components raw.notch_filter([60, 120], n_jobs=n_jobs) raw.filter(*filter_params, n_jobs=n_jobs) # Resample to the requested sfreq if sfreq is not None: raw.resample(sfreq=sfreq, n_jobs=n_jobs) events = mne.find_events(raw) raw.pick_types(meg='mag', stim=False) events[:, 0] -= raw.first_samp # Deep copy before modifying info to avoid issues when saving EvokedArray info = deepcopy(raw.info) info['events'] = events info['event_id'] = np.unique(events[:, 2]) # Return the data return raw.get_data(), info
src_outputs = hcp.anatomy.compute_forward_stack( subject=subject, subjects_dir=subjects_dir, hcp_path=hcp_path, recordings_path=recordings_path, # speed up computations here. Setting `add_dist` to True may improve the # accuracy. src_params=dict(add_dist=False), info_from=dict(data_type=data_type, run_index=run_index)) fwd = src_outputs['fwd'] ############################################################################## # Now we can compute the noise covariance. For this purpose we will apply # the same filtering as was used for the computations of the ERF in the first # place. See also :ref:`tut_reproduce_erf`. raw_noise = hcp.read_raw(subject=subject, hcp_path=hcp_path, data_type='noise_empty_room') raw_noise.load_data() # apply ref channel correction and drop ref channels preproc.apply_ref_correction(raw_noise) # Note: MNE complains on Python 2.7 raw_noise.filter(0.50, None, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=1) raw_noise.filter(None, 60, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=1) ############################################################################## # Note that using the empty room noise covariance will inflate the SNR of the # evkoked and renders comparisons to `baseline` rather uninformative. noise_cov = mne.compute_raw_covariance(raw_noise, method='empirical')
def test_make_layout(): """Test making a layout.""" raw = hcp.read_raw(data_type='rest', **hcp_params).crop(0, 1).load_data() raw.pick_types() lout = make_hcp_bti_layout(raw.info) assert_equal(lout.names, raw.info['ch_names'])
trial_info['stim']['codes'][:, 6] - 1, # time sample np.zeros(len(trial_info['stim']['codes'])), trial_info['stim']['codes'][:, 3] # event codes ].astype(int) events = events[np.argsort(events[:, 0])] # chronological order # for some reason in the HCP data the time events may not always be unique unique_subset = np.nonzero(np.r_[1, np.diff(events[:, 0])])[0] events = events[unique_subset] # use diff to find first unique events all_events.append(events) # now we can go ahead evokeds = list() for run_index, events in zip([0, 1], all_events): raw = hcp.read_raw(run_index=run_index, **hcp_params) raw.load_data() # apply ref channel correction and drop ref channels # preproc.apply_ref_correction(raw) annots = hcp.read_annot(run_index=run_index, **hcp_params) # construct MNE annotations bad_seg = (annots['segments']['all']) / raw.info['sfreq'] annotations = mne.Annotations( bad_seg[:, 0], (bad_seg[:, 1] - bad_seg[:, 0]), description='bad') raw.annotations = annotations raw.info['bads'].extend(annots['channels']['all']) raw.pick_types(meg=True, ref_meg=False)
def main(filename=None, subjid=None, trans=None, info=None, line_freq=None, emptyroom_filename=None, subjects_dir=None): raw = hcp.read_raw(subjid, 'rest', hcp_path='/data/EnigmaMeg/HCP/HCP_MEG') raw.load_data() eraw = hcp.read_raw(subjid, 'noise_empty_room',hcp_path='/data/EnigmaMeg/HCP/HCP_MEG') eraw.load_data() hcp.preprocessing.apply_ref_correction(raw) hcp.preprocessing.apply_ref_correction(eraw) #Below may be useful for testing ICA components #ica_mat = hcp.read_ica(subjid, 'rest') #annotations_dict=hcp.read_annot(subjid, 'rest') #hcp.preprocessing.apply_ica_hcp(raw, ica_mat, annotations_dict['ica']['ecg_eog_ic']) ## Load and prefilter continuous data #raw=load_data(filename) #eraw=load_data(emptyroom_filename) if type(raw)==mne.io.ctf.ctf.RawCTF: raw.apply_gradient_compensation(3) ## Test SSS bad channel detection for non-Elekta data # !!!!!!!!!!! Currently no finecal or crosstalk used !!!!!!!!!!!!!!! # if filename[-3:]=='fif': # raw_bads_dict = assess_bads(filename) # eraw_bads_dict = assess_bads(emptyroom_filename, is_eroom=True) # raw.info['bads']=raw_bads_dict['noisy'] + raw_bads_dict['flat'] # eraw.info['bads']=eraw_bads_dict['noisy'] + eraw_bads_dict['flat'] resample_freq=300 raw.resample(resample_freq) eraw.resample(resample_freq) raw.filter(0.5, 140) eraw.filter(0.5, 140) if line_freq==None: try: line_freq = raw.info['line_freq'] # this isn't present in all files except: raise(ValueError('Could not determine line_frequency')) notch_freqs = np.arange(line_freq, resample_freq/2, line_freq) raw.notch_filter(notch_freqs) ## Create Epochs and covariance epochs = mne.make_fixed_length_epochs(raw, duration=4.0, preload=True) epochs.apply_baseline(baseline=(0,None)) cov = mne.compute_covariance(epochs) er_epochs=mne.make_fixed_length_epochs(eraw, duration=4.0, preload=True) er_epochs.apply_baseline(baseline=(0,None)) er_cov = mne.compute_covariance(er_epochs) os.environ['SUBJECTS_DIR']=subjects_dir src = mne.read_source_spaces(info.src_filename) bem = mne.read_bem_solution(info.bem_sol_filename) fwd = mne.make_forward_solution(epochs.info, trans, src, bem) data_info = epochs.info from mne.beamformer import make_lcmv, apply_lcmv_epochs filters = make_lcmv(epochs.info, fwd, cov, reg=0.01, noise_cov=er_cov, pick_ori='max-power', weight_norm='unit-noise-gain', rank=None) labels_lh=mne.read_labels_from_annot(subjid, parc='aparc_sub', subjects_dir=subjects_dir, hemi='lh') labels_rh=mne.read_labels_from_annot(subjid, parc='aparc_sub', subjects_dir=subjects_dir, hemi='rh') labels=labels_lh + labels_rh results_stcs = apply_lcmv_epochs(epochs, filters, return_generator=True)#, max_ori_out='max_power') #Monkey patch of mne.source_estimate to perform 15 component SVD label_ts = mod_source_estimate.extract_label_time_course(results_stcs, labels, fwd['src'], mode='pca15_multitaper') #Convert list of numpy arrays to ndarray (Epoch/Label/Sample) label_stack = np.stack(label_ts) #HACK HARDCODED FREQ BINS freq_bins = np.linspace(1,45,177) ######################################3######### FIX #Initialize label_power = np.zeros([len(labels), len(freq_bins)]) alpha_peak = np.zeros(len(labels)) #Create PSD for each label for label_idx in range(len(labels)): print(str(label_idx)) current_psd = label_stack[:,label_idx, :].mean(axis=0) label_power[label_idx,:] = current_psd spectral_image_path = os.path.join(info.outfolder, 'Spectra_'+ labels[label_idx].name + '.png') try: tmp_fmodel = calc_spec_peak(freq_bins, current_psd, out_image_path=spectral_image_path) #FIX FOR MULTIPLE ALPHA PEAKS potential_alpha_idx = np.where((8.0 <= tmp_fmodel.peak_params[:,0] ) & \ (tmp_fmodel.peak_params[:,0] <= 12.0 ) )[0] if len(potential_alpha_idx) != 1: alpha_peak[label_idx] = np.nan #############FIX ###########################3 FIX else: alpha_peak[label_idx] = tmp_fmodel.peak_params[potential_alpha_idx[0]][0] except: alpha_peak[label_idx] = np.nan #Fix <<<<<<<<<<<<<< #Save the label spectrum to assemble the relative power freq_bin_names=[str(binval) for binval in freq_bins] label_spectra_dframe = pd.DataFrame(label_power, columns=[freq_bin_names]) label_spectra_dframe.to_csv( os.path.join(info.outfolder, 'label_spectra.csv') , index=False) # with open(os.path.join(info.outfolder, 'label_spectra.npy'), 'wb') as f: # np.save(f, label_power) relative_power = label_power / label_power.sum(axis=1, keepdims=True) #Define bands bands = [[1,3], [3,6], [8,12], [13,35], [35,55]] band_idxs = get_freq_idx(bands, freq_bins) #initialize output band_means = np.zeros([len(labels), len(bands)]) #Loop over all bands, select the indexes assocaited with the band and average for mean_band, band_idx in enumerate(band_idxs): band_means[:, mean_band] = relative_power[:, band_idx].mean(axis=1) output_filename = os.path.join(info.outfolder, 'Band_rel_power.csv') bands_str = [str(i) for i in bands] label_names = [i.name for i in labels] output_dframe = pd.DataFrame(band_means, columns=bands_str, index=label_names) output_dframe['AlphaPeak'] = alpha_peak output_dframe.to_csv(output_filename, sep='\t')
def test_read_raw_rest(): """Test reading raw for resting state""" for run_index in tconf.run_inds[:tconf.max_runs]: raw = hcp.read_raw(data_type='rest', run_index=run_index, **hcp_params) _basic_raw_checks(raw=raw)
psd = psd[freqs > 0] plt.plot(np.log10(freqs), 10 * np.log10(psd.ravel()), label=label, color=color) ############################################################################### # Now we read in the data # # Then we plot the power spectrum of the MEG and reference channels, # apply the reference correction and add the resulting cleaned MEG channels # to our comparison. raw = hcp.read_raw(subject=subject, hcp_path=hcp_path, run_index=run_index, data_type=data_type) raw.load_data() # get meg and ref channels meg_picks = mne.pick_types(raw.info, meg=True, ref_meg=False) ref_picks = mne.pick_types(raw.info, ref_meg=True, meg=False) # put single channel aside for comparison later chan1 = raw[meg_picks[0]][0] # add some plotting parameter decim_fit = 100 # we lean a purely spatial model, we don't need all samples decim_show = 10 # we can make plotting faster n_fft = 2**15 # let's use long windows to see low frequencies
def reprocess_the_data_from_scratch(all_events, event_id, tmin, tmax, baseline, decim): # now we can go ahead evokeds = list() all_epochs = list() for run_index, events in zip([0, 1], all_events): raw = hcp.read_raw(run_index=run_index, **hcp_params) raw.load_data() # apply ref channel correction and drop ref channels # preproc.apply_ref_correction(raw) annots = hcp.read_annot(run_index=run_index, **hcp_params) # construct MNE annotations bad_seg = (annots['segments']['all']) / raw.info['sfreq'] annotations = mne.Annotations(bad_seg[:, 0], (bad_seg[:, 1] - bad_seg[:, 0]), description='bad') raw.annotations = annotations raw.info['bads'].extend(annots['channels']['all']) raw.pick_types(meg=True, ref_meg=False) # Note: MNE complains on Python 2.7 raw.filter(0.50, None, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=1) raw.filter(None, 60, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=1) # read ICA and remove EOG ECG # note that the HCP ICA assumes that bad channels have already been removed ica_mat = hcp.read_ica(run_index=run_index, **hcp_params) # We will select the brain ICs only exclude = annots['ica']['ecg_eog_ic'] preproc.apply_ica_hcp(raw, ica_mat=ica_mat, exclude=exclude) # now we can epoch events = np.sort(events, 0) epochs = mne.Epochs(raw, events=events[events[:, 2] == 1], event_id=event_id, tmin=tmin, tmax=tmax, reject=None, baseline=baseline, decim=decim, preload=True) all_epochs.append(epochs) evoked = epochs.average() # now we need to add back out channels for comparison across runs. evoked = preproc.interpolate_missing(evoked, **hcp_params) evokeds.append(evoked) return all_epochs, evokeds
noverlap=int(NFFT * 0.8)) freqs = freqs[freqs > 0] psd = psd[freqs > 0] plt.plot(np.log10(freqs), 10 * np.log10(psd.ravel()), label=label, color=color) ############################################################################### # Now we read in the data # # Then we plot the power spectrum of the MEG and reference channels, # apply the reference correction and add the resulting cleaned MEG channels # to our comparison. raw = hcp.read_raw(subject=subject, hcp_path=hcp_path, run_index=run_index, data_type=data_type) raw.load_data() # get meg and ref channels meg_picks = mne.pick_types(raw.info, meg=True, ref_meg=False) ref_picks = mne.pick_types(raw.info, ref_meg=True, meg=False) # put single channel aside for comparison later chan1 = raw[meg_picks[0]][0] # add some plotting parameter decim_fit = 100 # we lean a purely spatial model, we don't need all samples decim_show = 10 # we can make plotting faster n_fft = 2 ** 15 # let's use long windows to see low frequencies
# # speed up computations here. Setting `add_dist` to True may improve the # # accuracy. # src_params=dict(add_dist=False), # info_from=dict(data_type=task, run_index=run_index)) # # fwd = src_outputs['fwd'] fwd = mne.read_forward_solution(fwd_fname) ############################################################################## # Now we can compute the noise covariance. For this purpose we will apply # the same filtering as was used for the computations of the ERF in the first # place. See also :ref:`tut_reproduce_erf`. if not op.isfile(noise_cov_fname): raw_noise = hcp.read_raw(subject=subject, HCP_DIR=HCP_DIR, data_type='noise_empty_room') raw_noise.load_data() # apply ref channel correction and drop ref channels hcp.preprocessing.apply_ref_correction(raw_noise) # Note: MNE complains on Python 2.7 raw_noise.filter(0.50, None, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=n_jobs) raw_noise.filter(None, 60, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=n_jobs) ############################################################################## # Note that using the empty room noise covariance will inflate the SNR of the # evkoked and renders comparisons to `baseline` rather uninformative. noise_cov = mne.compute_raw_covariance(raw_noise, method='empirical')
hcp_path=hcp_path, recordings_path=recordings_path, # seed up computations here. Setting add_dist to True may improve the accuracy src_params=dict(add_dist=False), info_from=dict(data_type=data_type, run_index=run_index)) fwd = src_outputs['fwd'] del src_outputs #================================================================= # just using baseline to compute the noise cov # after this, using empty room noise #noise_cov = mne.compute_covariance(hcp_epochs, tmax=-0.5,method=['shrunk', 'empirical']) #================================================================= # Now we can compute the noise covariance. For this purpose we will apply # the same filtering as was used for the computations of the ERF raw_noise = hcp.read_raw(subject=subject, hcp_path=hcp_path, data_type='noise_empty_room') raw_noise.load_data() # apply ref channel correction and drop ref channels preproc.apply_ref_correction(raw_noise) # Note: MNE complains on Python 2.7 raw_noise.filter(0.50, None, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=1) raw_noise.filter(None, 60, method='iir', iir_params=dict(order=4, ftype='butter'),
def compute_src_label_ts(subject, crop_to=[0, 250], resample_to=100., bads=None, mag_reject=5e-12, win_len=2000, n_wins=11, verbose=None, lambda2=1. / 9., inv_method='dSPM', extract_ts_mode='mean_flip'): """ Compute source label time series """ """ Compute anatomy """ hcp.make_mne_anatomy(subject, subjects_dir=subjects_dir, hcp_path=hcp_path, recordings_path=hcp_path) """ Read surface labels """ labels = read_labels_from_annot(subject, parc='aparc', subjects_dir=subjects_dir) labels_fsav = read_labels_from_annot('fsaverage', parc='aparc', subjects_dir=subjects_dir) """ Read raw data """ raw = hcp.read_raw(subject=subject, data_type=data_type, hcp_path=hcp_path, run_index=run_index) raw.load_data() raw.crop(crop_to[0], crop_to[1]) raw.resample(resample_to) raw.info['bads'] = bads hcp.preprocessing.set_eog_ecg_channels(raw) hcp.preprocessing.apply_ref_correction(raw) info = raw.info.copy() raw.info['projs'] = [] ecg_ave = create_ecg_epochs(raw).average() eog_ave = create_eog_epochs(raw).average() ssp_eog, _ = compute_proj_eog(raw, n_grad=1, n_mag=1, average=True, reject=dict(mag=mag_reject)) raw.add_proj(ssp_eog, remove_existing=True) n_fft = next_fast_len(int(round(4 * raw.info['sfreq']))) sfreq = raw.info['sfreq'] """ Compute forward model """ src_outputs = hcp.anatomy.compute_forward_stack( subject=subject, subjects_dir=subjects_dir, hcp_path=hcp_path, recordings_path=hcp_path, src_params=dict(add_dist=False), info_from=dict(data_type=data_type, run_index=run_index)) fwd = src_outputs['fwd'] """ Compute noise covariance """ raw_noise = hcp.read_raw(subject=subject, hcp_path=hcp_path, data_type='noise_empty_room') raw_noise.load_data() hcp.preprocessing.apply_ref_correction(raw_noise) raw_noise.add_proj(ssp_eog) noise_cov = compute_raw_covariance(raw_noise, method='oas') """ Compute inverse operator """ raw.info = info inv_op = make_inverse_operator(raw.info, forward=fwd, noise_cov=noise_cov, verbose=verbose) """ Compute source activity """ wins = [[0, win_len]] for i in range(n_wins): new_wins = [ wins[0][0] + (win_len * (i + 1)), wins[0][1] + (win_len * (i + 1)) ] wins.append(new_wins) raw_srcs = [] for win in wins: res = apply_inverse_raw(raw, inv_op, lambda2=lambda2, method=inv_method, label=None, start=win[0], stop=win[1], nave=1, time_func=None, pick_ori=None, buffer_size=None, prepared=False, method_params=None, verbose=verbose) raw_srcs.append(res) """ Compute source label time series """ src = inv_op['src'] label_ts = extract_label_time_course(raw_srcs, labels, src, mode=extract_ts_mode, return_generator=False) return label_ts, sfreq
for subj_fold in dirs: hcp_params['subject'] = subj_fold # Construct folder for saving epochs epo_fold = op.join(hcp_path, subj_fold, 'epochs') check_and_create_dir(epo_fold) ########################################################################### # Construct epochs for run_index in rest_params['runs']: hcp_params['run_index'] = run_index raw = hcp.read_raw(**hcp_params) raw.load_data() # Make 1 second events; assign event code from params, shouldn't # overlap with the motor task 'fixate' events events = make_events(raw, id=rest_params['event_id']['rest'], duration=1.) ################# # Preprocess data raw, annots = preproc_annot_filter(subj_fold, raw, hcp_params, apply_ref_correction=rest_params['ref_correction']) ################# # Epoch data
mne.write_source_spaces(op.join(src_fold, 'subject-src.fif'), src_outputs['src_subject']) mne.write_source_spaces(op.join(src_fold, 'fsaverage-src.fif'), src_outputs['src_fsaverage']) mne.write_forward_solution(op.join(hcp_path, subj_fold, 'forward', '%s-meg-fwd.fif' % subj_fold), src_outputs['fwd'], overwrite=True) if True: # Construct SSP projectors using all raw objects raw_list =[] hcp_params = dict(hcp_path=hcp_path, subject=subj_fold) for run_i in rest_params['runs']: hcp_params.update(dict(data_type='rest', run_index=run_i)) raw = hcp.read_raw(**hcp_params) raw.load_data() annots = hcp.read_annot(**hcp_params) bad_seg = (annots['segments']['all']) / raw.info['sfreq'] annotations = mne.Annotations( bad_seg[:, 0], (bad_seg[:, 1] - bad_seg[:, 0]), description='bad') raw.annotations = annotations raw_list.append(raw) for run_i in motor_params['runs']: hcp_params.update(dict(data_type='task_motor', run_index=run_i)) raw = hcp.read_raw(**hcp_params)