Changeset 420

Timestamp:

08/20/09 01:01:14 (3 years ago)

Author:

lestebanez

Message:

spikes.py : finished to implement the trick for Interval/t_start-t_stop compatibility... This code doesn't yet compile...

Files:

• branches/interval/src/signals/spikes.py (modified) (23 diffs)

branches/interval/src/signals/spikes.py

@@ -93 +93 @@
             SpikeTrain
         """
-        self.interval = extract_intervals_from_function_arguments(t_start, t_stop, interval)
+        self.interval = extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)
         
         self.spike_times = self.interval.slice_times(numpy.array(spike_times, numpy.float32))
@@ -245 +245 @@
                 34.2
         """
-        rate_interval = extract_intervals_from_function_arguments(t_start, t_stop, interval)
+        rate_interval = extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)
 
         rate_interval = rate_interval.intersect(self.interval)
@@ -378 +378 @@
         """
         
-        raster_interval = extract_intervals_from_function_arguments(t_start, t_stop, interval)
+        raster_interval = extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)
 
         if not raster_interval.is_equal(self.interval):
@@ -719 +719 @@
         return F1/F0
 
-    def extract_intervals_from_function_arguments(self, t_start=None, t_stop=None, interval=None) :
+    def extract_intervals_from_SpikeTrain_arguments(self, t_start=None, t_stop=None, interval=None) :
         if interval is not None:
             # interval is fully defined by the user
@@ -727 +727 @@
                 interval_out = Interval(interval) 
         else: 
-            if t_start == None and t_stop == None and self.interval :
+            if t_start == None and t_stop == None and interval :
                 # absolutely no information provided on interval, but
                 # self has a well defined interval
-                interval_out = self.interval
+                interval_out = interval
             else :
                 # first analyse t_stop
@@ -784 +784 @@
     ## Constructor and key methods to manipulate the SpikeList objects   ##
     #######################################################################
-    def __init__(self, spikes, id_list, interval=None, dims=None):
+    def __init__(self, spikes, id_list, t_start=None, t_stop=None, interval=None, dims=None):
         """
         Constructor of the SpikeList object
@@ -792 +792 @@
         """
         #if t_start or t_stop:
-            
-        self.interval    = interval
+
+        self.interval = extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)
         self.dimensions  = dims
         self.spiketrains = {}
@@ -817 +817 @@
                 if id in id_list:
                     self.spiketrains[id] = SpikeTrain(spikes[break_points[idx]:break_points[idx+1], 1], interval=self.interval)
-        
-        if len(self) > 0 and (self.interval is None):
-            self.__calc_startstop()
-
+
+        if len(self) > 0:
+            for id in self.spiketrains.keys():
+                self.spiketrains[id].interval.intersect(SpikeList_interval)
+
+        
     def id_list(self):
         """ 
@@ -842 +844 @@
         return spklist
 
-    def __calc_startstop(self):
-        """
-        t_start and t_stop are shared for all neurons, so we take min and max values respectively.
-        TO DO : check the t_start and t_stop parameters for a SpikeList. Is it commun to
-        all the spikeTrains within the spikelist or each spikelistes do need its own.
-        """
+    def extract_intervals_from_SpikeList_arguments(self, t_start=None, t_stop=None, interval=None) :
         if len(self) > 0:
-            if self.interval is None:
-                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)
-
-                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)
-
-                for id in self.spiketrains.keys():
-                    self.spiketrains[id].interval = Interval((t_start, t_stop))
+            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 and interval :
+                    # absolutely no information provided on interval, but
+                    # self has a well defined interval
+                    interval_out = interval
+                else :
+                    # first analyse t_stop
+                    if t_stop == None :
+                        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 = 0.1
+                    
+                    # then analyse t_start (ovewrite t_stop if t_start is actually an interval)
+                    if t_start == None :  # no t_start
+                        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
+                        interval_out = Interval([[t_start, t_stop]])
+                    else :
+                        if t_start.__class__.__name == 'float' or t_start.__class__.__name == 'int' :
+                            # migrate the t_start/t_stop notation to an Interval 
+                            interval_out = Interval([[t_start, t_stop]]) 
+                        else :
+                            if t_start.__class__.__name__ == 'Interval' :
+                                interval_out = interval
+                            else :
+                                interval_out = Interval(interval)
         else:
             raise Exception("No SpikeTrains")
+        return interval_out
+
 
     def __getitem__(self, id):
