def compute_noise_cov(cov_fname, raw):
import os.path as op
from mne import compute_raw_covariance, pick_types, write_cov
from nipype.utils.filemanip import split_filename as split_f
from neuropype_ephy.preproc import create_reject_dict
print '***** COMPUTE RAW COV *****' + cov_fname
if not op.isfile(cov_fname):
data_path, basename, ext = split_f(raw.info['filename'])
fname = op.join(data_path, '%s-cov.fif' % basename)
reject = create_reject_dict(raw.info)
# reject = dict(mag=4e-12, grad=4000e-13, eog=250e-6)
picks = pick_types(raw.info, meg=True, ref_meg=False, exclude='bads')
noise_cov = compute_raw_covariance(raw, picks=picks, reject=reject)
write_cov(fname, noise_cov)
else:
print '*** NOISE cov file %s exists!!!' % cov_fname
return cov_fname
def test_io_cov():
"""Test IO for noise covariance matrices
"""
cov = read_cov(cov_fname)
cov.save(op.join(tempdir, 'test-cov.fif'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif'))
assert_array_almost_equal(cov.data, cov2.data)
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, 'test-cov.fif.gz'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz'))
assert_array_almost_equal(cov.data, cov2.data)
cov['bads'] = ['EEG 039']
cov_sel = pick_channels_cov(cov, exclude=cov['bads'])
assert_true(cov_sel['dim'] == (len(cov['data']) - len(cov['bads'])))
assert_true(cov_sel['data'].shape == (cov_sel['dim'], cov_sel['dim']))
cov_sel.save(op.join(tempdir, 'test-cov.fif'))
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, 'test-cov.fif.gz'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz'))
assert_array_almost_equal(cov.data, cov2.data)
# test warnings on bad filenames
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
cov_badname = op.join(tempdir, 'test-bad-name.fif.gz')
write_cov(cov_badname, cov)
read_cov(cov_badname)
assert_true(len(w) == 2)
def test_io_cov():
"""Test IO for noise covariance matrices
"""
tempdir = _TempDir()
cov = read_cov(cov_fname)
cov.save(op.join(tempdir, 'test-cov.fif'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif'))
assert_array_almost_equal(cov.data, cov2.data)
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, 'test-cov.fif.gz'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz'))
assert_array_almost_equal(cov.data, cov2.data)
cov['bads'] = ['EEG 039']
cov_sel = pick_channels_cov(cov, exclude=cov['bads'])
assert_true(cov_sel['dim'] == (len(cov['data']) - len(cov['bads'])))
assert_true(cov_sel['data'].shape == (cov_sel['dim'], cov_sel['dim']))
cov_sel.save(op.join(tempdir, 'test-cov.fif'))
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, 'test-cov.fif.gz'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz'))
assert_array_almost_equal(cov.data, cov2.data)
# test warnings on bad filenames
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
cov_badname = op.join(tempdir, 'test-bad-name.fif.gz')
write_cov(cov_badname, cov)
read_cov(cov_badname)
assert_true(len(w) == 2)
def test_io_cov():
"""Test IO for noise covariance matrices
"""
cov = read_cov(cov_fname)
cov.save(op.join(tempdir, "test-cov.fif"))
cov2 = read_cov(op.join(tempdir, "test-cov.fif"))
assert_array_almost_equal(cov.data, cov2.data)
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, "test-cov.fif.gz"))
cov2 = read_cov(op.join(tempdir, "test-cov.fif.gz"))
assert_array_almost_equal(cov.data, cov2.data)
cov["bads"] = ["EEG 039"]
cov_sel = pick_channels_cov(cov, exclude=cov["bads"])
assert_true(cov_sel["dim"] == (len(cov["data"]) - len(cov["bads"])))
assert_true(cov_sel["data"].shape == (cov_sel["dim"], cov_sel["dim"]))
cov_sel.save(op.join(tempdir, "test-cov.fif"))
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, "test-cov.fif.gz"))
cov2 = read_cov(op.join(tempdir, "test-cov.fif.gz"))
assert_array_almost_equal(cov.data, cov2.data)
# test warnings on bad filenames
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
cov_badname = op.join(tempdir, "test-bad-name.fif.gz")
write_cov(cov_badname, cov)
read_cov(cov_badname)
assert_true(len(w) == 2)
def apply_create_noise_covariance(fname_empty_room, require_filter=True, verbose=None):
'''
Creates the noise covariance matrix from an empty room file.
Parameters
----------
fname_empty_room : String containing the filename
of the empty room file (must be a fif-file)
require_filter: bool
If true, the empy room file is filtered before calculating
the covariance matrix. (Beware, filter settings are fixed.)
verbose : bool, str, int, or None
If not None, override default verbose level
(see mne.verbose).
default: verbose=None
'''
# -------------------------------------------
# import necessary modules
# -------------------------------------------
from mne import compute_raw_data_covariance as cp_covariance
from mne import write_cov
from mne.io import Raw
from mne import pick_types
import os
fner = get_files_from_list(fname_empty_room)
nfiles = len(fner)
# loop across all filenames
for ifile in range(nfiles):
fn_in = fner[ifile]
print ">>> create noise covariance using file: "
path_in , name = os.path.split(fn_in)
print name
if require_filter == True:
print "Filtering with preset settings..."
# filter empty room raw data
apply_filter(fn_in, flow=1, fhigh=45, order=4, njobs=4)
# reconstruct empty room file name accordingly
fn_in = fn_in.split('-')[0] + ',bp1-45Hz-empty.fif'
# file name for saving noise_cov
fn_out = fn_in.split('-')[0] + ',empty-cov.fif'
# read in data
raw_empty = Raw(fn_in, verbose=verbose)
# pick MEG channels only
picks = pick_types(raw_empty.info, meg=True, ref_meg=False, eeg=False, stim=False,
eog=False, exclude='bads')
# calculate noise-covariance matrix
noise_cov_mat = cp_covariance(raw_empty, picks=picks, verbose=verbose)
# write noise-covariance matrix to disk
write_cov(fn_out, noise_cov_mat)
def _run_interface(self, runtime):
raw_filename = self.inputs.raw_filename
cov_fname_in = self.inputs.cov_fname_in
is_epoched = self.inputs.is_epoched
is_evoked = self.inputs.is_evoked
events_id = self.inputs.events_id
t_min = self.inputs.t_min
t_max = self.inputs.t_max
data_path, basename, ext = split_f(raw_filename)
self.cov_fname_out = op.join(data_path, '%s-cov.fif' % basename)
# Check if a noise cov matrix was already computed
if not op.isfile(cov_fname_in):
if is_epoched and is_evoked:
raw = read_raw_fif(raw_filename)
events = find_events(raw)
if not op.isfile(self.cov_fname_out):
print(('\n*** COMPUTE COV FROM EPOCHS ***\n' +
self.cov_fname_out))
reject = _create_reject_dict(raw.info)
picks = pick_types(raw.info,
meg=True,
ref_meg=False,
exclude='bads')
epochs = Epochs(raw,
events,
events_id,
t_min,
t_max,
picks=picks,
baseline=(None, 0),
reject=reject)
# TODO method='auto'? too long!!!
noise_cov = compute_covariance(epochs,
tmax=0,
method='diagonal_fixed')
write_cov(self.cov_fname_out, noise_cov)
else:
print(('\n *** NOISE cov file %s exists!!! \n' %
self.cov_fname_out))
else:
# Compute noise cov matrix from empty room data
self.cov_fname_out = compute_noise_cov(
op.join(data_path, cov_fname_in), raw_filename)
else:
print(
('\n *** NOISE cov file {} exists!!! \n'.format(cov_fname_in)))
self.cov_fname_out = cov_fname_in
return runtime
def meg_calc_noise_cov(subj):
'''
Calculate noise covariance using rest epochs.
'''
subj = subj
epo = mne.read_epochs(subj)
noise_cov = mne.compute_covariance(epo['rest'], tmin = 0.0, method = 'empirical', n_jobs = n_cores)
noise_cov.plot(epo.info)
mne.write_cov(os.path.join(sourceP_dir, subj_id + '_noise-cov.fif'), noise_cov)
return(epo, noise_cov)
def compute_epochs_cov_evokeds(subject):
"""Epoch, compute noise covariance and average.
params:
subject : str
the subject id to be loaded
"""
raw = Raw(save_folder + "%s_filtered_ica_mc_raw_tsss.fif" % subject,
preload=True)
# Select events to extract epochs from.
event_id = {'ent_left': 1,
'ent_right': 2,
'ctl_left': 4,
'ctl_right': 8}
# Setup for reading the raw data
events = mne.find_events(raw, min_duration=0.01)
picks = mne.pick_types(raw.info, meg=True, eeg=True, stim=False, eog=False,
include=include, exclude='bads')
# Read epochs
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject,
preload=True)
epochs.save(epochs_folder + "%s_filtered_ica_mc_tsss-epo.fif" % subject)
# Plot epochs.
# epochs.plot(trellis=False)
# Look at channels that caused dropped events, showing that the subject's
# blinks were likely to blame for most epochs being dropped
epochs.drop_bad_epochs()
fig = epochs.plot_drop_log(subject=subject, show=False)
fig.savefig(epochs_folder + "pics/%s_drop_log.png" % subject)
# Make noise cov
cov = compute_covariance(epochs, tmin=None, tmax=0, method="auto")
mne.write_cov(epochs_folder + "%s-cov.fif" % subject, cov)
# Average epochs and get evoked data corresponding to the left stimulation
###########################################################################
# Save evoked responses for different conditions to disk
# average epochs and get Evoked datasets
evokeds = [epochs[cond].average() for cond in ['ent_left', 'ent_right',
'ctl_left', 'ctl_right']]
evokeds = [epochs[cond].average() for cond in epochs.event_id.keys()]
# save evoked data to disk
mne.write_evokeds(epochs_folder +
'%s_filtered_ica_mc_raw_tsss-ave.fif' % subject, evokeds)
plt.close("all")
def apply_create_noise_covariance(fname_empty_room, verbose=None):
'''
Creates the noise covariance matrix from an empty room file.
Parameters
----------
fname_empty_room : String containing the filename
of the de-noise, empty room file (must be a fif-file)
require_filter: bool
If true, the empy room file is filtered before calculating
the covariance matrix. (Beware, filter settings are fixed.)
verbose : bool, str, int, or None
If not None, override default verbose level
(see mne.verbose).
default: verbose=None
'''
# -------------------------------------------
# import necessary modules
# -------------------------------------------
from mne import compute_raw_data_covariance as cp_covariance
from mne import write_cov, pick_types
from mne.io import Raw
from jumeg.jumeg_noise_reducer import noise_reducer
fner = get_files_from_list(fname_empty_room)
nfiles = len(fner)
ext_empty_raw = '-raw.fif'
ext_empty_cov = '-cov.fif'
# loop across all filenames
for ifile in range(nfiles):
fn_in = fner[ifile]
print ">>> create noise covariance using file: "
path_in, name = os.path.split(fn_in)
print name
fn_empty_nr = fn_in[:fn_in.rfind('-raw.fif')] + ',nr-raw.fif'
noise_reducer(fn_in, refnotch=50, detrending=False, fnout=fn_empty_nr)
noise_reducer(fn_empty_nr, refnotch=60, detrending=False, fnout=fn_empty_nr)
noise_reducer(fn_empty_nr, reflp=5, fnout=fn_empty_nr)
# file name for saving noise_cov
fn_out = fn_empty_nr[:fn_empty_nr.rfind(ext_empty_raw)] + ext_empty_cov
# read in data
raw_empty = Raw(fn_empty_nr, preload=True, verbose=verbose)
raw_empty.interpolate_bads()
# pick MEG channels only
picks = pick_types(raw_empty.info, meg=True, ref_meg=False, eeg=False,
stim=False, eog=False, exclude='bads')
# calculate noise-covariance matrix
noise_cov_mat = cp_covariance(raw_empty, picks=picks, verbose=verbose)
# write noise-covariance matrix to disk
write_cov(fn_out, noise_cov_mat)
def compute_noise_cov(fname_template, raw_filename):
"""
Compute noise covariance data from a continuous segment of raw data.
Employ empty room data (collected without the subject) to calculate
the full noise covariance matrix.
This is recommended for analyzing ongoing spontaneous activity.
Inputs
cov_fname : str
noise covariance file name template
raw_filename : str
raw filename
Output
cov_fname : str
noise covariance file name in which is saved the noise covariance
matrix
"""
# Check if cov matrix exists
cov_fname = _get_cov_fname(fname_template)
if not op.isfile(cov_fname):
er_raw, cov_fname = _get_er_data(fname_template)
if not op.isfile(cov_fname) and er_raw:
reject = _create_reject_dict(er_raw.info)
picks = pick_types(er_raw.info,
meg=True,
ref_meg=False,
exclude='bads')
noise_cov = compute_raw_covariance(er_raw,
picks=picks,
reject=reject)
write_cov(cov_fname, noise_cov)
elif op.isfile(cov_fname):
print(('*** NOISE cov file {} exists!!!'.format(cov_fname)))
elif not er_raw:
cov_fname = compute_cov_identity(raw_filename)
else:
print(('*** NOISE cov file {} exists!!!'.format(cov_fname)))
return cov_fname
def compute_noise_cov(cov_fname, raw):
"""Compute noise covariance data from a continuous segment of raw data.
Employ empty room data (collected without the subject) to calculate
the full noise covariance matrix. This is recommended for analyzing ongoing
spontaneous activity.
Parameters
----------
cov_fname : str
noise covariance file name
raw : Raw
the raw data
Returns
-------
cov_fname : str
noise covariance file name in which is saved the noise covariance
matrix
"""
import os.path as op
from mne import compute_raw_covariance, pick_types, write_cov
from nipype.utils.filemanip import split_filename as split_f
from ephypype.preproc import create_reject_dict
print(('***** COMPUTE RAW COV *****' + cov_fname))
if not op.isfile(cov_fname):
data_path, basename, ext = split_f(raw.info['filename'])
fname = op.join(data_path, '%s-cov.fif' % basename)
reject = create_reject_dict(raw.info)
picks = pick_types(raw.info, meg=True, ref_meg=False, exclude='bads')
noise_cov = compute_raw_covariance(raw, picks=picks, reject=reject)
write_cov(fname, noise_cov)
else:
print(('*** NOISE cov file %s exists!!!' % cov_fname))
return cov_fname
def _run_interface(self, runtime):
raw_filename = self.inputs.raw_filename
cov_fname_in = self.inputs.cov_fname_in
is_epoched = self.inputs.is_epoched
is_evoked = self.inputs.is_evoked
events_id = self.inputs.events_id
t_min = self.inputs.t_min
t_max = self.inputs.t_max
if cov_fname_in == '' or not op.exists(cov_fname_in):
if is_epoched and is_evoked:
raw = Raw(raw_filename)
events = find_events(raw)
data_path, basename, ext = split_f(raw.info['filename'])
self.cov_fname_out = op.join(data_path, '%s-cov.fif' % basename)
if not op.exists(self.cov_fname_out):
print '\n*** COMPUTE COV FROM EPOCHS ***\n' + self.cov_fname_out
reject = create_reject_dict(raw.info)
picks = pick_types(raw.info, meg=True, ref_meg=False,
exclude='bads')
epochs = Epochs(raw, events, events_id, t_min, t_max,
picks=picks, baseline=(None, 0),
reject=reject)
# TODO method='auto'? too long!!!
noise_cov = compute_covariance(epochs, tmax=0,
method='diagonal_fixed')
write_cov(self.cov_fname_out, noise_cov)
else:
print '\n *** NOISE cov file %s exists!!! \n' % self.cov_fname_out
else:
'\n *** NO EPOCH DATA \n'
else:
print '\n *** NOISE cov file %s exists!!! \n' % cov_fname_in
self.cov_fname_out = cov_fname_in
return runtime
def compute_cov_identity(raw_filename):
"Compute Identity Noise Covariance matrix."
raw = read_raw_fif(raw_filename)
data_path, basename, ext = split_f(raw_filename)
cov_fname = op.join(data_path, 'identity_noise-cov.fif')
if not op.isfile(cov_fname):
picks = pick_types(raw.info, meg=True, ref_meg=False, exclude='bads')
ch_names = [raw.info['ch_names'][k] for k in picks]
bads = [b for b in raw.info['bads'] if b in ch_names]
noise_cov = mne.Covariance(np.identity(len(picks)), ch_names, bads,
raw.info['projs'], nfree=0)
write_cov(cov_fname, noise_cov)
return cov_fname
def compute_covariance_matrix(self,tmax=0,method='auto'):
""""""
fname = op.join(self.processed_files, '%s_cov.fif' %self.subject)
if not op.exists(fname):
cov_reg = mne.cov.compute_covariance(self.epochs_clean, tmax = 0, method=method)
mne.write_cov(fname, cov_reg)
self.add_preprocessing_notes("Noise covariance matrix computed, regularized, and saved to %s" %fname)
else:
cov_reg = mne.read_cov(fname)
self.cov_reg = cov_reg
return self.cov_reg
def compute_covariance_matrix(self,tmax=0,method='auto'):
""""""
fname = op.join(self.processed_files, '%s_cov.fif' %self.subject)
if not op.exists(fname):
cov_reg = mne.cov.compute_covariance(self.epochs_clean, tmax = 0, method=method)
mne.write_cov(fname, cov_reg)
self.add_preprocessing_notes("Noise covariance matrix computed, regularized, and saved to %s" %fname)
else:
cov_reg = mne.read_cov(fname)
self.cov_reg = cov_reg
return self.cov_reg
def _run_interface(self, runtime):
raw_filename = self.inputs.raw_filename
cov_fname_in = self.inputs.cov_fname_in
is_epoched = self.inputs.is_epoched
is_evoked = self.inputs.is_evoked
data_path, basename, ext = split_f(raw_filename)
# self.cov_fname_out = op.join(data_path, '%s-cov.fif' % basename)
self.cov_fname_out = op.abspath('%s-cov.fif' % basename)
# Check if a noise cov matrix was already computed
if not op.isfile(cov_fname_in):
if is_epoched and is_evoked:
epochs = read_epochs(raw_filename, preload=True)
if not op.isfile(self.cov_fname_out):
print(('\n*** COMPUTE COV FROM EPOCHS ***\n' +
self.cov_fname_out))
# make sure cv is deterministic
cv = KFold(3, random_state=42)
noise_cov = compute_covariance(epochs,
tmax=0,
method='shrunk',
cv=cv)
write_cov(self.cov_fname_out, noise_cov)
else:
print(('\n *** NOISE cov file %s exists!!! \n' %
self.cov_fname_out))
else:
# Compute noise cov matrix from empty room data
self.cov_fname_out = compute_noise_cov(
op.join(data_path, cov_fname_in), raw_filename)
else:
print(
('\n *** NOISE cov file {} exists!!! \n'.format(cov_fname_in)))
self.cov_fname_out = cov_fname_in
return runtime
def read_noise_cov(cov_fname, raw_info):
import os.path as op
import numpy as np
import mne
print '***** READ RAW COV *****' + cov_fname
if not op.isfile(cov_fname):
# create an Identity matrix
picks = mne.pick_types(raw_info, meg=True, ref_meg=False,
exclude='bads')
ch_names = [raw_info['ch_names'][i] for i in picks]
C = mne.Covariance(data=np.identity(len(picks)), names=ch_names,
bads=[], projs=[], nfree=0)
mne.write_cov(cov_fname, C)
else:
print '*** noise covariance file %s exists!!!' % cov_fname
noise_cov = mne.read_cov(cov_fname)
return noise_cov
def read_noise_cov(cov_fname, raw_info):
"""Read a noise covariance matrix from cov_fname.
Parameters
----------
cov_fname : str
noise covariance file name
raw_info : dict
dictionary containing the information about the raw data
Returns
-------
noise_cov : Covariance
the noise covariance matrix
"""
import os.path as op
import numpy as np
import mne
print(('***** READ RAW COV *****' + cov_fname))
if not op.isfile(cov_fname):
# create an Identity matrix
picks = mne.pick_types(raw_info,
meg=True,
ref_meg=False,
exclude='bads')
ch_names = [raw_info['ch_names'][i] for i in picks]
c = mne.Covariance(data=np.identity(len(picks)),
names=ch_names,
bads=[],
projs=[],
nfree=0)
mne.write_cov(cov_fname, c)
else:
print(('*** noise covariance file %s exists!!!' % cov_fname))
noise_cov = mne.read_cov(cov_fname)
return noise_cov
def test_io_cov():
"""Test IO for noise covariance matrices
"""
tempdir = _TempDir()
cov = read_cov(cov_fname)
cov['method'] = 'empirical'
cov['loglik'] = -np.inf
cov.save(op.join(tempdir, 'test-cov.fif'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif'))
assert_array_almost_equal(cov.data, cov2.data)
assert_equal(cov['method'], cov2['method'])
assert_equal(cov['loglik'], cov2['loglik'])
assert_true('Covariance' in repr(cov))
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, 'test-cov.fif.gz'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz'))
assert_array_almost_equal(cov.data, cov2.data)
cov['bads'] = ['EEG 039']
cov_sel = pick_channels_cov(cov, exclude=cov['bads'])
assert_true(cov_sel['dim'] == (len(cov['data']) - len(cov['bads'])))
assert_true(cov_sel['data'].shape == (cov_sel['dim'], cov_sel['dim']))
cov_sel.save(op.join(tempdir, 'test-cov.fif'))
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, 'test-cov.fif.gz'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz'))
assert_array_almost_equal(cov.data, cov2.data)
# test warnings on bad filenames
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
cov_badname = op.join(tempdir, 'test-bad-name.fif.gz')
write_cov(cov_badname, cov)
read_cov(cov_badname)
assert_naming(w, 'test_cov.py', 2)
def test_io_cov():
"""Test IO for noise covariance matrices."""
tempdir = _TempDir()
cov = read_cov(cov_fname)
cov["method"] = "empirical"
cov["loglik"] = -np.inf
cov.save(op.join(tempdir, "test-cov.fif"))
cov2 = read_cov(op.join(tempdir, "test-cov.fif"))
assert_array_almost_equal(cov.data, cov2.data)
assert_equal(cov["method"], cov2["method"])
assert_equal(cov["loglik"], cov2["loglik"])
assert_true("Covariance" in repr(cov))
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, "test-cov.fif.gz"))
cov2 = read_cov(op.join(tempdir, "test-cov.fif.gz"))
assert_array_almost_equal(cov.data, cov2.data)
cov["bads"] = ["EEG 039"]
cov_sel = pick_channels_cov(cov, exclude=cov["bads"])
assert_true(cov_sel["dim"] == (len(cov["data"]) - len(cov["bads"])))
assert_true(cov_sel["data"].shape == (cov_sel["dim"], cov_sel["dim"]))
cov_sel.save(op.join(tempdir, "test-cov.fif"))
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, "test-cov.fif.gz"))
cov2 = read_cov(op.join(tempdir, "test-cov.fif.gz"))
assert_array_almost_equal(cov.data, cov2.data)
# test warnings on bad filenames
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
cov_badname = op.join(tempdir, "test-bad-name.fif.gz")
write_cov(cov_badname, cov)
read_cov(cov_badname)
assert_naming(w, "test_cov.py", 2)
def create_noise_covariance_matrix(fname_empty_room,
fname_out=None,
verbose=None):
"""Creates the noise covariance matrix from an empty room file"""
print ">>>> estimate noise covariance matrix from empty room file..."
# read in data
raw_empty = mne.fiff.Raw(fname_empty_room, verbose=verbose)
# filter data
# pick only MEG channels
picks = mne.fiff.pick_types(raw_empty.info, meg=True, exclude='bads')
# calculate noise-covariance matrix
noise_cov_mat = mne.compute_raw_data_covariance(raw_empty,
picks=picks,
verbose=verbose)
# write noise-covariance matrix to disk
if fname_out is not None:
mne.write_cov(fname_out, noise_cov_mat)
return noise_cov_mat
def test_io_cov():
"""Test IO for noise covariance matrices."""
tempdir = _TempDir()
cov = read_cov(cov_fname)
cov['method'] = 'empirical'
cov['loglik'] = -np.inf
cov.save(op.join(tempdir, 'test-cov.fif'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif'))
assert_array_almost_equal(cov.data, cov2.data)
assert_equal(cov['method'], cov2['method'])
assert_equal(cov['loglik'], cov2['loglik'])
assert 'Covariance' in repr(cov)
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, 'test-cov.fif.gz'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz'))
assert_array_almost_equal(cov.data, cov2.data)
cov['bads'] = ['EEG 039']
cov_sel = pick_channels_cov(cov, exclude=cov['bads'])
assert cov_sel['dim'] == (len(cov['data']) - len(cov['bads']))
assert cov_sel['data'].shape == (cov_sel['dim'], cov_sel['dim'])
cov_sel.save(op.join(tempdir, 'test-cov.fif'))
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, 'test-cov.fif.gz'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz'))
assert_array_almost_equal(cov.data, cov2.data)
# test warnings on bad filenames
cov_badname = op.join(tempdir, 'test-bad-name.fif.gz')
with pytest.warns(RuntimeWarning, match='-cov.fif'):
write_cov(cov_badname, cov)
with pytest.warns(RuntimeWarning, match='-cov.fif'):
read_cov(cov_badname)
def test_io_cov():
"""Test IO for noise covariance matrices."""
tempdir = _TempDir()
cov = read_cov(cov_fname)
cov['method'] = 'empirical'
cov['loglik'] = -np.inf
cov.save(op.join(tempdir, 'test-cov.fif'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif'))
assert_array_almost_equal(cov.data, cov2.data)
assert_equal(cov['method'], cov2['method'])
assert_equal(cov['loglik'], cov2['loglik'])
assert 'Covariance' in repr(cov)
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, 'test-cov.fif.gz'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz'))
assert_array_almost_equal(cov.data, cov2.data)
cov['bads'] = ['EEG 039']
cov_sel = pick_channels_cov(cov, exclude=cov['bads'])
assert cov_sel['dim'] == (len(cov['data']) - len(cov['bads']))
assert cov_sel['data'].shape == (cov_sel['dim'], cov_sel['dim'])
cov_sel.save(op.join(tempdir, 'test-cov.fif'))
cov2 = read_cov(cov_gz_fname)
assert_array_almost_equal(cov.data, cov2.data)
cov2.save(op.join(tempdir, 'test-cov.fif.gz'))
cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz'))
assert_array_almost_equal(cov.data, cov2.data)
# test warnings on bad filenames
cov_badname = op.join(tempdir, 'test-bad-name.fif.gz')
with pytest.warns(RuntimeWarning, match='-cov.fif'):
write_cov(cov_badname, cov)
with pytest.warns(RuntimeWarning, match='-cov.fif'):
read_cov(cov_badname)
def create_noise_covariance_matrix(fname_empty_room, fname_out=None, verbose=None):
"""Creates the noise covariance matrix from an empty room file"""
print ">>>> estimate noise covariance matrix from empty room file..."
# read in data
raw_empty = mne.fiff.Raw(fname_empty_room,
verbose=verbose)
# filter data
# pick only MEG channels
picks = mne.fiff.pick_types(raw_empty.info,
meg=True,
exclude='bads')
# calculate noise-covariance matrix
noise_cov_mat = mne.compute_raw_data_covariance(raw_empty,
picks=picks,
verbose=verbose)
# write noise-covariance matrix to disk
if fname_out is not None:
mne.write_cov(fname_out, noise_cov_mat)
return noise_cov_mat
PartNoise = 'ParticipantNoise_Preprocessed_trans_raw_tsss.fif'
PartNoiseData = mne.io.read_raw_fif(
rootdir + '/Datafiles/ICAforConcatenatedRaws/' + PartNoise, preload=True)
sfreq = PartNoiseData.info['sfreq']
picks = mne.pick_types(PartNoiseData.info,
meg=True,
eeg=False,
eog=False,
stim=False,
exclude='bads')
# Covariance calculation:
print('\n<< Calculating Covariance from Participant Noise Data >>')
if CovRankEst:
rank = None
newfile = 'NoiseCov_fromParticipantNoise-cov.fif'
else:
rank = 'full'
newfile = 'NoiseCov_fromParticipantNoise_FullRank-cov.fif'
NoiseCov = mne.compute_raw_covariance(PartNoiseData,
picks=picks,
method='shrunk',
rank=rank)
# save data files
os.chdir(rootdir)
mne.write_cov(newfile, NoiseCov)
# # pick EEG channels
picks = mne.pick_types(raw.info, meg=True, eeg=False, stim=False, eog=True, include=include, exclude='bads')
reject = dict(mag = 4e-12, grad = 4000e-13)
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, baseline = (None,0), picks = picks, proj = True, preload = True, reject=reject)
print epochs
# ##Example: reject = dict(grad=4000e-13, # T / m (gradiometers)
# mag=4e-12, # T (magnetometers)
# eeg=40e-6, # uV (EEG channels)
# eog=250e-6 # uV (EOG channels)
# )
# Compute the covariance from the raw data or from epochs
cov = mne.compute_covariance(epochs, tmin = None, tmax = 0) #Use for runs...
print cov
# covRuns.append(cov)
mne.write_cov(cname, cov)
#
#print len(covRuns)
#
###Make the Final Grand average of all the runs
#runData = []
#runNave = []
#newCov = []
#newCov = copy.deepcopy(cov)
#count = 0
#
#for covRun in covRuns:
# runData.append(covRun)
### runNave.append(evRun[c].nave)
# print 'Jane Here',
#print runData
import mne
import sys
from mne import compute_covariance
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from my_settings import *
reject = dict(
grad=4000e-13, # T / m (gradiometers)
mag=4e-12, # T (magnetometers)
eeg=180e-6 #
)
subject = sys.argv[1]
epochs = mne.read_epochs(epochs_folder + "%s_trial_start-epo.fif" % subject)
epochs.drop_bad_epochs(reject_params)
# fig = epochs.plot_drop_log(subject=subject, show=False)
# fig.savefig(epochs_folder + "pics/%s_drop_log.png" % subject)
# Make noise cov
cov = compute_covariance(epochs, tmin=None, tmax=0, method="factor_analysis")
mne.write_cov(mne_folder + "%s-cov.fif" % subject, cov)
baseline=baseline)
return epochs
epochs_s = [process_meg(raw_name) for raw_name in raw_name_s]
evoked_s = [ep.average() for ep in epochs_s]
# compute noise covariance (takes a few minutes)
noise_cov_s = []
for subj, ep in zip(["a", "b"], epochs_s):
cov_fname = meg_path + f"subject_{subj}/sef-cov.fif"
if os.path.exists(cov_fname):
cov = mne.read_cov(cov_fname)
else:
cov = mne.compute_covariance(ep, tmin=None, tmax=0.)
mne.write_cov(cov_fname, cov)
noise_cov_s.append(cov)
f, axes = plt.subplots(1, 2, sharey=True)
for ax, ev, nc, ll in zip(axes.ravel(), evoked_s, noise_cov_s, ["a", "b"]):
picks = mne.pick_types(ev.info, meg="grad")
ev.plot(picks=picks, axes=ax, noise_cov=nc, show=False)
ax.set_title("Subject %s" % ll, fontsize=15)
plt.show()
#########################################################
# Source and forward modeling
# ---------------------------
# To guarantee an alignment across subjects, we start by
# computing (or reading if available) the source space of the average
# subject of freesurfer `fsaverage`
fwd_fname = meg_dir + subject + '_shepard-fwd.fif'
inv_fname = meg_dir + subject + '_shepard-inv.fif'
src_fname = meg_dir + subject + '-ico-4-src.fif'
trans_fname = meg_dir + subject + '-trans.fif'
bem_fname = mri_dir + '%s/bem/%s-inner_skull-bem-sol.fif' % (subject,
subject)
stc_fname = meg_dir + subject + '_shepard.stc.npy'
os.environ[
"SUBJECTS_DIR"] = '/Volumes/Server/MORPHLAB/Users/Ellie/Shepard/mri/'
# load
epochs = read_epochs(epochs_fname)
print("Making covariance matrix...")
noise_cov = compute_covariance(epochs, tmax=0., method=['shrunk'])
write_cov(cov_fname, noise_cov)
noise_cov = read_cov(cov_fname)
print("Making BEM model...")
surfaces = make_bem_model(subject,
ico=4,
conductivity=(0.3, ),
subjects_dir=mri_dir,
verbose=None)
bem = make_bem_solution(surfaces)
write_bem_solution(bem_fname, bem)
# if not op.isfile(fwd_fname):
print("Making forward solution...")
src = setup_source_space(subject, spacing='ico4', subjects_dir=mri_dir)
def apply_cov(fname_empty_room, filtered=True):
'''
Creates the noise covariance matrix from an empty room file.
Parameters
----------
fname_empty_room : String containing the filename
of the empty room file (must be a fif-file)
File name should end with -raw.fif in order to have proper output filenames.
require_filter: bool
If true, the empy room file is filtered before calculating
the covariance matrix. (Beware, filter settings are fixed.)
require_noise_reducer: bool
If true, a noise reducer is applied on the empty room file.
The noise reducer frequencies are fixed to 50Hz, 60Hz and
to frequencies less than 5Hz i.e. the reference channels are filtered to
these frequency ranges and then signal obtained is removed from
the empty room raw data. For more information please check the jumeg noise reducer.
verbose : bool, str, int, or None
If not None, override default verbose level
(see mne.verbose).
default: verbose=None
'''
# -------------------------------------------
# import necessary modules
# -------------------------------------------
from mne import compute_raw_covariance as cp_covariance
from mne import write_cov, pick_types
from mne.io import Raw
fner = get_files_from_list(fname_empty_room)
nfiles = len(fner)
# loop across all filenames
for ifile in range(nfiles):
fn_in = fner[ifile]
fn_fig1 = fn_in[:fn_in.rfind(ext_empty_raw)] + ',Magnetometers.tiff'
fn_fig2 = fn_in[:fn_in.rfind(ext_empty_raw)] + ',Eigenvalue_index.tiff'
#fn_out = fn_in[:fn_in.rfind(ext_empty_raw)] + ext_empty_cov
path_in, name = os.path.split(fn_in)
subject = name.split('_')[0]
# read in data
raw_empty = Raw(fn_in)
# pick MEG channels only
picks = pick_types(raw_empty.info, meg=True, exclude='bads')
# calculate noise-covariance matrix
noise_cov_mat = cp_covariance(raw_empty,
tmin=None,
tmax=None,
tstep=0.2,
picks=picks)
#noise_cov_mat = cp_covariance(raw_empty, picks=picks)
fig1, fig2 = mne.viz.plot_cov(noise_cov_mat, raw_empty.info)
# write noise-covariance matrix to disk
if filtered:
fn_out = path_in + '/%s_empty,fibp1-45' % subject + ext_empty_cov
else:
fn_out = path_in + '/%s_empty' % subject + ext_empty_cov
write_cov(fn_out, noise_cov_mat)
fig1.savefig(fn_fig1)
fig2.savefig(fn_fig2)
pl.close('all')
def apply_create_noise_covariance(fname_empty_room, require_filter=False,
require_noise_reducer=False, verbose=None):
'''
Creates the noise covariance matrix from an empty room file.
Parameters
----------
fname_empty_room : String containing the filename
of the empty room file (must be a fif-file)
File name should end with -raw.fif in order to have proper output filenames.
require_filter: bool
If true, the empy room file is filtered before calculating
the covariance matrix. (Beware, filter settings are fixed.)
require_noise_reducer: bool
If true, a noise reducer is applied on the empty room file.
The noise reducer frequencies are fixed to 50Hz, 60Hz and
to frequencies less than 5Hz i.e. the reference channels are filtered to
these frequency ranges and then signal obtained is removed from
the empty room raw data. For more information please check the jumeg noise reducer.
verbose : bool, str, int, or None
If not None, override default verbose level
(see mne.verbose).
default: verbose=None
'''
# -------------------------------------------
# import necessary modules
# -------------------------------------------
from mne import compute_raw_data_covariance as cp_covariance
from mne import write_cov, pick_types
from mne.io import Raw
from jumeg.jumeg_noise_reducer import noise_reducer
fner = get_files_from_list(fname_empty_room)
nfiles = len(fner)
# loop across all filenames
for ifile in range(nfiles):
fn_in = fner[ifile]
print ">>> create noise covariance using file: "
path_in, name = os.path.split(fn_in)
print name
if require_filter:
print "Filtering with preset settings..."
# filter empty room raw data
apply_filter(fn_in, flow=1, fhigh=45, order=4, njobs=4)
# reconstruct empty room file name accordingly
fn_in = fn_in[:fn_in.rfind(ext_empty_raw)] + ',fibp1-45-raw.fif'
if require_noise_reducer:
fn_empty_nr = fn_in[:fn_in.rfind(ext_empty_raw)] + ',nr-raw.fif'
noise_reducer(fn_in, refnotch=50, detrending=False, fnout=fn_empty_nr)
noise_reducer(fn_empty_nr, refnotch=60, detrending=False, fnout=fn_empty_nr)
noise_reducer(fn_empty_nr, reflp=5, fnout=fn_empty_nr)
fn_in = fn_empty_nr
# file name for saving noise_cov
fn_out = fn_in[:fn_in.rfind(ext_empty_raw)] + ext_empty_cov
# read in data
raw_empty = Raw(fn_in, verbose=verbose)
# pick MEG channels only
picks = pick_types(raw_empty.info, meg=True, ref_meg=False, eeg=False,
stim=False, eog=False, exclude='bads')
# calculate noise-covariance matrix
noise_cov_mat = cp_covariance(raw_empty, picks=picks, verbose=verbose)
# write noise-covariance matrix to disk
write_cov(fn_out, noise_cov_mat)
def _compute_evoked(subject, kind):
fname = BIDSPath(root=BIDS_ROOT,
subject=subject,
session=kind,
task=kind,
datatype='meg',
extension='.fif')
raw = read_raw_bids(fname)
mne.channels.fix_mag_coil_types(raw.info)
raw = _run_maxfilter(raw)
raw.filter(0.1, 45)
_compute_add_ssp_exg(raw)
out = {}
for ii, event_id in enumerate(task_info[kind]['event_id']):
epochs_params = task_info[kind]['epochs_params'][ii]
lock = task_info[kind]['lock'][ii]
events = mne.find_events(raw,
uint_cast=True,
min_duration=2. / raw.info['sfreq'])
if kind == 'task' and lock == 'resp':
event_map = np.array([(k, v)
for k, v in Counter(events[:, 2]).items()])
button_press = event_map[:, 0][np.argmax(event_map[:, 1])]
if event_map[:, 1][np.argmax(event_map[:, 1])] >= 50:
events[events[:, 2] == button_press, 2] = 8192
else:
raise RuntimeError('Could not guess button press')
reject = _get_global_reject_epochs(raw,
events=events,
event_id=event_id,
epochs_params=epochs_params)
epochs = mne.Epochs(raw,
events=events,
event_id=event_id,
reject=reject,
preload=True,
**epochs_params)
evokeds = list()
for kk in event_id:
evoked = epochs[kk].average()
evoked.comment = kk
evokeds.append(evoked)
# tmax is 0.05 to account for the shift error of 50ms in camcan
noise_covs = mne.compute_covariance(epochs,
tmin=None,
tmax=0.05,
verbose=False,
n_jobs=1,
projs=None)
out_path = op.join(derivative_path, subject)
if not op.exists(out_path):
os.makedirs(out_path)
epo_fname = op.join(out_path, '%s_%s_sensors-epo.fif' % (kind, lock))
cov_fname = op.join(out_path, '%s_%s_sensors-cov.fif' % (kind, lock))
ave_fname = op.join(out_path, '%s_%s_sensors-ave.fif' % (kind, lock))
mne.write_evokeds(ave_fname, evokeds)
mne.write_cov(cov_fname, noise_covs)
epochs.save(epo_fname, overwrite=True)
out.update({lock: (kind, epochs.average().nave)})
return out
subject = sys.argv[1] #Get the subject
except:
print "Please run with input file provided. Exiting"
sys.exit()
subjects_dir = '/home/qdong/freesurfer/subjects/'
subject_path = subjects_dir + subject #Set the data path of the subject
raw_empty_fname = subject_path + '/MEG/%s_emptyroom.fif' % subject
raw_empty = mne.fiff.Raw(raw_empty_fname, preload=True)
#Filter the empty room data
picks_empty = mne.fiff.pick_types(raw_empty.info,
meg=True,
eeg=False,
eog=True,
ecg=True,
stim=False,
exclude='bads')
raw_empty.filter(flow,
fhigh,
picks=picks_empty,
n_jobs=njobs,
method='iir',
iir_params={
'ftype': filter_type,
'order': filter_order
})
#Get the basename
raw_empty_basename = os.path.splitext(os.path.basename(raw_empty_fname))[0]
cov = mne.compute_raw_data_covariance(raw_empty, picks=picks_empty)
mne.write_cov(subject_path + '/MEG/%s_cov.fif' % (raw_empty_basename), cov)
def run_correlation(subjects_dir, subject, volume_spacing, freq, ortho_bool):
num_threads(8)
ortho_flag = str(ortho_bool)
frequency = str(freq)
DATA_DIR = Path(f'{subjects_dir}', f'{subject}', 'mne_files')
eye_proj1 = f'{DATA_DIR}/{subject}_eyes1-proj.fif.gz'
eye_proj2 = f'{DATA_DIR}/{subject}_eyes2-proj.fif.gz'
fname_meg = f'{DATA_DIR}/{subject}_ses-rest_task-rest.fif'
t1_fname = os.path.join(subjects_dir, subject, 'mri', 'T1.mgz')
heartbeat_proj = f'{DATA_DIR}/{subject}_heartbeat-proj.fif.gz'
fwd_fname = f'{DATA_DIR}/{subject}_{volume_spacing}-fwd.fif.gz'
src_fname = f'{DATA_DIR}/{subject}_{volume_spacing}-src.fif.gz'
cov_fname = f'{DATA_DIR}/{subject}-cov_{volume_spacing}.fif.gz'
raw_cov_fname = f'{DATA_DIR}/{subject}-rawcov_{volume_spacing}.fif.gz'
raw_proj = f'{DATA_DIR}/{subject}_ses-rest_task-rest_proj.fif.gz'
source_voxel_coords = f'{DATA_DIR}/{subject}_coords_{volume_spacing}.pkl'
corr_file_acLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_acLeft.npy'
corr_file_scLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_scLeft.npy'
corr_file_vcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_vcLeft.npy'
corr_file_mtLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mtLeft.npy'
corr_file_mtlLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mtlLeft.npy'
corr_file_smcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_smcLeft.npy'
corr_file_lpcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_lpcLeft.npy'
corr_file_dpfcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_dpfcLeft.npy'
corr_file_tmpcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_tmpcLeft.npy'
corr_file_acRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_acRight.npy'
corr_file_scRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_scRight.npy'
corr_file_vcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_vcRight.npy'
corr_file_mtRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mtRight.npy'
corr_file_mtlRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mtlRight.npy'
corr_file_smcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_smcRight.npy'
corr_file_lpcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_lpcRight.npy'
corr_file_dpfcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_dpfcRight.npy'
corr_file_tmpcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_tmpcRight.npy'
corr_file_mpfc = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mpfc.npy'
corr_file_sma = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_sma.npy'
check_for_files = []
check_for_files.append(corr_file_acLeft)
check_for_files.append(corr_file_scLeft)
check_for_files.append(corr_file_vcLeft)
check_for_files.append(corr_file_mtLeft)
check_for_files.append(corr_file_mtlLeft)
check_for_files.append(corr_file_smcLeft)
check_for_files.append(corr_file_lpcLeft)
check_for_files.append(corr_file_dpfcLeft)
check_for_files.append(corr_file_tmpcLeft)
check_for_files.append(corr_file_acRight)
check_for_files.append(corr_file_scRight)
check_for_files.append(corr_file_vcRight)
check_for_files.append(corr_file_mtRight)
check_for_files.append(corr_file_mtlRight)
check_for_files.append(corr_file_smcRight)
check_for_files.append(corr_file_lpcRight)
check_for_files.append(corr_file_dpfcRight)
check_for_files.append(corr_file_tmpcRight)
check_for_files.append(corr_file_mpfc)
check_for_files.append(corr_file_sma)
file_exist = [f for f in check_for_files if os.path.isfile(f)]
file_not_exist = list(set(file_exist) ^ set(check_for_files))
if not file_not_exist:
print('SC, AC, VC correlation files exists...')
else:
trans = f'/home/senthilp/caesar/camcan/cc700/camcan_coreg-master/trans/{subject}-trans.fif' # The transformation file obtained by coregistration
file_trans = pathlib.Path(trans)
file_ss = pathlib.Path(src_fname)
file_fm = pathlib.Path(fwd_fname)
file_proj = pathlib.Path(raw_proj)
file_cov = pathlib.Path(cov_fname)
file_rawcov = pathlib.Path(raw_cov_fname)
t1 = nib.load(t1_fname)
if not file_trans.exists():
print (f'{trans} File doesnt exist...')
sys.exit(0)
#info = mne.io.read_info(fname_meg)
# plot_registration(info, trans, subject, subjects_dir)
if not file_ss.exists():
src = compute_SourceSpace(subject, subjects_dir, src_fname, source_voxel_coords, plot=True, ss='volume',
volume_spacing=volume_spacing)
seed_l_sc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SSC_Left'])
seed_r_sc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SSC_Right'])
seed_l_ac = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['AC_Left'])
seed_r_ac = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['AC_Right'])
seed_l_vc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['VC_Left'])
seed_r_vc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['VC_Right'])
seed_l_mt = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MT+_Left'])
seed_r_mt = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MT+_Right'])
seed_l_mtl = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MTL_Left'])
seed_r_mtl = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MTL_Right'])
seed_l_smc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SMC_Left'])
seed_r_smc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SMC_Right'])
seed_l_lpc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['LPC_Left'])
seed_r_lpc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['LPC_Right'])
seed_l_dpfc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['DPFC_Left'])
seed_r_dpfc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['DPFC_Right'])
seed_l_tmpc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['TMPC_Left'])
seed_r_tmpc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['TMPC_Right'])
seed_mpfc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MPFC_MidBrain'])
seed_sma = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SMA_MidBrain'])
src_inuse = np.where(src[0]['inuse'] == 1)
loc_l_sc = src_inuse[0][0]
loc_r_sc = src_inuse[0][1]
loc_l_ac = src_inuse[0][2]
loc_r_ac = src_inuse[0][3]
loc_l_vc = src_inuse[0][4]
loc_r_vc = src_inuse[0][5]
loc_l_mt = src_inuse[0][6]
loc_r_mt = src_inuse[0][7]
loc_l_mtl = src_inuse[0][8]
loc_r_mtl = src_inuse[0][9]
loc_l_smc = src_inuse[0][10]
loc_r_smc = src_inuse[0][11]
loc_l_lpc = src_inuse[0][12]
loc_r_lpc = src_inuse[0][13]
loc_l_dpfc = src_inuse[0][14]
loc_r_dpfc = src_inuse[0][15]
loc_l_tmpc = src_inuse[0][16]
loc_r_tmpc = src_inuse[0][17]
loc_mpfc = src_inuse[0][18]
loc_sma = src_inuse[0][19]
src[0]['rr'][loc_l_sc] = seed_l_sc
src[0]['rr'][loc_r_sc] = seed_r_sc
src[0]['rr'][loc_l_ac] = seed_l_ac
src[0]['rr'][loc_r_ac] = seed_r_ac
src[0]['rr'][loc_l_vc] = seed_l_vc
src[0]['rr'][loc_r_vc] = seed_r_vc
src[0]['rr'][loc_l_mt] = seed_l_mt
src[0]['rr'][loc_r_mt] = seed_r_mt
src[0]['rr'][loc_l_mtl] = seed_l_mtl
src[0]['rr'][loc_r_mtl] = seed_r_mtl
src[0]['rr'][loc_l_smc] = seed_l_smc
src[0]['rr'][loc_r_smc] = seed_r_smc
src[0]['rr'][loc_l_lpc] = seed_l_lpc
src[0]['rr'][loc_r_lpc] = seed_r_lpc
src[0]['rr'][loc_l_dpfc] = seed_l_dpfc
src[0]['rr'][loc_r_dpfc] = seed_r_dpfc
src[0]['rr'][loc_l_tmpc] = seed_l_tmpc
src[0]['rr'][loc_r_tmpc] = seed_r_tmpc
src[0]['rr'][loc_mpfc] = seed_mpfc
src[0]['rr'][loc_sma] = seed_sma
src.save(src_fname, overwrite=True)
src = mne.read_source_spaces(src_fname)
#view_SS_brain(subject, subjects_dir, src)
if not file_fm.exists():
forward_model(subject, subjects_dir, fname_meg, trans, src, fwd_fname)
fwd = mne.read_forward_solution(fwd_fname)
# sensitivty_plot(subject, subjects_dir, fwd)
raw = mne.io.read_raw_fif(fname_meg, verbose='error', preload=True)
srate = raw.info['sfreq']
n_time_samps = raw.n_times
time_secs = raw.times
ch_names = raw.ch_names
n_chan = len(ch_names)
freq_res = srate/n_time_samps
print('\n')
print('-------------------------- Data summary-------------------------------')
print(f'Subject {subject}')
print(f"Frequency resolution {freq_res} Hz")
print(f"The first few channel names are {ch_names[:3]}")
print(f"The last time sample at {time_secs[-1]} seconds.")
print(f"Sampling Frequency (No of time points/sec) {srate} Hz")
print(f"Miscellaneous acquisition info {raw.info['description']}")
print(f"Bad channels marked during data acquisition {raw.info['bads']}")
print(f"Convert time in sec ( 60s ) to ingeter index {raw.time_as_index(60)}") # Convert time to indices
print(f"The raw data object has {n_time_samps} time samples and {n_chan} channels.")
print('------------------------------------------------------------------------')
print('\n')
# raw.plot(n_channels=10, scalings='auto', title='Data from arrays', show=True, block=True)
if not file_proj.exists():
projs_ecg, _ = compute_proj_ecg(raw, n_grad=1, n_mag=2, ch_name='ECG063')
projs_eog1, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='EOG061')
projs_eog2, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='EOG062')
if projs_ecg is not None:
mne.write_proj(heartbeat_proj, projs_ecg) # Saving projectors
raw.info['projs'] += projs_ecg
if projs_eog1 is not None:
mne.write_proj(eye_proj1, projs_eog1)
raw.info['projs'] += projs_eog1
if projs_eog2 is not None:
mne.write_proj(eye_proj2, projs_eog2)
raw.info['projs'] += projs_eog2
raw.apply_proj()
raw.save(raw_proj, proj=True, overwrite=True)
print(raw_proj)
raw_proj_applied = mne.io.read_raw_fif(raw_proj, verbose='error', preload=True)
print(f'High-pass filtering data at 0.5 Hz')
raw_proj_applied.filter(l_freq=0.5, h_freq=None, method='iir')
if not file_cov.exists():
cov = mne.compute_raw_covariance(raw_proj_applied) # compute before band-pass of interest
mne.write_cov(cov_fname, cov)
cov = mne.read_cov(cov_fname)
# cov.plot(raw.info, proj=True, exclude='bads', show_svd=False
# raw_proj_applied.crop(tmax=10)
do_epochs = False
l_freq = freq-2.0
h_freq = freq+2.0
print(f'Band pass filter data [{l_freq}, {h_freq}]')
raw_proj_filtered = raw_proj_applied.filter(l_freq=l_freq, h_freq=h_freq)
if do_epochs:
print('Segmenting raw data...')
events = mne.make_fixed_length_events(raw_proj_filtered, duration=5.)
raw_proj_filtered = mne.Epochs(raw_proj_filtered, events=events, tmin=0, tmax=5.,
baseline=None, preload=True)
data_cov = mne.compute_covariance(raw_proj_filtered)
else:
if not file_rawcov.exists():
data_cov = mne.compute_raw_covariance(raw_proj_filtered)
mne.write_cov(raw_cov_fname, data_cov)
else:
data_cov = mne.read_cov(file_rawcov)
filters = make_lcmv(raw_proj_filtered.info, fwd, data_cov, 0.05, cov,
pick_ori='max-power', weight_norm='nai')
raw_proj_filtered_comp = raw_proj_filtered.apply_hilbert()
if do_epochs:
stcs = apply_lcmv_epochs(raw_proj_filtered_comp, filters, return_generator=False)
else:
stcs = apply_lcmv_raw(raw_proj_filtered_comp, filters, verbose=True)
stcs = [stcs]
# Power Envelope Correlation
print(f'Computing Power Envelope Correlation for {subject}....Orthogonalize {ortho_flag}')
all_corr = envelope_correlation(stcs, combine=None, orthogonalize=False,
log=False, absolute=True, verbose=None)
np.save(corr_file_scLeft, all_corr[seed_left_sc])
np.save(corr_file_acLeft, all_corr[seed_left_ac])
np.save(corr_file_vcLeft, all_corr[seed_left_vc])
np.save(corr_file_mtLeft, all_corr[seed_left_mt])
np.save(corr_file_mtlLeft, all_corr[seed_left_mtl])
np.save(corr_file_smcLeft, all_corr[seed_left_smc])
np.save(corr_file_lpcLeft, all_corr[seed_left_lpc])
np.save(corr_file_dpfcLeft, all_corr[seed_left_dpfc])
np.save(corr_file_tmpcLeft, all_corr[seed_left_tmpc])
np.save(corr_file_scRight, all_corr[seed_right_sc])
np.save(corr_file_acRight, all_corr[seed_right_ac])
np.save(corr_file_vcRight, all_corr[seed_right_vc])
np.save(corr_file_mtRight, all_corr[seed_right_mt])
np.save(corr_file_mtlRight, all_corr[seed_right_mtl])
np.save(corr_file_smcRight, all_corr[seed_right_smc])
np.save(corr_file_lpcRight, all_corr[seed_right_lpc])
np.save(corr_file_dpfcRight, all_corr[seed_right_dpfc])
np.save(corr_file_tmpcRight, all_corr[seed_right_tmpc])
np.save(corr_file_mpfc, all_corr[seed_mpfc_index])
np.save(corr_file_sma, all_corr[seed_sma_index])
del stcs
def gen_covariances(p, subjects, run_indices, decim):
"""Generate forward solutions
Can only complete successfully once preprocessing is performed.
Parameters
----------
p : instance of Parameters
Analysis parameters.
subjects : list of str
Subject names to analyze (e.g., ['Eric_SoP_001', ...]).
run_indices : array-like | None
Run indices to include.
decim : list of int
The subject decimations.
"""
for si, subj in enumerate(subjects):
print(' Subject %2d/%2d...' % (si + 1, len(subjects)), end='')
cov_dir = op.join(p.work_dir, subj, p.cov_dir)
if not op.isdir(cov_dir):
os.mkdir(cov_dir)
has_rank_arg = 'rank' in get_args(compute_covariance)
kwargs = dict()
kwargs_erm = dict()
if p.cov_rank == 'full': # backward compat
if has_rank_arg:
kwargs['rank'] = 'full'
else:
if not has_rank_arg:
raise RuntimeError(
'There is no "rank" argument of compute_covariance, '
'you need to update MNE-Python')
if p.cov_rank is None:
assert p.compute_rank # otherwise this is weird
kwargs['rank'] = _compute_rank(p, subj, run_indices[si])
else:
kwargs['rank'] = p.cov_rank
kwargs_erm['rank'] = kwargs['rank']
if p.force_erm_cov_rank_full and has_rank_arg:
kwargs_erm['rank'] = 'full'
# Use the same thresholds we used for primary Epochs
if p.autoreject_thresholds:
reject = get_epochs_evokeds_fnames(p, subj, [])[0][1]
reject = reject.replace('-epo.fif', '-reject.h5')
reject = read_hdf5(reject)
else:
reject = _handle_dict(p.reject, subj)
flat = _handle_dict(p.flat, subj)
# Make empty room cov
if p.runs_empty:
if len(p.runs_empty) > 1:
raise ValueError('Too many empty rooms; undefined output!')
new_run = safe_inserter(p.runs_empty[0], subj)
empty_cov_name = op.join(
cov_dir, new_run + p.pca_extra + p.inv_tag + '-cov.fif')
empty_fif = get_raw_fnames(p, subj, 'pca', 'only', False)[0]
raw = read_raw_fif(empty_fif, preload=True)
raw.pick_types(meg=True, eog=True, exclude='bads')
use_reject, use_flat = _restrict_reject_flat(reject, flat, raw)
if 'eeg' in use_reject:
del use_reject['eeg']
if 'eeg' in use_flat:
del use_flat['eeg']
cov = compute_raw_covariance(raw,
reject=use_reject,
flat=use_flat,
method=p.cov_method,
**kwargs_erm)
write_cov(empty_cov_name, cov)
# Make evoked covariances
for ii, (inv_name, inv_run) in enumerate(zip(p.inv_names, p.inv_runs)):
cov_name = op.join(
cov_dir,
safe_inserter(inv_name, subj) + ('-%d' % p.lp_cut) +
p.inv_tag + '-cov.fif')
if run_indices[si] is None:
ridx = inv_run
else:
ridx = np.intersect1d(run_indices[si], inv_run)
# read in raw files
raw_fnames = get_raw_fnames(p, subj, 'pca', False, False, ridx)
raws = []
first_samps = []
last_samps = []
for raw_fname in raw_fnames:
raws.append(read_raw_fif(raw_fname, preload=False))
first_samps.append(raws[-1]._first_samps[0])
last_samps.append(raws[-1]._last_samps[-1])
_fix_raw_eog_cals(raws) # safe b/c cov only needs MEEG
raw = concatenate_raws(raws)
# read in events
events = _read_events(p, subj, ridx, raw)
if p.pick_events_cov is not None:
old_count = sum(len(e) for e in events)
if callable(p.pick_events_cov):
picker = p.pick_events_cov
else:
picker = p.pick_events_cov[ii]
events = picker(events)
new_count = len(events)
print(' Using %s/%s events for %s' %
(new_count, old_count, op.basename(cov_name)))
# create epochs
use_reject, use_flat = _restrict_reject_flat(reject, flat, raw)
baseline = _get_baseline(p)
epochs = Epochs(
raw,
events,
event_id=None,
tmin=baseline[0],
tmax=baseline[1],
baseline=(None, None),
proj=False,
reject=use_reject,
flat=use_flat,
preload=True,
decim=decim[si],
verbose='error', # ignore decim-related warnings
on_missing=p.on_missing,
reject_by_annotation=p.reject_epochs_by_annot)
epochs.pick_types(meg=True, eeg=True, exclude=[])
cov = compute_covariance(epochs, method=p.cov_method, **kwargs)
if kwargs.get('rank', None) not in (None, 'full'):
want_rank = sum(kwargs['rank'].values())
out_rank = compute_whitener(cov,
epochs.info,
return_rank=True,
verbose='error')[2]
if want_rank != out_rank:
# Hopefully we never hit this code path, but let's keep
# some debugging stuff around just in case
plot_cov(cov, epochs.info)
epochs_fnames, _ = get_epochs_evokeds_fnames(
p, subj, p.analyses)
epochs2 = read_epochs(epochs_fnames[1], preload=True)
idx = np.searchsorted(epochs.events[:, 0],
epochs2.events[:, 0])
assert len(np.unique(idx)) == len(idx)
epochs = epochs[idx]
assert np.array_equal(epochs.events[:, 0],
epochs2.events[:, 0])
epochs2.pick_types(meg=True, eeg=True, exclude=[])
import matplotlib.pyplot as plt
plt.figure()
for eps in (epochs, epochs2):
eps = eps.get_data().transpose([1, 0, 2])
eps = eps.reshape(len(eps), -1)
plt.plot(
np.log10(np.maximum(linalg.svdvals(eps), 1e-50)))
epochs.plot()
baseline = _get_baseline(p)
epochs2.copy().crop(*baseline).plot()
raise RuntimeError('Error computing rank')
write_cov(cov_name, cov)
print()
def apply_create_noise_covariance(fname_empty_room, fname_out, verbose=None):
'''
Creates the noise covariance matrix from an
empty room file.
Parameters
----------
fname_empty_room : String containing the filename
of the empty room file (must be a fif-file)
fname_out : String containing the output filename
of the noise-covariance estimation (must also
be a fif-file)
verbose : bool, str, int, or None
If not None, override default verbose level
(see mne.verbose).
default: verbose=None
'''
# -------------------------------------------
# import necessary modules
# -------------------------------------------
from mne import compute_raw_data_covariance as cp_covariance
from mne import write_cov
from mne.io import Raw
from mne import pick_types
import os
if isinstance(fname_empty_room, list):
fner = fname_empty_room
else:
if isinstance(fname_empty_room, str):
fner = list([fname_empty_room])
else:
fner = list(fname_empty_room)
nfiles = len(fner)
if isinstance(fname_out, list):
fnout = fname_out
else:
if isinstance(fname_out, str):
fnout = list([fname_out])
else:
fnout = list(fname_out)
if (len(fnout) != nfiles):
print ">>> Error (create_noise_covariance_matrix):"
print " Number of in/out files do not match"
print
exit()
# loop across all filenames
for ifile in range(nfiles):
fn_in = fner[ifile]
fn_out = fnout[ifile]
print ">>> create noise covariance using file: "
path_in , name = os.path.split(fn_in)
print name
# read in data
raw_empty = Raw(fn_in, verbose=verbose)
# pick MEG channels only
picks = pick_types(raw_empty.info, meg=True, eeg=False, stim=False,
eog=False, exclude='bads')
# calculate noise-covariance matrix
noise_cov_mat = cp_covariance(raw_empty, picks=picks, verbose=verbose)
# write noise-covariance matrix to disk
write_cov(fn_out, noise_cov_mat)
def intra(subj_list, fmin, fmax):
'''
Performs main process, including generation of inverse solution and PSD computation.
'''
for subj in subj_list:
print('Now beginning intra processing on ' + subj + '...\n') * 5
# Set function parameters
fname_raw = data_path + subj[:5] + '/' + subj
fname_fwd = data_path + subj[:5] + '/' + subj[:-4] + '-ico-4-fwd.fif'
# Load data
raw = fiff.Raw(fname_raw)
forward_meg = mne.read_forward_solution(fname_fwd)
# Estimate noise covariance from the raw data
precov = mne.compute_raw_data_covariance(raw, reject=dict(eog=150e-6))
write_cov(data_path + subj[:5] + '/' + subj[:-4] + '-cov.fif', precov)
# Find events from raw file
events = mne.find_events(raw, stim_channel='STI 014')
# Write events to file
mne.write_events(data_path + subj[:5] + '/' + subj[:-4] + '-eve.fif', events)
# Set up pick list:
include = []
exclude = raw.info['bads']
picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True, eog=True, include=include, exclude=exclude)
# Read epochs and remove bad epochs
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=(None, 0), preload=True, reject=dict(grad=4000e-13, mag=4e-12, eog=150e-6))
# Average epochs to produce an evoked dataset, then write to disk
evoked = epochs.average()
evoked.save(data_path + subj[:5] + '/' + subj[:-4] + '-ave.fif')
# Regularize noise cov
cov = mne.cov.regularize(precov, evoked.info, grad=0.05, mag=0.05, eeg=0.1, proj=True)
# Restrict forward solution as necessary for MEG
restricted_fwd = mne.fiff.pick_types_forward(forward_meg, meg=True, eeg=False)
# Make inverse operator
info = evoked.info
inverse_operator = make_inverse_operator(info, restricted_fwd, cov, loose=None, depth=0.8)
# Pull data for averaging later
epc_array = epochs.get_data()
# Compute the inverse solution
inv = apply_inverse(evoked, inverse_operator, lambda2, "dSPM", pick_normal=False)
inv.save(data_path + subj[:5] + '/' + subj[:-4] + '-inv.fif')
# picks MEG gradiometers
picks = fiff.pick_types(raw.info, meg=True, eeg=False, eog=True, stim=False, exclude=exclude)
# Compute source power spectral density and save to file
psd = compute_source_psd(raw, inverse_operator, method='dSPM', lambda2=lambda2, fmin=fmin, fmax=fmax, NFFT=2048)
psd.save(data_path + subj[:5] + '/' + subj[:-4] + '-psd.fif')
def intra(subj):
'''
Performs initial computations within subject and returns average PSD and variance of all epochs.
'''
print('Now beginning intra processing on ' + subj + '...\n') * 5
# Set function parameters
fname_label = subjects_dir + '/' + subj + '/' + 'label/%s.label' % label_name
fname_raw = data_path + subj + '/' + subj + '_rest_raw_sss.fif'
if os.path.isfile(data_path + subj + '/' + subj + '_rest_raw_sss-ico-4-fwd.fif'):
fname_fwd = data_path + subj + '/' + subj + '_rest_raw_sss-ico-4-fwd.fif'
else:
print('Subject ' + subj + ' does not have a ico-4-fwd.fif on file.')
if label_name.startswith('lh.'):
hemi = 'left'
elif label_name.startswith('rh.'):
hemi = 'right'
# Load data
label = mne.read_label(fname_label)
raw = fiff.Raw(fname_raw)
forward_meg = mne.read_forward_solution(fname_fwd)
# Estimate noise covariance from teh raw data
cov = mne.compute_raw_data_covariance(raw, reject=dict(eog=150e-6))
write_cov(data_path + subj + '/' + subj + '-cov.fif', cov)
# Make inverse operator
info = raw.info
inverse_operator = make_inverse_operator(info, forward_meg, cov, loose=None, depth=0.8)
# Epoch data into 4s intervals
events = mne.make_fixed_length_events(raw, 1, start=0, stop=None,
duration=4.)
# Set up pick list: (MEG minus bad channels)
include = []
exclude = raw.info['bads']
picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=False, eog=True, include=include, exclude=exclude)
# Read epochs and remove bad epochs
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=(None, 0), preload=True, reject=dict(grad=4000e-13, mag=4e-12, eog=150e-6))
# Pull data for averaging later
epc_array = epochs.get_data()
# Compute the inverse solution
inv = apply_inverse_epochs(epochs, inverse_operator, lambda2, method, label=label)
#Need to add a line here to automatically create stc directory within subj
epoch_num = 1
epoch_num_str = str(epoch_num)
for i in inv:
# i.save(data_path + subj + '/tmp/' + label_name[3:] + '_rest_raw_sss-oct-6-inv' + epoch_num_str)
i.save(data_path + subj + '/tmp/' + label_name[3:] + '_rest_raw_sss-ico-4-inv' + epoch_num_str)
epoch_num = epoch_num + 1
epoch_num_str = str(epoch_num)
# The following is used to remove the empty opposing hemisphere files
# and then move the files to save into the appropriate directory
if hemi == 'left':
filelist = [ f for f in os.listdir(data_path + subj + '/tmp') if f.endswith("-rh.stc") ]
for f in filelist:
os.remove(data_path + subj + '/tmp/' + f)
keepers = [ f for f in os.listdir(data_path + subj + '/tmp') if f.endswith("-lh.stc") ]
for f in keepers:
src = f
os.rename(data_path + subj + '/tmp/' + src, data_path + subj + '/inv/' + src)
elif hemi == 'right':
filelist = [ f for f in os.listdir(data_path + subj + '/tmp') if f.endswith("-lh.stc") ]
for f in filelist:
os.remove(data_path + subj + '/tmp/' + f)
keepers = [ f for f in os.listdir(data_path + subj + '/tmp') if f.endswith("-rh.stc") ]
for f in keepers:
src = f
os.rename(data_path + subj + '/tmp/' + src, data_path + subj + '/inv/' + src)
# define frequencies of interest
bandwidth = 4. # bandwidth of the windows in Hz
# compute source space psd in label
# Note: By using "return_generator=True" stcs will be a generator object
# instead of a list. This allows us so to iterate without having to
# keep everything in memory.
psd = compute_source_psd_epochs(epochs, inverse_operator, lambda2=lambda2,
method=method, fmin=fmin, fmax=fmax,
bandwidth=bandwidth, label=label, return_generator=False)
epoch_num = 1
epoch_num_str = str(epoch_num)
for i in psd:
i.save(data_path + subj + '/' + 'tmp' + '/' + label_name[3:] + '_dspm_snr-1_PSD'+ epoch_num_str)
epoch_num = epoch_num + 1
epoch_num_str = str(epoch_num)
if hemi == 'left':
filelist = [ f for f in os.listdir(data_path + subj + '/tmp') if f.endswith("-rh.stc") ]
for f in filelist:
os.remove(data_path + subj + '/tmp/' + f)
keepers = [ f for f in os.listdir(data_path + subj + '/tmp') if f.endswith("-lh.stc") ]
for f in keepers:
src = f
os.rename(data_path + subj + '/tmp/' + src,data_path + subj + '/psd/' + src)
elif hemi == 'right':
filelist = [ f for f in os.listdir(data_path + subj + '/tmp') if f.endswith("-lh.stc") ]
for f in filelist:
os.remove(data_path + subj + '/tmp/' + f)
keepers = [ f for f in os.listdir(data_path + subj + '/tmp') if f.endswith("-rh.stc") ]
for f in keepers:
src = f
os.rename(data_path + subj + '/tmp/' + src,data_path + subj + '/psd/' + src)
# This code computes the average PSDs of each epoch. Each PSD file is an array of shape N_vertices*N_frequencies. This code averages the PSD value of each vertex together and outputs the average PSD value of each frequency. Then, it averages the PSD values of each epoch, outputting one average PSD value per frequency value, i.e., this is the average across epochs.
n_epochs = len(epc_array)
for i, stc in enumerate(psd):
if i >= n_epochs:
break
if i == 0:
psd_avg = np.mean(stc.data, axis=0)
else:
psd_avg += np.mean(stc.data, axis=0)
print('Length of psd for subject ' + subj + ' is ' + str(len(psd)) + '.')
print('Number of epochs for subject ' + subj + ' is ' + str(n_epochs) + '.')
if len(psd) != 0:
psd_avg /= n_epochs
# Compute variance for each epoch and then variance across epochs
n_epochs = len(epc_array)
for i, stc in enumerate(psd):
if i >= n_epochs:
psd_var = np.array()
break
if i == 0:
psd_var = np.var(stc.data, axis=0)
else:
psd_var = np.vstack((psd_var,np.var(stc.data, axis=0)))
if len(psd) >= 2:
tot_var = np.var(psd_var, axis=0)
if len(psd) <= 1:
failed_subj = subj
print(failed_subj + ' failed. No PSD values calculated, likely because all epochs were rejected.')
return failed_subj, failed_subj, failed_subj
if len(psd) >= 2:
return (psd_avg, tot_var, len(psd_avg))
def apply_inverse(fnepo, method='dSPM', event='LLst', min_subject='fsaverage', STC_US='ROI',
condition='LL', save_cov=False):
'''
1. Noise covariance matrix is calculated under the condion of 'require_
filter'.
2. 'fnclean' is inversed and morphed into the common source space under
the condition of 'require_filter'.
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_use: string
The using of the inversion for further analysis.
'ROI' stands for ROIs definition, 'CAU' stands for causality analysis.
'''
#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:
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
snr = 3.0
lambda2 = 1.0 / snr ** 2
#noise_cov = mne.read_cov(fn_cov)
epochs = mne.read_epochs(fname)
fn_cov = meg_path + '/%s-cov.fif' %condition
if save_cov == False:
noise_cov = mne.read_cov(fn_cov)
elif save_cov==True:
noise_cov = mne.compute_covariance(epochs, tmax=0.)
mne.write_cov(fn_cov, noise_cov)
if STC_US == 'ROI':
# this path used for ROI definition
stc_path = min_dir + '/MNE_ROIs/%s' % 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=4, smooth=4)
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=4, smooth=4)
stc_morph.save(stcs_path + '/trial%s_fsaverage'
% (subject, str(s)), ftype='stc')
s = s + 1
verbose=None)
#writing and reading it in as surf_ori is set to true in the process
fwd20 = mne.read_forward_solution(fwd_fname20, surf_ori=True)
fwd30 = mne.read_forward_solution(fwd_fname30, surf_ori=True)
fwd40 = mne.read_forward_solution(fwd_fname40, surf_ori=True)
epochs20 = mne.read_epochs(fname20, proj=True, preload=True, verbose=None)
epochs30 = mne.read_epochs(fname30, proj=True, preload=True, verbose=None)
epochs40 = mne.read_epochs(fname40, proj=True, preload=True, verbose=None)
noise_cov20 = mne.compute_covariance(epochs20, tmax=0., method=['shrunk'])
noise_cov30 = mne.compute_covariance(epochs30, tmax=0., method=['shrunk'])
noise_cov40 = mne.compute_covariance(epochs40, tmax=0., method=['shrunk'])
mne.write_cov(cov20_fname, noise_cov20)
mne.write_cov(cov30_fname, noise_cov30)
mne.write_cov(cov40_fname, noise_cov40)
evoked20 = epochs20.average()
evoked30 = epochs30.average()
evoked40 = epochs40.average()
# make an MEG inverse operator
info20 = evoked20.info
info30 = evoked30.info
info40 = evoked40.info
inverse_operator20 = make_inverse_operator(info20,
fwd20,
noise_cov30,
reject={'mag': 3e-12},
verbose=False)
# # back to coding
# proj = mne.read_proj(fname_proj)
# epochs.add_proj(proj)
# epochs.apply_proj()
# plot evoked
evoked = epochs.average()
p = evoked.plot(titles={'mag': 'Evoked Response'}, show=False)
rep_group.add_figs_to_section(
p, (f"{subject}: Evoked Response " + "to Prime Word"), 'Evoked')
# plot covariance and whitened evoked
epochs.load_data().crop(-.2, -.1)
cov = mne.compute_covariance(epochs, method='auto', verbose=False)
p = cov.plot(epochs.info, show_svd=0, show=False)[0]
# comments = ('The covariance matrix is computed on the -200:-100 ms '
# 'baseline. -100:0 ms is confounded with the eye-mvt.')
rep_group.add_figs_to_section(p, f"{subject}: Covariance Matrix",
'Covariance Matrix')
p = evoked.plot_white(cov, show=False)
rep_group.add_figs_to_section(
p, f"{subject}: Whitened Evoked to Prime Word", 'Whitened Evoked')
# save covariance
mne.write_cov(fname_cov, cov)
rep_group.save(fname_rep_group, overwrite=True, open_browser=False)
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')
mne.write_cov(noise_cov_fname, noise_cov)
else:
noise_cov = mne.read_cov(noise_cov_fname)
##############################################################################
# Now we assemble the inverse operator, project the data and show the results
# on the `fsaverage` surface, the freesurfer average brain.
if not op.isfile(inv_fname):
inv_op = mne.minimum_norm.make_inverse_operator(
evoked.info, fwd, noise_cov=noise_cov)
write_inverse_operator(inv_fname, inv_op)
else:
inv_op = read_inverse_operator(inv_fname)
elif label_name.startswith('rh.'):
hemi = 'right'
event_id, tmin, tmax = 1, 0.0, 4.0
snr = 1.0
lambda2 = 1.0 / snr ** 2
method = "dSPM"
# Load data
label = mne.read_label(fname_label)
raw = fiff.Raw(fname_raw)
forward_meg = mne.read_forward_solution(fname_fwd)
# Estimate noise covariance from teh raw data
cov = mne.compute_raw_data_covariance(raw, reject=dict(eog=150e-6))
write_cov(data_path + subj + '/' + subj + '-cov.fif', cov)
# Make inverse operator
info = raw.info
inverse_operator = make_inverse_operator(info, forward_meg, cov, loose=None, depth=0.8)
# Epoch data into 4s intervals
events = mne.make_fixed_length_events(raw, 1, start=0, stop=None,
duration=4.)
# Set up pick list: (MEG minus bad channels)
include = []
exclude = raw.info['bads']
picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=False, eog=True,
include=include, exclude=exclude)
def apply_create_noise_covariance(fname_empty_room, require_filter=False,
require_noise_reducer=False, verbose=None):
'''
Creates the noise covariance matrix from an empty room file.
Parameters
----------
fname_empty_room : String containing the filename
of the empty room file (must be a fif-file)
File name should end with -raw.fif in order to have proper output filenames.
require_filter: bool
If true, the empy room file is filtered before calculating
the covariance matrix. (Beware, filter settings are fixed.)
require_noise_reducer: bool
If true, a noise reducer is applied on the empty room file.
The noise reducer frequencies are fixed to 50Hz, 60Hz and
to frequencies less than 5Hz i.e. the reference channels are filtered to
these frequency ranges and then signal obtained is removed from
the empty room raw data. For more information please check the jumeg noise reducer.
verbose : bool, str, int, or None
If not None, override default verbose level
(see mne.verbose).
default: verbose=None
'''
# -------------------------------------------
# import necessary modules
# -------------------------------------------
from mne import compute_raw_data_covariance as cp_covariance
from mne import write_cov, pick_types
from mne.io import Raw
from jumeg.jumeg_noise_reducer import noise_reducer
fner = get_files_from_list(fname_empty_room)
nfiles = len(fner)
# loop across all filenames
for ifile in range(nfiles):
fn_in = fner[ifile]
print ">>> create noise covariance using file: "
path_in, name = os.path.split(fn_in)
print name
if require_filter:
print "Filtering with preset settings..."
# filter empty room raw data
apply_filter(fn_in, flow=1, fhigh=45, order=4, njobs=4)
# reconstruct empty room file name accordingly
fn_in = fn_in[:fn_in.rfind(ext_empty_raw)] + ',fibp1-45-raw.fif'
if require_noise_reducer:
fn_empty_nr = fn_in[:fn_in.rfind(ext_empty_raw)] + ',nr-raw.fif'
noise_reducer(fn_in, refnotch=50, detrending=False, fnout=fn_empty_nr)
noise_reducer(fn_empty_nr, refnotch=60, detrending=False, fnout=fn_empty_nr)
noise_reducer(fn_empty_nr, reflp=5, fnout=fn_empty_nr)
fn_in = fn_empty_nr
# file name for saving noise_cov
fn_out = fn_in[:fn_in.rfind(ext_empty_raw)] + ext_empty_cov
# read in data
raw_empty = Raw(fn_in, verbose=verbose)
# pick MEG channels only
picks = pick_types(raw_empty.info, meg=True, ref_meg=False, eeg=False,
stim=False, eog=False, exclude='bads')
# calculate noise-covariance matrix
noise_cov_mat = cp_covariance(raw_empty, picks=picks, verbose=verbose)
# write noise-covariance matrix to disk
write_cov(fn_out, noise_cov_mat)
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
def _run_interface(self, runtime):
raw_filename = self.inputs.raw_filename
cov_fname_in = self.inputs.cov_fname_in
is_epoched = self.inputs.is_epoched
is_evoked = self.inputs.is_evoked
events_id = self.inputs.events_id
t_min = self.inputs.t_min
t_max = self.inputs.t_max
data_path, basename, ext = split_f(raw_filename)
self.cov_fname_out = op.join(data_path, '%s-cov.fif' % basename)
if not op.isfile(cov_fname_in):
if is_epoched and is_evoked:
raw = read_raw_fif(raw_filename)
events = find_events(raw)
if not op.isfile(self.cov_fname_out):
print(('\n*** COMPUTE COV FROM EPOCHS ***\n' +
self.cov_fname_out))
reject = create_reject_dict(raw.info)
picks = pick_types(raw.info,
meg=True,
ref_meg=False,
exclude='bads')
epochs = Epochs(raw,
events,
events_id,
t_min,
t_max,
picks=picks,
baseline=(None, 0),
reject=reject)
# TODO method='auto'? too long!!!
noise_cov = compute_covariance(epochs,
tmax=0,
method='diagonal_fixed')
write_cov(self.cov_fname_out, noise_cov)
else:
print(('\n *** NOISE cov file %s exists!!! \n' %
self.cov_fname_out))
else:
'\n *** RAW DATA \n'
for er_fname in glob.glob(op.join(data_path, cov_fname_in)):
print(('\n found file name %s \n' % er_fname))
try:
if er_fname.rfind('cov.fif') > -1:
print("\n *** NOISE cov file %s exists!! "
"\n" % er_fname)
self.cov_fname_out = er_fname
else:
if er_fname.rfind('.fif') > -1:
er_raw = read_raw_fif(er_fname)
er_fname = er_fname.replace('.fif', '-raw-cov.fif')
elif er_fname.rfind('.ds') > -1:
er_raw = read_raw_ctf(er_fname)
er_fname = er_fname.replace('.ds', '-raw-cov.fif')
self.cov_fname_out = op.join(data_path, er_fname)
if not op.isfile(self.cov_fname_out):
reject = create_reject_dict(er_raw.info)
picks = pick_types(er_raw.info,
meg=True,
ref_meg=False,
exclude='bads')
noise_cov = compute_raw_covariance(er_raw,
picks=picks,
reject=reject)
write_cov(self.cov_fname_out, noise_cov)
else:
print(('\n *** NOISE cov file %s exists!!! \n' %
self.cov_fname_out))
except NameError:
sys.exit("No covariance matrix as input!")
# TODO creare una matrice diagonale?
else:
print(('\n *** NOISE cov file %s exists!!! \n' % cov_fname_in))
self.cov_fname_out = cov_fname_in
return runtime
def run_correlation(subjects_dir, subject, volume_spacing, freq):
num_threads(8)
frequency = str(freq)
DATA_DIR = Path(f'{subjects_dir}', f'{subject}', 'mne_files')
eye_proj1 = f'{DATA_DIR}/{subject}_eyes1-proj.fif.gz'
eye_proj2 = f'{DATA_DIR}/{subject}_eyes2-proj.fif.gz'
fname_meg = f'{DATA_DIR}/{subject}_ses-rest_task-rest.fif'
t1_fname = os.path.join(subjects_dir, subject, 'mri', 'T1.mgz')
heartbeat_proj = f'{DATA_DIR}/{subject}_heartbeat-proj.fif.gz'
fwd_fname = f'{DATA_DIR}/{subject}_{volume_spacing}-fwd-label.fif.gz'
src_fname = f'{DATA_DIR}/{subject}_{volume_spacing}-src-label.fif.gz'
cov_fname = f'{DATA_DIR}/{subject}-cov_{volume_spacing}-label.fif.gz'
raw_cov_fname = f'{DATA_DIR}/{subject}-rawcov_{volume_spacing}-label.fif.gz'
raw_proj = f'{DATA_DIR}/{subject}_ses-rest_task-rest_proj-label.fif.gz'
source_voxel_coords = f'{DATA_DIR}/{subject}_coords_{volume_spacing}.pkl'
freesurfer_label = f'{DATA_DIR}/{subject}_freesurferlabel_{volume_spacing}-label.pkl'
corr_true_file_label = f'{DATA_DIR}/{subject}_corr_ortho_true_{volume_spacing}_{frequency}_label.npy'
check_for_files = []
check_for_files.append(corr_true_file_label)
file_exist = [f for f in check_for_files if os.path.isfile(f)]
file_not_exist = list(set(file_exist) ^ set(check_for_files))
if not file_not_exist:
print('correlation files exists...')
else:
trans = f'/home/senthilp/caesar/camcan/cc700/camcan_coreg-master/trans/{subject}-trans.fif' # The transformation file obtained by coregistration
file_trans = pathlib.Path(trans)
file_ss = pathlib.Path(src_fname)
file_fm = pathlib.Path(fwd_fname)
file_proj = pathlib.Path(raw_proj)
file_cov = pathlib.Path(cov_fname)
file_rawcov = pathlib.Path(raw_cov_fname)
t1 = nib.load(t1_fname)
if not file_trans.exists():
print (f'{trans} File doesnt exist...')
sys.exit(0)
info = mne.io.read_info(fname_meg)
# plot_registration(info, trans, subject, subjects_dir)
print(file_ss)
if not file_ss.exists():
src = compute_SourceSpace(subject, subjects_dir, src_fname, source_voxel_coords, plot=True, ss='volume',
volume_spacing=volume_spacing)
src.save(src_fname, overwrite=True)
src = mne.read_source_spaces(src_fname)
#view_SS_brain(subject, subjects_dir, src)
if not file_fm.exists():
forward_model(subject, subjects_dir, fname_meg, trans, src, fwd_fname)
fwd = mne.read_forward_solution(fwd_fname)
# sensitivty_plot(subject, subjects_dir, fwd)
raw = mne.io.read_raw_fif(fname_meg, verbose='error', preload=True)
srate = raw.info['sfreq']
n_time_samps = raw.n_times
time_secs = raw.times
ch_names = raw.ch_names
n_chan = len(ch_names)
freq_res = srate/n_time_samps
print('\n')
print('-------------------------- Data summary-------------------------------')
print(f'Subject {subject}')
print(f"Frequency resolution {freq_res} Hz")
print(f"The first few channel names are {ch_names[:3]}")
print(f"The last time sample at {time_secs[-1]} seconds.")
print(f"Sampling Frequency (No of time points/sec) {srate} Hz")
print(f"Miscellaneous acquisition info {raw.info['description']}")
print(f"Bad channels marked during data acquisition {raw.info['bads']}")
print(f"Convert time in sec ( 60s ) to ingeter index {raw.time_as_index(60)}") # Convert time to indices
print(f"The raw data object has {n_time_samps} time samples and {n_chan} channels.")
print('------------------------------------------------------------------------')
print('\n')
# raw.plot(n_channels=10, scalings='auto', title='Data from arrays', show=True, block=True)
if not file_proj.exists():
projs_ecg, _ = compute_proj_ecg(raw, n_grad=1, n_mag=2, ch_name='ECG063')
projs_eog1, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='EOG061')
projs_eog2, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='EOG062')
if projs_ecg is not None:
mne.write_proj(heartbeat_proj, projs_ecg) # Saving projectors
raw.info['projs'] += projs_ecg
if projs_eog1 is not None:
mne.write_proj(eye_proj1, projs_eog1)
raw.info['projs'] += projs_eog1
if projs_eog2 is not None:
mne.write_proj(eye_proj2, projs_eog2)
raw.info['projs'] += projs_eog2
raw.apply_proj()
raw.save(raw_proj, proj=True, overwrite=True)
print(raw_proj)
raw_proj_applied = mne.io.read_raw_fif(raw_proj, verbose='error', preload=True)
print(f'High-pass filtering data at 0.5 Hz')
raw_proj_applied.filter(l_freq=0.5, h_freq=None, method='iir')
if not file_cov.exists():
cov = mne.compute_raw_covariance(raw_proj_applied) # compute before band-pass of interest
mne.write_cov(cov_fname, cov)
cov = mne.read_cov(cov_fname)
# cov.plot(raw.info, proj=True, exclude='bads', show_svd=False
# raw_proj_applied.crop(tmax=10)
do_epochs = False
l_freq = freq-2.0
h_freq = freq+2.0
print(f'Band pass filter data [{l_freq}, {h_freq}]')
raw_proj_filtered = raw_proj_applied.filter(l_freq=l_freq, h_freq=h_freq)
if do_epochs:
print('Segmenting raw data...')
events = mne.make_fixed_length_events(raw_proj_filtered, duration=5.)
raw_proj_filtered = mne.Epochs(raw_proj_filtered, events=events, tmin=0, tmax=5.,
baseline=None, preload=True)
data_cov = mne.compute_covariance(raw_proj_filtered)
else:
if not file_rawcov.exists():
data_cov = mne.compute_raw_covariance(raw_proj_filtered)
mne.write_cov(raw_cov_fname, data_cov)
else:
data_cov = mne.read_cov(file_rawcov)
filters = make_lcmv(raw_proj_filtered.info, fwd, data_cov, 0.05, cov,
pick_ori='max-power', weight_norm='nai')
raw_proj_filtered_comp = raw_proj_filtered.apply_hilbert()
if do_epochs:
stcs = apply_lcmv_epochs(raw_proj_filtered_comp, filters, return_generator=False)
else:
stcs = apply_lcmv_raw(raw_proj_filtered_comp, filters, verbose=True)
print('Extracting label time course...')
atlas = f'{subjects_dir}/{subject}/mri/aparc.a2009s+aseg.mgz'
label_ts = mne.extract_label_time_course(stcs, atlas, fwd['src'], return_generator=False)
label_ts = [label_ts]
# Power Envelope Correlation
print(f'Computing Power Envelope Correlation for {subject}....Orthogonalize True')
all_corr = envelope_correlation(label_ts, combine=None, orthogonalize="pairwise",
log=True, absolute=True, verbose=None)
print(f'Correlation saved to {corr_true_file_label}')
np.save(corr_true_file_label, all_corr)
del stcs
import mne
import sys
from mne import compute_covariance
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from my_settings import *
reject = dict(grad=4000e-13, # T / m (gradiometers)
mag=4e-12, # T (magnetometers)
eeg=180e-6 #
)
subject = sys.argv[1]
epochs = mne.read_epochs(epochs_folder + "%s_trial_start-epo.fif" % subject)
epochs.drop_bad_epochs(reject_params)
# fig = epochs.plot_drop_log(subject=subject, show=False)
# fig.savefig(epochs_folder + "pics/%s_drop_log.png" % subject)
# Make noise cov
cov = compute_covariance(epochs, tmin=None, tmax=0,
method="factor_analysis")
mne.write_cov(mne_folder + "%s-cov.fif" % subject, cov)
Compute the noise matrix
Author: Praveen, Qunxi
"""
import mne, sys, os
import pylab as pl
import numpy as np
flow, fhigh = 1.0, 45.0
filter_type = 'butter'
filter_order = 4
njobs = 4
try:
subject = sys.argv[1]#Get the subject
except:
print "Please run with input file provided. Exiting"
sys.exit()
subjects_dir = '/home/qdong/freesurfer/subjects/'
subject_path = subjects_dir + subject#Set the data path of the subject
raw_empty_fname = subject_path + '/MEG/%s_emptyroom.fif' %subject
raw_empty = mne.fiff.Raw(raw_empty_fname, preload=True)
#Filter the empty room data
picks_empty = mne.fiff.pick_types(raw_empty.info, meg=True, eeg=False, eog=True, ecg=True, stim=False, exclude='bads')
raw_empty.filter(flow, fhigh, picks=picks_empty, n_jobs=njobs, method='iir',
iir_params={'ftype': filter_type, 'order': filter_order})
#Get the basename
raw_empty_basename = os.path.splitext(os.path.basename(raw_empty_fname))[0]
cov = mne.compute_raw_data_covariance(raw_empty, picks=picks_empty)
mne.write_cov(subject_path+'/MEG/%s_cov.fif' %(raw_empty_basename), cov)
# Making the inverse solution
from mne.minimum_norm import (make_inverse_operator, apply_inverse,
write_inverse_operator)
## Computing the covariance
# Empty room data goes here
emptyroom = '/Users/aditya/desktop/MEG_TrainingData/SelfPaced_ButtonPress/empty_room-2.fif'
raw_empty_room = mne.io.read_raw_fif(emptyroom)
## Noise covariance compuation - can be done through either the empty room
## calculaion or using the epochs before the stimilus - I got the
## 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.
def apply_create_noise_covariance_data(fname,raw=None,do_filter=True,filter_parameter=None,verbose=False,do_run=True,save=True ):
'''
Creates the noise covariance matrix from an empty room file.
Parameters
----------
fname : string
containing the filename of the empty room file (must be a fif-file)
do_filter: bool
If true, the empy room file is filtered before calculating
the covariance matrix. (Beware, filter settings are fixed.)
filter_parameter: dict
dict with filter parameter and flags
do_run: bool
execute this
save: bool
save output file
verbose : bool, str, int, or None
If not None, override default verbose level
(see mne.verbose).
default: verbose=None
RETURN
---------
full empty room filname as string
raw obj of input raw-obj or raw-empty-room obj
'''
# -------------------------------------------
# import necessary modules
# -------------------------------------------
from mne import compute_raw_data_covariance as cp_covariance
from mne import write_cov
from mne.io import Raw
from mne import pick_types
import os
mne.verbose = verbose
try:
(fname_empty_room,raw_empty) = jumeg_base.get_empty_room_fif(fname=fname,raw=raw,preload=do_run)
except:
return
if raw_empty :
#--- picks meg channels
filter_parameter.picks = jumeg_base.pick_meg_nobads(raw_empty)
#--- filter or get filter name
filter_parameter.do_run = do_filter
if do_filter :
print "Filtering empty room fif with noise variance settings...\n"
(fname_empty_room,raw_empty) = apply_filter_data(fname_empty_room,raw=raw_empty,**filter_parameter)
#--- update file name for saving noise_cov
fname_empty_room_cov = fname_empty_room.split('-')[0] + ',empty-cov.fif'
#--- calc nois-covariance matrix
if do_run :
noise_cov_mat = cp_covariance(raw_empty,picks=filter_parameter.picks,verbose=verbose)
#--- write noise-covariance matrix to disk
if save :
write_cov( fname_empty_room_cov, noise_cov_mat)
return fname_empty_room_cov
def intra(subj):
"""
Performs initial computations within subject and returns average PSD and variance of all epochs.
"""
print ("Now beginning intra processing on " + subj + "...\n") * 5
# Set function parameters
fname_label = subjects_dir + "/" + subj + "/" + "label/%s.label" % label_name
fname_raw = data_path + subj + "/" + subj + "_list" + list_num + "_raw_sss-ico-4-fwd.fif"
if os.path.isfile(data_path + subj + "/" + subj + "_list" + list_num + "_raw_sss-ico-4-fwd.fif"):
fname_fwd = data_path + subj + "/" + subj + "_list" + list_num + "_raw_sss-ico-4-fwd.fif"
else:
print ("Subject " + subj + " does not have a ico-4-fwd.fif on file.")
if label_name.startswith("lh."):
hemi = "left"
elif label_name.startswith("rh."):
hemi = "right"
# Load data
label = mne.read_label(fname_label)
raw = fiff.Raw(fname_raw)
forward_meg = mne.read_forward_solution(fname_fwd)
# Estimate noise covariance from the raw data.
precov = mne.compute_raw_data_covariance(raw, reject=dict(eog=150e-6))
write_cov(data_path + subj + "/" + subj + "-cov.fif", precov)
# Find events from raw file
events = mne.find_events(raw, stim_channel="STI 014")
# Set up pick list: (MEG minus bad channels)
include = []
exclude = raw.info["bads"]
picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=False, eog=True, include=include, exclude=exclude)
# Read epochs and remove bad epochs
epochs = mne.Epochs(
raw,
events,
event_id,
tmin,
tmax,
proj=True,
picks=picks,
baseline=(None, 0),
preload=True,
reject=dict(grad=4000e-13, mag=4e-12, eog=150e-6),
)
# Average epochs and get an evoked dataset. Save to disk.
evoked = epochs.average()
evoked.save(data_path + subj + "/" + subj + "_list" + list_num + "_rest_raw_sss-ave.fif")
# Regularize noise cov
cov = mne.cov.regularize(precov, evoked.info, grad=4000e-13, mag=4e-12, eog=150e-6, proj=True)
# Make inverse operator
info = evoked.info
inverse_operator = make_inverse_operator(info, forward_meg, cov, loose=None, depth=0.8)
# Pull data for averaging later
epc_array = epochs.get_data()
# Compute the inverse solution
inv = apply_inverse_epochs(epochs, inverse_operator, lambda2, method, label=label)
# Need to add a line here to automatically create stc directory within subj
epoch_num = 1
epoch_num_str = str(epoch_num)
for i in inv:
i.save(data_path + subj + "/tmp/" + label_name[3:] + "_rest_raw_sss-ico-4-inv" + epoch_num_str)
epoch_num = epoch_num + 1
epoch_num_str = str(epoch_num)
# The following is used to remove the empty opposing hemisphere files
# and then move the files to save into the appropriate directory
if hemi == "left":
filelist = [f for f in os.listdir(data_path + subj + "/tmp") if f.endswith("-rh.stc")]
for f in filelist:
os.remove(data_path + subj + "/tmp/" + f)
keepers = [f for f in os.listdir(data_path + subj + "/tmp") if f.endswith("-lh.stc")]
for f in keepers:
src = f
os.rename(data_path + subj + "/tmp/" + src, data_path + subj + "/inv/" + src)
elif hemi == "right":
filelist = [f for f in os.listdir(data_path + subj + "/tmp") if f.endswith("-lh.stc")]
for f in filelist:
os.remove(data_path + subj + "/tmp/" + f)
keepers = [f for f in os.listdir(data_path + subj + "/tmp") if f.endswith("-rh.stc")]
for f in keepers:
src = f
os.rename(data_path + subj + "/tmp/" + src, data_path + subj + "/inv/" + src)
# define frequencies of interest
bandwidth = 4.0 # bandwidth of the windows in Hz
# compute source space psd in label
# Note: By using "return_generator=True" stcs will be a generator object
# instead of a list. This allows us so to iterate without having to
# keep everything in memory.
psd = compute_source_psd_epochs(
epochs,
inverse_operator,
lambda2=lambda2,
method=method,
fmin=fmin,
fmax=fmax,
bandwidth=bandwidth,
label=label,
return_generator=False,
)
epoch_num = 1
epoch_num_str = str(epoch_num)
for i in psd:
i.save(data_path + subj + "/" + "tmp" + "/" + label_name[3:] + "_dspm_snr-1_PSD" + epoch_num_str)
epoch_num = epoch_num + 1
epoch_num_str = str(epoch_num)
if hemi == "left":
filelist = [f for f in os.listdir(data_path + subj + "/tmp") if f.endswith("-rh.stc")]
for f in filelist:
os.remove(data_path + subj + "/tmp/" + f)
keepers = [f for f in os.listdir(data_path + subj + "/tmp") if f.endswith("-lh.stc")]
for f in keepers:
src = f
os.rename(data_path + subj + "/tmp/" + src, data_path + subj + "/psd/" + src)
elif hemi == "right":
filelist = [f for f in os.listdir(data_path + subj + "/tmp") if f.endswith("-lh.stc")]
for f in filelist:
os.remove(data_path + subj + "/tmp/" + f)
keepers = [f for f in os.listdir(data_path + subj + "/tmp") if f.endswith("-rh.stc")]
for f in keepers:
src = f
os.rename(data_path + subj + "/tmp/" + src, data_path + subj + "/psd/" + src)
# This code computes the average PSDs of each epoch. Each PSD file is an array of shape N_vertices*N_frequencies. This code averages the PSD value of each vertex together and outputs the average PSD value of each frequency. Then, it averages the PSD values of each epoch, outputting one average PSD value per frequency value, i.e., this is the average across epochs.
n_epochs = len(epc_array)
for i, stc in enumerate(psd):
if i >= n_epochs:
break
if i == 0:
psd_avg = np.mean(stc.data, axis=0)
else:
psd_avg += np.mean(stc.data, axis=0)
print ("Length of psd for subject " + subj + " is " + str(len(psd)) + ".")
print ("Number of epochs for subject " + subj + " is " + str(n_epochs) + ".")
if len(psd) != 0:
psd_avg /= n_epochs
# Compute variance for each epoch and then variance across epochs
n_epochs = len(epc_array)
for i, stc in enumerate(psd):
if i >= n_epochs:
psd_var = np.array()
break
if i == 0:
psd_var = np.var(stc.data, axis=0)
else:
psd_var = np.vstack((psd_var, np.var(stc.data, axis=0)))
if len(psd) >= 2:
tot_var = np.var(psd_var, axis=0)
if len(psd) <= 1:
failed_subj = subj
print (failed_subj + " failed. No PSD values calculated, likely because all epochs were rejected.")
return failed_subj, failed_subj, failed_subj
if len(psd) >= 2:
return (psd_avg, tot_var, len(psd_avg))
