Changeset 54 for branches

Timestamp:

05/11/07 16:00:49 (5 years ago)

Author:

apdavison

Message:

Merged trunk changes r48:53 into pyNN-0.3 branch

Location:

branches/0.3

Files:

• common.py (modified) (3 diffs)
• facetsml.py (modified) (8 diffs)
• nest.py (modified) (16 diffs)
• neuron.py (modified) (8 diffs)
• oldneuron.py (modified) (6 diffs)
• pcsim.py (modified) (15 diffs)
• test/facetsmltest.py (copied) (copied from trunk/test/facetsmltest.py)
• test/pyNNPcsimLowLevelTest.py (modified) (3 diffs)
• test/pyNNPcsimPopulationTest.py (modified) (6 diffs)

branches/0.3/common.py

@@ -186 +186 @@
 # ==============================================================================
 
-def setup(timestep=0.1,min_delay=0.1,max_delay=0.1,debug=False):
-    """Should be called at the very beginning of a script."""
+def setup(timestep=0.1,min_delay=0.1,max_delay=0.1,debug=False,**extra_params):
+    """
+    Should be called at the very beginning of a script.
+    extra_params contains any keyword arguments that are required by a given
+    simulator but not by others.
+    """
     dt = timestep
     pass
@@ -365 +369 @@
     def printSpikes(self,filename,gather=True, compatible_output=True):
         """
-        Prints spike times to file in the two-column format
-        "spiketime cell_id" where cell_id is the index of the cell counting
-        along rows and down columns (and the extension of that for 3-D).
+        Writes spike times to file.
+        If compatible_output is True, the format is "spiketime cell_id",
+        where cell_id is the index of the cell counting along rows and down
+        columns (and the extension of that for 3-D).
         This allows easy plotting of a `raster' plot of spiketimes, with one
         line for each cell.
-        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
-        """
+        The timestep and number of data points per cell is written as a header,
+        indicated by a '#' at the beginning of the line.
+        
+        If compatible_output is False, the raw format produced by the simulator
+        is used. This may be faster, since it avoids any post-processing of the
+        spike files.
+        
+        If gather is True, the file will only be created on the master node,
+        otherwise, a file will be written on each node.
+        """        
         pass
     
@@ -381 +390 @@
         """
         Write membrane potential traces to file.
