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