Changeset 419 for branches

Timestamp:

08/19/09 00:31:31 (3 years ago)

Author:

lestebanez

Message:

1 - implement a mechanism for compatibility between old 't_start', 't_stop' based syntax

and the new interval based time selection mechanism

2 - add this mechanism to most functions in SpikeTrain. Still to be done in SpikeList

Files:

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

branches/interval/src/signals/spikes.py

@@ -54 +54 @@
 class SpikeTrain(object):
     """
-    SpikeTrain(spikes_times, t_start=None, t_stop=None)
+    SpikeTrain(spikes_times, t_start=None, t_stop=None, interval=None)
     This class defines a spike train as a list of times events.
 
@@ -63 +63 @@
         t_start     - beginning of the SpikeTrain (if not, this is infered)
         t_stop      - end of the SpikeTrain (if not, this is infered)
+        interval    - an Interval instance or a list of value couples that
+                      indicates when the spike train is defined.
+    
+    Note on inputs: either the t_start/t_stop or the interval should be provided.
+    If both are provided, the t_start/t_stops are ignored. 
+    If no argument name is provided, and the second argument of the function is
+    a list of 2-value tuples, then it is an interval.
+    If this second argument is a single number, it is counted as a t_start.
+    
 
     Examples:
@@ -77 +86 @@
     ## Constructor and key methods to manipulate the SpikeTrain objects  ##
     #######################################################################
-    def __init__(self, spike_times, interval=None):
+    def __init__(self, spike_times, t_start=None, t_stop=None, interval=None):
         """
         Constructor of the SpikeTrain object
@@ -84 +93 @@
             SpikeTrain
         """
-        if interval is not None:
-            self.interval = interval
-        else:
-            try:
-                t_start = min(spike_times)
-            except Exception:
-                print "Error in guessing t_start (first spike), spikes may be empty !"
-                t_start = 0
-            try:
-                t_stop  = max(spike_times)
-            except Exception:
-                print "Error in guessing t_stop (last spike), spikes may be empty !"
-                t_stop = 0.1
-            self.interval = Interval((t_start, t_stop))
-
+        self.interval = extract_intervals_from_function_arguments(t_start, t_stop, interval)
+        
         self.spike_times = self.interval.slice_times(numpy.array(spike_times, numpy.float32))
 
-        # We sort the spike_times. May be slower, but is necessary by the way for quite a 
-        # lot of methods...
+        # We sort the spike_times. May be slowe, but required for
+        # several analysis methods
         self.spike_times = numpy.sort(self.spike_times, kind="quicksort")
-        # Here we deal with the t_start and t_stop values if the SpikeTrain
-        # is empty, with only one element or several elements, if we
-        # need to guess t_start and t_stop
-        # no element : t_start = 0, t_stop = 0.1 
-        # 1 element  : t_start = time, t_stop = time + 0.1
-        # several    : t_start = min(time), t_stop = max(time)
-
 
     def __str__(self):
@@ -245 +234 @@
         return numpy.diff(self.spike_times)
 
-    def mean_rate(self, interval=None):
+    def mean_rate(self, t_start=None, t_stop=None, interval=None):
         """ 
         Returns the mean firing rate between t_start and t_stop, in Hz
@@ -256 +245 @@
                 34.2
         """
-        if interval:
-            new_interval = interval.intersect(self.interval)
-            idx          = new_interval.slice_times(self.spike_times)
-        else:
-            idx          = self.spike_times
-            new_interval = self.interval
-        return 1000.*len(idx)/new_interval.total_duration()
-
-    def cv_isi(self):
+        rate_interval = extract_intervals_from_function_arguments(t_start, t_stop, interval)
+
+        rate_interval = rate_interval.intersect(self.interval)
+        idx           = rate_interval.slice_times(self.spike_times)
+
+        return 1000.*len(idx)/rate_interval.total_duration()
+
+    def cv_isi(self, t_start=None, t_stop=None, interval=None):
         """
         Return the coefficient of variation of the isis.
@@ -283 +271 @@
             
         """
-        isi = self.isi()
+        isi = self.isi(t_start, t_stop, interval)
         if len(isi) > 0:
             return numpy.std(isi)/numpy.mean(isi)
@@ -290 +278 @@
             return numpy.nan
 
-    def cv_kl(self, bins=100):
+    def cv_kl(self, bins=100, t_start=None, t_stop=None, interval=None):
         """
         Provides a measure for the coefficient of variation to describe the
@@ -313 +301 @@
             
         """
-        isi = self.isi() / 1000.
+        isi = self.isi(t_start, t_stop, interval) / 1000.
         if len(isi) < 2:
             logging.debug("Warning, a CV can't be computed because there are not enough spikes")
@@ -332 +320 @@
     
 
-    def fano_factor_isi(self):
+    def fano_factor_isi(self, t_start=None, t_stop=None, interval=None):
         """ 
         Return the fano factor of this spike trains ISI.
@@ -343 +331 @@
             isi, cv_isi
         """
-        isi = self.isi()
+        isi = self.isi(t_start, t_stop, interval)
         if len(isi) > 0:
             fano = numpy.var(isi)/numpy.mean(isi)
@@ -371 +359 @@
         return axis
 
-    def raster_plot(self, interval=None, display=True, kwargs={}):
+    def raster_plot(self, t_start=None, t_stop=None, interval=None, display=True, kwargs={}):
         """
         Generate a raster plot with the SpikeTrain in a subwindow of interest,
@@ -390 +378 @@
         """
         
-        if interval is None:
-            interval = self.interval
-        
-        if not interval.is_equal(self.interval):
-            spikes  = interval.slice_times(self.spike_times)
+        raster_interval = extract_intervals_from_function_arguments(t_start, t_stop, interval)
+
+        if not raster_interval.is_equal(self.interval):
+            spikes  = raster_interval.slice_times(self.spike_times)
         else:
             spikes = self.spike_times
@@ -731 +718 @@
             raise Exception(errmsg)
         return F1/F0
-        
-
+
+    def extract_intervals_from_function_arguments(self, t_start=None, t_stop=None, interval=None) :
+        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 self.interval :
+                # absolutely no information provided on interval, but
+                # self has a well defined interval
+                interval_out = self.interval
+            else :
+                # first analyse t_stop
+                if t_stop == None :
+                    try:
+                        t_stop  = max(self.spike_times)
+                    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
+                        t_start = min(self.spike_times)
+                    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)
+        return interval_out
 
 class SpikeList(object):