+        If compatible_output is True, the format is "v cell_id",
+        where cell_id is the index of the cell counting along rows and down
+        columns (and the extension of that for 3-D).
+        This allows easy plotting of a `raster' plot of spiketimes, with one
+        line for each cell.
+        The timestep and number of data points per cell is written as a header,
+        indicated by a '#' at the beginning of the line.
+        
+        If compatible_output is False, the raw format produced by the simulator
+        is used. This may be faster, since it avoids any post-processing of the
+        voltage files.
         """
         pass

branches/0.3/facetsml.py

@@ -38 +38 @@
     #if the <neuroml> markup is not yet created
     if(neuromlNodes.length == 0):
-        #seems createElementNS doesn't create the xmlns attribute
+        #neuroml has no prefix, namespace http://morphml.org/neuroml/schema is the default one
         neuromlNode = xmldoc.createElementNS('http://morphml.org/neuroml/schema','neuroml')
         xmldoc.appendChild(neuromlNode)
@@ -44 +44 @@
         neuromlNode = neuromlNodes[0]
     parentElementNodes = neuromlNode.getElementsByTagNameNS(parentElementNS,parentElementName)
+    #if the <parentElementName> markup is not yet created
     if(parentElementNodes.length == 0):
+        #if no prefix has been defined and the namespace of the new parent element is not the default
+        # namespace, a new namespace is associated to null prefix, which is not good 
         if(prefix == ''):
             parentElementNode = xmldoc.createElementNS(parentElementNS,parentElementName)
@@ -53 +56 @@
         parentElementNode = parentElementNodes[0]
     return parentElementNode
+
+def writeDocument(url):
+    """
+    write the xmldoc created to a file specified by the url
+    """
+    file = open(url,'w')
+    PrettyPrint(xmldoc, file)
+    file.close()
+    
 
 
@@ -306 +318 @@
     </net:populations>
     
-    
-    
         """
         
@@ -317 +327 @@
     
     
-    populationsNode = initDocument('http://morphml.org/networkml/schema','populations','net')
-    
-    populationNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','net:population')
-    populationNode.setAttribute('name',label)
-    populationsNode.appendChild(populationNode)
-    
-    cell_typeNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','net:cell_type')
-    #coming from neuron.py
-    if isinstance(cellclass, type):
+        populationsNode = initDocument('http://morphml.org/networkml/schema','populations','net')
+    
+        populationNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','net:population')
+        populationNode.setAttribute('name',label)
+        populationsNode.appendChild(populationNode)
+    
+        cell_typeNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','net:cell_type')
+        #coming from neuron.py
+        if isinstance(cellclass, type):
             self.celltype = cellclass(cellparams)
             self.cellparams = self.celltype.parameters
@@ -332 +342 @@
             hoc_name = cellclass
         #end of coming
-    
-    cell_typeTextNode = xmldoc.createTextNode(hoc_name)
-    cell_typeNode.appendChild(cell_typeTextNode)
-    populationNode.appendChild(cell_typeNode)
-    """
-    the minimal neuroml to add there is :
-       <net:pop_location reference="aReference">
-                <net:grid_arrangement>
-                    <net:rectangular_location name="aName">
-                        <meta:corner x="0" y="0" z="0"/>
-                        <meta:size depth="10" height="100" width="100"/>
-                    </net:rectangular_location>
-                    <net:spacing x="10" y="10" z="10"/>
-                </net:grid_arrangement>
-                
-            </net:pop_location>
-    """
-    pop_locationNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','net:pop_location')
-    pop_locationNode.setAttribute('reference','aReference')
-    populationNode.appendChild(pop_locationNode)
-    
-    grid_arrangementNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','net:grid_arrangement')
-    pop_locationNode.appendChild(grid_arrangementNode)
-    
-    rectangular_locationNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','net:rectangular_location')
-    rectangular_locationNode.setAttribute('name','aName')
-    grid_arrangementNode.appendChild(rectangular_locationNode)
-    
-    cornerNode = xmldoc.createElementNS('http://morphml.org/metadata/schema','meta:corner')
-    cornerNode.setAttribute('x','0')
-    cornerNode.setAttribute('y','0')
-    cornerNode.setAttribute('z','0')
-    rectangular_locationNode.appendChild(cornerNode)
-    
-    sizeNode = xmldoc.createElementNS('http://morphml.org/metadata/schema','meta:size')
-    #neuroml is always in 3D adding 0 for non covered dimensions
-    sizeNode.setAttribute('depth',str(10*dims[0]))
-    sizeNode.setAttribute('height',str(10*dims[1]))
-    if(dims.__len__() > 2):
-        sizeNode.setAttribute('width',str(10*dims[2]))
-    else:
-        sizeNode.setAttribute('width','0')
-    rectangular_locationNode.appendChild(sizeNode)
-    
-    spacingNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','net:spacing')
-    spacingNode.setAttribute('x','10')
-    spacingNode.setAttribute('y','10')
-    spacingNode.setAttribute('z','10')
-    grid_arrangementNode.appendChild(spacingNode)
-    
-    
-    #cellparams would be defined in a <cell> markup which would define precisely the neuron model
-    
-    
+        
+        cell_typeTextNode = xmldoc.createTextNode(hoc_name)
+        cell_typeNode.appendChild(cell_typeTextNode)
+        populationNode.appendChild(cell_typeNode)
+        """
+        the minimal neuroml to add there is :
+        <net:pop_location reference="aReference">
+            <net:grid_arrangement>
+                <net:rectangular_location name="aName">
+                    <meta:corner x="0" y="0" z="0"/>
+                    <meta:size depth="10" height="100" width="100"/>
+                </net:rectangular_location>
+                <net:spacing x="10" y="10" z="10"/>
+            </net:grid_arrangement>
+        </net:pop_location>
+        """
+        pop_locationNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','net:pop_location')
+        pop_locationNode.setAttribute('reference','aReference')
+        populationNode.appendChild(pop_locationNode)
+        
+        grid_arrangementNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','net:grid_arrangement')
+        pop_locationNode.appendChild(grid_arrangementNode)
+        
+        rectangular_locationNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','net:rectangular_location')
+        rectangular_locationNode.setAttribute('name','aName')
+        grid_arrangementNode.appendChild(rectangular_locationNode)
+        
+        cornerNode = xmldoc.createElementNS('http://morphml.org/metadata/schema','meta:corner')
+        cornerNode.setAttribute('x','0')
+        cornerNode.setAttribute('y','0')
+        cornerNode.setAttribute('z','0')
+        rectangular_locationNode.appendChild(cornerNode)
+        
+        sizeNode = xmldoc.createElementNS('http://morphml.org/metadata/schema','meta:size')
+        #neuroml is always in 3D, adding 0 for non covered dimensions
+        sizeNode.setAttribute('depth',str(10*dims[0]))
+        sizeNode.setAttribute('height',str(10*dims[1]))
+        if(dims.__len__() > 2):
+            sizeNode.setAttribute('width',str(10*dims[2]))
+        else:
+            sizeNode.setAttribute('width','0')
+        rectangular_locationNode.appendChild(sizeNode)
+        
+        spacingNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','net:spacing')
+        spacingNode.setAttribute('x','10')
+        spacingNode.setAttribute('y','10')
+        spacingNode.setAttribute('z','10')
+        grid_arrangementNode.appendChild(spacingNode)
+        
+        
+        #cellparams would be defined in a <cell> markup which would define precisely the neuron model
+        
+        
         #raise "Not yet implemented."
         
         
         Population.nPop += 1
-    PrettyPrint(xmldoc)
+        PrettyPrint(xmldoc)
     
         
@@ -515 +524 @@
         than within methodParameters, particularly since some methods also use
         random numbers to give variability in the number of connections per cell.
+        
+        
+        
+        
+        example of NeuroML for projections :
+        <projections units="Physiological Units" xmlns="http://morphml.org/networkml/schema">
+           <projection name="NetworkConnection">
+               <source>CellGroupA</source>
+               <target>CellGroupB</target>
+               <synapse_props>
+                   <synapse_type>DoubExpSynA</synapse_type>
+                   <default_values internal_delay="5" weight="1" threshold="-20"/>
+               </synapse_props>
+               <connections>
+                   <connection id="0">
+                       <pre cell_id="0" segment_id = "0" fraction_along="0.5"/>
+                       <post cell_id="1" segment_id = "1"/>
+                   </connection>
+                   <connection id="1">
+                       <pre cell_id="2" segment_id = "0"/>
+                       <post cell_id="1" segment_id = "0"/>
+                   </connection>
+                   <connection id="1">
+                       <pre cell_id="3" segment_id = "0"/>
+                       <post cell_id="1" segment_id = "1"/>
+                       <properties internal_delay="10" weight="0.5"/>                    <!-- adjusted value -->
+                   </connection>
+               </connections>
+           </projection>
+           <projection name="2">
+               <source>CellGroupA</source>
+               <target>CellGroupB</target>
+               <synapse_props>
+                   <synapse_type>DoubExpSynA</synapse_type>
+                   <default_values/>
+               </synapse_props>
+               <connectivity_pattern>
+                   <all_to_all/>
+               </connectivity_pattern>
+           </projection>
+       </projections>
         """
         common.Projection.__init__(self,presynaptic_population,postsynaptic_population,method,methodParameters,source,target,label,rng)
@@ -520 +570 @@
         self._targets = []
         self._sources = []
-        connection_method = getattr(self,'_%s' % method)
-        self.nconn = connection_method(methodParameters)
+        #connection_method = getattr(self,'_%s' % method)
+        #self.nconn = connection_method(methodParameters)
+        
+        
+        
+        
+        
+        
+        projectionsNode = initDocument('http://morphml.org/networkml/schema','projections')
+        projectionsNode.setAttribute('units','Physiological Units')
+        
+        projectionNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','projection')
+        projectionNode.setAttribute('name',label)
+        projectionsNode.appendChild(projectionNode)
+        
+        sourceNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','source')
+        
+        #evaluating presynaptic_populationName
+        if isinstance(presynaptic_population, Population):
+            presynaptic_populationName = presynaptic_population.label
+        elif isinstance(presynaptic_population, str):
+            presynaptic_populationName = presynaptic_population
+        
+        
+        sourceTextNode = xmldoc.createTextNode(presynaptic_populationName)
+        sourceNode.appendChild(sourceTextNode)
+        projectionNode.appendChild(sourceNode)
+        
+        targetNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','target')
+        
+        #evaluating postsynaptic_populationName
+        if isinstance(postsynaptic_population, Population):
+            postsynaptic_populationName = postsynaptic_population.label
+        elif isinstance(postsynaptic_population, str):
+            postsynaptic_populationName = postsynaptic_population
+        
+        
+        targetTextNode = xmldoc.createTextNode(postsynaptic_populationName)
+        targetNode.appendChild(targetTextNode)
+        projectionNode.appendChild(targetNode)
+        
+        synapse_propsNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','synapse_props')
+        
+        #I don't know how to deal with that
+        projectionNode.appendChild(synapse_propsNode)
+        
+        synapse_typeNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','synapse_type')
+        #false values to make it valid
+        synapse_typeTextNode = xmldoc.createTextNode("DoubExpSynA")
+        synapse_typeNode.appendChild(synapse_typeTextNode)
+        synapse_propsNode.appendChild(synapse_typeNode)
+        
+        default_valuesNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','default_values')
+        synapse_propsNode.appendChild(default_valuesNode)
+        
+        """
+        example of connectivity_pattern to add, must be generic
+            
+            <connectivity_pattern>
+                <fixed_probability probability="0.5"></fixed_probability>
+            </connectivity_pattern>
+        
+        
+        """
+        
+        connectivity_patternNode = xmldoc.createElementNS('http://morphml.org/networkml/schema','connectivity_pattern')
+        projectionNode.appendChild(connectivity_patternNode)
+        
+        methodNode = xmldoc.createElementNS('http://morphml.org/networkml/schema',method)
+        for key in methodParameters:
+            methodNode.setAttribute(key,methodParameters[key])
+        
+        connectivity_patternNode.appendChild(methodNode)
+        
+        
+        PrettyPrint(xmldoc)
+        
+        
+        
         
     # --- Connection methods ---------------------------------------------------

branches/0.3/nest.py

@@ -109 +109 @@
             'v_thresh'  : ('Theta'       , "parameters['v_thresh']"),
             'i_offset'  : ('I0'          , "parameters['i_offset']*1000.0"), # I0 is in pA, i_offset in nA
-            'e_rev_E'   : ('V_reversal_E', "parameters['e_rev_E']"),
+            'e_rev_E'   : ('V_reversal_E', "parameters['e_rev_E']"),
             'e_rev_I'   : ('V_reversal_I', "parameters['e_rev_I']"),
             'v_init'    : ('u'           , "parameters['v_init']"),
@@ -154 +154 @@
 # ==============================================================================
 
-def setup(timestep=0.1,min_delay=0.1,max_delay=0.1,debug=False):
-    """Should be called at the very beginning of a script."""
+def setup(timestep=0.1,min_delay=0.1,max_delay=0.1,debug=False,**extra_params):
+    """
+    Should be called at the very beginning of a script.
+    extra_params contains any keyword arguments that are required by a given
+    simulator but not by others.
+    """
     if min_delay > max_delay:
         raise Exception("min_delay has to be less than or equal to max_delay.")
@@ -244 +248 @@
     both be individual cells or lists of cells, in which case all possible
     connections are made with probability p, using either the random number
-    generator supplied, or the default rng otherwise."""
+    generator supplied, or the default rng otherwise.
+    Weights should be in nA or uS."""
     global dt
     if weight is None:
@@ -332 +337 @@
     pynest.sr('%s close' %tempfilename) 
     if (compatible_output):
-        # Here we postprocess the file to have effectively the
+        # Here we postprocess the file to have effectively the
         # desired format :
-        # First line: # dimensions of the population
-        # Then spiketime (in ms) cell_id-min(cell_id)
+        # First line: # dimensions of the population
+        # Then spiketime (in ms) cell_id-min(cell_id)
         result = open(filename,'w',100)
         g = open(tempfilename,'r',100)
@@ -344 +349 @@
             neuron = int(single_line[0][1:len(single_line[0])])
             spike_time = dt*float(single_line[1])
-            result.write("%g\t%d\n" %(spike_time, neuron))
+            result.write("%g\t%d\n" %(spike_time, neuron))
         result.close()
     else:
@@ -364 +369 @@
     if (compatible_output):
         f = open(tempfilename.replace('/','_'),'r',100)
-        lines = f.readlines()
+        lines = f.readlines()
         f.close()
 
-        # Here we postprocess the file to have effectively the
+        # Here we postprocess the file to have effectively the
         # desired format :
-        # First line: dimensions of the population
-        # Then spiketime cell_id-min(cell_id)
+        # First line: dimensions of the population
+        # Then spiketime cell_id-min(cell_id)
         for line in lines:
             line = line.rstrip()
@@ -376 +381 @@
             if (len(single_line) > 1) and (single_line[1] != '-'):
                neuron = int(single_line[0])
-               result.write("%s\t%d\n" %(single_line[1], neuron))
+               result.write("%s\t%d\n" %(single_line[1], neuron))
     else:
         f = open(tempfilename.replace('/','_'),'r',100)
-        lines = f.readlines()
+        lines = f.readlines()
         f.close()
         for line in lines:
@@ -620 +625 @@
                                             'withpath':True}) # record which neuron spiked
         
-        fixed_list = False
+        fixed_list = False
 
         if record_from:
             if type(record_from) == types.ListType:
-                fixed_list = True
-                n_rec = len(record_from)
+                fixed_list = True
+                n_rec = len(record_from)
             elif type(record_from) == types.IntType:
                 n_rec = record_from
@@ -634 +639 @@
         pynest.resCons(self.spike_detector[0],n_rec)
 
-        if (fixed_list == True):
-            for neuron in record_from:
+        if (fixed_list == True):
+            for neuron in record_from:
                 pynest.connect(pynest.getAddress(neuron),self.spike_detector[0])
         else:
-            for neuron in numpy.random.permutation(numpy.reshape(self.cell,(self.cell.size,)))[0:n_rec]:
+            for neuron in numpy.random.permutation(numpy.reshape(self.cell,(self.cell.size,)))[0:n_rec]:
                 pynest.connect(pynest.getAddress(neuron),self.spike_detector[0])
-                
-        # Open temporary output file & register file with detectors
+                
+        # 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)) # old
@@ -658 +663 @@
         """
         global hl_v_files
-        
-        fixed_list = False
-        
-        fixed_list = False
+        
+        fixed_list = False
+        
+        fixed_list = False
         if record_from:
             if type(record_from) == types.ListType:
-                fixed_list = True
+                fixed_list = True
                 n_rec = len(record_from)
             elif type(record_from) == types.IntType:
@@ -673 +678 @@
             n_rec = self.size
 
-        tmp_list = []
+        tmp_list = []
         filename    = '%s.v' % self.label
         record_file = tempdir+'/'+filename
-        if (fixed_list == True):
-            tmp_list = [pynest.getAddress(neuron) for neuron in record_from]
-        else:
-            for neuron in numpy.random.permutation(numpy.reshape(self.cell,(self.cell.size,)))[0:n_rec]:
-                tmp_list.append(pynest.getAddress(neuron))
+        if (fixed_list == True):
+            tmp_list = [pynest.getAddress(neuron) for neuron in record_from]
+        else:
+            for neuron in numpy.random.permutation(numpy.reshape(self.cell,(self.cell.size,)))[0:n_rec]:
+                tmp_list.append(pynest.getAddress(neuron))
         hl_v_files.append(filename)
         pynest.record_v(tmp_list, record_file.replace('/','_'))
@@ -687 +692 @@
     def printSpikes(self,filename,gather=True, compatible_output=True):
         """
-        Prints spike times to file in the two-column format
-        On the first line the dimensions of the population are saved as
-        # x y z
-        And then, we writes "spiketime cell_id" where cell_id is the relative gid
-        of the cell (starting from 0 to the number of cells in the population,
-        because we have substract the starting gid of the population)
+        Writes spike times to file.
+        If compatible_output is True, the format is "spiketime cell_id",
+        where cell_id is the index of the cell counting along rows and down
+        columns (and the extension of that for 3-D).
         This allows easy plotting of a `raster' plot of spiketimes, with one
         line for each cell.
