Changeset 422 for branches

Timestamp:

08/24/09 23:20:02 (3 years ago)

Author:

lestebanez

Message:

spikes : debuging : reduce the unit test FAILURE from 6 to 4. Modified the init of SpikeList to ensure
that even IDs with zero spikes are kept in the SpikeList (to complie with unit test TestMerge?)

Location:

branches/interval/src/signals

Files:

• intervals.py (modified) (1 diff)
• spikes.py (modified) (8 diffs)

branches/interval/src/signals/intervals.py

@@ -40 +40 @@
         for item in sub_intervals:
             assert (len(item) == 2), "Intervals must be a list of tuple (t_start, t_stop) !"
-            assert item[1] > item[0], "Intervals must have tuple with t_start < t_stop !"
+            assert item[1] >= item[0], "Intervals must have tuple with t_start < t_stop !"
     
     def __str__(self):

branches/interval/src/signals/spikes.py

@@ -93 +93 @@
             SpikeTrain
         """
-        self.interval = self.extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)
-        
-        self.spike_times = self.interval.slice_times(numpy.array(spike_times, numpy.float32))
+        self.spike_times = spike_times
+        self.interval = self.extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)        
+        self.spike_times = self.interval.slice_times(numpy.array(self.spike_times, numpy.float32))
 
         # We sort the spike_times. May be slowe, but required for
@@ -110 +110 @@
         else: 
             if t_start == None and t_stop == None :
-                if self.interval :
-                    # absolutely no information provided on interval argument, nor t_start or t_stop, but
-                    # self has a well defined interval
-                    interval_out = self.interval
-                else :
-                    try:
-                        t_start = min(self.spike_times)
-                    except Exception:
-                        print "Error in guessing t_start (first spike), spikes may be empty !"
-                        t_start = 0
-                    try:
-                        t_stop  = max(self.spike_times)
-                    except Exception:
-                        print "Error in guessing t_stop (last spike), spikes may be empty !"
-                        t_stop = t_start+0.1
-                    interval_out = Interval([[t_start, t_stop]])
+                try:
+                    t_start = min(self.spike_times)
+                except Exception:
+                    print "Error in guessing t_start (first spike), spikes may be empty !"
+                    t_start = 0
+                try:
+                    t_stop  = max(self.spike_times)
+                except Exception:
+                    print "Error in guessing t_stop (last spike), spikes may be empty !"
+                    t_stop = t_start+0.1
+                interval_out = Interval([[t_start, t_stop]])
             else :
                 if t_start == None :
@@ -152 +147 @@
         return str(self.spike_times)
 
-    def __format__(self):
-        return 'hella'
-
     def __len__(self):
         return len(self.spike_times)
@@ -803 +795 @@
         #if t_start or t_stop:
 
-        self.interval = extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)
         self.dimensions  = dims
         self.spiketrains = {}
@@ -823 +814 @@
             break_points = numpy.concatenate(([0], break_points))
             break_points = numpy.concatenate((break_points, [N]))
+
+            # even if a spikeTrain is empty, add ID to the cell list
+            for id in id_list:
+                self.spiketrains[id] = SpikeTrain([])
+            # if there are spikes corresponding to an ID, add it
             for idx in xrange(len(break_points)-1):
                 id = spikes[break_points[idx], 0]
                 if id in id_list:
-                    self.spiketrains[id] = SpikeTrain(spikes[break_points[idx]:break_points[idx+1], 1], interval=self.interval)
-
+                    self.spiketrains[id] = SpikeTrain(spikes[break_points[idx]:break_points[idx+1], 1])
+        self.interval = self.extract_intervals_from_SpikeList_arguments(t_start, t_stop, interval)
         if len(self) > 0:
             for id in self.spiketrains.keys():
-                self.spiketrains[id].interval.intersect(SpikeList_interval)
+                self.spiketrains[id].interval = self.interval
 
         
@@ -849 +845 @@
         Return a copy of the SpikeList object
         """
+
         spklist = SpikeList([], [], self.interval, self.dimensions)
         for id in self.id_list():
-            spklist.append(id, self.spiketrains[id])
+            spklist.append(float(id), self.spiketrains[float(id)])
         return spklist
 
