def test_preload_modify():
""" Test preloading and modifying data
"""
for preload in [False, True, 'memmap.dat']:
raw = Raw(fif_fname, preload=preload)
nsamp = raw.last_samp - raw.first_samp + 1
picks = pick_types(raw.info, meg='grad')
data = np.random.randn(len(picks), nsamp / 2)
try:
raw[picks, :nsamp / 2] = data
except RuntimeError as err:
if not preload:
continue
else:
raise err
tmp_fname = 'raw.fif'
raw.save(tmp_fname)
raw_new = Raw(tmp_fname)
data_new, _ = raw_new[picks, :nsamp / 2]
assert_array_almost_equal(data, data_new)
def test_compensation_raw():
raw1 = Raw(ctf_comp_fname, compensation=None)
assert_true(raw1.comp is None)
data1, times1 = raw1[:, :]
raw2 = Raw(ctf_comp_fname, compensation=3)
data2, times2 = raw2[:, :]
assert_true(raw2.comp is None) # unchanged (data come with grade 3)
assert_array_equal(times1, times2)
assert_array_equal(data1, data2)
raw3 = Raw(ctf_comp_fname, compensation=1)
data3, times3 = raw3[:, :]
assert_true(raw3.comp is not None)
assert_array_equal(times1, times3)
# make sure it's different with a different compensation:
assert_true(np.mean(np.abs(data1 - data3)) > 1e-12)
assert_raises(ValueError, Raw, ctf_comp_fname, compensation=33)
# Try IO with compensation
temp_file = op.join(tempdir, "raw.fif")
raw1.save(temp_file, overwrite=True)
raw4 = Raw(temp_file)
data4, times4 = raw4[:, :]
assert_array_equal(times1, times4)
assert_array_equal(data1, data4)
# Now save the file that has modified compensation
# and make sure we can the same data as input ie. compensation
# is undone
raw3.save(temp_file, overwrite=True)
raw5 = Raw(temp_file)
data5, times5 = raw5[:, :]
assert_array_equal(times1, times5)
assert_allclose(data1, data5, rtol=1e-12, atol=1e-22)
def test_preload_modify():
""" Test preloading and modifying data
"""
for preload in [False, True, 'memmap.dat']:
raw = Raw(fif_fname, preload=preload)
nsamp = raw.last_samp - raw.first_samp + 1
picks = pick_types(raw.info, meg='grad', exclude='bads')
data = np.random.randn(len(picks), nsamp / 2)
try:
raw[picks, :nsamp / 2] = data
except RuntimeError as err:
if not preload:
continue
else:
raise err
tmp_fname = op.join(tempdir, 'raw.fif')
raw.save(tmp_fname, overwrite=True)
raw_new = Raw(tmp_fname)
data_new, _ = raw_new[picks, :nsamp / 2]
assert_allclose(data, data_new)
def test_preload_modify():
""" Test preloading and modifying data
"""
for preload in [False, True, "memmap.dat"]:
raw = Raw(fif_fname, preload=preload)
nsamp = raw.last_samp - raw.first_samp + 1
picks = pick_types(raw.info, meg="grad", exclude="bads")
data = np.random.randn(len(picks), nsamp / 2)
try:
raw[picks, : nsamp / 2] = data
except RuntimeError as err:
if not preload:
continue
else:
raise err
tmp_fname = op.join(tempdir, "raw.fif")
raw.save(tmp_fname, overwrite=True)
raw_new = Raw(tmp_fname)
data_new, _ = raw_new[picks, : nsamp / 2]
assert_allclose(data, data_new)
def test_preload_modify():
""" Test preloading and modifying data
"""
for preload in [False, True, 'memmap.dat']:
raw = Raw(fif_fname, preload=preload)
nsamp = raw.last_samp - raw.first_samp + 1
picks = pick_types(raw.info, meg='grad', exclude='bads')
data = np.random.randn(len(picks), nsamp / 2)
try:
raw[picks, :nsamp / 2] = data
except RuntimeError as err:
if not preload:
continue
else:
raise err
tmp_fname = op.join(tempdir, 'raw.fif')
raw.save(tmp_fname)
raw_new = Raw(tmp_fname)
data_new, _ = raw_new[picks, :nsamp / 2]
assert_array_almost_equal(data, data_new)
def test_subject_info():
"""Test reading subject information
"""
raw = Raw(fif_fname)
raw.crop(0, 1)
assert_true(raw.info['subject_info'] is None)
# fake some subject data
keys = [
'id', 'his_id', 'last_name', 'first_name', 'birthday', 'sex', 'hand'
]
vals = [1, 'foobar', 'bar', 'foo', (1901, 2, 3), 0, 1]
subject_info = dict()
for key, val in zip(keys, vals):
subject_info[key] = val
raw.info['subject_info'] = subject_info
out_fname = op.join(tempdir, 'test_subj_info_raw.fif')
raw.save(out_fname, overwrite=True)
raw_read = Raw(out_fname)
for key in keys:
assert_equal(subject_info[key], raw_read.info['subject_info'][key])
raw_read.anonymize()
assert_true(raw_read.info.get('subject_info') is None)
out_fname_anon = op.join(tempdir, 'test_subj_info_anon_raw.fif')
raw_read.save(out_fname_anon, overwrite=True)
raw_read = Raw(out_fname_anon)
assert_true(raw_read.info.get('subject_info') is None)
def test_subject_info():
"""Test reading subject information
"""
raw = Raw(fif_fname)
raw.crop(0, 1)
assert_true(raw.info['subject_info'] is None)
# fake some subject data
keys = ['id', 'his_id', 'last_name', 'first_name', 'birthday', 'sex',
'hand']
vals = [1, 'foobar', 'bar', 'foo', (1901, 2, 3), 0, 1]
subject_info = dict()
for key, val in zip(keys, vals):
subject_info[key] = val
raw.info['subject_info'] = subject_info
out_fname = op.join(tempdir, 'test_subj_info_raw.fif')
raw.save(out_fname, overwrite=True)
raw_read = Raw(out_fname)
for key in keys:
assert_equal(subject_info[key], raw_read.info['subject_info'][key])
raw_read.anonymize()
assert_true(raw_read.info.get('subject_info') is None)
out_fname_anon = op.join(tempdir, 'test_subj_info_anon_raw.fif')
raw_read.save(out_fname_anon, overwrite=True)
raw_read = Raw(out_fname_anon)
assert_true(raw_read.info.get('subject_info') is None)
def test_compute_proj_raw():
"""Test SSP computation on raw"""
# Test that the raw projectors work
raw_time = 2.5 # Do shorter amount for speed
raw = Raw(raw_fname, preload=True).crop(0, raw_time, False)
for ii in (0.25, 0.5, 1, 2):
with warnings.catch_warnings(True) as w:
projs = compute_proj_raw(raw, duration=ii - 0.1, stop=raw_time,
n_grad=1, n_mag=1, n_eeg=0)
assert_true(len(w) == 1)
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, raw.ch_names, bads=[])
assert_true(nproj == 2)
assert_true(U.shape[1] == 2)
# test that you can save them
raw.info['projs'] += projs
raw.save(op.join(tempdir, 'foo_%d_raw.fif' % ii), overwrite=True)
# Test that purely continuous (no duration) raw projection works
with warnings.catch_warnings(True) as w:
projs = compute_proj_raw(raw, duration=None, stop=raw_time,
n_grad=1, n_mag=1, n_eeg=0)
assert_true(len(w) == 1)
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, raw.ch_names, bads=[])
assert_true(nproj == 2)
assert_true(U.shape[1] == 2)
# test that you can save them
raw.info['projs'] += projs
raw.save(op.join(tempdir, 'foo_rawproj_continuous_raw.fif'))
# test resampled-data projector, upsampling instead of downsampling
# here to save an extra filtering (raw would have to be LP'ed to be equiv)
raw_resamp = cp.deepcopy(raw)
raw_resamp.resample(raw.info['sfreq'] * 2, n_jobs=2)
with warnings.catch_warnings(True) as w:
projs = compute_proj_raw(raw_resamp, duration=None, stop=raw_time,
n_grad=1, n_mag=1, n_eeg=0)
projs = activate_proj(projs)
proj_new, _, _ = make_projector(projs, raw.ch_names, bads=[])
assert_array_almost_equal(proj_new, proj, 4)
# test with bads
raw.load_bad_channels(bads_fname) # adds 2 bad mag channels
with warnings.catch_warnings(True) as w:
projs = compute_proj_raw(raw, n_grad=0, n_mag=0, n_eeg=1)
# test that bad channels can be excluded
proj, nproj, U = make_projector(projs, raw.ch_names,
bads=raw.ch_names)
assert_array_almost_equal(proj, np.eye(len(raw.ch_names)))
def test_proj():
"""Test SSP proj operations
"""
for proj_active in [True, False]:
raw = Raw(fif_fname, preload=False, proj_active=proj_active)
assert_true(all(p['active'] == proj_active for p in raw.info['projs']))
data, times = raw[0:2, :]
data1, times1 = raw[0:2]
assert_array_equal(data, data1)
assert_array_equal(times, times1)
# test adding / deleting proj
if proj_active:
assert_raises(ValueError, raw.add_proj, [],
{'remove_existing': True})
assert_raises(ValueError, raw.del_proj, 0)
else:
projs = deepcopy(raw.info['projs'])
n_proj = len(raw.info['projs'])
raw.del_proj(0)
assert_true(len(raw.info['projs']) == n_proj - 1)
raw.add_proj(projs, remove_existing=False)
assert_true(len(raw.info['projs']) == 2 * n_proj - 1)
raw.add_proj(projs, remove_existing=True)
assert_true(len(raw.info['projs']) == n_proj)
# test apply_proj() with and without preload
for preload in [True, False]:
raw = Raw(fif_fname, preload=preload, proj_active=False)
data, times = raw[:, 0:2]
raw.apply_projector()
data_proj_1 = np.dot(raw._projector, data)
# load the file again without proj
raw = Raw(fif_fname, preload=preload, proj_active=False)
# write the file with proj. activated, make sure proj has been applied
raw.save('raw.fif', proj_active=True)
raw2 = Raw('raw.fif', proj_active=False)
data_proj_2, _ = raw2[:, 0:2]
assert_array_almost_equal(data_proj_1, data_proj_2)
assert_true(all(p['active'] for p in raw2.info['projs']))
# read orig file with proj. active
raw2 = Raw(fif_fname, preload=preload, proj_active=True)
data_proj_2, _ = raw2[:, 0:2]
assert_array_almost_equal(data_proj_1, data_proj_2)
assert_true(all(p['active'] for p in raw2.info['projs']))
# test that apply_projector works
raw.apply_projector()
data_proj_2, _ = raw[:, 0:2]
assert_array_almost_equal(data_proj_1, data_proj_2)
assert_array_almost_equal(data_proj_2,
np.dot(raw._projector, data_proj_2))
def test_proj():
"""Test SSP proj operations
"""
for proj_active in [True, False]:
raw = Raw(fif_fname, preload=False, proj_active=proj_active)
assert_true(all(p['active'] == proj_active for p in raw.info['projs']))
data, times = raw[0:2, :]
data1, times1 = raw[0:2]
assert_array_equal(data, data1)
assert_array_equal(times, times1)
# test adding / deleting proj
if proj_active:
assert_raises(ValueError, raw.add_proj, [],
{'remove_existing': True})
assert_raises(ValueError, raw.del_proj, 0)
else:
projs = deepcopy(raw.info['projs'])
n_proj = len(raw.info['projs'])
raw.del_proj(0)
assert_true(len(raw.info['projs']) == n_proj - 1)
raw.add_proj(projs, remove_existing=False)
assert_true(len(raw.info['projs']) == 2 * n_proj - 1)
raw.add_proj(projs, remove_existing=True)
assert_true(len(raw.info['projs']) == n_proj)
# test apply_proj() with and without preload
for preload in [True, False]:
raw = Raw(fif_fname, preload=preload, proj_active=False)
data, times = raw[:, 0:2]
raw.apply_projector()
data_proj_1 = np.dot(raw._projector, data)
# load the file again without proj
raw = Raw(fif_fname, preload=preload, proj_active=False)
# write the file with proj. activated, make sure proj has been applied
raw.save(op.join(tempdir, 'raw.fif'), proj_active=True)
raw2 = Raw(op.join(tempdir, 'raw.fif'), proj_active=False)
data_proj_2, _ = raw2[:, 0:2]
assert_array_almost_equal(data_proj_1, data_proj_2)
assert_true(all(p['active'] for p in raw2.info['projs']))
# read orig file with proj. active
raw2 = Raw(fif_fname, preload=preload, proj_active=True)
data_proj_2, _ = raw2[:, 0:2]
assert_array_almost_equal(data_proj_1, data_proj_2)
assert_true(all(p['active'] for p in raw2.info['projs']))
# test that apply_projector works
raw.apply_projector()
data_proj_2, _ = raw[:, 0:2]
assert_array_almost_equal(data_proj_1, data_proj_2)
assert_array_almost_equal(data_proj_2,
np.dot(raw._projector, data_proj_2))
def test_save():
""" Test saving raw"""
raw = Raw(fif_fname, preload=True)
assert_raises(ValueError, raw.save, fif_fname)
new_fname = op.join(op.abspath(op.curdir), 'break.fif')
raw.save(op.join(tempdir, new_fname))
new_raw = Raw(op.join(tempdir, new_fname))
assert_raises(ValueError, new_raw.save, new_fname)
new_raw.close()
os.remove(new_fname)
def test_io_raw():
"""Test IO for raw data (Neuromag + CTF)
"""
for fname in [fif_fname, ctf_fname]:
raw = Raw(fname)
nchan = raw.info['nchan']
ch_names = raw.info['ch_names']
meg_channels_idx = [k for k in range(nchan)
if ch_names[k][0] == 'M']
n_channels = 100
meg_channels_idx = meg_channels_idx[:n_channels]
start, stop = raw.time_to_index(0, 5)
data, times = raw[meg_channels_idx, start:(stop + 1)]
meg_ch_names = [ch_names[k] for k in meg_channels_idx]
# Set up pick list: MEG + STI 014 - bad channels
include = ['STI 014']
include += meg_ch_names
picks = pick_types(raw.info, meg=True, eeg=False,
stim=True, misc=True, include=include,
exclude=raw.info['bads'])
print "Number of picked channels : %d" % len(picks)
# Writing with drop_small_buffer True
raw.save('raw.fif', picks, tmin=0, tmax=4, buffer_size_sec=3,
drop_small_buffer=True)
raw2 = Raw('raw.fif')
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(times2.max() <= 3)
# Writing
raw.save('raw.fif', picks, tmin=0, tmax=5)
if fname == fif_fname:
assert_true(len(raw.info['dig']) == 146)
raw2 = Raw('raw.fif')
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_array_almost_equal(data, data2)
assert_array_almost_equal(times, times2)
assert_array_almost_equal(raw.info['dev_head_t']['trans'],
raw2.info['dev_head_t']['trans'])
assert_array_almost_equal(raw.info['sfreq'], raw2.info['sfreq'])
if fname == fif_fname:
assert_array_almost_equal(raw.info['dig'][0]['r'],
raw2.info['dig'][0]['r'])
fname = op.join(op.dirname(__file__), 'data', 'test_raw.fif')
def test_io_raw():
"""Test IO for raw data (Neuromag + CTF + gz)
"""
fnames_in = [fif_fname, fif_gz_fname, ctf_fname]
fnames_out = ["raw.fif", "raw.fif.gz", "raw.fif"]
for fname_in, fname_out in zip(fnames_in, fnames_out):
raw = Raw(fname_in)
nchan = raw.info["nchan"]
ch_names = raw.info["ch_names"]
meg_channels_idx = [k for k in range(nchan) if ch_names[k][0] == "M"]
n_channels = 100
meg_channels_idx = meg_channels_idx[:n_channels]
start, stop = raw.time_as_index([0, 5])
data, times = raw[meg_channels_idx, start : (stop + 1)]
meg_ch_names = [ch_names[k] for k in meg_channels_idx]
# Set up pick list: MEG + STI 014 - bad channels
include = ["STI 014"]
include += meg_ch_names
picks = pick_types(
raw.info, meg=True, eeg=False, stim=True, misc=True, include=include, exclude=raw.info["bads"]
)
print "Number of picked channels : %d" % len(picks)
# Writing with drop_small_buffer True
raw.save(fname_out, picks, tmin=0, tmax=4, buffer_size_sec=3, drop_small_buffer=True)
raw2 = Raw(fname_out, preload=True)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(times2.max() <= 3)
# Writing
raw.save(fname_out, picks, tmin=0, tmax=5)
if fname_in == fif_fname or fname_in == fif_fname + ".gz":
assert_true(len(raw.info["dig"]) == 146)
raw2 = Raw(fname_out)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_array_almost_equal(data, data2)
assert_array_almost_equal(times, times2)
assert_array_almost_equal(raw.info["dev_head_t"]["trans"], raw2.info["dev_head_t"]["trans"])
assert_array_almost_equal(raw.info["sfreq"], raw2.info["sfreq"])
if fname_in == fif_fname or fname_in == fif_fname + ".gz":
assert_array_almost_equal(raw.info["dig"][0]["r"], raw2.info["dig"][0]["r"])
def reconstructICA(subjectID):
subject = 'dh{:#02d}a'.format(subjectID)
logFile = open(outPath + subject + '/removedICAcomponents.log', 'w')
for block in ['1','2']:
logFile.write('Processing subject ' + subject + ', block ' + block + '\n')
subjectStub = subject + '/block' + block
raw_fname = rawPath + subjectStub + '.fif'
icaFile = rawPath + subjectStub + '_ica.fif'
outFile = outPath + subjectStub + '.fif'
if not os.path.isdir(outPath + subject):
os.makedirs(outPath + subject)
if os.path.exists(raw_fname):
raw = Raw(raw_fname, preload=True)
raw.info['bads'] = badChanLibrary[subjectID][int(block)]
ica = read_ica(icaFile)
#raw.ch_names = ica.ch_names
# Select and filter interesting channels
picks_eog = mne.pick_types(raw.info, meg=False, eeg=False, stim=False, eog=True, ecg=False)
picks_ecg = mne.pick_types(raw.info, meg=False, eeg=False, stim=False, eog=False, ecg=True)
logFile.write('Rejecting components that correlate with EOG and ECG channels...\n')
excluded_components = []
eogChannel = picks_eog[1]
eogNames = raw.ch_names[eogChannel]
eog_idx, eog_scores = ica.find_bads_eog(raw, eogNames)
for i in eog_idx:
if i not in excluded_components:
excluded_components.append(i)
logFile.write("Excluding component {}, Correlation with EOG: {} \n".format(i, eog_scores[i]))
ecgChannel = picks_ecg
ecgNames = raw.ch_names[ecgChannel]
ecg_idx, ecg_scores = ica.find_bads_ecg(raw, ecgNames)
for i in ecg_idx:
if i not in excluded_components:
excluded_components.append(i)
logFile.write("Excluding component {}, Correlation with ECG: {} \n".format(i, ecg_scores[i]))
# Save corrected fif file
if len(excluded_components) > 0:
logFile.write('Saving corrected fif file\n')
ica.apply(raw, exclude=excluded_components)
raw.save(outFile, overwrite=True)
else:
logFile.write('Nothing to do; creating symlink\n')
force_symlink(raw_fname, outFile)
logFile.close()
def test_save():
""" Test saving raw"""
raw = Raw(fif_fname, preload=False)
# can't write over file being read
assert_raises(ValueError, raw.save, fif_fname)
raw = Raw(fif_fname, preload=True)
# can't overwrite file without overwrite=True
assert_raises(IOError, raw.save, fif_fname)
# test abspath support
new_fname = op.join(op.abspath(op.curdir), 'break.fif')
raw.save(op.join(tempdir, new_fname), overwrite=True)
new_raw = Raw(op.join(tempdir, new_fname), preload=False)
assert_raises(ValueError, new_raw.save, new_fname)
# make sure we can overwrite the file we loaded when preload=True
new_raw = Raw(op.join(tempdir, new_fname), preload=True)
new_raw.save(op.join(tempdir, new_fname), overwrite=True)
os.remove(new_fname)
def test_save():
""" Test saving raw"""
raw = Raw(fif_fname, preload=False)
# can't write over file being read
assert_raises(ValueError, raw.save, fif_fname)
raw = Raw(fif_fname, preload=True)
# can't overwrite file without overwrite=True
assert_raises(IOError, raw.save, fif_fname)
# test abspath support
new_fname = op.join(op.abspath(op.curdir), 'break.fif')
raw.save(op.join(tempdir, new_fname), overwrite=True)
new_raw = Raw(op.join(tempdir, new_fname), preload=False)
assert_raises(ValueError, new_raw.save, new_fname)
# make sure we can overwrite the file we loaded when preload=True
new_raw = Raw(op.join(tempdir, new_fname), preload=True)
new_raw.save(op.join(tempdir, new_fname), overwrite=True)
os.remove(new_fname)
def test_output_formats():
"""Test saving and loading raw data using multiple formats
"""
formats = ['short', 'int', 'single', 'double']
tols = [1e-4, 1e-7, 1e-7, 1e-15]
# let's fake a raw file with different formats
raw = Raw(fif_fname, preload=True)
raw.crop(0, 1, copy=False)
temp_file = op.join(tempdir, 'raw.fif')
for ii, (format, tol) in enumerate(zip(formats, tols)):
# Let's test the overwriting error throwing while we're at it
if ii > 0:
assert_raises(IOError, raw.save, temp_file, format=format)
raw.save(temp_file, format=format, overwrite=True)
raw2 = Raw(temp_file)
raw2_data = raw2[:, :][0]
assert_allclose(raw2_data, raw._data, rtol=tol, atol=1e-25)
assert_true(raw2.orig_format == format)
def test_compensation():
"""Test compensation
"""
raw = Raw(ctf_comp_fname, compensation=None)
comp1 = make_compensator(raw.info, 3, 1, exclude_comp_chs=False)
assert_true(comp1.shape == (340, 340))
comp2 = make_compensator(raw.info, 3, 1, exclude_comp_chs=True)
assert_true(comp2.shape == (311, 340))
# make sure that changing the comp doesn't modify the original data
raw2 = Raw(ctf_comp_fname, compensation=2)
assert_true(get_current_comp(raw2.info) == 2)
fname = op.join(tempdir, 'ctf-raw.fif')
raw2.save(fname)
raw2 = Raw(fname, compensation=None)
data, _ = raw[:, :]
data2, _ = raw2[:, :]
assert_allclose(data, data2, rtol=1e-9, atol=1e-20)
for ch1, ch2 in zip(raw.info['chs'], raw2.info['chs']):
assert_true(ch1['coil_type'] == ch2['coil_type'])
def test_output_formats():
"""Test saving and loading raw data using multiple formats
"""
formats = ['short', 'int', 'single', 'double']
tols = [1e-4, 1e-7, 1e-7, 1e-15]
# let's fake a raw file with different formats
raw = Raw(fif_fname, preload=True)
raw.crop(0, 1, copy=False)
temp_file = op.join(tempdir, 'raw.fif')
for ii, (format, tol) in enumerate(zip(formats, tols)):
# Let's test the overwriting error throwing while we're at it
if ii > 0:
assert_raises(IOError, raw.save, temp_file, format=format)
raw.save(temp_file, format=format, overwrite=True)
raw2 = Raw(temp_file)
raw2_data = raw2[:, :][0]
assert_allclose(raw2_data, raw._data, rtol=tol, atol=1e-25)
assert_true(raw2.orig_format == format)
def test_compensation_raw():
"""Test Raw compensation
"""
raw1 = Raw(ctf_comp_fname, compensation=None)
assert_true(raw1.comp is None)
data1, times1 = raw1[:, :]
raw2 = Raw(ctf_comp_fname, compensation=3)
data2, times2 = raw2[:, :]
assert_true(raw2.comp is None) # unchanged (data come with grade 3)
assert_array_equal(times1, times2)
assert_array_equal(data1, data2)
raw3 = Raw(ctf_comp_fname, compensation=1)
data3, times3 = raw3[:, :]
assert_true(raw3.comp is not None)
assert_array_equal(times1, times3)
# make sure it's different with a different compensation:
assert_true(np.mean(np.abs(data1 - data3)) > 1e-12)
assert_raises(ValueError, Raw, ctf_comp_fname, compensation=33)
# Try IO with compensation
temp_file = op.join(tempdir, 'raw.fif')
raw1.save(temp_file, overwrite=True)
raw4 = Raw(temp_file)
data4, times4 = raw4[:, :]
assert_array_equal(times1, times4)
assert_array_equal(data1, data4)
# Now save the file that has modified compensation
# and make sure we can the same data as input ie. compensation
# is undone
raw3.save(temp_file, overwrite=True)
raw5 = Raw(temp_file)
data5, times5 = raw5[:, :]
assert_array_equal(times1, times5)
assert_allclose(data1, data5, rtol=1e-12, atol=1e-22)
def test_load_bad_channels():
"""Test reading/writing of bad channels
"""
# Load correctly marked file (manually done in mne_process_raw)
raw_marked = Raw(fif_bad_marked_fname)
correct_bads = raw_marked.info['bads']
raw = Raw(fif_fname)
# Make sure it starts clean
assert_array_equal(raw.info['bads'], [])
# Test normal case
raw.load_bad_channels(bad_file_works)
# Write it out, read it in, and check
raw.save(op.join(tempdir, 'foo_raw.fif'))
raw_new = Raw(op.join(tempdir, 'foo_raw.fif'))
assert_equal(correct_bads, raw_new.info['bads'])
# Reset it
raw.info['bads'] = []
# Test bad case
assert_raises(ValueError, raw.load_bad_channels, bad_file_wrong)
# Test forcing the bad case
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
raw.load_bad_channels(bad_file_wrong, force=True)
n_found = sum(['1 bad channel' in str(ww.message) for ww in w])
assert_equal(n_found, 1) # there could be other irrelevant errors
# write it out, read it in, and check
raw.save(op.join(tempdir, 'foo_raw.fif'), overwrite=True)
raw_new = Raw(op.join(tempdir, 'foo_raw.fif'))
assert_equal(correct_bads, raw_new.info['bads'])
# Check that bad channels are cleared
raw.load_bad_channels(None)
raw.save(op.join(tempdir, 'foo_raw.fif'), overwrite=True)
raw_new = Raw(op.join(tempdir, 'foo_raw.fif'))
assert_equal([], raw_new.info['bads'])
def test_load_bad_channels():
"""Test reading/writing of bad channels
"""
# Load correctly marked file (manually done in mne_process_raw)
raw_marked = Raw(fif_bad_marked_fname)
correct_bads = raw_marked.info['bads']
raw = Raw(fif_fname)
# Make sure it starts clean
assert_array_equal(raw.info['bads'], [])
# Test normal case
raw.load_bad_channels(bad_file_works)
# Write it out, read it in, and check
raw.save(op.join(tempdir, 'foo_raw.fif'))
raw_new = Raw(op.join(tempdir, 'foo_raw.fif'))
assert_equal(correct_bads, raw_new.info['bads'])
# Reset it
raw.info['bads'] = []
# Test bad case
assert_raises(ValueError, raw.load_bad_channels, bad_file_wrong)
# Test forcing the bad case
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
raw.load_bad_channels(bad_file_wrong, force=True)
n_found = sum(['1 bad channel' in str(ww.message) for ww in w])
assert_equal(n_found, 1) # there could be other irrelevant errors
# write it out, read it in, and check
raw.save(op.join(tempdir, 'foo_raw.fif'), overwrite=True)
raw_new = Raw(op.join(tempdir, 'foo_raw.fif'))
assert_equal(correct_bads, raw_new.info['bads'])
# Check that bad channels are cleared
raw.load_bad_channels(None)
raw.save(op.join(tempdir, 'foo_raw.fif'), overwrite=True)
raw_new = Raw(op.join(tempdir, 'foo_raw.fif'))
assert_equal([], raw_new.info['bads'])
def test_load_bad_channels():
"""Test reading/writing of bad channels
"""
# Load correctly marked file (manually done in mne_process_raw)
raw_marked = Raw(fif_bad_marked_fname)
correct_bads = raw_marked.info['bads']
raw = Raw(fif_fname)
# Make sure it starts clean
assert_array_equal(raw.info['bads'], [])
# Test normal case
raw.load_bad_channels(bad_file_works)
# Write it out, read it in, and check
raw.save(op.join(tempdir, 'foo_raw.fif'))
raw_new = Raw(op.join(tempdir, 'foo_raw.fif'))
assert_equal(correct_bads, raw_new.info['bads'])
# Reset it
raw.info['bads'] = []
# Test bad case
assert_raises(ValueError, raw.load_bad_channels, bad_file_wrong)
# Test forcing the bad case
with warnings.catch_warnings(record=True) as w:
raw.load_bad_channels(bad_file_wrong, force=True)
assert_equal(len(w), 1)
# write it out, read it in, and check
raw.save(op.join(tempdir, 'foo_raw.fif'))
raw_new = Raw(op.join(tempdir, 'foo_raw.fif'))
assert_equal(correct_bads, raw_new.info['bads'])
# Check that bad channels are cleared
raw.load_bad_channels(None)
raw.save(op.join(tempdir, 'foo_raw.fif'))
raw_new = Raw(op.join(tempdir, 'foo_raw.fif'))
assert_equal([], raw_new.info['bads'])
def test_load_bad_channels():
"""Test reading/writing of bad channels
"""
# Load correctly marked file (manually done in mne_process_raw)
raw_marked = Raw(fif_bad_marked_fname)
correct_bads = raw_marked.info['bads']
raw = Raw(fif_fname)
# Make sure it starts clean
assert_array_equal(raw.info['bads'], [])
# Test normal case
raw.load_bad_channels(bad_file_works)
# Write it out, read it in, and check
raw.save('foo_raw.fif')
raw_new = Raw('foo_raw.fif')
assert_equal(correct_bads, raw_new.info['bads'])
# Reset it
raw.info['bads'] = []
# Test bad case
assert_raises(ValueError, raw.load_bad_channels, bad_file_wrong)
# Test forcing the bad case
with warnings.catch_warnings(record=True) as w:
raw.load_bad_channels(bad_file_wrong, force=True)
assert_equal(len(w), 1)
# write it out, read it in, and check
raw.save('foo_raw.fif')
raw_new = Raw('foo_raw.fif')
assert_equal(correct_bads, raw_new.info['bads'])
# Check that bad channels are cleared
raw.load_bad_channels(None)
raw.save('foo_raw.fif')
raw_new = Raw('foo_raw.fif')
assert_equal([], raw_new.info['bads'])
def test_io_raw():
"""Test IO for raw data (Neuromag + CTF + gz)
"""
fnames_in = [fif_fname, fif_gz_fname, ctf_fname]
fnames_out = ['raw.fif', 'raw.fif.gz', 'raw.fif']
for fname_in, fname_out in zip(fnames_in, fnames_out):
fname_out = op.join(tempdir, fname_out)
raw = Raw(fname_in)
nchan = raw.info['nchan']
ch_names = raw.info['ch_names']
meg_channels_idx = [k for k in range(nchan)
if ch_names[k][0] == 'M']
n_channels = 100
meg_channels_idx = meg_channels_idx[:n_channels]
start, stop = raw.time_as_index([0, 5])
data, times = raw[meg_channels_idx, start:(stop + 1)]
meg_ch_names = [ch_names[k] for k in meg_channels_idx]
# Set up pick list: MEG + STI 014 - bad channels
include = ['STI 014']
include += meg_ch_names
picks = pick_types(raw.info, meg=True, eeg=False, stim=True,
misc=True, include=include, exclude='bads')
# Writing with drop_small_buffer True
raw.save(fname_out, picks, tmin=0, tmax=4, buffer_size_sec=3,
drop_small_buffer=True)
raw2 = Raw(fname_out, preload=True)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(times2.max() <= 3)
# Writing
raw.save(fname_out, picks, tmin=0, tmax=5)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_true(len(raw.info['dig']) == 146)
raw2 = Raw(fname_out)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_array_almost_equal(data, data2)
assert_array_almost_equal(times, times2)
assert_array_almost_equal(raw.info['sfreq'], raw2.info['sfreq'])
# check transformations
for trans in ['dev_head_t', 'dev_ctf_t', 'ctf_head_t']:
if raw.info[trans] is None:
assert_true(raw2.info[trans] is None)
else:
assert_array_equal(raw.info[trans]['trans'],
raw2.info[trans]['trans'])
# check transformation 'from' and 'to'
if trans.startswith('dev'):
from_id = FIFF.FIFFV_COORD_DEVICE
else:
from_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD
if trans[4:8] == 'head':
to_id = FIFF.FIFFV_COORD_HEAD
else:
to_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD
for raw_ in [raw, raw2]:
assert_true(raw_.info[trans]['from'] == from_id)
assert_true(raw_.info[trans]['to'] == to_id)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_array_almost_equal(raw.info['dig'][0]['r'],
raw2.info['dig'][0]['r'])
def test_io_raw():
"""Test IO for raw data (Neuromag + CTF + gz)
"""
fnames_in = [fif_fname, fif_gz_fname, ctf_fname]
fnames_out = ['raw.fif', 'raw.fif.gz', 'raw.fif']
for fname_in, fname_out in zip(fnames_in, fnames_out):
raw = Raw(fname_in)
nchan = raw.info['nchan']
ch_names = raw.info['ch_names']
meg_channels_idx = [k for k in range(nchan) if ch_names[k][0] == 'M']
n_channels = 100
meg_channels_idx = meg_channels_idx[:n_channels]
start, stop = raw.time_as_index([0, 5])
data, times = raw[meg_channels_idx, start:(stop + 1)]
meg_ch_names = [ch_names[k] for k in meg_channels_idx]
# Set up pick list: MEG + STI 014 - bad channels
include = ['STI 014']
include += meg_ch_names
picks = pick_types(raw.info,
meg=True,
eeg=False,
stim=True,
misc=True,
include=include,
exclude=raw.info['bads'])
print "Number of picked channels : %d" % len(picks)
# Writing with drop_small_buffer True
raw.save(fname_out,
picks,
tmin=0,
tmax=4,
buffer_size_sec=3,
drop_small_buffer=True)
raw2 = Raw(fname_out, preload=True)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(times2.max() <= 3)
# Writing
raw.save(fname_out, picks, tmin=0, tmax=5)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_true(len(raw.info['dig']) == 146)
raw2 = Raw(fname_out)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_array_almost_equal(data, data2)
assert_array_almost_equal(times, times2)
assert_array_almost_equal(raw.info['dev_head_t']['trans'],
raw2.info['dev_head_t']['trans'])
assert_array_almost_equal(raw.info['sfreq'], raw2.info['sfreq'])
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_array_almost_equal(raw.info['dig'][0]['r'],
raw2.info['dig'][0]['r'])
def test_io_raw():
"""Test IO for raw data (Neuromag + CTF + gz)
"""
# Let's construct a simple test for IO first
raw = Raw(fif_fname, preload=True)
raw.crop(0, 3.5)
# put in some data that we know the values of
data = np.random.randn(raw._data.shape[0], raw._data.shape[1])
raw._data[:, :] = data
# save it somewhere
fname = op.join(tempdir, 'test_copy_raw.fif')
raw.save(fname, buffer_size_sec=1.0)
# read it in, make sure the whole thing matches
raw = Raw(fname)
assert_true(np.allclose(data, raw[:, :][0], 1e-6, 1e-20))
# let's read portions across the 1-sec tag boundary, too
inds = raw.time_as_index([1.75, 2.25])
sl = slice(inds[0], inds[1])
assert_true(np.allclose(data[:, sl], raw[:, sl][0], 1e-6, 1e-20))
# now let's do some real I/O
fnames_in = [fif_fname, fif_gz_fname, ctf_fname]
fnames_out = ['raw.fif', 'raw.fif.gz', 'raw.fif']
for fname_in, fname_out in zip(fnames_in, fnames_out):
fname_out = op.join(tempdir, fname_out)
raw = Raw(fname_in)
nchan = raw.info['nchan']
ch_names = raw.info['ch_names']
meg_channels_idx = [k for k in range(nchan)
if ch_names[k][0] == 'M']
n_channels = 100
meg_channels_idx = meg_channels_idx[:n_channels]
start, stop = raw.time_as_index([0, 5])
data, times = raw[meg_channels_idx, start:(stop + 1)]
meg_ch_names = [ch_names[k] for k in meg_channels_idx]
# Set up pick list: MEG + STI 014 - bad channels
include = ['STI 014']
include += meg_ch_names
picks = pick_types(raw.info, meg=True, eeg=False, stim=True,
misc=True, ref_meg=True, include=include,
exclude='bads')
# Writing with drop_small_buffer True
raw.save(fname_out, picks, tmin=0, tmax=4, buffer_size_sec=3,
drop_small_buffer=True, overwrite=True)
raw2 = Raw(fname_out, preload=True)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(times2.max() <= 3)
# Writing
raw.save(fname_out, picks, tmin=0, tmax=5, overwrite=True)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_true(len(raw.info['dig']) == 146)
raw2 = Raw(fname_out)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(np.allclose(data, data2, 1e-6, 1e-20))
assert_allclose(times, times2)
assert_allclose(raw.info['sfreq'], raw2.info['sfreq'], rtol=1e-5)
# check transformations
for trans in ['dev_head_t', 'dev_ctf_t', 'ctf_head_t']:
if raw.info[trans] is None:
assert_true(raw2.info[trans] is None)
else:
assert_array_equal(raw.info[trans]['trans'],
raw2.info[trans]['trans'])
# check transformation 'from' and 'to'
if trans.startswith('dev'):
from_id = FIFF.FIFFV_COORD_DEVICE
else:
from_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD
if trans[4:8] == 'head':
to_id = FIFF.FIFFV_COORD_HEAD
else:
to_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD
for raw_ in [raw, raw2]:
assert_true(raw_.info[trans]['from'] == from_id)
assert_true(raw_.info[trans]['to'] == to_id)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_allclose(raw.info['dig'][0]['r'], raw2.info['dig'][0]['r'])
def test_multiple_files():
"""Test loading multiple files simultaneously
"""
# split file
raw = Raw(fif_fname, preload=True)
split_size = 10. # in seconds
sfreq = raw.info['sfreq']
nsamp = (raw.last_samp - raw.first_samp)
tmins = np.round(np.arange(0., nsamp, split_size * sfreq))
tmaxs = np.concatenate((tmins[1:] - 1, [nsamp]))
tmaxs /= sfreq
tmins /= sfreq
# going in reverse order so the last fname is the first file (need later)
raws = [None] * len(tmins)
for ri in range(len(tmins) - 1, -1, -1):
fname = op.join(tempdir, 'test_raw_split-%d_raw.fif' % ri)
raw.save(fname, tmin=tmins[ri], tmax=tmaxs[ri])
raws[ri] = Raw(fname)
events = [find_events(r) for r in raws]
last_samps = [r.last_samp for r in raws]
first_samps = [r.first_samp for r in raws]
# test concatenation of split file
all_raw_1 = concatenate_raws(raws, preload=False)
assert_true(raw.first_samp == all_raw_1.first_samp)
assert_true(raw.last_samp == all_raw_1.last_samp)
assert_array_almost_equal(raw[:, :][0], all_raw_1[:, :][0])
raws[0] = Raw(fname)
all_raw_2 = concatenate_raws(raws, preload=True)
assert_array_almost_equal(raw[:, :][0], all_raw_2[:, :][0])
# test proper event treatment for split files
events = concatenate_events(events, first_samps, last_samps)
events2 = find_events(all_raw_2)
assert_array_equal(events, events2)
# test various methods of combining files
n_combos = 9
raw_combos = [None] * n_combos
raw = Raw(fif_fname, preload=True)
raw_combos[0] = Raw([fif_fname, fif_fname], preload=True)
raw_combos[1] = Raw([fif_fname, fif_fname], preload=False)
raw_combos[2] = Raw([fif_fname, fif_fname], preload='memmap8.dat')
assert_raises(ValueError, Raw, [fif_fname, ctf_fname])
assert_raises(ValueError, Raw, [fif_fname, fif_bad_marked_fname])
n_times = len(raw._times)
assert_true(raw[:, :][0].shape[1] * 2 == raw_combos[0][:, :][0].shape[1])
assert_true(raw_combos[0][:, :][0].shape[1] == len(raw_combos[0]._times))
# with all data preloaded, result should be preloaded
raw_combos[3] = Raw(fif_fname, preload=True)
raw_combos[3].append(Raw(fif_fname, preload=True))
assert_true(raw_combos[0]._preloaded == True)
# with any data not preloaded, don't set result as preloaded
raw_combos[4] = concatenate_raws([Raw(fif_fname, preload=True),
Raw(fif_fname, preload=False)])
assert_true(raw_combos[1]._preloaded == False)
assert_array_equal(find_events(raw_combos[4]), find_events(raw_combos[0]))
# user should be able to force data to be preloaded upon concat
raw_combos[5] = concatenate_raws([Raw(fif_fname, preload=False),
Raw(fif_fname, preload=True)],
preload=True)
assert_true(raw_combos[2]._preloaded == True)
raw_combos[6] = concatenate_raws([Raw(fif_fname, preload=False),
Raw(fif_fname, preload=True)],
preload='memmap3.dat')
raw_combos[7] = concatenate_raws([Raw(fif_fname, preload=True),
Raw(fif_fname, preload=True)],
preload='memmap4.dat')
raw_combos[8] = concatenate_raws([Raw(fif_fname, preload=False),
Raw(fif_fname, preload=False)],
preload='memmap5.dat')
# make sure that all our data match
times = range(0, 2 * n_times, 999)
# add potentially problematic points
times.extend([n_times - 1, n_times, 2 * n_times - 1])
for ti in times: # let's do a subset of points for speed
orig = raw[:, ti % n_times][0]
for raw_combo in raw_combos:
# these are almost_equals because of possible dtype differences
assert_array_almost_equal(orig, raw_combo[:, ti][0])
# verify that combining raws with different projectors throws an exception
raw.add_proj([], remove_existing=True)
assert_raises(ValueError, raw.append, Raw(fif_fname, preload=True))
# now test event treatment for concatenated raw files
events = [find_events(raw), find_events(raw)]
last_samps = [raw.last_samp, raw.last_samp]
first_samps = [raw.first_samp, raw.first_samp]
events = concatenate_events(events, first_samps, last_samps)
events2 = find_events(raw_combos[0])
assert_array_equal(events, events2)
# check out the len method
assert_true(len(raw) == raw.n_times)
assert_true(len(raw) == raw.last_samp - raw.first_samp + 1)
def test_compute_proj():
"""Test SSP computation"""
event_id, tmin, tmax = 1, -0.2, 0.3
raw = Raw(raw_fname, preload=True)
events = read_events(event_fname)
exclude = []
bad_ch = 'MEG 2443'
picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False,
exclude=exclude)
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=None, proj=False)
evoked = epochs.average()
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1)
write_proj('proj.fif.gz', projs)
for p_fname in [proj_fname, proj_gz_fname, 'proj.fif.gz']:
projs2 = read_proj(p_fname)
assert_true(len(projs) == len(projs2))
for p1, p2 in zip(projs, projs2):
assert_true(p1['desc'] == p2['desc'])
assert_true(p1['data']['col_names'] == p2['data']['col_names'])
assert_true(p1['active'] == p2['active'])
# compare with sign invariance
p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0])
p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0])
if bad_ch in p1['data']['col_names']:
bad = p1['data']['col_names'].index('MEG 2443')
mask = np.ones(p1_data.size, dtype=np.bool)
mask[bad] = False
p1_data = p1_data[:, mask]
p2_data = p2_data[:, mask]
corr = np.corrcoef(p1_data, p2_data)[0, 1]
assert_array_almost_equal(corr, 1.0, 5)
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[])
assert_true(nproj == 2)
assert_true(U.shape[1] == 2)
# test that you can save them
epochs.info['projs'] += projs
evoked = epochs.average()
evoked.save('foo.fif')
projs = read_proj(proj_fname)
projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0)
# XXX : test something
# test parallelization
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=2)
projs = activate_proj(projs)
proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[])
assert_array_equal(proj, proj_par)
# Test that the raw projectors work
for ii in (1, 2, 4, 8, 12, 24):
raw = Raw(raw_fname)
projs = compute_proj_raw(raw, duration=ii-0.1, n_grad=1, n_mag=1,
n_eeg=0)
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[])
assert_true(nproj == 2)
assert_true(U.shape[1] == 2)
# test that you can save them
raw.info['projs'] += projs
raw.save('foo_%d_raw.fif' % ii)
# Test that purely continuous (no duration) raw projection works
raw = Raw(raw_fname)
projs = compute_proj_raw(raw, duration=None, n_grad=1, n_mag=1, n_eeg=0)
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[])
assert_true(nproj == 2)
assert_true(U.shape[1] == 2)
# test that you can save them
raw.info['projs'] += projs
raw.save('foo_rawproj_continuous_raw.fif')
def test_multiple_files():
"""Test loading multiple files simultaneously
"""
# split file
raw = Raw(fif_fname, preload=True)
split_size = 10. # in seconds
sfreq = raw.info['sfreq']
nsamp = (raw.last_samp - raw.first_samp)
tmins = np.round(np.arange(0., nsamp, split_size * sfreq))
tmaxs = np.concatenate((tmins[1:] - 1, [nsamp]))
tmaxs /= sfreq
tmins /= sfreq
# going in reverse order so the last fname is the first file (need later)
raws = [None] * len(tmins)
for ri in range(len(tmins) - 1, -1, -1):
fname = op.join(tempdir, 'test_raw_split-%d_raw.fif' % ri)
raw.save(fname, tmin=tmins[ri], tmax=tmaxs[ri])
raws[ri] = Raw(fname)
events = [find_events(r, stim_channel='STI 014') for r in raws]
last_samps = [r.last_samp for r in raws]
first_samps = [r.first_samp for r in raws]
# test concatenation of split file
all_raw_1 = concatenate_raws(raws, preload=False)
assert_true(raw.first_samp == all_raw_1.first_samp)
assert_true(raw.last_samp == all_raw_1.last_samp)
assert_allclose(raw[:, :][0], all_raw_1[:, :][0])
raws[0] = Raw(fname)
all_raw_2 = concatenate_raws(raws, preload=True)
assert_allclose(raw[:, :][0], all_raw_2[:, :][0])
# test proper event treatment for split files
events = concatenate_events(events, first_samps, last_samps)
events2 = find_events(all_raw_2, stim_channel='STI 014')
assert_array_equal(events, events2)
# test various methods of combining files
n_combos = 9
raw_combos = [None] * n_combos
raw = Raw(fif_fname, preload=True)
raw_combos[0] = Raw([fif_fname, fif_fname], preload=True)
raw_combos[1] = Raw([fif_fname, fif_fname], preload=False)
raw_combos[2] = Raw([fif_fname, fif_fname], preload='memmap8.dat')
assert_raises(ValueError, Raw, [fif_fname, ctf_fname])
assert_raises(ValueError, Raw, [fif_fname, fif_bad_marked_fname])
n_times = len(raw._times)
assert_true(raw[:, :][0].shape[1] * 2 == raw_combos[0][:, :][0].shape[1])
assert_true(raw_combos[0][:, :][0].shape[1] == len(raw_combos[0]._times))
# with all data preloaded, result should be preloaded
raw_combos[3] = Raw(fif_fname, preload=True)
raw_combos[3].append(Raw(fif_fname, preload=True))
assert_true(raw_combos[0]._preloaded == True)
assert_true(len(raw_combos[3]._times) == raw_combos[3]._data.shape[1])
# with any data not preloaded, don't set result as preloaded
raw_combos[4] = concatenate_raws(
[Raw(fif_fname, preload=True),
Raw(fif_fname, preload=False)])
assert_true(raw_combos[1]._preloaded == False)
assert_array_equal(find_events(raw_combos[4], stim_channel='STI 014'),
find_events(raw_combos[0], stim_channel='STI 014'))
# user should be able to force data to be preloaded upon concat
raw_combos[5] = concatenate_raws(
[Raw(fif_fname, preload=False),
Raw(fif_fname, preload=True)],
preload=True)
assert_true(raw_combos[2]._preloaded == True)
raw_combos[6] = concatenate_raws(
[Raw(fif_fname, preload=False),
Raw(fif_fname, preload=True)],
preload='memmap3.dat')
raw_combos[7] = concatenate_raws(
[Raw(fif_fname, preload=True),
Raw(fif_fname, preload=True)],
preload='memmap4.dat')
raw_combos[8] = concatenate_raws(
[Raw(fif_fname, preload=False),
Raw(fif_fname, preload=False)],
preload='memmap5.dat')
# make sure that all our data match
times = range(0, 2 * n_times, 999)
# add potentially problematic points
times.extend([n_times - 1, n_times, 2 * n_times - 1])
for ti in times: # let's do a subset of points for speed
orig = raw[:, ti % n_times][0]
for raw_combo in raw_combos:
# these are almost_equals because of possible dtype differences
assert_allclose(orig, raw_combo[:, ti][0])
# verify that combining raws with different projectors throws an exception
raw.add_proj([], remove_existing=True)
assert_raises(ValueError, raw.append, Raw(fif_fname, preload=True))
# now test event treatment for concatenated raw files
events = [
find_events(raw, stim_channel='STI 014'),
find_events(raw, stim_channel='STI 014')
]
last_samps = [raw.last_samp, raw.last_samp]
first_samps = [raw.first_samp, raw.first_samp]
events = concatenate_events(events, first_samps, last_samps)
events2 = find_events(raw_combos[0], stim_channel='STI 014')
assert_array_equal(events, events2)
# check out the len method
assert_true(len(raw) == raw.n_times)
assert_true(len(raw) == raw.last_samp - raw.first_samp + 1)
def test_io_raw():
"""Test IO for raw data (Neuromag + CTF + gz)
"""
# Let's construct a simple test for IO first
raw = Raw(fif_fname, preload=True)
raw.crop(0, 3.5)
# put in some data that we know the values of
data = np.random.randn(raw._data.shape[0], raw._data.shape[1])
raw._data[:, :] = data
# save it somewhere
fname = op.join(tempdir, 'test_copy_raw.fif')
raw.save(fname, buffer_size_sec=1.0)
# read it in, make sure the whole thing matches
raw = Raw(fname)
assert_true(np.allclose(data, raw[:, :][0], 1e-6, 1e-20))
# let's read portions across the 1-sec tag boundary, too
inds = raw.time_as_index([1.75, 2.25])
sl = slice(inds[0], inds[1])
assert_true(np.allclose(data[:, sl], raw[:, sl][0], 1e-6, 1e-20))
# now let's do some real I/O
fnames_in = [fif_fname, fif_gz_fname, ctf_fname]
fnames_out = ['raw.fif', 'raw.fif.gz', 'raw.fif']
for fname_in, fname_out in zip(fnames_in, fnames_out):
fname_out = op.join(tempdir, fname_out)
raw = Raw(fname_in)
nchan = raw.info['nchan']
ch_names = raw.info['ch_names']
meg_channels_idx = [k for k in range(nchan) if ch_names[k][0] == 'M']
n_channels = 100
meg_channels_idx = meg_channels_idx[:n_channels]
start, stop = raw.time_as_index([0, 5])
data, times = raw[meg_channels_idx, start:(stop + 1)]
meg_ch_names = [ch_names[k] for k in meg_channels_idx]
# Set up pick list: MEG + STI 014 - bad channels
include = ['STI 014']
include += meg_ch_names
picks = pick_types(raw.info,
meg=True,
eeg=False,
stim=True,
misc=True,
ref_meg=True,
include=include,
exclude='bads')
# Writing with drop_small_buffer True
raw.save(fname_out,
picks,
tmin=0,
tmax=4,
buffer_size_sec=3,
drop_small_buffer=True,
overwrite=True)
raw2 = Raw(fname_out, preload=True)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(times2.max() <= 3)
# Writing
raw.save(fname_out, picks, tmin=0, tmax=5, overwrite=True)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_true(len(raw.info['dig']) == 146)
raw2 = Raw(fname_out)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(np.allclose(data, data2, 1e-6, 1e-20))
assert_allclose(times, times2)
assert_allclose(raw.info['sfreq'], raw2.info['sfreq'], rtol=1e-5)
# check transformations
for trans in ['dev_head_t', 'dev_ctf_t', 'ctf_head_t']:
if raw.info[trans] is None:
assert_true(raw2.info[trans] is None)
else:
assert_array_equal(raw.info[trans]['trans'],
raw2.info[trans]['trans'])
# check transformation 'from' and 'to'
if trans.startswith('dev'):
from_id = FIFF.FIFFV_COORD_DEVICE
else:
from_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD
if trans[4:8] == 'head':
to_id = FIFF.FIFFV_COORD_HEAD
else:
to_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD
for raw_ in [raw, raw2]:
assert_true(raw_.info[trans]['from'] == from_id)
assert_true(raw_.info[trans]['to'] == to_id)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_allclose(raw.info['dig'][0]['r'], raw2.info['dig'][0]['r'])
def test_multiple_files():
"""Test loading multiple files simultaneously
"""
# split file
raw = Raw(fif_fname, preload=True).crop(0, 10)
split_size = 3. # in seconds
sfreq = raw.info['sfreq']
nsamp = (raw.last_samp - raw.first_samp)
tmins = np.round(np.arange(0., nsamp, split_size * sfreq))
tmaxs = np.concatenate((tmins[1:] - 1, [nsamp]))
tmaxs /= sfreq
tmins /= sfreq
assert_equal(raw.n_times, len(raw._times))
# going in reverse order so the last fname is the first file (need later)
raws = [None] * len(tmins)
for ri in range(len(tmins) - 1, -1, -1):
fname = op.join(tempdir, 'test_raw_split-%d_raw.fif' % ri)
raw.save(fname, tmin=tmins[ri], tmax=tmaxs[ri])
raws[ri] = Raw(fname)
events = [find_events(r, stim_channel='STI 014') for r in raws]
last_samps = [r.last_samp for r in raws]
first_samps = [r.first_samp for r in raws]
# test concatenation of split file
all_raw_1 = concatenate_raws(raws, preload=False)
assert_true(raw.first_samp == all_raw_1.first_samp)
assert_true(raw.last_samp == all_raw_1.last_samp)
assert_allclose(raw[:, :][0], all_raw_1[:, :][0])
raws[0] = Raw(fname)
all_raw_2 = concatenate_raws(raws, preload=True)
assert_allclose(raw[:, :][0], all_raw_2[:, :][0])
# test proper event treatment for split files
events = concatenate_events(events, first_samps, last_samps)
events2 = find_events(all_raw_2, stim_channel='STI 014')
assert_array_equal(events, events2)
# test various methods of combining files
raw = Raw(fif_fname, preload=True)
n_times = len(raw._times)
# make sure that all our data match
times = list(range(0, 2 * n_times, 999))
# add potentially problematic points
times.extend([n_times - 1, n_times, 2 * n_times - 1])
raw_combo0 = Raw([fif_fname, fif_fname], preload=True)
_compare_combo(raw, raw_combo0, times, n_times)
raw_combo = Raw([fif_fname, fif_fname], preload=False)
_compare_combo(raw, raw_combo, times, n_times)
raw_combo = Raw([fif_fname, fif_fname], preload='memmap8.dat')
_compare_combo(raw, raw_combo, times, n_times)
assert_raises(ValueError, Raw, [fif_fname, ctf_fname])
assert_raises(ValueError, Raw, [fif_fname, fif_bad_marked_fname])
assert_true(raw[:, :][0].shape[1] * 2 == raw_combo0[:, :][0].shape[1])
assert_true(raw_combo0[:, :][0].shape[1] == len(raw_combo0._times))
# with all data preloaded, result should be preloaded
raw_combo = Raw(fif_fname, preload=True)
raw_combo.append(Raw(fif_fname, preload=True))
assert_true(raw_combo._preloaded is True)
assert_true(len(raw_combo._times) == raw_combo._data.shape[1])
_compare_combo(raw, raw_combo, times, n_times)
# with any data not preloaded, don't set result as preloaded
raw_combo = concatenate_raws([Raw(fif_fname, preload=True),
Raw(fif_fname, preload=False)])
assert_true(raw_combo._preloaded is False)
assert_array_equal(find_events(raw_combo, stim_channel='STI 014'),
find_events(raw_combo0, stim_channel='STI 014'))
_compare_combo(raw, raw_combo, times, n_times)
# user should be able to force data to be preloaded upon concat
raw_combo = concatenate_raws([Raw(fif_fname, preload=False),
Raw(fif_fname, preload=True)],
preload=True)
assert_true(raw_combo._preloaded is True)
_compare_combo(raw, raw_combo, times, n_times)
raw_combo = concatenate_raws([Raw(fif_fname, preload=False),
Raw(fif_fname, preload=True)],
preload='memmap3.dat')
_compare_combo(raw, raw_combo, times, n_times)
raw_combo = concatenate_raws([Raw(fif_fname, preload=True),
Raw(fif_fname, preload=True)],
preload='memmap4.dat')
_compare_combo(raw, raw_combo, times, n_times)
raw_combo = concatenate_raws([Raw(fif_fname, preload=False),
Raw(fif_fname, preload=False)],
preload='memmap5.dat')
_compare_combo(raw, raw_combo, times, n_times)
# verify that combining raws with different projectors throws an exception
raw.add_proj([], remove_existing=True)
assert_raises(ValueError, raw.append, Raw(fif_fname, preload=True))
# now test event treatment for concatenated raw files
events = [find_events(raw, stim_channel='STI 014'),
find_events(raw, stim_channel='STI 014')]
last_samps = [raw.last_samp, raw.last_samp]
first_samps = [raw.first_samp, raw.first_samp]
events = concatenate_events(events, first_samps, last_samps)
events2 = find_events(raw_combo0, stim_channel='STI 014')
assert_array_equal(events, events2)
# check out the len method
assert_true(len(raw) == raw.n_times)
assert_true(len(raw) == raw.last_samp - raw.first_samp + 1)