-        This "compatible output" is the same than pyNN.neuron, and imply a 
-        small postprocesing of the files produced by nest. To avoid that, the option
-        compatible_output can be set to False and then the results are the results given
-        by nest, i.e:
-        spikes_time (in dt unit) and gid (global gid)
-
-        TODO : return a numpy array?
-
-        """
+        The timestep and number of data points per cell is written as a header,
+        indicated by a '#' at the beginning of the line.
+        
+        If compatible_output is False, the raw format produced by the simulator
+        is used. This may be faster, since it avoids any post-processing of the
+        spike files.
+        
+        If gather is True, the file will only be created on the master node,
+        otherwise, a file will be written on each node.
+        """        
         global hl_spike_files
         tempfilename = '%s.spikes' % self.label
@@ -710 +714 @@
             pynest.sr('%s close' % tempfilename)
             hl_spike_files.remove(tempfilename)
-        if (compatible_output):
-            # Here we postprocess the file to have effectively the
-            # desired format :
-            # First line: # dimensions of the population
-            # Then spiketime (in ms) cell_id-min(cell_id)
+        if (compatible_output):
+            # Here we postprocess the file to have effectively the
+            # desired format: spiketime (in ms) cell_id-min(cell_id)
             result = open(filename,'w',1)
             g = open("%s/%s" %(tempdir, tempfilename),'r',1)
