def test_apply_mne_inverse_raw():
"""Test MNE with precomputed inverse operator on Raw
"""
start = 3
stop = 10
raw = fiff.Raw(fname_raw)
label_lh = read_label(fname_label % 'Aud-lh')
_, times = raw[0, start:stop]
inverse_operator = read_inverse_operator(fname_inv)
for pick_ori in [None, "normal"]:
stc = apply_inverse_raw(raw, inverse_operator, lambda2, "dSPM",
label=label_lh, start=start, stop=stop, nave=1,
pick_ori=pick_ori, buffer_size=None)
stc2 = apply_inverse_raw(raw, inverse_operator, lambda2, "dSPM",
label=label_lh, start=start, stop=stop,
nave=1, pick_ori=pick_ori,
buffer_size=3)
if pick_ori is None:
assert_true(np.all(stc.data > 0))
assert_true(np.all(stc2.data > 0))
assert_true(stc.subject == 'sample')
assert_true(stc2.subject == 'sample')
assert_array_almost_equal(stc.times, times)
assert_array_almost_equal(stc2.times, times)
assert_array_almost_equal(stc.data, stc2.data)
def test_apply_mne_inverse_fixed_raw():
"""Test MNE with fixed-orientation inverse operator on Raw
"""
raw = fiff.Raw(fname_raw)
start = 3
stop = 10
_, times = raw[0, start:stop]
label_lh = read_label(fname_label % 'Aud-lh')
# create a fixed-orientation inverse operator
fwd = read_forward_solution(fname_fwd, force_fixed=False, surf_ori=True)
noise_cov = read_cov(fname_cov)
inv_op = make_inverse_operator(raw.info, fwd, noise_cov,
loose=None, depth=0.8, fixed=True)
stc = apply_inverse_raw(raw, inv_op, lambda2, "dSPM",
label=label_lh, start=start, stop=stop, nave=1,
pick_ori=None, buffer_size=None)
stc2 = apply_inverse_raw(raw, inv_op, lambda2, "dSPM",
label=label_lh, start=start, stop=stop, nave=1,
pick_ori=None, buffer_size=3)
assert_true(stc.subject == 'sample')
assert_true(stc2.subject == 'sample')
assert_array_almost_equal(stc.times, times)
assert_array_almost_equal(stc2.times, times)
assert_array_almost_equal(stc.data, stc2.data)
def test_filterestimator():
"""Test methods of FilterEstimator
"""
raw = fiff.Raw(raw_fname, preload=False)
events = read_events(event_name)
picks = fiff.pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=False,
exclude='bads')
picks = picks[1:13:3]
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True)
epochs_data = epochs.get_data()
filt = FilterEstimator(epochs.info, 1, 40)
y = epochs.events[:, -1]
with warnings.catch_warnings(record=True): # stop freq attenuation warning
X = filt.fit_transform(epochs_data, y)
assert_true(X.shape == epochs_data.shape)
assert_array_equal(filt.fit(epochs_data, y).transform(epochs_data), X)
# Test init exception
assert_raises(ValueError, filt.fit, epochs, y)
assert_raises(ValueError, filt.transform, epochs, y)
def test_epochs_proj():
"""Test handling projection (apply proj in Raw or in Epochs)
"""
exclude = raw.info['bads'] + ['MEG 2443', 'EEG 053'] # bads + 2 more
this_picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True,
eog=True, exclude=exclude)
epochs = Epochs(raw, events[:4], event_id, tmin, tmax, picks=this_picks,
baseline=(None, 0), proj=True)
assert_true(all(p['active'] == True for p in epochs.info['projs']))
evoked = epochs.average()
assert_true(all(p['active'] == True for p in evoked.info['projs']))
data = epochs.get_data()
raw_proj = fiff.Raw(raw_fname, proj=True)
epochs_no_proj = Epochs(raw_proj, events[:4], event_id, tmin, tmax,
picks=this_picks, baseline=(None, 0), proj=False)
data_no_proj = epochs_no_proj.get_data()
assert_true(all(p['active'] == True for p in epochs_no_proj.info['projs']))
evoked_no_proj = epochs_no_proj.average()
assert_true(all(p['active'] == True for p in evoked_no_proj.info['projs']))
assert_true(epochs_no_proj.proj == True) # as projs are active from Raw
assert_array_almost_equal(data, data_no_proj, decimal=8)
# make sure we can exclude avg ref
this_picks = fiff.pick_types(raw.info, meg=True, eeg=True, stim=True,
eog=True, exclude=exclude)
epochs = Epochs(raw, events[:4], event_id, tmin, tmax, picks=this_picks,
baseline=(None, 0), proj=True, add_eeg_ref=True)
assert_true(_has_eeg_average_ref_proj(epochs.info['projs']))
epochs = Epochs(raw, events[:4], event_id, tmin, tmax, picks=this_picks,
baseline=(None, 0), proj=True, add_eeg_ref=False)
assert_true(not _has_eeg_average_ref_proj(epochs.info['projs']))
def test_scaler():
"""Test methods of Scaler
"""
raw = fiff.Raw(raw_fname, preload=False)
events = read_events(event_name)
picks = fiff.pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=False,
exclude='bads')
picks = picks[1:13:3]
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True)
epochs_data = epochs.get_data()
scaler = Scaler(epochs.info)
y = epochs.events[:, -1]
with warnings.catch_warnings(True): # np invalid divide value warnings
X = scaler.fit_transform(epochs_data, y)
assert_true(X.shape == epochs_data.shape)
X2 = scaler.fit(epochs_data, y).transform(epochs_data)
assert_array_equal(X2, X)
# Test init exception
assert_raises(ValueError, scaler.fit, epochs, y)
assert_raises(ValueError, scaler.transform, epochs, y)
def test_psdestimator():
"""Test methods of PSDEstimator
"""
raw = fiff.Raw(raw_fname, preload=False)
events = read_events(event_name)
picks = fiff.pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=False,
exclude='bads')
picks = picks[1:13:3]
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True)
epochs_data = epochs.get_data()
psd = PSDEstimator(2 * np.pi, 0, np.inf)
y = epochs.events[:, -1]
X = psd.fit_transform(epochs_data, y)
assert_true(X.shape[0] == epochs_data.shape[0])
assert_array_equal(psd.fit(epochs_data, y).transform(epochs_data), X)
# Test init exception
assert_raises(ValueError, psd.fit, epochs, y)
assert_raises(ValueError, psd.transform, epochs, y)
def test_psd():
"""Test PSD estimation
"""
raw = fiff.Raw(raw_fname)
exclude = raw.info['bads'] + ['MEG 2443', 'EEG 053'] # bads + 2 more
# picks MEG gradiometers
picks = fiff.pick_types(raw.info, meg='mag', eeg=False, stim=False,
exclude=exclude)
picks = picks[:2]
tmin, tmax = 0, 10 # use the first 60s of data
fmin, fmax = 2, 70 # look at frequencies between 5 and 70Hz
NFFT = 128 # the FFT size (NFFT). Ideally a power of 2
psds, freqs = compute_raw_psd(raw, tmin=tmin, tmax=tmax, picks=picks,
fmin=fmin, fmax=fmax, NFFT=NFFT, n_jobs=1,
proj=False)
psds_proj, freqs = compute_raw_psd(raw, tmin=tmin, tmax=tmax, picks=picks,
fmin=fmin, fmax=fmax, NFFT=NFFT,
n_jobs=1, proj=True)
assert_array_almost_equal(psds, psds_proj)
assert_true(psds.shape == (len(picks), len(freqs)))
assert_true(np.sum(freqs < 0) == 0)
assert_true(np.sum(psds < 0) == 0)
def test_info():
"""Test info object"""
raw = fiff.Raw(raw_fname)
event_id, tmin, tmax = 1, -0.2, 0.5
events = read_events(event_name)
event_id = int(events[0, 2])
epochs = Epochs(raw,
events[:1],
event_id,
tmin,
tmax,
picks=None,
baseline=(None, 0))
evoked = epochs.average()
events = read_events(event_name)
# Test subclassing was successful.
info = Info(a=7, b='aaaaa')
assert_true('a' in info)
assert_true('b' in info)
info[42] = 'foo'
assert_true(info[42] == 'foo')
# test info attribute in API objects
for obj in [raw, epochs, evoked]:
assert_true(isinstance(obj.info, Info))
info_str = '%s' % obj.info
assert_equal(len(info_str.split('\n')), (len(obj.info.keys()) + 2))
assert_true(all(k in info_str for k in obj.info.keys()))
def test_source_psd():
"""Test source PSD computation in label"""
raw = fiff.Raw(fname_data)
inverse_operator = read_inverse_operator(fname_inv)
label = read_label(fname_label)
tmin, tmax = 0, 20 # seconds
fmin, fmax = 55, 65 # Hz
NFFT = 2048
stc = compute_source_psd(raw,
inverse_operator,
lambda2=1. / 9.,
method="dSPM",
tmin=tmin,
tmax=tmax,
fmin=fmin,
fmax=fmax,
pick_ori="normal",
NFFT=NFFT,
label=label,
overlap=0.1)
assert_true(stc.times[0] >= fmin * 1e-3)
assert_true(stc.times[-1] <= fmax * 1e-3)
# Time max at line frequency (60 Hz in US)
assert_true(
59e-3 <= stc.times[np.argmax(np.sum(stc.data, axis=0))] <= 61e-3)
def test_read_epochs():
"""Reading epochs from raw files
"""
event_id = 1
tmin = -0.2
tmax = 0.5
# Setup for reading the raw data
raw = fiff.Raw(raw_fname)
events = mne.read_events(event_name)
picks = fiff.pick_types(raw.info,
meg=True,
eeg=False,
stim=False,
eog=True,
include=['STI 014'])
epochs = mne.Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0))
epochs.average()
data = epochs.get_data()
eog_picks = fiff.pick_types(raw.info,
meg=False,
eeg=False,
stim=False,
eog=True)
epochs.drop_picks(eog_picks)
data_no_eog = epochs.get_data()
assert data.shape[1] == (data_no_eog.shape[1] + len(eog_picks))
def test_find_events():
"""Test find events in raw file
"""
events = read_events(fname)
raw = fiff.Raw(raw_fname)
events2 = find_events(raw)
assert_array_almost_equal(events, events2)
def test_time_generalization():
"""Test time generalization decoding
"""
raw = fiff.Raw(raw_fname, preload=False)
events = read_events(event_name)
picks = fiff.pick_types(raw.info,
meg='mag',
stim=False,
ecg=False,
eog=False,
exclude='bads')
picks = picks[1:13:3]
decim = 30
with warnings.catch_warnings(record=True) as w:
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True,
decim=decim)
epochs_list = [epochs[k] for k in event_id.keys()]
scores = time_generalization(epochs_list, cv=2, random_state=42)
n_times = len(epochs.times)
assert_true(scores.shape == (n_times, n_times))
assert_true(scores.max() <= 1.)
assert_true(scores.min() >= 0.)
def test_run_ica():
"""Test run_ica function"""
raw = fiff.Raw(raw_fname, preload=True).crop(0, stop, False).crop(1.5)
params = []
params += [(None, -1, slice(2), [0, 1])] # varicance, kurtosis idx
params += [(None, 'MEG 1531')] # ECG / EOG channel params
for idx, ch_name in product(*params):
run_ica(raw, n_components=2, start=0, stop=6, start_find=0,
stop_find=5, ecg_ch=ch_name, eog_ch=ch_name,
skew_criterion=idx, var_criterion=idx, kurt_criterion=idx)
def equalize_AXCPT(subjID):
print "Jane here!"
event_id = {'A_prime': 5, 'B_prime': 6}
rawfname = '/cluster/kuperberg/SemPrMM/MEG/data/' + subjID + '/' + subjID + '_AXCPTRun1_raw.fif'
raw = fiff.Raw(rawfname)
eventsfname = '/cluster/kuperberg/SemPrMM/MEG/data/%s/eve/%s_AXCPTRun1Mod.eve' % (
subjID, subjID)
# eventsfname = '/cluster/kuperberg/SemPrMM/MEG/data/%s/%s_AXCPTRun1_raw-eve.fif' % (subjID, subjID)
events = mne.read_events(eventsfname)
APrime_event_id = 5
BPrime_event_id = 6
AX_event_id = 4
AY_event_id = 1
BX_event_id = 2
BY_event_id = 3
tmin = -0.1
tmax = 0.7
APrimeEpochs = mne.Epochs(raw, events, APrime_event_id, tmin, tmax)
BPrimeEpochs = mne.Epochs(raw, events, BPrime_event_id, tmin, tmax)
AXEpochs = mne.Epochs(raw, events, AX_event_id, tmin, tmax)
AYEpochs = mne.Epochs(raw, events, AY_event_id, tmin, tmax)
BXEpochs = mne.Epochs(raw, events, BX_event_id, tmin, tmax)
BYEpochs = mne.Epochs(raw, events, BY_event_id, tmin, tmax)
print "A Prime before"
print APrimeEpochs
print "B Prime before"
print BPrimeEpochs
print "AX before"
print AXEpochs
print "BX Before"
print BXEpochs
print "AY before"
print AYEpochs
print "BY Before"
print BYEpochs
mne.epochs.equalize_epoch_counts(
[APrimeEpochs, BPrimeEpochs],
method='mintime') ## tried mintime and truncate, default is fine
mne.epochs.equalize_epoch_counts(
[AXEpochs, AYEpochs, BXEpochs, BYEpochs],
method='mintime') ## tried mintime and truncate, default is fine
print "A Prime After"
print APrimeEpochs
print "B Prime After"
print BPrimeEpochs
print "AX after"
print AXEpochs
print "BX after"
print BXEpochs
print "AY after"
print AYEpochs
print "BY after"
print BYEpochs
def test_define_events():
"""Test defining response events
"""
events = read_events(fname)
raw = fiff.Raw(raw_fname)
events_, _ = define_target_events(events, 5, 32, raw.info['sfreq'], .2,
0.7, 42, 99)
n_target = events[events[:, 2] == 5].shape[0]
n_miss = events_[events_[:, 2] == 99].shape[0]
n_target_ = events_[events_[:, 2] == 42].shape[0]
assert_true(n_target_ == (n_target - n_miss))
def test_ica_full_data_recovery():
"""Test recovery of full data when no source is rejected"""
# Most basic recovery
raw = fiff.Raw(raw_fname, preload=True).crop(0, stop, False).crop(1.5)
events = read_events(event_name)
picks = fiff.pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=False,
exclude='bads')
epochs = Epochs(raw,
events[:4],
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True)
n_channels = 5
data = raw._data[:n_channels].copy()
data_epochs = epochs.get_data()
for n_components, n_pca_components, ok in [(2, n_channels, True),
(2, n_channels // 2, False)]:
ica = ICA(n_components=n_components,
max_pca_components=n_pca_components,
n_pca_components=n_pca_components)
ica.decompose_raw(raw, picks=list(range(n_channels)))
raw2 = ica.pick_sources_raw(raw, exclude=[])
if ok:
assert_allclose(data[:n_channels],
raw2._data[:n_channels],
rtol=1e-10,
atol=1e-15)
else:
diff = np.abs(data[:n_channels] - raw2._data[:n_channels])
assert_true(np.max(diff) > 1e-14)
ica = ICA(n_components=n_components,
max_pca_components=n_pca_components,
n_pca_components=n_pca_components)
ica.decompose_epochs(epochs, picks=list(range(n_channels)))
epochs2 = ica.pick_sources_epochs(epochs, exclude=[])
data2 = epochs2.get_data()[:, :n_channels]
if ok:
assert_allclose(data_epochs[:, :n_channels],
data2,
rtol=1e-10,
atol=1e-15)
else:
diff = np.abs(data_epochs[:, :n_channels] - data2)
assert_true(np.max(diff) > 1e-14)
def test_apply_mne_inverse_epochs():
"""Test MNE with precomputed inverse operator on Epochs
"""
inverse_operator = read_inverse_operator(fname_inv)
label_lh = read_label(fname_label % 'Aud-lh')
label_rh = read_label(fname_label % 'Aud-rh')
event_id, tmin, tmax = 1, -0.2, 0.5
raw = fiff.Raw(fname_raw)
picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True,
ecg=True, eog=True, include=['STI 014'],
exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
flat = dict(grad=1e-15, mag=1e-15)
events = read_events(fname_event)[:15]
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject, flat=flat)
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh, pick_ori="normal")
assert_true(len(stcs) == 4)
assert_true(3 < stcs[0].data.max() < 10)
assert_true(stcs[0].subject == 'sample')
data = sum(stc.data for stc in stcs) / len(stcs)
flip = label_sign_flip(label_lh, inverse_operator['src'])
label_mean = np.mean(data, axis=0)
label_mean_flip = np.mean(flip[:, np.newaxis] * data, axis=0)
assert_true(label_mean.max() < label_mean_flip.max())
# test extracting a BiHemiLabel
stcs_rh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_rh, pick_ori="normal")
stcs_bh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh + label_rh,
pick_ori="normal")
n_lh = len(stcs[0].data)
assert_array_almost_equal(stcs[0].data, stcs_bh[0].data[:n_lh])
assert_array_almost_equal(stcs_rh[0].data, stcs_bh[0].data[n_lh:])
# test without using a label (so delayed computation is used)
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
pick_ori="normal")
assert_true(stcs[0].subject == 'sample')
label_stc = stcs[0].in_label(label_rh)
assert_true(label_stc.subject == 'sample')
assert_array_almost_equal(stcs_rh[0].data, label_stc.data)
def test_ica_reject_buffer():
"""Test ICA data raw buffer rejection"""
raw = fiff.Raw(raw_fname, preload=True).crop(0, stop, False).crop(1.5)
picks = fiff.pick_types(raw.info, meg=True, stim=False, ecg=False,
eog=False, exclude='bads')
ica = ICA(n_components=3, max_pca_components=4, n_pca_components=4)
raw._data[2, 1000:1005] = 5e-12
drop_log = op.join(op.dirname(tempdir), 'ica_drop.log')
set_log_file(drop_log, overwrite=True)
ica.decompose_raw(raw, picks[:5], reject=dict(mag=2.5e-12), decim=2,
tstep=0.01, verbose=True)
assert_true(raw._data[:5, ::2].shape[1] - 4 == ica.n_samples_)
log = [l for l in open(drop_log) if 'detected' in l]
assert_equal(len(log), 1)
def test_ems():
"""Test event-matched spatial filters"""
raw = fiff.Raw(raw_fname, preload=False)
# create unequal number of events
events = read_events(event_name)
events[-2, 2] = 3
picks = fiff.pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=False,
exclude='bads')
picks = picks[1:13:3]
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True)
assert_raises(ValueError, compute_ems, epochs, ['aud_l', 'vis_l'])
epochs.equalize_event_counts(epochs.event_id, copy=False)
assert_raises(KeyError, compute_ems, epochs, ['blah', 'hahah'])
surrogates, filters, conditions = compute_ems(epochs)
assert_equal(list(set(conditions)), [1, 3])
events = read_events(event_name)
event_id2 = dict(aud_l=1, aud_r=2, vis_l=3)
epochs = Epochs(raw,
events,
event_id2,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True)
epochs.equalize_event_counts(epochs.event_id, copy=False)
n_expected = sum([len(epochs[k]) for k in ['aud_l', 'vis_l']])
assert_raises(ValueError, compute_ems, epochs)
surrogates, filters, conditions = compute_ems(epochs, ['aud_r', 'vis_l'])
assert_equal(n_expected, len(surrogates))
assert_equal(n_expected, len(conditions))
assert_equal(list(set(conditions)), [2, 3])
raw.close()
def test_ar_raw():
"""Test fitting AR model on raw data
"""
raw = fiff.Raw(raw_fname)
# picks MEG gradiometers
picks = fiff.pick_types(raw.info, meg='grad')
picks = picks[:2]
tmin, tmax = 0, 10 # use the first s of data
order = 2
coefs = ar_raw(raw, picks=picks, order=order, tmin=tmin, tmax=tmax)
mean_coefs = np.mean(coefs, axis=0)
assert_true(coefs.shape == (len(picks), order))
assert_true(0.9 < mean_coefs[0] < 1.1)
def test_epochs_proj():
"""Test handling projection (apply proj in Raw or in Epochs)
"""
exclude = raw.info['bads'] + ['MEG 2443', 'EEG 053'] # bads + 2 more
this_picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True,
eog=True, exclude=exclude)
epochs = Epochs(raw, events[:4], event_id, tmin, tmax, picks=this_picks,
baseline=(None, 0), proj=True)
epochs.average()
data = epochs.get_data()
raw_proj = fiff.Raw(raw_fname, proj_active=True)
epochs_no_proj = Epochs(raw_proj, events[:4], event_id, tmin, tmax,
picks=this_picks, baseline=(None, 0), proj=False)
epochs_no_proj.average()
data_no_proj = epochs_no_proj.get_data()
assert_array_almost_equal(data, data_no_proj, decimal=8)
def test_regularized_csp():
"""Test Common Spatial Patterns algorithm using regularized covariance
"""
raw = fiff.Raw(raw_fname, preload=False)
events = read_events(event_name)
picks = fiff.pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=False,
exclude='bads')
picks = picks[1:13:3]
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True)
epochs_data = epochs.get_data()
n_channels = epochs_data.shape[1]
n_components = 3
reg_cov = [None, 0.05, 'lws', 'oas']
for reg in reg_cov:
csp = CSP(n_components=n_components, reg=reg)
csp.fit(epochs_data, epochs.events[:, -1])
y = epochs.events[:, -1]
X = csp.fit_transform(epochs_data, y)
assert_true(csp.filters_.shape == (n_channels, n_channels))
assert_true(csp.patterns_.shape == (n_channels, n_channels))
assert_array_almost_equal(
csp.fit(epochs_data, y).transform(epochs_data), X)
# test init exception
assert_raises(ValueError, csp.fit, epochs_data,
np.zeros_like(epochs.events))
assert_raises(ValueError, csp.fit, epochs, y)
assert_raises(ValueError, csp.transform, epochs, y)
csp.n_components = n_components
sources = csp.transform(epochs_data)
assert_true(sources.shape[1] == n_components)
def compute_proj_ecg(in_path, in_fif_fname, h_tmin, h_tmax, n_grad, n_mag,
n_eeg, l_freq, h_freq, filter_length, n_jobs, ch_name,
reject, avg_ref):
# Reading fif File
raw_in = fiff.Raw(in_fif_fname)
prefix = in_fif_fname[:-8]
# prefix = 'sc3_BaleenLPRun4'
# print prefix
in_fif_fname = in_path + in_fif_fname
print in_fif_fname
out_path = os.path.join(in_path + 'ssp/')
out_fif_fname = in_path + 'ssp/' + prefix + '_clean_ecg_raw.fif'
ecg_proj_fname = in_path + prefix + '_ecg_proj.fif'
ecg_event_fname = in_path + 'ssp/' + prefix + '_ecg-eve.fif'
flag = 0
print 'Implementing ECG artifact rejection on data'
ecg_events, _, _ = mne.artifacts.find_ecg_events(raw_in)
if not len(ecg_events) < 30:
# print ecg_event_fname
print "Writing ECG events in %s" % ecg_event_fname
mne.write_events(ecg_event_fname, ecg_events)
# Making projector
print 'Computing ECG projector'
print out_path
#os.chdir('/cluster/kuperberg/SemPrMM/MEG/data/ac1/ssp')
#os.getcwd()
command = (
'mne_process_raw --cd %s --raw %s --events %s --makeproj '
'--projtmin -0.2 --projtmax 0.2 --saveprojtag _ecg_proj '
'--projnmag 1 --projngrad 1 --projneeg 0 --projevent 999 --highpass 5 '
'--lowpass 35 --projmagrej 8000 --projgradrej 5000 --projeegrej 600' %
(in_path, in_fif_fname, ecg_event_fname)
) ##6/1/13 CU:projectors fixed 1 1 0
st = os.system(command)
if st != 0:
print "Error while running : %s" % command
return in_fif_fname, ecg_proj_fname, len(ecg_event_fname), out_fif_fname
def compute_proj_ecg(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg,
l_freq, h_freq, filter_length, n_jobs, ch_name, reject,
avg_ref, bads):
# Reading fif File
raw_in = fiff.Raw(in_fif_fname)
if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'):
prefix = in_fif_fname[:-8]
else:
prefix = in_fif_fname[:-4]
print in_fif_fname
if out_fif_fname is None:
out_fif_fname = prefix + '_clean_ecg_raw.fif'
if ecg_proj_fname is None:
ecg_proj_fname = prefix + '_ecg_proj.fif'
if ecg_event_fname is None:
ecg_event_fname = prefix + '_ecg-eve.fif'
flag = 0
print 'Implementing ECG artifact rejection on data'
ecg_events, _, _ = mne.artifacts.find_ecg_events(raw_in)
if not len(ecg_events) < 30:
print ecg_event_fname
print "Writing ECG events in %s" % ecg_event_fname
mne.write_events(ecg_event_fname, ecg_events)
# Making projector
print 'Computing ECG projector'
command = (
'mne_process_raw --cd %s --raw %s --events %s --makeproj '
'--projtmin tmin --projtmax tmax --saveprojtag _ecg_proj '
'--projnmag %d --projngrad 1 --projneeg 1 --projevent 999 --highpass h_freq '
'--lowpass l_freq --projmagrej 4000 --projgradrej 3000 --projeegrej 500'
% (in_path, in_fif_fname, ecg_event_fname, n_mag))
st = os.system(command)
if st != 0:
print "Error while running : %s" % command
def test_ica_twice():
"""Test running ICA twice"""
raw = fiff.Raw(raw_fname, preload=True).crop(0, stop, False).crop(1.5)
picks = fiff.pick_types(raw.info, meg='grad', exclude='bads')
n_components = 0.9
max_pca_components = None
n_pca_components = 1.1
with warnings.catch_warnings(record=True):
ica1 = ICA(n_components=n_components,
max_pca_components=max_pca_components,
n_pca_components=n_pca_components,
random_state=0)
ica1.decompose_raw(raw, picks=picks, decim=3)
raw_new = ica1.pick_sources_raw(raw, n_pca_components=n_pca_components)
ica2 = ICA(n_components=n_components,
max_pca_components=max_pca_components,
n_pca_components=1.0,
random_state=0)
ica2.decompose_raw(raw_new, picks=picks, decim=3)
assert_equal(ica1.n_components_, ica2.n_components_)
def test_psd_epochs():
"""Test PSD estimation on epochs
"""
raw = fiff.Raw(raw_fname)
exclude = raw.info['bads'] + ['MEG 2443', 'EEG 053'] # bads + 2 more
# picks MEG gradiometers
picks = fiff.pick_types(raw.info, meg='mag', eeg=False, stim=False,
exclude=exclude)
picks = picks[:2]
n_fft = 128 # the FFT size (n_fft). Ideally a power of 2
tmin, tmax, event_id = -1, 1, 1
include = []
raw.info['bads'] += ['MEG 2443'] # bads
# picks MEG gradiometers
picks = fiff.pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=False, include=include, exclude='bads')
events = read_events(event_fname)
epochs = Epochs(raw, events[:10], event_id, tmin, tmax, picks=picks,
baseline=(None, 0),
reject=dict(grad=4000e-13, eog=150e-6), proj=False,
preload=True)
picks = fiff.pick_types(epochs.info, meg='grad', eeg=False, eog=True,
stim=False, include=include, exclude='bads')
psds, freqs = compute_epochs_psd(epochs[:1], fmin=2, fmax=300, n_fft=n_fft,
picks=picks)
psds_proj, _ = compute_epochs_psd(epochs[:1].apply_proj(), fmin=2,
fmax=300, n_fft=n_fft, picks=picks)
assert_array_almost_equal(psds, psds_proj)
assert_true(psds.shape == (1, len(picks), len(freqs)))
assert_true(np.sum(freqs < 0) == 0)
assert_true(np.sum(psds < 0) == 0)
def test_concatenatechannels():
"""Test methods of ConcatenateChannels
"""
raw = fiff.Raw(raw_fname, preload=False)
events = read_events(event_name)
picks = fiff.pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=False,
exclude='bads')
picks = picks[1:13:3]
with warnings.catch_warnings(record=True) as w:
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True)
epochs_data = epochs.get_data()
concat = ConcatenateChannels(epochs.info)
y = epochs.events[:, -1]
X = concat.fit_transform(epochs_data, y)
# Check data dimensions
assert_true(X.shape[0] == epochs_data.shape[0])
assert_true(X.shape[1] == epochs_data.shape[1] * epochs_data.shape[2])
assert_array_equal(concat.fit(epochs_data, y).transform(epochs_data), X)
# Check if data is preserved
n_times = epochs_data.shape[2]
assert_array_equal(epochs_data[0, 0, 0:n_times], X[0, 0:n_times])
# Test init exception
assert_raises(ValueError, concat.fit, epochs, y)
assert_raises(ValueError, concat.transform, epochs, y)
def compute_proj_eog(in_path, in_fif_fname, e_tmin, e_tmax, n_grad, n_mag,
n_eeg, l_freq, h_freq, filter_length, n_jobs, ch_name,
reject, avg_ref):
raw_in = fiff.Raw(in_fif_fname)
prefix = in_fif_fname[:-8]
# prefix = 'sc3_BaleenLPRun4'
## print prefix
in_fif_fname = in_path + in_fif_fname
print in_fif_fname
out_path = os.path.join(in_path + 'ssp/')
out_fif_fname = in_path + 'ssp/' + prefix + '_clean_eog_raw.fif'
eog_proj_fname = in_path + prefix + '_eog_proj.fif'
eog_event_fname = in_path + 'ssp/' + prefix + '_eog-eve.fif'
flag = 0
#print 'Implementing EOG artifact rejection on data'
#eog_events,_ = mne.artifacts.find_eog_events(raw_in)
#if not len(eog_events)<20:
# print eog_event_fname
# print "Writing EOG events in %s" % eog_event_fname
# mne.write_events(eog_event_fname, eog_events)
# print eog_proj_fname
print "Computing the EOG projector"
command = (
'mne_process_raw --cd %s --raw %s --events %s --makeproj '
'--projtmin %s --projtmax %s --saveprojtag _eog_proj '
'--projnmag %s --projngrad %s --projneeg %s --projevent 998 --highpass 0.3 '
'--lowpass 35 --filtersize 8192 --projmagrej 8000 --projgradrej 7000 --projeegrej 800' ###filtersize 8192, projeegrej was 500 by default!!!
% (in_path, in_fif_fname, eog_event_fname, e_tmin, e_tmax, n_mag,
n_grad, n_eeg)
) ##1/15/13 CU: refer the speadsheet(projectors custom made for each subject) --projmagrej 5500 --projgradrej 3000 --projeegrej 900
st = os.system(command)
if st != 0:
print "Error while running : %s" % command
return in_fif_fname, eog_proj_fname, len(eog_event_fname), out_fif_fname
def test_reject_epochs():
"""Test of epochs rejection
"""
event_id = 1
tmin = -0.2
tmax = 0.5
# Setup for reading the raw data
raw = fiff.Raw(raw_fname)
events = mne.read_events(event_name)
picks = fiff.pick_types(raw.info,
meg=True,
eeg=True,
stim=True,
eog=True,
include=['STI 014'])
epochs = mne.Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
reject=dict(grad=1000e-12,
mag=4e-12,
eeg=80e-6,
eog=150e-6),
flat=dict(grad=1e-15, mag=1e-15))
data = epochs.get_data()
n_events = len(epochs.events)
n_clean_epochs = len(data)
# Should match
# mne_process_raw --raw test_raw.fif --projoff \
# --saveavetag -ave --ave test.ave --filteroff
assert n_events > n_clean_epochs
assert n_clean_epochs == 3
def compute_proj_eog(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg,
l_freq, h_freq, filter_length, n_jobs, ch_name, reject,
avg_ref):
raw_in = fiff.Raw(in_fif_fname)
prefix = in_fif_fname[:-8]
print prefix
in_fif_fname = in_path + in_fif_fname
print in_fif_fname
out_path = os.path.join(in_path + 'ssp/')
out_fif_fname = in_path + 'ssp/' + prefix + '_clean_eog1_raw.fif'
eog_proj_fname = in_path + prefix + '_eog1_proj.fif'
eog_event_fname = in_path + 'ssp/' + prefix + '_eog1-eve.fif'
flag = 0
print 'Implementing EOG artifact rejection on data'
## eog_events,_ = mne.artifacts.find_eog_events(raw_in)
## if not len(eog_events)<20:
## print eog_event_fname
## print "Writing EOG events in %s" % eog_event_fname
## mne.write_events(eog_event_fname, eog_events)
## print eog_proj_fname
print "Computing the EOG projector"
command = (
'mne_process_raw --cd %s --raw %s --events %s --makeproj '
'--projtmin %s --projtmax %s --saveprojtag _eog1_proj '
'--projnmag %s --projngrad %s --projneeg %s --projevent 998 --highpass 0.3 '
'--lowpass 35 --filtersize 8192 --projmagrej 5500 --projgradrej 3000 --projeegrej 500 '
% (in_path, in_fif_fname, eog_event_fname, tmin, tmax, n_mag, n_grad,
n_eeg))
st = os.system(command)
if st != 0:
print "Error while running : %s" % command
return in_fif_fname, eog_proj_fname, len(eog_event_fname), out_fif_fname
