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_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_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: 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_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)