def test_apply_mne_inverse_epochs():
"""Test MNE with precomputed inverse operator on Epochs
"""
event_id, tmin, tmax = 1, -0.2, 0.5
picks = fiff.pick_types(raw.info,
meg=True,
eeg=False,
stim=True,
ecg=True,
eog=True,
include=['STI 014'])
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
flat = dict(grad=1e-15, mag=1e-15)
events = read_events(fname_event)[:15]
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
reject=reject,
flat=flat)
stcs = apply_inverse_epochs(epochs,
inverse_operator,
lambda2,
"dSPM",
label=label_lh,
pick_normal=True)
assert_true(len(stcs) == 4)
assert_true(3 < stcs[0].data.max() < 10)
data = sum(stc.data for stc in stcs) / len(stcs)
flip = label_sign_flip(label_lh, inverse_operator['src'])
label_mean = np.mean(data, axis=0)
label_mean_flip = np.mean(flip[:, np.newaxis] * data, axis=0)
assert_true(label_mean.max() < label_mean_flip.max())
# test extracting a BiHemiLabel
stcs_rh = apply_inverse_epochs(epochs,
inverse_operator,
lambda2,
"dSPM",
label=label_rh,
pick_normal=True)
stcs_bh = apply_inverse_epochs(epochs,
inverse_operator,
lambda2,
"dSPM",
label=label_lh + label_rh,
pick_normal=True)
n_lh = len(stcs[0].data)
assert_array_almost_equal(stcs[0].data, stcs_bh[0].data[:n_lh])
assert_array_almost_equal(stcs_rh[0].data, stcs_bh[0].data[n_lh:])
def test_apply_mne_inverse_epochs():
"""Test MNE with precomputed inverse operator on Epochs
"""
inverse_operator = read_inverse_operator(fname_inv)
label_lh = read_label(fname_label % 'Aud-lh')
label_rh = read_label(fname_label % 'Aud-rh')
event_id, tmin, tmax = 1, -0.2, 0.5
raw = fiff.Raw(fname_raw)
picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True,
ecg=True, eog=True, include=['STI 014'],
exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
flat = dict(grad=1e-15, mag=1e-15)
events = read_events(fname_event)[:15]
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject, flat=flat)
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh, pick_ori="normal")
assert_true(len(stcs) == 4)
assert_true(3 < stcs[0].data.max() < 10)
assert_true(stcs[0].subject == 'sample')
data = sum(stc.data for stc in stcs) / len(stcs)
flip = label_sign_flip(label_lh, inverse_operator['src'])
label_mean = np.mean(data, axis=0)
label_mean_flip = np.mean(flip[:, np.newaxis] * data, axis=0)
assert_true(label_mean.max() < label_mean_flip.max())
# test extracting a BiHemiLabel
stcs_rh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_rh, pick_ori="normal")
stcs_bh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh + label_rh,
pick_ori="normal")
n_lh = len(stcs[0].data)
assert_array_almost_equal(stcs[0].data, stcs_bh[0].data[:n_lh])
assert_array_almost_equal(stcs_rh[0].data, stcs_bh[0].data[n_lh:])
# test without using a label (so delayed computation is used)
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
pick_ori="normal")
assert_true(stcs[0].subject == 'sample')
label_stc = stcs[0].in_label(label_rh)
assert_true(label_stc.subject == 'sample')
assert_array_almost_equal(stcs_rh[0].data, label_stc.data)
def test_apply_mne_inverse_epochs():
"""Test MNE with precomputed inverse operator on Epochs
"""
inverse_operator = read_inverse_operator(fname_inv)
label_lh = read_label(fname_label % 'Aud-lh')
label_rh = read_label(fname_label % 'Aud-rh')
event_id, tmin, tmax = 1, -0.2, 0.5
raw = fiff.Raw(fname_raw)
picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True,
ecg=True, eog=True, include=['STI 014'],
exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
flat = dict(grad=1e-15, mag=1e-15)
events = read_events(fname_event)[:15]
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject, flat=flat)
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh, pick_ori="normal")
assert_true(len(stcs) == 4)
assert_true(3 < stcs[0].data.max() < 10)
assert_true(stcs[0].subject == 'sample')
data = sum(stc.data for stc in stcs) / len(stcs)
flip = label_sign_flip(label_lh, inverse_operator['src'])
label_mean = np.mean(data, axis=0)
label_mean_flip = np.mean(flip[:, np.newaxis] * data, axis=0)
assert_true(label_mean.max() < label_mean_flip.max())
# test extracting a BiHemiLabel
stcs_rh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_rh, pick_ori="normal")
stcs_bh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh + label_rh,
pick_ori="normal")
n_lh = len(stcs[0].data)
assert_array_almost_equal(stcs[0].data, stcs_bh[0].data[:n_lh])
assert_array_almost_equal(stcs_rh[0].data, stcs_bh[0].data[n_lh:])
# test without using a label (so delayed computation is used)
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
pick_ori="normal")
assert_true(stcs[0].subject == 'sample')
label_stc = stcs[0].in_label(label_rh)
assert_true(label_stc.subject == 'sample')
assert_array_almost_equal(stcs_rh[0].data, label_stc.data)
def test_apply_mne_inverse_epochs():
"""Test MNE with precomputed inverse operator on Epochs
"""
event_id, tmin, tmax = 1, -0.2, 0.5
picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True,
ecg=True, eog=True, include=['STI 014'])
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
flat = dict(grad=1e-15, mag=1e-15)
events = read_events(fname_event)[:15]
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject, flat=flat)
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label, pick_normal=True)
assert_true(len(stcs) == 4)
assert_true(3 < stcs[0].data.max() < 10)
data = sum(stc.data for stc in stcs) / len(stcs)
flip = label_sign_flip(label, inverse_operator['src'])
label_mean = np.mean(data, axis=0)
label_mean_flip = np.mean(flip[:, np.newaxis] * data, axis=0)
assert_true(label_mean.max() < label_mean_flip.max())
def test_source_psd_epochs():
"""Test multi-taper source PSD computation in label from epochs"""
raw = fiff.Raw(fname_data)
inverse_operator = read_inverse_operator(fname_inv)
label = read_label(fname_label)
event_id, tmin, tmax = 1, -0.2, 0.5
lambda2, method = 1. / 9., 'dSPM'
bandwidth = 8.
fmin, fmax = 0, 100
picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True,
ecg=True, eog=True, include=['STI 014'],
exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
events = find_events(raw)
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject)
# only look at one epoch
epochs.drop_bad_epochs()
one_epochs = epochs[:1]
# return list
stc_psd = compute_source_psd_epochs(one_epochs, inverse_operator,
lambda2=lambda2, method=method,
pick_normal=True, label=label,
bandwidth=bandwidth,
fmin=fmin, fmax=fmax)[0]
# return generator
stcs = compute_source_psd_epochs(one_epochs, inverse_operator,
lambda2=lambda2, method=method,
pick_normal=True, label=label,
bandwidth=bandwidth,
fmin=fmin, fmax=fmax,
return_generator=True)
for stc in stcs:
stc_psd_gen = stc
assert_array_almost_equal(stc_psd.data, stc_psd_gen.data)
# compare with direct computation
stc = apply_inverse_epochs(one_epochs, inverse_operator,
lambda2=lambda2, method=method,
pick_normal=True, label=label)[0]
sfreq = epochs.info['sfreq']
psd, freqs = multitaper_psd(stc.data, sfreq=sfreq, bandwidth=bandwidth,
fmin=fmin, fmax=fmax)
assert_array_almost_equal(psd, stc_psd.data)
assert_array_almost_equal(freqs, stc_psd.times)
def test_apply_mne_inverse_epochs(self):
"""Test MNE with precomputed inverse operator on Epochs
"""
event_id, tmin, tmax = 1, -0.2, 0.5
picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True,
ecg=True, eog=True, include=['STI 014'],
exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
flat = dict(grad=1e-15, mag=1e-15)
events = read_events(fname_event)[:15]
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject, flat=flat)
stcs = apply_inverse_epochs(epochs, self.inv_op, lambda2, "dSPM",
label=label_lh, pick_normal=True)
assert_true(len(stcs) == 4)
assert_true(3 < stcs[0].data.max() < 10)
data = sum(stc.data for stc in stcs) / len(stcs)
flip = label_sign_flip(label_lh, self.inv_op['src'])
label_mean = np.mean(data, axis=0)
label_mean_flip = np.mean(flip[:, np.newaxis] * data, axis=0)
assert_true(label_mean.max() < label_mean_flip.max())
# test extracting a BiHemiLabel
stcs_rh = apply_inverse_epochs(epochs, self.inv_op, lambda2, "dSPM",
label=label_rh, pick_normal=True)
stcs_bh = apply_inverse_epochs(epochs, self.inv_op, lambda2, "dSPM",
label=label_lh + label_rh,
pick_normal=True)
n_lh = len(stcs[0].data)
assert_array_almost_equal(stcs[0].data, stcs_bh[0].data[:n_lh])
assert_array_almost_equal(stcs_rh[0].data, stcs_bh[0].data[n_lh:])
def test_source_psd_epochs():
"""Test multi-taper source PSD computation in label from epochs."""
raw = read_raw_fif(fname_data)
inverse_operator = read_inverse_operator(fname_inv)
label = read_label(fname_label)
event_id, tmin, tmax = 1, -0.2, 0.5
lambda2, method = 1. / 9., 'dSPM'
bandwidth = 8.
fmin, fmax = 0, 100
picks = pick_types(raw.info,
meg=True,
eeg=False,
stim=True,
ecg=True,
eog=True,
include=['STI 014'],
exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
events = find_events(raw, stim_channel='STI 014')
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
reject=reject)
# only look at one epoch
epochs.drop_bad()
one_epochs = epochs[:1]
inv = prepare_inverse_operator(inverse_operator,
nave=1,
lambda2=1. / 9.,
method="dSPM")
# return list
stc_psd = compute_source_psd_epochs(one_epochs,
inv,
lambda2=lambda2,
method=method,
pick_ori="normal",
label=label,
bandwidth=bandwidth,
fmin=fmin,
fmax=fmax,
prepared=True)[0]
# return generator
stcs = compute_source_psd_epochs(one_epochs,
inv,
lambda2=lambda2,
method=method,
pick_ori="normal",
label=label,
bandwidth=bandwidth,
fmin=fmin,
fmax=fmax,
return_generator=True,
prepared=True)
for stc in stcs:
stc_psd_gen = stc
assert_array_almost_equal(stc_psd.data, stc_psd_gen.data)
# compare with direct computation
stc = apply_inverse_epochs(one_epochs,
inv,
lambda2=lambda2,
method=method,
pick_ori="normal",
label=label,
prepared=True)[0]
sfreq = epochs.info['sfreq']
psd, freqs = psd_array_multitaper(stc.data,
sfreq=sfreq,
bandwidth=bandwidth,
fmin=fmin,
fmax=fmax)
assert_array_almost_equal(psd, stc_psd.data)
assert_array_almost_equal(freqs, stc_psd.times)
# Check corner cases caused by tiny bandwidth
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
compute_source_psd_epochs(one_epochs,
inv,
lambda2=lambda2,
method=method,
pick_ori="normal",
label=label,
bandwidth=0.01,
low_bias=True,
fmin=fmin,
fmax=fmax,
return_generator=False,
prepared=True)
compute_source_psd_epochs(one_epochs,
inv,
lambda2=lambda2,
method=method,
pick_ori="normal",
label=label,
bandwidth=0.01,
low_bias=False,
fmin=fmin,
fmax=fmax,
return_generator=False,
prepared=True)
assert_true(len(w) >= 2)
assert_true(any('not properly use' in str(ww.message) for ww in w))
assert_true(any('Bandwidth too small' in str(ww.message) for ww in w))
def test_source_psd_epochs():
"""Test multi-taper source PSD computation in label from epochs."""
raw = read_raw_fif(fname_data)
inverse_operator = read_inverse_operator(fname_inv)
label = read_label(fname_label)
event_id, tmin, tmax = 1, -0.2, 0.5
lambda2, method = 1. / 9., 'dSPM'
bandwidth = 8.
fmin, fmax = 0, 100
picks = pick_types(raw.info, meg=True, eeg=False, stim=True,
ecg=True, eog=True, include=['STI 014'],
exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
events = find_events(raw, stim_channel='STI 014')
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject)
# only look at one epoch
epochs.drop_bad()
one_epochs = epochs[:1]
inv = prepare_inverse_operator(inverse_operator, nave=1,
lambda2=1. / 9., method="dSPM")
# return list
stc_psd = compute_source_psd_epochs(one_epochs, inv,
lambda2=lambda2, method=method,
pick_ori="normal", label=label,
bandwidth=bandwidth,
fmin=fmin, fmax=fmax,
prepared=True)[0]
# return generator
stcs = compute_source_psd_epochs(one_epochs, inv,
lambda2=lambda2, method=method,
pick_ori="normal", label=label,
bandwidth=bandwidth,
fmin=fmin, fmax=fmax,
return_generator=True,
prepared=True)
for stc in stcs:
stc_psd_gen = stc
assert_array_almost_equal(stc_psd.data, stc_psd_gen.data)
# compare with direct computation
stc = apply_inverse_epochs(one_epochs, inv,
lambda2=lambda2, method=method,
pick_ori="normal", label=label,
prepared=True)[0]
sfreq = epochs.info['sfreq']
psd, freqs = _psd_multitaper(stc.data, sfreq=sfreq, bandwidth=bandwidth,
fmin=fmin, fmax=fmax)
assert_array_almost_equal(psd, stc_psd.data)
assert_array_almost_equal(freqs, stc_psd.times)
# Check corner cases caused by tiny bandwidth
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
compute_source_psd_epochs(one_epochs, inv,
lambda2=lambda2, method=method,
pick_ori="normal", label=label,
bandwidth=0.01, low_bias=True,
fmin=fmin, fmax=fmax,
return_generator=False,
prepared=True)
compute_source_psd_epochs(one_epochs, inv,
lambda2=lambda2, method=method,
pick_ori="normal", label=label,
bandwidth=0.01, low_bias=False,
fmin=fmin, fmax=fmax,
return_generator=False,
prepared=True)
assert_true(len(w) >= 2)
assert_true(any('not properly use' in str(ww.message) for ww in w))
assert_true(any('Bandwidth too small' in str(ww.message) for ww in w))
def test_apply_mne_inverse_epochs():
"""Test MNE with precomputed inverse operator on Epochs."""
inverse_operator = read_inverse_operator(fname_full)
label_lh = read_label(fname_label % 'Aud-lh')
label_rh = read_label(fname_label % 'Aud-rh')
event_id, tmin, tmax = 1, -0.2, 0.5
raw = read_raw_fif(fname_raw)
picks = pick_types(raw.info,
meg=True,
eeg=False,
stim=True,
ecg=True,
eog=True,
include=['STI 014'],
exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
flat = dict(grad=1e-15, mag=1e-15)
events = read_events(fname_event)[:15]
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
reject=reject,
flat=flat)
inverse_operator = prepare_inverse_operator(inverse_operator,
nave=1,
lambda2=lambda2,
method="dSPM")
for pick_ori in [None, "normal", "vector"]:
stcs = apply_inverse_epochs(epochs,
inverse_operator,
lambda2,
"dSPM",
label=label_lh,
pick_ori=pick_ori)
stcs2 = apply_inverse_epochs(epochs,
inverse_operator,
lambda2,
"dSPM",
label=label_lh,
pick_ori=pick_ori,
prepared=True)
# test if using prepared and not prepared inverse operator give the
# same result
assert_array_almost_equal(stcs[0].data, stcs2[0].data)
assert_array_almost_equal(stcs[0].times, stcs2[0].times)
assert (len(stcs) == 2)
assert (3 < stcs[0].data.max() < 10)
assert (stcs[0].subject == 'sample')
inverse_operator = read_inverse_operator(fname_full)
stcs = apply_inverse_epochs(epochs,
inverse_operator,
lambda2,
"dSPM",
label=label_lh,
pick_ori='normal')
data = sum(stc.data for stc in stcs) / len(stcs)
flip = label_sign_flip(label_lh, inverse_operator['src'])
label_mean = np.mean(data, axis=0)
label_mean_flip = np.mean(flip[:, np.newaxis] * data, axis=0)
assert (label_mean.max() < label_mean_flip.max())
# test extracting a BiHemiLabel
inverse_operator = prepare_inverse_operator(inverse_operator,
nave=1,
lambda2=lambda2,
method="dSPM")
stcs_rh = apply_inverse_epochs(epochs,
inverse_operator,
lambda2,
"dSPM",
label=label_rh,
pick_ori="normal",
prepared=True)
stcs_bh = apply_inverse_epochs(epochs,
inverse_operator,
lambda2,
"dSPM",
label=label_lh + label_rh,
pick_ori="normal",
prepared=True)
n_lh = len(stcs[0].data)
assert_array_almost_equal(stcs[0].data, stcs_bh[0].data[:n_lh])
assert_array_almost_equal(stcs_rh[0].data, stcs_bh[0].data[n_lh:])
# test without using a label (so delayed computation is used)
stcs = apply_inverse_epochs(epochs,
inverse_operator,
lambda2,
"dSPM",
pick_ori="normal",
prepared=True)
assert (stcs[0].subject == 'sample')
label_stc = stcs[0].in_label(label_rh)
assert (label_stc.subject == 'sample')
assert_array_almost_equal(stcs_rh[0].data, label_stc.data)
def test_apply_mne_inverse_epochs():
"""Test MNE with precomputed inverse operator on Epochs."""
inverse_operator = read_inverse_operator(fname_full)
label_lh = read_label(fname_label % 'Aud-lh')
label_rh = read_label(fname_label % 'Aud-rh')
event_id, tmin, tmax = 1, -0.2, 0.5
raw = read_raw_fif(fname_raw)
picks = pick_types(raw.info, meg=True, eeg=False, stim=True, ecg=True,
eog=True, include=['STI 014'], exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
flat = dict(grad=1e-15, mag=1e-15)
events = read_events(fname_event)[:15]
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject, flat=flat)
inverse_operator = prepare_inverse_operator(inverse_operator, nave=1,
lambda2=lambda2,
method="dSPM")
for pick_ori in [None, "normal", "vector"]:
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh, pick_ori=pick_ori)
stcs2 = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh, pick_ori=pick_ori,
prepared=True)
# test if using prepared and not prepared inverse operator give the
# same result
assert_array_almost_equal(stcs[0].data, stcs2[0].data)
assert_array_almost_equal(stcs[0].times, stcs2[0].times)
assert (len(stcs) == 2)
assert (3 < stcs[0].data.max() < 10)
assert (stcs[0].subject == 'sample')
inverse_operator = read_inverse_operator(fname_full)
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh, pick_ori='normal')
data = sum(stc.data for stc in stcs) / len(stcs)
flip = label_sign_flip(label_lh, inverse_operator['src'])
label_mean = np.mean(data, axis=0)
label_mean_flip = np.mean(flip[:, np.newaxis] * data, axis=0)
assert (label_mean.max() < label_mean_flip.max())
# test extracting a BiHemiLabel
inverse_operator = prepare_inverse_operator(inverse_operator, nave=1,
lambda2=lambda2,
method="dSPM")
stcs_rh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_rh, pick_ori="normal",
prepared=True)
stcs_bh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh + label_rh,
pick_ori="normal",
prepared=True)
n_lh = len(stcs[0].data)
assert_array_almost_equal(stcs[0].data, stcs_bh[0].data[:n_lh])
assert_array_almost_equal(stcs_rh[0].data, stcs_bh[0].data[n_lh:])
# test without using a label (so delayed computation is used)
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
pick_ori="normal", prepared=True)
assert (stcs[0].subject == 'sample')
label_stc = stcs[0].in_label(label_rh)
assert (label_stc.subject == 'sample')
assert_array_almost_equal(stcs_rh[0].data, label_stc.data)
def test_source_psd_epochs():
"""Test multi-taper source PSD computation in label from epochs."""
raw = read_raw_fif(fname_data)
inverse_operator = read_inverse_operator(fname_inv)
label = read_label(fname_label)
event_id, tmin, tmax = 1, -0.2, 0.5
lambda2, method = 1. / 9., 'dSPM'
bandwidth = 8.
fmin, fmax = 0, 100
picks = pick_types(raw.info,
meg=True,
eeg=False,
stim=True,
ecg=True,
eog=True,
include=['STI 014'],
exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
events = find_events(raw, stim_channel='STI 014')
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
reject=reject)
# only look at one epoch
epochs.drop_bad()
one_epochs = epochs[:1]
inv = prepare_inverse_operator(inverse_operator,
nave=1,
lambda2=1. / 9.,
method="dSPM")
# return list
stc_psd = compute_source_psd_epochs(one_epochs,
inv,
lambda2=lambda2,
method=method,
pick_ori="normal",
label=label,
bandwidth=bandwidth,
fmin=fmin,
fmax=fmax,
prepared=True)[0]
# return generator
stcs = compute_source_psd_epochs(one_epochs,
inv,
lambda2=lambda2,
method=method,
pick_ori="normal",
label=label,
bandwidth=bandwidth,
fmin=fmin,
fmax=fmax,
return_generator=True,
prepared=True)
for stc in stcs:
stc_psd_gen = stc
assert_allclose(stc_psd.data, stc_psd_gen.data, atol=1e-7)
# compare with direct computation
stc = apply_inverse_epochs(one_epochs,
inv,
lambda2=lambda2,
method=method,
pick_ori="normal",
label=label,
prepared=True)[0]
sfreq = epochs.info['sfreq']
psd, freqs = psd_array_multitaper(stc.data,
sfreq=sfreq,
bandwidth=bandwidth,
fmin=fmin,
fmax=fmax)
assert_allclose(psd, stc_psd.data, atol=1e-7)
assert_allclose(freqs, stc_psd.times)
# Check corner cases caused by tiny bandwidth
with pytest.raises(ValueError, match='use a value of at least'):
compute_source_psd_epochs(one_epochs,
inv,
lambda2=lambda2,
method=method,
pick_ori="normal",
label=label,
bandwidth=0.01,
low_bias=True,
fmin=fmin,
fmax=fmax,
return_generator=False,
prepared=True)
def test_source_psd_epochs():
"""Test multi-taper source PSD computation in label from epochs"""
raw = fiff.Raw(fname_data)
inverse_operator = read_inverse_operator(fname_inv)
label = read_label(fname_label)
event_id, tmin, tmax = 1, -0.2, 0.5
lambda2, method = 1. / 9., 'dSPM'
bandwidth = 8.
fmin, fmax = 0, 100
picks = fiff.pick_types(raw.info,
meg=True,
eeg=False,
stim=True,
ecg=True,
eog=True,
include=['STI 014'],
exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
events = find_events(raw, stim_channel='STI 014')
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
reject=reject)
# only look at one epoch
epochs.drop_bad_epochs()
one_epochs = epochs[:1]
# return list
stc_psd = compute_source_psd_epochs(one_epochs,
inverse_operator,
lambda2=lambda2,
method=method,
pick_ori="normal",
label=label,
bandwidth=bandwidth,
fmin=fmin,
fmax=fmax)[0]
# return generator
stcs = compute_source_psd_epochs(one_epochs,
inverse_operator,
lambda2=lambda2,
method=method,
pick_ori="normal",
label=label,
bandwidth=bandwidth,
fmin=fmin,
fmax=fmax,
return_generator=True)
for stc in stcs:
stc_psd_gen = stc
assert_array_almost_equal(stc_psd.data, stc_psd_gen.data)
# compare with direct computation
stc = apply_inverse_epochs(one_epochs,
inverse_operator,
lambda2=lambda2,
method=method,
pick_ori="normal",
label=label)[0]
sfreq = epochs.info['sfreq']
psd, freqs = multitaper_psd(stc.data,
sfreq=sfreq,
bandwidth=bandwidth,
fmin=fmin,
fmax=fmax)
assert_array_almost_equal(psd, stc_psd.data)
assert_array_almost_equal(freqs, stc_psd.times)
def test_source_psd_epochs():
"""Test multi-taper source PSD computation in label from epochs."""
raw = read_raw_fif(fname_data)
inverse_operator = read_inverse_operator(fname_inv)
label = read_label(fname_label)
event_id, tmin, tmax = 1, -0.2, 0.5
lambda2, method = 1. / 9., 'dSPM'
bandwidth = 8.
fmin, fmax = 0, 100
picks = pick_types(raw.info, meg=True, eeg=False, stim=True,
ecg=True, eog=True, include=['STI 014'],
exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
events = find_events(raw, stim_channel='STI 014')
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject)
# only look at one epoch
epochs.drop_bad()
one_epochs = epochs[:1]
inv = prepare_inverse_operator(inverse_operator, nave=1,
lambda2=1. / 9., method="dSPM")
# return list
stc_psd = compute_source_psd_epochs(one_epochs, inv,
lambda2=lambda2, method=method,
pick_ori="normal", label=label,
bandwidth=bandwidth,
fmin=fmin, fmax=fmax,
prepared=True)[0]
# return generator
stcs = compute_source_psd_epochs(one_epochs, inv,
lambda2=lambda2, method=method,
pick_ori="normal", label=label,
bandwidth=bandwidth,
fmin=fmin, fmax=fmax,
return_generator=True,
prepared=True)
for stc in stcs:
stc_psd_gen = stc
assert_allclose(stc_psd.data, stc_psd_gen.data, atol=1e-7)
# compare with direct computation
stc = apply_inverse_epochs(one_epochs, inv,
lambda2=lambda2, method=method,
pick_ori="normal", label=label,
prepared=True)[0]
sfreq = epochs.info['sfreq']
psd, freqs = psd_array_multitaper(stc.data, sfreq=sfreq,
bandwidth=bandwidth, fmin=fmin,
fmax=fmax)
assert_allclose(psd, stc_psd.data, atol=1e-7)
assert_allclose(freqs, stc_psd.times)
# Check corner cases caused by tiny bandwidth
with pytest.raises(ValueError, match='use a value of at least'):
compute_source_psd_epochs(
one_epochs, inv, lambda2=lambda2, method=method,
pick_ori="normal", label=label, bandwidth=0.01, low_bias=True,
fmin=fmin, fmax=fmax, return_generator=False, prepared=True)
