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 filter_chpi_and_line(raw):
"""
Remove Chpi and line noise from the data. This can be useful in order to
use no filtering during bad channel detection for maxwell filtering.
:param raw: Raw data, preloaded
:return:
"""
from mne.chpi import filter_chpi
# make sure the data is loaded first
logging.info("Loading data for CHPI and line noise filtering")
raw.load_data()
logging.info("Applying CHPI and line noise filter")
# all parameters are set to the defaults of 0.23dev
filter_chpi(
raw,
include_line=True,
t_step=0.01,
t_window="auto",
ext_order=1,
allow_line_only=False,
verbose=None,
)
# the data is now preconditioned, hence we change the state of the global
# variable
global preconditioned
preconditioned = True
return raw
def test_chpi_subtraction():
"""Test subtraction of cHPI signals"""
raw = Raw(chpi_fif_fname, allow_maxshield="yes", preload=True)
with catch_logging() as log:
filter_chpi(raw, include_line=False, verbose=True)
assert_true("5 cHPI" in log.getvalue())
# MaxFilter doesn't do quite as well as our algorithm with the last bit
raw.crop(0, 16, copy=False)
# remove cHPI status chans
raw_c = Raw(sss_hpisubt_fname).crop(0, 16, copy=False).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 = Raw(test_fif_fname, preload=True)
assert_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 = Raw(chpi_fif_fname, allow_maxshield="yes")
with warnings.catch_warnings(record=True): # uint cast suggestion
raw = raw.crop(0, 1).load_data().resample(600.0, npad="auto")
raw.info["buffer_size_sec"] = np.float64(2.0)
raw.info["lowpass"] = 200.0
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)
assert_true("2 cHPI" in log.getvalue())
def prepare_raw_orig_data(fif_file, subj):
raw = read_raw_fif(fif_file, preload=True).pick_types(meg=True, exclude=[])
if subj.name == "sub-emptyroom":
allow_line_only = True
else:
allow_line_only = False
filter_chpi(raw, allow_line_only=allow_line_only)
# set bads and annotations
bads_dir = dirs.bads / subj.name
if subj.name == "sub-emptyroom":
print(fif_file)
bids_dict = BidsFname(fif_file.name)
bads_dir = bads_dir / ("ses-" + bids_dict["ses"])
basename = fif_file.name[: -len("_meg.fif")]
bads_fpath = bads_dir / (basename + "-bads.tsv")
with open(bads_fpath, "r") as f:
bads = f.readline().split("\t")
raw.info["bads"] = bads
annotations_fpath = bads_dir / (basename + "-annot.fif")
annotations = read_annotations(str(annotations_fpath))
raw.set_annotations(annotations)
picks_grad = mne.pick_types(raw.info, meg="grad")
picks_mag = mne.pick_types(raw.info, meg="mag")
var = raw.get_data(reject_by_annotation="omit").var(axis=1)
del raw
return var[picks_mag], var[picks_grad]
def test_chpi_subtraction():
"""Test subtraction of cHPI signals"""
raw = Raw(chpi_fif_fname, allow_maxshield='yes', preload=True)
with catch_logging() as log:
filter_chpi(raw, include_line=False, verbose=True)
assert_true('5 cHPI' in log.getvalue())
# MaxFilter doesn't do quite as well as our algorithm with the last bit
raw.crop(0, 16, copy=False)
raw_c = Raw(sss_hpisubt_fname, preload=True).crop(0, 16, copy=False)
raw_c.pick_types(meg=True, eeg=True, eog=True, ecg=True, stim=True,
misc=True, copy=False) # remove cHPI status chans
assert_meg_snr(raw, raw_c, 143, 624)
# Degenerate cases
raw_nohpi = Raw(test_fif_fname, preload=True)
assert_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 = Raw(chpi_fif_fname, allow_maxshield='yes')
raw.crop(0, 1, copy=False).load_data()
raw.resample(600., npad='auto')
raw.info['buffer_size_sec'] = np.float64(2.)
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)
assert_true('2 cHPI' in log.getvalue())
def test_chpi_subtraction():
"""Test subtraction of cHPI signals"""
raw = Raw(chpi_fif_fname, allow_maxshield='yes', preload=True)
filter_chpi(raw, include_line=False)
# MaxFilter doesn't do quite as well as our algorithm with the last bit
raw.crop(0, 16, copy=False)
raw_c = Raw(sss_hpisubt_fname, preload=True).crop(0, 16, copy=False)
raw_c.pick_types(meg=True, eeg=True, eog=True, ecg=True, stim=True,
misc=True, copy=False) # remove cHPI status chans
assert_meg_snr(raw, raw_c, 143, 624)
# Degenerate cases
raw_nohpi = Raw(test_fif_fname, preload=True)
assert_raises(RuntimeError, filter_chpi, raw_nohpi)
def inspect_fif(fif_path, bads, annotations, is_emptyroom):
"""Manually mark bad channels and segments in gui signal viewer
Filter chpi and line noise from data copy for inspection
"""
raw_check = read_raw_fif(fif_path, preload=True)
if bads is not None:
raw_check.info["bads"] = bads
if annotations is not None:
raw_check.set_annotations(annotations)
filter_chpi(raw_check, allow_line_only=is_emptyroom)
raw_check.plot(block=True, lowpass=100, highpass=0.5, n_channels=50)
logger.info(f"Channels marked bad: {raw_check.info['bads']}")
return raw_check.info["bads"], raw_check.annotations
def prepare_raw(raw_path, bads_path, annot_path, is_er):
"""Load raw, filter chpi and line noise, set bads and annotations"""
raw = read_raw_fif(raw_path, preload=True)
filter_chpi(
raw, allow_line_only=is_er, t_window=cfg.maxfilt_config["t_window"]
)
fix_mag_coil_types(raw.info)
with open(bads_path, "r") as f:
bads = f.readline().split("\t")
if bads == [""]:
bads = []
raw.info["bads"] = bads
raw.set_annotations(read_annotations(annot_path))
return raw
def test_chpi_subtraction():
"""Test subtraction of cHPI signals"""
with warnings.catch_warnings(record=True): # maxshield
raw = Raw(chpi_fif_fname, allow_maxshield=True, preload=True)
filter_chpi(raw, include_line=False)
# MaxFilter doesn't do quite as well as our algorithm with the last bit
raw.crop(0, 16, copy=False)
raw_c = Raw(sss_hpisubt_fname, preload=True).crop(0, 16, copy=False)
raw_c.pick_types(meg=True,
eeg=True,
eog=True,
ecg=True,
stim=True,
misc=True,
copy=False) # remove cHPI status chans
assert_meg_snr(raw, raw_c, 143, 624)
# Degenerate cases
raw_nohpi = Raw(test_fif_fname, preload=True)
assert_raises(RuntimeError, filter_chpi, raw_nohpi)
def test_chpi_subtraction():
"""Test subtraction of cHPI signals"""
raw = Raw(chpi_fif_fname, allow_maxshield='yes', preload=True)
with catch_logging() as log:
filter_chpi(raw, include_line=False, verbose=True)
assert_true('5 cHPI' in log.getvalue())
# MaxFilter doesn't do quite as well as our algorithm with the last bit
raw.crop(0, 16, copy=False)
# remove cHPI status chans
raw_c = Raw(sss_hpisubt_fname).crop(0, 16, copy=False).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 = Raw(test_fif_fname, preload=True)
assert_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 = Raw(chpi_fif_fname, allow_maxshield='yes')
with warnings.catch_warnings(record=True): # uint cast suggestion
raw = raw.crop(0, 1).load_data().resample(600., npad='auto')
raw.info['buffer_size_sec'] = np.float64(2.)
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)
assert_true('2 cHPI' in log.getvalue())
def test_movement_compensation():
"""Test movement compensation."""
temp_dir = _TempDir()
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 warnings.catch_warnings(record=True) as w: # untested feature
raw_sss_mv = maxwell_filter(raw_nohpi,
head_pos=head_pos,
st_duration=4.,
origin=mf_head_origin,
st_fixed=False)
assert_equal(len(w), 1)
assert_true('is untested' in str(w[0].message))
# 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)
assert_raises(ValueError,
maxwell_filter,
raw_erm,
coord_frame='meg',
head_pos=head_pos) # can't do ERM file
assert_raises(ValueError, maxwell_filter, raw,
head_pos=head_pos[:, :9]) # bad shape
assert_raises(TypeError, maxwell_filter, raw, head_pos='foo') # bad type
assert_raises(ValueError, maxwell_filter, raw, head_pos=head_pos[::-1])
head_pos_bad = head_pos.copy()
head_pos_bad[0, 0] = raw.first_samp / raw.info['sfreq'] - 1e-2
assert_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 warnings.catch_warnings(record=True) as w:
maxwell_filter(raw.copy().crop(0, 0.1),
head_pos=head_pos_bad,
bad_condition='ignore')
assert_true(any('greater than 1 m' in str(ww.message) for ww in w))
# make sure numerical error doesn't screw it up, though
head_pos_bad = head_pos.copy()
head_pos_bad[0, 0] = raw.first_samp / raw.info['sfreq'] - 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_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():
"""Test movement compensation"""
temp_dir = _TempDir()
lims = (0, 4)
raw = Raw(raw_fname, allow_maxshield='yes', preload=True).crop(*lims)
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, Raw(sss_movecomp_fname).crop(*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 = Raw(temp_fname)
assert_meg_snr(raw_sss, Raw(sss_movecomp_fname).crop(*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, Raw(sss_movecomp_reg_in_fname).crop(*lims),
0.5, 1.9, chpi_med_tol=121)
#
# Movement compensation, regularization, tSSS at the end
#
raw_nohpi = filter_chpi(raw.copy())
with warnings.catch_warnings(record=True) as w: # untested feature
raw_sss_mv = maxwell_filter(raw_nohpi, head_pos=head_pos,
st_duration=4., origin=mf_head_origin,
st_fixed=False)
assert_equal(len(w), 1)
assert_true('is untested' in str(w[0].message))
# Neither match is particularly good because our algorithm actually differs
assert_meg_snr(raw_sss_mv, Raw(sss_movecomp_reg_in_st4s_fname).crop(*lims),
0.6, 1.3)
tSSS_fname = op.join(sss_path, 'test_move_anon_st4s_raw_sss.fif')
assert_meg_snr(raw_sss_mv, Raw(tSSS_fname).crop(*lims),
0.6, 1.0, chpi_med_tol=None)
assert_meg_snr(Raw(sss_movecomp_reg_in_st4s_fname), Raw(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, Raw(tSSS_fname).crop(*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 = Raw(erm_fname, allow_maxshield='yes')
assert_raises(ValueError, maxwell_filter, raw_erm, coord_frame='meg',
head_pos=head_pos) # can't do ERM file
assert_raises(ValueError, maxwell_filter, raw,
head_pos=head_pos[:, :9]) # bad shape
assert_raises(TypeError, maxwell_filter, raw, head_pos='foo') # bad type
assert_raises(ValueError, maxwell_filter, raw, head_pos=head_pos[::-1])
head_pos_bad = head_pos.copy()
head_pos_bad[0, 0] = raw.first_samp / raw.info['sfreq'] - 1e-2
assert_raises(ValueError, maxwell_filter, raw, head_pos=head_pos_bad)
# make sure numerical error doesn't screw it up, though
head_pos_bad[0, 0] = raw.first_samp / raw.info['sfreq'] - 1e-4
raw_sss_tweak = maxwell_filter(raw, head_pos=head_pos_bad,
origin=mf_head_origin)
assert_meg_snr(raw_sss_tweak, raw_sss, 2., 10.)
def test_movement_compensation():
"""Test movement compensation"""
lims = (0, 8)
with warnings.catch_warnings(record=True): # maxshield
raw = Raw(raw_fname, allow_maxshield=True, preload=True).crop(*lims)
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,
Raw(sss_movecomp_fname).crop(*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,
Raw(sss_movecomp_reg_in_fname).crop(*lims),
0.7,
1.9,
chpi_med_tol=121)
#
# Movement compensation, regularization, tSSS at the end
#
raw_nohpi = filter_chpi(raw.copy())
with warnings.catch_warnings(record=True) as w: # untested feature
raw_sss_mv = maxwell_filter(raw_nohpi,
head_pos=head_pos,
st_duration=4.,
origin=mf_head_origin,
st_fixed=False)
assert_equal(len(w), 1)
assert_true('is untested' in str(w[0].message))
# Neither match is particularly good because our algorithm actually differs
assert_meg_snr(raw_sss_mv,
Raw(sss_movecomp_reg_in_st4s_fname).crop(*lims), 0.6, 1.3)
tSSS_fname = op.join(sss_path, 'test_move_anon_st4s_raw_sss.fif')
assert_meg_snr(raw_sss_mv,
Raw(tSSS_fname).crop(*lims),
0.6,
1.0,
chpi_med_tol=None)
assert_meg_snr(Raw(sss_movecomp_reg_in_st4s_fname),
Raw(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,
Raw(tSSS_fname).crop(*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
with warnings.catch_warnings(record=True): # maxshield
raw_erm = Raw(erm_fname, allow_maxshield=True)
assert_raises(ValueError,
maxwell_filter,
raw_erm,
coord_frame='meg',
head_pos=head_pos) # can't do ERM file
head_pos_bad = head_pos[:, :9]
assert_raises(ValueError, maxwell_filter, raw,
head_pos=head_pos_bad) # bad shape
head_pos_bad = 'foo'
assert_raises(TypeError, maxwell_filter, raw,
head_pos=head_pos_bad) # bad type
head_pos_bad = head_pos[::-1]
assert_raises(ValueError, maxwell_filter, raw, head_pos=head_pos_bad)
head_pos_bad = head_pos.copy()
head_pos_bad[0, 0] = 1. # bad time given the first_samp...
assert_raises(ValueError, maxwell_filter, raw, head_pos=head_pos_bad)
def test_movement_compensation():
"""Test movement compensation"""
lims = (0, 8)
with warnings.catch_warnings(record=True): # maxshield
raw = Raw(raw_fname, allow_maxshield=True, preload=True).crop(*lims)
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, Raw(sss_movecomp_fname).crop(*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, Raw(sss_movecomp_reg_in_fname).crop(*lims),
0.7, 1.9, chpi_med_tol=121)
#
# Movement compensation, regularization, tSSS at the end
#
raw_nohpi = filter_chpi(raw.copy())
with warnings.catch_warnings(record=True) as w: # untested feature
raw_sss_mv = maxwell_filter(raw_nohpi, head_pos=head_pos,
st_duration=4., origin=mf_head_origin,
st_fixed=False)
assert_equal(len(w), 1)
assert_true('is untested' in str(w[0].message))
# Neither match is particularly good because our algorithm actually differs
assert_meg_snr(raw_sss_mv, Raw(sss_movecomp_reg_in_st4s_fname).crop(*lims),
0.6, 1.3)
tSSS_fname = op.join(sss_path, 'test_move_anon_st4s_raw_sss.fif')
assert_meg_snr(raw_sss_mv, Raw(tSSS_fname).crop(*lims),
0.6, 1.0, chpi_med_tol=None)
assert_meg_snr(Raw(sss_movecomp_reg_in_st4s_fname), Raw(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, Raw(tSSS_fname).crop(*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
with warnings.catch_warnings(record=True): # maxshield
raw_erm = Raw(erm_fname, allow_maxshield=True)
assert_raises(ValueError, maxwell_filter, raw_erm, coord_frame='meg',
head_pos=head_pos) # can't do ERM file
head_pos_bad = head_pos[:, :9]
assert_raises(ValueError, maxwell_filter, raw,
head_pos=head_pos_bad) # bad shape
head_pos_bad = 'foo'
assert_raises(TypeError, maxwell_filter, raw,
head_pos=head_pos_bad) # bad type
head_pos_bad = head_pos[::-1]
assert_raises(ValueError, maxwell_filter, raw,
head_pos=head_pos_bad)
head_pos_bad = head_pos.copy()
head_pos_bad[0, 0] = 1. # bad time given the first_samp...
assert_raises(ValueError, maxwell_filter, raw, head_pos=head_pos_bad)
def test_movement_compensation():
"""Test movement compensation."""
temp_dir = _TempDir()
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_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)