Changeset 409

Timestamp:

07/16/09 14:19:41 (3 years ago)

Author:

pierre

Message:

More and more intervals fixes, addition of a nex wrapper to read .nex files. should be slightly reorganized and commented

Location:

branches/interval

Files:

• setup.py (modified) (1 diff)
• src/__init__.py (modified) (1 diff)
• src/nex (added)
• src/nex/__init__.py (added)
• src/nex/nex_wrapper.py (added)
• src/signals/intervals.py (modified) (3 diffs)
• src/signals/spikes.py (modified) (17 diffs)
• test/test_spikes.py (modified) (1 diff)

branches/interval/setup.py

@@ -11 +11 @@
                 'NeuroTools.tisean',
                 'NeuroTools.spike2',
+                'NeuroTools.nex',
                 'NeuroTools.signals',
                 'NeuroTools.spike2.sonpy',

branches/interval/src/__init__.py

@@ -35 +35 @@
 """
 
-__all__ = ['analysis', 'parameters', 'plotting', 'signals', 'stgen', 'io', 'datastore', 'utilities', 'spike2', 'random', 'optimize', 'tisean']
+__all__ = ['analysis', 'parameters', 'plotting', 'signals', 'stgen', 'io', 'datastore', 'utilities', 'spike2', 'random', 'optimize', 'tisean', 'nex']
 __version__ = "0.1.0 (Asynchronous Astrocyte)"
 

branches/interval/src/signals/intervals.py

@@ -145 +145 @@
         self.interval_data += shift
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    def offset(self, start=None, end=None) :
-        """
-        Modifies globally the intervals by offsetting the start and end of the stimulation. 
-        
-        The start and/or stop arguments should be tuples (limit, offset) where limit
-        defines the reference limit (0 : start, 1: end) from where the new value is
-        defined by adding the offset value to the current start/end.          
-        """
-        n_intervals = len(list(self.interval_data))
-        new_iv = zeros((n_intervals,2))
-        if start is None :
-            for i in range(n_intervals) :
-                new_iv[i,0] = self.interval_data[i][0]
-        else :
-            if start[0] == 0 :
-                for i in range(n_intervals) :
-                    new_iv[i,0] = self.interval_data[i][0] + start[1]
-            if start[0] == 1 :
-                for i in range(n_intervals) :
-                    new_iv[i,0] = self.interval_data[i][1] + start[1]
-        
-        if end is None :
-            for i in range(n_intervals) :
-                new_iv[i,1] = self.interval_data[i][1]
-        else :
-            if end[0] == 0 :
-                for i in range(n_intervals) :
-                    new_iv[i,1] = self.interval_data[i][0] + end[1]
-            if end[0] == 1 :
-                for i in range(n_intervals) :
-                    new_iv[i,1] = self.interval_data[i][1] + end[1]
-
-        self.interval_data = interval(*list(new_iv))
-
     def total_duration(self) :
         """
@@ -203 +154 @@
         return tot_duration
 
-
     def slice_times(self, times):
         spikes_selector = numpy.zeros(len(times), dtype=numpy.bool)
@@ -212 +162 @@
             spikes_selector = (times >= self.t_start()) & (times <= self.t_stop())
         return numpy.extract(spikes_selector, times)
+
+    def idx_slice_times(self, times):
+        spikes_selector = numpy.zeros(len(times), dtype=numpy.bool)
+        if HAVE_INTERVAL:
+            for itv in self.interval_data :
+                spikes_selector = spikes_selector + (times > itv[0])*(times <= itv[1])
+        else:
+            spikes_selector = (times >= self.t_start()) & (times <= self.t_stop())
+        return spikes_selector
 
     def is_equal(self, itv) :

branches/interval/src/signals/spikes.py

@@ -390 +390 @@
             interval = self.interval
         
-        spikes  = interval.slice_times(self.spike_times)
+        if not interval.is_equal(self.interval):
+            spikes  = interval.slice_times(self.spike_times)
+        else:
+            spikes = self
+
         subplot = get_display(display)
         if not subplot or not HAVE_PYLAB:
