def test_eeg_read_incomplete_data(self):
e_path_incomplete = '/Volumes/rhino_root/data/events/RAM_PS/R1104D_events.mat'
if sys.platform.startswith('win'):
e_path_incomplete = 'D:/data/events/RAM_PS/R1104D_events.mat'
base_event_reader = BaseEventReader(filename=e_path_incomplete)
base_events = base_event_reader.read()
sess_1 = base_events[base_events.session == 1]
sess_3 = base_events[base_events.session == 3]
sess_5 = base_events[base_events.session == 5]
sess_7 = base_events[base_events.session == 7]
sess_1[440].eegoffset = 2000000000000
sess_1[444].eegoffset = 2000000000000
sess_1[434].eegoffset = 2000000000000
shuffled_sess_events = np.hstack((sess_3, sess_7, sess_1, sess_5)).view(np.recarray)
eeg_reader = EEGReader(events=shuffled_sess_events, channels=np.array(['002', '003']),
start_time=self.start_time, end_time=self.end_time, buffer_time=self.buffer_time)
base_eegs = eeg_reader.read()
if eeg_reader.removed_bad_data():
print('REMOVED BAD DATA !!!!!!!!!!!!!')
events = base_eegs['events'].data.view(np.recarray)
if not isinstance(events, Events):
events = Events(events)
from ptsa.data.rawbinwrapper import RawBinWrapper
events = events.add_fields(esrc=np.dtype(RawBinWrapper))
# ------------- using PTSAevent reader functions to prepare events for reading old-ptsa-style
ptsa_event_reader = PTSAEventReader()
ptsa_event_reader.attach_rawbinwrapper_groupped(events)
eegs = events.get_data(channels=['002', '003'], start_time=self.start_time, end_time=self.end_time,
buffer_time=self.buffer_time, eoffset='eegoffset', keep_buffer=True,
eoffset_in_time=False, verbose=True)
npt.assert_array_equal(eegs[:, :, :-1], base_eegs.data)
def compute_powers(self, events, sessions,monopolar_channels , bipolar_pairs ):
n_freqs = len(self.params.freqs)
n_bps = len(bipolar_pairs)
self.pow_mat = None
pow_ev = None
winsize = bufsize = 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)
# from ptsa.data.readers import TimeSeriesEEGReader
# time_series_reader = TimeSeriesEEGReader(events=sess_events, start_time=self.params.fr1_start_time,
# end_time=self.params.fr1_end_time, buffer_time=self.params.fr1_buf, keep_buffer=True)
#
# eegs = time_series_reader.read(monopolar_channels)
# VERSION 2/22/2016
# eeg_reader = EEGReader(events=sess_events, channels=monopolar_channels,
# start_time=self.params.fr1_start_time,
# end_time=self.params.fr1_end_time, buffer_time=self.params.fr1_buf)
# VERSION WITH MIRRORING
eeg_reader = EEGReader(events=sess_events, channels=monopolar_channels,
start_time=self.params.fr1_start_time,
end_time=self.params.fr1_end_time, buffer_time=0.0)
eegs = eeg_reader.read()
if eeg_reader.removed_bad_data():
print 'REMOVED SOME BAD EVENTS !!!'
sess_events = eegs['events'].values.view(np.recarray)
n_events = len(sess_events)
events = np.hstack((events[events.session!=sess],sess_events)).view(np.recarray)
ev_order = np.argsort(events, order=('session','list','mstime'))
events = events[ev_order]
self.pass_object(self.pipeline.task+'_events', events)
# mirroring
#eegs[...,:1365] = eegs[...,2730:1365:-1]
#eegs[...,2731:4096] = eegs[...,2729:1364:-1]
eegs = eegs.add_mirror_buffer(duration=self.params.fr1_buf)
if self.samplerate is None:
self.samplerate = float(eegs.samplerate)
winsize = int(round(self.samplerate*(self.params.fr1_end_time-self.params.fr1_start_time+2*self.params.fr1_buf)))
bufsize = int(round(self.samplerate*self.params.fr1_buf))
print 'samplerate =', self.samplerate, 'winsize =', winsize, 'bufsize =', bufsize
pow_ev = np.empty(shape=n_freqs*winsize, dtype=float)
self.wavelet_transform.init(self.params.width, self.params.freqs[0], self.params.freqs[-1], n_freqs, self.samplerate, winsize)
print 'Computing FR1 powers'
sess_pow_mat = np.empty(shape=(n_events, n_bps, n_freqs), dtype=np.float)
#monopolar_channels_np = np.array(monopolar_channels)
for i,ti in enumerate(bipolar_pairs):
# print bp
# print monopolar_channels
# print np.where(monopolar_channels == bp[0])
# print np.where(monopolar_channels == bp[1])
bp = ti['channel_str']
print 'Computing powers for bipolar pair', bp
elec1 = np.where(monopolar_channels == bp[0])[0][0]
elec2 = np.where(monopolar_channels == bp[1])[0][0]
# print 'elec1=',elec1
# print 'elec2=',elec2
# eegs_elec1 = eegs[elec1]
# eegs_elec2 = eegs[elec2]
# print 'eegs_elec1=',eegs_elec1
# print 'eegs_elec2=',eegs_elec2
# eegs_elec1.reset_coords('channels')
# eegs_elec2.reset_coords('channels')
bp_data = eegs[elec1] - eegs[elec2]
bp_data.attrs['samplerate'] = self.samplerate
# bp_data = eegs[elec1] - eegs[elec2]
# bp_data = eegs[elec1] - eegs[elec2]
# bp_data = eegs.values[elec1] - eegs.values[elec2]
bp_data = bp_data.filtered([58,62], filt_type='stop', order=self.params.filt_order)
for ev in xrange(n_events):
self.wavelet_transform.multiphasevec(bp_data[ev][0:winsize], pow_ev)
#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)
pow_ev_stripped = np.reshape(pow_ev, (n_freqs,winsize))[:,bufsize:winsize-bufsize]
if self.params.log_powers:
np.log10(pow_ev_stripped, out=pow_ev_stripped)
sess_pow_mat[ev,i,:] = np.nanmean(pow_ev_stripped, axis=1)
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(self.pow_mat, (len(events), n_bps*n_freqs))
def compute_powers(self, events, sessions, monopolar_channels,
bipolar_pairs):
n_freqs = len(self.params.freqs)
n_bps = len(bipolar_pairs)
self.pow_mat = None
pow_ev = None
winsize = bufsize = 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)
# from ptsa.data.readers import TimeSeriesEEGReader
# time_series_reader = TimeSeriesEEGReader(events=sess_events, start_time=self.params.fr1_start_time,
# end_time=self.params.fr1_end_time, buffer_time=self.params.fr1_buf, keep_buffer=True)
#
# eegs = time_series_reader.read(monopolar_channels)
eeg_reader = EEGReader(events=sess_events,
channels=monopolar_channels,
start_time=self.params.fr1_start_time,
end_time=self.params.fr1_end_time,
buffer_time=self.params.fr1_buf)
eegs = eeg_reader.read()
if eeg_reader.removed_bad_data():
print 'REMOVED SOME BAD EVENTS !!!'
sess_events = eegs['events'].values.view(np.recarray)
n_events = len(sess_events)
events = np.hstack((events[events.session != sess],
sess_events)).view(np.recarray)
ev_order = np.argsort(events,
order=('session', 'list', 'mstime'))
events = events[ev_order]
self.pass_object('FR_events', events)
# print 'eegs=',eegs.values[0,0,:2],eegs.values[0,0,-2:]
# sys.exit()
#
# a = eegs[0]-eegs[1]
# mirroring
#eegs[...,:1365] = eegs[...,2730:1365:-1]
#eegs[...,2731:4096] = eegs[...,2729:1364:-1]
if self.samplerate is None:
self.samplerate = float(eegs.samplerate)
winsize = int(
round(
self.samplerate *
(self.params.fr1_end_time - self.params.fr1_start_time
+ 2 * self.params.fr1_buf)))
bufsize = int(round(self.samplerate * self.params.fr1_buf))
print 'samplerate =', self.samplerate, 'winsize =', winsize, 'bufsize =', bufsize
pow_ev = np.empty(shape=n_freqs * winsize, dtype=float)
self.wavelet_transform.init(self.params.width,
self.params.freqs[0],
self.params.freqs[-1], n_freqs,
self.samplerate, winsize)
print 'Computing FR1 powers'
sess_pow_mat = np.empty(shape=(n_events, n_bps, n_freqs),
dtype=np.float)
#monopolar_channels_np = np.array(monopolar_channels)
for i, ti in enumerate(bipolar_pairs):
# print bp
# print monopolar_channels
# print np.where(monopolar_channels == bp[0])
# print np.where(monopolar_channels == bp[1])
bp = ti['channel_str']
print 'Computing powers for bipolar pair', bp
elec1 = np.where(monopolar_channels == bp[0])[0][0]
elec2 = np.where(monopolar_channels == bp[1])[0][0]
# print 'elec1=',elec1
# print 'elec2=',elec2
# eegs_elec1 = eegs[elec1]
# eegs_elec2 = eegs[elec2]
# print 'eegs_elec1=',eegs_elec1
# print 'eegs_elec2=',eegs_elec2
# eegs_elec1.reset_coords('channels')
# eegs_elec2.reset_coords('channels')
bp_data = eegs[elec1] - eegs[elec2]
bp_data.attrs['samplerate'] = self.samplerate
# bp_data = eegs[elec1] - eegs[elec2]
# bp_data = eegs[elec1] - eegs[elec2]
# bp_data = eegs.values[elec1] - eegs.values[elec2]
bp_data = bp_data.filtered([58, 62],
filt_type='stop',
order=self.params.filt_order)
for ev in xrange(n_events):
self.wavelet_transform.multiphasevec(
bp_data[ev][0:winsize], pow_ev)
#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)
pow_ev_stripped = np.reshape(
pow_ev, (n_freqs, winsize))[:,
bufsize:winsize - bufsize]
if self.params.log_powers:
np.log10(pow_ev_stripped, out=pow_ev_stripped)
sess_pow_mat[ev, i, :] = np.nanmean(pow_ev_stripped,
axis=1)
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(self.pow_mat, (len(events), n_bps * n_freqs))
def compute_ps_powers(self, events, sessions, monopolar_channels, bipolar_pairs, experiment):
n_freqs = len(self.params.freqs)
n_bps = len(bipolar_pairs)
pow_mat_pre = pow_mat_post = None
pow_ev = None
samplerate = winsize = bufsize = None
monopolar_channels_list = list(monopolar_channels)
for sess in sessions:
sess_events = events[events.session == sess]
# print type(sess_events)
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)
eeg_pre_reader = EEGReader(events=sess_events, channels=np.array(monopolar_channels_list),
start_time=pre_start_time,
end_time=pre_end_time, buffer_time=self.params.ps_buf)
eegs_pre = eeg_pre_reader.read()
if eeg_pre_reader.removed_bad_data():
print 'REMOVED SOME BAD EVENTS !!!'
sess_events = eegs_pre['events'].values.view(np.recarray)
n_events = len(sess_events)
events = np.hstack((events[events.session!=sess],sess_events)).view(np.recarray)
ev_order = np.argsort(events, order=('session','mstime'))
events = events[ev_order]
self.pass_object(self.pipeline.experiment+'_events', events)
if samplerate is None:
# samplerate = round(eegs_pre.samplerate)
# samplerate = eegs_pre.attrs['samplerate']
samplerate = float(eegs_pre['samplerate'])
winsize = int(round(samplerate*(pre_end_time-pre_start_time+2*self.params.ps_buf)))
bufsize = int(round(samplerate*self.params.ps_buf))
print 'samplerate =', samplerate, 'winsize =', winsize, 'bufsize =', bufsize
pow_ev = np.empty(shape=n_freqs*winsize, dtype=float)
self.wavelet_transform.init(self.params.width, self.params.freqs[0], self.params.freqs[-1], n_freqs, samplerate, winsize)
# mirroring
nb_ = int(round(samplerate*(self.params.ps_buf)))
eegs_pre[...,-nb_:] = eegs_pre[...,-nb_-2:-2*nb_-2:-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)
from ptsa.data.TimeSeriesX import TimeSeriesX
eegs_post = TimeSeriesX(np.zeros_like(eegs_pre),dims=eegs_pre.dims,coords=eegs_pre.coords)
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 experiment!='PS3' else sess_events[i_ev].train_duration
if ev_offset > 0:
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)
eeg_post_reader = EEGReader(events=sess_events[i_ev:i_ev+1], channels=np.array(monopolar_channels_list),
start_time=post_start_time+ev_offset,
end_time=post_end_time+ev_offset, buffer_time=self.params.ps_buf)
eeg_post = eeg_post_reader.read()
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_:nb_:-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(bipolar_pairs):
bp = ti['channel_str']
print 'Computing powers for bipolar pair', bp
elec1 = np.where(monopolar_channels == bp[0])[0][0]
elec2 = np.where(monopolar_channels == bp[1])[0][0]
#
# 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.attrs['samplerate'] = samplerate
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')
self.wavelet_transform.multiphasevec(bp_data_pre[ev][0:winsize], pow_ev)
#sess_pow_mat_pre[ev,i,:] = np.mean(pow_pre_ev[:,nb_:-nb_], axis=1)
pow_ev_stripped = np.reshape(pow_ev, (n_freqs,winsize))[:,bufsize:winsize-bufsize]
if self.params.log_powers:
np.log10(pow_ev_stripped, out=pow_ev_stripped)
sess_pow_mat_pre[ev,i,:] = np.nanmean(pow_ev_stripped, axis=1)
bp_data_post = eegs_post[elec1] - eegs_post[elec2]
# bp_data_post.attrs['samplerate'] = samplerate
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')
self.wavelet_transform.multiphasevec(bp_data_post[ev][0:winsize], pow_ev)
#sess_pow_mat_post[ev,i,:] = np.mean(pow_post_ev[:,nb_:-nb_], axis=1)
pow_ev_stripped = np.reshape(pow_ev, (n_freqs,winsize))[:,bufsize:winsize-bufsize]
if self.params.log_powers:
np.log10(pow_ev_stripped, out=pow_ev_stripped)
sess_pow_mat_post[ev,i,:] = np.nanmean(pow_ev_stripped, 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)
sess_pow_mat_joint = zscore(np.vstack((sess_pow_mat_pre,sess_pow_mat_post)), axis=0, ddof=1)
sess_pow_mat_pre = sess_pow_mat_joint[:n_events,...]
sess_pow_mat_post = sess_pow_mat_joint[n_events:,...]
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
def compute_ps_powers(self, events, sessions, monopolar_channels, bipolar_pairs, experiment):
n_freqs = len(self.params.freqs)
n_bps = len(bipolar_pairs)
pow_mat_pre = pow_mat_post = None
pow_ev = None
samplerate = winsize = bufsize = None
monopolar_channels_list = list(monopolar_channels)
for sess in sessions:
sess_events = events[events.session == sess]
# print type(sess_events)
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)
eeg_pre_reader = EEGReader(
events=sess_events,
channels=np.array(monopolar_channels_list),
start_time=pre_start_time,
end_time=pre_end_time,
buffer_time=self.params.ps_buf,
)
eegs_pre = eeg_pre_reader.read()
if eeg_pre_reader.removed_bad_data():
print "REMOVED SOME BAD EVENTS !!!"
sess_events = eegs_pre["events"].values.view(np.recarray)
n_events = len(sess_events)
events = np.hstack((events[events.session != sess], sess_events)).view(np.recarray)
ev_order = np.argsort(events, order=("session", "mstime"))
events = events[ev_order]
self.pass_object(self.pipeline.experiment + "_events", events)
if samplerate is None:
# samplerate = round(eegs_pre.samplerate)
# samplerate = eegs_pre.attrs['samplerate']
samplerate = float(eegs_pre["samplerate"])
winsize = int(round(samplerate * (pre_end_time - pre_start_time + 2 * self.params.ps_buf)))
bufsize = int(round(samplerate * self.params.ps_buf))
print "samplerate =", samplerate, "winsize =", winsize, "bufsize =", bufsize
pow_ev = np.empty(shape=n_freqs * winsize, dtype=float)
self.wavelet_transform.init(
self.params.width, self.params.freqs[0], self.params.freqs[-1], n_freqs, samplerate, winsize
)
# mirroring
nb_ = int(round(samplerate * (self.params.ps_buf)))
eegs_pre[..., -nb_:] = eegs_pre[..., -nb_ - 2 : -2 * nb_ - 2 : -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)
from ptsa.data.TimeSeriesX import TimeSeriesX
eegs_post = TimeSeriesX(np.zeros_like(eegs_pre), dims=eegs_pre.dims, coords=eegs_pre.coords)
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 experiment != "PS3" else sess_events[i_ev].train_duration
)
if ev_offset > 0:
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)
eeg_post_reader = EEGReader(
events=sess_events[i_ev : i_ev + 1],
channels=np.array(monopolar_channels_list),
start_time=post_start_time + ev_offset,
end_time=post_end_time + ev_offset,
buffer_time=self.params.ps_buf,
)
eeg_post = eeg_post_reader.read()
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_ : nb_ : -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(bipolar_pairs):
bp = ti["channel_str"]
print "Computing powers for bipolar pair", bp
elec1 = np.where(monopolar_channels == bp[0])[0][0]
elec2 = np.where(monopolar_channels == bp[1])[0][0]
#
# 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.attrs['samplerate'] = samplerate
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')
self.wavelet_transform.multiphasevec(bp_data_pre[ev][0:winsize], pow_ev)
# sess_pow_mat_pre[ev,i,:] = np.mean(pow_pre_ev[:,nb_:-nb_], axis=1)
pow_ev_stripped = np.reshape(pow_ev, (n_freqs, winsize))[:, bufsize : winsize - bufsize]
if self.params.log_powers:
np.log10(pow_ev_stripped, out=pow_ev_stripped)
sess_pow_mat_pre[ev, i, :] = np.nanmean(pow_ev_stripped, axis=1)
bp_data_post = eegs_post[elec1] - eegs_post[elec2]
# bp_data_post.attrs['samplerate'] = samplerate
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')
self.wavelet_transform.multiphasevec(bp_data_post[ev][0:winsize], pow_ev)
# sess_pow_mat_post[ev,i,:] = np.mean(pow_post_ev[:,nb_:-nb_], axis=1)
pow_ev_stripped = np.reshape(pow_ev, (n_freqs, winsize))[:, bufsize : winsize - bufsize]
if self.params.log_powers:
np.log10(pow_ev_stripped, out=pow_ev_stripped)
sess_pow_mat_post[ev, i, :] = np.nanmean(pow_ev_stripped, 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)
sess_pow_mat_joint = zscore(np.vstack((sess_pow_mat_pre, sess_pow_mat_post)), axis=0, ddof=1)
sess_pow_mat_pre = sess_pow_mat_joint[:n_events, ...]
sess_pow_mat_post = sess_pow_mat_joint[n_events:, ...]
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
