Changeset 430

Timestamp:

08/26/09 11:22:13 (3 years ago)

Author:

lestebanez

Message:

analog.py : port the analogSignalList to intervals. One issue : how to represent sliced analog signals ?
A list of sub-signals will not be very compatible with the current reprensentation.
Or reimplement all methods to take into account this new shape.

Location:

branches/interval/src/signals

Files:

• analogs.py (modified) (16 diffs)
• spikes.py (modified) (1 diff)

branches/interval/src/signals/analogs.py

@@ -76 +76 @@
         AnalogSignalList, load_currentlist, load_vmlist, load_conductancelist, load
     """
-    def __init__(self, signal, dt, t_start=0, t_stop=None):
-        logging.debug("Creating AnalogSignal. len(signal)=%d, dt=%g, t_start=%g, t_stop=%s" % (len(signal), dt, t_start, t_stop))
-        self.signal  = numpy.array(signal, float)
+    def __init__(self, signal, dt, t_start=0, t_stop=None, interval=None):
+        #logging.debug("Creating AnalogSignal. len(signal)=%d, dt=%g, t_start=%g, t_stop=%s" % (len(signal), dt, t_start, t_stop))
+        self.signal  = signal
         self.dt      = float(dt)
         self.interval = self.create_intervals(t_start, t_stop, interval)
@@ -100 +100 @@
         else:
             if t_start is None and t_stop is None :
-                try:
-                    t_start = numpy.min(self.spike_times)
-                except Exception:
-                    print "AnalogSignal error in guessing t_start (first spike), spikes may be empty !"
-                    t_start = 0
-                try:
-                    t_stop  = numpy.max(self.spike_times)
-                except Exception:
-                    print "AnalogSignal error in guessing t_stop (last spike), spikes may be empty !"
-                    t_stop = t_start+self.dt
+                print "AnalogSignal interval derived from dt"
+                interval_out = Interval([[0,len(self.signal)*self.dt]])
+            elif t_start is None and t_stop is not None:
+                interval_out = Interval([[t_stop - len(self.signal)*self.dt, t_stop]])
+            elif t_start is not None and t_stop is not None:
+                if (t_stop - t_start)/self.dt != len(self.signal):
+                    print 't_start/t_stop and dt are not consistent with len(signal)'
                 interval_out = Interval([[t_start, t_stop]])
-            elif t_start is None and t_stop is not None:
-                try:
-                    t_start  = numpy.min(self.spike_times)
-                except Exception:
-                    print "AnalogSignal error in guessing t_start (first spike), spikes may be empty !"
-                    t_start = 0
-                interval_out = Interval([[t_start, t_stop]])
-            elif t_start is not None and t_stop is not None:
-                interval_out = Interval([[t_start, t_stop]])
             elif t_start is not None and t_stop is None:
                 if type(t_start) == float or type(t_start) == int:
-                    try:
-                        t_stop  = numpy.max(self.spike_times)
-                    except Exception:
-                        print "AnalogSignal error in guessing t_stop (last spike), spikes may be empty !"
-                        t_stop = t_start+self.dt
-                    interval_out = Interval([[t_start, t_stop]]) 
+                    interval_out = Interval([[t_start, t_start + len(self.signal)*self.dt]])
                 else :
                     if type(t_start) == Interval:
@@ -135 +118 @@
         return interval_out
 
+    def init_times(self):
+        """
+        Update the t_start and t_stop constant to reflect the current t_start() and t_stop() methods
+        """
+        self.t_start = self.interval.t_start()
+        self.t_stop  = self.interval.t_stop()
 
     def __getslice__(self, i, j):
@@ -173 +162 @@
         Return the time axis of the AnalogSignal
         """
+        self.init_times()
+
         if normalized:
             norm = self.t_start
         else:
             norm = 0.
-        return numpy.arange(self.t_start-norm, self.t_stop-norm, self.dt)
+
+        time_pavement = numpy.arange(self.t_start-norm, self.t_stop-norm, self.dt)
+        return SpikeTrain(time_pavement, interval=self.interval).spike_times
     
     def time_offset(self, offset):
@@ -251 +244 @@
         i_stop = int((t_stop-self.t_start)/self.dt)
         signal = self.signal[i_start:i_stop]
-        result = AnalogSignal(signal, self.dt, t_start, t_stop)
-        return result
+
+        return AnalogSignal(signal, self.dt, t_start, t_stop)
 
     def interval_slice(self, interval):
@@ -268 +261 @@
             time_slice
         """
-        result = []
+        signal_list = []
+
+        if type(interval) is not Interval :
+            interval = Interval(interval)
+
         for itv in interval.interval_data :
-            result.append(self.signal[(intv[0]-self.t_start)/self.dt:(intv[1]-t_start)/self.dt])
-        return result
+            signal_list.append(self.signal[(itv[0]-self.t_start)/self.dt:(itv[1]-self.t_start)/self.dt])
+
+        return AnalogSignal(signal_list, self.dt, interval)
 
     def threshold_detection(self, threshold=None, format=None,sign='above'):
@@ -428 +426 @@
         
             
-
-
-
 class AnalogSignalList(object):
     """