@@ -607 +611 @@
         t_max_l  = numpy.floor(t_max/time_bin)
         result   = numpy.zeros((t_min_l+t_max_l), numpy.float32)
-        t_start  = numpy.floor(self.t_start/time_bin)
-        t_stop   = numpy.floor(self.t_stop/time_bin)
         for ev in events:
-           ev = numpy.floor(ev/time_bin)
-           if ((ev - t_min_l )> t_start) and (ev + t_max_l ) < t_stop:
+           itv = Interval((ev-t_min,ev+t_max))
+           ev  = numpy.floor(ev/time_bin)
+           if itv.intersect(self.interval).total_duration() == (t_max+t_min):
                count  += 1
                result += spk_hist[(ev-t_min_l):ev+t_max_l]
@@ -1432 +1435 @@
             mean_rates, mean_rate_std
         """
-        return numpy.mean(self.mean_rates(t_start, t_stop))
+        return numpy.mean(self.mean_rates(interval))
 
 
@@ -1662 +1665 @@
 
     
-    def activity_map(self, t_start=None, t_stop=None, float_positions=None, display=False, kwargs={}):
+    def activity_map(self, interval=None, float_positions=None, display=False, kwargs={}):
         """
         Generate a 2D map of the activity averaged between t_start and t_stop.
@@ -1693 +1696 @@
         subplot = get_display(display)
         
-        if t_start == None: 
-            t_start = self.t_start
-        if t_stop  == None: 
-            t_stop  = self.t_stop
-        if t_start != self.t_start or t_stop != self.t_stop:
-            spklist = self.time_slice(t_start, t_stop)
+        if interval is None:
+            interval = self.interval
+        
+        if not interval.is_equal(self.interval):
+            spklist = self.interval_slice(interval)
         else:
             spklist = self
@@ -1717 +1719 @@
                 pylab.draw()
         elif isinstance(float_positions, numpy.ndarray):
-            if not len(spklist.id_list()) == len(float_positions[0]):
+            if not len(spklist.id_list()) == len(fspike2loat_positions[0]):
                 raise Exception("Error, the number of flotting positions does not match the number of cells in the SpikeList")
             rates = spklist.mean_rates()
@@ -1844 +1846 @@
             raise Exception("The two SpikeList must have common time axis !")
         
-        num_bins     = int(numpy.round((self.t_stop-self.t_start)/time_bin)+1)
+        num_bins     = int(numpy.round((self.interval.t_stop()-self.interval.t_start())/time_bin)+1)
         mat_neur1    = numpy.zeros((num_bins,N),int)
         mat_neur2    = numpy.zeros((num_bins,N),int)
@@ -1856 +1858 @@
         for idx in xrange(len(cells_id)):
             ids2[numpy.where(ids2 == cells_id[idx])[0]] = idx
-        times1  = numpy.array(((times1 - self.t_start)/time_bin),int)
-        times2  = numpy.array(((times2 - self.t_start)/time_bin),int)
+        times1  = numpy.array(((times1 - self.interval.t_start())/time_bin),int)
+        times2  = numpy.array(((times2 - self.interval.t_stop())/time_bin),int)
         mat_neur1[times1,ids1] = 1
         mat_neur2[times2,ids2] = 1
@@ -1880 +1882 @@
                 xlabel  = "Time (ms)"
                 ylabel  = "Normalized CC"
-                subplot.plot(xaxis+self.t_start, cc_time, **kwargs)
+                subplot.plot(xaxis+self.interval.t_start(), cc_time, **kwargs)
                 set_labels(subplot, xlabel, ylabel)
                 pylab.draw()
@@ -1978 +1980 @@
         if not isinstance(spikelist, SpikeList):
             raise Exception("Error, argument should be a SpikeList object")
-        if not spikelist.time_parameters() == self.time_parameters():
-            raise Exception("Error, both SpikeLists should share common t_start, t_stop")
+        if not spikelist.interval.is_equal(self.interval):
+            raise Exception("Error, both SpikeLists should share common intervals")
         frate_1 = self.firing_rate(time_bin, average=True)
         frate_2 = spikelist.firing_rate(time_bin, average=True)
