Changeset 76

Timestamp:

05/24/07 11:49:19 (1 year ago)

Author:

apdavison

Message:

Merged trunk changes r54:75 into pyNN-0.3 branch

Files:

• branches/0.3/common.py (modified) (8 diffs)
• branches/0.3/doc/README (copied) (copied from trunk/doc/README)
• branches/0.3/doc/highlevelapi.txt (modified) (1 diff)
• branches/0.3/doc/lowlevelapi.txt (modified) (6 diffs)
• branches/0.3/doc/testdocs.py (copied) (copied from trunk/doc/testdocs.py)
• branches/0.3/doc/wikidoc.py (modified) (11 diffs)
• branches/0.3/nest.py (modified) (30 diffs)
• branches/0.3/nest2.py (copied) (copied from trunk/nest2.py)
• branches/0.3/neuron.py (modified) (55 diffs)
• branches/0.3/oldneuron.py (modified) (5 diffs)
• branches/0.3/pcsim.py (modified) (23 diffs)
• branches/0.3/test/IF_cond_alpha.py (modified) (1 diff)
• branches/0.3/test/VAbenchmark2.py (deleted)
• branches/0.3/test/VAbenchmark2_graphs.py (deleted)
• branches/0.3/test/VAbenchmark_graphs.py (modified) (5 diffs)
• branches/0.3/test/VAbenchmarks.py (modified) (10 diffs)
• branches/0.3/test/checkAPI.py (modified) (2 diffs)
• branches/0.3/test/nest_test.py (deleted)
• branches/0.3/test/nesttests.py (modified) (3 diffs)
• branches/0.3/test/neurontests.py (modified) (4 diffs)
• branches/0.3/test/pcsimtests_lowlevel.py (copied) (copied from trunk/test/pcsimtests_lowlevel.py)
• branches/0.3/test/pcsimtests_population.py (copied) (copied from trunk/test/pcsimtests_population.py)
• branches/0.3/test/pyNNPcsimLowLevelTest.py (deleted)
• branches/0.3/test/pyNNPcsimPopulationTest.py (deleted)
• branches/0.3/utility.py (copied) (copied from trunk/utility.py)

branches/0.3/common.py

@@ -43 +43 @@
-
-    def set(self,param,val=None):
-pass
+raise Exception("Not yet implemented")
-    
-    def get(self,param):
-pass
+raise Exception("Not yet implemented")
-
-    def setCellClass(self, cellclass):
@@ -97 +97 @@
-                        raise InvalidParameterValueError, (type(supplied_parameters[k]), type(default_parameters[k]))
-                else:
-
+(k)
-        return parameters
-
@@ -273 +273 @@
-        self.dim      = dims
-        if isinstance(dims, int): # also allow a single integer, for a 1D population
-
+#
-            self.dim = (self.dim,)
-        self.label    = label
@@ -352 +352 @@
-        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)
-
-
+
-        """
-        pass
@@ -367 +366 @@
-        pass
-
- 
+
-        """
-        Writes spike times to file.
@@ -556 +555 @@
-        """
-        Read connections from a list of tuples,
-
+
+
+
-        """
-        # Need to implement parameter parsing here...
@@ -566 +567 @@
-        """
-        w can be a single number, in which case all weights are set to this
-
+
+
+
+
-        """
-        pass
@@ -582 +586 @@
-        """
-        d can be a single number, in which case all delays are set to this
-
+
+
-        """
-        pass

branches/0.3/doc/highlevelapi.txt

