def run_inverse(subject): print("processing subject: %s" % subject) meg_subject_dir = op.join(config.meg_dir, subject) fname_ave = op.join(meg_subject_dir, '%s-ave.fif' % subject) fname_fwd = op.join(meg_subject_dir, '%s-%s-fwd.fif' % (subject, config.spacing)) fname_cov = op.join(meg_subject_dir, '%s-cov.fif' % subject) fname_inv = op.join(meg_subject_dir, '%s-%s-inv.fif' % (subject, config.spacing)) evokeds = mne.read_evokeds(fname_ave) cov = mne.read_cov(fname_cov) forward = mne.read_forward_solution(fname_fwd) info = evokeds[0].info inverse_operator = make_inverse_operator(info, forward, cov, loose=0.2, depth=0.8) write_inverse_operator(fname_inv, inverse_operator) # Apply inverse snr = 3.0 lambda2 = 1.0 / snr**2 for condition, evoked in zip(config.conditions, evokeds): stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM", pick_ori=None) stc.save( op.join(meg_subject_dir, 'mne_dSPM_inverse-%s' % condition.replace(op.sep, '')))
def save(var, typ, subject='fsaverage', analysis='analysis', block=999, upload=aws, overwrite=False): """Auxiliary saving function.""" # get file name fname = paths(typ, subject=subject, analysis=analysis, block=block) # check if file exists if op.exists(fname) and not overwrite: print('%s already exists. Skipped' % fname) return False # different data format depending file type if typ in ['epo_block', 'epochs', 'epochs_decim', 'cov', 'epochs_vhp']: var.save(fname) elif typ in ['evoked', 'decod', 'decod_tfr', 'score', 'score_tfr', 'evoked_source']: with open(fname, 'wb') as f: pickle.dump(var, f) elif typ in ['inv']: from mne.minimum_norm import write_inverse_operator write_inverse_operator(fname, var) elif typ in ['fwd']: from mne import write_forward_solution write_forward_solution(fname, var) elif typ == 'morph': np.savez(fname, data=var.data, indices=var.indices, indptr=var.indptr, shape=var.shape) elif typ in ['score_source', 'score_pval']: np.save(fname, var) else: raise NotImplementedError() if upload: client.upload(fname) return True
def apply_inverse_ave(fnevo, min_subject='fsaverage'): from mne import make_forward_solution from mne.minimum_norm import write_inverse_operator fnlist = get_files_from_list(fnevo) # loop across all filenames for fname in fnlist: fn_path = os.path.split(fname)[0] name = os.path.basename(fname) #fn_inv = fname[:fname.rfind('-ave.fif')] + ',ave-inv.fif' subject = name.split('_')[0] fn_inv = fn_path + '/%s_fibp1-45,ave-inv.fif' %subject subject_path = subjects_dir + '/%s' %subject #min_dir = subjects_dir + '/%s' %min_subject fn_trans = fn_path + '/%s-trans.fif' % subject #fn_cov = fn_path + '/%s_empty,nr,fibp1-45-cov.fif' % subject fn_cov = fn_path + '/%s_empty,fibp1-45-cov.fif' %subject fn_src = subject_path + '/bem/%s-oct-6-src.fif' % subject fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject [evoked] = mne.read_evokeds(fname) evoked.pick_types(meg=True, ref_meg=False) noise_cov = mne.read_cov(fn_cov) #noise_cov = mne.cov.regularize(noise_cov, evoked.info, # mag=0.05, grad=0.05, proj=True) fwd = make_forward_solution(evoked.info, fn_trans, fn_src, fn_bem) fwd['surf_ori'] = True inv = mne.minimum_norm.make_inverse_operator(evoked.info, fwd, noise_cov, loose=0.2, depth=0.8, limit_depth_chs=False) write_inverse_operator(fn_inv, inv)
def run_inverse(subject_id): subject = "sub%03d" % subject_id print("processing subject: %s" % subject) data_path = op.join(meg_dir, subject) fname_ave = op.join(data_path, '%s-ave.fif' % subject) fname_cov = op.join(data_path, '%s-cov.fif' % subject) fname_fwd = op.join(data_path, '%s-meg-%s-fwd.fif' % (subject, spacing)) fname_inv = op.join(data_path, '%s-meg-%s-inv.fif' % (subject, spacing)) evokeds = mne.read_evokeds(fname_ave, condition=[0, 1, 2, 3, 4, 5]) cov = mne.read_cov(fname_cov) # cov = mne.cov.regularize(cov, evokeds[0].info, # mag=0.05, grad=0.05, eeg=0.1, proj=True) forward = mne.read_forward_solution(fname_fwd, surf_ori=True) # forward = mne.pick_types_forward(forward, meg=True, eeg=False) # make an M/EEG, MEG-only, and EEG-only inverse operators info = evokeds[0].info inverse_operator = make_inverse_operator(info, forward, cov, loose=0.2, depth=0.8) write_inverse_operator(fname_inv, inverse_operator) # Compute inverse solution snr = 3.0 lambda2 = 1.0 / snr ** 2 for evoked in evokeds: stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM", pick_ori=None) stc.save(op.join(data_path, 'mne_dSPM_inverse-%s' % evoked.comment))
def test_apply_inverse_sphere(evoked): """Test applying an inverse with a sphere model (rank-deficient).""" evoked.pick_channels(evoked.ch_names[:306:8]) evoked.info['projs'] = [] cov = make_ad_hoc_cov(evoked.info) sphere = make_sphere_model('auto', 'auto', evoked.info) fwd = read_forward_solution(fname_fwd) vertices = [fwd['src'][0]['vertno'][::5], fwd['src'][1]['vertno'][::5]] stc = SourceEstimate(np.zeros((sum(len(v) for v in vertices), 1)), vertices, 0., 1.) fwd = restrict_forward_to_stc(fwd, stc) fwd = make_forward_solution(evoked.info, fwd['mri_head_t'], fwd['src'], sphere, mindist=5.) evoked = EvokedArray(fwd['sol']['data'].copy(), evoked.info) assert fwd['sol']['nrow'] == 39 assert fwd['nsource'] == 101 assert fwd['sol']['ncol'] == 303 tempdir = _TempDir() temp_fname = op.join(tempdir, 'temp-inv.fif') inv = make_inverse_operator(evoked.info, fwd, cov, loose=1.) # This forces everything to be float32 write_inverse_operator(temp_fname, inv) inv = read_inverse_operator(temp_fname) stc = apply_inverse(evoked, inv, method='eLORETA', method_params=dict(eps=1e-2)) # assert zero localization bias assert_array_equal(np.argmax(stc.data, axis=0), np.repeat(np.arange(101), 3))
def test_io_inverse_operator(): """Test IO of inverse_operator.""" tempdir = _TempDir() inverse_operator = read_inverse_operator(fname_inv) x = repr(inverse_operator) assert (x) assert (isinstance(inverse_operator['noise_cov'], Covariance)) # just do one example for .gz, as it should generalize _compare_io(inverse_operator, '.gz') # test warnings on bad filenames inv_badname = op.join(tempdir, 'test-bad-name.fif.gz') with pytest.warns(RuntimeWarning, match='-inv.fif'): write_inverse_operator(inv_badname, inverse_operator) with pytest.warns(RuntimeWarning, match='-inv.fif'): read_inverse_operator(inv_badname) # make sure we can write and read inv_fname = op.join(tempdir, 'test-inv.fif') args = (10, 1. / 9., 'dSPM') inv_prep = prepare_inverse_operator(inverse_operator, *args) write_inverse_operator(inv_fname, inv_prep) inv_read = read_inverse_operator(inv_fname) _compare(inverse_operator, inv_read) inv_read_prep = prepare_inverse_operator(inv_read, *args) _compare(inv_prep, inv_read_prep) inv_prep_prep = prepare_inverse_operator(inv_prep, *args) _compare(inv_prep, inv_prep_prep)
def run_inverse(subject, session=None): print("Processing subject: %s" % subject) # 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) 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) fpath_deriv = op.join(config.bids_root, 'derivatives', config.PIPELINE_NAME, subject_path) fname_ave = \ op.join(fpath_deriv, bids_basename + '-ave.fif') fname_fwd = \ op.join(fpath_deriv, bids_basename + '-fwd.fif') fname_cov = \ op.join(fpath_deriv, bids_basename + '-cov.fif') fname_inv = \ op.join(fpath_deriv, bids_basename + '-inv.fif') evokeds = mne.read_evokeds(fname_ave) cov = mne.read_cov(fname_cov) forward = mne.read_forward_solution(fname_fwd) info = evokeds[0].info inverse_operator = make_inverse_operator(info, forward, cov, loose=0.2, depth=0.8) write_inverse_operator(fname_inv, inverse_operator) # Apply inverse snr = 3.0 lambda2 = 1.0 / snr**2 for condition, evoked in zip(config.conditions, evokeds): stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM", pick_ori=None) stc.save( op.join( fpath_deriv, '%s_%s_mne_dSPM_inverse-%s' % (config.study_name, subject, condition.replace(op.sep, ''))))
def calc_inverse_operator(events_id, epochs_fn, fwd_sub_fn, inv_fn, min_crop_t=None, max_crop_t=0): for cond in events_id.keys(): epochs = mne.read_epochs(epochs_fn.format(cond=cond)) noise_cov = mne.compute_covariance(epochs.crop(min_crop_t, max_crop_t, copy=True)) forward_sub = mne.read_forward_solution(fwd_sub_fn.format(cond=cond)) inverse_operator_sub = make_inverse_operator(epochs.info, forward_sub, noise_cov, loose=None, depth=None) write_inverse_operator(inv_fn.format(cond=cond), inverse_operator_sub)
def run_inverse(subject, session=None): bids_path = BIDSPath(subject=subject, session=session, task=config.get_task(), acquisition=config.acq, run=None, recording=config.rec, space=config.space, extension='.fif', datatype=config.get_datatype(), root=config.deriv_root, check=False) fname_ave = bids_path.copy().update(suffix='ave') fname_fwd = bids_path.copy().update(suffix='fwd') fname_cov = bids_path.copy().update(suffix='cov') fname_inv = bids_path.copy().update(suffix='inv') evokeds = mne.read_evokeds(fname_ave) cov = mne.read_cov(fname_cov) forward = mne.read_forward_solution(fname_fwd) info = evokeds[0].info inverse_operator = make_inverse_operator(info, forward, cov, loose=0.2, depth=0.8, rank='info') write_inverse_operator(fname_inv, inverse_operator) # Apply inverse snr = 3.0 lambda2 = 1.0 / snr**2 if isinstance(config.conditions, dict): conditions = list(config.conditions.keys()) else: conditions = config.conditions for condition, evoked in zip(conditions, evokeds): method = config.inverse_method pick_ori = None cond_str = config.sanitize_cond_name(condition) inverse_str = method hemi_str = 'hemi' # MNE will auto-append '-lh' and '-rh'. fname_stc = bids_path.copy().update( suffix=f'{cond_str}+{inverse_str}+{hemi_str}', extension=None) if "eeg" in config.ch_types: evoked.set_eeg_reference('average', projection=True) stc = apply_inverse(evoked=evoked, inverse_operator=inverse_operator, lambda2=lambda2, method=method, pick_ori=pick_ori) stc.save(fname_stc)
def run(): args = sys.argv if len(args) <= 1: print 'Usage: run_anatomy_tutorial.sh <sample data directory>' return sample_dir = args[1] subjects_dir = join(sample_dir, 'subjects') meg_dir = join(sample_dir, 'MEG', 'sample') os.environ['SUBJECTS_DIR'] = subjects_dir os.environ['MEG_DIR'] = meg_dir subject = 'sample' bem = join(subjects_dir, subject, 'bem', 'sample-5120-bem-sol.fif') mri = join(subjects_dir, subject, 'mri', 'T1.mgz') fname = join(subjects_dir, subject, 'bem', 'volume-7mm-src.fif') src = setup_volume_source_space(subject, fname=fname, pos=7, mri=mri, bem=bem, overwrite=True, subjects_dir=subjects_dir) ############################################################################### # Compute forward solution a.k.a. lead field raw = mne.io.Raw(join(meg_dir, 'sample_audvis_raw.fif')) fwd_fname = join(meg_dir, 'sample_audvis-meg-vol-7-fwd.fif') trans = join(meg_dir, 'sample_audvis_raw-trans.fif') # for MEG only fwd = make_forward_solution(raw.info, trans=trans, src=src, bem=bem, fname=fwd_fname, meg=True, eeg=False, overwrite=True) # Make a sensitivity map smap = mne.sensitivity_map(fwd, ch_type='grad', mode='free') smap.save(join(meg_dir, 'sample_audvis-grad-vol-7-fwd-sensmap'), ftype='w') ############################################################################### # Compute MNE inverse operators # # Note: The MEG/EEG forward solution could be used for all # noise_cov = mne.read_cov(join(meg_dir, 'sample_audvis-cov.fif')) inv = make_inverse_operator(raw.info, fwd, noise_cov) fname = join(meg_dir, 'sample_audvis-meg-vol-7-meg-inv.fif') write_inverse_operator(fname, inv)
def run_inverse(subject, session=None): deriv_path = config.get_subject_deriv_path(subject=subject, session=session, kind=config.get_kind()) bids_basename = BIDSPath(subject=subject, session=session, task=config.get_task(), acquisition=config.acq, run=None, recording=config.rec, space=config.space, prefix=deriv_path, extension='.fif', check=False) fname_ave = bids_basename.copy().update(kind='ave') fname_fwd = bids_basename.copy().update(kind='fwd') fname_cov = bids_basename.copy().update(kind='cov') fname_inv = bids_basename.copy().update(kind='inv') evokeds = mne.read_evokeds(fname_ave) cov = mne.read_cov(fname_cov) forward = mne.read_forward_solution(fname_fwd) info = evokeds[0].info inverse_operator = make_inverse_operator(info, forward, cov, loose=0.2, depth=0.8, rank='info') write_inverse_operator(fname_inv, inverse_operator) # Apply inverse snr = 3.0 lambda2 = 1.0 / snr**2 for condition, evoked in zip(config.conditions, evokeds): method = config.inverse_method pick_ori = None cond_str = condition.replace(op.sep, '').replace('_', '') inverse_str = method hemi_str = 'hemi' # MNE will auto-append '-lh' and '-rh'. fname_stc = bids_basename.copy().update( kind=f'{cond_str}+{inverse_str}+{hemi_str}', extension=None) stc = apply_inverse(evoked=evoked, inverse_operator=inverse_operator, lambda2=lambda2, method=method, pick_ori=pick_ori) stc.save(fname_stc)
def run_inverse(subject, session=None): deriv_path = config.get_subject_deriv_path(subject=subject, session=session, kind=config.get_kind()) 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) fname_ave = op.join(deriv_path, bids_basename + '-ave.fif') fname_fwd = op.join(deriv_path, bids_basename + '-fwd.fif') fname_cov = op.join(deriv_path, bids_basename + '-cov.fif') fname_inv = op.join(deriv_path, bids_basename + '-inv.fif') evokeds = mne.read_evokeds(fname_ave) cov = mne.read_cov(fname_cov) forward = mne.read_forward_solution(fname_fwd) info = evokeds[0].info inverse_operator = make_inverse_operator(info, forward, cov, loose=0.2, depth=0.8, rank='info') write_inverse_operator(fname_inv, inverse_operator) # Apply inverse snr = 3.0 lambda2 = 1.0 / snr**2 for condition, evoked in zip(config.conditions, evokeds): method = config.inverse_method pick_ori = None cond_str = 'cond-%s' % condition.replace(op.sep, '') inverse_str = 'inverse-%s' % method hemi_str = 'hemi' # MNE will auto-append '-lh' and '-rh'. fname_stc = op.join( deriv_path, '_'.join([bids_basename, cond_str, inverse_str, hemi_str])) stc = apply_inverse(evoked=evoked, inverse_operator=inverse_operator, lambda2=lambda2, method=method, pick_ori=pick_ori) stc.save(fname_stc)
def mne_inv_operator(self, overwrite=False): from mne.minimum_norm import (read_inverse_operator, make_inverse_operator, write_inverse_operator) fname = self.subject + '_' + self.experiment + '_mne-inv.fif.gz' out_fname = op.join(self.out_srcData, fname) if op.exists(out_fname) and not overwrite: print('Reading inverse operator from file') self.inv = read_inverse_operator(out_fname) else: self.inv = make_inverse_operator(self.epochs.info, self.fwd, self.ncov, loose=0.2, depth=0.8) write_inverse_operator(out_fname, self.inv)
def run_inverse(subject_id): subject = "sub%03d" % subject_id print("processing subject: %s" % subject) data_path = op.join(meg_dir, subject) fname_ave = op.join(data_path, '%s_highpass-%sHz-ave.fif' % (subject, l_freq)) fname_cov = op.join(data_path, '%s_highpass-%sHz-cov.fif' % (subject, l_freq)) fname_fwd = op.join(data_path, '%s-meg-eeg-%s-fwd.fif' % (subject, spacing)) fname_inv = op.join( data_path, '%s_highpass-%sHz-meg-eeg-%s-inv.fif' % (subject, l_freq, spacing)) evokeds = mne.read_evokeds(fname_ave, condition=[ 'scrambled', 'unfamiliar', 'famous', 'faces', 'contrast', 'faces_eq', 'scrambled_eq' ]) cov = mne.read_cov(fname_cov) forward = mne.read_forward_solution(fname_fwd) # This will be an MEG-only inverse because the 3-layer BEMs are not # reliable, so our forward only has MEG channels. info = evokeds[0].info inverse_operator = make_inverse_operator(info, forward, cov, loose=0.2, depth=0.8) write_inverse_operator(fname_inv, inverse_operator) # Apply inverse snr = 3.0 lambda2 = 1.0 / snr**2 for evoked in evokeds: stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM", pick_ori='vector') stc.save( op.join( data_path, 'mne_dSPM_inverse_highpass-%sHz-%s' % (l_freq, evoked.comment)))
def _compare_io(inv_op, out_file_ext='.fif'): """Compare inverse IO.""" tempdir = _TempDir() if out_file_ext == '.fif': out_file = op.join(tempdir, 'test-inv.fif') elif out_file_ext == '.gz': out_file = op.join(tempdir, 'test-inv.fif.gz') else: raise ValueError('IO test could not complete') out_file = Path(out_file) # Test io operations inv_init = copy.deepcopy(inv_op) write_inverse_operator(out_file, inv_op) read_inv_op = read_inverse_operator(out_file) _compare(inv_init, read_inv_op) _compare(inv_init, inv_op)
def estimate_inverse_solution(info, noise_cov_mat, fwd_sol=None, fname_fwd=None, fname_inv=None): """"Estimates inverse solution for the given data set.""" if fwd_sol is not None: pass elif fname_fwd is not None: fwd_sol = mne.read_forward_solution(fname_fwd, surf_ori=True) else: print "ERROR: Neither a forward solution given nor the filename of one!" sys.exit() # restrict forward solution as necessary for MEG fwd = mne.fiff.pick_types_forward(fwd_sol, meg=True, eeg=False) # # regularize noise covariance # # --> not necessary as the data set to estimate the # # noise-covariance matrix is quiet long, i.e. # # the noise-covariance matrix is robust # noise_cov_mat = mne.cov.regularize(noise_cov_mat, # info, # mag=0.1, # proj=True, # verbose=verbose) # create the MEG inverse operators print ">>>> estimate inverse operator..." inverse_operator = min_norm.make_inverse_operator(info, fwd, noise_cov_mat, loose=0.2, depth=0.8) if fname_inv is not None: min_norm.write_inverse_operator(fname_inv, inverse_operator) return inverse_operator
def inverse_function(sub_id, session): """ Will calculate the inverse model based dSPM """ data_path = "/media/mje/My_Book/Data/MEG/MEG_libet/sub_2_tests" fname = "sub_%d_%s_tsss_mc" % (sub_id, session) fname_epochs = data_path + fname + "_epochs.fif" fname_fwd_meg = data_path + fname + "_fwd.fif" fname_cov = data_path + fname + "_cov.fif" fname_inv = data_path + fname + "_inv.fif" fname_stcs = fname + "_mne_dSPM_inverse" epochs = mne.read_epochs(fname_epochs) evoked = epochs.average() snr = 3.0 lambda2 = 1.0 / snr ** 2 # Load data forward_meg = mne.read_forward_solution(fname_fwd_meg, surf_ori=True) noise_cov = mne.read_cov(fname_cov) # regularize noise covariance noise_cov = mne.cov.regularize(noise_cov, evoked.info, mag=0.05, grad=0.05, eeg=0.1, proj=True) # Restrict forward solution as necessary for MEG forward_meg = mne.fiff.pick_types_forward(forward_meg, meg=True, eeg=False) # make an M/EEG, MEG-only, and EEG-only inverse operators info = evoked.info inverse_operator_meg = make_inverse_operator(info, forward_meg, noise_cov, loose=0.2, depth=0.8) write_inverse_operator(fname_inv, inverse_operator_meg) # Compute inverse solution stc = apply_inverse(evoked, inverse_operator_meg, lambda2, "dSPM", pick_normal=False) # Save result in stc files stc.save(fname_stcs)
def apply_inverse_ave(fnevo, subjects_dir): ''' Make individual inverse operator. Parameter --------- fnevo: string or list The evoked file with ECG, EOG and environmental noise free. subjects_dir: The total bath of all the subjects. ''' from mne import make_forward_solution from mne.minimum_norm import make_inverse_operator, write_inverse_operator fnlist = get_files_from_list(fnevo) # loop across all filenames for fname in fnlist: fn_path = os.path.split(fname)[0] name = os.path.basename(fname) subject = name.split('_')[0] fn_inv = fn_path + '/%s_fibp1-45,ave-inv.fif' % subject subject_path = subjects_dir + '/%s' % subject fn_trans = fn_path + '/%s-trans.fif' % subject fn_cov = fn_path + '/%s_empty,fibp1-45-cov.fif' % subject fn_src = subject_path + '/bem/%s-ico-5-src.fif' % subject fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject [evoked] = mne.read_evokeds(fname) evoked.pick_types(meg=True, ref_meg=False) noise_cov = mne.read_cov(fn_cov) # noise_cov = dSPM.cov.regularize(noise_cov, evoked.info, # mag=0.05, grad=0.05, proj=True) fwd = make_forward_solution(evoked.info, fn_trans, fn_src, fn_bem) fwd['surf_ori'] = True inv = make_inverse_operator(evoked.info, fwd, noise_cov, loose=0.2, depth=0.8, limit_depth_chs=False) write_inverse_operator(fn_inv, inv)
def _calc_inverse(params): subject, epochs, overwrite = params epo = op.join(REMOTE_ROOT_DIR, 'ave', '{}_ecr_nTSSS_conflict-epo.fif'.format(subject)) fwd = op.join(REMOTE_ROOT_DIR, 'fwd', '{}_ecr-fwd.fif'.format(subject)) local_inv_file_name = op.join(LOCAL_ROOT_DIR, 'inv', '{}_ecr_nTSSS_conflict-inv.fif'.format(subject)) if os.path.isfile(local_inv_file_name) and not overwrite: inverse_operator = read_inverse_operator(local_inv_file_name) print('inv already calculated for {}'.format(subject)) else: if epochs is None: epochs = mne.read_epochs(epo) noise_cov = mne.compute_covariance(epochs.crop(None, 0, copy=True)) inverse_operator = None if not os.path.isfile(fwd): print('no fwd for {}'.format(subject)) else: forward = mne.read_forward_solution(fwd) inverse_operator = make_inverse_operator(epochs.info, forward, noise_cov, loose=None, depth=None) write_inverse_operator(local_inv_file_name, inverse_operator) return inverse_operator
def apply_inverse_oper(fnepo, tmin=-0.2, tmax=0.8, subjects_dir=None): ''' Apply inverse operator Parameter --------- fnepo: string or list The epochs file with ECG, EOG and environmental noise free. tmax, tmax:float The time period (second) of each epoch. ''' # Get the default subjects_dir from mne import make_forward_solution from mne.minimum_norm import make_inverse_operator, write_inverse_operator fnlist = get_files_from_list(fnepo) # loop across all filenames for fname in fnlist: fn_path = os.path.split(fname)[0] name = os.path.basename(fname) subject = name.split('_')[0] subject_path = subjects_dir + '/%s' % subject fn_trans = fn_path + '/%s-trans.fif' % subject fn_cov = fn_path + '/%s_empty-cov.fif' % subject fn_src = subject_path + '/bem/%s-oct-6-src.fif' % subject fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject fn_inv = fn_path + '/%s_epo-inv.fif' % subject epochs = mne.read_epochs(fname) epochs.crop(tmin, tmax) epochs.pick_types(meg=True, ref_meg=False) noise_cov = mne.read_cov(fn_cov) fwd = make_forward_solution(epochs.info, fn_trans, fn_src, fn_bem) fwd['surf_ori'] = True inv = make_inverse_operator(epochs.info, fwd, noise_cov, loose=0.2, depth=0.8, limit_depth_chs=False) write_inverse_operator(fn_inv, inv)
def apply_inverse_ave(fnevo, subjects_dir): ''' Make individual inverse operator. Parameter --------- fnevo: string or list The evoked file with ECG, EOG and environmental noise free. subjects_dir: The total bath of all the subjects. ''' from mne import make_forward_solution from mne.minimum_norm import make_inverse_operator, write_inverse_operator fnlist = get_files_from_list(fnevo) # loop across all filenames for fname in fnlist: fn_path = os.path.split(fname)[0] name = os.path.basename(fname) subject = name.split('_')[0] fn_inv = fn_path + '/%s_fibp1-45,ave-inv.fif' % subject subject_path = subjects_dir + '/%s' % subject fn_trans = fn_path + '/%s-trans.fif' % subject fn_cov = fn_path + '/%s_empty,fibp1-45-cov.fif' % subject fn_src = subject_path + '/bem/%s-oct-6-src.fif' % subject fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject [evoked] = mne.read_evokeds(fname) evoked.pick_types(meg=True, ref_meg=False) noise_cov = mne.read_cov(fn_cov) # noise_cov = mne.cov.regularize(noise_cov, evoked.info, # mag=0.05, grad=0.05, proj=True) fwd = make_forward_solution(evoked.info, fn_trans, fn_src, fn_bem) fwd['surf_ori'] = True inv = make_inverse_operator(evoked.info, fwd, noise_cov, loose=0.2, depth=0.8, limit_depth_chs=False) write_inverse_operator(fn_inv, inv)
def test_channel_name_limit(tmp_path, monkeypatch, fname): """Test that our remapping works properly.""" # # raw # if fname.endswith('fif'): raw = read_raw_fif(fname) raw.pick_channels(raw.ch_names[:3]) ref_names = [] data_names = raw.ch_names else: assert fname.endswith('.ds') raw = read_raw_ctf(fname) ref_names = [ raw.ch_names[pick] for pick in pick_types(raw.info, meg=False, ref_meg=True) ] data_names = raw.ch_names[32:35] proj = dict(data=np.ones((1, len(data_names))), col_names=data_names[:2].copy(), row_names=None, nrow=1) proj = Projection(data=proj, active=False, desc='test', kind=0, explained_var=0.) raw.add_proj(proj, remove_existing=True) raw.info.normalize_proj() raw.pick_channels(data_names + ref_names).crop(0, 2) long_names = ['123456789abcdefg' + name for name in raw.ch_names] fname = tmp_path / 'test-raw.fif' with catch_logging() as log: raw.save(fname) log = log.getvalue() assert 'truncated' not in log rename = dict(zip(raw.ch_names, long_names)) long_data_names = [rename[name] for name in data_names] long_proj_names = long_data_names[:2] raw.rename_channels(rename) for comp in raw.info['comps']: for key in ('row_names', 'col_names'): for name in comp['data'][key]: assert name in raw.ch_names if raw.info['comps']: assert raw.compensation_grade == 0 raw.apply_gradient_compensation(3) assert raw.compensation_grade == 3 assert len(raw.info['projs']) == 1 assert raw.info['projs'][0]['data']['col_names'] == long_proj_names raw.info['bads'] = bads = long_data_names[2:3] good_long_data_names = [ name for name in long_data_names if name not in bads ] with catch_logging() as log: raw.save(fname, overwrite=True, verbose=True) log = log.getvalue() assert 'truncated to 15' in log for name in raw.ch_names: assert len(name) > 15 # first read the full way with catch_logging() as log: raw_read = read_raw_fif(fname, verbose=True) log = log.getvalue() assert 'Reading extended channel information' in log for ra in (raw, raw_read): assert ra.ch_names == long_names assert raw_read.info['projs'][0]['data']['col_names'] == long_proj_names del raw_read # next read as if no longer names could be read monkeypatch.setattr(meas_info, '_read_extended_ch_info', lambda x, y, z: None) with catch_logging() as log: raw_read = read_raw_fif(fname, verbose=True) log = log.getvalue() assert 'extended' not in log if raw.info['comps']: assert raw_read.compensation_grade == 3 raw_read.apply_gradient_compensation(0) assert raw_read.compensation_grade == 0 monkeypatch.setattr( # restore meas_info, '_read_extended_ch_info', _read_extended_ch_info) short_proj_names = [ f'{name[:13 - bool(len(ref_names))]}-{len(ref_names) + ni}' for ni, name in enumerate(long_data_names[:2]) ] assert raw_read.info['projs'][0]['data']['col_names'] == short_proj_names # # epochs # epochs = Epochs(raw, make_fixed_length_events(raw)) fname = tmp_path / 'test-epo.fif' epochs.save(fname) epochs_read = read_epochs(fname) for ep in (epochs, epochs_read): assert ep.info['ch_names'] == long_names assert ep.ch_names == long_names del raw, epochs_read # cov epochs.info['bads'] = [] cov = compute_covariance(epochs, verbose='error') fname = tmp_path / 'test-cov.fif' write_cov(fname, cov) cov_read = read_cov(fname) for co in (cov, cov_read): assert co['names'] == long_data_names assert co['bads'] == [] del cov_read # # evoked # evoked = epochs.average() evoked.info['bads'] = bads assert evoked.nave == 1 fname = tmp_path / 'test-ave.fif' evoked.save(fname) evoked_read = read_evokeds(fname)[0] for ev in (evoked, evoked_read): assert ev.ch_names == long_names assert ev.info['bads'] == bads del evoked_read, epochs # # forward # with _record_warnings(): # not enough points for CTF sphere = make_sphere_model('auto', 'auto', evoked.info) src = setup_volume_source_space( pos=dict(rr=[[0, 0, 0.04]], nn=[[0, 1., 0.]])) fwd = make_forward_solution(evoked.info, None, src, sphere) fname = tmp_path / 'temp-fwd.fif' write_forward_solution(fname, fwd) fwd_read = read_forward_solution(fname) for fw in (fwd, fwd_read): assert fw['sol']['row_names'] == long_data_names assert fw['info']['ch_names'] == long_data_names assert fw['info']['bads'] == bads del fwd_read # # inv # inv = make_inverse_operator(evoked.info, fwd, cov) fname = tmp_path / 'test-inv.fif' write_inverse_operator(fname, inv) inv_read = read_inverse_operator(fname) for iv in (inv, inv_read): assert iv['info']['ch_names'] == good_long_data_names apply_inverse(evoked, inv) # smoke test
fwd = make_forward_solution(raw_crop.info, trans=trans, src=src, bem=bem, meg=True, eeg=False, mindist=0.0, n_jobs=3) write_forward_solution(fwdFile, fwd, overwrite=True) else: fwd = read_forward_solution(fwdFile) # Make (or read) inverse operator if not op.isfile(invFile) or overwrite_pre: inv = make_inverse_operator(raw_crop.info, fwd, noise_cov) write_inverse_operator(invFile, inv) else: inv = read_inverse_operator(invFile) # Do source recon t0 = time.time() stc_dSPM = apply_inverse_raw(raw_crop, inv, lambda2, method="dSPM") # stc_MNE = apply_inverse_raw(raw_crop, inv, lambda2, method="MNE") dt = time.time() - t0 print('Time elapsed: ' + str(dt / 60.0) + ' min') # Save stc_dSPM.save(outFile_dSPM) # stc_MNE.save(outFile_MNE) #END
fwd20, noise_cov30, loose=0.2, depth=0.8) inverse_operator30 = make_inverse_operator(info30, fwd30, noise_cov30, loose=0.2, depth=0.8) inverse_operator40 = make_inverse_operator(info40, fwd40, noise_cov40, loose=0.2, depth=0.8) write_inverse_operator(inv20_fname, inverse_operator20) write_inverse_operator(inv30_fname, inverse_operator30) write_inverse_operator(inv40_fname, inverse_operator40) method = "dSPM" snr = 1. lambda2 = 1. / snr**2 stc40 = apply_inverse(evoked40, inverse_operator40, lambda2, method=method, pick_ori=None) stc30 = apply_inverse(evoked30, inverse_operator30, lambda2,
noise_cov = mne.compute_covariance(epochs, tmax=0., method=['shrunk', 'empirical']) fig_cov, fig_spectra = mne.viz.plot_cov(noise_cov, raw.info) name_temp = data_evoked_directory + bloc + '/' + nip + '/' + stimulus + '_noise-cov.fif' noise_cov.save(name_temp) ################################################################### ###################### Make inverse operator ###################### ################################################################### # Load forward solution fname = data_forward_directory + nip + '/FM_trans_sss_MEG-ico5-fwd.fif' fwd = mne.read_forward_solution(fname, surf_ori=True) fwd = mne.pick_types_forward(fwd, meg=True, eeg=False) # Compute inverse operator info = evoked.info inverse_operator = make_inverse_operator(info, fwd, noise_cov, loose=0.2, depth=0.8) # Save inverse operator name_temp = data_evoked_directory + bloc + '/' + nip + '/' + stimulus + '-inv.fif' write_inverse_operator(name_temp, inverse_operator) # Save HTML report report.save(os.getcwd() + '/2_buildEvokedPerBlock.html', overwrite=True, open_browser=False)
def aud_dataset(self): print 'Treat: ', self.treat ############################################################################### # Setup for reading the raw data data_path = sample.data_path() raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif' event_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif' tmin = -0.2 # start of each epoch (200ms before the trigger) tmax = 0.5 # end of each epoch (500ms after the trigger) self.subject='sample' raw = mne.io.read_raw_fif(raw_fname, add_eeg_ref=False, preload=True,verbose=False) #raw.set_eeg_reference() # set EEG average reference baseline = (None, 0) # means from the first instant to t = 0 reject = dict(mag=4e-12, eog=150e-6) events = mne.read_events(event_fname) picks = mne.pick_types(raw.info, meg='mag', eeg=True, eog=True, exclude='bads') #for simplicity ignore grad channels raw.rename_channels(mapping={'EOG 061': 'EOG'}) event_id = {'left/auditory': 1, 'right/auditory': 2, 'left/visual': 3, 'right/visual': 4} epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=baseline, reject=reject, add_eeg_ref=False, preload=True,verbose=False) if self.treat is not None: self.epochs_eeg = epochs[self.treat].copy().pick_types(eeg=True,meg=False) self.epochs_meg = epochs[self.treat].copy().pick_types(meg=True,eeg=False) else: self.epochs_eeg = epochs.copy().pick_types(eeg=True,meg=False) self.epochs_meg = epochs.copy().pick_types(meg=True,eeg=False) noise_cov = mne.compute_covariance( epochs, tmax=0., method=['shrunk', 'empirical'],verbose=False) ############################################################################### # Inverse modeling: MNE/dSPM on evoked and raw data # ------------------------------------------------- # Read the forward solution and compute the inverse operator fname_fwd = data_path + '/MEG/sample/sample_audvis-meg-oct-5-fwd.fif' fwd = mne.read_forward_solution(fname_fwd, surf_ori=True,verbose=False) # Restrict forward solution as necessary fwd = mne.pick_types_forward(fwd, meg=True, eeg=True) # make an inverse operator info = epochs.info inverse_operator = make_inverse_operator(info, fwd, noise_cov, loose=0.2, depth=0.8,verbose=False) write_inverse_operator('sample_audvis-meg-oct-5-inv.fif', inverse_operator,verbose=False) ############################################################################### # Compute inverse solution # ------------------------ method = "MNE" snr = 3. lambda2 = 1. / snr ** 2 if self.treat is not None: self.stc = apply_inverse_epochs(epochs[self.treat], inverse_operator, lambda2, method=method, pick_ori=None,verbose=False) else: self.stc = apply_inverse_epochs(epochs, inverse_operator, lambda2, method=method, pick_ori=None,verbose=False) if self.Wt is None: print 'Precalculate PCA weights:' #weight PCA matrix. Uses 'self.treat' - so to apply across all treatments, use treat=None self.Wt=Wt_calc(self.stc,self.epochs_eeg,self.epochs_meg) #stc.save('sample_audvis-source-epochs') self.prepro()
snr = 3.0 lambda2 = 1.0 / snr ** 2 # Load data evoked = Evoked(fname_evoked, setno=0, baseline=(None, 0)) forward = mne.read_forward_solution(fname_fwd, surf_ori=True) noise_cov = mne.read_cov(fname_cov) # regularize noise covariance noise_cov = mne.cov.regularize(noise_cov, evoked.info, mag=0.05, grad=0.05, eeg=0.1, proj=True) inverse_operator = make_inverse_operator(evoked.info, forward, noise_cov, loose=0.2, depth=0.8) # Save inverse operator to vizualize with mne_analyze write_inverse_operator("sample_audvis-eeg-oct-6-eeg-inv.fif", inverse_operator) # Compute inverse solution stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM", pick_normal=False) # Save result in stc files stc.save("mne_dSPM_inverse") ############################################################################### # View activation time-series pl.close("all") pl.plot(1e3 * stc.times, stc.data[::150, :].T) pl.xlabel("time (ms)") pl.ylabel("dSPM value") pl.show()
# for evoked data use noise cov based on epochs, however, # if there is no baseline, e.g., in resting state data # there is no stimulus, use empty room noise cov fn_cov = fn_epo.split('-epo.fif')[0] + '-cov.fif' fn_inv = fn_epo.rsplit('-epo.fif')[0] + '-inv.fif' # to read forward solution and noise_cov noise_cov = mne.read_cov(fn_cov) if not op.isfile(fn_inv): # compute the inverse operator (mne_do_inverse_operator) inv = make_inverse_operator(epochs.info, fwd, noise_cov, loose=0.2, depth=0.8, limit_depth_chs=False) write_inverse_operator(fn_inv, inv) else: inv = read_inverse_operator(fn_inv) evoked = epochs.average() # Compute inverse solution for evoked data fn_stc = fn_epo.rsplit('-epo.fif')[0] + ',ave' if not op.isfile(fn_stc + '-lh.stc'): stc = apply_inverse(evoked, inv, lambda2, method, pick_ori=None) stc.save(fn_stc) print('Saved...', fn_stc + '-lh.stc') if plot_stc:
def run(): args = sys.argv if len(args) <= 1: print 'Usage: run_meg_tutorial.sh <sample data directory>' return sample_dir = args[1] subjects_dir = join(sample_dir, 'subjects') meg_dir = join(sample_dir, 'MEG', 'sample') os.environ['SUBJECTS_DIR'] = subjects_dir os.environ['MEG_DIR'] = meg_dir subject = 'sample' src = setup_source_space(subject, fname=True, spacing='oct6', n_jobs=2, overwrite=True) # If one wanted to use other source spaces, these types of options are # available src_fsaverage = setup_source_space('fsaverage', fname=True, spacing='ico5', n_jobs=2, overwrite=True, add_dist=False) morph_source_spaces(src_fsaverage, subject_to='sample') setup_source_space(subject, fname=True, spacing='all', overwrite=True, n_jobs=2, add_dist=False) # Add distances to source space (if desired, takes a long time) bem_dir = join(subjects_dir, join('sample', 'bem')) os.rename(join(bem_dir, 'sample-oct-6-src.fif'), join(bem_dir, 'sample-oct-6-orig-src.fif')) new_src = add_source_space_distances(src, dist_limit=0.007) new_src.save(join(bem_dir, 'sample-oct-6-src.fif')) # Preprocessing raw = mne.io.Raw(join(meg_dir, 'sample_audvis_raw.fif'), preload=True) raw.info['bads'] = ['MEG 2443', 'EEG 053'] reject = dict(grad=3000e-13, mag=4000e-15, eeg=100e-6) ecg_proj, _ = mne.preprocessing.compute_proj_ecg(raw, l_freq=1, h_freq=100, ch_name='MEG 1531', reject=reject) eog_proj, _ = mne.preprocessing.compute_proj_eog(raw, l_freq=1, h_freq=35, reject=reject, no_proj=True) events = mne.find_events(raw) mne.write_events(join(meg_dir, 'sample_audvis_raw-eve.fif'), events) event_id = [1, 2, 3, 4] tmin, tmax = -0.2, 0.5 picks = mne.pick_types(raw.info, meg=True, eeg=True, stim=True, eog=True) # Average with no filter epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks) evoked = epochs.average() evoked.save(join(meg_dir, 'sample_audvis-no-filter-ave.fif')) raw.filter(l_freq=None, h_freq=40) raw_resampled = raw.resample(150) raw_resampled.save(join(meg_dir, 'sample_audvis_filt-0-40_raw.fif'), overwrite=True) raw.add_proj(ecg_proj) raw.add_proj(eog_proj) resampled_events = mne.find_events(raw_resampled) mne.write_events(join(meg_dir, 'sample_audvis_filt-0-40_raw-eve.fif'), resampled_events) # Average with filter epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks) evoked = epochs.average() evoked.save(join(meg_dir, 'sample_audvis-ave.fif')) # Compute the noise covariance matrix noise_cov = mne.compute_raw_data_covariance(raw, picks=picks) noise_cov.save(join(meg_dir, 'audvis.cov')) # Compute the empty-room noise covariance matrix ernoise_raw = mne.io.Raw(join(meg_dir, 'ernoise_raw.fif'), preload=True) ernoise_raw.info['bads'] = ['MEG 2443'] ernoise_raw.filter(l_freq=None, h_freq=40) picks = mne.pick_types(ernoise_raw.info, meg=True, eeg=True, stim=True, eog=True) ernoise_cov = mne.compute_raw_data_covariance(ernoise_raw, picks=picks) ernoise_cov.save(join(meg_dir, 'ernoise.cov')) ############################################################################### # Compute forward solution a.k.a. lead field trans = join(meg_dir, 'sample_audvis_raw-trans.fif') bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-bem-sol.fif') # for MEG only fname = join(meg_dir, 'sample_audvis-meg-oct-6-fwd.fif') fwd_meg = mne.make_forward_solution(raw.info, trans, src, bem, fname=fname, meg=True, eeg=False, mindist=5.0, n_jobs=2, overwrite=True) # for EEG only bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-5120-5120-bem-sol.fif') fname = join(meg_dir, 'sample_audvis-eeg-oct-6-fwd.fif') fwd_eeg = mne.make_forward_solution(raw.info, trans, src, bem, fname=fname, meg=False, eeg=True, mindist=5.0, n_jobs=2, overwrite=True) # for both EEG and MEG fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-fwd.fif') fwd = mne.make_forward_solution(raw.info, trans, src, bem, fname=fname, meg=True, eeg=True, mindist=5.0, n_jobs=2, overwrite=True) # Create various sensitivity maps grad_map = mne.sensitivity_map(fwd, ch_type='grad', mode='free') grad_map.save(join(meg_dir, 'sample_audvis-grad-oct-6-fwd-sensmap'), ftype='w') mag_map = mne.sensitivity_map(fwd, ch_type='mag', mode='free') mag_map.save(join(meg_dir, 'sample_audvis-mag-oct-6-fwd-sensmap'), ftype='w') eeg_map = mne.sensitivity_map(fwd, ch_type='eeg', mode='free') eeg_map.save(join(meg_dir, 'sample_audvis-eeg-oct-6-fwd-sensmap'), ftype='w') grad_map2 = mne.sensitivity_map(fwd, ch_type='grad', mode='fixed') grad_map2.save(join(meg_dir, 'sample_audvis-grad-oct-6-fwd-sensmap-2'), ftype='w') mag_map2 = mne.sensitivity_map(fwd, ch_type='mag', mode='ratio') mag_map2.save(join(meg_dir, 'sample_audvis-mag-oct-6-fwd-sensmap-3'), ftype='w') # Compute some with the EOG + ECG projectors projs = ecg_proj + eog_proj + raw.info['projs'] for map_type in ['radiality', 'angle', 'remaining', 'dampening']: eeg_map = mne.sensitivity_map(fwd, projs=projs, ch_type='eeg', mode=map_type) eeg_map.save(join(meg_dir, 'sample_audvis-eeg-oct-6-fwd-sensmap-' + map_type)) ############################################################################### # Compute MNE inverse operators # # Note: The MEG/EEG forward solution could be used for all # inv_meg = make_inverse_operator(raw.info, fwd_meg, noise_cov, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-inv.fif') write_inverse_operator(fname, inv_meg) inv_eeg = make_inverse_operator(raw.info, fwd_eeg, noise_cov, loose=0.2) fname = join(meg_dir, 'sample_audvis-eeg-oct-6-eeg-inv.fif') write_inverse_operator(fname, inv_eeg) inv = make_inverse_operator(raw.info, fwd, noise_cov, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-meg-eeg-inv.fif') write_inverse_operator(fname, inv) # inverse operator with fixed orientation (for testing). Not implemented #inv_fixed = make_inverse_operator(raw.info, fwd_meg, noise_cov, # depth=None, fixed=True) #fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-nodepth-fixed-inv.fif') #write_inverse_operator(fname, inv_fixed) # produce two with diagonal noise (for testing) diag = noise_cov.as_diag() inv_meg_diag = make_inverse_operator(raw.info, fwd_meg, diag, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-diagnoise-inv.fif') write_inverse_operator(fname, inv_meg_diag) inv_eeg_diag = make_inverse_operator(raw.info, fwd, diag, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-meg-eeg-diagnoise-inv.fif') write_inverse_operator(fname, inv_eeg_diag) # Produce stc files evoked.crop(0, 0.25) stc_meg = apply_inverse(evoked, inv_meg, method='MNE') stc_meg.save(join(meg_dir, 'sample_audvis-meg')) stc_eeg = apply_inverse(evoked, inv_eeg, method='MNE') stc_eeg.save(join(meg_dir, 'sample_audvis-eeg')) stc = apply_inverse(evoked, inv, method='MNE') stc.save(join(meg_dir, 'sample_audvis-meg-eeg')) # let's also morph to fsaverage stc_to = stc_meg.morph('fsaverage', grade=3, smooth=12) stc_to.save(join(meg_dir, 'fsaverage_audvis-meg')) stc_to = stc_eeg.morph('fsaverage', grade=3, smooth=12) stc_to.save(join(meg_dir, 'fsaverage_audvis-eeg')) stc_to = stc.morph('fsaverage', grade=3, smooth=12) stc_to.save(join(meg_dir, 'fsaverage_audvis-meg-eeg')) ############################################################################### # Do one dipole fitting evoked = evoked.pick_types(meg=True, eeg=False) evoked.crop(0.04, 0.095) bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-bem-sol.fif') dip, _ = mne.fit_dipole(evoked, noise_cov, bem, trans) dip.save(join(meg_dir, 'sample_audvis_set1.dip'))
def EpochAndAverage_eq(condnames,datasource,ListSubj,listRunPerSubj,EEGbadlist,nbtrial,LKMEG,LKEEG,LKMEEG): #ipython --pylab import mne import matplotlib.pyplot as pl import numpy as np import random from scipy import io from copy import deepcopy import os os.chdir('/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/SCRIPTS/MNE_PYTHON') import MatchEventsFT2MNE as match import time from mne.minimum_norm import (make_inverse_operator, apply_inverse, write_inverse_operator) os.environ['SUBJECTS_DIR'] = '/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/mri' os.environ['MNE_ROOT'] = '/neurospin/local/mne' wdir = "/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/" #wdir = "/media/bgauthie/Seagate Backup Plus Drive/TMP_MEG_SOURCE/MEG/" for i in range(len(ListSubj)): # open a text logfile logfile = open(wdir+ListSubj[i]+"/mne_python/logfile_preproc.txt", "w") logfile.write(time.strftime("%d/%m/%Y")+"\n") logfile.write(time.strftime("%H:%M:%S")+"\n") fname_fwd_eeg = (wdir+ListSubj[i]+"/mne_python/run3_ico-5_eegonly_-fwd.fif") fname_fwd_meg = (wdir+ListSubj[i]+"/mne_python/run3_ico-5_megonly_-fwd.fif") fname_fwd_meeg = (wdir+ListSubj[i]+"/mne_python/run3_ico-5_meeg_-fwd.fif") for j in range(len(listRunPerSubj[i])): print(j) print(i) # load trans_sss data raw = mne.io.Raw(wdir+ListSubj[i]+"/mne_python/preproc_"+listRunPerSubj[i][j]+"_trans_sss_raw.fif", preload = True) # band-pass filter 1-35Hz raw.filter(l_freq = 1, h_freq=35, method = 'iir',n_jobs=3) # Specify bad channels raw.info['bads'] += EEGbadlist[i] # define events : import trial definition from fieldtrip and with mne_function tmp = str(j+1) fileE = io.loadmat("/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/From_laptop/Subjects/"+ListSubj[i]+"/PsychData/events"+tmp+".mat") eventsFT = fileE['fullsubj'] eventsMNE = mne.find_events(raw, stim_channel=['STI101'],consecutive = False) print "%d events found" %len(eventsMNE) logfile.write("" "\n") logfile.write("processing subject " +ListSubj[i]+""+listRunPerSubj[i][j]+"\n") logfile.write("%d mne events found " %len(eventsMNE)+"\n") logfile.write("%d ft events found " %len(eventsFT)+"\n") logfile.write("" "\n") # find events corresponding to FT run j itemindex = np.where(eventsFT[:,7]==(j+1)) eventsFT = eventsFT[itemindex[0],:] # set the "zero point" to a target event in MNE event (Ft to MNE sample matching strategy, because different zero time convention)) initsampmne = eventsMNE[np.where(eventsMNE[:,2] == 18)[0][0],0] for l in range(eventsMNE.shape[0]): eventsMNE[l,0] = eventsMNE[l,0] - initsampmne # set the "zero point" to a target event in FT event initsampft = eventsFT[np.where(eventsFT[:,6] == 18)[0][0],0] for l in range(eventsFT.shape[0]): eventsFT[l,0] = eventsFT[l,0] - initsampft # Select original event before recoding according to the condition and the source dataset if datasource == 'EVT': origevent = [16,20,24,28,32,17,21,25,29,33] # find events corresponding to "Historical events" stimuli init = np.where(eventsFT[:,6]== origevent[0]) for k in origevent[1:]: init = np.append(init,np.where(eventsFT[:,6]== k)[0]) eventsFT = eventsFT[init,:] del init elif datasource == 'EVS': origevent = [18,22,26,30,34,19,23,27,31,35] # find events corresponding to "Historical events" stimuli init = np.where(eventsFT[:,6]== origevent[0]) for k in origevent[1:]: init = np.append(init,np.where(eventsFT[:,6]== k)[0]) eventsFT = eventsFT[init,:] del init elif datasource == 'QTT': origevent = [6,8,10,12,14] # find events corresponding to "Historical events" stimuli init = np.where(eventsFT[:,6]== origevent[0]) for k in origevent[1:]: init = np.append(init,np.where(eventsFT[:,6]== k)[0]) eventsFT = eventsFT[init,:] del init elif datasource == 'QTS': origevent = [7,9,11,13,15] # find events corresponding to "Historical events" stimuli init = np.where(eventsFT[:,6]== origevent[0]) for k in origevent[1:]: init = np.append(init,np.where(eventsFT[:,6]== k)[0]) eventsFT = eventsFT[init,:] del init # reject bad data based on fieldtrip "ft_rejectvisual" good_meg = np.where(eventsFT[:,8]== 1) good_eeg = np.where(eventsFT[:,9]== 1) good_meeg = np.where(np.multiply(eventsFT[:,8],eventsFT[:,9])==1) eventsFT_meg = eventsFT[good_meg[0],:] eventsFT_eeg = eventsFT[good_eeg[0],:] eventsFT_meeg = eventsFT[good_meeg[0],:] # get the FT event in MNE events (should be the same but a small sample of events isn't matched # (FIXME) SelEve_meg = match.MatchEventsFT2MNE(eventsMNE,eventsFT_meg) SelEve_eeg = match.MatchEventsFT2MNE(eventsMNE,eventsFT_eeg) SelEve_meeg = match.MatchEventsFT2MNE(eventsMNE,eventsFT_meeg) # get back to the original timing for m in range(SelEve_meg.shape[0]): SelEve_meg[m,0] = SelEve_meg[m,0] + initsampmne for n in range(SelEve_eeg.shape[0]): SelEve_eeg[n,0] = SelEve_eeg[n,0] + initsampmne for k in range(SelEve_meeg.shape[0]): SelEve_meeg[k,0] = SelEve_meeg[k,0] + initsampmne # correct for photodelay for m in range(SelEve_meg.shape[0]): SelEve_meg[m,0] = SelEve_meg[m,0] + 60 for n in range(SelEve_eeg.shape[0]): SelEve_eeg[n,0] = SelEve_eeg[n,0] + 60 for k in range(SelEve_meeg.shape[0]): SelEve_meeg[k,0] = SelEve_meeg[k,0] + 60 TMPset1 = io.loadmat("/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/From_laptop/Scripts/event_def_for_mne/"+condnames+".mat") DATASET1 = TMPset1['cond'] logfile.write("%d selected final meg events" %len(SelEve_meg)+"\n") logfile.write("%d selected final eeg events" %len(SelEve_eeg)+"\n") logfile.write("%d selected final meeg events" %len(SelEve_meeg)+"\n") # process cond1 ev_meg = np.intersect1d(SelEve_meg[:,2].astype(int).tolist(),DATASET1[:,0].tolist()) ev_eeg = np.intersect1d(SelEve_eeg[:,2].astype(int).tolist(),DATASET1[:,0].tolist()) ev_meeg = np.intersect1d(SelEve_meeg[:,2].astype(int).tolist(),DATASET1[:,0].tolist()) event_id1_meg , tmin, tmax = ev_meg.tolist(), -0.2, 1.1 event_id1_eeg , tmin, tmax = ev_eeg.tolist(), -0.2, 1.1 event_id1_meeg, tmin, tmax = ev_meeg.tolist(), -0.2, 1.1 # epoched data picksmeg = mne.pick_types(raw.info, meg=True, eeg=False, stim=True , eog=False, include=[], exclude='bads') pickseeg = mne.pick_types(raw.info, meg=False, eeg=True, stim=True , eog=False, include=[], exclude='bads') picksmeeg = mne.pick_types(raw.info, meg=True , eeg=True, stim=True , eog=False, include=[], exclude='bads') epochs_cond1_meg = mne.Epochs(raw, SelEve_meg, event_id1_meg, tmin, tmax, baseline=(-0.2, 0),picks = picksmeg,preload = True,decim=4,reject = None,on_missing = 'warning') epochs_cond1_eeg = mne.Epochs(raw, SelEve_eeg, event_id1_eeg, tmin, tmax, baseline=(-0.2, 0),picks = pickseeg,preload = True,decim=4,reject = None,on_missing = 'warning') epochs_cond1_meeg= mne.Epochs(raw, SelEve_meeg, event_id1_meeg,tmin, tmax, baseline=(-0.2, 0),picks = picksmeeg,preload = True,decim=4,reject= None,on_missing = 'warning') baseline_cond1_meg = mne.Epochs(raw, SelEve_meg, event_id1_meg, -0.2, 0, baseline=(None, 0),picks = picksmeg,preload = True,reject = None,on_missing = 'warning') baseline_cond1_eeg = mne.Epochs(raw, SelEve_eeg, event_id1_eeg, -0.2, 0, baseline=(None, 0),picks = pickseeg,preload = True,reject = None,on_missing = 'warning') baseline_cond1_meeg= mne.Epochs(raw, SelEve_meeg, event_id1_meeg, -0.2, 0, baseline=(None, 0),picks= picksmeeg,preload = True,reject = None,on_missing = 'warning') # Drop epochs for nb trial equalization (impacts SNR and so final source amplitude) # to do this: remove (actual nb trial - (ideal nb trial)*(% trial kept overall for the subject - 5%)) n_event_meg = epochs_cond1_meg.events.shape[0] n_event_eeg = epochs_cond1_eeg.events.shape[0] n_event_meeg = epochs_cond1_meeg.events.shape[0] n_event_toremove_meg = n_event_meg -np.floor(nbtrial*(LKMEG[i]-0.05)) n_event_toremove_eeg = n_event_eeg -np.floor(nbtrial*(LKEEG[i]-0.05)) n_event_toremove_meeg = n_event_meeg -np.floor(nbtrial*(LKMEEG[i]-0.05)) # if there is not enough events, don't remove any trial (FIXME) if n_event_toremove_meg > 0: event_toremove_ind_meg = random.sample(range(n_event_meg), n_event_toremove_meg.astype(int)) epochs_cond1_meg.drop_epochs(event_toremove_ind_meg) baseline_cond1_meg.drop_epochs(event_toremove_ind_meg) if n_event_toremove_eeg > 0: event_toremove_ind_eeg = random.sample(range(n_event_eeg), n_event_toremove_eeg.astype(int)) epochs_cond1_eeg.drop_epochs(event_toremove_ind_eeg) baseline_cond1_eeg.drop_epochs(event_toremove_ind_eeg) if n_event_toremove_meeg > 0: event_toremove_ind_meeg = random.sample(range(n_event_meeg), n_event_toremove_meeg.astype(int)) epochs_cond1_meeg.drop_epochs(event_toremove_ind_meeg) baseline_cond1_meeg.drop_epochs(event_toremove_ind_meeg) # compute noise covariance matrix from baseline epochs # evokedcond1_meg = epochs_cond1_meg.average() evokedcond1_eeg = epochs_cond1_eeg.average() evokedcond1_meeg= epochs_cond1_meeg.average() noise_cov1_meg = mne.compute_covariance(baseline_cond1_meg, keep_sample_mean=True, tmin=-0.2, tmax=0) noise_cov1_eeg = mne.compute_covariance(baseline_cond1_eeg, keep_sample_mean=True, tmin=-0.2, tmax=0) noise_cov1_meeg = mne.compute_covariance(baseline_cond1_meeg,keep_sample_mean=True, tmin=-0.2, tmax=0) noise_cov1_meg = mne.cov.regularize(noise_cov1_meg, evokedcond1_meg.info, grad=0.1, mag=0.1, eeg=0.1) noise_cov1_eeg = mne.cov.regularize(noise_cov1_eeg, evokedcond1_eeg.info, grad=0.1, mag=0.1, eeg=0.1) noise_cov1_meeg = mne.cov.regularize(noise_cov1_meeg, evokedcond1_meeg.info, grad=0.1, mag=0.1, eeg=0.1) data_cov1_meg = mne.compute_covariance(epochs_cond1_meg, keep_sample_mean=True, tmin=0, tmax=1.1) data_cov1_eeg = mne.compute_covariance(epochs_cond1_eeg, keep_sample_mean=True, tmin=0, tmax=1.1) data_cov1_meeg = mne.compute_covariance(epochs_cond1_meeg,keep_sample_mean=True, tmin=0, tmax=1.1) data_cov1_meg = mne.cov.regularize(noise_cov1_meg, evokedcond1_meg.info, grad=0.1, mag=0.1, eeg=0.1) data_cov1_eeg = mne.cov.regularize(noise_cov1_eeg, evokedcond1_eeg.info, grad=0.1, mag=0.1, eeg=0.1) data_cov1_meeg = mne.cov.regularize(noise_cov1_meeg, evokedcond1_meeg.info, grad=0.1, mag=0.1, eeg=0.1) logfile.write("computing average on run" + listRunPerSubj[i][j] +"\n") logfile.write("computing noise convariance on baseline period on run + listRunPerSubj[i][j]" +"\n") logfile.write("computing data convariance on activation period on run + listRunPerSubj[i][j]" +"\n") # append subject's meg runs if j == 0: epochs_tot_cond1_meg = deepcopy(epochs_cond1_meg) epochs_tot_base1_meg = deepcopy(baseline_cond1_meg) COV1_meg = noise_cov1_meg COV_MEGdata = data_cov1_meg else: epochs_tmp_cond1_meg = epochs_cond1_meg epochs_tmp_base1_meg = baseline_cond1_meg COV1_meg['data'] += noise_cov1_meg['data'] COV1_meg['nfree'] += noise_cov1_meg['nfree'] COV1_meg = COV1_meg + noise_cov1_meg COV_MEGdata['data'] += data_cov1_meg['data'] COV_MEGdata['nfree'] += data_cov1_meg['nfree'] COV_MEGdata = COV_MEGdata + data_cov1_meg epochs_tot_cond1_meg._data = np.vstack((epochs_tot_cond1_meg._data,epochs_tmp_cond1_meg._data)) epochs_tot_cond1_meg.events = np.vstack((epochs_tot_cond1_meg.events,epochs_tmp_cond1_meg.events)) #epochs_tot_cond1.selection = np.concatenate((epochs_tot_cond1.selection,epochs_tmp_cond1.selection)) epochs_tot_base1_meg._data = np.vstack((epochs_tot_base1_meg._data,epochs_tmp_base1_meg._data)) epochs_tot_base1_meg.events = np.vstack((epochs_tot_base1_meg.events,epochs_tmp_base1_meg.events)) #epochs_tot_base1.selection = np.concatenate((epochs_tot_base1.selection,epochs_tmp_base1.selection)) SelEve = None # save evoked data evokedcond1_meg = epochs_tot_cond1_meg.average() mne.write_evokeds(wdir+ListSubj[i]+"/mne_python/MEG_"+condnames+"_"+ListSubj[i]+"-ave.fif",evokedcond1_meg) logfile.write("saving all runs MEG evoked data" +"\n") #compute noise covariance matrix from emptyroom epochs # NOISE_COV1_meg = mne.cov.regularize(COV1_meg, evokedcond1_meg.info, grad=0.1, mag=0.1, eeg=0.1) NOISE_COV1_meg.save(wdir+ListSubj[i]+"/mne_python/MEGnoisecov_"+condnames+"_"+ListSubj[i]+"-cov.fif") COV_MEGdata.save(wdir+ListSubj[i]+"/mne_python/MEGdatacov_"+condnames+"_"+ListSubj[i]+"-cov.fif") logfile.write("regularizing MEG noise covariance matrix from all runs" +"\n") logfile.write("saving MEG noise covariance matrix " +"\n") logfile.write("saving MEG data covariance matrix from all runs" +"\n") # append subject's eeg runs if j == 0: epochs_tot_cond1_eeg = deepcopy(epochs_cond1_eeg) epochs_tot_base1_eeg = deepcopy(baseline_cond1_eeg) COV1_eeg = noise_cov1_eeg COV_EEGdata = data_cov1_eeg else: epochs_tmp_cond1_eeg = epochs_cond1_eeg epochs_tmp_base1_eeg = baseline_cond1_eeg COV1_eeg['data'] += noise_cov1_eeg['data'] COV1_eeg['nfree'] += noise_cov1_eeg['nfree'] COV1_eeg = COV1_eeg + noise_cov1_eeg COV_EEGdata['data'] += data_cov1_eeg['data'] COV_EEGdata['nfree'] += data_cov1_eeg['nfree'] COV_EEGdata = COV_EEGdata + data_cov1_eeg epochs_tot_cond1_eeg._data = np.vstack((epochs_tot_cond1_eeg._data,epochs_tmp_cond1_eeg._data)) epochs_tot_cond1_eeg.events = np.vstack((epochs_tot_cond1_eeg.events,epochs_tmp_cond1_eeg.events)) #epochs_tot_cond1.selection = np.concatenate((epochs_tot_cond1.selection,epochs_tmp_cond1.selection)) epochs_tot_base1_eeg._data = np.vstack((epochs_tot_base1_eeg._data,epochs_tmp_base1_eeg._data)) epochs_tot_base1_eeg.events = np.vstack((epochs_tot_base1_eeg.events,epochs_tmp_base1_eeg.events)) #epochs_tot_base1.selection = np.concatenate((epochs_tot_base1.selection,epochs_tmp_base1.selection)) # save evoked data evokedcond1_eeg = epochs_tot_cond1_eeg.average() mne.write_evokeds(wdir+ListSubj[i]+"/mne_python/EEG_"+condnames+"_"+ListSubj[i]+"-ave.fif",evokedcond1_eeg) logfile.write("saving all runs EEG evoked data" +"\n") #compute noise covariance matrix from emptyroom epochs # NOISE_COV1_eeg = mne.cov.regularize(COV1_eeg, evokedcond1_eeg.info, grad=0.1, mag=0.1, eeg=0.1) NOISE_COV1_eeg.save(wdir+ListSubj[i]+"/mne_python/EEGnoisecov_"+condnames+"_"+ListSubj[i]+"-cov.fif") COV_EEGdata.save(wdir+ListSubj[i]+"/mne_python/EEGdatacov_"+condnames+"_"+ListSubj[i]+"-cov.fif") logfile.write("regularizing EEG noise covariance matrix from all runs" +"\n") logfile.write("saving EEG noise covariance matrix " +"\n") logfile.write("saving EEG data covariance matrix from all runs" +"\n") # append subject's meeg runs if j == 0: epochs_tot_cond1_meeg = deepcopy(epochs_cond1_meeg) epochs_tot_base1_meeg = deepcopy(baseline_cond1_meeg) COV1_meeg = noise_cov1_meeg COV_MEEGdata = data_cov1_meeg else: epochs_tmp_cond1_meeg = epochs_cond1_meeg epochs_tmp_base1_meeg = baseline_cond1_meeg COV1_meeg['data'] += noise_cov1_meeg['data'] COV1_meeg['nfree'] += noise_cov1_meeg['nfree'] COV1_meeg = COV1_meeg + noise_cov1_meeg COV_MEEGdata['data'] += data_cov1_meeg['data'] COV_MEEGdata['nfree'] += data_cov1_meeg['nfree'] COV_MEEGdata = COV_MEEGdata + data_cov1_meeg epochs_tot_cond1_meeg._data = np.vstack((epochs_tot_cond1_meeg._data,epochs_tmp_cond1_meeg._data)) epochs_tot_cond1_meeg.events = np.vstack((epochs_tot_cond1_meeg.events,epochs_tmp_cond1_meeg.events)) #epochs_tot_cond1.selection = np.concatenate((epochs_tot_cond1.selection,epochs_tmp_cond1.selection)) epochs_tot_base1_meeg._data = np.vstack((epochs_tot_base1_meeg._data,epochs_tmp_base1_meeg._data)) epochs_tot_base1_meeg.events = np.vstack((epochs_tot_base1_meeg.events,epochs_tmp_base1_meeg.events)) #epochs_tot_base1.selection = np.concatenate((epochs_tot_base1.selection,epochs_tmp_base1.selection)) # save evoked data evokedcond1_meeg = epochs_tot_cond1_meeg.average() mne.write_evokeds(wdir+ListSubj[i]+"/mne_python/MEEG_"+condnames+"_"+ListSubj[i]+"-ave.fif",evokedcond1_meeg) logfile.write("saving all runs MEEG evoked data" +"\n") #compute noise covariance matrix from emptyroom epochs # NOISE_COV1_meeg = mne.cov.regularize(COV1_meeg, evokedcond1_meeg.info, grad=0.1, mag=0.1, eeg=0.1) NOISE_COV1_meeg.save(wdir+ListSubj[i]+"/mne_python/MEEGnoisecov_"+condnames+"_"+ListSubj[i]+"-cov.fif") COV_MEEGdata.save(wdir+ListSubj[i]+"/mne_python/MEEGdatacov_"+condnames+"_"+ListSubj[i]+"-cov.fif") logfile.write("regularizing MEEG noise covariance matrix from all runs" +"\n") logfile.write("saving MEEG noise covariance matrix " +"\n") logfile.write("saving MEEG data covariance matrix from all runs" +"\n") # compute and save inverse operators forward_meeg = mne.read_forward_solution(fname_fwd_meeg,surf_ori=True) forward_eeg = mne.read_forward_solution(fname_fwd_eeg,surf_ori=True) forward_meg = mne.read_forward_solution(fname_fwd_meg,surf_ori=True) inverse_operator1_meg = make_inverse_operator(evokedcond1_meg.info, forward_meg, NOISE_COV1_meg, loose=0.2, depth=0.8) inverse_operator1_eeg = make_inverse_operator(evokedcond1_eeg.info, forward_eeg, NOISE_COV1_eeg, loose=0.2, depth=0.8) inverse_operator1_meeg = make_inverse_operator(evokedcond1_meeg.info, forward_meeg, NOISE_COV1_meeg, loose=0.2, depth=0.8) write_inverse_operator(wdir+ListSubj[i]+"/mne_python/"+condnames+"_meg_ico5-inv",inverse_operator1_meg) write_inverse_operator(wdir+ListSubj[i]+"/mne_python/"+condnames+"_eeg_ico5-inv",inverse_operator1_eeg) write_inverse_operator(wdir+ListSubj[i]+"/mne_python/"+condnames+"_meeg_ico5-inv",inverse_operator1_meeg) logfile.write("compute and save MEG inverse operator from all runs" +"\n") logfile.write("compute and save EEG inverse operator from all runs" +"\n") logfile.write("compute and save MEEG inverse operator from all runs" +"\n") print(NOISE_COV1_meeg) # Show covariance mne.viz.plot_cov(NOISE_COV1_meeg, raw.info, colorbar=True, proj=True,show_svd=False,show=False) logfile.write("print and save M/E/EG noise covariance matrices from all runs" +"\n") logfile.close()
## results I showed you using the epochs method #noise_cov = mne.compute_raw_covariance(raw_empty_room, tmin=0, tmax=None) noise_cov = mne.compute_covariance( epochs, tmax=0., method=['shrunk', 'empirical']) mne.write_cov('fingerpress-cov.fif', noise_cov) fig_cov, fig_spectra = mne.viz.plot_cov(noise_cov, raw.info) ## Pick specific types of fwd operator - not really needed fwd = mne.pick_types_forward(fwd, meg=True , eeg=True) info = evoked.info ### Computing inverse operator inverse_operator = make_inverse_operator(info, fwd, noise_cov, loose=0.2, depth=0.8) ## Writing inverse operator write_inverse_operator('fingerpress-inv.fif', inverse_operator) ### Computing inverse solution method = "dSPM" snr = 3. lambda2 = 1. / snr ** 2 stc = apply_inverse(evoked, inverse_operator, lambda2, method=method, pick_ori=None) stc.times ## Visualization of time series activation plt.plot(1e3 * stc.times, stc.data[::100, :].T) ts_show = -30 # show the 40 largest responses plt.plot(stc.times, stc.data[np.argsort(stc.data.max(axis=1))[ts_show:]].T) plt.xlabel('time (ms)') plt.ylabel('%s value' % method) plt.show()
parser = ArgumentParser(description=__doc__) parser.add_argument("subject", help="subject id") subj = parser.parse_args().subject json_path = bp.root_json.fpath(subject=subj, task="rest", run=None) with open(json_path, "r") as f: er_relpath = json.load(f)["AssociatedEmptyRoom"] er_path = dirs.bids_root / er_relpath er_raw = read_raw_fif(er_path, preload=True) # remove ICA components marked for 'quesitions' data from ER data ica_sol_path = bp.ica_sol.fpath(subject=subj, task="questions") ica_bads_path = bp.ica_bads.fpath(subject=subj, task="questions") ica = read_ica(ica_sol_path) ica.exclude = read_ica_bads(ica_bads_path, logger) logger.info(f"Excluding ICs {ica.exclude} from ER data") ica.apply(er_raw) noise_cov = compute_raw_covariance(er_raw, method="auto") del er_raw info = read_info(bp.epochs.fpath(subject=subj)) fwd = read_forward_solution(bp.fwd.fpath(subject=subj)) inv_path = bp.inv.fpath(subject=subj) inverse_operator = make_inverse_operator(info, fwd, noise_cov, rank="info") write_inverse_operator(inv_path, inverse_operator)
fname_fwd = data_path + '/MEG/sample/sample_audvis-meg-oct-6-fwd.fif' fwd = mne.read_forward_solution(fname_fwd, surf_ori=True) # Restrict forward solution as necessary for MEG fwd = mne.pick_types_forward(fwd, meg=True, eeg=False) # make an MEG inverse operator info = evoked.info inverse_operator = make_inverse_operator(info, fwd, noise_cov, loose=0.2, depth=0.8) write_inverse_operator('sample_audvis-meg-oct-6-inv.fif', inverse_operator) ############################################################################### # Compute inverse solution # ------------------------ method = "dSPM" snr = 3. lambda2 = 1. / snr**2 stc = apply_inverse(evoked, inverse_operator, lambda2, method=method, pick_ori=None) del fwd, inverse_operator, epochs # to save memory
def run(): args = sys.argv if len(args) <= 1: print 'Usage: run_meg_tutorial.sh <sample data directory>' return sample_dir = args[1] subjects_dir = join(sample_dir, 'subjects') meg_dir = join(sample_dir, 'MEG', 'sample') os.environ['SUBJECTS_DIR'] = subjects_dir os.environ['MEG_DIR'] = meg_dir subject = 'sample' src = setup_source_space(subject, fname=True, spacing='oct6', n_jobs=2, overwrite=True) # If one wanted to use other source spaces, these types of options are # available src_fsaverage = setup_source_space('fsaverage', fname=True, spacing='ico5', n_jobs=2, overwrite=True, add_dist=False) morph_source_spaces(src_fsaverage, subject_to='sample') setup_source_space(subject, fname=True, spacing='all', overwrite=True, n_jobs=2, add_dist=False) # Add distances to source space (if desired, takes a long time) bem_dir = join(subjects_dir, join('sample', 'bem')) os.rename(join(bem_dir, 'sample-oct-6-src.fif'), join(bem_dir, 'sample-oct-6-orig-src.fif')) new_src = add_source_space_distances(src, dist_limit=0.007) new_src.save(join(bem_dir, 'sample-oct-6-src.fif')) # Preprocessing raw = mne.io.Raw(join(meg_dir, 'sample_audvis_raw.fif'), preload=True) raw.info['bads'] = ['MEG 2443', 'EEG 053'] reject = dict(grad=3000e-13, mag=4000e-15, eeg=100e-6) ecg_proj, _ = mne.preprocessing.compute_proj_ecg(raw, l_freq=1, h_freq=100, ch_name='MEG 1531', reject=reject) eog_proj, _ = mne.preprocessing.compute_proj_eog(raw, l_freq=1, h_freq=35, reject=reject, no_proj=True) events = mne.find_events(raw) mne.write_events(join(meg_dir, 'sample_audvis_raw-eve.fif'), events) event_id = [1, 2, 3, 4] tmin, tmax = -0.2, 0.5 picks = mne.pick_types(raw.info, meg=True, eeg=True, stim=True, eog=True) # Average with no filter epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks) evoked = epochs.average() evoked.save(join(meg_dir, 'sample_audvis-no-filter-ave.fif')) raw.filter(l_freq=None, h_freq=40) raw_resampled = raw.resample(150) raw_resampled.save(join(meg_dir, 'sample_audvis_filt-0-40_raw.fif'), overwrite=True) raw.add_proj(ecg_proj) raw.add_proj(eog_proj) resampled_events = mne.find_events(raw_resampled) mne.write_events(join(meg_dir, 'sample_audvis_filt-0-40_raw-eve.fif'), resampled_events) # Average with filter epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks) evoked = epochs.average() evoked.save(join(meg_dir, 'sample_audvis-ave.fif')) # Compute the noise covariance matrix noise_cov = mne.compute_raw_data_covariance(raw, picks=picks) noise_cov.save(join(meg_dir, 'audvis.cov')) # Compute the empty-room noise covariance matrix ernoise_raw = mne.io.Raw(join(meg_dir, 'ernoise_raw.fif'), preload=True) ernoise_raw.info['bads'] = ['MEG 2443'] ernoise_raw.filter(l_freq=None, h_freq=40) picks = mne.pick_types(ernoise_raw.info, meg=True, eeg=True, stim=True, eog=True) ernoise_cov = mne.compute_raw_data_covariance(ernoise_raw, picks=picks) ernoise_cov.save(join(meg_dir, 'ernoise.cov')) ############################################################################### # Compute forward solution a.k.a. lead field trans = join(meg_dir, 'sample_audvis_raw-trans.fif') bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-bem-sol.fif') # for MEG only fname = join(meg_dir, 'sample_audvis-meg-oct-6-fwd.fif') fwd_meg = mne.make_forward_solution(raw.info, trans, src, bem, fname=fname, meg=True, eeg=False, mindist=5.0, n_jobs=2, overwrite=True) # for EEG only bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-5120-5120-bem-sol.fif') fname = join(meg_dir, 'sample_audvis-eeg-oct-6-fwd.fif') fwd_eeg = mne.make_forward_solution(raw.info, trans, src, bem, fname=fname, meg=False, eeg=True, mindist=5.0, n_jobs=2, overwrite=True) # for both EEG and MEG fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-fwd.fif') fwd = mne.make_forward_solution(raw.info, trans, src, bem, fname=fname, meg=True, eeg=True, mindist=5.0, n_jobs=2, overwrite=True) # Create various sensitivity maps grad_map = mne.sensitivity_map(fwd, ch_type='grad', mode='free') grad_map.save(join(meg_dir, 'sample_audvis-grad-oct-6-fwd-sensmap'), ftype='w') mag_map = mne.sensitivity_map(fwd, ch_type='mag', mode='free') mag_map.save(join(meg_dir, 'sample_audvis-mag-oct-6-fwd-sensmap'), ftype='w') eeg_map = mne.sensitivity_map(fwd, ch_type='eeg', mode='free') eeg_map.save(join(meg_dir, 'sample_audvis-eeg-oct-6-fwd-sensmap'), ftype='w') grad_map2 = mne.sensitivity_map(fwd, ch_type='grad', mode='fixed') grad_map2.save(join(meg_dir, 'sample_audvis-grad-oct-6-fwd-sensmap-2'), ftype='w') mag_map2 = mne.sensitivity_map(fwd, ch_type='mag', mode='ratio') mag_map2.save(join(meg_dir, 'sample_audvis-mag-oct-6-fwd-sensmap-3'), ftype='w') # Compute some with the EOG + ECG projectors projs = ecg_proj + eog_proj + raw.info['projs'] for map_type in ['radiality', 'angle', 'remaining', 'dampening']: eeg_map = mne.sensitivity_map(fwd, projs=projs, ch_type='eeg', mode=map_type) eeg_map.save( join(meg_dir, 'sample_audvis-eeg-oct-6-fwd-sensmap-' + map_type)) ############################################################################### # Compute MNE inverse operators # # Note: The MEG/EEG forward solution could be used for all # inv_meg = make_inverse_operator(raw.info, fwd_meg, noise_cov, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-inv.fif') write_inverse_operator(fname, inv_meg) inv_eeg = make_inverse_operator(raw.info, fwd_eeg, noise_cov, loose=0.2) fname = join(meg_dir, 'sample_audvis-eeg-oct-6-eeg-inv.fif') write_inverse_operator(fname, inv_eeg) inv = make_inverse_operator(raw.info, fwd, noise_cov, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-meg-eeg-inv.fif') write_inverse_operator(fname, inv) # inverse operator with fixed orientation (for testing). Not implemented #inv_fixed = make_inverse_operator(raw.info, fwd_meg, noise_cov, # depth=None, fixed=True) #fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-nodepth-fixed-inv.fif') #write_inverse_operator(fname, inv_fixed) # produce two with diagonal noise (for testing) diag = noise_cov.as_diag() inv_meg_diag = make_inverse_operator(raw.info, fwd_meg, diag, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-oct-6-meg-diagnoise-inv.fif') write_inverse_operator(fname, inv_meg_diag) inv_eeg_diag = make_inverse_operator(raw.info, fwd, diag, loose=0.2) fname = join(meg_dir, 'sample_audvis-meg-eeg-oct-6-meg-eeg-diagnoise-inv.fif') write_inverse_operator(fname, inv_eeg_diag) # Produce stc files evoked.crop(0, 0.25) stc_meg = apply_inverse(evoked, inv_meg, method='MNE') stc_meg.save(join(meg_dir, 'sample_audvis-meg')) stc_eeg = apply_inverse(evoked, inv_eeg, method='MNE') stc_eeg.save(join(meg_dir, 'sample_audvis-eeg')) stc = apply_inverse(evoked, inv, method='MNE') stc.save(join(meg_dir, 'sample_audvis-meg-eeg')) # let's also morph to fsaverage stc_to = stc_meg.morph('fsaverage', grade=3, smooth=12) stc_to.save(join(meg_dir, 'fsaverage_audvis-meg')) stc_to = stc_eeg.morph('fsaverage', grade=3, smooth=12) stc_to.save(join(meg_dir, 'fsaverage_audvis-eeg')) stc_to = stc.morph('fsaverage', grade=3, smooth=12) stc_to.save(join(meg_dir, 'fsaverage_audvis-meg-eeg')) ############################################################################### # Do one dipole fitting evoked = evoked.pick_types(meg=True, eeg=False) evoked.crop(0.04, 0.095) bem = join(subjects_dir, 'sample', 'bem', 'sample-5120-bem-sol.fif') dip, _ = mne.fit_dipole(evoked, noise_cov, bem, trans) dip.save(join(meg_dir, 'sample_audvis_set1.dip'))
# Restrict forward solution as necessary for MEG forward_meg = mne.fiff.pick_types_forward(forward_meeg, meg=True, eeg=False) # Alternatively, you can just load a forward solution that is restricted forward_eeg = mne.read_forward_solution(fname_fwd_eeg, surf_ori=True) # make an M/EEG, MEG-only, and EEG-only inverse operators info = evoked.info inverse_operator_meeg = make_inverse_operator(info, forward_meeg, noise_cov, loose=0.2, depth=0.8) inverse_operator_meg = make_inverse_operator(info, forward_meg, noise_cov, loose=0.2, depth=0.8) inverse_operator_eeg = make_inverse_operator(info, forward_eeg, noise_cov, loose=0.2, depth=0.8) write_inverse_operator('sample_audvis-meeg-oct-6-inv.fif', inverse_operator_meeg) write_inverse_operator('sample_audvis-meg-oct-6-inv.fif', inverse_operator_meg) write_inverse_operator('sample_audvis-eeg-oct-6-inv.fif', inverse_operator_eeg) # Compute inverse solution stcs = dict() stcs['meeg'] = apply_inverse(evoked, inverse_operator_meeg, lambda2, "dSPM", pick_normal=False) stcs['meg'] = apply_inverse(evoked, inverse_operator_meg, lambda2, "dSPM", pick_normal=False) stcs['eeg'] = apply_inverse(evoked, inverse_operator_eeg, lambda2, "dSPM", pick_normal=False) # Save result in stc files
import sys import mne from mne.minimum_norm import make_inverse_operator, write_inverse_operator from my_settings import (mne_folder, conditions, ica_folder) subject = sys.argv[1] for condition in conditions: fwd = mne.read_forward_solution( mne_folder + "%s_%s_ar-fwd.fif" % (subject, condition), surf_ori=False) epochs = mne.read_epochs(ica_folder + "%s_%s_ar_ica-epo.fif" % ( subject, condition)) cov = mne.read_cov(mne_folder + "%s_%s_ar-cov.fif" % (subject, condition)) evoked = epochs.average() # make an MEG inverse operator inverse_operator = make_inverse_operator( evoked.info, fwd, cov, loose=0.2, depth=0.8) write_inverse_operator(mne_folder + "%s_%s_ar-inv.fif" % (subject, condition), inverse_operator)
import sys import mne from mne.minimum_norm import make_inverse_operator, write_inverse_operator from my_settings import (mne_folder, conditions, ica_folder) subject = sys.argv[1] for condition in conditions: fwd = mne.read_forward_solution(mne_folder + "%s_%s_ar-fwd.fif" % (subject, condition), surf_ori=False) epochs = mne.read_epochs(ica_folder + "%s_%s_ar_ica-epo.fif" % (subject, condition)) cov = mne.read_cov(mne_folder + "%s_%s_ar-cov.fif" % (subject, condition)) evoked = epochs.average() # make an MEG inverse operator inverse_operator = make_inverse_operator(evoked.info, fwd, cov, loose=0.2, depth=0.8) write_inverse_operator( mne_folder + "%s_%s_ar-inv.fif" % (subject, condition), inverse_operator)
info_mat = scipy.io.loadmat(datapath + 'Results_Alpha_and_Gamma/' + subject + '/' + subject + '_info.mat') good_epo = info_mat['ALLINFO']['ep_order_num'][0][0][0] - 1 info_file = info_mat['ALLINFO']['stim_type_previous_tr'][0][0][0] goodevents = relevantevents[good_epo] goodevents[:, 2] = info_file # Define epochs allepochs = mne.Epochs(raw, goodevents, events_id, tmin=presim_sec, tmax=poststim_sec, baseline=(None, 0), proj=False, preload=True) # Resample epochs if allepochs.info['sfreq'] > 500: allepochs.resample(500) #inverse operator inv = make_inverse_operator(allepochs.info, fwd, noise_cov, loose=0.2, depth=0.8, verbose=True) write_inverse_operator(savepath + subject + '/' + subject + '_inv', inv, verbose=None)
bem_fname, meg=True, ignore_ref=True) print("Converting forward solution...") fwd_fixed = convert_forward_solution(fwd, force_fixed=False, surf_ori=True) write_forward_solution(fwd_fname, fwd_fixed, overwrite=True) # else: # fwd = read_forward_solution(fwd_fname) print("Making inverse operator...") inverse_operator = make_inverse_operator(epochs.info, fwd_fixed, noise_cov, fixed=True, loose=0.0) write_inverse_operator(inv_fname, inverse_operator) print("Done with %s!" % (subject)) ############################################################################### ################# MAKE EPOCHS STCS, SAVE AVG OF 4 LABELS ##################### ############################################################################### snr = 2.0 # Standard assumption for single trial lambda2 = 1.0 / snr**2 mri_dir = '/Volumes/Server/MORPHLAB/Users/Ellie/Shepard/mri' # params for subject in subjects:
# Forward model fwd = mne.make_forward_solution(raw.info, fname_trans, src, bem_sol_file) mne.write_forward_solution(fwd_file, fwd) # Restrict forward solution as necessary for MEG fwd = mne.pick_types_forward(fwd, meg=True, eeg=False) # make an inverse operator info = evoked.info inverse_operator = make_inverse_operator(info, fwd, noise_cov, loose=0.2, depth=0.8) write_inverse_operator(inverse_file, inverse_operator) # Compute inverse solution method = "dSPM" snr = 3. lambda2 = 1. / snr ** 2 stc = apply_inverse(evoked, inverse_operator, lambda2, method=method, pick_ori=None,verbose=1) # visualize _, peak_time = stc.get_peak(hemi='lh') brain = stc.plot(initial_time=peak_time, surface='inflated', hemi='lh', subjects_dir=subj_dir)
sph_bem = make_sphere_model(r0='auto', head_radius='auto', info=subj_info) ########################################################### # Create foward solution # Read source space and trans (mri->head) for foward computation src = read_source_spaces(fname_load_src) if generic_sph is True: # Use this trans if using generic fsaverage head model trans = read_trans(fname_load_trans) else: # Use this trans if using individual's head model trans = model_inv['mri_head_t'] fwd = make_forward_solution(info=subj_info, trans=trans, src=src, bem=sph_bem, fname=fname_save_fwd, meg=False, eeg=True, overwrite=True, n_jobs=n_jobs) # Fix orientation convert_forward_solution(fwd, surf_ori=True, force_fixed=True, copy=False) ########################################################### # Create and save inverse solution noise_cov = model_inv['noise_cov'] # EEG only, so depth weighting not needed sph_inv = make_inverse_operator(subj_info, fwd, noise_cov, depth=None, fixed=True) write_inverse_operator(fname_save_inv, sph_inv)
n_jobs = 1 else: data_path = "/projects/MINDLAB2015_MEG-CorticalAlphaAttention/scratch/" n_jobs = 1 subjects_dir = data_path + "fs_subjects_dir/" fname_fwd = data_path + '0001-fwd.fif' fname_cov = data_path + '0001-cov.fif' fname_evoked = data_path + "0001_p_03_filter_ds_ica-mc_raw_tsss-ave.fif" snr = 1.0 lambda2 = 1.0 / snr ** 2 # Load data evoked = mne.read_evokeds(fname_evoked, condition=0, baseline=(None, 0)) forward_meeg = mne.read_forward_solution(fname_fwd, surf_ori=True) noise_cov = mne.read_cov(fname_cov) # Restrict forward solution as necessary for MEG forward_meg = mne.pick_types_forward(forward_meeg, meg=True, eeg=False) # Alternatively, you can just load a forward solution that is restricted # make an M/EEG, MEG-only, and EEG-only inverse operators inverse_operator_meg = make_inverse_operator(evoked.info, forward_meg, noise_cov, loose=0.2, depth=0.8) write_inverse_operator('0001-meg-oct-6-inv.fif', inverse_operator_meg)