-    def extract_intervals_from_SpikeList_arguments(self, t_start=None, t_stop=None, interval=None) :
-        if len(self) > 0:
-            if interval is not None:
-                # interval is fully defined by the user
-                if interval.__class__.__name__ == 'Interval' :
-                    interval_out = interval
-                else :
-                    interval_out = Interval(interval) 
-            else: 
-                if t_start == None and t_stop == None :
-                    if self.interval :
-                        # absolutely no information provided on interval argument, nor t_start or t_stop, but
-                        # self has a well defined interval
-                        interval_out = self.interval
-                    else :
-                        try:
-                            start_times = numpy.array([self.spiketrains[idx].interval.t_start() for idx in self.id_list()], numpy.float32)
-                            t_start = numpy.min(start_times)
-                            logging.debug("Warning, t_start is infered from the data : %f" %t_start)
-                        except Exception:
-                            print "Error in guessing t_start (first spike), spikes may be empty !"
-                            t_start = 0
-                        try:
-                            stop_times = numpy.array([self.spiketrains[idx].interval.t_stop() for idx in self.id_list()], numpy.float32)
-                            t_stop  = numpy.max(stop_times)
-                            logging.debug("Warning, t_stop  is infered from the data : %f" %t_stop)     
-                        except Exception:
-                            t_stop = t_start + 0.1
-                            print "Error in guessing t_stop (last spike), spikes may be empty !"
-                        interval_out = Interval([[t_start, t_stop]])
-                else :
-                    if t_start == None :
-                        try:
-                            start_times = numpy.array([self.spiketrains[idx].interval.t_start() for idx in self.id_list()], numpy.float32)
-                            t_start = numpy.min(start_times)
-                            logging.debug("Warning, t_start is infered from the data : %f" %t_start)
-                        except Exception:
-                            print "Error in guessing t_stop (last spike), spikes may be empty !"
-                            t_start = 0
-                        interval_out = Interval([[t_start, t_stop]])
-                    if t_stop == None :
-                        if t_start.__class__.__name__ == 'float' or t_start.__class__.__name__ == 'int' :
-                            try:
-                                stop_times = numpy.array([self.spiketrains[idx].interval.t_stop() for idx in self.id_list()], numpy.float32)
-                                t_stop  = numpy.max(stop_times)
-                                logging.debug("Warning, t_stop  is infered from the data : %f" %t_stop) 
-                            except Exception:
-                                print "Error in guessing t_stop (last spike), spikes may be empty !"
-                                t_stop = t_start+0.1
-                            interval_out = Interval([[t_start, t_stop]]) 
-                        else :
-                            if t_start.__class__.__name__ == 'Interval' :
-                                interval_out = t_start
-                            else :
-                                interval_out = Interval(t_start)
-        else:
-            raise Exception("No SpikeTrains")
-        return interval_out
-
-
-    def extract_intervals_from_SpikeTrain_arguments(self, t_start=None, t_stop=None, interval=None) :
+    def extract_intervals_from_SpikeList_arguments(self, t_start, t_stop, interval) :
         if interval is not None:
             # interval is fully defined by the user
@@ -923 +860 @@
         else: 
             if t_start == None and t_stop == None :
-                if self.interval :
-                    # absolutely no information provided on interval argument, nor t_start or t_stop, but
-                    # self has a well defined interval
-                    interval_out = self.interval
-                else :
-                    try:
-                        t_start = min(self.spike_times)
-                    except Exception:
-                        print "Error in guessing t_start (first spike), spikes may be empty !"
-                        t_start = 0
-                    try:
-                        t_stop  = max(self.spike_times)
-                    except Exception:
-                        print "Error in guessing t_stop (last spike), spikes may be empty !"
-                        t_stop = t_start+0.1
-                    interval_out = Interval([[t_start, t_stop]])
+                try:
+                    start_times = numpy.array([self.spiketrains[idx].interval.t_start() for idx in self.id_list()], numpy.float32)
+                    t_start = numpy.min(start_times)
+                    logging.debug("Warning, t_start is infered from the data : %f" %t_start)
+                except Exception:
+                    print "Error in guessing t_start (first spike), spikes may be empty !"
+                    t_start = 0
+                try:
+                    stop_times = numpy.array([self.spiketrains[idx].interval.t_stop() for idx in self.id_list()], numpy.float32)
+                    t_stop  = numpy.max(stop_times)
+                    logging.debug("Warning, t_stop  is infered from the data : %f" %t_stop)     
+                except Exception:
+                    t_stop = t_start + 0.1
+                    print "Error in guessing t_stop (last spike), spikes may be empty !"
+                interval_out = Interval([[t_start, t_stop]])
             else :
                 if t_start == None :
                     try:
-                        t_stop  = max(self.spike_times)
+                        start_times = numpy.array([self.spiketrains[idx].interval.t_start() for idx in self.id_list()], numpy.float32)
+                        t_start = numpy.min(start_times)
+                        logging.debug("Warning, t_start is infered from the data : %f" %t_start)
                     except Exception:
                         print "Error in guessing t_stop (last spike), spikes may be empty !"
-                        t_stop = t_start+0.1
+                        t_start = 0
                     interval_out = Interval([[t_start, t_stop]])
                 if t_stop == None :
                     if t_start.__class__.__name__ == 'float' or t_start.__class__.__name__ == 'int' :
                         try:
-                            t_stop  = max(self.spike_times)
+                            stop_times = numpy.array([self.spiketrains[idx].interval.t_stop() for idx in self.id_list()], numpy.float32)
+                            t_stop  = numpy.max(stop_times)
+                            logging.debug("Warning, t_stop  is infered from the data : %f" %t_stop)     
                         except Exception:
                             print "Error in guessing t_stop (last spike), spikes may be empty !"
@@ -1118 +1058 @@
         for id, spiketrain in spikelist.spiketrains.items():
             if id in self.id_list():
-                self.spiketrains[id].merge(spiketrain, relative)
+                self.spiketrains[id].merge(spiketrain)
             else:
                 if relative: