def test_ptsa_event_ordering(self): # --------------------OROG PTSA - one raw bin wrapper per event e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True, use_groupped_rawbinwrapper=False) events = e_reader.read() events = events[events.type == 'WORD'] events = events[self.event_range] if not isinstance(events, Events): events = Events(events) eegs = events.get_data(channels=['002', '003'], start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) eegs = eegs[:,:,:-1] words_ptsa = eegs['events']['item'] print 'words_ptsa=',words_ptsa words = self.base_eegs['events'].data['item'] print words assert_array_equal(np.array(words_ptsa),words) assert_array_equal(eegs, self.base_eegs)
def test_eeg_read_keep_buffer(self): # OLD READERS events = self.read_ptsa_events() # in case fancy indexing looses Eventness of events we need to create Events object explicitely if not isinstance(events, Events): events = Events(events) eegs = events.get_data(channels=['002', '003'], start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) # NEW READERS base_events = self.read_base_events() from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader time_series_reader = TimeSeriesEEGReader(events=base_events, start_time=0.0, end_time=1.6, buffer_time=1.0, keep_buffer=True) time_series_reader.read(channels=['002', '003']) base_eegs = time_series_reader.get_output() # testing assert_array_equal(eegs, base_eegs.data)
def test_ptsa_event_ordering(self): # --------------------OROG PTSA - one raw bin wrapper per event e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True, use_groupped_rawbinwrapper=False) events = e_reader.read() events = events[events.type == 'WORD'] events = events[self.event_range] if not isinstance(events, Events): events = Events(events) eegs = events.get_data(channels=['002', '003'], start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) eegs = eegs[:, :, :-1] words_ptsa = eegs['events']['item'] print('words_ptsa=', words_ptsa) words = self.base_eegs['events'].data['item'] print(words) assert_array_equal(np.array(words_ptsa), words) assert_array_equal(eegs, self.base_eegs)
def run(self): subject = self.pipeline.subject experiment = self.pipeline.experiment try: events = Events(get_events(subject=subject, task='RAM_PS', path_prefix=self.pipeline.mount_point)) except IOError: raise Exception('No parameter search for subject %s' % subject) events = events[events.experiment == experiment] if events.size == 0: raise Exception('No %s events for subject %s' % (experiment,subject)) events = correct_eegfile_field(events) events = self.attach_raw_bin_wrappers(events) sessions = np.unique(events.session) print experiment, 'sessions:', sessions events = pd.DataFrame.from_records(events) events = compute_isi(events) is_stim_event_type_vec = np.vectorize(is_stim_event_type) events = events[is_stim_event_type_vec(events.type)] print len(events), 'stim', experiment, 'events' events = Events(events.to_records(index=False)) joblib.dump(events, self.get_path_to_resource_in_workspace(subject+'-'+experiment+'-ps_events.pkl')) self.pass_object(experiment+'_events', events)
def setUp(self): self.event_range = range(0, 30, 1) self.e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat' self.tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat' # --------------- TAL STRUCTS READ tal_reader = TalReader(filename=self.tal_path) self.monopolar_channels = tal_reader.get_monopolar_channels() # ---------------- ORIG PTSA ------------------- e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True) events = e_reader.read() events = events[events.type == 'WORD'] events = events[self.event_range] ev_order = np.argsort(events, order=('session','list','mstime')) self.events = events[ev_order] # self.events = self.read_ptsa_events() # in case fancy indexing looses Eventness of events we need to create Events object explicitely if not isinstance(self.events, Events): self.events = Events(self.events) start_time = 0.0 end_time = 1.6 buffer_time = 1.0 self.eegs = self.events.get_data(channels=['002', '003'], start_time=start_time, end_time=end_time, buffer_time=buffer_time, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) # ---------------- NEW STYLE PTSA ------------------- base_e_reader = BaseEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True) base_events = base_e_reader.read() base_events = base_events[base_events.type == 'WORD'] base_ev_order = np.argsort(base_events, order=('session','list','mstime')) base_events = base_events[base_ev_order] self.base_events = base_events[self.event_range] # self.base_events = self.read_base_events() eeg_reader = EEGReader(events=self.base_events, channels=np.array(['002', '003']), start_time=start_time, end_time=end_time, buffer_time=buffer_time) self.base_eegs = eeg_reader.read()
def test_full_session_read(self): # ---------------- ORIG PTSA ------------------- e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True) events = e_reader.read() events = events[events.type == 'WORD'] events = events[self.event_range] ev_order = np.argsort(events, order=('session', 'list', 'mstime')) self.events = events[ev_order] # self.events = self.read_ptsa_events() # in case fancy indexing looses Eventness of events we need to create Events object explicitely if not isinstance(self.events, Events): self.events = Events(self.events) eegs = self.events.get_data(channels=self.monopolar_channels, start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) # removing last entry to match dimensions - ptsa adds one extra element at the end of time axis eegs = eegs[:, :, :-1] eeg_reader = EEGReader(events=self.base_events, channels=self.monopolar_channels, start_time=0.0, end_time=1.6, buffer_time=1.0) base_eegs = eeg_reader.read() assert_array_equal(x=eegs, y=base_eegs) # checking if axes match assert_array_equal(np.array(eegs['channels']['name']), base_eegs['channels'].data) assert_array_almost_equal(np.array(eegs['time']), base_eegs['time'].data, decimal=3) assert_array_equal(np.array(eegs['events']['item']), base_eegs['events'].data['item']) print()
def test_eeg_read_keep_buffer_butterworth_filtered(self): # old readers events = self.read_ptsa_events() # in case fancy indexing looses Eventness of events we need to create Events object explicitely if not isinstance(events, Events): events = Events(events) base_events = self.read_base_events() eegs = events.get_data(channels=['002', '003'], start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) # filtering eegs_filtered = eegs.filtered([58, 62], filt_type='stop', order=4) # New style reading from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader time_series_reader = TimeSeriesEEGReader(events=base_events, start_time=0.0, end_time=1.6, buffer_time=1.0, keep_buffer=True) time_series_reader.read(channels=['002', '003']) base_eegs = time_series_reader.get_output() from ptsa.data.filters.ButterworthFilter import ButterworthFilter b_filter = ButterworthFilter(time_series=base_eegs, samplerate=base_eegs.attrs['samplerate'], freq_range=[58, 62], filt_type='stop', order=4) base_eegs_filtered = b_filter.filter() # testing assert_array_equal(eegs_filtered, base_eegs_filtered.data) assert_array_equal(eegs, base_eegs.data)
def get_word_events(sub, task, montage=0): from ptsa.data.readers import BaseEventReader from ptsa.data.events import Events from ptsa.data.readers.IndexReader import JsonIndexReader reader = JsonIndexReader('/protocols/r1.json') #Get events evfiles = list( reader.aggregate_values('task_events', subject=sub, experiment=task, montage=montage)) evs_on = np.array([]) for ef in evfiles: try: base_e_reader = BaseEventReader(filename=ef, eliminate_events_with_no_eeg=True) base_events = base_e_reader.read() if len(evs_on) == 0: evs_on = base_events[base_events.type == 'WORD'] else: evs_on = np.concatenate( (evs_on, base_events[base_events.type == 'WORD']), axis=0) except: continue evs = Events(evs_on) return evs
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 get_stim_events(sub, task, montage=0): from ptsa.data.readers import BaseEventReader from ptsa.data.events import Events from ptsa.data.readers.IndexReader import JsonIndexReader reader = JsonIndexReader('/protocols/r1.json') #Get events evfiles = list( reader.aggregate_values( 'task_events', subject=sub, experiment=task, montage=montage)) #This is supposed to work but often does not if len(evfiles) < 1: from glob import glob sessions = [ s.split('/')[-1] for s in glob('/protocols/r1/subjects/' + sub + '/experiments/' + task + '/sessions/*') ] evfiles = [] for sess in sessions: evfiles.append('/protocols/r1/subjects/' + sub + '/experiments/' + task + '/sessions/' + sess + '/behavioral/current_processed/task_events.json') evs_on = np.array([]) for ef in evfiles: try: base_e_reader = BaseEventReader(filename=ef, eliminate_events_with_no_eeg=True) base_events = base_e_reader.read() if len(evs_on) == 0: evs_on = base_events[base_events.type == 'STIM_ON'] else: evs_on = np.concatenate( (evs_on, base_events[base_events.type == 'STIM_ON']), axis=0) except: continue evs_on = Events(evs_on) #Reorganize sessions around stim sites sessions = reader.sessions(subject=sub, experiment=task, montage=montage) sess_tags = [] for i in range(len(evs_on)): stimtag = str(evs_on[i]['stim_params']['anode_number']) + '-' + str( evs_on[i]['stim_params']['cathode_number']) sess_tags.append(stimtag) sess_tags = np.array(sess_tags) if len(np.unique(sess_tags)) <= len(sessions): session_array = evs_on['session'] else: session_array = np.empty(len(evs_on)) for idx, s in enumerate(np.unique(sess_tags)): session_array[sess_tags == s] = int(idx) sessions = np.unique(session_array) return evs_on, session_array
def setUp(self): self.event_range = range(0, 30, 1) self.e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat' self.tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat' if sys.platform.startswith('win'): self.e_path = 'D:/data/events/RAM_FR1/R1060M_events.mat' self.tal_path = 'D:/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat' # --------------- TAL STRUCTS READ tal_reader = TalReader(filename=self.tal_path) self.monopolar_channels = tal_reader.get_monopolar_channels() # ---------------- ORIG PTSA ------------------- e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True) events = e_reader.read() events = events[events.type == 'WORD'] events = events[self.event_range] ev_order = np.argsort(events, order=('session','list','mstime')) self.events = events[ev_order] # self.events = self.read_ptsa_events() # in case fancy indexing looses Eventness of events we need to create Events object explicitely if not isinstance(self.events, Events): self.events = Events(self.events) start_time = 0.0 end_time = 1.6 buffer_time = 1.0 self.eegs = self.events.get_data(channels=['002', '003'], start_time=start_time, end_time=end_time, buffer_time=buffer_time, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) # ---------------- NEW STYLE PTSA ------------------- base_e_reader = BaseEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True) base_events = base_e_reader.read() base_events = base_events[base_events.type == 'WORD'] base_ev_order = np.argsort(base_events, order=('session','list','mstime')) base_events = base_events[base_ev_order] self.base_events = base_events[self.event_range] # self.base_events = self.read_base_events() eeg_reader = EEGReader(events=self.base_events, channels=np.array(['002', '003']), start_time=start_time, end_time=end_time, buffer_time=buffer_time) self.base_eegs = eeg_reader.read()
def test_eeg_resample(self): # old readers events = self.read_ptsa_events() # in case fancy indexing looses Eventness of events we need to create Events object explicitely if not isinstance(events, Events): events = Events(events) base_events = self.read_base_events() eegs = events.get_data(channels=['002', '003'], start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) # filtering eegs_resampled = eegs.resampled(50.0) # New style reading from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader time_series_reader = TimeSeriesEEGReader(events=base_events, start_time=0.0, end_time=1.6, buffer_time=1.0, keep_buffer=True) time_series_reader.read(channels=['002', '003']) base_eegs = time_series_reader.get_output() from ptsa.data.filters.ResampleFilter import ResampleFilter resample_filter = ResampleFilter(time_series=base_eegs, resamplerate=50.0) base_eegs_resampled = resample_filter.filter() # testing assert_array_equal(eegs_resampled, base_eegs_resampled.data)
def read(self): """ Reads Matlab event file , converts it to np.recarray and attaches rawbinwrappers (if appropriate flags indicate so) :return: Events object. depending on flagg settings the rawbinwrappers may be attached as well """ # calling base class read fcn evs = BaseEventReader.read(self) # in case evs is simply recarray if not isinstance(evs, Events): evs = Events(evs) if self.attach_rawbinwrapper: evs = evs.add_fields(esrc=np.dtype(RawBinWrapper)) if self.use_groupped_rawbinwrapper: # this should be default choice - much faster execution self.attach_rawbinwrapper_groupped(evs) else: # used for debugging purposes self.attach_rawbinwrapper_individual(evs) return evs
def read(self): ''' Reads Matlab event file , converts it to np.recarray and attaches rawbinwrappers (if appropriate flags indicate so) :return: Events object. depending on flagg settings the rawbinwrappers may be attached as well ''' # calling base class read fcn evs = BaseEventReader.read(self) # in case evs is simply recarray if not isinstance(evs, Events): evs = Events(evs) if self.attach_rawbinwrapper: evs = evs.add_fields(esrc=np.dtype(RawBinWrapper)) if self.use_groupped_rawbinwrapper: # this should be default choice - much faster execution self.attach_rawbinwrapper_groupped(evs) else: # used for debugging purposes self.attach_rawbinwrapper_individual(evs) return evs
def test_eeg_read(self): ptsa_reader = PTSAEventReader(filename=self.e_path) events = ptsa_reader.read() # in case fancy indexing looses Eventness of events we need to create Events object explicitely if not isinstance(events, Events): events = Events(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) base_event_reader = BaseEventReader(filename=self.e_path) base_events = base_event_reader.read() eeg_reader = EEGReader(events=base_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() npt.assert_array_equal(eegs[:, :, :-1], base_eegs.data)
def get_ps4_events(fn): from ptsa.data.readers import BaseEventReader from ptsa.data.events import Events #Get events evfiles = [fn] evs_on = np.array([]) for ef in evfiles: try: base_e_reader = BaseEventReader(filename=ef, eliminate_events_with_no_eeg=True) base_events = base_e_reader.read() if len(evs_on) == 0: evs_on = base_events[base_events.type == 'STIM_ON'] else: evs_on = np.concatenate( (evs_on, base_events[base_events.type == 'STIM_ON']), axis=0) except: continue evs_on = Events(evs_on) #Reorganize sessions around stim sites sessions = np.unique(evs_on['session']) sess_tags = [] for i in range(len(evs_on)): stimtag = str(evs_on[i]['anode_num']) + '-' + str( evs_on[i]['cathode_num']) sess_tags.append(stimtag) sess_tags = np.array(sess_tags) if len(np.unique(sess_tags)) <= len(sessions): session_array = evs_on['session'] else: session_array = np.empty(len(evs_on)) for idx, s in enumerate(np.unique(sess_tags)): session_array[sess_tags == s] = int(idx) sessions = np.unique(session_array) return evs_on, session_array
def test_full_session_read(self): # ---------------- ORIG PTSA ------------------- e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True) events = e_reader.read() events = events[events.type == 'WORD'] events = events[self.event_range] ev_order = np.argsort(events, order=('session','list','mstime')) self.events = events[ev_order] # self.events = self.read_ptsa_events() # in case fancy indexing looses Eventness of events we need to create Events object explicitely if not isinstance(self.events, Events): self.events = Events(self.events) eegs = self.events.get_data(channels=self.monopolar_channels, start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) # removing last entry to match dimensions - ptsa adds one extra element at the end of time axis eegs = eegs[:,:,:-1] eeg_reader = EEGReader(events=self.base_events, channels=self.monopolar_channels, start_time=0.0, end_time=1.6, buffer_time=1.0) base_eegs = eeg_reader.read() assert_array_equal(x=eegs, y=base_eegs) # checking if axes match assert_array_equal(np.array(eegs['channels']['name']), base_eegs['channels'].data) assert_array_almost_equal(np.array(eegs['time']), base_eegs['time'].data, decimal=3) assert_array_equal(np.array(eegs['events']['item']), base_eegs['events'].data['item']) print
def read(self): from MatlabIO import read_single_matlab_matrix_as_numpy_structured_array # extract matlab matrix (called 'events') as numpy structured array struct_array = read_single_matlab_matrix_as_numpy_structured_array( self.__event_file, 'events') evs = Events(struct_array) if self.eliminate_events_with_no_eeg: # eliminating events that have no eeg file indicator = np.empty(len(evs), dtype=bool) indicator[:] = False for i, ev in enumerate(evs): indicator[i] = (type( evs[i].eegfile).__name__.startswith('unicode')) & (len( str(evs[i].eegfile)) > 3) evs = evs[indicator] self.__events = evs return self.__events
class TestRegressionPTSA(unittest.TestCase): # class TestRegressionPTSA(unittest.TestCase): def setUp(self): self.event_range = range(0, 30, 1) self.e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat' self.tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat' # --------------- TAL STRUCTS READ tal_reader = TalReader(filename=self.tal_path) self.monopolar_channels = tal_reader.get_monopolar_channels() # ---------------- ORIG PTSA ------------------- e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True) events = e_reader.read() events = events[events.type == 'WORD'] events = events[self.event_range] ev_order = np.argsort(events, order=('session','list','mstime')) self.events = events[ev_order] # self.events = self.read_ptsa_events() # in case fancy indexing looses Eventness of events we need to create Events object explicitely if not isinstance(self.events, Events): self.events = Events(self.events) start_time = 0.0 end_time = 1.6 buffer_time = 1.0 self.eegs = self.events.get_data(channels=['002', '003'], start_time=start_time, end_time=end_time, buffer_time=buffer_time, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) # ---------------- NEW STYLE PTSA ------------------- base_e_reader = BaseEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True) base_events = base_e_reader.read() base_events = base_events[base_events.type == 'WORD'] base_ev_order = np.argsort(base_events, order=('session','list','mstime')) base_events = base_events[base_ev_order] self.base_events = base_events[self.event_range] # self.base_events = self.read_base_events() eeg_reader = EEGReader(events=self.base_events, channels=np.array(['002', '003']), start_time=start_time, end_time=end_time, buffer_time=buffer_time) self.base_eegs = eeg_reader.read() def test_time_series_mirror(self): duration = 1.0 mirrored_buf_eegs = self.base_eegs.add_mirror_buffer(duration=duration) samplerate = float(self.base_eegs['samplerate']) nb_ = int(np.ceil(samplerate * duration)) assert_array_equal(self.base_eegs[...,1:nb_+1], mirrored_buf_eegs[...,:nb_][...,::-1]) print mirrored_buf_eegs def test_missing_data_read(self): self.e_path = '/Volumes/rhino_root/data/events/RAM_PS/R1104D_events.mat' base_e_reader = BaseEventReader(filename=self.e_path) base_events = base_e_reader.read() print 'base_events=',base_events def test_full_session_read(self): # ---------------- ORIG PTSA ------------------- e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True) events = e_reader.read() events = events[events.type == 'WORD'] events = events[self.event_range] ev_order = np.argsort(events, order=('session','list','mstime')) self.events = events[ev_order] # self.events = self.read_ptsa_events() # in case fancy indexing looses Eventness of events we need to create Events object explicitely if not isinstance(self.events, Events): self.events = Events(self.events) eegs = self.events.get_data(channels=self.monopolar_channels, start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) # removing last entry to match dimensions - ptsa adds one extra element at the end of time axis eegs = eegs[:,:,:-1] eeg_reader = EEGReader(events=self.base_events, channels=self.monopolar_channels, start_time=0.0, end_time=1.6, buffer_time=1.0) base_eegs = eeg_reader.read() assert_array_equal(x=eegs, y=base_eegs) # checking if axes match assert_array_equal(np.array(eegs['channels']['name']), base_eegs['channels'].data) assert_array_almost_equal(np.array(eegs['time']), base_eegs['time'].data, decimal=3) assert_array_equal(np.array(eegs['events']['item']), base_eegs['events'].data['item']) print def test_ptsa_event_ordering(self): # --------------------OROG PTSA - one raw bin wrapper per event e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True, use_groupped_rawbinwrapper=False) events = e_reader.read() events = events[events.type == 'WORD'] events = events[self.event_range] if not isinstance(events, Events): events = Events(events) eegs = events.get_data(channels=['002', '003'], start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) eegs = eegs[:,:,:-1] words_ptsa = eegs['events']['item'] print 'words_ptsa=',words_ptsa words = self.base_eegs['events'].data['item'] print words assert_array_equal(np.array(words_ptsa),words) assert_array_equal(eegs, self.base_eegs) def test_eeg_read(self): # base_eegs = self.base_eegs.remove_buffer(duration=1.0) # eegs = self.eegs.remove_buffer(duration=1.0) base_eegs = self.base_eegs eegs = self.eegs # orig ptsa returns extra stime point that's why eegs[:,:,:-1] # assert_array_equal(eegs[:, :, :-1], base_eegs.data) assert_array_equal(eegs[:, :, :-1], base_eegs.data) def test_eeg_read_keep_buffer(self): # orig ptsa returns extra stime point that's why eegs[:,:,:-1] eegs = self.eegs base_eegs = self.base_eegs assert_array_equal(eegs[:, :, :-1], base_eegs.data) def test_eeg_read_keep_buffer_butterworth_filtered(self): # filtering # # orig ptsa returns extra time point that's why eegs[:,:,:-1] eegs = self.eegs[:, :, :-1] eegs_filtered = eegs.filtered([58, 62], filt_type='stop', order=4) # -------------------TimeSeriesX base_eegs = self.base_eegs base_eegs_filtered_direct = self.base_eegs.filtered([58, 62], filt_type='stop', order=4) b_filter = ButterworthFilter(time_series=base_eegs, freq_range=[58, 62], filt_type='stop', order=4) base_eegs_filtered = b_filter.filter() # ---------------- testing # assert_array_almost_equal(eegs_filtered[:,:,:], base_eegs_filtered.data, decimal=2) assert_array_equal(eegs_filtered[:, :, :], base_eegs_filtered.data) assert_array_equal(eegs_filtered[:, :, :], base_eegs_filtered_direct.data) # checking filtering of just single time series eegs_0_0 = eegs[0,0] eegs_filtered_0_0 = eegs_0_0.filtered([58, 62], filt_type='stop', order=4) assert_array_equal(eegs_filtered_0_0, eegs_filtered[0,0]) base_eegs[0:1,0:1].filtered([58, 62], filt_type='stop', order=4) def test_eeg_resample(self): # # orig ptsa returns extra stime point that's why eegs[:,:,:-1] eegs = self.eegs[:, :, :-1] # filtering eegs_resampled = eegs.resampled(100.0) # -------------------TimeSeriesX base_eegs = self.base_eegs resample_filter = ResampleFilter(time_series=base_eegs, resamplerate=100.0) base_eegs_resampled = resample_filter.filter() base_eegs_resampled_direct = base_eegs.resampled(resampled_rate=100.0) # -------------- testing assert_array_equal(eegs_resampled, base_eegs_resampled.data) assert_array_equal(eegs_resampled, base_eegs_resampled_direct.data) base_eegs_resampled_direct_0_0 = base_eegs[0,0].resampled(resampled_rate=100.0) def test_wavelets_resample(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() resample_filter = ResampleFilter(time_series=pow_wavelet, resamplerate=100.0) pow_wavelet_resampled = resample_filter.filter() print pow_wavelet_resampled pow_wavelet_resampled_direct = pow_wavelet.resampled(resampled_rate=100.0) print pow_wavelet_resampled_direct # 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 def test_ts_convenience_fcns(self): # # orig ptsa returns extra stime point that's why eegs[:,:,:-1] eegs = self.eegs[:, :, :-1] base_eegs = self.base_eegs mean_eegs = eegs.mean(axis='time') mean_base_eegs = base_eegs.mean(dim='time') assert_array_equal(mean_eegs, mean_base_eegs) min_eegs = eegs.min(axis='time') min_base_eegs = base_eegs.min(dim='time') assert_array_equal(min_eegs, min_base_eegs) max_eegs = eegs.max(axis='time') max_base_eegs = base_eegs.max(dim='time') assert_array_equal(max_eegs, max_base_eegs) cumsum_eegs = eegs.cumsum(axis='time') cumsum_base_eegs = np.cumsum(base_eegs,axis=base_eegs.get_axis_num('time')) assert_array_equal(cumsum_eegs, cumsum_base_eegs) cumprod_eegs = eegs.cumprod(axis='time') cumprod_base_eegs = np.cumprod(base_eegs,axis=base_eegs.get_axis_num('time')) assert_array_equal(cumprod_eegs, cumprod_base_eegs) std_eegs = eegs.std(axis='time') std_base_eegs = base_eegs.std(dim='time') assert_array_equal(std_eegs, std_base_eegs) sum_eegs = eegs.sum(axis='time') sum_base_eegs = base_eegs.sum(dim='time') assert_array_equal(sum_eegs, sum_base_eegs) argmin_eegs = eegs.argmin(axis='time') argmin_base_eegs = base_eegs.argmin(dim='time') assert_array_equal(argmin_eegs, argmin_base_eegs) argmax_eegs = eegs.argmax(axis='time') argmax_base_eegs = base_eegs.argmax(dim='time') assert_array_equal(argmax_eegs, argmax_base_eegs) argsort_eegs = eegs.argsort(axis='time') argsort_base_eegs = np.argsort(base_eegs,axis=base_eegs.get_axis_num('time')) assert_array_equal(argsort_eegs, argsort_base_eegs) # could not get compress to work using timeseries.compress method # compress_eegs = eegs.compress(condition=[0,2], axis='time') # compress_base_eegs = np.compress(condition=[0,1], a=base_eegs.data, axis=base_eegs.get_axis_num('channels')) # assert_array_equal(compress_eegs, compress_base_eegs) diagonal_eegs = eegs.diagonal(offset=0, axis1=1, axis2=2) diagonal_base_eegs = np.diagonal(base_eegs,offset=0, axis1=1,axis2=2) assert_array_equal(diagonal_eegs, diagonal_base_eegs) flatten_eegs = eegs.flatten() flatten_base_eegs = base_eegs.data.flatten() assert_array_equal(flatten_eegs, flatten_base_eegs) prod_eegs = eegs.prod(axis='channels') prod_base_eegs = base_eegs.prod(dim = 'channels') assert_array_equal(prod_eegs, prod_base_eegs) ptp_eegs = eegs.ptp(axis='channels') ptp_base_eegs = np.ptp(base_eegs.data, axis = base_eegs.get_axis_num('channels')) assert_array_equal(ptp_eegs, ptp_base_eegs) ravel_eegs = eegs.ravel() ravel_base_eegs = np.ravel(base_eegs) assert_array_equal(ravel_eegs, ravel_base_eegs) repeat_eegs = eegs.repeat(repeats=2, axis='channels') repeat_base_eegs = np.repeat(base_eegs.data, repeats=2, axis=base_eegs.get_axis_num('channels')) assert_array_equal(repeat_eegs, repeat_base_eegs) swapaxes_eegs = eegs.swapaxes(axis1='channels',axis2='events') swapaxes_base_eegs = base_eegs.transpose('events','channels','time') assert_array_equal(swapaxes_eegs , swapaxes_base_eegs) take_eegs = eegs.take(indices=[2,4,6,8],axis='events') take_base_eegs = base_eegs.isel(events=[2,4,6,8]) assert_array_equal(take_eegs , take_base_eegs) trace_eegs = eegs.trace(offset=0, axis1=0,axis2=2) trace_base_eegs = np.trace(base_eegs, offset=0, axis1=base_eegs.get_axis_num('channels'), axis2=base_eegs.get_axis_num('time')) assert_array_equal(trace_eegs , trace_base_eegs) var_eegs = eegs.var(axis='time') var_base_eegs = base_eegs.var(dim='time') assert_array_equal(var_eegs, var_base_eegs) 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 test_wavelets_python_cpp(self): from ptsa.data.filters import MorletWaveletFilterCpp print 'hello' wf = MorletWaveletFilter(time_series=self.base_eegs, freqs=np.logspace(np.log10(3), np.log10(180), 8), output='power', ) pow_wavelet, phase_wavelet = wf.filter() wf_cpp = MorletWaveletFilterCpp(time_series=self.base_eegs, freqs=np.logspace(np.log10(3), np.log10(180), 8), output='power', ) pow_wavelet_cpp, phase_wavelet_cpp = wf_cpp.filter() decimal = 2 freq_num=0 from scipy.stats import describe desc_cpp = describe(pow_wavelet_cpp[freq_num,:,:,500:-500]) desc_py = describe(pow_wavelet[freq_num,:,:,500:-500]) try: assert_array_almost_equal( (pow_wavelet_cpp[freq_num,:,:,500:-500]-pow_wavelet[freq_num,:,:,500:-500])/pow_wavelet_cpp[freq_num,:,:,500:-500], np.zeros_like(pow_wavelet_cpp[freq_num,:,:,500:-500]), decimal=decimal) except AssertionError: print 'WARNING: Cpp and Python wavelets are not within 1%. Will try weaker test ' mean_min = np.min((desc_cpp.mean-desc_py.mean)/desc_cpp.mean) mean_max = np.max((desc_cpp.mean-desc_py.mean)/desc_cpp.mean) print 'mean_max=',mean_max print 'mean_min=',mean_min self.assertTrue(np.abs(mean_max)<0.05) self.assertTrue(np.abs(mean_min)<0.05) def test_wavelets_multicore(self): from ptsa.data.filters import MorletWaveletFilterCpp print 'hello' print sys.path wf_cpp_multi = MorletWaveletFilterCpp(time_series=self.base_eegs, freqs=np.logspace(np.log10(3), np.log10(180), 8), output='both', cpus=8 ) pow_wavelet_multi, phase_wavelet_multi = wf_cpp_multi.filter() wf_cpp = MorletWaveletFilterCpp(time_series=self.base_eegs, freqs=np.logspace(np.log10(3), np.log10(180), 8), output='both', cpus=1 ) pow_wavelet, phase_wavelet= wf_cpp.filter() assert_array_equal(pow_wavelet_multi,pow_wavelet) assert_array_equal(phase_wavelet_multi,phase_wavelet) 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 def test_event_data_chopper(self): dataroot=self.base_events[0].eegfile from ptsa.data.readers import EEGReader session_reader = EEGReader(session_dataroot=dataroot, channels=self.monopolar_channels) session_eegs = session_reader.read() sedc = DataChopper(events=self.base_events, session_data=session_eegs, start_time=0.0, end_time=1.6, buffer_time=1.0) chopped_session = sedc.filter() sedc_so = DataChopper(start_offsets=self.base_events.eegoffset, session_data=session_eegs, start_time=0.0, end_time=1.6, buffer_time=1.0) chopped_session_so = sedc_so.filter() assert_array_equal(chopped_session,chopped_session_so) 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 run(self): # PTSA EVENT READER # e_path = join(self.pipeline.mount_point, 'data/events', self.pipeline.task,self.pipeline.subject+'_events.mat') e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat' # e_path = '/Users/m/data/events/RAM_FR1/R1056M_events.mat' e_reader = PTSAEventReader(event_file=e_path, eliminate_events_with_no_eeg=True) e_reader.read() events = e_reader.get_output() events = events[events.type == 'WORD'] events = events[0:30] ev_order = np.argsort(events, order=('session', 'list', 'mstime')) events = events[ev_order] events = Events(events) # necessary workaround for new numpy print 'events=', events eegs = events.get_data(channels=['002', '003'], start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=False, eoffset_in_time=False, verbose=True) print eegs # BASE READER base_e_reader = BaseEventReader(event_file=e_path, eliminate_events_with_no_eeg=True, use_ptsa_events_class=False) base_e_reader.read() base_events = base_e_reader.get_output() base_events = base_events[base_events.type == 'WORD'] base_ev_order = np.argsort(base_events, order=('session', 'list', 'mstime')) base_events = base_events[base_ev_order] base_events = base_events[0:30] print 'base_events=', base_events from ptsa.data.readers.TimeSeriesEEGReader import TimeSeriesEEGReader time_series_reader = TimeSeriesEEGReader(base_events) time_series_reader.start_time = 0.0 time_series_reader.end_time = 1.6 time_series_reader.buffer_time = 1.0 time_series_reader.keep_buffer = False time_series_reader.read(channels=['002', '003']) base_eegs = time_series_reader.get_output() print
class TestRegressionPTSA(unittest.TestCase): # class TestRegressionPTSA(unittest.TestCase): def setUp(self): self.event_range = range(0, 30, 1) self.e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat' self.tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat' if sys.platform.startswith('win'): self.e_path = 'D:/data/events/RAM_FR1/R1060M_events.mat' self.tal_path = 'D:/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat' # --------------- TAL STRUCTS READ tal_reader = TalReader(filename=self.tal_path) self.monopolar_channels = tal_reader.get_monopolar_channels() # ---------------- ORIG PTSA ------------------- e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True) events = e_reader.read() events = events[events.type == 'WORD'] events = events[self.event_range] ev_order = np.argsort(events, order=('session', 'list', 'mstime')) self.events = events[ev_order] # self.events = self.read_ptsa_events() # in case fancy indexing looses Eventness of events we need to create Events object explicitely if not isinstance(self.events, Events): self.events = Events(self.events) start_time = 0.0 end_time = 1.6 buffer_time = 1.0 self.eegs = self.events.get_data(channels=['002', '003'], start_time=start_time, end_time=end_time, buffer_time=buffer_time, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) # ---------------- NEW STYLE PTSA ------------------- base_e_reader = BaseEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True) base_events = base_e_reader.read() base_events = base_events[base_events.type == 'WORD'] base_ev_order = np.argsort(base_events, order=('session', 'list', 'mstime')) base_events = base_events[base_ev_order] self.base_events = base_events[self.event_range] # self.base_events = self.read_base_events() eeg_reader = EEGReader(events=self.base_events, channels=np.array(['002', '003']), start_time=start_time, end_time=end_time, buffer_time=buffer_time) self.base_eegs = eeg_reader.read() def test_time_series_mirror(self): duration = 1.0 mirrored_buf_eegs = self.base_eegs.add_mirror_buffer(duration=duration) samplerate = float(self.base_eegs['samplerate']) nb_ = int(np.ceil(samplerate * duration)) assert_array_equal(self.base_eegs[..., 1:nb_ + 1], mirrored_buf_eegs[..., :nb_][..., ::-1]) print(mirrored_buf_eegs) def test_missing_data_read(self): self.e_path = '/Volumes/rhino_root/data/events/RAM_PS/R1104D_events.mat' if sys.platform.startswith('win'): self.e_path = 'D:/data/events/RAM_PS/R1104D_events.mat' base_e_reader = BaseEventReader(filename=self.e_path) base_events = base_e_reader.read() print('base_events=', base_events) def test_full_session_read(self): # ---------------- ORIG PTSA ------------------- e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True) events = e_reader.read() events = events[events.type == 'WORD'] events = events[self.event_range] ev_order = np.argsort(events, order=('session', 'list', 'mstime')) self.events = events[ev_order] # self.events = self.read_ptsa_events() # in case fancy indexing looses Eventness of events we need to create Events object explicitely if not isinstance(self.events, Events): self.events = Events(self.events) eegs = self.events.get_data(channels=self.monopolar_channels, start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) # removing last entry to match dimensions - ptsa adds one extra element at the end of time axis eegs = eegs[:, :, :-1] eeg_reader = EEGReader(events=self.base_events, channels=self.monopolar_channels, start_time=0.0, end_time=1.6, buffer_time=1.0) base_eegs = eeg_reader.read() assert_array_equal(x=eegs, y=base_eegs) # checking if axes match assert_array_equal(np.array(eegs['channels']['name']), base_eegs['channels'].data) assert_array_almost_equal(np.array(eegs['time']), base_eegs['time'].data, decimal=3) assert_array_equal(np.array(eegs['events']['item']), base_eegs['events'].data['item']) print() def test_ptsa_event_ordering(self): # --------------------OROG PTSA - one raw bin wrapper per event e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True, use_groupped_rawbinwrapper=False) events = e_reader.read() events = events[events.type == 'WORD'] events = events[self.event_range] if not isinstance(events, Events): events = Events(events) eegs = events.get_data(channels=['002', '003'], start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True) eegs = eegs[:, :, :-1] words_ptsa = eegs['events']['item'] print('words_ptsa=', words_ptsa) words = self.base_eegs['events'].data['item'] print(words) assert_array_equal(np.array(words_ptsa), words) assert_array_equal(eegs, self.base_eegs) def test_eeg_read(self): # base_eegs = self.base_eegs.remove_buffer(duration=1.0) # eegs = self.eegs.remove_buffer(duration=1.0) base_eegs = self.base_eegs eegs = self.eegs # orig ptsa returns extra stime point that's why eegs[:,:,:-1] # assert_array_equal(eegs[:, :, :-1], base_eegs.data) assert_array_equal(eegs[:, :, :-1], base_eegs.data) def test_eeg_read_keep_buffer(self): # orig ptsa returns extra stime point that's why eegs[:,:,:-1] eegs = self.eegs base_eegs = self.base_eegs assert_array_equal(eegs[:, :, :-1], base_eegs.data) def test_eeg_read_keep_buffer_butterworth_filtered(self): # filtering # # orig ptsa returns extra time point that's why eegs[:,:,:-1] eegs = self.eegs[:, :, :-1] eegs_filtered = eegs.filtered([58, 62], filt_type='stop', order=4) # -------------------TimeSeries base_eegs = self.base_eegs base_eegs_filtered_direct = self.base_eegs.filtered([58, 62], filt_type='stop', order=4) b_filter = ButterworthFilter(time_series=base_eegs, freq_range=[58, 62], filt_type='stop', order=4) base_eegs_filtered = b_filter.filter() # ---------------- testing # assert_array_almost_equal(eegs_filtered[:,:,:], base_eegs_filtered.data, decimal=2) assert_array_equal(eegs_filtered[:, :, :], base_eegs_filtered.data) assert_array_equal(eegs_filtered[:, :, :], base_eegs_filtered_direct.data) # checking filtering of just single time series eegs_0_0 = eegs[0, 0] eegs_filtered_0_0 = eegs_0_0.filtered([58, 62], filt_type='stop', order=4) assert_array_equal(eegs_filtered_0_0, eegs_filtered[0, 0]) base_eegs[0:1, 0:1].filtered([58, 62], filt_type='stop', order=4) def test_eeg_resample(self): # # orig ptsa returns extra stime point that's why eegs[:,:,:-1] eegs = self.eegs[:, :, :-1] # filtering eegs_resampled = eegs.resampled(100.0) # -------------------TimeSeries base_eegs = self.base_eegs resample_filter = ResampleFilter(time_series=base_eegs, resamplerate=100.0) base_eegs_resampled = resample_filter.filter() base_eegs_resampled_direct = base_eegs.resampled(resampled_rate=100.0) # -------------- testing assert_array_equal(eegs_resampled, base_eegs_resampled.data) assert_array_equal(eegs_resampled, base_eegs_resampled_direct.data) base_eegs_resampled_direct_0_0 = base_eegs[0, 0].resampled( resampled_rate=100.0) def test_wavelets_resample(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() resample_filter = ResampleFilter(time_series=pow_wavelet, resamplerate=100.0) pow_wavelet_resampled = resample_filter.filter() print(pow_wavelet_resampled) pow_wavelet_resampled_direct = pow_wavelet.resampled( resampled_rate=100.0) print(pow_wavelet_resampled_direct) # 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 def test_ts_convenience_fcns(self): # # orig ptsa returns extra stime point that's why eegs[:,:,:-1] eegs = self.eegs[:, :, :-1] base_eegs = self.base_eegs mean_eegs = eegs.mean(axis='time') mean_base_eegs = base_eegs.mean(dim='time') assert_array_equal(mean_eegs, mean_base_eegs) min_eegs = eegs.min(axis='time') min_base_eegs = base_eegs.min(dim='time') assert_array_equal(min_eegs, min_base_eegs) max_eegs = eegs.max(axis='time') max_base_eegs = base_eegs.max(dim='time') assert_array_equal(max_eegs, max_base_eegs) cumsum_eegs = eegs.cumsum(axis='time') cumsum_base_eegs = np.cumsum(base_eegs, axis=base_eegs.get_axis_num('time')) assert_array_equal(cumsum_eegs, cumsum_base_eegs) cumprod_eegs = eegs.cumprod(axis='time') cumprod_base_eegs = np.cumprod(base_eegs, axis=base_eegs.get_axis_num('time')) assert_array_equal(cumprod_eegs, cumprod_base_eegs) std_eegs = eegs.std(axis='time') std_base_eegs = base_eegs.std(dim='time') assert_array_equal(std_eegs, std_base_eegs) sum_eegs = eegs.sum(axis='time') sum_base_eegs = base_eegs.sum(dim='time') assert_array_equal(sum_eegs, sum_base_eegs) argmin_eegs = eegs.argmin(axis='time') argmin_base_eegs = base_eegs.argmin(dim='time') assert_array_equal(argmin_eegs, argmin_base_eegs) argmax_eegs = eegs.argmax(axis='time') argmax_base_eegs = base_eegs.argmax(dim='time') assert_array_equal(argmax_eegs, argmax_base_eegs) argsort_eegs = eegs.argsort(axis='time') argsort_base_eegs = np.argsort(base_eegs, axis=base_eegs.get_axis_num('time')) assert_array_equal(argsort_eegs, argsort_base_eegs) # could not get compress to work using timeseries.compress method # compress_eegs = eegs.compress(condition=[0,2], axis='time') # compress_base_eegs = np.compress(condition=[0,1], a=base_eegs.data, axis=base_eegs.get_axis_num('channels')) # assert_array_equal(compress_eegs, compress_base_eegs) diagonal_eegs = eegs.diagonal(offset=0, axis1=1, axis2=2) diagonal_base_eegs = np.diagonal(base_eegs, offset=0, axis1=1, axis2=2) assert_array_equal(diagonal_eegs, diagonal_base_eegs) flatten_eegs = eegs.flatten() flatten_base_eegs = base_eegs.data.flatten() assert_array_equal(flatten_eegs, flatten_base_eegs) prod_eegs = eegs.prod(axis='channels') prod_base_eegs = base_eegs.prod(dim='channels') assert_array_equal(prod_eegs, prod_base_eegs) ptp_eegs = eegs.ptp(axis='channels') ptp_base_eegs = np.ptp(base_eegs.data, axis=base_eegs.get_axis_num('channels')) assert_array_equal(ptp_eegs, ptp_base_eegs) ravel_eegs = eegs.ravel() ravel_base_eegs = np.ravel(base_eegs) assert_array_equal(ravel_eegs, ravel_base_eegs) repeat_eegs = eegs.repeat(repeats=2, axis='channels') repeat_base_eegs = np.repeat(base_eegs.data, repeats=2, axis=base_eegs.get_axis_num('channels')) assert_array_equal(repeat_eegs, repeat_base_eegs) swapaxes_eegs = eegs.swapaxes(axis1='channels', axis2='events') swapaxes_base_eegs = base_eegs.transpose('events', 'channels', 'time') assert_array_equal(swapaxes_eegs, swapaxes_base_eegs) take_eegs = eegs.take(indices=[2, 4, 6, 8], axis='events') take_base_eegs = base_eegs.isel(events=[2, 4, 6, 8]) assert_array_equal(take_eegs, take_base_eegs) trace_eegs = eegs.trace(offset=0, axis1=0, axis2=2) trace_base_eegs = np.trace(base_eegs, offset=0, axis1=base_eegs.get_axis_num('channels'), axis2=base_eegs.get_axis_num('time')) assert_array_equal(trace_eegs, trace_base_eegs) var_eegs = eegs.var(axis='time') var_base_eegs = base_eegs.var(dim='time') assert_array_equal(var_eegs, var_base_eegs) 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_python_cpp(self): from ptsa.data.filters import MorletWaveletFilter wf = MorletWaveletFilter( timeseries=self.base_eegs, freqs=np.logspace(np.log10(3), np.log10(180), 8), output='power', ) pow_wavelet, phase_wavelet = wf.filter() wf_cpp = MorletWaveletFilter(timeseries=self.base_eegs, freqs=np.logspace(np.log10(3), np.log10(180), 8), output='power', cpus=4) pow_wavelet_cpp, phase_wavelet_cpp = wf_cpp.filter() decimal = 2 freq_num = 0 from scipy.stats import describe desc_cpp = describe(pow_wavelet_cpp[freq_num, :, :, 500:-500]) desc_py = describe(pow_wavelet[freq_num, :, :, 500:-500]) try: assert_array_almost_equal( (pow_wavelet_cpp[freq_num, :, :, 500:-500] - pow_wavelet[freq_num, :, :, 500:-500]) / pow_wavelet_cpp[freq_num, :, :, 500:-500], np.zeros_like(pow_wavelet_cpp[freq_num, :, :, 500:-500]), decimal=decimal) except AssertionError: print( 'WARNING: Cpp and Python wavelets are not within 1%. Will try weaker test ' ) mean_min = np.min((desc_cpp.mean - desc_py.mean) / desc_cpp.mean) mean_max = np.max((desc_cpp.mean - desc_py.mean) / desc_cpp.mean) print('mean_max=', mean_max) print('mean_min=', mean_min) self.assertTrue(np.abs(mean_max) < 0.05) self.assertTrue(np.abs(mean_min) < 0.05) def test_wavelets_multicore(self): from ptsa.data.filters import MorletWaveletFilter print('hello') print(sys.path) wf_cpp_multi = MorletWaveletFilter(timeseries=self.base_eegs, freqs=np.logspace( np.log10(3), np.log10(180), 8), output='both', cpus=8) pow_wavelet_multi, phase_wavelet_multi = wf_cpp_multi.filter() wf_cpp = MorletWaveletFilter(timeseries=self.base_eegs, freqs=np.logspace(np.log10(3), np.log10(180), 8), output='both', cpus=1) pow_wavelet, phase_wavelet = wf_cpp.filter() assert_array_equal(pow_wavelet_multi, pow_wavelet) assert_array_equal(phase_wavelet_multi, phase_wavelet) 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 def test_event_data_chopper(self): dataroot = self.base_events[0].eegfile from ptsa.data.readers import EEGReader session_reader = EEGReader(session_dataroot=dataroot, channels=self.monopolar_channels) session_eegs = session_reader.read() sedc = DataChopper(events=self.base_events, session_data=session_eegs, start_time=0.0, end_time=1.6, buffer_time=1.0) chopped_session = sedc.filter() sedc_so = DataChopper(start_offsets=self.base_events.eegoffset, session_data=session_eegs, start_time=0.0, end_time=1.6, buffer_time=1.0) chopped_session_so = sedc_so.filter() assert_array_equal(chopped_session, chopped_session_so) 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)
newevs_stimParams = np.rec.recarray(len(matevs),dtype=dtypes_stimParams) # sys.exit() for field in matevs.dtype.names: try: newevs[field] = matevs[field] except ValueError: if ((field == 'stimAmp') and (np.all(np.array(matevs[field],np.str)=='X'))): matevs[field].fill(np.nan) newevs[field] = matevs[field] else: # not sure what's going on, so raise the same error as above 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
e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat' base_e_reader = BaseEventReader(event_file=e_path, eliminate_events_with_no_eeg=True, use_ptsa_events_class=False) base_events = base_e_reader.read() base_events = base_events[base_events.type == 'WORD'] base_e_reader_ptsa = BaseEventReader(event_file=e_path, eliminate_events_with_no_eeg=True, use_ptsa_events_class=False) base_events_ptsa = base_e_reader_ptsa.read() base_events_ptsa = base_events_ptsa[base_events_ptsa.type == 'WORD'] base_events_ptsa = Events(base_events_ptsa) base_events_ptsa = attach_rawbinwrappers(base_events_ptsa) print base_events_ptsa base_ev_data_ptsa, base_ev_data_xray = base_events_ptsa.get_data( channels=channels, start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True, return_both=True)
newevs_stimParams = np.rec.recarray(len(matevs), dtype=dtypes_stimParams) # sys.exit() for field in matevs.dtype.names: try: newevs[field] = matevs[field] except ValueError: if ((field == 'stimAmp') and (np.all(np.array(matevs[field], np.str) == 'X'))): matevs[field].fill(np.nan) newevs[field] = matevs[field] else: # not sure what's going on, so raise the same error as above 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
}, 'catFR2':{ 'output_path': rhino_mount+'/data10/scratch/cweidema/RAM/RAM_catFR/RAM_catFR2_power/hdf5_files_sess', 'ev_file': rhino_mount+'/home1/cweidema/Christoph/Analyses/RAM/RAM_catFR/data/RAM_catFR2_events20151106.npy' }, 'FR1':{ 'output_path': rhino_mount+'/data10/scratch/cweidema/RAM/RAM_FR/RAM_FR1_power/hdf5_files_sess', 'ev_file': rhino_mount+'/home1/cweidema/Christoph/Analyses/RAM/RAM_FR/data/RAM_FR1_events20151106.npy' }, 'FR2':{ 'output_path': rhino_mount+'/data10/scratch/cweidema/RAM/RAM_FR/RAM_FR2_power/hdf5_files_sess', 'ev_file': rhino_mount+'/home1/cweidema/Christoph/Analyses/RAM/RAM_FR/data/RAM_FR2_events20151106.npy' } } ev = Events(np.load(pow_params[exp]['ev_file'])) ev = ev.add_fields(esrc=np.dtype(RawBinWrapper)) ev = ev[ev['type']=='WORD'] good_indices = np.ones(len(ev),np.bool) for e,event in enumerate(ev): try: event['esrc'] = RawBinWrapper(rhino_mount+event['eegfile']) except IOError: print('No EEG files for',event['subject'],event['session'],event['eegfile']) good_indices[e] = False ev = ev[good_indices] start_time = -0.6 end_time = 1.6 buf = 1
channels = ['002', '003', '004', '005'] from ptsa.data.readers import BaseEventReader e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat' base_e_reader = BaseEventReader(event_file=e_path, eliminate_events_with_no_eeg=True, use_ptsa_events_class=False) base_events = base_e_reader.read() base_events = base_events[base_events.type == 'WORD'] base_e_reader_ptsa = BaseEventReader(event_file=e_path, eliminate_events_with_no_eeg=True, use_ptsa_events_class=False) base_events_ptsa = base_e_reader_ptsa.read() base_events_ptsa = base_events_ptsa[base_events_ptsa.type == 'WORD'] base_events_ptsa = Events(base_events_ptsa) base_events_ptsa = attach_rawbinwrappers(base_events_ptsa) print base_events_ptsa base_ev_data_ptsa, base_ev_data_xray = base_events_ptsa.get_data(channels=channels, start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=True, eoffset_in_time=False, verbose=True, return_both=True) # casting data DataArray into TimeSeriesXray base_ev_data_xray = TimeSeriesXray(base_ev_data_xray) # baseline_corrected test
def get_sub_events(task, sub, eliminate_events_with_no_eeg=True, rhino_prefix='/', ignore_no_params=False): """Returns all events for a given task and subject identifier Keyword arguments: task -- string of task name sub -- string of subject identifier eliminate_events_with_no_eeg -- (default: True) Do not return events for which no corresponding eeg file exists. rhino_prefix -- (default: '/') To get data if rhino is mounted as an external volume from a local computer. ignore_no_params -- (default: False) Automatically handles IOError when no params.txt file is found for a subject. """ from MatlabIO import read_single_matlab_matrix_as_numpy_structured_array e_path = rhino_prefix+'/data/events/'+task+'/'+sub+'_events.mat' # extract matlab matrix (called 'events') as numpy structured array struct_array = read_single_matlab_matrix_as_numpy_structured_array(e_path, 'events') evs = Events(struct_array) if eliminate_events_with_no_eeg: # eliminating events that have no eeg file indicator = np.empty(len(evs), dtype=bool) indicator[:] = False for i, ev in enumerate(evs): indicator[i] = (type(evs[i].eegfile).__name__.startswith('unicode')) & (len(str(evs[i].eegfile)) > 3) #Due to numpy upgrade evs = Events(evs[indicator]) evs = evs.add_fields(esrc=np.dtype(RawBinWrapper)) import pathlib #This may throw and error for a few subjects who have no params file. Should be written to handle this elegantly. if ignore_no_params: try: for ev in evs: try: eeg_file_path = join(rhino_prefix, str(pathlib.Path(str(ev.eegfile)).parts[1:])) ev.esrc = RawBinWrapper(eeg_file_path) #self.raw_data_root=str(eeg_file_path) except TypeError: print 'skipping event with eegfile=',ev.eegfile pass except IOError: print('No params.txt or .params file found for '+sub) else: for ev in evs: try: eeg_file_path = join(rhino_prefix, str(pathlib.Path(str(ev.eegfile)).parts[1:])) ev.esrc = RawBinWrapper(eeg_file_path) #self.raw_data_root=str(eeg_file_path) except TypeError: print 'skipping event with eegfile=',ev.eegfile pass return(evs)
def run(self): # PTSA EVENT READER # e_path = join(self.pipeline.mount_point, 'data/events', self.pipeline.task,self.pipeline.subject+'_events.mat') e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat' # e_path = '/Users/m/data/events/RAM_FR1/R1056M_events.mat' e_reader = PTSAEventReader(event_file=e_path, eliminate_events_with_no_eeg=True) e_reader.read() events = e_reader.get_output() events = events[events.type == 'WORD'] events = events[0:30] ev_order = np.argsort(events, order=('session','list','mstime')) events = events[ev_order] events = Events(events) # necessary workaround for new numpy print 'events=',events eegs= events.get_data(channels=['002','003'], start_time=0.0, end_time=1.6, buffer_time=1.0, eoffset='eegoffset', keep_buffer=False, eoffset_in_time=False,verbose=True) print eegs # BASE READER base_e_reader = BaseEventReader(event_file=e_path, eliminate_events_with_no_eeg=True, use_ptsa_events_class=False) base_e_reader.read() base_events = base_e_reader.get_output() base_events = base_events[base_events.type == 'WORD'] base_ev_order = np.argsort(base_events, order=('session','list','mstime')) base_events = base_events[base_ev_order] base_events = base_events[0:30] print 'base_events=',base_events from ptsa.data.readers.TimeSeriesEEGReader import TimeSeriesEEGReader time_series_reader = TimeSeriesEEGReader(base_events) time_series_reader.start_time = 0.0 time_series_reader.end_time = 1.6 time_series_reader.buffer_time = 1.0 time_series_reader.keep_buffer = False time_series_reader.read(channels=['002','003']) base_eegs = time_series_reader.get_output() print