Changeset 3

Timestamp:

04/16/07 16:58:22 (6 years ago)

Author:

davison

Message:

Synchronised with FACETSCOMMON (r163) repository (post Code-Jam).

Location:

trunk

Files:

• common.py (modified) (3 diffs)
• nest.py (modified) (7 diffs)
• neuron2.py (modified) (4 diffs)
• test/nesttests.py (modified) (2 diffs)
• test/neuron2tests.py (modified) (1 diff)

trunk/common.py

@@ -3 +3 @@
 The simulator-specific classes should inherit from these and have the same
 arguments.
-$Id: common.py 78 2007-01-25 10:36:59Z apdavison $
+$Id: common.py 146 2007-04-03 16:19:16Z Pierre $
 """
 __version__ = "$Revision: 284 $"
@@ -360 +360 @@
         pass
 
-    def printSpikes(self,filename,gather=True):
+    def printSpikes(self,filename,gather=True, compatible_output=True):
         """
         Prints spike times to file in the two-column format
@@ -367 +367 @@
         This allows easy plotting of a `raster' plot of spiketimes, with one
         line for each cell.
-        """
-        pass
-    
-    def print_v(self,filename,gather=True):
+        On the first line, we have the dimension of the populations
+        By defaut, we should use a common format for that could be provided independent
+        of the simulator used to run the simulation. This will include post processing
+        of the raw file provided by the simulator, so for speed up increase one can
+        prefer to use avoid this step and use the format proposed by the different simulators
+        """
+        pass
+    
+    def print_v(self,filename,gather=True, compatible_output=True):
         """
         Write membrane potential traces to file.

trunk/nest.py

@@ -2 +2 @@
 """
 PyNEST implementation of the PyNN API.
-$Id: nest.py 78 2007-01-25 10:36:59Z apdavison $
+$Id: nest.py 152 2007-04-04 15:43:10Z Pierre $
 """
 __version__ = "$Revision: 284 $"
@@ -152 +152 @@
 def end():
     """Do any necessary cleaning up before exiting."""
-    for file in spike_files + v_files:
+    for file in spike_files:
         pynest.sr('%s close' % file)
+    for couples in v_files:
+        pynest.sr('%s close' % couples[1])
     pynest.end()
 
@@ -316 +318 @@
             id.setPosition(self.locate(id))
             
-        
         if self.cellparams:
             pynest.setDict(self.cell, self.cellparams)
@@ -459 +460 @@
         pynest.setDict(self.spike_detector,{'withtime':True,  # record time of spikes
                                             'withpath':True}) # record which neuron spiked
+        
+        fixed_list = False
+        
         if record_from:
             if type(record_from) == types.ListType:
+                fixed_list = True
+                n_rec = len(record_from)
+            elif type(record_from) == types.IntType:
+                n_rec = record_from
+            else:
+                raise "record_from must be a list or an integer"
+        else:
+            n_rec = self.size
+        pynest.resCons(self.spike_detector[0],n_rec)
+
+        if (fixed_list == True):
+            for neuron in record_from:
+                pynest.connect(pynest.getAddress(neuron),self.spike_detector[0])
+        else:
+            for neuron in numpy.reshape(self.cell,(self.cell.size,))[0:n_rec]: # should change this to pick randomly
+                pynest.connect(pynest.getAddress(neuron),self.spike_detector[0])
+                
+        # Open temporary output file & register file with detectors
+        # This should be redone now that Eilif has implemented the pythondatum datum type
+        pynest.sr('/tmpfile_%s (tmpfile_%s) (w) file def' % (self.label,self.label))
+        pynest.sr('%s << /output_stream tmpfile_%s >> SetStatus' % (pynest.getGID(self.spike_detector[0]),self.label))
+        spike_files.append('tmpfile_%s' % self.label)
+        self.n_rec = n_rec
+
+    def record_v(self,record_from=None,rng=None):
+        """
+        If record_from is not given, record the membrane potential for all cells in
+        the Population.
+        record_from can be an integer - the number of cells to record from, chosen
+        at random (in this case a random number generator can also be supplied)
+        - or a list containing the ids of the cells to record.
+        """
+        global v_files
+        
+        fixed_list = False
+        
+        if record_from:
+            if type(record_from) == types.ListType:
+                fixed_list = True
                 n_rec = len(record_from)
             elif type(record_from) == types.IntType:
@@ -468 +511 @@
         else:
             n_rec = self.size
-        pynest.resCons(self.spike_detector[0],n_rec)
-        
-        for neuron in numpy.reshape(self.cell,(self.cell.size,))[0:n_rec]: # should change this to pick randomly
-            pynest.connect(pynest.getAddress(neuron),self.spike_detector[0])
-
-        # Open temporary output file & register file with detectors
-        # This should be redone now that Eilif has implemented the pythondatum datum type
-        pynest.sr('/tmpfile_%s (tmpfile_%s) (w) file def' % (self.label,self.label))
-        pynest.sr('%s << /output_stream tmpfile_%s >> SetStatus' % (pynest.getGID(self.spike_detector[0]),self.label))
-        spike_files.append('tmpfile_%s' % self.label)
-        self.n_rec = n_rec
-
-    def record_v(self,record_from=None,rng=None):
-        """
-        If record_from is not given, record the membrane potential for all cells in
-        the Population.
-        record_from can be an integer - the number of cells to record from, chosen
-        at random (in this case a random number generator can also be supplied)
-        - or a list containing the ids of the cells to record.
-        """
-        global v_files
-        
-        if record_from:
-            if type(record_from) == types.ListType:
-                n_rec = len(record_from)
-            elif type(record_from) == types.IntType:
-                n_rec = record_from
-            else:
-                raise "record_from must be a list or an integer"
-        else:
-            n_rec = self.size
-            
-        for neuron in numpy.reshape(self.cell,(self.cell.size,))[0:n_rec]: # should change this to pick randomly
-            filename = 'tmpfile_%s_%d.v' % (self.label, neuron)
-            v_files.append(filename)
-            pynest.record_v(pynest.getAddress(neuron),filename)
-    
-    
-    def printSpikes(self,filename,gather=True):
+
+        if (fixed_list == True):
+            for neuron in record_from:
+                filename = 'tmpfile_%s_%d.v' % (self.label, neuron)
+                v_files.append([neuron, filename])
+                pynest.record_v(pynest.getAddress(neuron),filename)
+        else:
+            for neuron in numpy.reshape(self.cell,(self.cell.size,))[0:n_rec]: # should change this to pick randomly
+                filename = 'tmpfile_%s_%d.v' % (self.label, neuron)
+                v_files.append([neuron, filename])
+                pynest.record_v(pynest.getAddress(neuron),filename)
+    
+    
+    def printSpikes(self,filename,gather=True, compatible_output=True):
         """
         Prints spike times to file in the two-column format
@@ -520 +538 @@
             spike_files.remove(tempfilename)
         shutil.move(tempfilename,filename)
+        if (compatible_output):
+            # Here we postprocess the file to have effectively the
+            # desired format :
+            # First line: dimensions of the population
+            # Then spiketime cell_id-min(cell_id)
+            f = open(filename,'r',1)
+            g = open("temp",'w',1)
+            # Writing dimensions of the population:
+            g.write("# ")
+            for dimension in self.dim:
+                g.write("%d\t" %dimension)
+            g.write("\n")
+        
+            # Writing spiketimes, cell_id-min(cell_id)
+            padding = numpy.reshape(self.cell,self.cell.size)[0]
+            lines = f.readlines()
+            f.close()
+            for line in lines:
+                single_line = line.split("\t", 1)
+                neuron = int(single_line[0][1:len(single_line[0])]) - padding
+                spike_time = dt*float(single_line[1])
+                g.write("%g\t%d" %(spike_time, neuron))
+            #    for i in range(0,len(self.locate(neuron))):    
+            #           g.write("%d\t" %self.locate(neuron)[i])
+                g.write("\n")
+            g.close()
+            os.system("mv temp %s" %filename)
+        
 
     def meanSpikeCount(self,gather=True):
@@ -536 +582 @@
         """
         cells = numpy.reshape(self.cell,self.cell.size)
-        rvals = rand_distr.next(n=self.dim)
+        rvals = rand_distr.next(n=self.cell.size)
         for node, v_init in zip(cells,rvals):
             pynest.setDict([node],{'u': v_init})
     
-    def print_v(self,filename,gather=True):
+    def print_v(self,filename,gather=True, compatible_output=True):
         """
         Write membrane potential traces to file.
         """
         global v_files
-        for tempfile in v_files:
-            pynest.sr('%s close' % tempfile)
         #os.system("paste %s > %s" % (" ".join(v_files), filename))
-        f = open('temp','w')
+        result = open(filename,'w',1)
         dt = pynest.getNESTStatus()['resolution']
         n = int(pynest.getNESTStatus()['time']/dt)
-        f.write("# dt = %f\n# n = %d\n" % (dt,n))
-        f.close()
-        os.system("cat temp %s > %s" % (" ".join(v_files), filename))
-        for tempfile in v_files:
-            v_files.remove(tempfile)
-        #shutil.move(tempfile,filename)
+        result.write("# dt = %f\n# n = %d\n" % (dt,n))
+        if (compatible_output):
+            result.write("# ")
+            for dimension in self.dim:
+               result.write("%d\t" %dimension)
+            result.write("\n")
+            padding = numpy.reshape(self.cell,self.cell.size)[0]
+        for couples in v_files:
+            if couples[0] in self.cell:
+                pynest.sr('%s close' % couples[1])
+                if (compatible_output):
+                    # We add the cell number to the recorded potential:
+                    f = open(couples[1],'r',1)
+                    lines = f.readlines()
+                    input_tuples = []
+                    for line in lines:
+                        single_line = line.rstrip()
+                        neuron = couples[0]
+                        result.write("%s\t%d\t\n" %(single_line, neuron-padding))
+                    f.close()
+                    os.system("rm %s" %couples[1])
+                else:
+                    os.system("cat %s > %s" %(couples[1], filename))
+                    os.system("rm %s" %couples[1])
+        for couples in v_files:
+            if couples[0] in self.cell:
+                v_files.remove(couples)
+        
         
     

trunk/neuron2.py

@@ -899 +899 @@
                             'strdef fmt']
             if header:
-                hoc_commands += ['tmp = fileobj.printf("%s")' % header]   
+                hoc_commands += ['tmp = fileobj.printf("%s\\n")' % header]   
             if gather:
                 hoc_commands += ['objref gatheredvec']
+            padding = self.fullgidlist[0]
             for id in self.record_from[print_what]:
                 addr = self.locate(id)
-                hoc_commands += ['fmt = "%s\\t%s\\n"' % (num_format, "\\t".join([str(j) for j in addr]))]
+                #hoc_commands += ['fmt = "%s\\t%s\\n"' % (num_format, "\\t".join([str(j) for j in addr]))]
+                hoc_commands += ['fmt = "%s\\t%d\\n"' % (num_format, id-padding)]
                 if id in self.gidlist:
                     hoc_commands += ['tmp = %s.object(%d).%s.printf(fileobj,fmt)' % (self.label,self.gidlist.index(id),print_what)]
@@ -914 +916 @@
             hoc_execute(hoc_commands,"--- Population[%s].__print()__ ---" %self.label)
 
-    def printSpikes(self,filename,gather=True):
+    def printSpikes(self,filename,gather=True, compatible_output=True):
         """
         Prints spike times to file in the two-column format
@@ -926 +928 @@
         """
         hoc_comment("--- Population[%s].__printSpikes()__ ---" %self.label)
-        self.__print('spiketimes',filename,"%.2f",gather)
-
-    def print_v(self,filename,gather=True):
+        header = "# %d" %self.dim[0]
+        for dimension in list(self.dim)[1:]:
+                header = "%s\t%d" %(header,dimension)
+        self.__print('spiketimes',filename,"%.2f",gather, header)
+
+    def print_v(self,filename,gather=True, compatible_output=True):
         """
         Write membrane potential traces to file.
@@ -934 +939 @@
         tstop = HocToPy.get('tstop','float')
         header = "# dt = %f\\n# n = %d\\n" % (dt,int(tstop/dt))
+        header = "%s # %d" %(header,self.dim[0])
+        for dimension in list(self.dim)[1:]:
+                header = "%s\t%d" %(header,dimension)
         hoc_comment("--- Population[%s].__print_v()__ ---" %self.label)
         self.__print('vtrace',filename,"%.4g",gather,header)

trunk/test/nesttests.py

@@ -1 +1 @@
 """
 Unit tests for pyNN/nest.py.
-$Id: nesttests.py 78 2007-01-25 10:36:59Z apdavison $
+$Id: nesttests.py 146 2007-04-03 16:19:16Z Pierre $
 """
 
@@ -280 +280 @@
     """Tests of the record(), record_v(), printSpikes(), print_v() and
        meanSpikeCount() methods of the Population class."""
-    pass
-
-# ==============================================================================
-class PopulationOtherTest(unittest.TestCase): # to write later
-    """Tests of the randomInit() method of the Population class."""
-    pass
+    def setUp(self):
+        nest.setup()
+        nest.Population.nPop = 0
+        self.pop1 = nest.Population((3,3), nest.SpikeSourcePoisson,{'rate': 20})
+        self.pop2 = nest.Population((3,3), nest.IF_curr_alpha)
+
+    def testRecordAll(self):
+        """Population.record(): not a full test, just checking there are no Exceptions raised."""
+        self.pop1.record()
+        
+    def testRecordInt(self):
+        """Population.record(n): not a full test, just checking there are no Exceptions raised."""
+        # Partial record        
+        self.pop1.record(5)
+        
+    def testRecordWithRNG(self):
+        """Population.record(n,rng): not a full test, just checking there are no Exceptions raised."""
+        self.pop1.record(5,random.NumpyRNG())
+        
+    def testRecordList(self):
+        """Population.record(list): not a full test, just checking there are no Exceptions raised."""
+        # Selected list record
+        record_list = []
+        for i in range(0,2):
+            record_list.append(self.pop1[i,1])
+        self.pop1.record(record_list)   
+   
+    def testSpikeRecording(self):
+        # We test the mean spike count by checking if the rate of the poissonian sources are
+        # close to 20 Hz. Then we also test how the spikes are saved
+        self.pop1.record()
+        simtime = 1000
+        nest.run(simtime)
+        self.pop1.printSpikes("temp_nest.ras")
+        rate = self.pop1.meanSpikeCount()*1000/simtime
+        assert (20*0.8 < rate) and (rate < 20*1.2)
+        
+    def testPotentialRecording(self):
+        """Population.record_v() and Population.print_v(): not a full test, just checking 
+        # there are no Exceptions raised."""
+        rng = random.NumpyRNG(123)
+        v_reset  = -65.0
+        v_thresh = -50.0
+        uniformDistr = random.RandomDistribution(rng,'uniform',[v_reset,v_thresh])
+        self.pop2.randomInit(uniformDistr)
+        self.pop2.record_v([self.pop2[0,0], self.pop2[1,1]])
+        simtime = 10
+        nest.run(simtime)
+        self.pop2.print_v("temp_nest.v")
 
 # ==============================================================================

trunk/test/neuron2tests.py

@@ -330 +330 @@
     
     def setUp(self):
-        neuron.Population.nPop = 0
-        self.net = neuron.Population((3,3),neuron.IF_curr_alpha)
-        
+        self.pop1 = neuron.Population((3,3), neuron.SpikeSourcePoisson,{'rate': 20})
+        self.pop2 = neuron.Population((3,3), neuron.IF_curr_alpha)
+
     def testRecordAll(self):
         """Population.record(): not a full test, just checking there are no Exceptions raised."""
-        self.net.record()
+        self.pop1.record()
         
     def testRecordInt(self):
         """Population.record(n): not a full test, just checking there are no Exceptions raised."""
-        self.net.record(5)
-        
+        # Partial record        
+        self.pop1.record(5)
+        
     def testRecordWithRNG(self):
         """Population.record(n,rng): not a full test, just checking there are no Exceptions raised."""
-        self.net.record(5,random.NumpyRNG())
+        self.pop1.record(5,random.NumpyRNG())
         
     def testRecordList(self):
         """Population.record(list): not a full test, just checking there are no Exceptions raised."""
-        self.net.record([self.net[(2,2)],self.net[(1,2)],self.net[(0,0)]])
+        # Selected list record
+        record_list = []
+        for i in range(0,2):
+            record_list.append(self.pop1[i,1])
+        self.pop1.record(record_list)
+
+    def testSpikeRecording(self):
+        # We test the mean spike count by checking if the rate of the poissonian sources are
+        # close to 20 Hz. Then we also test how the spikes are saved
+        self.pop1.record()
+        simtime = 1000.0
+        neuron.run(simtime)
+        self.pop1.printSpikes("temp_neuron2.ras")
+        rate = self.pop1.meanSpikeCount()*1000/simtime
+        assert (20*0.8 < rate) and (rate < 20*1.2)
+
+    def testPotentialRecording(self):
+        """Population.record_v() and Population.print_v(): not a full test, just checking 
+        # there are no Exceptions raised."""
+        rng = NumpyRNG(123)
+        v_reset  = -65.0
+        v_thresh = -50.0
+        uniformDistr = RandomDistribution(rng,'uniform',[v_reset,v_thresh])
+        self.pop2.randomInit(uniformDistr)
+        self.pop2.record_v([self.pop2[0,0], self.pop2[1,1]])
+        simtime = 10.0
+        neuron.run(simtime)
+        self.pop2.print_v("temp_neuron2.v")
 
 # ==============================================================================