@@ -983 +1012 @@
             spklists - could be a single SpikeList or a list of SpikeLists
         
-        The concatenated SpikeLists must have similar (t_start, t_stop), and
+        The concatenated SpikeLists must have similar interval, and
         they can't shared similar cells. All their ids have to be different.
         
@@ -1027 +1056 @@
     def complete(self, id_list):
         """
-        Complete the SpikeList by adding Sempty SpikeTrain for all the ids present in
+        Complete the SpikeList by adding empty SpikeTrain for all the ids present in
         ids that will not already be in the SpikeList
         
@@ -1454 +1483 @@
             
 
-    def mean_rate(self, interval=None):
+    def mean_rate(self, t_start=None, t_stop=None, interval=None):
         """
         Return the mean firing rate averaged accross all SpikeTrains between t_start and t_stop.
@@ -1470 +1499 @@
             mean_rates, mean_rate_std
         """
+        interval = extract_intervals_from_SpikeList_arguments(t_start, t_stop, interval)
+
         return numpy.mean(self.mean_rates(interval))
 
 
-    def mean_rate_std(self, interval=None):
+    def mean_rate_std(self, t_start=None, t_stop=None, interval=None):
         """
         Standard deviation of the firing rates accross all SpikeTrains 
@@ -1490 +1521 @@
             mean_rate, mean_rates
         """
+        interval = extract_intervals_from_SpikeList_arguments(t_start, t_stop, interval)
         return numpy.std(self.mean_rates(interval))
 
 
-    def mean_rates(self, interval=None):
+    def mean_rates(self, t_start=None, t_stop=None, interval=None):
         """ 
         Returns a vector of the size of id_list giving the mean firing rate for each neuron
@@ -1505 +1537 @@
             mean_rate, mean_rate_std
         """
+        interval = extract_intervals_from_SpikeList_arguments(t_start, t_stop, interval)
         rates = []
         for id in self.id_list():
@@ -1700 +1733 @@
 
     
-    def activity_map(self, interval=None, float_positions=None, display=False, kwargs={}):
+    def activity_map(self, t_start=None, t_stop=None, interval=None, float_positions=None, display=False, kwargs={}):
         """
         Generate a 2D map of the activity averaged between t_start and t_stop.
@@ -1730 +1763 @@
         """
         subplot = get_display(display)
-        
-        if interval is None:
-            interval = self.interval
-        
+
+        interval = extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)        
         if not interval.is_equal(self.interval):
             spklist = self.interval_slice(interval)
@@ -2024 +2055 @@
 
 
-    def raster_plot(self, id_list=None, interval=None, display=True, kwargs={}):
+    def raster_plot(self, id_list=None, t_start=None, t_stop=None, interval=None, display=True, kwargs={}):
         """
         Generate a raster plot for the SpikeList in a subwindow of interest,
@@ -2052 +2083 @@
             spk = self.id_slice(id_list)
 
-        if interval is None:
-            interval = spk.interval
-
+        interval = extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)   
         if not interval.is_equal(spk.interval):
             spk = spk.interval_slice(interval)
@@ -2146 +2175 @@
 
 
-    def activity_movie(self, time_bin=10, interval=None, float_positions=None, output="animation.mpg", bounds=(0,5), fps=10, display=True, kwargs={}):
+    def activity_movie(self, time_bin=10, t_start=None, t_stop=None, interval=None, float_positions=None, output="animation.mpg", bounds=(0,5), fps=10, display=True, kwargs={}):
         """
         Generate a movie of the activity between t_start and t_stop.
@@ -2180 +2209 @@
         """
         subplot = get_display(display)
-        
-        if interval is None:
-            interval = self.interval
-
+
+        interval = extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)   
         if not subplot or not HAVE_PYLAB:
             print PYLAB_ERROR
@@ -2379 +2406 @@
 #############################################################
 
-def load_spikelist(user_file, id_list=None, interval=None, dims=None):
+def load_spikelist(user_file, id_list=None, t_start=None, t_stop=None, interval=None, dims=None):
     """
     Returns a SpikeList object from a file. If the file has been generated by PyNN, 
@@ -2400 +2427 @@
     The format of the file (text, pickle) will be inferred automatically
     """
+    interval = extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)   
     spike_loader = DataHandler(user_file)
     return spike_loader.load_spikes(id_list=id_list, interval=interval, dims=dims)