-            # Writing dimensions of the population:
-            result.write("# ")
-            for dimension in self.dim:
-                result.write("%d\t" %dimension)
-            result.write("\n")
-        
-            # Writing spiketimes, cell_id-min(cell_id)
+            # Writing dimensions of the population:
+            result.write("# " + "\t".join([str(d) for d in self.dim]) + "\n")
+        
+            # Writing spiketimes, cell_id-min(cell_id)
             padding = numpy.reshape(self.cell,self.cell.size)[0]
             lines = g.readlines()
@@ -731 +730 @@
                 neuron = int(single_line[0][1:len(single_line[0])]) - padding
                 spike_time = dt*float(single_line[1])
-                result.write("%g\t%d\n" %(spike_time, neuron))
+                result.write("%g\t%d\n" %(spike_time, neuron))
             result.close()
         else:
             shutil.move(tempdir+'/'+tempfilename,filename)
-        
+        
 
     def meanSpikeCount(self,gather=True):
@@ -760 +759 @@
         """
         Write membrane potential traces to file.
-        On the first lines informations ar saved as
-        # dt = ... (dt in ms)
-        # n = ...  (number of recorded values)
-        # x y z (dimensions of the population)
-        
-        And then, we writes "Vm cell_id" where cell_id is the relative gid
-        of the cell (starting from 0 to the number of cells in the population,
-        because we have substract the starting gid of the population)
-        
-        This "compatible output" is the same than pyNN.neuron, and imply a 
-        small postprocesing of the files produced by nest. To avoid that, the option
-        compatible_output can be set to False and then the results are the results given
-        by nest, i.e:
-        # dt = ...
-        # n = ...
-        Vm and gid (global gid)
-        
+        If compatible_output is True, the format is "v cell_id",
+        where cell_id is the index of the cell counting along rows and down
+        columns (and the extension of that for 3-D).
+        This allows easy plotting of a `raster' plot of spiketimes, with one
+        line for each cell.
+        The timestep and number of data points per cell is written as a header,
+        indicated by a '#' at the beginning of the line.
+        
+        If compatible_output is False, the raw format produced by the simulator
+        is used. This may be faster, since it avoids any post-processing of the
+        voltage files.
         """
         global hl_v_files
