def test_all(): """Test maxwell filter using all options.""" raw_fnames = (raw_fname, raw_fname, erm_fname, sample_fname) sss_fnames = (sss_st1FineCalCrossTalkRegIn_fname, sss_st1FineCalCrossTalkRegInTransSample_fname, sss_erm_st1FineCalCrossTalkRegIn_fname, sss_samp_fname) fine_cals = (fine_cal_fname, fine_cal_fname, fine_cal_fname, fine_cal_mgh_fname) coord_frames = ('head', 'head', 'meg', 'head') ctcs = (ctc_fname, ctc_fname, ctc_fname, ctc_mgh_fname) mins = (3.5, 3.5, 1.2, 0.9) meds = (10.8, 10.4, 3.2, 6.) st_durs = (1., 1., 1., None) destinations = (None, sample_fname, None, None) origins = (mf_head_origin, mf_head_origin, mf_meg_origin, mf_head_origin) for ii, rf in enumerate(raw_fnames): raw = read_crop(rf, (0., 1.)) with pytest.warns(None): # sometimes the fit is bad sss_py = maxwell_filter( raw, calibration=fine_cals[ii], cross_talk=ctcs[ii], st_duration=st_durs[ii], coord_frame=coord_frames[ii], destination=destinations[ii], origin=origins[ii]) sss_mf = read_crop(sss_fnames[ii]) assert_meg_snr(sss_py, sss_mf, mins[ii], meds[ii], msg=rf)
def test_chpi_subtraction(): """Test subtraction of cHPI signals.""" raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes', preload=True) raw.info['bads'] = ['MEG0111'] raw.del_proj() with catch_logging() as log: filter_chpi(raw, include_line=False, verbose=True) assert 'No average EEG' not in log.getvalue() assert '5 cHPI' in log.getvalue() # MaxFilter doesn't do quite as well as our algorithm with the last bit raw.crop(0, 16) # remove cHPI status chans raw_c = read_raw_fif(sss_hpisubt_fname).crop(0, 16).load_data() raw_c.pick_types( meg=True, eeg=True, eog=True, ecg=True, stim=True, misc=True) assert_meg_snr(raw, raw_c, 143, 624) # Degenerate cases raw_nohpi = read_raw_fif(test_fif_fname, preload=True) pytest.raises(RuntimeError, filter_chpi, raw_nohpi) # When MaxFliter downsamples, like:: # $ maxfilter -nosss -ds 2 -f test_move_anon_raw.fif \ # -o test_move_anon_ds2_raw.fif # it can strip out some values of info, which we emulate here: raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes') raw = raw.crop(0, 1).load_data().resample(600., npad='auto') raw.info['lowpass'] = 200. del raw.info['maxshield'] del raw.info['hpi_results'][0]['moments'] del raw.info['hpi_subsystem']['event_channel'] with catch_logging() as log: filter_chpi(raw, verbose=True) pytest.raises(ValueError, filter_chpi, raw, t_window=-1) assert '2 cHPI' in log.getvalue()
def test_all(): """Test maxwell filter using all options.""" raw_fnames = (raw_fname, raw_fname, erm_fname, sample_fname) sss_fnames = (sss_st1FineCalCrossTalkRegIn_fname, sss_st1FineCalCrossTalkRegInTransSample_fname, sss_erm_st1FineCalCrossTalkRegIn_fname, sss_samp_fname) fine_cals = (fine_cal_fname, fine_cal_fname, fine_cal_fname, fine_cal_mgh_fname) coord_frames = ('head', 'head', 'meg', 'head') ctcs = (ctc_fname, ctc_fname, ctc_fname, ctc_mgh_fname) mins = (3.5, 3.5, 1.2, 0.9) meds = (10.8, 10.4, 3.2, 6.) st_durs = (1., 1., 1., None) destinations = (None, sample_fname, None, None) origins = (mf_head_origin, mf_head_origin, mf_meg_origin, mf_head_origin) for ii, rf in enumerate(raw_fnames): raw = read_crop(rf, (0., 1.)) with pytest.warns(None): # sometimes the fit is bad sss_py = maxwell_filter( raw, calibration=fine_cals[ii], cross_talk=ctcs[ii], st_duration=st_durs[ii], coord_frame=coord_frames[ii], destination=destinations[ii], origin=origins[ii]) sss_mf = read_crop(sss_fnames[ii]) assert_meg_snr(sss_py, sss_mf, mins[ii], meds[ii], msg=rf)
def test_chpi_subtraction(): """Test subtraction of cHPI signals.""" raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes', preload=True) raw.info['bads'] = ['MEG0111'] raw.del_proj() with catch_logging() as log: filter_chpi(raw, include_line=False, verbose=True) assert 'No average EEG' not in log.getvalue() assert '5 cHPI' in log.getvalue() # MaxFilter doesn't do quite as well as our algorithm with the last bit raw.crop(0, 16) # remove cHPI status chans raw_c = read_raw_fif(sss_hpisubt_fname).crop(0, 16).load_data() raw_c.pick_types( meg=True, eeg=True, eog=True, ecg=True, stim=True, misc=True) assert_meg_snr(raw, raw_c, 143, 624) # Degenerate cases raw_nohpi = read_raw_fif(test_fif_fname, preload=True) pytest.raises(RuntimeError, filter_chpi, raw_nohpi) # When MaxFliter downsamples, like:: # $ maxfilter -nosss -ds 2 -f test_move_anon_raw.fif \ # -o test_move_anon_ds2_raw.fif # it can strip out some values of info, which we emulate here: raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes') raw = raw.crop(0, 1).load_data().resample(600., npad='auto') raw.info['lowpass'] = 200. del raw.info['maxshield'] del raw.info['hpi_results'][0]['moments'] del raw.info['hpi_subsystem']['event_channel'] with catch_logging() as log: filter_chpi(raw, verbose=True) pytest.raises(ValueError, filter_chpi, raw, t_window=-1) assert '2 cHPI' in log.getvalue()
def test_bads_reconstruction(): """Test Maxwell filter reconstruction of bad channels.""" raw = read_crop(raw_fname, (0., 1.)) raw.info['bads'] = bads with use_coil_def(elekta_def_fname): raw_sss = maxwell_filter(raw, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, read_crop(sss_bad_recon_fname), 300.)
def test_bads_reconstruction(): """Test Maxwell filter reconstruction of bad channels.""" raw = read_crop(raw_fname, (0., 1.)) raw.info['bads'] = bads with use_coil_def(elekta_def_fname): raw_sss = maxwell_filter(raw, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, read_crop(sss_bad_recon_fname), 300.)
def test_spatiotemporal_only(): """Test tSSS-only processing.""" # Load raw testing data tmax = 0.5 raw = read_crop(raw_fname, (0, tmax)).load_data() picks = pick_types(raw.info, meg=True, exclude='bads')[::2] raw.pick_channels([raw.ch_names[pick] for pick in picks]) mag_picks = pick_types(raw.info, meg='mag', exclude=()) power = np.sqrt(np.sum(raw[mag_picks][0] ** 2)) # basics raw_tsss = maxwell_filter(raw, st_duration=tmax / 2., st_only=True) assert len(raw.info['projs']) == len(raw_tsss.info['projs']) assert _compute_rank_int(raw_tsss, proj=False) == len(picks) _assert_shielding(raw_tsss, power, 9) # with movement head_pos = read_head_pos(pos_fname) raw_tsss = maxwell_filter(raw, st_duration=tmax / 2., st_only=True, head_pos=head_pos) assert _compute_rank_int(raw_tsss, proj=False) == len(picks) _assert_shielding(raw_tsss, power, 9) with pytest.warns(RuntimeWarning, match='st_fixed'): raw_tsss = maxwell_filter(raw, st_duration=tmax / 2., st_only=True, head_pos=head_pos, st_fixed=False) assert _compute_rank_int(raw_tsss, proj=False) == len(picks) _assert_shielding(raw_tsss, power, 9) # should do nothing raw_tsss = maxwell_filter(raw, st_duration=tmax, st_correlation=1., st_only=True) assert_allclose(raw[:][0], raw_tsss[:][0]) # degenerate pytest.raises(ValueError, maxwell_filter, raw, st_only=True) # no ST # two-step process equivalent to single-step process raw_tsss = maxwell_filter(raw, st_duration=tmax, st_only=True) raw_tsss = maxwell_filter(raw_tsss) raw_tsss_2 = maxwell_filter(raw, st_duration=tmax) assert_meg_snr(raw_tsss, raw_tsss_2, 1e5) # now also with head movement, and a bad MEG channel assert len(raw.info['bads']) == 0 bads = [raw.ch_names[0]] raw.info['bads'] = list(bads) raw_tsss = maxwell_filter(raw, st_duration=tmax, st_only=True, head_pos=head_pos) assert raw.info['bads'] == bads assert raw_tsss.info['bads'] == bads # don't reset raw_tsss = maxwell_filter(raw_tsss, head_pos=head_pos) assert raw_tsss.info['bads'] == [] # do reset MEG bads raw_tsss_2 = maxwell_filter(raw, st_duration=tmax, head_pos=head_pos) assert raw_tsss_2.info['bads'] == [] assert_meg_snr(raw_tsss, raw_tsss_2, 1e5)
def test_spatiotemporal_only(): """Test tSSS-only processing.""" # Load raw testing data tmax = 0.5 raw = read_crop(raw_fname, (0, tmax)).load_data() picks = pick_types(raw.info, meg=True, exclude='bads')[::2] raw.pick_channels([raw.ch_names[pick] for pick in picks]) mag_picks = pick_types(raw.info, meg='mag', exclude=()) power = np.sqrt(np.sum(raw[mag_picks][0] ** 2)) # basics raw_tsss = maxwell_filter(raw, st_duration=tmax / 2., st_only=True) assert len(raw.info['projs']) == len(raw_tsss.info['projs']) assert _compute_rank_int(raw_tsss, proj=False) == len(picks) _assert_shielding(raw_tsss, power, 9) # with movement head_pos = read_head_pos(pos_fname) raw_tsss = maxwell_filter(raw, st_duration=tmax / 2., st_only=True, head_pos=head_pos) assert _compute_rank_int(raw_tsss, proj=False) == len(picks) _assert_shielding(raw_tsss, power, 9) with pytest.warns(RuntimeWarning, match='st_fixed'): raw_tsss = maxwell_filter(raw, st_duration=tmax / 2., st_only=True, head_pos=head_pos, st_fixed=False) assert _compute_rank_int(raw_tsss, proj=False) == len(picks) _assert_shielding(raw_tsss, power, 9) # should do nothing raw_tsss = maxwell_filter(raw, st_duration=tmax, st_correlation=1., st_only=True) assert_allclose(raw[:][0], raw_tsss[:][0]) # degenerate pytest.raises(ValueError, maxwell_filter, raw, st_only=True) # no ST # two-step process equivalent to single-step process raw_tsss = maxwell_filter(raw, st_duration=tmax, st_only=True) raw_tsss = maxwell_filter(raw_tsss) raw_tsss_2 = maxwell_filter(raw, st_duration=tmax) assert_meg_snr(raw_tsss, raw_tsss_2, 1e5) # now also with head movement, and a bad MEG channel assert len(raw.info['bads']) == 0 bads = [raw.ch_names[0]] raw.info['bads'] = list(bads) raw_tsss = maxwell_filter(raw, st_duration=tmax, st_only=True, head_pos=head_pos) assert raw.info['bads'] == bads assert raw_tsss.info['bads'] == bads # don't reset raw_tsss = maxwell_filter(raw_tsss, head_pos=head_pos) assert raw_tsss.info['bads'] == [] # do reset MEG bads raw_tsss_2 = maxwell_filter(raw, st_duration=tmax, head_pos=head_pos) assert raw_tsss_2.info['bads'] == [] assert_meg_snr(raw_tsss, raw_tsss_2, 1e5)
def test_cross_talk(tmpdir): """Test Maxwell filter cross-talk cancellation.""" raw = read_crop(raw_fname, (0., 1.)) raw.info['bads'] = bads sss_ctc = read_crop(sss_ctc_fname) with use_coil_def(elekta_def_fname): raw_sss = maxwell_filter(raw, cross_talk=ctc_fname, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, sss_ctc, 275.) py_ctc = raw_sss.info['proc_history'][0]['max_info']['sss_ctc'] assert (len(py_ctc) > 0) pytest.raises(ValueError, maxwell_filter, raw, cross_talk=raw) pytest.raises(ValueError, maxwell_filter, raw, cross_talk=raw_fname) mf_ctc = sss_ctc.info['proc_history'][0]['max_info']['sss_ctc'] del mf_ctc['block_id'] # we don't write this assert isinstance(py_ctc['decoupler'], sparse.csc_matrix) assert isinstance(mf_ctc['decoupler'], sparse.csc_matrix) assert_array_equal(py_ctc['decoupler'].toarray(), mf_ctc['decoupler'].toarray()) # I/O roundtrip tempdir = str(tmpdir) fname = op.join(tempdir, 'test_sss_raw.fif') sss_ctc.save(fname) sss_ctc_read = read_raw_fif(fname) mf_ctc_read = sss_ctc_read.info['proc_history'][0]['max_info']['sss_ctc'] assert isinstance(mf_ctc_read['decoupler'], sparse.csc_matrix) assert_array_equal(mf_ctc_read['decoupler'].toarray(), mf_ctc['decoupler'].toarray()) assert object_diff(py_ctc, mf_ctc) == '' raw_ctf = read_crop(fname_ctf_raw).apply_gradient_compensation(0) pytest.raises(ValueError, maxwell_filter, raw_ctf) # cannot fit headshape raw_sss = maxwell_filter(raw_ctf, origin=(0., 0., 0.04)) _assert_n_free(raw_sss, 68) raw_sss = maxwell_filter(raw_ctf, origin=(0., 0., 0.04), ignore_ref=True) _assert_n_free(raw_sss, 70) raw_missing = raw.copy().crop(0, 0.1).load_data().pick_channels( [raw.ch_names[pi] for pi in pick_types(raw.info, meg=True, exclude=())[3:]]) with pytest.warns(RuntimeWarning, match='Not all cross-talk channels'): maxwell_filter(raw_missing, cross_talk=ctc_fname) # MEG channels not in cross-talk pytest.raises(RuntimeError, maxwell_filter, raw_ctf, origin=(0., 0., 0.04), cross_talk=ctc_fname)
def test_cross_talk(tmpdir): """Test Maxwell filter cross-talk cancellation.""" raw = read_crop(raw_fname, (0., 1.)) raw.info['bads'] = bads sss_ctc = read_crop(sss_ctc_fname) with use_coil_def(elekta_def_fname): raw_sss = maxwell_filter(raw, cross_talk=ctc_fname, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, sss_ctc, 275.) py_ctc = raw_sss.info['proc_history'][0]['max_info']['sss_ctc'] assert (len(py_ctc) > 0) pytest.raises(ValueError, maxwell_filter, raw, cross_talk=raw) pytest.raises(ValueError, maxwell_filter, raw, cross_talk=raw_fname) mf_ctc = sss_ctc.info['proc_history'][0]['max_info']['sss_ctc'] del mf_ctc['block_id'] # we don't write this assert isinstance(py_ctc['decoupler'], sparse.csc_matrix) assert isinstance(mf_ctc['decoupler'], sparse.csc_matrix) assert_array_equal(py_ctc['decoupler'].toarray(), mf_ctc['decoupler'].toarray()) # I/O roundtrip tempdir = str(tmpdir) fname = op.join(tempdir, 'test_sss_raw.fif') sss_ctc.save(fname) sss_ctc_read = read_raw_fif(fname) mf_ctc_read = sss_ctc_read.info['proc_history'][0]['max_info']['sss_ctc'] assert isinstance(mf_ctc_read['decoupler'], sparse.csc_matrix) assert_array_equal(mf_ctc_read['decoupler'].toarray(), mf_ctc['decoupler'].toarray()) assert object_diff(py_ctc, mf_ctc) == '' raw_ctf = read_crop(fname_ctf_raw).apply_gradient_compensation(0) pytest.raises(ValueError, maxwell_filter, raw_ctf) # cannot fit headshape raw_sss = maxwell_filter(raw_ctf, origin=(0., 0., 0.04)) _assert_n_free(raw_sss, 68) raw_sss = maxwell_filter(raw_ctf, origin=(0., 0., 0.04), ignore_ref=True) _assert_n_free(raw_sss, 70) raw_missing = raw.copy().crop(0, 0.1).load_data().pick_channels( [raw.ch_names[pi] for pi in pick_types(raw.info, meg=True, exclude=())[3:]]) with pytest.warns(RuntimeWarning, match='Not all cross-talk channels'): maxwell_filter(raw_missing, cross_talk=ctc_fname) # MEG channels not in cross-talk pytest.raises(RuntimeError, maxwell_filter, raw_ctf, origin=(0., 0., 0.04), cross_talk=ctc_fname)
def test_spatiotemporal(): """Test Maxwell filter (tSSS) spatiotemporal processing.""" # Load raw testing data raw = read_crop(raw_fname) # Test that window is less than length of data with pytest.raises(ValueError, match='duration'): maxwell_filter(raw, st_duration=1000.) # We could check both 4 and 10 seconds because Elekta handles them # differently (to ensure that std/non-std tSSS windows are correctly # handled), but the 4-sec case should hopefully be sufficient. st_durations = [4.] # , 10.] tols = [(80, 100)] # , 200.] kwargs = dict(origin=mf_head_origin, regularize=None, bad_condition='ignore') for st_duration, tol in zip(st_durations, tols): # Load tSSS data depending on st_duration and get data tSSS_fname = op.join(sss_path, 'test_move_anon_st%0ds_raw_sss.fif' % st_duration) tsss_bench = read_crop(tSSS_fname) # Because Elekta's tSSS sometimes(!) lumps the tail window of data # onto the previous buffer if it's shorter than st_duration, we have to # crop the data here to compensate for Elekta's tSSS behavior. # if st_duration == 10.: # tsss_bench.crop(0, st_duration) # raw.crop(0, st_duration) # Test sss computation at the standard head origin. Same cropping issue # as mentioned above. raw_tsss = maxwell_filter( raw, st_duration=st_duration, **kwargs) assert _compute_rank_int(raw_tsss, proj=False) == 140 assert_meg_snr(raw_tsss, tsss_bench, *tol) py_st = raw_tsss.info['proc_history'][0]['max_info']['max_st'] assert (len(py_st) > 0) assert py_st['buflen'] == st_duration assert py_st['subspcorr'] == 0.98 # Degenerate cases pytest.raises(ValueError, maxwell_filter, raw, st_duration=10., st_correlation=0.)
def test_spatiotemporal(): """Test Maxwell filter (tSSS) spatiotemporal processing.""" # Load raw testing data raw = read_crop(raw_fname) # Test that window is less than length of data with pytest.raises(ValueError, match='duration'): maxwell_filter(raw, st_duration=1000.) # We could check both 4 and 10 seconds because Elekta handles them # differently (to ensure that std/non-std tSSS windows are correctly # handled), but the 4-sec case should hopefully be sufficient. st_durations = [4.] # , 10.] tols = [(80, 100)] # , 200.] kwargs = dict(origin=mf_head_origin, regularize=None, bad_condition='ignore') for st_duration, tol in zip(st_durations, tols): # Load tSSS data depending on st_duration and get data tSSS_fname = op.join(sss_path, 'test_move_anon_st%0ds_raw_sss.fif' % st_duration) tsss_bench = read_crop(tSSS_fname) # Because Elekta's tSSS sometimes(!) lumps the tail window of data # onto the previous buffer if it's shorter than st_duration, we have to # crop the data here to compensate for Elekta's tSSS behavior. # if st_duration == 10.: # tsss_bench.crop(0, st_duration) # raw.crop(0, st_duration) # Test sss computation at the standard head origin. Same cropping issue # as mentioned above. raw_tsss = maxwell_filter( raw, st_duration=st_duration, **kwargs) assert _compute_rank_int(raw_tsss, proj=False) == 140 assert_meg_snr(raw_tsss, tsss_bench, *tol) py_st = raw_tsss.info['proc_history'][0]['max_info']['max_st'] assert (len(py_st) > 0) assert py_st['buflen'] == st_duration assert py_st['subspcorr'] == 0.98 # Degenerate cases pytest.raises(ValueError, maxwell_filter, raw, st_duration=10., st_correlation=0.)
def test_head_translation(): """Test Maxwell filter head translation.""" raw = read_crop(raw_fname, (0., 1.)) # First try with an unchanged destination with use_coil_def(elekta_def_fname): raw_sss = maxwell_filter(raw, destination=raw_fname, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, read_crop(sss_std_fname, (0., 1.)), 200.) # Now with default with use_coil_def(elekta_def_fname): with pytest.warns(RuntimeWarning, match='over 25 mm'): raw_sss = maxwell_filter(raw, destination=mf_head_origin, origin=mf_head_origin, regularize=None, bad_condition='ignore', verbose=True) assert_meg_snr(raw_sss, read_crop(sss_trans_default_fname), 125.) destination = np.eye(4) destination[2, 3] = 0.04 assert_allclose(raw_sss.info['dev_head_t']['trans'], destination) # Now to sample's head pos with pytest.warns(RuntimeWarning, match='= 25.6 mm'): raw_sss = maxwell_filter(raw, destination=sample_fname, origin=mf_head_origin, regularize=None, bad_condition='ignore', verbose=True) assert_meg_snr(raw_sss, read_crop(sss_trans_sample_fname), 13., 100.) assert_allclose(raw_sss.info['dev_head_t']['trans'], read_info(sample_fname)['dev_head_t']['trans']) # Degenerate cases pytest.raises(RuntimeError, maxwell_filter, raw, destination=mf_head_origin, coord_frame='meg') pytest.raises(ValueError, maxwell_filter, raw, destination=[0.] * 4)
def test_head_translation(): """Test Maxwell filter head translation.""" raw = read_crop(raw_fname, (0., 1.)) # First try with an unchanged destination with use_coil_def(elekta_def_fname): raw_sss = maxwell_filter(raw, destination=raw_fname, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, read_crop(sss_std_fname, (0., 1.)), 200.) # Now with default with use_coil_def(elekta_def_fname): with pytest.warns(RuntimeWarning, match='over 25 mm'): raw_sss = maxwell_filter(raw, destination=mf_head_origin, origin=mf_head_origin, regularize=None, bad_condition='ignore', verbose=True) assert_meg_snr(raw_sss, read_crop(sss_trans_default_fname), 125.) destination = np.eye(4) destination[2, 3] = 0.04 assert_allclose(raw_sss.info['dev_head_t']['trans'], destination) # Now to sample's head pos with pytest.warns(RuntimeWarning, match='= 25.6 mm'): raw_sss = maxwell_filter(raw, destination=sample_fname, origin=mf_head_origin, regularize=None, bad_condition='ignore', verbose=True) assert_meg_snr(raw_sss, read_crop(sss_trans_sample_fname), 13., 100.) assert_allclose(raw_sss.info['dev_head_t']['trans'], read_info(sample_fname)['dev_head_t']['trans']) # Degenerate cases pytest.raises(RuntimeError, maxwell_filter, raw, destination=mf_head_origin, coord_frame='meg') pytest.raises(ValueError, maxwell_filter, raw, destination=[0.] * 4)
def test_regularization(): """Test Maxwell filter regularization.""" # Load testing data (raw, SSS std origin, SSS non-standard origin) min_tols = (20., 2.6, 1.0) med_tols = (200., 21., 3.7) origins = ((0., 0., 0.04), (0.,) * 3, (0., 0.02, 0.02)) coord_frames = ('head', 'meg', 'head') raw_fnames = (raw_fname, erm_fname, sample_fname) sss_fnames = (sss_reg_in_fname, sss_erm_reg_in_fname, sss_samp_reg_in_fname) comp_tols = [0, 1, 4] for ii, rf in enumerate(raw_fnames): raw = read_crop(rf, (0., 1.)) sss_reg_in = read_crop(sss_fnames[ii]) # Test "in" regularization raw_sss = maxwell_filter(raw, coord_frame=coord_frames[ii], origin=origins[ii]) assert_meg_snr(raw_sss, sss_reg_in, min_tols[ii], med_tols[ii], msg=rf) # check components match _check_reg_match(raw_sss, sss_reg_in, comp_tols[ii])
def test_regularization(): """Test Maxwell filter regularization.""" # Load testing data (raw, SSS std origin, SSS non-standard origin) min_tols = (20., 2.6, 1.0) med_tols = (200., 21., 3.7) origins = ((0., 0., 0.04), (0.,) * 3, (0., 0.02, 0.02)) coord_frames = ('head', 'meg', 'head') raw_fnames = (raw_fname, erm_fname, sample_fname) sss_fnames = (sss_reg_in_fname, sss_erm_reg_in_fname, sss_samp_reg_in_fname) comp_tols = [0, 1, 4] for ii, rf in enumerate(raw_fnames): raw = read_crop(rf, (0., 1.)) sss_reg_in = read_crop(sss_fnames[ii]) # Test "in" regularization raw_sss = maxwell_filter(raw, coord_frame=coord_frames[ii], origin=origins[ii]) assert_meg_snr(raw_sss, sss_reg_in, min_tols[ii], med_tols[ii], msg=rf) # check components match _check_reg_match(raw_sss, sss_reg_in, comp_tols[ii])
def test_fine_calibration(): """Test Maxwell filter fine calibration.""" # Load testing data (raw, SSS std origin, SSS non-standard origin) raw = read_crop(raw_fname, (0., 1.)) sss_fine_cal = read_crop(sss_fine_cal_fname) # Test 1D SSS fine calibration with use_coil_def(elekta_def_fname): raw_sss = maxwell_filter(raw, calibration=fine_cal_fname, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, sss_fine_cal, 82, 611) py_cal = raw_sss.info['proc_history'][0]['max_info']['sss_cal'] assert (py_cal is not None) assert (len(py_cal) > 0) mf_cal = sss_fine_cal.info['proc_history'][0]['max_info']['sss_cal'] # we identify these differently mf_cal['cal_chans'][mf_cal['cal_chans'][:, 1] == 3022, 1] = 3024 assert_allclose(py_cal['cal_chans'], mf_cal['cal_chans']) assert_allclose(py_cal['cal_corrs'], mf_cal['cal_corrs'], rtol=1e-3, atol=1e-3) # with missing channels raw_missing = raw.copy().load_data() raw_missing.info['bads'] = ['MEG0111', 'MEG0943'] # 1 mag, 1 grad raw_missing.info._check_consistency() raw_sss_bad = maxwell_filter( raw_missing, calibration=fine_cal_fname, origin=mf_head_origin, regularize=None, bad_condition='ignore') raw_missing.pick_types() # actually remove bads raw_sss_bad.pick_channels(raw_missing.ch_names) # remove them here, too with pytest.warns(RuntimeWarning, match='cal channels not in data'): raw_sss_missing = maxwell_filter( raw_missing, calibration=fine_cal_fname, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss_missing, raw_sss_bad, 1000., 10000.) # Test 3D SSS fine calibration (no equivalent func in MaxFilter yet!) # very low SNR as proc differs, eventually we should add a better test raw_sss_3D = maxwell_filter(raw, calibration=fine_cal_fname_3d, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss_3D, sss_fine_cal, 1.0, 6.) raw_ctf = read_crop(fname_ctf_raw).apply_gradient_compensation(0) pytest.raises(RuntimeError, maxwell_filter, raw_ctf, origin=(0., 0., 0.04), calibration=fine_cal_fname)
def test_fine_calibration(): """Test Maxwell filter fine calibration.""" # Load testing data (raw, SSS std origin, SSS non-standard origin) raw = read_crop(raw_fname, (0., 1.)) sss_fine_cal = read_crop(sss_fine_cal_fname) # Test 1D SSS fine calibration with use_coil_def(elekta_def_fname): raw_sss = maxwell_filter(raw, calibration=fine_cal_fname, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, sss_fine_cal, 82, 611) py_cal = raw_sss.info['proc_history'][0]['max_info']['sss_cal'] assert (py_cal is not None) assert (len(py_cal) > 0) mf_cal = sss_fine_cal.info['proc_history'][0]['max_info']['sss_cal'] # we identify these differently mf_cal['cal_chans'][mf_cal['cal_chans'][:, 1] == 3022, 1] = 3024 assert_allclose(py_cal['cal_chans'], mf_cal['cal_chans']) assert_allclose(py_cal['cal_corrs'], mf_cal['cal_corrs'], rtol=1e-3, atol=1e-3) # with missing channels raw_missing = raw.copy().load_data() raw_missing.info['bads'] = ['MEG0111', 'MEG0943'] # 1 mag, 1 grad raw_missing.info._check_consistency() raw_sss_bad = maxwell_filter( raw_missing, calibration=fine_cal_fname, origin=mf_head_origin, regularize=None, bad_condition='ignore') raw_missing.pick_types() # actually remove bads raw_sss_bad.pick_channels(raw_missing.ch_names) # remove them here, too with pytest.warns(RuntimeWarning, match='cal channels not in data'): raw_sss_missing = maxwell_filter( raw_missing, calibration=fine_cal_fname, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss_missing, raw_sss_bad, 1000., 10000.) # Test 3D SSS fine calibration (no equivalent func in MaxFilter yet!) # very low SNR as proc differs, eventually we should add a better test raw_sss_3D = maxwell_filter(raw, calibration=fine_cal_fname_3d, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss_3D, sss_fine_cal, 1.0, 6.) raw_ctf = read_crop(fname_ctf_raw).apply_gradient_compensation(0) pytest.raises(RuntimeError, maxwell_filter, raw_ctf, origin=(0., 0., 0.04), calibration=fine_cal_fname)
def test_triux(): """Test TRIUX system support.""" raw = read_crop(tri_fname, (0, 0.999)) raw.fix_mag_coil_types() # standard with use_coil_def(elekta_def_fname): sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None) assert_meg_snr(sss_py, read_crop(tri_sss_fname), 37, 700) # cross-talk sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None, cross_talk=tri_ctc_fname) assert_meg_snr(sss_py, read_crop(tri_sss_ctc_fname), 31, 250) # fine cal sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None, calibration=tri_cal_fname) assert_meg_snr(sss_py, read_crop(tri_sss_cal_fname), 22, 200) # ctc+cal sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None, calibration=tri_cal_fname, cross_talk=tri_ctc_fname) assert_meg_snr(sss_py, read_crop(tri_sss_ctc_cal_fname), 28, 200) # regularization sss_py = maxwell_filter(raw, coord_frame='meg', regularize='in') sss_mf = read_crop(tri_sss_reg_fname) assert_meg_snr(sss_py, sss_mf, 0.6, 9) _check_reg_match(sss_py, sss_mf, 1) # all three sss_py = maxwell_filter(raw, coord_frame='meg', regularize='in', calibration=tri_cal_fname, cross_talk=tri_ctc_fname) sss_mf = read_crop(tri_sss_ctc_cal_reg_in_fname) assert_meg_snr(sss_py, sss_mf, 0.6, 9) _check_reg_match(sss_py, sss_mf, 1) # tSSS raw = read_crop(tri_fname).fix_mag_coil_types() with use_coil_def(elekta_def_fname): sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None, st_duration=4., verbose=True) assert_meg_snr(sss_py, read_crop(tri_sss_st4_fname), 700., 1600)
def test_basic(): """Test Maxwell filter basic version.""" # Load testing data (raw, SSS std origin, SSS non-standard origin) raw = read_crop(raw_fname, (0., 1.)) raw_err = read_crop(raw_fname).apply_proj() raw_erm = read_crop(erm_fname) pytest.raises(RuntimeError, maxwell_filter, raw_err) pytest.raises(TypeError, maxwell_filter, 1.) # not a raw pytest.raises(ValueError, maxwell_filter, raw, int_order=20) # too many n_int_bases = int_order ** 2 + 2 * int_order n_ext_bases = ext_order ** 2 + 2 * ext_order nbases = n_int_bases + n_ext_bases # Check number of bases computed correctly assert _get_n_moments([int_order, ext_order]).sum() == nbases # Test SSS computation at the standard head origin assert len(raw.info['projs']) == 12 # 11 MEG projs + 1 AVG EEG with use_coil_def(elekta_def_fname): raw_sss = maxwell_filter(raw, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert len(raw_sss.info['projs']) == 1 # avg EEG assert raw_sss.info['projs'][0]['desc'] == 'Average EEG reference' assert_meg_snr(raw_sss, read_crop(sss_std_fname), 200., 1000.) py_cal = raw_sss.info['proc_history'][0]['max_info']['sss_cal'] assert len(py_cal) == 0 py_ctc = raw_sss.info['proc_history'][0]['max_info']['sss_ctc'] assert len(py_ctc) == 0 py_st = raw_sss.info['proc_history'][0]['max_info']['max_st'] assert len(py_st) == 0 pytest.raises(RuntimeError, maxwell_filter, raw_sss) # Test SSS computation at non-standard head origin with use_coil_def(elekta_def_fname): raw_sss = maxwell_filter(raw, origin=[0., 0.02, 0.02], regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, read_crop(sss_nonstd_fname), 250., 700.) # Test SSS computation at device origin sss_erm_std = read_crop(sss_erm_std_fname) raw_sss = maxwell_filter(raw_erm, coord_frame='meg', origin=mf_meg_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, sss_erm_std, 70., 260.) for key in ('job', 'frame'): vals = [x.info['proc_history'][0]['max_info']['sss_info'][key] for x in [raw_sss, sss_erm_std]] assert vals[0] == vals[1] # Two equivalent things: at device origin in device coords (0., 0., 0.) # and at device origin at head coords info['dev_head_t'][:3, 3] raw_sss_meg = maxwell_filter( raw, coord_frame='meg', origin=(0., 0., 0.)) raw_sss_head = maxwell_filter( raw, origin=raw.info['dev_head_t']['trans'][:3, 3]) assert_meg_snr(raw_sss_meg, raw_sss_head, 100., 900.) # Check against SSS functions from proc_history assert _get_n_moments(int_order) == _get_rank_sss(raw_sss) # Degenerate cases pytest.raises(ValueError, maxwell_filter, raw, coord_frame='foo') pytest.raises(ValueError, maxwell_filter, raw, origin='foo') pytest.raises(ValueError, maxwell_filter, raw, origin=[0] * 4) pytest.raises(ValueError, maxwell_filter, raw, mag_scale='foo') raw_missing = raw.copy().load_data() raw_missing.info['bads'] = ['MEG0111'] raw_missing.pick_types(meg=True) # will be missing the bad maxwell_filter(raw_missing) with pytest.warns(RuntimeWarning, match='not in data'): maxwell_filter(raw_missing, calibration=fine_cal_fname)
def test_triux(): """Test TRIUX system support.""" raw = read_crop(tri_fname, (0, 0.999)) raw.fix_mag_coil_types() # standard with use_coil_def(elekta_def_fname): sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None) assert_meg_snr(sss_py, read_crop(tri_sss_fname), 37, 700) # cross-talk sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None, cross_talk=tri_ctc_fname) assert_meg_snr(sss_py, read_crop(tri_sss_ctc_fname), 31, 250) # fine cal sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None, calibration=tri_cal_fname) assert_meg_snr(sss_py, read_crop(tri_sss_cal_fname), 22, 200) # ctc+cal sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None, calibration=tri_cal_fname, cross_talk=tri_ctc_fname) assert_meg_snr(sss_py, read_crop(tri_sss_ctc_cal_fname), 28, 200) # regularization sss_py = maxwell_filter(raw, coord_frame='meg', regularize='in') sss_mf = read_crop(tri_sss_reg_fname) assert_meg_snr(sss_py, sss_mf, 0.6, 9) _check_reg_match(sss_py, sss_mf, 1) # all three sss_py = maxwell_filter(raw, coord_frame='meg', regularize='in', calibration=tri_cal_fname, cross_talk=tri_ctc_fname) sss_mf = read_crop(tri_sss_ctc_cal_reg_in_fname) assert_meg_snr(sss_py, sss_mf, 0.6, 9) _check_reg_match(sss_py, sss_mf, 1) # tSSS raw = read_crop(tri_fname).fix_mag_coil_types() with use_coil_def(elekta_def_fname): sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None, st_duration=4., verbose=True) assert_meg_snr(sss_py, read_crop(tri_sss_st4_fname), 700., 1600)
def test_movement_compensation(tmpdir): """Test movement compensation.""" temp_dir = str(tmpdir) lims = (0, 4) raw = read_crop(raw_fname, lims).load_data() head_pos = read_head_pos(pos_fname) # # Movement compensation, no regularization, no tSSS # raw_sss = maxwell_filter(raw, head_pos=head_pos, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, read_crop(sss_movecomp_fname, lims), 4.6, 12.4, chpi_med_tol=58) # IO temp_fname = op.join(temp_dir, 'test_raw_sss.fif') raw_sss.save(temp_fname) raw_sss = read_crop(temp_fname) assert_meg_snr(raw_sss, read_crop(sss_movecomp_fname, lims), 4.6, 12.4, chpi_med_tol=58) # # Movement compensation, regularization, no tSSS # raw_sss = maxwell_filter(raw, head_pos=head_pos, origin=mf_head_origin) assert_meg_snr(raw_sss, read_crop(sss_movecomp_reg_in_fname, lims), 0.5, 1.9, chpi_med_tol=121) # # Movement compensation, regularization, tSSS at the end # raw_nohpi = filter_chpi(raw.copy()) with pytest.warns(RuntimeWarning, match='untested'): raw_sss_mv = maxwell_filter(raw_nohpi, head_pos=head_pos, st_duration=4., origin=mf_head_origin, st_fixed=False) # Neither match is particularly good because our algorithm actually differs assert_meg_snr(raw_sss_mv, read_crop(sss_movecomp_reg_in_st4s_fname, lims), 0.6, 1.3) tSSS_fname = op.join(sss_path, 'test_move_anon_st4s_raw_sss.fif') assert_meg_snr(raw_sss_mv, read_crop(tSSS_fname, lims), 0.6, 1.0, chpi_med_tol=None) assert_meg_snr(read_crop(sss_movecomp_reg_in_st4s_fname), read_crop(tSSS_fname), 0.8, 1.0, chpi_med_tol=None) # # Movement compensation, regularization, tSSS at the beginning # raw_sss_mc = maxwell_filter(raw_nohpi, head_pos=head_pos, st_duration=4., origin=mf_head_origin) assert_meg_snr(raw_sss_mc, read_crop(tSSS_fname, lims), 0.6, 1.0, chpi_med_tol=None) assert_meg_snr(raw_sss_mc, raw_sss_mv, 0.6, 1.4) # some degenerate cases raw_erm = read_crop(erm_fname) pytest.raises(ValueError, maxwell_filter, raw_erm, coord_frame='meg', head_pos=head_pos) # can't do ERM file pytest.raises(ValueError, maxwell_filter, raw, head_pos=head_pos[:, :9]) # bad shape pytest.raises(TypeError, maxwell_filter, raw, head_pos='foo') # bad type pytest.raises(ValueError, maxwell_filter, raw, head_pos=head_pos[::-1]) head_pos_bad = head_pos.copy() head_pos_bad[0, 0] = raw._first_time - 1e-2 pytest.raises(ValueError, maxwell_filter, raw, head_pos=head_pos_bad) head_pos_bad = head_pos.copy() head_pos_bad[0, 4] = 1. # off by more than 1 m with pytest.warns(RuntimeWarning, match='greater than 1 m'): maxwell_filter(raw.copy().crop(0, 0.1), head_pos=head_pos_bad, bad_condition='ignore') # make sure numerical error doesn't screw it up, though head_pos_bad = head_pos.copy() head_pos_bad[0, 0] = raw._first_time - 5e-4 raw_sss_tweak = maxwell_filter( raw.copy().crop(0, 0.05), head_pos=head_pos_bad, origin=mf_head_origin) assert_meg_snr(raw_sss_tweak, raw_sss.copy().crop(0, 0.05), 1.4, 8., chpi_med_tol=5)
def test_basic(): """Test Maxwell filter basic version.""" # Load testing data (raw, SSS std origin, SSS non-standard origin) raw = read_crop(raw_fname, (0., 1.)) raw_err = read_crop(raw_fname).apply_proj() raw_erm = read_crop(erm_fname) pytest.raises(RuntimeError, maxwell_filter, raw_err) pytest.raises(TypeError, maxwell_filter, 1.) # not a raw pytest.raises(ValueError, maxwell_filter, raw, int_order=20) # too many n_int_bases = int_order ** 2 + 2 * int_order n_ext_bases = ext_order ** 2 + 2 * ext_order nbases = n_int_bases + n_ext_bases # Check number of bases computed correctly assert _get_n_moments([int_order, ext_order]).sum() == nbases # Test SSS computation at the standard head origin assert len(raw.info['projs']) == 12 # 11 MEG projs + 1 AVG EEG with use_coil_def(elekta_def_fname): raw_sss = maxwell_filter(raw, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert len(raw_sss.info['projs']) == 1 # avg EEG assert raw_sss.info['projs'][0]['desc'] == 'Average EEG reference' assert_meg_snr(raw_sss, read_crop(sss_std_fname), 200., 1000.) py_cal = raw_sss.info['proc_history'][0]['max_info']['sss_cal'] assert len(py_cal) == 0 py_ctc = raw_sss.info['proc_history'][0]['max_info']['sss_ctc'] assert len(py_ctc) == 0 py_st = raw_sss.info['proc_history'][0]['max_info']['max_st'] assert len(py_st) == 0 pytest.raises(RuntimeError, maxwell_filter, raw_sss) # Test SSS computation at non-standard head origin with use_coil_def(elekta_def_fname): raw_sss = maxwell_filter(raw, origin=[0., 0.02, 0.02], regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, read_crop(sss_nonstd_fname), 250., 700.) # Test SSS computation at device origin sss_erm_std = read_crop(sss_erm_std_fname) raw_sss = maxwell_filter(raw_erm, coord_frame='meg', origin=mf_meg_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, sss_erm_std, 70., 260.) for key in ('job', 'frame'): vals = [x.info['proc_history'][0]['max_info']['sss_info'][key] for x in [raw_sss, sss_erm_std]] assert vals[0] == vals[1] # Two equivalent things: at device origin in device coords (0., 0., 0.) # and at device origin at head coords info['dev_head_t'][:3, 3] raw_sss_meg = maxwell_filter( raw, coord_frame='meg', origin=(0., 0., 0.)) raw_sss_head = maxwell_filter( raw, origin=raw.info['dev_head_t']['trans'][:3, 3]) assert_meg_snr(raw_sss_meg, raw_sss_head, 100., 900.) # Check against SSS functions from proc_history assert _get_n_moments(int_order) == _get_rank_sss(raw_sss) # Degenerate cases pytest.raises(ValueError, maxwell_filter, raw, coord_frame='foo') pytest.raises(ValueError, maxwell_filter, raw, origin='foo') pytest.raises(ValueError, maxwell_filter, raw, origin=[0] * 4) pytest.raises(ValueError, maxwell_filter, raw, mag_scale='foo') raw_missing = raw.copy().load_data() raw_missing.info['bads'] = ['MEG0111'] raw_missing.pick_types(meg=True) # will be missing the bad maxwell_filter(raw_missing) with pytest.warns(RuntimeWarning, match='not in data'): maxwell_filter(raw_missing, calibration=fine_cal_fname)
def test_chpi_subtraction_filter_chpi(): """Test subtraction of cHPI signals.""" raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes', preload=True) raw.info['bads'] = ['MEG0111'] raw.del_proj() raw_orig = raw.copy().crop(0, 16) with catch_logging() as log: with pytest.deprecated_call(match='"auto"'): filter_chpi(raw, include_line=False, verbose=True) assert 'No average EEG' not in log.getvalue() assert '5 cHPI' in log.getvalue() # MaxFilter doesn't do quite as well as our algorithm with the last bit raw.crop(0, 16) # remove cHPI status chans raw_c = read_raw_fif(sss_hpisubt_fname).crop(0, 16).load_data() raw_c.pick_types( meg=True, eeg=True, eog=True, ecg=True, stim=True, misc=True) assert_meg_snr(raw, raw_c, 143, 624) # cHPI suppressed but not line freqs (or others) assert_suppressed(raw, raw_orig, np.arange(83, 324, 60), [30, 60, 150]) raw = raw_orig.copy() with catch_logging() as log: with pytest.deprecated_call(match='"auto"'): filter_chpi(raw, include_line=True, verbose=True) log = log.getvalue() assert '5 cHPI' in log assert '6 line' in log # cHPI and line freqs suppressed suppressed = np.sort(np.concatenate([ np.arange(83, 324, 60), np.arange(60, 301, 60), ])) assert_suppressed(raw, raw_orig, suppressed, [30, 150]) # No HPI information raw = read_raw_fif(sample_fname, preload=True) raw_orig = raw.copy() assert raw.info['line_freq'] is None with pytest.raises(RuntimeError, match='line_freq.*consider setting it'): filter_chpi(raw, t_window=0.2) raw.info['line_freq'] = 60. with pytest.raises(RuntimeError, match='cHPI information not found'): filter_chpi(raw, t_window=0.2) # but this is allowed with catch_logging() as log: filter_chpi(raw, t_window='auto', allow_line_only=True, verbose=True) log = log.getvalue() assert '0 cHPI' in log assert '1 line' in log # Our one line freq suppressed but not others assert_suppressed(raw, raw_orig, [60], [30, 45, 75]) # When MaxFliter downsamples, like:: # $ maxfilter -nosss -ds 2 -f test_move_anon_raw.fif \ # -o test_move_anon_ds2_raw.fif # it can strip out some values of info, which we emulate here: raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes') raw = raw.crop(0, 1).load_data().resample(600., npad='auto') raw.info['lowpass'] = 200. del raw.info['maxshield'] del raw.info['hpi_results'][0]['moments'] del raw.info['hpi_subsystem']['event_channel'] with catch_logging() as log: filter_chpi(raw, t_window='auto', verbose=True) with pytest.raises(ValueError, match='must be > 0'): filter_chpi(raw, t_window=-1) assert '2 cHPI' in log.getvalue()
def test_movement_compensation(tmpdir): """Test movement compensation.""" temp_dir = str(tmpdir) lims = (0, 4) raw = read_crop(raw_fname, lims).load_data() head_pos = read_head_pos(pos_fname) # # Movement compensation, no regularization, no tSSS # raw_sss = maxwell_filter(raw, head_pos=head_pos, origin=mf_head_origin, regularize=None, bad_condition='ignore') assert_meg_snr(raw_sss, read_crop(sss_movecomp_fname, lims), 4.6, 12.4, chpi_med_tol=58) # IO temp_fname = op.join(temp_dir, 'test_raw_sss.fif') raw_sss.save(temp_fname) raw_sss = read_crop(temp_fname) assert_meg_snr(raw_sss, read_crop(sss_movecomp_fname, lims), 4.6, 12.4, chpi_med_tol=58) # # Movement compensation, regularization, no tSSS # raw_sss = maxwell_filter(raw, head_pos=head_pos, origin=mf_head_origin) assert_meg_snr(raw_sss, read_crop(sss_movecomp_reg_in_fname, lims), 0.5, 1.9, chpi_med_tol=121) # # Movement compensation, regularization, tSSS at the end # raw_nohpi = filter_chpi(raw.copy(), t_window=0.2) with pytest.warns(RuntimeWarning, match='untested'): raw_sss_mv = maxwell_filter(raw_nohpi, head_pos=head_pos, st_duration=4., origin=mf_head_origin, st_fixed=False) # Neither match is particularly good because our algorithm actually differs assert_meg_snr(raw_sss_mv, read_crop(sss_movecomp_reg_in_st4s_fname, lims), 0.6, 1.3) tSSS_fname = op.join(sss_path, 'test_move_anon_st4s_raw_sss.fif') assert_meg_snr(raw_sss_mv, read_crop(tSSS_fname, lims), 0.6, 1.0, chpi_med_tol=None) assert_meg_snr(read_crop(sss_movecomp_reg_in_st4s_fname), read_crop(tSSS_fname), 0.8, 1.0, chpi_med_tol=None) # # Movement compensation, regularization, tSSS at the beginning # raw_sss_mc = maxwell_filter(raw_nohpi, head_pos=head_pos, st_duration=4., origin=mf_head_origin) assert_meg_snr(raw_sss_mc, read_crop(tSSS_fname, lims), 0.6, 1.0, chpi_med_tol=None) assert_meg_snr(raw_sss_mc, raw_sss_mv, 0.6, 1.4) # some degenerate cases raw_erm = read_crop(erm_fname) pytest.raises(ValueError, maxwell_filter, raw_erm, coord_frame='meg', head_pos=head_pos) # can't do ERM file pytest.raises(ValueError, maxwell_filter, raw, head_pos=head_pos[:, :9]) # bad shape pytest.raises(TypeError, maxwell_filter, raw, head_pos='foo') # bad type pytest.raises(ValueError, maxwell_filter, raw, head_pos=head_pos[::-1]) head_pos_bad = head_pos.copy() head_pos_bad[0, 0] = raw._first_time - 1e-2 pytest.raises(ValueError, maxwell_filter, raw, head_pos=head_pos_bad) head_pos_bad = head_pos.copy() head_pos_bad[0, 4] = 1. # off by more than 1 m with pytest.warns(RuntimeWarning, match='greater than 1 m'): maxwell_filter(raw.copy().crop(0, 0.1), head_pos=head_pos_bad, bad_condition='ignore') # make sure numerical error doesn't screw it up, though head_pos_bad = head_pos.copy() head_pos_bad[0, 0] = raw._first_time - 5e-4 raw_sss_tweak = maxwell_filter( raw.copy().crop(0, 0.05), head_pos=head_pos_bad, origin=mf_head_origin) assert_meg_snr(raw_sss_tweak, raw_sss.copy().crop(0, 0.05), 1.4, 8., chpi_med_tol=5)