@@ -450 +445 @@
         load_currentlist load_vmlist, load_conductancelist
     """
-    def __init__(self, signals, id_list, dt, t_start=0, t_stop=None, dims=None):
-        #logging.debug("Creating an AnalogSignalList. len(signals)=%d, min(id_list)=%d, max(id_list)=%d, dt=%g, t_start=%g, t_stop=%s, dims=%s" % \
-        #                 (len(signals), min(id_list), max(id_list), dt, t_start, t_stop, dims))
-        
-        if t_start is None:
-            t_start = 0
-        self.t_start        = float(t_start)
-        self.t_stop         = t_stop
+    def __init__(self, signals, id_list, dt, t_start=None, t_stop=None, interval=None, dims=None):
+        
         self.dt             = float(dt)
         self.dimensions     = dims
         self.analog_signals = {}
         
-        signals = numpy.array(signals)
-        
+        signals = numpy.array(signals)        
         for id in id_list:
-            signal = numpy.transpose(signals[signals[:,0] == id, 1:])[0]
+            signal = signals[[signals[:,0] == id]][:,1]
+            #signal = numpy.transpose(signals[signals[:,0] == id, 1:])[0]
             if len(signal) > 0:
-                self.analog_signals[id] = AnalogSignal(signal, self.dt, self.t_start, self.t_stop)
-        
-        if id_list:
-            signals = self.analog_signals.values()
-            self.signal_length = len(signals[0])
-            for signal in signals[1:]:
-                if len(signal) != self.signal_length:
-                    raise Exception("Signals must all be the same length %d != %d" % (self.signal_length, len(signal)))
-        else:
-            logging.warning("id_list is empty")
-            self.signal_length = 0
-        
-        if t_stop is None:
-            self.t_stop = self.t_start + self.signal_length*self.dt
+                self.analog_signals[id] = AnalogSignal(signal, self.dt)
+        self.interval = self.create_intervals(t_start, t_stop, interval)
+        self.init_times()
+        if len(self) > 0:
+            for id in self.id_list():
+                self.analog_signals[id] = self.analog_signals[id].interval_slice(self.interval)
+                self.analog_signals[id].init_times()
+        self.init_times()
+
+        #if len(self.id_list()) == 0 :
+            #logging.warning("id_list is empty")
+            #self.signal_length = 0
+                    
+    def create_intervals(self, t_start=None, t_stop=None, interval=None):
+        # due to the design of the __init__, all signals have the same length
+        if len(self.id_list()) > 0 :
+            signal = self.analog_signals[self.id_list()[0]]
+        else :
+            signal = numpy.array([])
+        if hasattr(self, 'interval') and t_start is None and t_stop is None and interval is None:
+            interval_out = self.interval.copy()
+        elif interval is not None:
+            # interval is fully defined by the user
+            if type(interval) == Interval:
+                interval_out = interval.copy()
+            else :
+                interval_out = Interval(interval) 
+        else:
+            if t_start is None and t_stop is None :
+                print "AnalogSignal interval derived from dt"
+                interval_out = Interval([[0,max([len(signal),1])*self.dt]])
+            elif t_start is None and t_stop is not None:
+                interval_out = Interval([[t_stop - len(signal)*self.dt, t_stop]])
+            elif t_start is not None and t_stop is not None:
+                if (t_stop - t_start)/self.dt != len(signal):
+                    print 't_start/t_stop and dt are not consistent with len(signal)'
+                interval_out = Interval([[t_start, t_stop]])
+            elif t_start is not None and t_stop is None:
+                if type(t_start) == float or type(t_start) == int:
+                    interval_out = Interval([[t_start, t_start + len(signal)*self.dt]])
+                else :
+                    if type(t_start) == Interval:
+                        interval_out = t_start.copy()
+                    else :
+                        interval_out = Interval(t_start)
+        return interval_out
+
+    def init_times(self):
+        """
+        Update the t_start and t_stop constant to reflect the current t_start() and t_stop() methods
+        """
+        self.t_start = self.interval.t_start()
+        self.t_stop  = self.interval.t_stop()
 
     def id_list(self):
@@ -509 +537 @@
         if len(self) > 0:
             errmsgs = []
-            for attr in "dt", "t_start", "t_stop":
-                if getattr(val, attr) != getattr(self, attr):
-                    errmsgs.append("%s: %g != %g" % (attr, getattr(val, attr), getattr(self, attr)))
-            if len(val) != self.signal_length:
-                errmsgs.append("signal length: %g != %g" % (len(val), self.signal_length))
-            if errmsgs:
-                raise Exception("AnalogSignal being added does not match the existing signals: "+", ".join(errmsgs))
+            print numpy.shape(val.signal)
+            val = val.interval_slice(self.interval)
+            print numpy.shape(val.signal)
+            if not val.interval.is_equal(self.interval) :
+                raise Exception("the provided signal doesn't cover the AnalogSignalList interval")
         else:
             self.signal_length = len(val)
+            self.interval = self.create_intervals(t_start=None, t_stop=None, interval=val.interval)
             self.t_start = val.t_start
             self.t_stop = val.t_stop
@@ -560 +587 @@
         Return the time axis of the AnalogSignalList object
         """
