def apply_inverse(fnevo, method='dSPM', snr=3.0, event='LLst',
baseline=False, btmin=-0.3, btmax=-0.1, min_subject='fsaverage'):
'''
Parameter
---------
fnevo: string or list
The evoked file with ECG, EOG and environmental noise free.
method: inverse method, 'MNE' or 'dSPM'
event: string
The event name related with epochs.
min_subject: string
The subject name as the common brain.
snr: signal to noise ratio for inverse solution.
'''
#Get the default subjects_dir
from mne.minimum_norm import apply_inverse
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)
stc_name = name[:name.rfind('-ave.fif')]
subject = name.split('_')[0]
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-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
snr = snr
lambda2 = 1.0 / snr ** 2
#noise_cov = mne.read_cov(fn_cov)
[evoked] = mne.read_evokeds(fname)
noise_cov = mne.read_cov(fn_cov)
# this path used for ROI definition
stc_path = min_dir + '/%s_ROIs/%s' %(method,subject)
#fn_cov = meg_path + '/%s_empty,fibp1-45,nr-cov.fif' % subject
set_directory(stc_path)
noise_cov = mne.cov.regularize(noise_cov, evoked.info,
mag=0.05, grad=0.05, proj=True)
fwd_ev = mne.make_forward_solution(evoked.info, trans=fn_trans,
src=fn_src, bem=fn_bem,
fname=None, meg=True, eeg=False,
mindist=5.0, n_jobs=2,
overwrite=True)
fwd_ev = mne.convert_forward_solution(fwd_ev, surf_ori=True)
forward_meg_ev = mne.pick_types_forward(fwd_ev, meg=True, eeg=False)
inverse_operator_ev = mne.minimum_norm.make_inverse_operator(
evoked.info, forward_meg_ev, noise_cov,
loose=0.2, depth=0.8)
# Compute inverse solution
stc = apply_inverse(evoked, inverse_operator_ev, lambda2, method,
pick_ori=None)
# Morph STC
stc_morph = mne.morph_data(subject, min_subject, stc, grade=5, smooth=5)
stc_morph.save(stc_path + '/%s' % (stc_name), ftype='stc')
if baseline == True:
stc_base = stc_morph.crop(btmin, btmax)
stc_base.save(stc_path + '/%s_%s_baseline' % (subject, event), ftype='stc')
def stan_rois(fname, size=8.0, min_subject='fsaverage'):
"""
Before merging all ROIs together, the size of ROIs will be standardized.
Keep every ROIs in a same size
----------
fname: averaged STC of the trials.
size: the radius of every ROI.
min_subject: the subject for the common brain space.
"""
fnlist = get_files_from_list(fname)
subjects_dir = os.environ['SUBJECTS_DIR']
# loop across all filenames
for fn_stc in fnlist:
stc_path = os.path.split(fn_stc)[0]
stc_morph = mne.read_source_estimate(fn_stc, subject=min_subject)
min_path = subjects_dir + '/%s' %min_subject
# extract the subject infromation from the file name
name = os.path.basename(fn_stc)
subject = name.split('_')[0]
mer_path = stc_path + '/ROIs/'
stan_path = min_path + '/Group_ROIs/standard/'
set_directory(stan_path)
list_dirs = os.walk(mer_path)
for root, dirs, files in list_dirs:
for f in files:
label_fname = os.path.join(root, f)
label = mne.read_label(label_fname)
stc_label = stc_morph.in_label(label)
src_pow = np.sum(stc_label.data ** 2, axis=1)
if label.hemi == 'lh':
# Get the max MNE value within each ROI
seed_vertno = stc_label.vertices[0][np.argmax(src_pow)]
func_label = mne.grow_labels(min_subject, seed_vertno,
extents=size, hemis=0,
subjects_dir=subjects_dir,
n_jobs=1)
func_label = func_label[0]
func_label.save(stan_path + '%s_%s' % (subject, f))
elif label.hemi == 'rh':
seed_vertno = stc_label.vertices[1][np.argmax(src_pow)]
func_label = mne.grow_labels(min_subject, seed_vertno,
extents=size, hemis=1,
subjects_dir=subjects_dir,
n_jobs=1)
func_label = func_label[0]
func_label.save(stan_path + '%s_%s' % (subject, f))
def morph_STC(fn_stc, grade, template='fsaverage', event='LLst',
baseline=True, btmin=-0.3, btmax=0.):
from mne import read_source_estimate, morph_data
fnlist = get_files_from_list(fn_stc)
for fname in fnlist:
name = os.path.basename(fname)
subject = name.split('_')[0]
stc_name = name[:name.rfind('-ave.fif')]
min_dir = subjects_dir + '/%s' %template
# this path used for ROI definition
stc_path = min_dir + '/dSPM_ROIs/%s' %(subject)
#fn_cov = meg_path + '/%s_empty,fibp1-45,nr-cov.fif' % subject
set_directory(stc_path)
# Morph STC
stc = read_source_estimate(fname)
stc_morph = morph_data(subject, template, stc, grade=grade)
stc_morph.save(stc_path + '/%s' % (stc_name), ftype='stc')
if baseline == True:
stc_base = stc_morph.crop(btmin, btmax)
stc_base.save(stc_path + '/%s_%s_baseline' % (subject, event[:2]), ftype='stc')
def apply_inverse(fnepo, method='dSPM', event='LLst', min_subject='fsaverage', STC_US='ROI',
snr=5.0):
'''
Parameter
---------
fnepo: string or list
The epochs file with ECG, EOG and environmental noise free.
method: inverse method, 'MNE' or 'dSPM'
event: string
The event name related with epochs.
min_subject: string
The subject name as the common brain.
STC_US: string
The using of the inversion for further analysis.
'ROI' stands for ROIs definition, 'CAU' stands for causality analysis.
snr: signal to noise ratio for inverse solution.
'''
#Get the default subjects_dir
from mne.minimum_norm import (apply_inverse, apply_inverse_epochs)
subjects_dir = os.environ['SUBJECTS_DIR']
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)
stc_name = name[:name.rfind('-epo.fif')]
subject = name.split('_')[0]
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-cov.fif' % subject
fn_src = subject_path + '/bem/%s-ico-4-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
snr = snr
lambda2 = 1.0 / snr ** 2
#noise_cov = mne.read_cov(fn_cov)
epochs = mne.read_epochs(fname)
noise_cov = mne.read_cov(fn_cov)
if STC_US == 'ROI':
# this path used for ROI definition
stc_path = min_dir + '/%s_ROIs/%s' %(method,subject)
#fn_cov = meg_path + '/%s_empty,fibp1-45,nr-cov.fif' % subject
evoked = epochs.average()
set_directory(stc_path)
noise_cov = mne.cov.regularize(noise_cov, evoked.info,
mag=0.05, grad=0.05, proj=True)
fwd_ev = mne.make_forward_solution(evoked.info, trans=fn_trans,
src=fn_src, bem=fn_bem,
fname=None, meg=True, eeg=False,
mindist=5.0, n_jobs=2,
overwrite=True)
fwd_ev = mne.convert_forward_solution(fwd_ev, surf_ori=True)
forward_meg_ev = mne.pick_types_forward(fwd_ev, meg=True, eeg=False)
inverse_operator_ev = mne.minimum_norm.make_inverse_operator(
evoked.info, forward_meg_ev, noise_cov,
loose=0.2, depth=0.8)
# Compute inverse solution
stc = apply_inverse(evoked, inverse_operator_ev, lambda2, method,
pick_ori=None)
# Morph STC
subject_id = min_subject
stc_morph = mne.morph_data(subject, subject_id, stc, grade=5, smooth=5)
stc_morph.save(stc_path + '/%s' % (stc_name), ftype='stc')
elif STC_US == 'CAU':
stcs_path = min_dir + '/stcs/%s/%s/' % (subject,event)
reset_directory(stcs_path)
noise_cov = mne.cov.regularize(noise_cov, epochs.info,
mag=0.05, grad=0.05, proj=True)
fwd = mne.make_forward_solution(epochs.info, trans=fn_trans,
src=fn_src, bem=fn_bem,
meg=True, eeg=False, mindist=5.0,
n_jobs=2, overwrite=True)
fwd = mne.convert_forward_solution(fwd, surf_ori=True)
forward_meg = mne.pick_types_forward(fwd, meg=True, eeg=False)
inverse_operator = mne.minimum_norm.make_inverse_operator(
epochs.info, forward_meg, noise_cov, loose=0.2,
depth=0.8)
# Compute inverse solution
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2,
method=method, pick_ori='normal')
s = 0
while s < len(stcs):
stc_morph = mne.morph_data(
subject, min_subject, stcs[s], grade=5, smooth=5)
stc_morph.save(stcs_path + '/trial%s_fsaverage'
% (subject, str(s)), ftype='stc')
s = s + 1
from jumeg.jumeg_plot import plot_artefact_overview
import glob, os
from dirs_manage import set_directory
subjects_dir = '/home/uais_common/dong/freesurfer/subjects/'
per_path = subjects_dir + 'performance/'
set_directory(per_path)
#fn_raw_list = glob.glob(subjects_dir + '/*[0-9]/MEG/*rfDC-raw.fif')
fn_raw_list = glob.glob(subjects_dir + '/203840/MEG/*rfDC-raw.fif')
for fn_raw in fn_raw_list:
fn_raw_clean = fn_raw[:fn_raw.rfind('-raw.fif')] + ',nr,ocarta-raw.fif'
subject = os.path.basename(fn_raw).split('_')[0]
fn_out = per_path + subject
plot_artefact_overview(fn_raw,
fn_raw_clean,
overview_fname=fn_out,
ecg_ch='ECG 001',
eog1_ch='EOG 001',
eog2_ch='EOG 002')
def DICS_inverse(fn_epo, event_id=1,event='LLst', ctmin=0.05, ctmax=0.25, fmin=4, fmax=8,
min_subject='fsaverage'):
"""
Inverse evokes into source space using DICS method.
----------
fn_epo : epochs of raw data.
event_id: event id related with epochs.
ctmin: the min time for computing CSD
ctmax: the max time for computing CSD
fmin: min value of the interest frequency band
fmax: max value of the interest frequency band
min_subject: the subject for the common brain space.
save_forward: Whether save the forward solution or not.
"""
from mne import Epochs, pick_types
from mne.io import Raw
from mne.event import make_fixed_length_events
fnlist = get_files_from_list(fn_epo)
# loop across all filenames
for fname in fnlist:
meg_path = os.path.split(fname)[0]
name = os.path.basename(fname)
stc_name = name[:name.rfind('-epo.fif')]
subject = name.split('_')[0]
subject_path = subjects_dir + '/%s' %subject
min_dir = subjects_dir + '/%s' %min_subject
fn_trans = meg_path + '/%s-trans.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
# Make sure the target path is exist
stc_path = min_dir + '/DICS_ROIs/%s' % subject
set_directory(stc_path)
# Read the MNI source space
epochs = mne.read_epochs(fname)
tmin = epochs.times.min()
tmax = epochs.times.max()
fn_empty = meg_path + '/%s_empty,nr-raw.fif' % subject
raw_noise = Raw(fn_empty, preload=True)
epochs.info['bads'] = raw_noise.info['bads']
picks_noise = pick_types(raw_noise.info, meg='mag', exclude='bads')
events_noise = make_fixed_length_events(raw_noise, event_id, duration=1.)
epochs_noise = Epochs(raw_noise, events_noise, event_id, tmin,
tmax, proj=True, picks=picks_noise,
baseline=None, preload=True, reject=None)
# Make sure the number of noise epochs is the same as data epochs
epochs_noise = epochs_noise[:len(epochs.events)]
evoked = epochs.average()
forward = mne.make_forward_solution(epochs.info, trans=fn_trans,
src=fn_src, bem=fn_bem,
fname=None, meg=True, eeg=False,
mindist=5.0, n_jobs=2,
overwrite=True)
forward = mne.convert_forward_solution(forward, surf_ori=True)
from mne.time_frequency import compute_epochs_csd
from mne.beamformer import dics
data_csd = compute_epochs_csd(epochs, mode='multitaper', tmin=ctmin, tmax=ctmax,
fmin=fmin, fmax=fmax)
noise_csd = compute_epochs_csd(epochs_noise, mode='multitaper', tmin=ctmin, tmax=ctmax,
fmin=fmin, fmax=fmax)
stc = dics(evoked, forward, noise_csd, data_csd)
from mne import morph_data
stc_morph = morph_data(subject, min_subject, stc, grade=5, smooth=5)
stc_morph.save(stc_path + '/%s_%d_%d' % (event, fmin, fmax), ftype='stc')
def apply_inverse(fn_epo, event='LLst',ctmin=0.05, ctmax=0.25, nctmin=-0.2, nctmax=0,
fmin=4, fmax=8, min_subject='fsaverage', STCs=False):
"""
Inverse evokes into source space using DICS method.
----------
fn_epo : epochs of raw data.
event_id: event id related with epochs.
ctmin: the min time for computing CSD
ctmax: the max time for computing CSD
fmin: min value of the interest frequency band
fmax: max value of the interest frequency band
min_subject: the subject for the common brain space.
STCs: bool, make STCs of epochs.
"""
from mne import Epochs, pick_types
from mne.io import Raw
from mne.event import make_fixed_length_events
fnlist = get_files_from_list(fn_epo)
# loop across all filenames
for fname in fnlist:
subjects_dir = os.environ['SUBJECTS_DIR']
# extract the subject infromation from the file name
meg_path = os.path.split(fname)[0]
name = os.path.basename(fname)
stc_name = name[:name.rfind('-epo.fif')]
subject = name.split('_')[0]
subject_path = subjects_dir + '/%s' %subject
min_dir = subjects_dir + '/%s' %min_subject
fn_trans = meg_path + '/%s-trans.fif' % subject
fn_src = subject_path + '/bem/%s-ico-4-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
# Make sure the target path is exist
stc_path = min_dir + '/DICS_ROIs/%s' % subject
set_directory(stc_path)
# Read the MNI source space
epochs = mne.read_epochs(fname)
evoked = epochs.average()
forward = mne.make_forward_solution(epochs.info, trans=fn_trans,
src=fn_src, bem=fn_bem,
fname=None, meg=True, eeg=False,
mindist=5.0, n_jobs=2,
overwrite=True)
forward = mne.convert_forward_solution(forward, surf_ori=True)
from mne.time_frequency import compute_epochs_csd
from mne.beamformer import dics
data_csd = compute_epochs_csd(epochs, mode='multitaper', tmin=ctmin, tmax=ctmax,
fmin=fmin, fmax=fmax)
noise_csd = compute_epochs_csd(epochs, mode='multitaper', tmin=nctmin, tmax=nctmax,
fmin=fmin, fmax=fmax)
stc = dics(evoked, forward, noise_csd, data_csd)
from mne import morph_data
stc_morph = morph_data(subject, min_subject, stc, grade=4, smooth=4)
stc_morph.save(stc_path + '/%s_%d_%d' % (stc_name, fmin, fmax), ftype='stc')
if STCs == True:
stcs_path = stc_path + '/STCs-%s/' %event
reset_directory(stcs_path)
stcs = dics(epochs, forward, noise_csd, data_csd)
s = 0
while s < len(stcs):
stc_morph = mne.morph_data(subject, min_subject, stcs[s], grade=4, smooth=4)
stc_morph.save(stcs_path + '/trial_%s'
% (str(s)), ftype='stc')
s = s + 1