-        
-        tempfilename = tempdir+'/'+'%s.v' % self.label
+        
+        tempfilename = tempdir+'/'+'%s.v' % self.label
         if hl_v_files.__contains__(tempfilename):
             pynest.sr('%s close' % tempfilename.replace('/','_'))
             hl_v_files.remove(tempfilename)
-                
-        result = open(filename,'w',1)
+                
+        result = open(filename,'w',1)
         dt = pynest.getNESTStatus()['resolution']
         n = int(pynest.getNESTStatus()['time']/dt)
         result.write("# dt = %f\n# n = %d\n" % (dt,n))
 
-        if (compatible_output):
-            f = open(tempfilename.replace('/','_'),'r',1)
-            lines = f.readlines()
+        if (compatible_output):
+            f = open(tempfilename.replace('/','_'),'r',1)
+            lines = f.readlines()
             f.close()
-            result.write("# ")
-            for dimension in self.dim:
-               result.write("%d\t" %dimension)
-            result.write("\n")
+            result.write("# " + "\t".join([str(d) for d in self.dim]) + "\n")
             padding = numpy.reshape(self.cell,self.cell.size)[0]
 
-            # Here we postprocess the file to have effectively the
+            # Here we postprocess the file to have effectively the
             # desired format :
-            # First line: dimensions of the population
-            # Then spiketime cell_id-min(cell_id)
+            # First line: dimensions of the population
+            # Then spiketime cell_id-min(cell_id)
             for line in lines:
                 line = line.rstrip()
@@ -809 +799 @@
                 if (len(single_line) > 1) and (single_line[1] != '-'):
                     neuron = int(single_line[0]) - padding
-                    result.write("%s\t%d\n" %(single_line[1], neuron))
-        else:
+                    result.write("%s\t%d\n" %(single_line[1], neuron))
+        else:
             f = open(tempfilename.replace('/','_'),'r',1)
-            lines = f.readlines()
+            lines = f.readlines()
             f.close()
             for line in lines:

branches/0.3/neuron.py

@@ -62 +62 @@
     # creation of networks
     def setHocName(self, name):
-        self._hocname = name
+        self._hocname = name
 
     def getHocName(self):
-        return self._hocname
+        return self._hocname
     
 
@@ -208 +208 @@
         errorstr = '"raise HocError(\'caused by HocToPy.get(%s,return_type=\\"%s\\")\')"' % (name,return_type)
         hoc_commands = ['success = sprint(cmd,"HocToPy.hocvar = %s",%s)' % (HocToPy.fmt_dict[return_type],name),
-                        'if (success) { nrnpython(cmd) } else { nrnpython(%s) }' % errorstr ]
+                        'if (success) { nrnpython(cmd) } else { nrnpython(%s) }' % errorstr ]
         hoc_execute(hoc_commands)
         return HocToPy.hocvar
@@ -343 +343 @@
 # ==============================================================================
 
-def setup(timestep=0.1,min_delay=0.1,max_delay=0.1,debug=False):
-    """Should be called at the very beginning of a script."""
+def setup(timestep=0.1,min_delay=0.1,max_delay=0.1,debug=False,**extra_params):
+    """
+    Should be called at the very beginning of a script.
+    extra_params contains any keyword arguments that are required by a given
+    simulator but not by others.
+    """
     global dt, nhost, myid, _min_delay, logger
     dt = timestep
@@ -486 +490 @@
     both be individual cells or lists of cells, in which case all possible
     connections are made with probability p, using either the random number
-    generator supplied, or the default rng otherwise."""
+    generator supplied, or the default rng otherwise.
+    Weights should be in nA or uS."""
     global ncid, gid, gidlist, _min_delay
     if type(source) != types.ListType:
@@ -960 +965 @@
             if gather:
                 hoc_commands += ['objref gatheredvec']
