def test_wavelets(self):
eegs = self.eegs[:, :, :-1]
base_eegs = self.base_eegs
wf = MorletWaveletFilter(
timeseries=base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
)
pow_wavelet, phase_wavelet = wf.filter()
print('pow_wavelet=', pow_wavelet)
from ptsa.wavelet import phase_pow_multi
pow_wavelet_ptsa_orig = phase_pow_multi(freqs=np.logspace(
np.log10(3), np.log10(180), 8),
dat=eegs,
to_return='power')
print('pow_wavelets_ptsa_orig=', pow_wavelet_ptsa_orig)
# import matplotlib;
# matplotlib.use('Qt4Agg')
#
#
# import matplotlib.pyplot as plt
# plt.get_current_fig_manager().window.raise_()
#
wavelet_1 = pow_wavelet[0, 0, 0, 500:-500]
wavelet_2 = pow_wavelet_ptsa_orig[0, 0, 0, 500:-500]
#
# plt.plot(np.arange(wavelet_1.shape[0])-1,wavelet_1,'k')
# plt.plot(np.arange(wavelet_2.shape[0])-1,wavelet_2,'r--')
#
# plt.show()
assert_array_equal(eegs, base_eegs.data)
# assert_array_equal(wavelet_1, wavelet_2)
# assert_array_almost_equal((wavelet_1-wavelet_2)/wavelet_1, np.zeros_like(wavelet_1), decimal=4)
# assert_array_almost_equal((pow_wavelet_ptsa_orig-pow_wavelet)/pow_wavelet_ptsa_orig, np.zeros_like(pow_wavelet), decimal=4)
assert_array_almost_equal(
(pow_wavelet_ptsa_orig - pow_wavelet) / pow_wavelet_ptsa_orig,
np.zeros_like(pow_wavelet),
decimal=6)
freq_num = 7
assert_array_equal((pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500] -
pow_wavelet[freq_num, :, :, 500:-500]) /
pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500],
np.zeros_like(pow_wavelet[freq_num, :, :,
500:-500]))
def test_wavelets(self):
eegs = self.eegs[:, :, :-1]
base_eegs = self.base_eegs
wf = MorletWaveletFilter(time_series=base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
)
pow_wavelet, phase_wavelet = wf.filter()
print 'pow_wavelet=',pow_wavelet
from ptsa.wavelet import phase_pow_multi
pow_wavelet_ptsa_orig = phase_pow_multi(freqs=np.logspace(np.log10(3), np.log10(180), 8), dat=eegs,to_return='power')
print 'pow_wavelets_ptsa_orig=',pow_wavelet_ptsa_orig
# import matplotlib;
# matplotlib.use('Qt4Agg')
#
#
# import matplotlib.pyplot as plt
# plt.get_current_fig_manager().window.raise_()
#
wavelet_1 = pow_wavelet[0,0,0,500:-500]
wavelet_2 = pow_wavelet_ptsa_orig[0,0,0,500:-500]
#
# plt.plot(np.arange(wavelet_1.shape[0])-1,wavelet_1,'k')
# plt.plot(np.arange(wavelet_2.shape[0])-1,wavelet_2,'r--')
#
# plt.show()
assert_array_equal(eegs, base_eegs.data)
# assert_array_equal(wavelet_1, wavelet_2)
# assert_array_almost_equal((wavelet_1-wavelet_2)/wavelet_1, np.zeros_like(wavelet_1), decimal=4)
# assert_array_almost_equal((pow_wavelet_ptsa_orig-pow_wavelet)/pow_wavelet_ptsa_orig, np.zeros_like(pow_wavelet), decimal=4)
assert_array_almost_equal(
(pow_wavelet_ptsa_orig-pow_wavelet)/pow_wavelet_ptsa_orig,
np.zeros_like(pow_wavelet), decimal=6)
freq_num = 7
assert_array_equal(
(pow_wavelet_ptsa_orig[freq_num,:,:,500:-500]-pow_wavelet[freq_num,:,:,500:-500])/pow_wavelet_ptsa_orig[freq_num,:,:,500:-500],
np.zeros_like(pow_wavelet[freq_num,:,:,500:-500]))
def compute_powers(self, events, sessions, channels, tal_info):
n_freqs = len(self.params.freqs)
n_bps = len(tal_info)
nt = int((self.params.fr1_end_time-self.params.fr1_start_time+2*self.params.fr1_buf+1e-5) * 50)
nb = int((self.params.fr1_buf+1e-5) * 50)
n_times = nt - 2*nb
self.pow_mat = None
for sess in sessions:
sess_events = events[events.session == sess]
n_events = len(sess_events)
print 'Loading EEG for', n_events, 'events of session', sess
eegs = Events(sess_events).get_data(channels=channels, start_time=self.params.fr1_start_time, end_time=self.params.fr1_end_time,
buffer_time=self.params.fr1_buf, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False)
print 'Computing FR1 powers'
sess_pow_mat = np.empty(shape=(n_events, n_bps, n_freqs, n_times), dtype=np.float)
for i,ti in enumerate(tal_info):
bp = ti['channel_str']
print 'Computing powers for bipolar pair', bp
elec1 = np.where(channels == bp[0])[0][0]
elec2 = np.where(channels == bp[1])[0][0]
bp_data = eegs[elec1] - eegs[elec2]
bp_data = bp_data.filtered([58,62], filt_type='stop', order=self.params.filt_order)
for ev in xrange(n_events):
pow_ev = phase_pow_multi(self.params.freqs, bp_data[ev], to_return='power')
if np.min(pow_ev) < 0.0:
print ev, events[ev]
joblib.dump(bp_data[ev], 'bad_bp_ev%d'%ev)
joblib.dump(eegs[elec1][ev], 'bad_elec1_ev%d'%ev)
joblib.dump(eegs[elec2][ev], 'bad_elec2_ev%d'%ev)
print 'Negative powers detected'
import sys
sys.exit(1)
if self.params.log_powers:
np.log10(pow_ev, out=pow_ev)
pow_ev = resample(pow_ev, num=nt, axis=1)
sess_pow_mat[ev,i,:,:] = pow_ev[:,nb:-nb]
self.pow_mat = np.concatenate((self.pow_mat,sess_pow_mat), axis=0) if self.pow_mat is not None else sess_pow_mat
self.pow_mat = np.reshape(np.mean(self.pow_mat, axis=3), (len(events), n_bps*n_freqs))
def compute_fr1_powers(events, sessions, channels, tal_info):
n_freqs = len(Params.freqs)
n_bps = len(tal_info)
pow_mat = None
recalls = None
for sess in sessions:
sess_events = events[events.session == sess]
n_events = len(sess_events)
sess_recalls = sess_events.recalled
print 'Loading EEG for', n_events, 'events of session', sess
eegs = sess_events.get_data(channels=channels, start_time=Params.fr1_start_time, end_time=Params.fr1_end_time,
buffer_time=Params.fr1_buf, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False)
print 'Computing FR1 powers'
sess_pow_mat = np.empty(shape=(n_events, n_bps, n_freqs), dtype=np.float)
for i,ti in enumerate(tal_info):
bp = ti['channel_str']
print bp
elec1 = np.where(channels == bp[0])[0][0]
elec2 = np.where(channels == bp[1])[0][0]
bp_data = eegs[elec1] - eegs[elec2]
bp_data = bp_data.filtered([58,62], filt_type='stop', order=1)
for ev in xrange(n_events):
pow_ev = phase_pow_multi(Params.freqs, bp_data[ev], to_return='power')
pow_ev = pow_ev.remove_buffer(Params.fr1_buf)
pow_ev = np.nanmean(pow_ev, 1)
sess_pow_mat[ev,i,:] = pow_ev
sess_pow_mat = sess_pow_mat.reshape((n_events, n_bps*n_freqs))
sess_pow_mat = zscore(sess_pow_mat, axis=0, ddof=1)
pow_mat = np.vstack((pow_mat,sess_pow_mat)) if pow_mat is not None else sess_pow_mat
recalls = np.hstack((recalls,sess_recalls)) if recalls is not None else sess_recalls
return pow_mat, recalls
def test_wavelets_synthetic_data(self):
samplerate = 1000.
frequency = 180.0
modulation_frequency = 80.0
duration = 1.0
n_points = int(np.round(duration * samplerate))
x = np.arange(n_points, dtype=np.float)
y = np.sin(x * (2 * np.pi * frequency / n_points))
y_mod = np.sin(x * (2 * np.pi * frequency / n_points)) * np.sin(
x * (2 * np.pi * modulation_frequency / n_points))
ts = TimeSeries(y, dims=['time'], coords=[x])
ts['samplerate'] = samplerate
ts.attrs['samplerate'] = samplerate
frequencies = [10.0, 30.0, 50.0, 80., 120., 180., 250.0, 300.0, 500.]
for frequency in frequencies:
wf = MorletWaveletFilter(timeseries=ts,
freqs=np.array([frequency]),
output='both',
frequency_dim_pos=0,
verbose=True)
pow_wavelet, phase_wavelet = wf.filter()
from ptsa.wavelet import phase_pow_multi
pow_wavelet_ptsa_orig = phase_pow_multi(freqs=[frequency],
samplerates=samplerate,
dat=ts.data,
to_return='power')
assert_array_almost_equal(
(pow_wavelet_ptsa_orig - pow_wavelet) / pow_wavelet_ptsa_orig,
np.zeros_like(pow_wavelet),
decimal=6)
def test_wavelets_synthetic_data(self):
samplerate = 1000.
frequency = 180.0
modulation_frequency = 80.0
duration = 1.0
n_points = int(np.round(duration*samplerate))
x = np.arange(n_points, dtype=np.float)
y = np.sin(x*(2*np.pi*frequency/n_points))
y_mod = np.sin(x*(2*np.pi*frequency/n_points))* np.sin(x*(2*np.pi*modulation_frequency/n_points))
ts = TimeSeriesX(y, dims=['time'], coords=[x])
ts['samplerate']=samplerate
ts.attrs['samplerate'] = samplerate
frequencies = [ 10.0, 30.0, 50.0, 80., 120., 180., 250.0 , 300.0, 500.]
for frequency in frequencies:
wf = MorletWaveletFilter(time_series=ts,
freqs=np.array([frequency]),
output='both',
frequency_dim_pos=0,
verbose=True
)
pow_wavelet, phase_wavelet = wf.filter()
from ptsa.wavelet import phase_pow_multi
pow_wavelet_ptsa_orig = phase_pow_multi(freqs=[frequency],samplerates=samplerate, dat=ts.data,to_return='power')
assert_array_almost_equal(
(pow_wavelet_ptsa_orig-pow_wavelet)/pow_wavelet_ptsa_orig,
np.zeros_like(pow_wavelet), decimal=6)
def test_wavelets_cpp(self):
eegs = self.eegs[:, :, :-1]
base_eegs = self.base_eegs
sys.path.append('/Users/m/src/morlet_git_install')
import morlet
num_freqs = 8
f_min = 3.0
f_max = 180.0
signal_length = base_eegs.shape[-1]
morlet_transform = morlet.MorletWaveletTransform()
samplerate = float(base_eegs['samplerate'])
morlet_transform.init(5, f_min, f_max, num_freqs, samplerate , signal_length)
signal = base_eegs[0:1,0:1,:]
signal_orig_eegs = eegs[0:1,0:1,:]
pow_wavelets_cpp = np.empty(shape=(base_eegs.shape[-1]*num_freqs,), dtype=np.float)
# for i in xrange(num_of_iterations):
# morlet_transform.multiphasevec(signal,powers)
morlet_transform.multiphasevec(signal.data.flatten(),pow_wavelets_cpp)
pow_wavelets_cpp = pow_wavelets_cpp.reshape(8,pow_wavelets_cpp.shape[0]/8)
wf = MorletWaveletFilter(time_series=signal,
freqs=np.logspace(np.log10(f_min), np.log10(f_max), num_freqs),
output='power',
frequency_dim_pos=0,
)
pow_wavelet, phase_wavelet = wf.filter()
from ptsa.wavelet import phase_pow_multi
pow_wavelet_ptsa_orig = phase_pow_multi(freqs=np.logspace(np.log10(3), np.log10(180), 8), dat=signal_orig_eegs,to_return='power')
freq_num = 0
decimal = 1
assert_array_almost_equal(
(np.squeeze(pow_wavelet[freq_num,:,:,500:-500])-np.squeeze(pow_wavelet_ptsa_orig[freq_num,:,:,500:-500]))/np.squeeze(pow_wavelet_ptsa_orig[freq_num,:,:,500:-500]),
np.zeros_like(np.squeeze(pow_wavelet_ptsa_orig[freq_num,:,:,500:-500])), decimal=decimal)
assert_array_almost_equal(
(pow_wavelets_cpp[freq_num,500:-500]-np.squeeze(pow_wavelet[freq_num,:,:,500:-500]))/pow_wavelets_cpp[freq_num,500:-500],
np.zeros_like(pow_wavelets_cpp[freq_num,500:-500]), decimal=decimal)
#
assert_array_almost_equal(
(pow_wavelets_cpp[freq_num,500:-500]-np.squeeze(pow_wavelet_ptsa_orig[freq_num,:,:,500:-500]))/pow_wavelets_cpp[freq_num,500:-500],
np.zeros_like(np.squeeze(pow_wavelet_ptsa_orig[freq_num,:,:,500:-500])), decimal=decimal)
from ptsa.wavelet import phase_pow_multi
filt_freq = 20.,
filt_type = 'low',
keep_buffer=True
)
ndat = events[events.recalled==False].get_data(0, # channel
1.0, # duration in sec
0.0, # offset in sec
buf_dur, # buffer in sec
filt_freq = 20.,
filt_type = 'low',
keep_buffer=True
)
# calc wavelet power
freqs = np.arange(2,50,2)
rpow = phase_pow_multi(freqs,rdat,to_return='power')
npow = phase_pow_multi(freqs,ndat,to_return='power')
# remove the buffer now that we have filtered and calculated power
#for ts in [rdat,ndat,rpow,npow]:
# ts = ts.remove_buffer(buf_dur)
# why does the above not work?
rdat = rdat.remove_buffer(buf_dur)
ndat = ndat.remove_buffer(buf_dur)
rpow = rpow.remove_buffer(buf_dur)
npow = npow.remove_buffer(buf_dur)
# plot ERP
pl.figure(1)
pl.clf()
pl.plot(rdat['time'],rdat.nanmean('events'),'r')
buf_dur, # buffer in sec
filt_freq=20.,
filt_type='low',
keep_buffer=True)
ndat = events[events.recalled == False].get_data(
0, # channel
1.0, # duration in sec
0.0, # offset in sec
buf_dur, # buffer in sec
filt_freq=20.,
filt_type='low',
keep_buffer=True)
# calc wavelet power
freqs = np.arange(2, 50, 2)
rpow = phase_pow_multi(freqs, rdat, to_return='power')
npow = phase_pow_multi(freqs, ndat, to_return='power')
# remove the buffer now that we have filtered and calculated power
#for ts in [rdat,ndat,rpow,npow]:
# ts = ts.remove_buffer(buf_dur)
# why does the above not work?
rdat = rdat.remove_buffer(buf_dur)
ndat = ndat.remove_buffer(buf_dur)
rpow = rpow.remove_buffer(buf_dur)
npow = npow.remove_buffer(buf_dur)
# plot ERP
pl.figure(1)
pl.clf()
pl.plot(rdat['time'], rdat.nanmean('events'), 'r')
def compute_ps_powers(events, sessions, channels, tal_info, experiment):
n_freqs = len(Params.freqs)
n_bps = len(tal_info)
pow_mat_pre = pow_mat_post = None
for sess in sessions:
sess_events = events[events.session == sess]
n_events = len(sess_events)
print 'Loading EEG for', n_events, 'events of session', sess
eegs_pre = sess_events.get_data(channels=channels, start_time=Params.ps_pre_start_time, end_time=Params.ps_pre_end_time,
buffer_time=Params.ps_pre_buf, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False)
eegs_post = np.empty_like(eegs_pre)
post_start_time = Params.ps_post_offset
post_end_time = Params.ps_post_offset + (Params.ps_pre_end_time - Params.ps_pre_start_time)
for i_ev in xrange(n_events):
ev_offset = sess_events[i_ev].pulse_duration
if ev_offset > 0:
if experiment == 'PS3' and sess_events[i_ev].nBursts > 0:
ev_offset *= sess_events[i_ev].nBursts + 1
ev_offset *= 0.001
else:
ev_offset = 0.0
eegs_post[:,i_ev:i_ev+1,:] = sess_events[i_ev:i_ev+1].get_data(channels=channels, start_time=post_start_time+ev_offset,
end_time=post_end_time+ev_offset, buffer_time=Params.ps_pre_buf, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False)
print 'Computing', experiment, 'powers'
sess_pow_mat_pre = np.empty(shape=(n_events, n_bps, n_freqs), dtype=np.float)
sess_pow_mat_post = np.empty_like(sess_pow_mat_pre)
for i,ti in enumerate(tal_info):
bp = ti['channel_str']
print bp
elec1 = np.where(channels == bp[0])[0][0]
elec2 = np.where(channels == bp[1])[0][0]
bp_data_pre = eegs_pre[elec1] - eegs_pre[elec2]
bp_data_pre = bp_data_pre.filtered([58,62], filt_type='stop', order=1)
for ev in xrange(n_events):
pow_pre_ev = phase_pow_multi(Params.freqs, bp_data_pre[ev], to_return='power')
pow_pre_ev = pow_pre_ev.remove_buffer(Params.ps_pre_buf)
pow_pre_ev = np.nanmean(pow_pre_ev, 1)
sess_pow_mat_pre[ev,i,:] = pow_pre_ev
bp_data_post = eegs_post[elec1] - eegs_post[elec2]
bp_data_post = bp_data_post.filtered([58,62], filt_type='stop', order=1)
for ev in xrange(n_events):
pow_post_ev = phase_pow_multi(Params.freqs, bp_data_post[ev], to_return='power')
pow_post_ev = pow_post_ev.remove_buffer(Params.ps_pre_buf)
pow_post_ev = np.nanmean(pow_post_ev, 1)
sess_pow_mat_post[ev,i,:] = pow_post_ev
sess_pow_mat_pre = sess_pow_mat_pre.reshape((n_events, n_bps*n_freqs))
sess_pow_mat_pre = zscore(sess_pow_mat_pre, axis=0, ddof=1)
sess_pow_mat_post = sess_pow_mat_post.reshape((n_events, n_bps*n_freqs))
sess_pow_mat_post = zscore(sess_pow_mat_post, axis=0, ddof=1)
pow_mat_pre = np.vstack((pow_mat_pre,sess_pow_mat_pre)) if pow_mat_pre is not None else sess_pow_mat_pre
pow_mat_post = np.vstack((pow_mat_post,sess_pow_mat_post)) if pow_mat_post is not None else sess_pow_mat_post
return pow_mat_pre, pow_mat_post
# ev_data_dict = edc.filter()
# print ev_data_dict
# wavelets
freqs = np.logspace(np.log10(3), np.log10(180), 12)
for session_file, ev_data in ev_data_dict.items():
break
print ev_data
bp = ev_data.values[0, 0, :] - ev_data.values[1, 0, :]
from ptsa.wavelet import phase_pow_multi
pow_ev_new = phase_pow_multi(freqs, bp, to_return='power', samplerates=ev_data.attrs['samplerate'])
print 'pow_ev_new=', pow_ev_new
for session_file, session_data in ts_dict.items():
break
bp_sess_0 = session_data.values[0, 0, :] - session_data.values[1, 0, :]
print bp_sess_0
pow_sess_new_0 = phase_pow_multi(freqs, bp_sess_0, to_return='power', samplerates=ev_data.attrs['samplerate'])
print pow_sess_new_0
pow_xray_0 = xray.DataArray(pow_sess_new_0.reshape(1, 1, pow_sess_new_0.shape[0], pow_sess_new_0.shape[1]),
coords=[['002_003'], np.arange(1), freqs, session_data['time']],
def test_wavelets_cpp(self):
eegs = self.eegs[:, :, :-1]
base_eegs = self.base_eegs
# if not sys.platform.startswith('win'):
# sys.path.append('/Users/m/src/morlet_git_install')
import ptsa.extensions.morlet as morlet
num_freqs = 8
f_min = 3.0
f_max = 180.0
signal_length = base_eegs.shape[-1]
morlet_transform = morlet.MorletWaveletTransform()
samplerate = float(base_eegs['samplerate'])
morlet_transform.init(5, f_min, f_max, num_freqs, samplerate,
signal_length)
signal = base_eegs[0:1, 0:1, :]
signal_orig_eegs = eegs[0:1, 0:1, :]
pow_wavelets_cpp = np.empty(shape=(base_eegs.shape[-1] * num_freqs, ),
dtype=np.float)
# for i in xrange(num_of_iterations):
# morlet_transform.multiphasevec(signal,powers)
morlet_transform.multiphasevec(signal.data.flatten(), pow_wavelets_cpp)
pow_wavelets_cpp = pow_wavelets_cpp.reshape(
8, pow_wavelets_cpp.shape[0] / 8)
wf = MorletWaveletFilter(
timeseries=signal,
freqs=np.logspace(np.log10(f_min), np.log10(f_max), num_freqs),
output='power',
frequency_dim_pos=0,
)
pow_wavelet, phase_wavelet = wf.filter()
from ptsa.wavelet import phase_pow_multi
pow_wavelet_ptsa_orig = phase_pow_multi(freqs=np.logspace(
np.log10(3), np.log10(180), 8),
dat=signal_orig_eegs,
to_return='power')
freq_num = 0
decimal = 1
assert_array_almost_equal(
(np.squeeze(pow_wavelet[freq_num, :, :, 500:-500]) -
np.squeeze(pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500])) /
np.squeeze(pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500]),
np.zeros_like(
np.squeeze(pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500])),
decimal=decimal)
assert_array_almost_equal(
(pow_wavelets_cpp[freq_num, 500:-500] -
np.squeeze(pow_wavelet[freq_num, :, :, 500:-500])) /
pow_wavelets_cpp[freq_num, 500:-500],
np.zeros_like(pow_wavelets_cpp[freq_num, 500:-500]),
decimal=decimal)
#
assert_array_almost_equal(
(pow_wavelets_cpp[freq_num, 500:-500] -
np.squeeze(pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500])) /
pow_wavelets_cpp[freq_num, 500:-500],
np.zeros_like(
np.squeeze(pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500])),
decimal=decimal)
from ptsa.wavelet import phase_pow_multi
newevs[field] = matevs[field]
events = Events(newevs)
events = events.add_fields(esrc=np.dtype(RawBinWrapper))
good_indices = np.ones(len(events),np.bool)
for e,event in enumerate(events):
try:
event['esrc'] = RawBinWrapper(event['eegfile'])
except IOError:
print('No EEG files for',event['subject'],event['session'],event['eegfile'])
good_indices[e] = False
events = events[good_indices]
start_time = -0.6
end_time = 1.6
buf = 1
baseline = (-.6,-.4)
# eeghz = 500
powhz = 50
freqs = np.logspace(np.log10(3),np.log10(180),12)
chan = 0
dat = events[10:20].get_data(
channels=chan,start_time=start_time,end_time=end_time,buffer_time=buf,
eoffset='eegoffset',keep_buffer=True)
dat = phase_pow_multi(freqs,dat[0],to_return='power')
events = events.add_fields(esrc=np.dtype(RawBinWrapper))
good_indices = np.ones(len(events), np.bool)
for e, event in enumerate(events):
try:
event['esrc'] = RawBinWrapper(event['eegfile'])
except IOError:
print('No EEG files for', event['subject'], event['session'],
event['eegfile'])
good_indices[e] = False
events = events[good_indices]
start_time = -0.6
end_time = 1.6
buf = 1
baseline = (-.6, -.4)
# eeghz = 500
powhz = 50
freqs = np.logspace(np.log10(3), np.log10(180), 12)
chan = 0
dat = events[10:20].get_data(channels=chan,
start_time=start_time,
end_time=end_time,
buffer_time=buf,
eoffset='eegoffset',
keep_buffer=True)
dat = phase_pow_multi(freqs, dat[0], to_return='power')
esrc = [edfw]*len(eoffset)
events = Events(np.rec.fromarrays([esrc,eoffset],
names='esrc,eoffset'))
# load in data with events (resample at the same time)
# check out the ringing induced in the saw-tooth with the resample!
dat = events.get_data(chan_num, # channel
1.0, # duration in sec
0.0, # offset in sec
buf_dur, # buffer in sec
keep_buffer=True,
resampled_rate=500
)
# calc wavelet power
freqs = np.arange(2,50,2)
datpow = phase_pow_multi(freqs,dat,to_return='power')
# remove the buffer now that we have filtered and calculated power
dat = dat.remove_buffer(buf_dur)
datpow = datpow.remove_buffer(buf_dur)
# plot ERP
pl.figure()
pl.clf()
pl.plot(dat['time'],dat.nanmean('events'),'r')
pl.xlabel('Time (s)')
pl.ylabel('Voltage')
# plot power spectrum
pl.figure()
pl.clf()
eoffset = np.arange(20) * samplerate / 4
esrc = [edfw] * len(eoffset)
events = Events(np.rec.fromarrays([esrc, eoffset], names='esrc,eoffset'))
# load in data with events (resample at the same time)
# check out the ringing induced in the saw-tooth with the resample!
dat = events.get_data(
chan_num, # channel
1.0, # duration in sec
0.0, # offset in sec
buf_dur, # buffer in sec
keep_buffer=True,
resampled_rate=500)
# calc wavelet power
freqs = np.arange(2, 50, 2)
datpow = phase_pow_multi(freqs, dat, to_return='power')
# remove the buffer now that we have filtered and calculated power
dat = dat.remove_buffer(buf_dur)
datpow = datpow.remove_buffer(buf_dur)
# plot ERP
pl.figure()
pl.clf()
pl.plot(dat['time'], dat.nanmean('events'), 'r')
pl.xlabel('Time (s)')
pl.ylabel('Voltage')
# plot power spectrum
pl.figure()
pl.clf()
def compute_ps_powers(self, events, sessions, channels, tal_info, experiment):
n_freqs = len(self.params.freqs)
n_bps = len(tal_info)
nt = int((self.params.ps_end_time-self.params.ps_start_time+2*self.params.ps_buf+1e-5) * 50)
nb = int((self.params.ps_buf+1e-5) * 50)
pow_mat_pre = pow_mat_post = None
for sess in sessions:
sess_events = events[events.session == sess]
n_events = len(sess_events)
print 'Loading EEG for', n_events, 'events of session', sess
pre_start_time = self.params.ps_start_time - self.params.ps_offset
pre_end_time = self.params.ps_end_time - self.params.ps_offset
eegs_pre = Events(sess_events).get_data(channels=channels, start_time=pre_start_time, end_time=pre_end_time,
buffer_time=self.params.ps_buf, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False)
# mirroring
nb_ = int((self.params.ps_buf+1e-5) * eegs_pre.samplerate)
eegs_pre[...,-nb_:] = eegs_pre[...,-nb_-1:-2*nb_-1:-1]
dim3_pre = eegs_pre.shape[2] # because post-stim time inreval does not align for all stim events (stims have different duration)
# we have to take care of aligning eegs_post ourselves time dim to dim3
eegs_post = np.zeros_like(eegs_pre)
post_start_time = self.params.ps_offset
post_end_time = self.params.ps_offset + (self.params.ps_end_time - self.params.ps_start_time)
for i_ev in xrange(n_events):
ev_offset = sess_events[i_ev].pulse_duration
if ev_offset > 0:
if experiment == 'PS3' and sess_events[i_ev].nBursts > 0:
ev_offset *= sess_events[i_ev].nBursts + 1
ev_offset *= 0.001
else:
ev_offset = 0.0
eeg_post = Events(sess_events[i_ev:i_ev+1]).get_data(channels=channels, start_time=post_start_time+ev_offset,
end_time=post_end_time+ev_offset, buffer_time=self.params.ps_buf,
eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False)
dim3_post = eeg_post.shape[2]
# here we take care of possible mismatch of time dim length
if dim3_pre == dim3_post:
eegs_post[:,i_ev:i_ev+1,:] = eeg_post
elif dim3_pre < dim3_post:
eegs_post[:,i_ev:i_ev+1,:] = eeg_post[:,:,:-1]
else:
eegs_post[:,i_ev:i_ev+1,:-1] = eeg_post
# mirroring
eegs_post[...,:nb_] = eegs_post[...,2*nb_-1:nb_-1:-1]
print 'Computing', experiment, 'powers'
sess_pow_mat_pre = np.empty(shape=(n_events, n_bps, n_freqs), dtype=np.float)
sess_pow_mat_post = np.empty_like(sess_pow_mat_pre)
for i,ti in enumerate(tal_info):
bp = ti['channel_str']
print 'Computing powers for bipolar pair', bp
elec1 = np.where(channels == bp[0])[0][0]
elec2 = np.where(channels == bp[1])[0][0]
bp_data_pre = eegs_pre[elec1] - eegs_pre[elec2]
bp_data_pre = bp_data_pre.filtered([58,62], filt_type='stop', order=self.params.filt_order)
for ev in xrange(n_events):
pow_pre_ev = phase_pow_multi(self.params.freqs, bp_data_pre[ev], to_return='power')
if self.params.log_powers:
np.log10(pow_pre_ev, out=pow_pre_ev)
pow_pre_ev = resample(pow_pre_ev, num=nt, axis=1)
sess_pow_mat_pre[ev,i,:] = np.mean(pow_pre_ev[:,nb:-nb], axis=1)
bp_data_post = eegs_post[elec1] - eegs_post[elec2]
bp_data_post = bp_data_post.filtered([58,62], filt_type='stop', order=self.params.filt_order)
for ev in xrange(n_events):
pow_post_ev = phase_pow_multi(self.params.freqs, bp_data_post[ev], to_return='power')
if self.params.log_powers:
np.log10(pow_post_ev, out=pow_post_ev)
pow_post_ev = resample(pow_post_ev, num=nt, axis=1)
sess_pow_mat_post[ev,i,:] = np.mean(pow_post_ev[:,nb:-nb], axis=1)
sess_pow_mat_pre = sess_pow_mat_pre.reshape((n_events, n_bps*n_freqs))
sess_pow_mat_pre = zscore(sess_pow_mat_pre, axis=0, ddof=1)
sess_pow_mat_post = sess_pow_mat_post.reshape((n_events, n_bps*n_freqs))
sess_pow_mat_post = zscore(sess_pow_mat_post, axis=0, ddof=1)
pow_mat_pre = np.vstack((pow_mat_pre,sess_pow_mat_pre)) if pow_mat_pre is not None else sess_pow_mat_pre
pow_mat_post = np.vstack((pow_mat_post,sess_pow_mat_post)) if pow_mat_post is not None else sess_pow_mat_post
return pow_mat_pre, pow_mat_post
