Changeset 202

Timestamp:

09/19/08 17:12:29 (4 months ago)

Author:

pierre

Message:

Finish a lot of documentation, delete spikes.py, and create a io.py file to regroup all the read/write function that will handles SpikeList. Now all function can be plotted in subplots, with extra params. Need to be continued

Files:

• branches/cleanup/src/__init__.py (modified) (1 diff)
• branches/cleanup/src/analysis.py (modified) (1 diff)
• branches/cleanup/src/io.py (added)
• branches/cleanup/src/signals.py (modified) (36 diffs)
• branches/cleanup/src/spikes.py (deleted)

branches/cleanup/src/__init__.py

@@ -1 @@
-pikes', 'signals', 'stgen', 'utilities
+ignals', 'stgen', 'utilities', 'io
-
-"""from tables import __version__

branches/cleanup/src/analysis.py

@@ -12 +12 @@
-def ccf(x, y, axis=None):
-    """Computes the cross-correlation function of two series `x` and `y`.
-
-
-
-
-
-
-
-
-
-
-
-
-
+        
+        
+        
+        
+
+        
+        
+        
+        
+        
+        
+        
+        
-    """
-    assert(x.ndim == y.ndim, "Inconsistent shape !")

branches/cleanup/src/signals.py

@@ -6 +6 @@
-import numpy, os, logging, re
-from NeuroTools import analysis
+from NeuroTools import io
-
-try :
@@ -14 +15 @@
-    print "Warning: pylab not detected, plots will be disabled"
-
-
-DEFAULT_BUFFER_SIZE = 10000
-
-class SpikeTrain(object):
@@ -86 +85 @@
-        size = len(spike_times)
-        if size == 0:
-
+ 
-                self.t_start = 0
-            if self.t_stop is None:
@@ -161 +160 @@
-        """
-        return self.t_stop - self.t_start
+    
+    def merge(self, spiketrain):
+        """
+        Add the spike times from a spiketrain to the current SpikeTrain
+        
+        Inputs:
+            spiketrain     - The SpikeTrain that should be added
+        
+        Examples:
+            >> a = SpikeTrain(range(0,100,10),0.1,0,100)
+            >> b = SpikeTrain(range(400,500,10),0.1,400,500)
+            >> a.merge(b)
+            >> a.spike_times
+            >> [   0.,   10.,   20.,   30.,   40.,   50.,   60.,   70.,   80.,
+                90.,  400.,  410.,  420.,  430.,  440.,  450.,  460.,  470.,
+                480.,  490.]
+            >> a.t_stop
+            >> 500
+        """
+        self.spike_times = numpy.concatenate((self.spike_times, spiketrain.spike_times))
+        self.spike_times = numpy.sort(self.spike_times)
+        self.t_start     = min(self.t_start, spiketrain.t_start)
+        self.t_stop      = max(self.t_stop, spiketrain.t_stop)
-
-    def format(self, relative=False, quantized=False):
@@ -210 +232 @@
-        return numpy.diff(self.spike_times)
-
-    # Returns the mean firing rate of the SpikeTrain
-    def mean_rate(self, t_start=None, t_stop=None):
-        """ 
@@ -229 +250 @@
-        return 1000.*len(idx)/(t_stop-t_start)
-
-    # Returns the cv of the isi of the SpikeTrain
-    def cv_isi(self):
-        """
@@ -255 +275 @@
-    def fano_factor_isi(self):
-        """ 
-
+
+
+
-        
-        See also
@@ -285 +307 @@
-        return numpy.arange(self.t_start, self.t_stop, time_bin)
-
-
-    def raster_plot(self, t_start=None, t_stop=None, display=True, kwargs={}):
-        """
@@ -310 +331 @@
-        subplot = self.__getdisplay__(display)
-        if not subplot or not ENABLE_PLOTS:
-
+
+
-        else:
-            if len(spikes) > 0:
@@ -372 +394 @@
-            self.t_start      = 0.0
-
+
+    ####################################################################
+    ### TOO SPECIFIC METHOD ?
+    ### Better documentation
+    ####################################################################
-    def tuning_curve(self, var_array, normalized=False, method='sum'):
-        """
@@ -418 +445 @@
-        return tuning_curve
-
+
+    ####################################################################
+    ### TOO SPECIFIC METHOD ?
+    ### Better documentation
+    ####################################################################
-    def frequency_spectrum(self, time_bin):
-        """
@@ -423 +455 @@
-        frequency axis.
-        """
-
+      
-        freq_spect = analysis.simple_frequency_spectrum(hist)
-
-
+  
+ 
-        return freq_spect, freq_axis    
-
+
+    ####################################################################
+    ### TOO SPECIFIC METHOD ?
+    ### Better documentation
+    ####################################################################
-    def f1f0_ratio(self, time_bin, f_stim):
-        """
@@ -444 +481 @@
-            raise Exception(errmsg)
-        return F1/F0
-    
-    def merge(self, spiketrain, relative_times=False):
-        """
-        Add the spike times from `spiketrain` to this `SpikeTrain`s spike list.
-        """
-        if relative_times:
-            self.relative_times()
-            spiketrain.relative_times()
-        self.spike_times = numpy.concatenate((self.spike_times, spiketrain.spike_times))
-        self.spike_times.sort()
-        self.t_start = min(self.t_start, spiketrain.t_start)
-        self.t_stop  = max(self.t_stop, spiketrain.t_stop)
-        
-
@@ -500 +525 @@
-        self.dt      = dt
-        self.label   = label
-= None
-
+ = dims
+    
-        self.spiketrains = {}
-
@@ -607 +632 @@
-        
-        See also
-
+, __setitem__
-        """
-        assert isinstance(spktrain, SpikeTrain), "A SpikeList object can only contain SpikeTrain objects"
-        if id in self.id_list:
-setitem
+__setitem__ (spk[id]=...)
-        else:
-            self.spiketrains[id] = spktrain.time_slice(self.t_start, self.t_stop)
@@ -641 +666 @@
-            spklists - could be a single SpikeList or a list of SpikeLists
-        
-t_start and t_stop
-s ids have to be different
-
-
-
+(t_start, t_stop, dt)
+ ids have to be different.
+
+
+, merge, __setitem__
-        """
-        if isinstance(spklists, SpikeList):
@@ -675 +700 @@
-    def id_slice(self, id_list):
-        """
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        if isinstance(id_list, int):
-            id_list = numpy.random.permutation(self.id_list)[0:id_list]
@@ -696 +730 @@
-    def time_slice(self, t_start, t_stop):
-        """
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-        for id in self.id_list:
-            new_SpkList.append(id, self.spiketrains[id].time_slice(t_start, t_stop))
-        new_SpkList.__calc_startstop()
-        return new_SpkList
+        
+    
+    def save(self, filename):
+        """
+        Save the SpikeList in a text file
+        
+        Inputs:
+            filename - name of the file
+        """
+        ## Should implement a way of saving the new SpikeList, using io class
+        pass
-
-
@@ -713 +762 @@
-
-    
-, nbins=100
+
-        """
-        Return the list of all the isi vectors for all the SpikeTrains objects
@@ -730 +779 @@
-        """
-        Return the histogram of the ISI.
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-        See also:
-            isi
@@ -752 +807 @@
-
-    
-, nbins=100
+
-        """
-        Return the list of all the cv coefficients for all the SpikeTrains objects
@@ -771 +826 @@
-        """
-        Return the histogram of the cv coefficients.
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-        
-        See also:
@@ -791 +852 @@
-            subplot.plot(xaxis, values, **kwargs)
-            pylab.draw()
-            
-
-    def time_axis(self, time_bin):
-        return numpy.arange(self.t_start, self.t_stop, time_bin)
-
-
@@ -800 +857 @@
-        """
-        Return the mean firing rate averaged accross all SpikeTrains between t_start and t_stop.
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-        """
-        return numpy.mean(self.mean_rates(t_start, t_stop))
@@ -809 +876 @@
-    def mean_rate_std(self, t_start=None, t_stop=None):
-        """
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        """
-        return numpy.std(self.mean_rates(t_start, t_stop))
@@ -821 +899 @@
-        Returns a vector of the size of id_list giving the mean rate for each neuron
-
-
-
+
+
+
+
+
+
+
+
-        """
-        rates = []
@@ -833 +917 @@
-        """
-        Return a vector with all the mean firing rates for all SpikeTrains.
-
+
+
+
+
+
+
+
+
+
+
-        """
-        rates   = self.mean_rates()
@@ -852 +945 @@
-        """
-        Generate an array with all the spike_histograms of all the SpikeTrains
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        for idx,id in enumerate(self.id_list):
-
-
-
-
-
-
-
+
-        if not subplot or not ENABLE_PLOTS:
-            return spike_hist
-        else:
-
+
+
+
+
-            xlabel = "Time (ms)"
-            self.__labels__(subplot, xlabel, ylabel)
-sum(spike_hist
+numpy.sum(spike_hist, axis=0
-            pylab.draw()
-            
@@ -885 +979 @@
-    def firing_rate(self, time_bin, display=False, kwargs={}):
-        """
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-        """
-        return self.spike_histogram(time_bin, normalized=True, display=display, kwargs=kwargs)
-
-
-    # Compute the Fano Factor of the population. Need to be checked
-    def fano_factor(self, time_bin):
+        """
+        Compute the Fano Factor of the population activity.
+        
+        Inputs:
+            time_bin   - the number of bins (between the min and max of the data) 
+                         or a list/array containing the lower edges of the bins.
+        
+        The Fano Factor is computed as the variance of the averaged activity divided by its
+        mean
+        
+        See also
+            spike_histogram, firing_rate
+        """
-        firing_rate = self.spike_histogram(time_bin)
-sum(firing_rate
-
+numpy.sum(firing_rate,axis=0
+       
-        return fano
-
@@ -920 +1033 @@
-
-    
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            return id
-        if len(dims) == 2:
-dim
-dim
+self.dimension
+self.dimension
-            return (x,y)
-
-    
-dims, t_start=None, t_stop
+t_start=None, t_stop=None, float_positions
-        """
-        Generate a 2D map of the activity averaged between t_start and t_stop.
-        If t_start and t_stop are not defined, we used those of the SpikeList object
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        
-        See also
@@ -953 +1085 @@
-        subplot = self.__getdisplay__(display)
-        
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-            rates        = spklist.mean_rates()
-            for id in spklist.id_list:
-, dims
+
-                activity_map[position] = rates[id]
-            if not subplot or not ENABLE_PLOTS:
@@ -969 +1108 @@
-                subplot.colorbar()
-                pylab.draw()
-dim
-dim
-
+float_position
+float_position
+flotting 
-            rates = spklist.mean_rates()
-            if not subplot or not ENABLE_PLOTS:
-                return rates
-            else:
-dim
-dim
+float_position
+float_position
-                subplot.scatter(x,y,c=rates, **kwargs)
-                subplot.colorbar()
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        hist_1 = spk1.spike_histogram(time_bin)
-        hist_2 = spk2.spike_histogram(time_bin)
-        length = 2*len(hist_1[0])
-
-
-
+
+
+
+
+
-            # We need to avoid empty spike histogram, otherwise the ccf function
-            # will give a nan vector
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            subplot.plot(xaxis, results)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-        """
-        Function to extract the covariance of the firing rate along time,
@@ -1034 +1187 @@
-        object with same time parameters to calculate the covariance
-        """
-SpkL
+spikel
-            raise Exception("Error, argument should be a SpikeList object")
-SpkL
+spikel
-            raise Exception("Error, both SpikeLists should share common t_start, t_stop and dt")
-        frate_1 = self.firing_rate(time_bin)
-sum(frate_1
+numpy.sum(frate_1, axis=0
-        frate_2 = SpkList.firing_rate(time_bin)
-sum(frate_2)/SpkL
-
-= sum(frate_1*frate_2)/N-sum(frate_1)*
+numpy.sum(frate_2, axis=0)/spikel
+      
+    = numpy.sum(frate_1*frate_2)/N-numpy.sum(frate_1)*numpy.
-        return cov
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        if id_list == None: 
-            id_list = self.id_list
-.id_slice(id_list)
+
-        elif id_list != self.id_list:
-            spk = self.id_slice(id_list)
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-            idx = numpy.where((spike_times >= t_start) & (spike_times <= t_stop))[0]
-            spike_times = spike_times[idx]
-            ids = ids[idx]
-            if len(spike_times) > 0:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+