-            padding = self.fullgidlist[0]
+            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%d\\n"' % (num_format, id-padding)]
+                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)]
@@ -976 +981 @@
     def printSpikes(self,filename,gather=True, compatible_output=True):
         """
-        Prints spike times to file in the two-column format
-        "spiketime cell_id" where cell_id is the index of the cell counting
-        along rows and down columns (and the extension of that for 3-D).
+        Writes spike times to file.
+        If compatible_output is True, the format is "spiketime cell_id",
+        where cell_id is the index of the cell counting along rows and down
+        columns (and the extension of that for 3-D).
         This allows easy plotting of a `raster' plot of spiketimes, with one
-        line for each cell. This method requires that the cell class records
-        spikes in a vector spiketimes.
+        line for each cell.
+        The timestep and number of data points per cell is written as a header,
+        indicated by a '#' at the beginning of the line.
+        
+        If compatible_output is False, the raw format produced by the simulator
+        is used. This may be faster, since it avoids any post-processing of the
+        spike files.
+        
         If gather is True, the file will only be created on the master node,
         otherwise, a file will be written on each node.
-        """
+        """        
         hoc_comment("--- Population[%s].__printSpikes()__ ---" %self.label)
-        header = "# %d" %self.dim[0]
-        for dimension in list(self.dim)[1:]:
-                header = "%s\t%d" %(header,dimension)
+        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)
 
@@ -994 +1006 @@
         """
         Write membrane potential traces to file.
+        If compatible_output is True, the format is "v cell_id",
+        where cell_id is the index of the cell counting along rows and down
+        columns (and the extension of that for 3-D).
+        This allows easy plotting of a `raster' plot of spiketimes, with one
+        line for each cell.
+        The timestep and number of data points per cell is written as a header,
+        indicated by a '#' at the beginning of the line.
+        
+        If compatible_output is False, the raw format produced by the simulator
+        is used. This may be faster, since it avoids any post-processing of the
+        voltage files.
         """
         tstop = HocToPy.get('tstop','float')
@@ -999 +1022 @@
         header = "%s# %d" %(header,self.dim[0])
         for dimension in list(self.dim)[1:]:
-                header = "%s\t%d" %(header,dimension)
+                header = "%s\t%d" %(header,dimension)
         hoc_comment("--- Population[%s].__print_v()__ ---" %self.label)
         self.__print('vtrace',filename,"%.4g",gather,header)

branches/0.3/oldneuron.py

@@ -335 +335 @@
 # ==============================================================================
 
-def setup(timestep=0.1,min_delay=0.1,max_delay=0.1,debug=False):
-    """Should be called at the very beginning of a script."""
+def setup(timestep=0.1,min_delay=0.1,max_delay=0.1,debug=False,**extra_params):
+    """
+    Should be called at the very beginning of a script.
+    extra_params contains any keyword arguments that are required by a given
+    simulator but not by others.
+    """
     global logfile, dt, _min_delay
     dt = timestep
@@ -355 +359 @@
     return 0
 
-def end():
+def end(compatible_output=True):
     """Do any necessary cleaning up before exiting."""
     global logfile, vfilelist, spikefilelist
@@ -428 +432 @@
     both be individual cells or lists of cells, in which case all possible
     connections are made with probability p, using either the random number
-    generator supplied, or the default rng otherwise."""
+    generator supplied, or the default rng otherwise.
+    Weights should be in nA or uS."""
     global hoc_netcons, _min_delay
     if type(source) != types.ListType:
@@ -741 +746 @@
         self.__record('_v',record_from,rng)
         
-    def printSpikes(self,filename,gather=True):
-        """
-        Prints spike times to file in the two-column format
-        "spiketime cell_id" where cell_id is the index of the cell counting
-        along rows and down columns (and the extension of that for 3-D).
+    def printSpikes(self,filename,gather=True,compatible_output=True):
+        """
+        Writes spike times to file.
+        If compatible_output is True, the format is "spiketime cell_id",
+        where cell_id is the index of the cell counting along rows and down
+        columns (and the extension of that for 3-D).
         This allows easy plotting of a `raster' plot of spiketimes, with one