@@ -2 +2 @@
-Populations and Projections
-===========================
+
+While it is entirely possible to create very large networks using only the ``create()``, ``connect()``, ``set()`` and ``record()`` functions, this involves writing a lot of repetitive code, which is the same or similar for every model: iterating over lists of cells and connections, creating common projection patterns, recording from all or a subset of neurons...
+This sort of 'book-keeping' code takes time to write, obscures the essential principles of the simulation script with details, and, of course, the more code that has to be written, the more bugs and errors will be introduced, and, if the code is only used for a single project, not all the bugs may be found.
+
+For these reasons, PyNN provides the ``Population`` object, representing a group of neurons all of the same type (although possibly with cell-to-cell variations in the values of parameters), and the ``Projection`` object, repesenting the set of connections between two ``Population``\s.
+All the book-keeping code is contained within the object classes, which also provide functions ('methods') to perform commonly-used tasks, such as recording from a fixed number of cells within the population, chosen at random.
+
+By using the ``Population`` and ``Projection`` classes, less code needs to be written to create a given simulation, which means fewer-bugs and easier-to-understand scripts, plus because the code for the classes is used in many different projects, bugs will be found more reliably, and the internal implementation of the classes optimized for performance.
+Of particular importance is iterations over large numbers of cells or connections can be done in fast compiled code (within the simulator engines) rather than in comparatively slow Python code.
+
+
+Creating ``Population``\s
+=========================
+
+Some examples of creating a population of neurons (don't forget to call ``setup()`` first).
+
+This creates a 10 x 10 array of ``IF_curr_exp`` neurons with default parameters::
+
+    >>> p1 = Population((10,10), IF_curr_exp)
+
+This creates a 1D array of 100 spike sources, and gives it a label::
+
+    >>> p2 = Population(100, SpikeSourceArray, label="Input Population")
+
+This illustrates all the possible arguments of the ``Population`` constructor, with argument names.
+It creates a 3D array of ``IF_cond_alpha`` neurons, all with a spike threshold set to -55 mV and membrane time constant set to 10 ms::
+
+    >>> p3 = Population(dims=(3,4,5), cellclass=IF_cond_alpha,
+    ...                 cellparams={'v_thresh': -55.0, 'tau_m': 10.0},
+    ...                 label="Column 1")
+                        
+The population dimensions can be retrieved using the ``dim`` attribute, e.g.::
+
+    >>> p1.dim
+    (10, 10)
+    >>> p2.dim
+    (100,)
+    >>> p3.dim
+    (3, 4, 5)
+    
+While the total number of neurons in a population can be obtained with the Python ``len()`` function::
+
+    >>> print len(p1), len(p2), len(p3)
+    100 100 60
+    
+The above examples all use PyNN standard cell models. It is also possible to use simulator-specific models, but in this case the ``cellclass`` should be given as a string, e.g.::
+
+    >>> p4 = Population(20, 'iaf_neuron', cellparams={'Tau': 15.0, 'C': 0.001})
+    
+This example will work with NEST but not with NEURON or PCSIM.
+                        
+Addressing individual neurons
+=============================
+
+To address individual neurons in a population, use ``[]`` notation, e.g.,::
+
+    >>> p1[0,0]
+    1
+    >>> p1[9,9]
+    100
+    >>> p2[67]
+    168
+    >>> p3[2,1,0]
+    246
+    
+The actual return values depend on the simulator engine used, and may be integers, strings, or Python objects.
+The n-tuple of values within the square brackets is referred to as a neurons's *address*, while the return value is its *id*.
+Trying to address a non-existent neuron will raise an Exception::
+
+    >>> p1[999,0]
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in ?
+      File "/usr/lib/python/site-packages/pyNN/nest.py", line 457, in __getitem__
+        id = self.cell[addr]
+    IndexError: index (999) out of range (0<=index<=10) in dimension 0
+
+as will giving the wrong number of dimensions in the address.
+It is equally possible to define the address as a tuple, and then pass the tuple within the square brackets, e.g.::
+
+    >>> p1[5,5]
+    56
+    >>> address = (5,5)
+    >>> p1[address]
+    56
+    
+Neuron addresses are used in setting parameter values, and in specifying which neurons to record from.
+They may also be used together with the low-level ``connect()``, ``set()``, and ``record()`` functions.
+They may also be used to specify a position in space, e.g.::
+
+    >>> p1[5,5].setPosition((0.0, 0.1))
+    >>> p1[5,5].getPosition()
+    (0.0, 0.10000000000000001)
+
+Setting parameter values
+========================
+
+Setting the same value for the entire population
+------------------------------------------------
+
+To set a parameter for all neurons in the population to the same value, use the ``set()`` method, e.g.::
+
+    >>> p1.set("tau_m", 20.0)
+    >>> p1.set({'tau_m':20, 'v_rest':-65})
+    
+The first form can be used for setting a single parameter, the second form for setting multiple parameters at once.
+
+Setting random values
+---------------------
+
+To set a parameter to values drawn from a random distribution, use the ``rset()`` method with a ``RandomDistribution`` object from the ``pyNN.random`` module (see the chapter on random numbers for more details).
+The following example sets the initial membrane potential of each neuron to a value drawn from a uniform distribution between -70 mV and -55 mV::
+
+    >>> from pyNN.random import RandomDistribution
+    >>> vinit_distr = RandomDistribution(distribution='uniform',parameters=[-70,-55])
+    >>> p1.rset('v_init', vinit_distr)
+
+For the specific case of setting the initial membrane potential, there is a convenience method ``randomInit()``, e.g.::
+
+    >>> p1.randomInit(vinit_distr)
+
+Setting values according to an array
+------------------------------------
+
+The most efficient way to set different (but non-random) values for different neurons is to use the ``tset()`` (for *topographic* set) method.
+The following example injects a current of 0.1 nA into the first column of neurons in the population::
+
+    >>> import numpy
+    >>> current_input = numpy.zeros(p1.dim)
+    >>> current_input[:,0] = 0.1
+    >>> p1.tset('i_offset', current_input)
+
+Setting parameter values for individual neurons
+-----------------------------------------------
+
+To set the parameters of an individual neuron, you can use the low-level ``set()`` function,::
+
+    >>> set(p1[3,3], IF_curr_exp, 'tau_m', 12.0)
+    
+or you can use the set method of the ''ID'' object that the ``neuron``, ``nest`` and ``pcsim`` (but not ``oldneuron``) modules return as neuron ids::
+
+    >>> p1[3,3].set('tau_m', 12.0)
+    
+Recording
+=========
+
+Recording spike times is done with the method ``record()``.
+Recording membrane potential is done with the method ``record_v()``.
+Both methods have identical argument lists.
+Some examples::
+
+    >>> p1.record()                            # record from all neurons in the population
+    >>> p1.record(10)                          # record from 10 neurons chosen at random
+    >>> p1.record([p1[0,0], p1[0,1], p1[0,2]]) # record from specific neurons
+
+Writing the recorded values to file is done with a second pair of methods, ``printSpikes()`` and ``print_v()``, e.g.::
+
+    >>> p1.printSpikes("spikefile.dat")
+
+By default, the output files are post-processed to reformat them from the native simulator format to a common format that is the same for all simulator engines.
+This facilitates comparisons across simulators, but of course has some performace penalty.
+To get output in the native format of the simulator, add ``compatible_output=False`` to the argument list.
+
+When running a distributed simulation, each node records only those neurons that it simulates.
+By default, at the end of the simulation all nodes send their recorded data to the master node so that all values are written to a single output file.
+Again, there is a performance penalty for this, so if you wish each node to write its own file, add ``gather=False`` to the argument list.
+
+Statistics
+==========
+
+Often, the exact spike times and exact membrane potential traces are not required, only statistical measures.
+PyNN currently only provides one such measure, the mean number of spikes per neuron, e.g.::
+
+    >>> p1.meanSpikeCount()
+    0.0
+    
+More such statistical measures are planned for future releases.
+
+
+Connecting two ``Population``\s with a ``Projection``
+=====================================================
+
+A ``Projection`` object is a container for all the synaptic connections between neurons in two ``Population``\s, together with methods for setting synaptic weights and delays.
+A ``Projection`` is created by specifying a pre-synaptic ``Population``, a post-synaptic ``Population`` and a 'wiring' method, e.g.::
+
+    >>> prj2_1 = Projection(p2, p1, method='allToAll')
+    
+This connects ``p2`` (pre-synaptic) to ``p1`` (post-synaptic), using the '``allToAll``' connection method, which connects every neuron in the pre-synaptic population to every neuron in the post-synaptic population.
+The currently available connection or 'wiring' methods are explained below.
+
+All-to-all connections
+----------------------
+
+The ``'allToAll'`` method has one optional argument ``allow_self_connections``, for use when connecting a ``Population`` to itself.
+By default it is ``True``, but if a neuron should not connect to itself, set it to ``False``, e.g.::
+
+    >>> prj1_1 = Projection(p1, p1, method='allToAll', methodParameters={'allow_self_connections': False})
+
+One-to-one connections
+----------------------
+
+Use of the ``'oneToOne'`` method requires that the pre- and post-synaptic populations have the same dimensions, e.g.::
+    
+    >>> prj1_1a = Projection(p1, p1, method='oneToOne')
+    
+Trying to connect two ``Population``\s with different dimensions will raise an Exception, e.g.::
+
+    >>> invalid_prj = Projection(p2, p3, method='oneToOne')
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in ?
+      File "/usr/lib/python/site-packages/pyNN/nest.py", line 839, in __init__
+        self.nconn = connection_method(methodParameters)
+      File "/usr/lib/python/site-packages/pyNN/nest.py", line 920, in _oneToOne
+        raise "Method 'oneToOne' not yet implemented for the case where presynaptic and postsynaptic Populations have different sizes."
+    Exception: Method 'oneToOne' not yet implemented for the case where presynaptic and postsynaptic Populations have different sizes.
+    
+    
+Connecting neurons with a fixed probability
+-------------------------------------------
+
+With the ``'fixedProbability'`` method, each possible connection between all pre-synaptic neurons and all post-synaptic neurons is created with probability ``p_connect``, e.g.::
+
+    >>> prj2_3 = Projection(p2, p3, 'fixedProbability', {'p_connect': 0.2})
+    
+The ``methodParams`` dictionary can also contain the ``allow_self_connections`` parameter, as above.
+
+Connecting neurons with a distance-dependent probability
+--------------------------------------------------------
+
+For each pair of pre-post cells, the connection probability depends on distance.
+If positions in space have been specified using the ``setPosition()`` method of the ID class, these positions are used to calculate distances.
+If not, the neuron addresses, i.e., the array coordinates, are used.
+
+The ``methodParams`` dictionary should contain a string ``d_expression``, which should be the right-hand side of a valid python expression for probability (i.e. returning a value between 0 and 1), involving '``d``', e.g.::
+
+    >>> prj1_1b = Projection(p1, p1, 'distanceDependentProbability', "exp(-abs(d))")
+    >>> prj3_3  = Projection(p3, p3, 'distanceDependentProbability', "float(d<3)")
+
+The first example connects neurons with an exponentially-decaying probability.
+The second example connects each neuron to all its neighbours within a range of 3 units (distance is in µm if positions have been specified, in array coordinate distance otherwise).
+
+Currently it is not possible to connect ``Population``\s which have different dimensionality. Trying to do this will raise an Exception::
+
+    >>> prj3_1 = Projection(p3, p1, 'distanceDependentProbability', "exp(-(d*d)/4.0)")
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in ?
+      File "/usr/lib/python/site-packages/pyNN/nest.py", line 839, in __init__
+        self.nconn = connection_method(methodParameters)
+      File "/usr/lib/python/site-packages/pyNN/nest.py", line 988, in _distanceDependentProbability
+        dist = self._distance(self.pre, self.post, pre, post)
+      File "/usr/lib/python/site-packages/pyNN/nest.py", line 875, in _distance
+        raise Exception("Method _distance() not yet implemented for Populations with different sizes.")
+    Exception: Method _distance() not yet implemented for Populations with different sizes.
+
+but it is planned to change this in the next release.
+
+
+Divergent/fan-out connections
+-----------------------------
+
+The ``'fixedNumberPost'`` method connects each pre-synaptic neuron to exactly ``n`` post-synaptic neurons chosen at random, where ``n`` is an integer supplied in the ``methodParams`` dictionary, e.g.::
+
+    >>> prj2_1a = Projection(p2, p1, 'fixedNumberPost', {'n': 30})
+    
+As a refinement to this, the number of post-synaptic neurons can be chosen at random from a ``RandomDistribution`` object, e.g.::
+
+    >>> distr_npost = RandomDistribution(distribution='binomial', parameters=[100,0.3])
+    >>> prj2_1b = Projection(p2, p1, 'fixedNumberPost', {'rand_distr': distr_npost})
+    
+(of course, the number of post-synaptic synapses is no longer exactly fixed, but it didn't seem worth defining a whole new method for it).
+
+
+Convergent/fan-in connections
+-----------------------------
+
+The ``'fixedNumberPre'`` method has the same arguments as ``'fixedNumberPost'``, but of course it connects each *post*-synaptic neuron to ``n`` *pre*-synaptic neurons, e.g.::
+
+    >>> prj2_1c = Projection(p2, p1, 'fixedNumberPre', {'n': 5})
+    >>> distr_npre = RandomDistribution(distribution='poisson', parameters=[5])
+    >>> prj2_1d = Projection(p2, p1, 'fixedNumberPre', {'rand_distr': distr_npre})
+
+
+Writing and reading connection patterns to/from a file
+------------------------------------------------------
+
+Connection patterns can be written to a file using ``saveConnections()``, e.g.::
+
+    >>> prj1_1a.saveConnections("prj1_1a.conn")
+    
+These files can then be read back in to create a new ``Projection`` object by specifying the ``fromFile`` connection method, e.g.::
+
+    >>> prj1_1c = Projection(p1, p1, 'fromFile', "prj1_1a.conn")
+
+Specifying a list of connections
+--------------------------------
+
+Specific connection patterns not covered by the methods above can be obtained by specifying an explicit list of pre-synaptic and post-synaptic neuron addresses, with weights and delays.
+(Note that the weights and delays should be optional, but currently are not). Example::
+
+    >>> conn_list = [
+    ...   ((0,0), (0,0,0), 0.0, 0.1),
+    ...   ((0,0), (0,0,1), 0.0, 0.1),
+    ...   ((0,0), (0,0,2), 0.0, 0.1),
+    ...   ((0,1), (1,3,0), 0.0, 0.1)
+    ... ]
+    >>> prj1_3d = Projection(p1, p3, 'fromList', conn_list)
+
+
+User-defined connection algorithms
+----------------------------------
+
+If you wish to use a specific connection/wiring algorithm not covered by the PyNN built-in ones, the only option currently is to construct a list of connections and use the ``'fromList'`` method.
+In 
+
+Setting synaptic weights and delays
+===================================
+
+To set the weights of all synaptic connections in a ``Projection`` to a single value, use the ``setWeights()`` method::
+
+    >>> prj1_1.setWeights(0.2)
+    
+[Note: synaptic weights in PyNN are in nA for current-based synapses and µS for conductance-based synapses)].
+
+To set different weights to different values, use ``setWeights()`` with a list or 1D numpy array argument, where the length of the list/array is equal to the number of synapses, e.g.::
+
+    >>> weight_list = 0.1*numpy.ones(len(prj2_1))
+    >>> weight_list[0:5] = 0.2
+    >>> prj2_1.setWeights(weight_list)
+    
+To set weights to random values, use the ``randomizeWeights()`` method::
+
+    >>> weight_distr = RandomDistribution(distribution='gamma',parameters=[1,0.1])
+    >>> prj1_1.randomizeWeights(weight_distr)
+    
+Setting delays works similarly::
+
+    >>> prj1_1.setDelays(0.6)
+    >>> delay_list = 0.3*numpy.ones(len(prj2_1))
+    >>> delay_list[0:5] = 0.4
+    >>> prj2_1.setDelays(delay_list)
+    >>> delay_distr = RandomDistribution(distribution='gamma',parameters=[2,0.2])
+    >>> prj1_1.randomizeDelays(delay_distr)
+
+Synaptic plasticity
+===================
+
+The PyNN API supports setting parameters of spike-timing-dependent plasticity (STDP) models, but
+this has currently only been implemented for NEURON.
+
+Example
+=======
+
+There are several examples of networks built with the high-level API in the ``test`` directory.

branches/0.3/doc/lowlevelapi.txt

@@ -12 +12 @@
-``setup()`` takes various optional arguments: setting the simulation timestep (there is currently no support in the API for variable timestep methods although native simulator code can be used to select this option where the simulator supports it), setting the minimum and maximum synaptic delays, and turning debugging output on and off, e.g.::
-
-1
+5
-    
-Debugging information is written to a log file in the working directory.
@@ -39 +39 @@
-    >>> create(IF_curr_alpha, n=10)
-    
-
-
+
+
+
+
+
+
+
-To use different parameter values, use the ``paramDict`` argument, e.g.::
-
@@ -48 +53 @@
-
-    >>> create(IF_curr_alpha, paramDict={'foo': 15.0})
-
+
+
+
+
+
+
+
+
+
+
+
-    >>> create(IF_curr_alpha, paramDict={'tau_m': 'bar'})
-
+
+
+
+
+
+
+
+
+
+
+
-    
-If you wish to do something with the cell after creating it: record from it, change a parameter, connect it to another cell, you should assign the return value of the function to a variable, e.g.::
@@ -64 +89 @@
-Any neuron that emits spikes can be connected to any neuron with at least one synapse using the ``connect()`` function, e.g.::
-
-
-s = create(IF_curr_alpha
-s
+_
+_list2 = create(IF_curr_exp
+_list2
-    
-In this case we connect a spike-generating mechanism (``SpikeSourceArray`` is a 'standard cell' model that emits spikes at times specified by the ``spiketimes`` parameter) to each cell in the list ``cells``, i.e. we create 10 connections at once.
-For clarity, we could also have specified the argument names::
-
-s
+_list2
-    
-Either ``source``, or ``target``, or both may be individual cell ids or lists of ids.
-In the latter case, each source (presynaptic) cell is connected to every target (postsynaptic) cell with probability given by the optional argument `p`, which defaults to 1, e.g.::
-
+    >>> source_list = cell_list
+    >>> target_list = cell_list2
-    >>> connect(source_list, target_list, p=0.5)
-    
-When specifying connections as above, default values are given to the synaptic weight and delay.
-[These default values may be different for different simulators?]
-These values are seldom very useful, and it is better to specify the ``weight`` and ``delay`` arguments of ``connect()``, e.g.::
-
@@ -86 +112 @@
-At the moment, in fact, this is the only way to specify synaptic weights and connections in PyNN without using simulator-specific code. This deficiency will be addressed in a future release.
-
-
+Â
-Delays are in ms.
-For current-based synapses, weights should be negative for inhibitory synapses.
@@ -102 +128 @@
-The parameters for individual neurons and post-synaptic mechanisms may be changed after creation of the neuron using the ``set()`` function, e.g.::
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-It is unfortunately necessary to specify the neuron type as the second argument, since cell ids do not (currently, at least) hold information about the neuron type.
-Individual parameters can be set using the ``param`` and ``val`` arguments, as above, or multiple parameters can be set at once by passing a dictionary of name:value pairs as the ``param`` argument, with ``val`` empty, e.g.::
-
-
+_E
-    
-An alternative way to set parameter values is to call the ``set()`` method of the cell ID objects, e.g.::
-
-    >>> cells[0].set('v_reset', -70.0)
-
+_E
-
-Recording spikes and membrane potential

branches/0.3/doc/wikidoc.py

@@ -24 +24 @@
-#-- Define global data ---------------------------------------------------------
-
-
-
-
-
+
+
+
+
+
-#               'time','types','copy',]
+exclude.remove('__init__')
-
-leftquote = re.compile(r"'\b")
-leftdblquote = re.compile(r'"\b')
+camelcase = re.compile(r'(\b([A-Z][a-z]+){2,99})')
-
-classes = {}
-functions = []
-data = []
-
-default_arg_fmt  = {'wiki'  : '%s<span style="color:grey;">=%s</span>',
-                    'latex' : '%s{\\color{grey}=%s}'}
-func_sig_fmt     = {'wiki'  : '%s(<span style="font-weight:normal;">%s</span>)',
-                    'latex' : '%s(\\mdseries %s)'}
-function_fmt     = {'wiki'  : '\n====<span style="color:#0066ff;">%s</span>====\n',
-                    'latex' : '\n\\paragraph*{\\color{brightblue}{%s}}\n'}
-method_fmt       = {'wiki'  : '\n====<span style="color:#8888ff;">%s</span>====\n',
-                    'latex' : '\n\\paragraph*{\\color{brightblue}{%s}}\n'}
-staticmethod_fmt = {'wiki'  : '\n====<span style="color:#0066ff;">%s</span> (static)====\n',
-                    'latex' : '\n\\paragraph*{\\color{brightblue}{%s} (static)}\n'}
-dict_fmt         = {'wiki'  : "\n\n'''%s''' = {\n",
-                    'latex' : '\n\\textbf{%s} = $\\lbrace$\n\n'}
-dict_fmt_end     = {'wiki'  : '}\n',
-                    'latex' : '$\\rbrace$\n'}
-data_element_fmt = {'wiki'  : "\n'''%s''' = %s\n",
-                    'latex' : "\n\\textbf{%s} = %s\n"}
-table_begin      = {'wiki'  : "{|\n",
-                    'latex' : "\\begin{tabular}{lll}\n"}
-table_end        = {'wiki'  : "|}\n",
-                    'latex' : "\\end{tabular}\n"}
-table_row_fmt    = {'wiki'  : "| &nbsp;&nbsp;&nbsp; || %s ||: %s\n|-\n",
-                    'latex' : '& %s & :%s\\\\\n'}
-category_fmt     = {'wiki'  : '\n==%s==\n',
-                    'latex' : '\n\\subsection{%s}\n'}
-class_fmt        = {'wiki'  : '\n===<span style="color:green">%s</span>===\n',
-                    'latex' : '\n\\subsubsection*{%s}\n'}
-horiz_line       = {'wiki'  : '\n----\n',
-                    'latex' : ''}
-
-#-- Process command line parameters --------------------------------------------
@@ -72 +46 @@
-    output = 'wiki'
-logging.info('Generating API documentation in %s format' % output)
+
+#-- Define templates -----------------------------------------------------------
+if output == 'wiki':
+    default_arg_fmt  = '%s<span style="color:grey;">=%s</span>'
+    func_sig_fmt     = '%s(<span style="font-weight:normal;">%s</span>)'
+    function_fmt     = '\n====<span style="color:#0066ff;">%s</span>====\n'
+    method_fmt       = '\n====<span style="color:#8888ff;">%s</span>====\n'
+    staticmethod_fmt = '\n====<span style="color:#0066ff;">%s</span> (static)====\n'
+    dict_fmt         = "\n\n'''%s''' = {\n"
+    dict_fmt_end     = '}\n'
+    data_element_fmt = "\n'''%s''' = %s\n"
+    table_begin      = "{|\n"
+    table_end        = "|}\n"
+    table_row_fmt    = "| &nbsp;&nbsp;&nbsp; || %s ||: %s\n|-\n"
+    category_fmt     = '\n==%s==\n'
+    class_fmt        = '\n===<span style="color:green">%s</span>===\n'
+    horiz_line       = '\n----\n'
+elif output == 'trac':
+    default_arg_fmt  = '%s=%s'
+    func_sig_fmt     = '%s(%s)'
+    function_fmt     = '\n=== %s ===\n'
+    method_fmt       = '\n=== %s ===\n'
+    staticmethod_fmt = '\n=== %s ===\n'
+    dict_fmt         = "\n\n'''%s''' = {\n"
+    dict_fmt_end     = '}\n'
+    data_element_fmt = "\n'''%s''' = %s\n"
+    table_begin      = "\n"
+    table_end        = "\n"
+    table_row_fmt    = "|| %s ||: %s ||\n"
+    category_fmt     = '\n= %s =\n'
+    class_fmt        = '\n== %s ==\n'
+    horiz_line       = '\n----\n'
+elif output == 'latex':
+    default_arg_fmt  = '%s{\\color{grey}=%s}'
+    func_sig_fmt     = '%s(\\mdseries %s)'
+    function_fmt     = '\n\\paragraph*{\\color{brightblue}{%s}}\n'
+    method_fmt       = '\n\\paragraph*{\\color{brightblue}{%s}}\n'
+    staticmethod_fmt = '\n\\paragraph*{\\color{brightblue}{%s} (static)}\n'
+    dict_fmt         = '\n\\textbf{%s} = $\\lbrace$\n\n'
+    dict_fmt_end     = '$\\rbrace$\n'
+    data_element_fmt = "\n\\textbf{%s} = %s\n"
+    table_begin      = "\\begin{tabular}{lll}\n"
+    table_end        = "\\end{tabular}\n"
+    table_row_fmt    = '& %s & :%s\\\\\n'
+    category_fmt     = '\n\\subsection{%s}\n'
+    class_fmt        = '\n\\subsubsection*{%s}\n'
+    horiz_line       = ''
-             
-#-- Define functions -----------------------------------------------------------
@@ -122 +143 @@
-                    # anonymous arguments
-                    arg = '(...)'
-[output]
+
-                i = i + 1
-        if code.co_flags & 0x0004: # CO_VARARGS
@@ -130 +151 @@
-            args.append('**'+code.co_varnames[callargs])
-            callargs = callargs + 1
-[output]
+
-    except AttributeError:
-        logging.warning("%s has no attribute 'func_code'" % func)
@@ -147 +168 @@
-            classes[entry] = { 'methods': [], 'data': [], 'staticmethods': [] }
-            for classentry in dir(instance):
-:
+ and (classentry[0] != '_' or classentry[0:2] == '__'): # don't include private methods
-                    classentry_type = type(eval('pyNN.common.%s.%s' % (entry,classentry)))
-                    logging.info('    %-28s %s' % (classentry,classentry_type))
@@ -175 +196 @@
-
-logging.info("==== DATA ====")
-[output]
+
-for element in data:
-    instance = eval('pyNN.common.%s' % element)
-    if type(instance) == types.DictType:
-[output]
-[output]
+
+
-        for k,v in instance.items():
-            if output == 'latex':
-                v = str(v).replace('{',' $\\lbrace$').replace('}',' $\\rbrace$')
-[output]
-[output]
-[output]
+
+
+
-    else:
-[output]
+
-    
-logging.info("==== FUNCTIONS ====")
-[output]
+
-for funcname in functions:
-    funcinst = eval('pyNN.common.%s' % funcname)
-[output]
+
-    if funcinst.__doc__:
-        outputStr += _(funcinst.__doc__.strip())
@@ -217 +238 @@
-
-# Now iterate through the classes
-[output]
+
-for classes in [celltype_classes, other_classes, error_classes]:
-    classlist = classes.keys()
-    classlist.sort()
-    for classname in classlist:
-[output]
+
-        docstr = eval('pyNN.common.%s.__doc__' % classname)
-        if docstr:
@@ -230 +251 @@
-            fs = func_sig(methodinst)
-            if fs:
-[output]
+
-                if methodinst.__doc__:
-                    outputStr += _(methodinst.__doc__.strip())
@@ -237 +258 @@
-            fs = func_sig(methodinst)
-            if fs:
-[output]
+
-                if methodinst.__doc__:
-                    outputStr += _(methodinst.__doc__.strip())
@@ -243 +264 @@
-            instance = eval('pyNN.common.%s.%s' % (classname,element))
-            if type(instance) == types.DictType:
-[output]
+
-                if len(instance) > 0:
-[output]
+
-                    for k,v in instance.items():
-                        if output == 'latex':
-                            v = str(v).replace('{',' $\\lbrace$').replace('}',' $\\rbrace$')
-[output]
+
-                        elif output == 'wiki':
-
-
-
+
+
+
+
+
-            else:
-[output]
+
-                
-[output]
+
-    
-if output == 'latex':
@@ -265 +288 @@
-    outputStr = leftquote.sub('`',outputStr)
-    outputStr = leftdblquote.sub('``',outputStr)
+if output == 'trac':
+    outputStr = outputStr.replace('__','!__')
+    outputStr = camelcase.sub(r'!\1',outputStr)
-
-print outputStr

branches/0.3/nest.py

@@ -34 +34 @@
-    """
-    
+    def __getattr__(self,name):
+        """Note that this currently does not translate units."""
+        translated_name = self._cellclass.translations[name][0]
+        return pynest.getDict([int(self)])[0][translated_name]
+    
-    def set(self,param,val=None):
-        # We perform a call to the low-level function set() of the API.
@@ -43 +48 @@
-            set(self,self._cellclass,param,val)
-
-    #def get(self,param):
-    #    pynest.getDict(self)[param]
-
-# ==============================================================================
@@ -230 +233 @@
-        celltype = cellclass(paramDict)
-        cell_gids = pynest.create(celltype.nest_name,n)
-pynest.getGID(gid
+ID(pynest.getGID(gid)
-        pynest.setDict(cell_gids,celltype.parameters)
-    elif isinstance(cellclass, str):  # celltype is not a standard cell
-        cell_gids = pynest.create(cellclass,n)
-pynest.getGID(gid
+ID(pynest.getGID(gid)
-        if paramDict:
-            pynest.setDict(cell_gids,paramDict)
-    else:
-        raise "Invalid cell type"
+    for id in cell_gids:
+        id.setCellClass(cellclass)
-    if n == 1:
-        return cell_gids[0]
@@ -257 +262 @@
-    weight = weight*1000 # weights should be in nA or uS, but iaf_neuron uses pA and iaf_cond_neuron uses nS.
-                         # Using convention in this way is not ideal. We should be able to look up the units used by each model somewhere.
+    if synapse_type == 'inhibitory' and weight > 0:
+        weight *= -1
-    try:
-        if type(source) != types.ListType and type(target) != types.ListType:
@@ -289 +296 @@
-    if val:
-        param = {param:val}
-
+
+
+
-        cells = [cells]
-
-
+
+
+
+
+
-    pynest.setDict(cells,param)
-
@@ -335 +347 @@
-    writing process, which is not the case for the moment"""
-    tempfilename = "%s/%s" %(tempdir, filename)
-temp
+
-    if (compatible_output):
-        # Here we postprocess the file to have effectively the
@@ -343 +355 @@
-        result = open(filename,'w',100)
-        g = open(tempfilename,'r',100)
+        # Writing # such that Population.printSpikes and this have same output format
+        result.write("# "+"\n")
-        lines = g.readlines()
-        g.close()
@@ -462 +476 @@
-        return id
-    
-    def __getitems__(self,addrs):
-        """Returns the ids of neurons. Input should have format:
-        n = number of synapses; nd = number of dimensions
-        shape(addrs) == (n,nd)