Some clean

Author: samuelgarcia

neo/rawio/spikegadgetsrawio.py

@@ -47,11 +47,6 @@ def _parse_header(self):
             f.seek(0)
             header_txt = f.read(header_size).decode('utf8')
 
-            #~ print(header_txt[-10:])
-            #~ f.seek(header_size)
-            #~ print(f.read(10))
-        
-        #~ exit()
         # explore xml header
         root = ElementTree.fromstring(header_txt)
         gconf = sr = root.find('GlobalConfiguration')
@@ -64,70 +59,40 @@ def _parse_header(self):
         # explore sub stream and count packet size
         # first bytes is 0x55
         packet_size = 1
-        
-        #~ main_dtype = []
         stream_bytes = {}
         for device in hconf:
             stream_id = device.attrib['name']
             num_bytes = int(device.attrib['numBytes'])
             stream_bytes[stream_id] = packet_size
             packet_size += num_bytes
-        #~ print('packet_size', packet_size)
-        #~ print(stream_bytes)
-        #~ exit()
 
         # timesteamps 4 uint32
         self._timestamp_byte = packet_size
         packet_size += 4
 
         packet_size += 2 * num_ephy_channels
 
-        print('packet_size', packet_size)
-        
-        #~ num_ephy_channels = num_ephy_channels * 4
-        #~ num_ephy_channels = 0
-        #~ chan_ids = []
-        #~ for chan_ind, trode in enumerate(sconf):
-            #~ for  spikechan in trode:
-                #~ print(spikechan, spikechan.attrib)
-                #~ num_ephy_channels += 1
-                #~ chan_ids.append(int(spikechan.attrib['hwChan']))
-        #~ print('num_ephy_channels', num_ephy_channels)
-        #~ print(np.sort(chan_ids))
-        
-        
-        
-        
-        
+        # read the binary part lazily
         raw_memmap = np.memmap(self.filename, mode='r', offset=header_size, dtype='<u1')
-        
-        inds, = np.nonzero(raw_memmap == 0x55)
-        #~ print(inds)
-        #~ print(np.diff(inds))
-        #~ exit()
-        
-        
         num_packet = raw_memmap.size // packet_size
-        #~ print(num_packet, num_packet*packet_size, raw_memmap.size)
         raw_memmap = raw_memmap[:num_packet*packet_size]
         self._raw_memmap = raw_memmap.reshape(-1, packet_size)
-        
 
+        # create signal channels
         stream_ids = []
         signal_streams = []
         signal_channels = []
 
-        # walk deveice and keep only "analog" one
+        # walk in xml device and keep only "analog" one
         self._mask_channels_bytes  = {}
         for device in hconf:
             stream_id = device.attrib['name']
             for channel in device:
-                #~ print(channel, channel.attrib)
-                
+
                 if 'interleavedDataIDByte' in channel.attrib:
                     # TODO deal with "headstageSensor" wich have interleaved
                     continue
-                
+
                 if channel.attrib['dataType'] == 'analog':
 
                     if stream_id not in stream_ids:
@@ -138,17 +103,15 @@ def _parse_header(self):
 
                     name = channel.attrib['id']
                     chan_id = channel.attrib['id']
-                    dtype = 'int16' # TODO check this
+                    dtype = 'int16'
                     units = 'uV' # TODO check where is the info
                     gain = 1. # TODO check where is the info
-                    offset = 0. # TODO check where is the info
+                    offset = 0.
                     signal_channels.append((name, chan_id, self._sampling_rate, 'int16',
                                          units, gain, offset, stream_id))
 
-                    #~ self._bytes_in_streams[stream_id].append()
                     num_bytes = stream_bytes[stream_id] + int(channel.attrib['startByte'])
                     chan_mask = np.zeros(packet_size, dtype='bool')
-                    # int6: 2 bytes
                     chan_mask[num_bytes] = True
                     chan_mask[num_bytes+1] = True
                     self._mask_channels_bytes[stream_id].append(chan_mask)
@@ -166,37 +129,33 @@ def _parse_header(self):
                     chan_id = schan.attrib['hwChan']
                     units = 'uV' # TODO check where is the info
                     gain = 1. # TODO check where is the info
-                    offset = 0. # TODO check where is the info
+                    offset = 0.
                     signal_channels.append((name, chan_id, self._sampling_rate, 'int16',
                                          units, gain, offset, stream_id))
 
                     chan_mask = np.zeros(packet_size, dtype='bool')
-                    
                     num_bytes = packet_size - 2 * num_ephy_channels + 2 * chan_ind
                     chan_mask[num_bytes] = True
                     chan_mask[num_bytes+1] = True
                     self._mask_channels_bytes[stream_id].append(chan_mask)
 
                     chan_ind += 1
 
-        # make mask as array
+        # make mask as array (used in _get_analogsignal_chunk(...))
         self._mask_streams = {}
         for stream_id, l in self._mask_channels_bytes.items():
             mask = np.array(l)
             self._mask_channels_bytes[stream_id] = mask
             self._mask_streams[stream_id] = np.any(mask, axis=0)
 
-
-
         signal_streams = np.array(signal_streams, dtype=_signal_stream_dtype)
         signal_channels = np.array(signal_channels, dtype=_signal_channel_dtype)
 
-
-        # No events
+        # No events channels
         event_channels = []
         event_channels = np.array(event_channels, dtype=_event_channel_dtype)
 
-        # No spikes
+        # No spikes  channels
         spike_channels = []
         spike_channels = np.array(spike_channels, dtype=_spike_channel_dtype)
 
@@ -235,16 +194,13 @@ def _get_analogsignal_chunk(self, block_index, seg_index, i_start, i_stop, strea
         stream_id = self.header['signal_streams'][stream_index]['id']
 
         raw_unit8 = self._raw_memmap[i_start:i_stop]
-        #~ print('raw_unit8', raw_unit8.shape, raw_unit8.dtype)
 
         num_chan = len(self._mask_channels_bytes[stream_id])
         if channel_indexes is None:
-            # no loop
+            # no loop : entire stream mask
             stream_mask = self._mask_streams[stream_id]
         else:
-            #~ print('channel_indexes', channel_indexes)
-            #~ print('chan_inds', chan_inds)
-
+            # acculate mask
             if  instance(channel_indexes, slice):
                 chan_inds = np.arange(num_chan)[channel_indexes]
             else:
@@ -253,18 +209,13 @@ def _get_analogsignal_chunk(self, block_index, seg_index, i_start, i_stop, strea
             for chan_ind in chan_inds:
                 chan_mask = self._mask_channels_bytes[stream_id][chan_ind]
                 stream_mask |= chan_mask
+            # TODO : make a fix when "channel_indexes" arein wring order.
 
-        
-        
-        #~ print(stream_mask)
-        
-        # thisi fo a copy
+        # this do a copy from memmap to memory
         raw_unit8_mask = raw_unit8[:, stream_mask]
         shape = raw_unit8_mask.shape
         shape = (shape[0], shape[1] // 2)
+        # reshape the and re type by view
         raw_unit16 = raw_unit8_mask.flatten().view('int16').reshape(shape)
-        #~ print(raw_unit16.shape,raw_unit16.strides)
 
         return raw_unit16
-
-