-        line for each cell. This method requires that the cell class records
-        spikes in a vector spiketimes.
-        """
+        line for each cell.
+        The timestep and number of data points per cell is written as a header,
+        indicated by a '#' at the beginning of the line.
+        
+        If compatible_output is False, the raw format produced by the simulator
+        is used. This may be faster, since it avoids any post-processing of the
+        spike files.
+        
+        If gather is True, the file will only be created on the master node,
+        otherwise, a file will be written on each node.
+        """
+        # Note that 'gather' has no effect, since this module is not
+        # parallelised.
         hoc_commands = ['objref spikefile',
                         'spikefile = new File()',
@@ -776 +792 @@
         self._tcall('memb_init',rvals)
         
-    def print_v(self,filename,gather=True):
+    def print_v(self,filename,gather=True,compatible_output=True):
         """
         Write membrane potential traces to file.
+        If compatible_output is True, the format is "v cell_id",
+        where cell_id is the index of the cell counting along rows and down
+        columns (and the extension of that for 3-D).
+        This allows easy plotting of a `raster' plot of spiketimes, with one
+        line for each cell.
+        The timestep and number of data points per cell is written as a header,
+        indicated by a '#' at the beginning of the line.
+        
+        If compatible_output is False, the raw format produced by the simulator
+        is used. This may be faster, since it avoids any post-processing of the
+        voltage files.
         """
         hoc_commands = ['objref vfile',
@@ -1160 +1187 @@
     
 # ==============================================================================
-    

branches/0.3/pcsim.py

@@ -19 +19 @@
 import numpy
 from pypcsim import *
-from tables import *
+try:
+    import tables
+except ImportError:
+    pass
 import exceptions
 from datetime import datetime
@@ -112 +115 @@
             if (src_id.node == pcsim_globals.net.mpi_rank()):                
                 self.recordings += [ (i, rec, src) ]
-            
-        
-                
+                            
     def saveSpikesH5(self, filename = None):
         if filename:
@@ -120 +121 @@
         if (pcsim_globals.net.mpi_rank() != 0):
             self.filename += ".node." + net.mpi_rank()
-        h5file = openFile(self.filename, mode = "w", title = "spike recordings")
+        try:
+            h5file = tables.openFile(self.filename, mode = "w", title = "spike recordings")
+        except NameError:
+            raise Exception("Use of this function requires PyTables.")
         for rec_info in self.recordings:
             spikes = array([rec_ids[1]] + pcsim_globals.net.object(rec_ids[0]).getSpikeTimes())
@@ -127 +131 @@
         h5file.close()
         
-    def saveSpikesText(self, filename = None):
+    def saveSpikesText(self, filename = None, compatible_output=True):
         if filename:
             self.filename = filename
@@ -133 +137 @@
             self.filename += ".node." + net.mpi_rank()
         f = file(self.filename, "w")
-        all_spikes = []        
-        for i, rec, src in self.recordings:            
-            spikes =  pcsim_globals.net.object(rec).getSpikeTimes()
-            all_spikes += zip( [ i for k in xrange(len(spikes)) ], spikes)
+        all_spikes = []
+        if compatible_output:
+            for i, rec, src in self.recordings:            
+                spikes =  1000.0*numpy.array(pcsim_globals.net.object(rec).getSpikeTimes())
+                all_spikes += zip(spikes, [ i for k in xrange(len(spikes)) ])
+        else:
+            for i, rec, src in self.recordings:            
+                spikes =  pcsim_globals.net.object(rec).getSpikeTimes()
+                all_spikes += zip( [ i for k in xrange(len(spikes)) ], spikes)
         all_spikes = sorted(all_spikes, key=operator.itemgetter(1))
         for spike in all_spikes:
@@ -159 +168 @@
         self.recordings = []
         self.record(sources, src_indices)
-        
-                
+                        
     def record(self, sources, src_indices = None):
         """
@@ -183 +191 @@
         if (pcsim_globals.net.mpi_rank() != 0):
             self.filename += ".node." + net.mpi_rank()
-        h5file = openFile(filename, mode = "w", title = self.fielname + " recordings")
+        try:
+            h5file = tables.openFile(filename, mode = "w", title = self.filename + " recordings")
+        except NameError:
+            raise Exception("Use of this function requires PyTables.")
         for i, rec, src in self.recordings:
             analog_values = array([i] + pcsim_globals.net.object(rec).getRecordedValues())
@@ -393 +404 @@
 # ==============================================================================
 
-def setup(timestep=0.1, min_delay=0.1, max_delay=10, construct_rng_seed = None, simulation_rng_seed = None, debug=False):
-    """Should be called at the very beginning of a script."""
+def setup(timestep=0.1, min_delay=0.1, max_delay=0.1, debug=False, **extra_params):
+    """
+    Should be called at the very beginning of a script.
+    extra_params contains any keyword arguments that are required by a given
+    simulator but not by others.
+    For pcsim, the possible arguments are 'construct_rng_seed' and 'simulation_rng_seed'.
+    """
     global pcsim_globals, dt
     pcsim_globals.dt = timestep
@@ -401 +417 @@
     pcsim_globals.maxDelay = max_delay
     if pcsim_globals.constructRNGSeed is None:
-        if construct_rng_seed is None:
+        if extra_params.has_key('construct_rng_seed'):
+            construct_rng_seed = extra_params['construct_rng_seed']
+        else:
             construct_rng_seed = datetime.today().microsecond
         pcsim_globals.constructRNGSeed = construct_rng_seed
     if pcsim_globals.simulationRNGSeed is None:
-        if simulation_rng_seed is None:
+        if extra_params.has_key('simulation_rng_seed'):
+            simulation_rng_seed = extra_params['simulation_rng_seed']
+        else:
             simulation_rng_seed = datetime.today().microsecond
         pcsim_globals.simulationRNGSeed = simulation_rng_seed    
@@ -420 +440 @@
         rec.saveValuesText(compatible_output=compatible_output)
     for filename, rec in pcsim_globals.spikes_multi_rec.items():
-        rec.saveSpikesText()    
+        rec.saveSpikesText(compatible_output=compatible_output)    
     pcsim_globals.vm_multi_rec = {}     
     pcsim_globals.spikes_multi_rec = {}
@@ -493 +513 @@
     both be individual cells or lists of cells, in which case all possible
     connections are made with probability p, using either the random number
-    generator supplied, or the default rng otherwise."""
+    generator supplied, or the default rng otherwise.
+    Weights should be in nA or uS."""
     global pcsim_globals
     if weight is None:  weight = 0.0
@@ -837 +858 @@
         self.vm_rec = FieldMultiChannelRecorder(sources, None, src_indices)
      
-    def printSpikes(self, filename, gather=True):
-        """
-        Prints spike times to file in the two-column format
-        "spiketime cell_id" where cell_id is the index of the cell counting
-        along rows and down columns (and the extension of that for 3-D).
+    def printSpikes(self, filename, gather=True,compatible_output=True):
+        """
+        Writes spike times to file.
+        If compatible_output is True, the format is "spiketime cell_id",
+        where cell_id is the index of the cell counting along rows and down
+        columns (and the extension of that for 3-D).
         This allows easy plotting of a `raster' plot of spiketimes, with one
-        line for each cell. This method requires that the cell class records
-        spikes in a vector spiketimes.
+        line for each cell.
+        The timestep and number of data points per cell is written as a header,
+        indicated by a '#' at the beginning of the line.
+        
+        If compatible_output is False, the raw format produced by the simulator
+        is used. This may be faster, since it avoids any post-processing of the
+        spike files.
+        
         If gather is True, the file will only be created on the master node,
         otherwise, a file will be written on each node.
-        """
+        """        
         """PCSIM: implemented by corresponding recorders at python level """
-        self.spike_rec.saveSpikesText(filename)
-        
-        
-    def print_v(self, filename, gather=True):
+        self.spike_rec.saveSpikesText(filename,compatible_output=compatible_output)
+        
+        
+    def print_v(self, filename, gather=True,compatible_output=True):
         """
         Write membrane potential traces to file.
+        If compatible_output is True, the format is "v cell_id",
+        where cell_id is the index of the cell counting along rows and down
+        columns (and the extension of that for 3-D).
+        This allows easy plotting of a `raster' plot of spiketimes, with one
+        line for each cell.
+        The timestep and number of data points per cell is written as a header,
+        indicated by a '#' at the beginning of the line.
+        
+        If compatible_output is False, the raw format produced by the simulator
+        is used. This may be faster, since it avoids any post-processing of the
+        voltage files.
         """
         """PCSIM: will be implemented by corresponding analog recorders at python level object  """
@@ -1034 +1073 @@
         value, or an array with the same dimensions as the Projection array.
         """
-        w = w*1e-9 # Convert from nA to A # !!likely problem with conductance-based synapses
         if isinstance(w, float) or isinstance(w, int):
+            w = w*1e-9 # Convert from nA to A # !!likely problem with conductance-based synapses
             for i in range(len(self)):
                 pcsim_globals.net.object(self.pcsim_projection[i]).W = w
         else:
             for i in range(len(self)):
-                pcsim_globals.net.object(self.pcsim_projection[i]).W = w[i]
+                pcsim_globals.net.object(self.pcsim_projection[i]).W = w[i]*1e-9
     
     def randomizeWeights(self, rand_distr):
@@ -1102 +1141 @@
     # --- Methods for writing/reading information to/from file. ----------------
     
-    def saveConnections(self, filename):
+    def saveConnections(self, filename,gather=False):
         """Save connections to file in a format suitable for reading in with the
         'fromFile' method."""
@@ -1109 +1148 @@
         
     
-    def printWeights(self, filename, format=None):
+    def printWeights(self, filename, format=None, gather=True):
         """Print synaptic weights to file."""
         raise Exception("Method not yet implemented")

branches/0.3/test/pyNNPcsimLowLevelTest.py

@@ -48 +48 @@
         """create(): Parameters set on creation should be the same as retrieved with pypcsim"""        
         global pcsim_globals
-        cellid = create(IF_curr_alpha,{'tau_syn':3.141592654})
-        self.assertAlmostEqual(pcsim_globals.net.object(cellid).TauSyn, 3.141592654, places = 6)
+        cellid = create(IF_curr_alpha,{'tau_syn':3.141592654}) # ms
+        self.assertAlmostEqual(pcsim_globals.net.object(cellid).TauSyn, 0.003141592654, places = 6) #s
     
     def testCreatePCSIMCell(self):
@@ -73 +73 @@
     
     def setUp(self):
-        setup()
+        setup(max_delay=5.0)
         self.postcells = create(IF_curr_alpha,n=3)
         self.precells = create(SpikeSourcePoisson,n=5)
@@ -188 +188 @@
         record( spiking_nrn, "recordTestSpikeFile1.txt")                
         run(1000)
-        end() 
+        end(compatible_output=False) 
         # Now check the contents of the file
         f = file('recordTestSpikeFile1.txt', 'r')

branches/0.3/test/pyNNPcsimPopulationTest.py

@@ -37 +37 @@
         popul = Population((3,3),IF_curr_alpha,{'tau_syn':3.141592654})
         tau_syn = pcsim_globals.net.object(popul.getObjectID(popul[2,2])).TauSyn 
-        self.assertAlmostEqual(tau_syn, 3.141592654, places=5)
+        self.assertAlmostEqual(tau_syn, 0.003141592654, places=5)
     
     def testInitWithLabel(self):
@@ -66 +66 @@
         self.net3 = Population((2,2,1),SpikeSourceArray)
         self.net4 = Population((1,2,1),SpikeSourceArray)
-        self.net5 = Population((3,3),IF_cond_alpha)
+        self.net5 = Population((3,3),IF_curr_exp)
     
     def testValidIndices(self):
@@ -105 +105 @@
          """Population.set(): Parameters set in a dict should all be retrievable from PyPCSIM directly"""
          self.popul1.set({'tau_m':43.21})
-         self.assertAlmostEqual( pcsim_globals.net.object(self.popul1.getObjectID(8)).taum, 43.21, places = 5)
+         self.assertAlmostEqual( pcsim_globals.net.object(self.popul1.getObjectID(8)).taum, 0.04321, places = 5)
 #     
      def testSetFromPair(self):
         """Population.set(): A parameter set as a string,value pair should be retrievable using PyPCSIM directly"""
         self.popul1.set('tau_m',12.34)
-        self.assertAlmostEqual( pcsim_globals.net.object(self.popul1.getObjectID(3)).taum, 12.34, places = 5)
+        self.assertAlmostEqual( pcsim_globals.net.object(self.popul1.getObjectID(3)).taum, 0.01234, places = 5)
      
      def testSetInvalidFromPair(self):
@@ -267 +267 @@
                      weights.append(pcsim_globals.net.object(prj1.pcsim_projection[i]).W)
                  for w in weights:
-                     self.assertAlmostEqual(w,1.234, places = 7)
+                     self.assertAlmostEqual(w,1.234*1e-9, places = 7)
          
      def testFixedProbability(self):
@@ -328 +328 @@
              weights.append(pcsim_globals.net.object(prj1[i]).W)
          for w in weights:
-             self.assertAlmostEqual(w, 2.345)
+             self.assertAlmostEqual(w, 2.345*1e-9)
          
          
@@ -401 +401 @@
 if __name__ == "__main__":
      unittest.main()
-