def test_epochs_plot():
"""Test plotting of epochs"""
tmin, tmax, event_id = -0.5, 1.5, 999
# create some evil events
events = np.array([[1000, 999], [2000, 999], [3000, 999]])
for fname in fnames:
raw = Raw(fname)
epochs = Epochs(raw, events, event_id, tmin, tmax)
assert_raises(ValueError, epochs.plot, picks=['whatever'])
epochs.plot(picks=['ps'])
fig = epochs.plot(n_chunks=2)
# test clicking: find our callbacks
for func in fig.canvas.callbacks.callbacks['button_press_event'].items():
func = func[1].func
if isinstance(func, partial):
break
params = func.keywords['params']
for ax in fig.axes:
_epochs_axes_onclick(DummyEvent(ax), params)
# nav clicking
_epochs_navigation_onclick(DummyEvent(params['next'].ax), params)
_epochs_navigation_onclick(DummyEvent(params['back'].ax), params)
_epochs_navigation_onclick(DummyEvent(params['reject-quit'].ax), params)
def test_epochs_deconv():
"""Test epochs deconvolution"""
tmin, tmax = -0.5, 1.5
event_dict = dict(foo=999)
events = np.array([np.arange(0, 21000, 1000, int),
999 * np.ones(21, int)]).T
for fi, fname in enumerate(fnames):
if fi == 0:
n_jobs = 1
else:
n_jobs = 0
raw = read_raw(fname)
epochs = Epochs(raw, events, event_dict,
tmin, tmax)
a = raw.info['sample_fields']
b = epochs.info['data_cols']
assert_equal(len(a), len(b))
assert_true(all(aa == bb for aa, bb in zip(a, b)))
data = epochs.get_data('ps')
assert_raises(RuntimeError, Epochs, raw, events, 'test', tmin, tmax)
fit, times = epochs.deconvolve()
assert_array_equal(data, epochs.get_data('ps'))
assert_equal(fit.shape, (len(epochs), len(times)))
fit, times = epochs.deconvolve(spacing=[-0.1, 0.4, 1.0],
bounds=(0, np.inf), n_jobs=n_jobs)
assert_equal(fit.shape, (len(epochs), len(times)))
assert_equal(len(times), 3)
if fi == 0:
if _has_joblib():
assert_raises(ValueError, epochs.deconvolve, n_jobs=-1000)
def test_epochs_deconv():
"""Test epochs deconvolution"""
tmin, tmax = -0.5, 1.5
event_dict = dict(foo=999, bar=77)
events_a = np.array([[12000, 77], [1000, 999]])
for fname in fnames:
raw = Raw(fname)
epochs = Epochs([raw] * 2, [events_a] * 2, event_dict,
tmin, tmax)
assert_raises(RuntimeError, Epochs, raw, events_a, 'test', tmin, tmax)
fit, times = epochs.deconvolve()
assert_equal(fit.shape, (len(epochs), len(times)))
fit, times = epochs.deconvolve(spacing=[-0.1, 0.4, 1.0],
bounds=(0, np.inf))
assert_equal(fit.shape, (len(epochs), len(times)))
assert_equal(len(times), 3)
def test_epochs_plot():
"""Test plotting of epochs"""
tmin, tmax, event_id = -0.5, 1.5, 999
# create some evil events
events = np.array([[1000, 999], [2000, 999], [3000, 999]])
for fname in fnames:
raw = read_raw(fname)
epochs = Epochs(raw, events, event_id, tmin, tmax)
assert_raises(ValueError, epochs.plot, picks=['whatever'])
epochs.plot(picks=['ps'])
fig = epochs.plot(n_chunks=2)
epochs.plot(draw_discrete='saccades')
# test clicking: find our callbacks
for func in fig.canvas.callbacks.callbacks['button_press_event'].items():
func = func[1].func
if isinstance(func, partial):
break
params = func.keywords['params']
for ax in fig.axes:
_epochs_axes_onclick(DummyEvent(ax), params)
# nav clicking
_epochs_navigation_onclick(DummyEvent(params['next'].ax), params)
_epochs_navigation_onclick(DummyEvent(params['back'].ax), params)
_epochs_navigation_onclick(DummyEvent(params['reject-quit'].ax), params)
def test_epochs_concat():
"""Test epochs concatenation"""
tmin, tmax = -0.5, 1.5
event_dict = dict(foo=999, bar=77)
events_a = np.array([[12000, 77], [1000, 999], [-1, 999]])
events_b = np.array([[1000, 999], [10000, 999]])
for fname in fnames:
raw = read_raw(fname)
events_a[-1, 0] = raw.n_samples - 1
epochs_ab = Epochs([raw] * 2, [events_a, events_b], event_dict, tmin,
tmax)
epochs_ba = Epochs([raw] * 2, [events_b, events_a], event_dict, tmin,
tmax)
# make sure discretes made it through
for epochs in [epochs_ab, epochs_ba]:
for d in [epochs.blinks, epochs.saccades, epochs_ab.fixations]:
assert_equal(len(d), len(epochs))
for dd in d:
if len(dd) > 0:
for t in (dd['stime'], dd['etime']):
assert_true(np.all(t >= tmin) & np.all(t <= tmax))
assert_equal(len(epochs_ab.events), 4)
assert_equal(len(epochs_ba.events), 4)
assert_array_equal(epochs_ab.times, epochs_ba.times)
# make sure event numbers match
reord = [2, 3, 0, 1]
assert_array_equal(epochs_ab.events[:, 1], epochs_ba.events[reord, 1])
# make sure actual data matches
data_ab = epochs_ab.data
data_ba = epochs_ba.data
assert_array_equal(data_ab, data_ba[reord])
# test discretes
assert_equal(len(epochs_ab.blinks), len(epochs_ba.blinks))
blink_ab = epochs_ab.blinks[3]
blink_ba = epochs_ba.blinks[reord[3]]
assert_equal(len(blink_ab), len(blink_ba))
assert_true(len(blink_ab) > 0) # make sure we've tested useful case
for key in ('stime', 'etime'):
blink_ab_d = blink_ab[key]
blink_ba_d = blink_ba[key]
assert_array_equal(blink_ab_d, blink_ba_d)
def test_epochs_deconv():
"""Test epochs deconvolution"""
tmin, tmax = -0.5, 1.5
event_dict = dict(foo=999)
events = np.array([np.arange(0, 21000, 1000, int),
999 * np.ones(21, int)]).T
for fi, fname in enumerate(fnames):
if fi == 0:
n_jobs = 1
else:
n_jobs = 0
raw = read_raw(fname)
epochs = Epochs(raw, events, event_dict, tmin, tmax)
a = raw.info['sample_fields']
b = epochs.info['data_cols']
assert_equal(len(a), len(b))
assert_true(all(aa == bb for aa, bb in zip(a, b)))
data = epochs.get_data('ps')
assert_raises(RuntimeError, Epochs, raw, events, 'test', tmin, tmax)
fit, times = epochs.deconvolve()
assert_array_equal(data, epochs.get_data('ps'))
assert_equal(fit.shape, (len(epochs), len(times)))
fit, times = epochs.deconvolve(spacing=[-0.1, 0.4, 1.0],
bounds=(0, np.inf),
n_jobs=n_jobs)
assert_equal(fit.shape, (len(epochs), len(times)))
assert_equal(len(times), 3)
if fi == 0:
if _has_joblib():
assert_raises(ValueError, epochs.deconvolve, n_jobs=-1000)
def test_epochs_combine():
"""Test epochs combine IDs functionality"""
tmin, tmax = -0.5, 1.5
event_dict = dict(foo=1, bar=2, test=3)
events_1 = np.array([[12000, 1], [1000, 2], [10000, 2], [2000, 3]])
events_2 = np.array([[12000, 2], [1000, 1], [10000, 1], [2000, 3]])
for fname in fnames:
raw = read_raw(fname)
epochs_1 = Epochs(raw, events_1, event_dict, tmin, tmax)
epochs_2 = Epochs(raw, events_2, event_dict, tmin, tmax)
assert_raises(ValueError, epochs_1.combine_event_ids, ['foo', 'bar'],
dict(foobar=1))
epochs_1.combine_event_ids(['foo', 'bar'], 12)
epochs_2.combine_event_ids(['foo', 'bar'], dict(foobar=12))
d1 = epochs_1.data
d2 = epochs_2.data
assert_array_equal(d1, d2)
epochs_1.equalize_event_counts(['12', 'test'])
epochs_2.equalize_event_counts(['foobar', 'test'])
d1 = epochs_1.data
d2 = epochs_2.data
assert_array_equal(d1, d2)
# this shouldn't really do anything
epochs_2.equalize_event_counts(['foobar', 'test'], method='truncate')
assert_array_equal(d1, epochs_2.data)
def test_epochs_io():
"""Test epochs IO functionality"""
tmin, tmax, event_id = -0.5, 1.5, 999
missing_event_dict = dict(foo=999, bar=555)
# create some evil events
events = np.array([[12000, 77], [1000, 999], [10000, 999]])
for fname in fnames:
raw = read_raw(fname)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
epochs = Epochs(raw,
events,
missing_event_dict,
tmin,
tmax,
ignore_missing=True)
assert_raises(RuntimeError, Epochs, raw, events, 1.1, tmin, tmax)
assert_raises(ValueError, Epochs, [raw] * 2, events, event_id, tmin,
tmax)
assert_equal(len(_filter_warnings(w)), 0)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
epochs = Epochs(raw, events, missing_event_dict, tmin, tmax)
assert_equal(len(_filter_warnings(w)), 1)
epochs = Epochs(raw, events, event_id, tmin, tmax)
assert_raises(IndexError, epochs.drop_epochs, [1000])
print(epochs) # test repr works
for disc in epochs.info['discretes']:
assert_equal(len(vars(epochs)[disc]), len(epochs.events))
assert_equal(len(epochs.events), 2)
# assert_equal(epochs.data_frame.shape[0] / epochs._n_times,
# len(epochs.events))
# assert_true(epochs.data_frame['time'].diff().min() >= 0)
epochs = Epochs(raw, events, dict(a=999, b=77), tmin, tmax)
assert_equal(len(epochs.events), 3)
# assert_equal(epochs.data_frame.shape[0] / epochs._n_times,
# len(epochs.events))
# assert_true(epochs.data_frame['time'].diff().min() >= 0)
for disc in epochs.info['discretes']:
this_disc = vars(epochs)[disc]
assert_equal(len(this_disc), len(epochs.events))
for field in ['stime', 'etime']:
for di in this_disc:
if field in di:
for event in di[field]:
assert_true(epochs.tmin <= event <= epochs.tmax)
epochs2 = epochs.copy()
assert_true(epochs._data is not epochs2._data)
del epochs2._data
assert_true('_data' in vars(epochs) and '_data' not in vars(epochs2))
assert_true(epochs is not epochs2)
epochs2 = epochs[0]
assert_equal(len(epochs2.events), 1)
assert_equal(set(epochs2.events[:, -1]), set([999]))
# desired = len(epochs2.events) * len(epochs.times)
# assert_equal(epochs2.data_frame.shape[0], desired)
# assert_true(epochs2.data_frame['time'].diff().min() >= 0)
assert_equal(len(epochs2.saccades), len(epochs2.events))
epochs2 = epochs[[1, 0]]
assert_equal(len(epochs2.events), 2)
assert_equal(set(epochs2.events[:, -1]), set([999]))
# desired = len(epochs2.events) * len(epochs.times)
assert_equal(len(epochs2.saccades), len(epochs2.events))
# assert_equal(epochs2.data_frame.shape[0], desired)
epochs2 = epochs['a']
assert_equal(len(epochs2.events), 2)
assert_equal(set(epochs2.events[:, -1]), set([999]))
# desired = len(epochs2.events) * len(epochs.times)
# assert_equal(epochs2.data_frame.shape[0], desired)
assert_equal(len(epochs2.saccades), len(epochs2.events))
epochs2 = epochs[['a', 'b']]
assert_equal(len(epochs2.events), 3)
assert_equal(set(epochs2.events[:, -1]), set([999, 77]))
# desired = len(epochs2.events) * len(epochs.times)
# assert_equal(epochs2.data_frame.shape[0], desired)
assert_equal(len(epochs2.saccades), len(epochs2.events))
assert_true(np.diff(epochs2.events[:, 0]).min() >= 0)
epochs2 = epochs[slice(1, 3)]
assert_equal(len(epochs2.events), 2)
assert_equal(set(epochs2.events[:, -1]), set([999, 77]))
# desired = len(epochs2.events) * len(epochs.times)
# assert_equal(epochs2.data_frame.shape[0], desired)
assert_equal(len(epochs2.saccades), len(epochs2.events))
assert_true(np.diff(epochs2.events[:, 0]).min() >= 0)
"""
data1 = epochs[0].data
data2 = epochs.data_frame.ix[0, epochs.info['data_cols']].values
data2 = data2.reshape(1,
len(epochs.times),
len(epochs.info['data_cols']))
assert_array_equal(data1, np.transpose(data2, [0, 2, 1]))
"""
for e in epochs:
assert_true(np.argmin(e.shape) == 0)
assert_array_equal(e, epochs.data[-1])
# ttl_to_id function. Those integer codes are then put into the event
# list in place of the 1-triggers used to mark stimulus onsets.
n_digits = [1, 2, 2, 1]
for c, t in zip(this_cond_mat, ttls):
assert np.array_equal(decimals_to_binary(c, n_digits), t)
# this maps the sequence of 4 (single-digit) ints into a single int.
# the sequence of experiment variables corresponding to each order of
# magnitude is taken from params['cond_readme']; in this case it is
# 1000s: attn, 100s: spatial, 10s: idents, 1s: gap
event[:, 1] = [ttl_to_id(c) for c in this_cond_mat]
for e in event[:, 1]:
assert e in rev_dict
events.append(event)
print('\n Epoching...')
epochs = Epochs(raws, events, event_dict, t_min, t_max)
if downsample:
print(' Downsampling...')
epochs.resample(fs_out, n_jobs=n_jobs)
# compute gaze angles (in degrees)
angles = get_gaze_angle(epochs, screenprops)
# zscore pupil sizes
zscore = epochs.pupil_zscores()
# init some containers
kernel_fits = list()
kernel_zscores = list()
print(' Deconvolving...')
deconv_kwargs = dict(kernel=kernel, n_jobs=n_jobs, acc=1e-3)
if deconv_time_pts is not None:
deconv_kwargs.update(dict(spacing=deconv_time_pts))
def test_epochs_combine():
"""Test epochs combine IDs functionality"""
tmin, tmax = -0.5, 1.5
event_dict = dict(foo=1, bar=2, test=3)
events_1 = np.array([[12000, 1], [1000, 2], [10000, 2], [2000, 3]])
events_2 = np.array([[12000, 2], [1000, 1], [10000, 1], [2000, 3]])
for fname in fnames:
raw = read_raw(fname)
epochs_1 = Epochs(raw, events_1, event_dict, tmin, tmax)
epochs_2 = Epochs(raw, events_2, event_dict, tmin, tmax)
assert_raises(ValueError, epochs_1.combine_event_ids, ['foo', 'bar'],
dict(foobar=1))
epochs_1.combine_event_ids(['foo', 'bar'], 12)
epochs_2.combine_event_ids(['foo', 'bar'], dict(foobar=12))
d1 = epochs_1.data
d2 = epochs_2.data
assert_array_equal(d1, d2)
epochs_1.equalize_event_counts(['12', 'test'])
epochs_2.equalize_event_counts(['foobar', 'test'])
d1 = epochs_1.data
d2 = epochs_2.data
assert_array_equal(d1, d2)
# this shouldn't really do anything
epochs_2.equalize_event_counts(['foobar', 'test'], method='truncate')
assert_array_equal(d1, epochs_2.data)
def test_epochs_io():
"""Test epochs IO functionality"""
tmin, tmax, event_id = -0.5, 1.5, 999
missing_event_dict = dict(foo=999, bar=555)
# create some evil events
events = np.array([[12000, 77], [1000, 999], [10000, 999]])
for fname in fnames:
raw = read_raw(fname)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
epochs = Epochs(raw, events, missing_event_dict, tmin, tmax,
ignore_missing=True)
assert_raises(RuntimeError, Epochs, raw, events, 1.1, tmin, tmax)
assert_raises(ValueError, Epochs, [raw] * 2, events, event_id,
tmin, tmax)
assert_equal(len(_filter_warnings(w)), 0)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
epochs = Epochs(raw, events, missing_event_dict, tmin, tmax)
assert_equal(len(_filter_warnings(w)), 1)
epochs = Epochs(raw, events, event_id, tmin, tmax)
assert_raises(IndexError, epochs.drop_epochs, [1000])
print(epochs) # test repr works
for disc in epochs.info['discretes']:
assert_equal(len(vars(epochs)[disc]), len(epochs.events))
assert_equal(len(epochs.events), 2)
# assert_equal(epochs.data_frame.shape[0] / epochs._n_times,
# len(epochs.events))
# assert_true(epochs.data_frame['time'].diff().min() >= 0)
epochs = Epochs(raw, events, dict(a=999, b=77), tmin, tmax)
assert_equal(len(epochs.events), 3)
# assert_equal(epochs.data_frame.shape[0] / epochs._n_times,
# len(epochs.events))
# assert_true(epochs.data_frame['time'].diff().min() >= 0)
for disc in epochs.info['discretes']:
this_disc = vars(epochs)[disc]
assert_equal(len(this_disc), len(epochs.events))
for field in ['stime', 'etime']:
for di in this_disc:
if field in di:
for event in di[field]:
assert_true(epochs.tmin <= event <= epochs.tmax)
epochs2 = epochs.copy()
assert_true(epochs._data is not epochs2._data)
del epochs2._data
assert_true('_data' in vars(epochs) and
'_data' not in vars(epochs2))
assert_true(epochs is not epochs2)
epochs2 = epochs[0]
assert_equal(len(epochs2.events), 1)
assert_equal(set(epochs2.events[:, -1]), set([999]))
# desired = len(epochs2.events) * len(epochs.times)
# assert_equal(epochs2.data_frame.shape[0], desired)
# assert_true(epochs2.data_frame['time'].diff().min() >= 0)
assert_equal(len(epochs2.saccades), len(epochs2.events))
epochs2 = epochs[[1, 0]]
assert_equal(len(epochs2.events), 2)
assert_equal(set(epochs2.events[:, -1]), set([999]))
# desired = len(epochs2.events) * len(epochs.times)
assert_equal(len(epochs2.saccades), len(epochs2.events))
# assert_equal(epochs2.data_frame.shape[0], desired)
epochs2 = epochs['a']
assert_equal(len(epochs2.events), 2)
assert_equal(set(epochs2.events[:, -1]), set([999]))
# desired = len(epochs2.events) * len(epochs.times)
# assert_equal(epochs2.data_frame.shape[0], desired)
assert_equal(len(epochs2.saccades), len(epochs2.events))
epochs2 = epochs[['a', 'b']]
assert_equal(len(epochs2.events), 3)
assert_equal(set(epochs2.events[:, -1]), set([999, 77]))
# desired = len(epochs2.events) * len(epochs.times)
# assert_equal(epochs2.data_frame.shape[0], desired)
assert_equal(len(epochs2.saccades), len(epochs2.events))
assert_true(np.diff(epochs2.events[:, 0]).min() >= 0)
epochs2 = epochs[slice(1, 3)]
assert_equal(len(epochs2.events), 2)
assert_equal(set(epochs2.events[:, -1]), set([999, 77]))
# desired = len(epochs2.events) * len(epochs.times)
# assert_equal(epochs2.data_frame.shape[0], desired)
assert_equal(len(epochs2.saccades), len(epochs2.events))
assert_true(np.diff(epochs2.events[:, 0]).min() >= 0)
"""
data1 = epochs[0].data
data2 = epochs.data_frame.ix[0, epochs.info['data_cols']].values
data2 = data2.reshape(1,
len(epochs.times),
len(epochs.info['data_cols']))
assert_array_equal(data1, np.transpose(data2, [0, 2, 1]))
"""
for e in epochs:
assert_true(np.argmin(e.shape) == 0)
assert_array_equal(e, epochs.data[-1])
old_ord = eyelink_stim_ord
eyelink_stim_ord = np.empty_like(stim_nums)
eyelink_stim_ord[missing] = stim_nums[missing]
eyelink_stim_ord[not_missing] = old_ord
print('Recovered {} trial(s)'.format(n_miss), end='\n ')
assert np.array_equal(eyelink_stim_ord, stim_nums)
assert len(event) == len(stim_nums)
# convert event numbers
band_num = run_inds[ri][:, 1]
gap_num = 10 * small_mat[:, 1] # cf. line 251 of vocExperiment_v2.m
attn_num = 100 * small_mat[:, 0] # cf. line 250 of vocExperiment_v2.m
event[:, 1] = band_num + gap_num + attn_num
events.append(event)
print('\n Epoching...')
epochs = Epochs(raws, events, event_dict, t_min, t_max)
kernel_fits = list()
kernel_zscores = list()
kernel_fits_continuous = list()
for kk, kernel in enumerate(kernels):
kname = ['LABSN', 'Wierda'][kk]
print(' Deconvolving ({} kernel)...'.format(kname))
fit, time_pts = epochs.deconvolve(kernel=kernel, n_jobs=6)
zscore = epochs.pupil_zscores()
if deconv_time_pts is None:
deconv_time_pts = time_pts
assert np.array_equal(deconv_time_pts, time_pts)
# reorder fits to match big_mat (stim# in serial order, voc band, time)
order = np.array(run_inds)
old_ord = eyelink_stim_ord
eyelink_stim_ord = np.empty_like(stim_nums)
eyelink_stim_ord[missing] = stim_nums[missing]
eyelink_stim_ord[not_missing] = old_ord
print('Recovered {} trial(s)'.format(n_miss), end='\n ')
assert np.array_equal(eyelink_stim_ord, stim_nums)
assert len(event) == len(stim_nums)
# convert event numbers
band_num = run_inds[ri][:, 1]
gap_num = 10 * small_mat[:, 1] # cf. line 251 of vocExperiment_v2.m
attn_num = 100 * small_mat[:, 0] # cf. line 250 of vocExperiment_v2.m
event[:, 1] = band_num + gap_num + attn_num
events.append(event)
print('\n Epoching...')
epochs = Epochs(raws, events, event_dict, t_min, t_max)
kernel_fits = list()
kernel_zscores = list()
kernel_fits_continuous = list()
for kk, kernel in enumerate(kernels):
kname = ['LABSN', 'Wierda'][kk]
print(' Deconvolving ({} kernel)...'.format(kname))
fit, time_pts = epochs.deconvolve(kernel=kernel, n_jobs=6)
zscore = epochs.pupil_zscores()
if deconv_time_pts is None:
deconv_time_pts = time_pts
assert np.array_equal(deconv_time_pts, time_pts)
# reorder fits to match big_mat (stim# in serial order, voc band, time)
order = np.array(run_inds)