-        return numpy.arange(self.t_start, self.t_stop, self.dt)
+        self.init_times()
+        time_pavement = numpy.arange(self.t_start, self.t_stop, self.dt)
+        return SpikeTrain(time_pavement, interval=self.interval).spike_times
 
     def id_offset(self, offset):
@@ -597 +626 @@
             time_slice
         """
+        id_list = self.__sub_id_list(id_list)
         new_AnalogSignalList = AnalogSignalList([], [], self.dt, self.t_start, self.t_stop, self.dimensions)
-        id_list = self.__sub_id_list(id_list)
+
         for id in id_list:
             try:
@@ -617 +647 @@
             id_slice
         """
-        new_AnalogSignalList = AnalogSignalList([], [], self.dt, t_start, t_stop, self.dimensions)
+        
+        new_AnalogSignalList = AnalogSignalList([], [], self.dt, t_start, t_stop, interval=None, dims=self.dimensions)
         for id in self.id_list():
             new_AnalogSignalList.append(id, self.analog_signals[id].time_slice(t_start, t_stop))
         return new_AnalogSignalList
+
+    def interval_slice(self, interval):
+        """
+        Return a new AnalogSignalList obtained by slicing between t_start and t_stop
+        Return only the parts of the AnalogSignal that are defined in the range of the interval. 
+        The output is therefor a list of signal segments
+        
+        Inputs:
+            interval - The Interval to slice the AnalogSignalList with
+        
+        Examples:
+            >> as.interval_slice(Interval([0,100],[50,150]))
+
+        See also:
+            time_slice
+        """
+        new_AnalogSignalList = AnalogSignalList([], self.id_list(), self.dt, t_start=None, t_stop=None, interval=interval, dims=self.dimensions)
+        for id in self.id_list():
+            new_AnalogSignalList[id] = self.analog_signals[id].interval_slice(interval)
+        return new_AnalogSignalList
+
 
     def select_ids(self, criteria=None):
@@ -725 +777 @@
             std
         """
-        result = numpy.zeros(int((self.t_stop - self.t_start)/self.dt),float)
-        for id in self.id_list():
-             result += self.analog_signals[id].signal
-        return result/len(self)
+        result = []
+        for i in range(len(self.interval)) :
+            result.append(numpy.zeros(int((self.interval[i][1] - self.interval[i][0])/self.dt),float))
+            for id in self.id_list():
+                result[i] += self.analog_signals[id].signal[i]
+        return numpy.array(result)/len(self)
     
     def std(self):
@@ -742 +796 @@
             mean
         """
-        result = numpy.zeros((len(self), int((self.t_stop - self.t_start)/self.dt)),float)
-        for count, id in enumerate(self.id_list()):
-            try:
-                result[count,:] = self.analog_signals[id].signal
-            except ValueError:
-                print result[count,:].shape, self.analog_signals[id].signal.shape
-                raise
-        return numpy.std(result, axis=0)
+        result = []
+        for i in range(len(self.interval)) :
+            result.append(numpy.zeros((int((self.interval[i][1] - self.interval[i][0])/self.dt),len(self.id_list())),float))
+          
+            for j in range(len(self.id_list())):
+                result[i][j,:] = self.analog_signals[j].signal[i]
+        return [numpy.std(result[i], axis=0) for i in range(len(self.interval))]
 
     def event_triggered_average(self, eventdict, events_ids = None, analogsignal_ids = None, average = True, t_min = 0, t_max = 100, ylim = None, display = False, mode = 'same', kwargs={}):
@@ -780 +833 @@
             >> vmlist.event_triggered_average({'1':[200,300,'3':[234,788]]}, average=False, display=True)
         """
+
         if isinstance(eventdict, SpikeList):
             eventdict = eventdict.spiketrains
+
+        # remove times that are out of the interval +-tmin/tmax
+        filtered_eventdict = {}
+        for index, spike in enumerate(eventdict):
+            if ((spike-t_min) >= self.t_start) and ((spike+t_max) < self.t_stop):
+                filtered_eventdict[index] = spike
+
         figure   = get_display(display)
         subplotcount = 1
         
         if events_ids is None:
-            events_ids = eventdict.keys()
+            events_ids = filtered_eventdict.keys()
         if analogsignal_ids is None:
             analogsignal_ids = self.analog_signals.keys()
@@ -797 +858 @@
         
         for id in events_ids:
-            events = eventdict[id]
+            events = filtered_eventdict[id]
             if len(events) <= 0:
                 continue

branches/interval/src/signals/spikes.py

@@ -103 +103 @@
         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
+        # We sort the spike_times. May be slow, but required for
         # several analysis methods
         self.spike_times = numpy.sort(self.spike_times, kind="quicksort")