def test_make_inverse_operator_fixed(): """Test MNE inverse computation with fixed orientation""" # XXX : should be fixed and not skipped raise nose.SkipTest("XFailed Test") evoked = fiff.Evoked(fname_data, setno=0, baseline=(None, 0)) fwd_op = read_forward_solution(fname_fwd, force_fixed=True) inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, depth=0.8, loose=None) assert_array_almost_equal(inverse_operator_fixed['depth_prior']['data'], inv_op['depth_prior']['data']) assert_equal(inverse_operator_fixed['orient_prior'], inv_op['orient_prior']) assert_array_almost_equal(inverse_operator_fixed['source_cov']['data'], inv_op['source_cov']['data']) stc_fixed = apply_inverse(evoked, inverse_operator_fixed, lambda2, "dSPM") my_stc = apply_inverse(evoked, inv_op, lambda2, "dSPM") assert_equal(stc_fixed.times, my_stc.times) assert_array_almost_equal(stc_fixed.data, my_stc.data, 2)
def test_gamma_map(): """Test Gamma MAP inverse""" forward = read_forward_solution(fname_fwd, force_fixed=False, surf_ori=True) evoked = fiff.Evoked(fname_evoked, setno=0, baseline=(None, 0)) evoked.crop(tmin=0, tmax=0.3) cov = read_cov(fname_cov) cov = mne.cov.regularize(cov, evoked.info) alpha = 0.2 stc = gamma_map(evoked, forward, cov, alpha, tol=1e-5, xyz_same_gamma=True, update_mode=1) idx = np.argmax(np.sum(stc.data ** 2, axis=1)) assert_true(np.concatenate(stc.vertno)[idx] == 96397) stc = gamma_map(evoked, forward, cov, alpha, tol=1e-5, xyz_same_gamma=False, update_mode=1) idx = np.argmax(np.sum(stc.data ** 2, axis=1)) assert_true(np.concatenate(stc.vertno)[idx] == 82010) # force fixed orientation stc, res = gamma_map(evoked, forward, cov, alpha, tol=1e-5, xyz_same_gamma=False, update_mode=2, loose=None, return_residual=True) idx = np.argmax(np.sum(stc.data ** 2, axis=1)) assert_true(np.concatenate(stc.vertno)[idx] == 83398) assert_array_almost_equal(evoked.times, res.times)
def test_apply_inverse_operator(): """Test MNE inverse computation With and without precomputed inverse operator. """ evoked = fiff.Evoked(fname_data, setno=0, baseline=(None, 0)) stc = apply_inverse(evoked, inverse_operator, lambda2, "MNE") assert_true(stc.data.min() > 0) assert_true(stc.data.max() < 10e-10) assert_true(stc.data.mean() > 1e-11) stc = apply_inverse(evoked, inverse_operator, lambda2, "sLORETA") assert_true(stc.data.min() > 0) assert_true(stc.data.max() < 9.0) assert_true(stc.data.mean() > 0.1) stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM") assert_true(stc.data.min() > 0) assert_true(stc.data.max() < 35) assert_true(stc.data.mean() > 0.1) # Test MNE inverse computation starting from forward operator evoked = fiff.Evoked(fname_data, setno=0, baseline=(None, 0)) fwd_op = read_forward_solution(fname_fwd, surf_ori=True) my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=0.2, depth=0.8) write_inverse_operator('test-inv.fif', my_inv_op) read_my_inv_op = read_inverse_operator('test-inv.fif') _compare(my_inv_op, read_my_inv_op) my_stc = apply_inverse(evoked, my_inv_op, lambda2, "dSPM") assert_true('dev_head_t' in my_inv_op['info']) assert_true('mri_head_t' in my_inv_op) assert_equal(stc.times, my_stc.times) assert_array_almost_equal(stc.data, my_stc.data, 2)
def test_inverse_operator_volume(): """Test MNE inverse computation on volume source space""" evoked = fiff.Evoked(fname_data, setno=0, baseline=(None, 0)) inverse_operator_vol = read_inverse_operator(fname_vol_inv) stc = apply_inverse(evoked, inverse_operator_vol, lambda2, "dSPM") stc.save('tmp-vl.stc') stc2 = read_source_estimate('tmp-vl.stc') assert_true(np.all(stc.data > 0)) assert_true(np.all(stc.data < 35)) assert_array_almost_equal(stc.data, stc2.data) assert_array_almost_equal(stc.times, stc2.times)
def test_comparision_with_c(): """Test of average obtained vs C code """ c_evoked = fiff.Evoked(evoked_nf_name, setno=0) epochs = Epochs(raw, events, event_id, tmin, tmax, baseline=None, preload=True, reject=None, flat=None) evoked = epochs.average() sel = fiff.pick_channels(c_evoked.ch_names, evoked.ch_names) evoked_data = evoked.data c_evoked_data = c_evoked.data[sel] assert_true(evoked.nave == c_evoked.nave) assert_array_almost_equal(evoked_data, c_evoked_data, 10) assert_array_almost_equal(evoked.times, c_evoked.times, 12)
from numpy.testing import assert_array_almost_equal import mne from mne.datasets import sample from mne import fiff, read_cov, read_forward_solution from mne.inverse_sparse import gamma_map data_path = sample.data_path() fname_evoked = op.join(data_path, 'MEG', 'sample', 'sample_audvis-ave.fif') fname_cov = op.join(data_path, 'MEG', 'sample', 'sample_audvis-cov.fif') fname_fwd = op.join(data_path, 'MEG', 'sample', 'sample_audvis-eeg-oct-6-fwd.fif') forward = read_forward_solution(fname_fwd, force_fixed=False, surf_ori=True) evoked = fiff.Evoked(fname_evoked, setno=0, baseline=(None, 0)) evoked.crop(tmin=0, tmax=0.3) cov = read_cov(fname_cov) cov = mne.cov.regularize(cov, evoked.info) def test_gamma_map(): """Test Gamma MAP inverse""" alpha = 0.2 stc = gamma_map(evoked, forward, cov, alpha, tol=1e-5, xyz_same_gamma=True, update_mode=1) idx = np.argmax(np.sum(stc.data ** 2, axis=1)) assert_true(np.concatenate(stc.vertno)[idx] == 96397)
def equalizeTriggers(subjID): os.chdir("/cluster/kuperberg/SemPrMM/MEG/data/" + subjID) expList = ['ATLLoc', 'MaskedMM', 'BaleenLP', 'BaleenHP', 'AXCPT'] runDict = { 'ATLLoc': [''], 'MaskedMM': ['Run1', 'Run2'], 'BaleenLP': ['Run1', 'Run2', 'Run3', 'Run4'], 'BaleenHP': ['Run1', 'Run2', 'Run3', 'Run4'], 'AXCPT': ['Run1', 'Run2'] } codeGroupDict = {'AXCPT': ['AXCPT_prime', 'AXCPT_target']} codeDict = {'AXCPT_prime': ['5', '6'], 'AXCPT_target': ['1', '2', '3']} minDict = {} if subjID == 'ya3': runDict['AXCPT'] = ['Run1'] if (subjID == 'ya1' or subjID == 'ya2' or subjID == 'ya4' or subjID == 'ya7' or subjID == 'ya8' or subjID == 'ya16'): runDict['AXCPT'] = '' ######################### ##EQUALIZE TRIGGER COUNTS### print '----equalize triggers' for exp in expList: for codeGroup in codeGroupDict[exp]: evMin = 9999 for code in codeDict[codeGroup]: print int(code) - 1 aveName = '/cluster/kuperberg/SemPrMM/MEG/data/%s/ave_projon/%s_%s_All-ave.fif' % ( subjID, subjID, exp) print aveName evoked = fiff.Evoked(aveName, setno=int(code) - 1) #needs revision print evoked.nave if int(evoked.nave) < evMin: evMin = int(evoked.nave) minDict[codeGroup] = evMin print codeGroup, evMin, minDict[codeGroup] for run in runDict[exp]: inFile = 'eve/' + subjID + '_' + exp + run + 'Mod.eve' outFile = 'eve/' + subjID + '_' + exp + run + 'Mod-testeq.eve' #when finalized, this should probably be ModRejEq.eve, and later scripts changed print inFile if os.path.exists(inFile): data = readInput.readTable(inFile) firstRow = data[0] firstSample = firstRow[0] firstTime = firstRow[1] flag = '' for row in data: trigger = row[3] time = row[1] writeOutput.writeTable(outFile, data)
# # License: BSD (3-clause) print __doc__ import matplotlib.pyplot as plt from mne import fiff from mne.datasets import sample data_path = sample.data_path() fname = data_path + '/MEG/sample/sample_audvis-ave.fif' # Reading evoked data evoked = fiff.Evoked(fname, setno='Left Auditory', baseline=(None, 0), proj=True) picks = fiff.pick_channels(ch_names=evoked.info['ch_names'], include="MEG 2332", exclude="bad") # Create subplots f, axarr = plt.subplots(3) evoked.plot(exclude=[], picks=picks, axes=axarr[0], titles=dict(grad='Before time shifting')) # Apply relative time-shift of 500 ms evoked.shift_time(0.5, relative=True)
font = { 'weight' : 'bold', 'size' : 12} pl.rc('font', **font) #figure(num=None, figsize=(16, 6), dpi=80, facecolor='w', edgecolor='k') # you could use this to change the size of the figure for c in range(2): ##get the data file = data_path + prefixList[c] +'-ave.fif' ##file = data_path + args.prefix1 +'-ave.fif' print file print 'set ',condList[c] evoked = fiff.Evoked(file,setno=condList[c],baseline=(-100,0),proj=False) times=evoked.times*1000 print channelList for chan in channelList: if chan == 'CZ': pl.subplot(3,3,2) pl.title("CZ") ##pl.title(1.0, 1.0, 'FZ', fontsize='medium', verticalalignment='top') elif chan == 'CPZ': pl.subplot(3,3,5) pl.title("CPZ") ##pl.title(1.0, 1.0, 'CZ', fontsize='medium', verticalalignment='top') elif chan == 'PZ': pl.subplot(3,3,8)
def test_mxne_inverse(): """Test (TF-)MxNE inverse computation""" # Handling forward solution evoked = fiff.Evoked(fname_data, setno=1, baseline=(None, 0)) # Read noise covariance matrix cov = read_cov(fname_cov) # Handling average file setno = 0 loose = None depth = 0.9 evoked = fiff.read_evoked(fname_data, setno=setno, baseline=(None, 0)) evoked.crop(tmin=-0.1, tmax=0.4) evoked_l21 = copy.deepcopy(evoked) evoked_l21.crop(tmin=0.08, tmax=0.1) label = read_label(fname_label) weights_min = 0.5 forward = read_forward_solution(fname_fwd, force_fixed=False, surf_ori=True) # Reduce source space to make test computation faster inverse_operator = make_inverse_operator(evoked.info, forward, cov, loose=loose, depth=depth, fixed=True) stc_dspm = apply_inverse(evoked_l21, inverse_operator, lambda2=1. / 9., method='dSPM') stc_dspm.data[np.abs(stc_dspm.data) < 12] = 0.0 stc_dspm.data[np.abs(stc_dspm.data) >= 12] = 1. # MxNE tests alpha = 60 # spatial regularization parameter stc_prox = mixed_norm(evoked_l21, forward, cov, alpha, loose=None, depth=0.9, maxit=1000, tol=1e-8, active_set_size=10, solver='prox') stc_cd = mixed_norm(evoked_l21, forward, cov, alpha, loose=None, depth=0.9, maxit=1000, tol=1e-8, active_set_size=10, solver='cd') assert_array_almost_equal(stc_prox.times, evoked_l21.times, 5) assert_array_almost_equal(stc_cd.times, evoked_l21.times, 5) assert_array_almost_equal(stc_prox.data, stc_cd.data, 5) assert_true(stc_prox.vertno[1][0] in label.vertices) assert_true(stc_cd.vertno[1][0] in label.vertices) stc, _ = mixed_norm(evoked_l21, forward, cov, alpha, loose=None, depth=depth, maxit=500, tol=1e-4, active_set_size=10, weights=stc_dspm, weights_min=weights_min, return_residual=True) assert_array_almost_equal(stc.times, evoked_l21.times, 5) assert_true(stc.vertno[1][0] in label.vertices) # Do with TF-MxNE for test memory savings alpha_space = 60. # spatial regularization parameter alpha_time = 1. # temporal regularization parameter stc, _ = tf_mixed_norm(evoked, forward, cov, alpha_space, alpha_time, loose=loose, depth=depth, maxit=100, tol=1e-4, tstep=4, wsize=16, window=0.1, weights=stc_dspm, weights_min=weights_min, return_residual=True) assert_array_almost_equal(stc.times, evoked.times, 5) assert_true(stc.vertno[1][0] in label.vertices)
from mne.datasets import sample from mne.label import read_label from mne import fiff, read_cov, read_forward_solution from mne.mixed_norm.inverse import mixed_norm examples_folder = op.join(op.dirname(__file__), '..', '..', '..', 'examples') data_path = sample.data_path(examples_folder) fname_data = op.join(data_path, 'MEG', 'sample', 'sample_audvis-ave.fif') fname_cov = op.join(data_path, 'MEG', 'sample', 'sample_audvis-cov.fif') fname_fwd = op.join(data_path, 'MEG', 'sample', 'sample_audvis-meg-oct-6-fwd.fif') label = 'Aud-rh' fname_label = op.join(data_path, 'MEG', 'sample', 'labels', '%s.label' % label) evoked = fiff.Evoked(fname_data, setno=1, baseline=(None, 0)) # Read noise covariance matrix cov = read_cov(fname_cov) # Handling average file setno = 0 loose = None evoked = fiff.read_evoked(fname_data, setno=setno, baseline=(None, 0)) evoked.crop(tmin=0.08, tmax=0.12) # Handling forward solution forward = read_forward_solution(fname_fwd, force_fixed=True) label = read_label(fname_label)
def _get_evoked(): evoked = fiff.Evoked(fname_data, setno=0, baseline=(None, 0)) evoked.crop(0, 0.2) return evoked
""" # Author: Denis Engemann <d.engemann@fz-juelichde> # Alexandre Gramfort <*****@*****.**> # # License: BSD (3-clause) print(__doc__) from mne import fiff from mne.datasets import sample from nitime.viz import plot_tseries import matplotlib.pyplot as plt data_path = sample.data_path() fname = data_path + '/MEG/sample/sample_audvis-ave.fif' # Reading evoked = fiff.Evoked(fname, setno=0, baseline=(None, 0), proj=True) # Pick channels to view picks = fiff.pick_types(evoked.info, meg='grad', eeg=False, exclude='bads') evoked_ts = evoked.to_nitime(picks=picks) plot_tseries(evoked_ts) plt.show()
parser = argparse.ArgumentParser(description='Get input') parser.add_argument('prefix1', type=str) parser.add_argument('prefix2', type=str) parser.add_argument('set1', type=int) parser.add_argument('set2', type=int) parser.add_argument('sensor', type=int) parser.add_argument('label1', type=str) parser.add_argument('label2', type=str) args = parser.parse_args() data_path = '/cluster/kuperberg/SemPrMM/MEG/results/sensor_level/ga_fif/' file1 = data_path + args.prefix1 + '-ave.fif' evoked1 = fiff.Evoked(file1, setno=args.set1, baseline=(-100, 0), proj=False) data1 = evoked1.data wave1 = data1[args.sensor][:] * scalingFactor print args.sensor times = evoked1.times * 1000 file2 = data_path + args.prefix2 + '-ave.fif' evoked2 = fiff.Evoked(file2, setno=args.set2, baseline=(-100, 0), proj=False) data2 = evoked2.data wave2 = data2[args.sensor][:] * scalingFactor ################### font = {'weight': 'bold', 'size': 16}
sub ) > 3: ##This makes the tabbing pretty for the table; different for longer subject names beg = '%s\t' % sub else: beg = '%s\t\t' % sub subjLine.append(beg) if k == 'ATLLoc': aveName = '/%s/kuperberg/SemPrMM/MEG/data/%s/ave_projon/%s_%s-ave.fif' % ( pre, sub, sub, k) else: aveName = '/%s/kuperberg/SemPrMM/MEG/data/%s/ave_projon/%s_%s_All_ecgeog1-ave.fif' % ( pre, sub, sub, k) count = 0 results = beg for code in codes: evoked = fiff.Evoked(aveName, setno=count) count = count + 1 results = results + '\t\t' + str( '%.2f' % (float(evoked.nave) / v[sub][code][1])) print results subject_lines.append(results) print sub, subject_lines #write out dat for each paradigm f = open(fname, 'w') f.write(code_line + '\n') f.write('\n'.join(subject_lines)) f.close() print("Saved combined table to %s" % fname) make_lingua(fname) pass