@@ -2025 +2027 @@
         else:
             ids, spike_times = spk.convert(format="[ids, times]")
-            idx = numpy.where((spike_times >= t_start) & (spike_times <= t_stop))[0]
             if len(spike_times) > 0:
                 subplot.plot(spike_times, ids, ',', **kwargs)
@@ -2077 +2078 @@
         t_max_l  = numpy.floor(t_max/time_bin)
         result   = numpy.zeros((len(self), t_min_l+t_max_l), numpy.float32)
-        t_start  = numpy.floor(self.t_start/time_bin)
-        t_stop   = numpy.floor(self.t_stop/time_bin)
         for ev in events:
-           ev = numpy.floor(ev/time_bin)
-           if ((ev - t_min_l )> t_start) and (ev + t_max_l ) < t_stop:
+           itv = Interval((ev-t_min,ev+t_max))
+           ev  = numpy.floor(ev/time_bin)
+           if itv.intersect(self.interval).total_duration() == (t_max+t_min):
                count  += 1
                result += spk_hist[:,(ev-t_min_l):ev+t_max_l]
@@ -2111 +2111 @@
 
 
-    def activity_movie(self, time_bin=10, t_start=None, t_stop=None, float_positions=None, output="animation.mpg", bounds=(0,5), fps=10, display=True, kwargs={}):
+    def activity_movie(self, time_bin=10, 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.
@@ -2145 +2145 @@
         """
         subplot = get_display(display)
-        if t_start is None: t_start = self.t_start
-        if t_stop is None:  t_stop  = self.t_stop
+        
+        if interval is None:
+            interval = self.interval
+
         if not subplot or not HAVE_PYLAB:
             print PYLAB_ERROR
@@ -2158 +2160 @@
             idx       = 0
             manager   = pylab.get_current_fig_manager()
-            if t_start != self.t_start or t_stop != self.t_stop:
-                spk   = self.time_slice(t_start, t_stop)
+            if not interval.is_equal(self.interval):
+                spk   = self.interval_slice(interval)
             else:
                 spk   = self
+            t_start, t_stop = self.interval.time_parameters()
             time, pos = spk.convert("times, ids")
             # We sort the spikes to allow faster process later
@@ -2341 +2344 @@
 #############################################################
 
-def load_spikelist(user_file, id_list=None, t_start=None, t_stop=None, dims=None):
+def load_spikelist(user_file, id_list=None, interval=None, dims=None):
     """
     Returns a SpikeList object from a file. If the file has been generated by PyNN, 
@@ -2363 +2366 @@
     """
     spike_loader = DataHandler(user_file)
-    return spike_loader.load_spikes(id_list=id_list, t_start=t_start, t_stop=t_stop, dims=dims)
+    return spike_loader.load_spikes(id_list=id_list, interval=interval, dims=dims)
 
 

branches/interval/test/test_spikes.py

@@ -36 +36 @@
     def testCreateSpikeTrain(self):
         spk = spikes.SpikeTrain(numpy.arange(0,110,10))
-        assert (spk.t_start == 0) and (spk.t_stop == 100)
+        t_start, t_stop = spk.time_parameters()
+        assert (t_start == 0) and (t_stop == 100)
         self.assert_( arrays_are_equal(spk.spike_times, numpy.arange(0,110,10)) )
     
     def testCreateSpikeTrainFromList(self):
         spk = spikes.SpikeTrain(range(0,110,10))
-        assert (spk.t_start == 0) and (spk.t_stop == 100)
+        t_start, t_stop = spk.time_parameters()
+        assert (t_start == 0) and (t_stop == 100)
         self.assert_( arrays_are_equal(spk.spike_times, numpy.arange(0,110,10)) )
     
     def testCreateSpikeTrainFull(self):
-        spk = spikes.SpikeTrain(numpy.arange(0,110,10), 0, 100)
-        assert (spk.t_start == 0) and (spk.t_stop == 100)
+        spk = spikes.SpikeTrain(numpy.arange(0,110,10), (0, 100))
+        t_start, t_stop = spk.time_parameters()
+        assert (t_start == 0) and (t_stop == 100)
     
     def testCreateWithTStartOnly(self):