====================
PyNN API version 0.6
====================
----
Simulation setup and control
============================
setup(timestep=0.1, min_delay=0.1, max_delay=10.0, **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.
end(compatible_output=True)
---------------------------
Do any necessary cleaning up before exiting.
run(simtime)
-------------
Run the simulation for simtime ms.
reset()
-------
Reset the time to zero, neuron membrane potentials and synaptic weights to
their initial values, and delete any recorded data. The network structure is
not changed, nor is the specification of which neurons to record from.
get_time_step()
---------------
Return the integration time step.
get_current_time()
------------------
Return the current time in the simulation.
get_min_delay()
---------------
Return the minimum allowed synaptic delay.
get_max_delay()
---------------
Return the maximum allowed synaptic delay.
rank()
------
Return the MPI rank of the current node.
num_processes()
---------------
Return the number of MPI processes.
----
----
Procedural interface for creating, connecting and recording networks
====================================================================
create(cellclass, cellparams=None, n=1)
---------------------------------------
Create n cells all of the same type.
If n > 1, return a list of cell ids/references.
If n==1, return just the single id.
connect(source, target, weight=None, delay=None, synapse_type=None, p=1, rng=None)
----------------------------------------------------------------------------------
Connect a source of spikes to a synaptic target.
source and target can 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.
Weights should be in nA or µS.
set(cells, param, val=None)
---------------------------
Set one or more parameters of an individual cell or list of cells.
param can be a dict, in which case val should not be supplied, or a string
giving the parameter name, in which case val is the parameter value.
record(source, filename)
------------------------
Record spikes to a file. source can be an individual cell or a list of
cells.
record(source, filename)
------------------------
Record membrane potential to a file. source can be an individual cell or
a list of cells.
record(source, filename)
------------------------
Record synaptic conductances to a file. source can be an individual cell
or a list of cells.
----
----
Object-oriented interface for creating, connecting and recording networks
=========================================================================
----
Population
----------
An array of neurons all of the same type. `Population' is used as a generic
term intended to include layers, columns, nuclei, etc., of cells.
**__getitem__(self, addr)**
Return a representation of the cell with coordinates given by addr,
suitable for being passed to other methods that require a cell id.
Note that !__getitem!__ is called when using [] access, e.g.
p = Population(...)
p[2,3] is equivalent to p.!__getitem!__((2,3)).
Also accepts slices, e.g.
p[0,3:6]
which returns an array of cells.
**__init__(self, dims, cellclass, cellparams=None, label=None)**
Create a population of neurons all of the same type.
dims should be a tuple containing the population dimensions, or a single
integer, for a one-dimensional population.
e.g., (10,10) will create a two-dimensional population of size 10x10.
cellclass should either be a standardized cell class (a class inheriting
from common.!StandardCellType) or a string giving the name of the
simulator-specific model that makes up the population.
cellparams should be a dict which is passed to the neuron model constructor
label is an optional name for the population.
**__iter__(self)**
Iterator over cell ids on the local node.
**__len__(self)**
Return the total number of cells in the population.
**addresses(self)**
Iterator over cell addresses on the local node.
**all(self)**
Iterator over cell ids on all nodes.
**can_record(self, variable)**
Determine whether `variable` can be recorded from this population.
**describe(self, template='standard', fill= at 0x2854470>)**
Returns a human-readable description of the population
**get(self, parameter_name, as_array=False)**
Get the values of a parameter for every cell in the population.
**getSpikes(self, gather=True, compatible_output=True)**
Return a 2-column numpy array containing cell ids and spike times for
recorded cells.
Useful for small populations, for example for single neuron Monte-Carlo.
**get_gsyn(self, gather=True, compatible_output=True)**
Return a 3-column numpy array containing cell ids and synaptic
conductances for recorded cells.
*get_spike_counts(self, gather=True)**
Returns the number of spikes for each neuron.
**get_v(self, gather=True, compatible_output=True)**
Return a 2-column numpy array containing cell ids and Vm for
recorded cells.
**id_to_index(self, id)**
Given the ID of a cell in the Population, return its index (order in the
Population).
>>> assert id_to_index(p.index(5)) == 5
**ids(self)**
Iterator over cell ids on the local node.
**index(self, n)**
Return the nth cell in the population (Indexing starts at 0).
n may be a list or array, e.g., [i,j,k], in which case, returns the
ith, jth and kth cells in the population.
**inject(self, current_source)**
Connect a current source to all cells in the Population.
**locate(self, id)**
Given an element id in a Population, return the coordinates.
e.g. for 4 6 , element 2 has coordinates (1,0) and value 7
7 9
**meanSpikeCount(self, gather=True)**
Returns the mean number of spikes per neuron.
**nearest(self, position)**
Return the neuron closest to the specified position.
**printSpikes(self, file, gather=True, compatible_output=True)**
Write spike times to file.
file should be either a filename or a PyNN File object.
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.
The timestep, first id, last id, and number of data points per cell are
written in 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.
For parallel simulators, if gather is True, all data will be gathered
to the master node and a single output file created there. Otherwise, a
file will be written on each node, containing only the cells simulated
on that node.
**print_gsyn(self, file, gather=True, compatible_output=True)**
Write synaptic conductance traces to file.
file should be either a filename or a PyNN File object.
If compatible_output is True, the format is "t g 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).
The timestep, first id, last id, and number of data points per cell are
written in 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.
**print_v(self, file, gather=True, compatible_output=True)**
Write membrane potential traces to file.
file should be either a filename or a PyNN File object.
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).
The timestep, first id, last id, and number of data points per cell are
written in 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.
For parallel simulators, if gather is True, all data will be gathered
to the master node and a single output file created there. Otherwise, a
file will be written on each node, containing only the cells simulated
on that node.
**randomInit(self, rand_distr)**
Set initial membrane potentials for all the cells in the population to
random values.
**record(self, record_from=None, rng=None, to_file=True)**
If record_from is not given, record spikes from 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.
**record_gsyn(self, record_from=None, rng=None, to_file=True)**
If record_from is not given, record synaptic conductances
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.
**record_v(self, record_from=None, rng=None, to_file=True)**
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.
**rset(self, parametername, rand_distr)**
'Random' set. Set the value of parametername to a value taken from
rand_distr, which should be a !RandomDistribution object.
**set(self, param, val=None)**
Set one or more parameters for every cell in the population.
param can be a dict, in which case val should not be supplied, or a string
giving the parameter name, in which case val is the parameter value.
val can be a numeric value, or list of such (e.g. for setting spike times).
e.g. p.set("tau_m",20.0).
p.set({'tau_m':20,'v_rest':-65})
**tset(self, parametername, value_array)**
'Topographic' set. Set the value of parametername to the values in
value_array, which must have the same dimensions as the Population.
----
ID
--
Instead of storing ids as integers, we store them as ID objects,
which allows a syntax like:
p[3,4].tau_m = 20.0
where p is a Population object.
**__init__(self, n)**
Create an ID object with numerical value `n`.
**__getattr__(self, name)**
Get the value of the cell parameter `name`, in PyNN standard units.
**get_native_parameters(self)**
Return a dictionary of parameters for the native cell model.
**get_parameters(self)**
Return a dict of all cell parameters.
**inject(self, current_source)**
Inject current from a current source object into the cell.
**is_standard_cell(self)**
**set_native_parameters(self, parameters)**
Set parameters of the native cell model from a dictionary.
**set_parameters(self, **parameters)**
Set cell parameters, given as a sequence of parameter=value arguments.
----
Projection
----------
A container for all the connections of a given type (same synapse type and
plasticity mechanisms) between two populations, together with methods to set
parameters of those connections, including of plasticity mechanisms.
**__init__(self, presynaptic_population, postsynaptic_population, method, source=None, target=None, synapse_dynamics=None, label=None, rng=None)**
presynaptic_population and postsynaptic_population - Population objects.
source - string specifying which attribute of the presynaptic cell
signals action potentials
target - string specifying which synapse on the postsynaptic cell to
connect to
If source and/or target are not given, default values are used.
method - a Connector object, encapsulating the algorithm to use for
connecting the neurons.
synapse_dynamics - a `!SynapseDynamics` object specifying which
synaptic plasticity mechanisms to use.
rng - specify an RNG object to be used by the Connector.
**__len__(self)**
Return the total number of local connections.
**describe(self, template='standard')**
Return a human-readable description of the projection
**getDelays(self, format='list', gather=True)**
Get synaptic delays for all connections in this Projection.
Possible formats are: a list of length equal to the number of connections
in the projection, a 2D delay array (with NaN for non-existent
connections).
**getSynapseDynamics(self, parameter_name, format='list', gather=True)**
Get parameters of the dynamic synapses for all connections in this
Projection.
**getWeights(self, format='list', gather=True)**
Get synaptic weights for all connections in this Projection.
Possible formats are: a list of length equal to the number of connections
in the projection, a 2D weight array (with NaN for non-existent
connections). Note that for the array format, if there is more than
one connection between two cells, the summed weight will be given.
**printWeights(self, filename, format='list', gather=True)**
Print synaptic weights to file. In the array format, zeros are printed for non-existent connections.
**randomizeDelays(self, rand_distr)**
Set delays to random values taken from rand_distr.
**randomizeSynapseDynamics(self, param, rand_distr)**
Set parameters of the synapse dynamics to values taken from rand_distr
**randomizeWeights(self, rand_distr)**
Set weights to random values taken from rand_distr.
**saveConnections(self, filename, gather=True, compatible_output=True)**
Save connections to file in a format suitable for reading in with a
!FromFileConnector.
**setDelays(self, d)**
d can be a single number, in which case all delays are set to this
value, or a list/1D array of length equal to the number of connections
in the projection, or a 2D array with the same dimensions as the
connectivity matrix (as returned by `getDelays(format='array')`).
**setSynapseDynamics(self, param, value)**
Set parameters of the dynamic synapses for all connections in this
projection.
**setWeights(self, w)**
w can be a single number, in which case all weights are set to this
value, or a list/1D array of length equal to the number of connections
in the projection, or a 2D array with the same dimensions as the
connectivity matrix (as returned by `getWeights(format='array')`).
Weights should be in nA for current-based and µS for conductance-based
synapses.
**size(self, gather=True)**
Return the total number of connections.
- only local connections, if gather is False,
- all connections, if gather is True (default)
**weightHistogram(self, min=None, max=None, nbins=10)**
Return a histogram of synaptic weights.
If min and max are not given, the minimum and maximum weights are
calculated automatically.
----
AllToAllConnector
-----------------
Connects all cells in the presynaptic population to all cells in the
postsynaptic population.
**__init__(self, allow_self_connections=True, weights=0.0, delays=None, space=)**
Create a new connector.
`allow_self_connections` -- if the connector is used to connect a
Population to itself, this flag determines whether a neuron is
allowed to connect to itself, or only to other neurons in the
Population.
`weights` -- may either be a float, a !RandomDistribution object, a list/
1D array with at least as many items as connections to be
created. Units nA.
`delays` -- as `weights`. If `None`, all synaptic delays will be set
to the global minimum delay.
----
OneToOneConnector
-----------------
Where the pre- and postsynaptic populations have the same size, connect
cell i in the presynaptic population to cell i in the postsynaptic
population for all i.
**__init__(self, weights=0.0, delays=None)**
Create a new connector.
`weights` -- may either be a float, a !RandomDistribution object, a list/
1D array with at least as many items as connections to be
created. Units nA.
`delays` -- as `weights`. If `None`, all synaptic delays will be set
to the global minimum delay.
----
FixedProbabilityConnector
-------------------------
For each pair of pre-post cells, the connection probability is constant.
**__init__(self, p_connect, allow_self_connections=True, weights=0.0, delays=None, space=)**
Create a new connector.
`p_connect` -- a float between zero and one. Each potential connection
is created with this probability.
`allow_self_connections` -- if the connector is used to connect a
Population to itself, this flag determines whether a neuron is
allowed to connect to itself, or only to other neurons in the
Population.
`weights` -- may either be a float, a !RandomDistribution object, a list/
1D array with at least as many items as connections to be
created. Units nA.
`delays` -- as `weights`. If `None`, all synaptic delays will be set
to the global minimum delay.
----
DistanceDependentProbabilityConnector
-------------------------------------
For each pair of pre-post cells, the connection probability depends on distance.
**__init__(self, d_expression, allow_self_connections=True, weights=0.0, delays=None, space=)**
Create a new connector.
`d_expression` -- the right-hand side of a valid python expression for
probability, involving 'd', e.g. "exp(-abs(d))", or "d<3"
`space` -- a Space object.
`weights` -- may either be a float, a !RandomDistribution object, a list/
1D array with at least as many items as connections to be
created, or a !DistanceDependence object. Units nA.
`delays` -- as `weights`. If `None`, all synaptic delays will be set
to the global minimum delay.
----
FixedNumberPreConnector
-----------------------
Each post-synaptic neuron is connected to exactly n pre-synaptic neurons
chosen at random.
If n is less than the size of the pre-synaptic population, there are no
multiple connections, i.e., no instances of the same pair of neurons being
multiply connected. If n is greater than the size of the pre-synaptic
population, all possible single connections are made before starting to add
duplicate connections.
**__init__(self, n, allow_self_connections=True, weights=0.0, delays=None)**
Create a new connector.
`n` -- either a positive integer, or a `!RandomDistribution` that produces
positive integers. If `n` is a `!RandomDistribution`, then the
number of pre-synaptic neurons is drawn from this distribution
for each post-synaptic neuron.
`allow_self_connections` -- if the connector is used to connect a
Population to itself, this flag determines whether a neuron is
allowed to connect to itself, or only to other neurons in the
Population.
`weights` -- may either be a float, a !RandomDistribution object, a list/
1D array with at least as many items as connections to be
created. Units nA.
`delays` -- as `weights`. If `None`, all synaptic delays will be set
to the global minimum delay.
----
FixedNumberPostConnector
------------------------
Each pre-synaptic neuron is connected to exactly n post-synaptic neurons
chosen at random.
If n is less than the size of the post-synaptic population, there are no
multiple connections, i.e., no instances of the same pair of neurons being
multiply connected. If n is greater than the size of the post-synaptic
population, all possible single connections are made before starting to add
duplicate connections.
**__init__(self, n, allow_self_connections=True, weights=0.0, delays=None)**
Create a new connector.
`n` -- either a positive integer, or a `!RandomDistribution` that produces
positive integers. If `n` is a `!RandomDistribution`, then the
number of post-synaptic neurons is drawn from this distribution
for each pre-synaptic neuron.
`allow_self_connections` -- if the connector is used to connect a
Population to itself, this flag determines whether a neuron is
allowed to connect to itself, or only to other neurons in the
Population.
`weights` -- may either be a float, a !RandomDistribution object, a list/
1D array with at least as many items as connections to be
created. Units nA.
`delays` -- as `weights`. If `None`, all synaptic delays will be set
to the global minimum delay.
----
FromListConnector
-----------------
Make connections according to a list.
**__init__(self, conn_list)**
Create a new connector.
`conn_list` -- a list of tuples, one tuple for each connection. Each
tuple should contain:
(pre_addr, post_addr, weight, delay)
where pre_addr is the address (a tuple) of the presynaptic
neuron, and post_addr is the address of the postsynaptic
neuron.
----
FromFileConnector
-----------------
Make connections according to a list read from a file.
**__init__(self, filename, distributed=False)**
Create a new connector.
`filename` -- name of a text file containing a list of connections, in
the format required by `!FromListConnector`.
`distributed` -- if this is True, then each node will read connections
from a file called `filename.x`, where `x` is the MPI
rank. This speeds up loading connections for
distributed simulations.
----
----
Standard neuron models
======================
----
IF_curr_exp
-----------
Leaky integrate and fire model with fixed threshold and
decaying-exponential post-synaptic current. (Separate synaptic currents for
excitatory and inhibitory synapses.
**__init__(self, parameters)**
**default_parameters** = {
============= ==========
============= ==========
'tau_refrac': 0.0
'tau_m': 20.0
'i_offset': 0.0
'cm': 1.0
'v_init': -65.0
'v_thresh': -50.0
'tau_syn_E': 5.0
'v_rest': -65.0
'tau_syn_I': 5.0
'v_reset': -65.0
============= ==========
}
----
IF_curr_alpha
-------------
Leaky integrate and fire model with fixed threshold and alpha-function-
shaped post-synaptic current.
**__init__(self, parameters)**
**default_parameters** = {
============= ==========
============= ==========
'tau_refrac': 0.0
'tau_m': 20.0
'i_offset': 0.0
'cm': 1.0
'v_init': -65.0
'v_thresh': -50.0
'tau_syn_E': 0.5
'v_rest': -65.0
'tau_syn_I': 0.5
'v_reset': -65.0
============= ==========
}
----
IF_cond_exp
-----------
Leaky integrate and fire model with fixed threshold and
exponentially-decaying post-synaptic conductance.
**__init__(self, parameters)**
**default_parameters** = {
============= ==========
============= ==========
'tau_refrac': 0.0
'tau_m': 20.0
'e_rev_E': 0.0
'i_offset': 0.0
'cm': 1.0
'e_rev_I': -70.0
'v_init': -65.0
'v_thresh': -50.0
'tau_syn_E': 5.0
'v_rest': -65.0
'tau_syn_I': 5.0
'v_reset': -65.0
============= ==========
}
----
IF_cond_alpha
-------------
Leaky integrate and fire model with fixed threshold and alpha-function-
shaped post-synaptic conductance.
**__init__(self, parameters)**
**default_parameters** = {
============= ==========
============= ==========
'tau_refrac': 0.0
'tau_m': 20.0
'e_rev_E': 0.0
'i_offset': 0.0
'cm': 1.0
'e_rev_I': -70.0
'v_init': -65.0
'v_thresh': -50.0
'tau_syn_E': 0.3
'v_rest': -65.0
'tau_syn_I': 0.5
'v_reset': -65.0
============= ==========
}
----
EIF_cond_alpha_isfa_ista
------------------------
Exponential integrate and fire neuron with spike triggered and sub-threshold
adaptation currents (isfa, ista reps.) according to:
Brette R and Gerstner W (2005) Adaptive Exponential Integrate-and-Fire Model as
an Effective Description of Neuronal Activity. J Neurophysiol 94:3637-3642
See also: IF_cond_exp_gsfa_grr
**__init__(self, parameters)**
**default_parameters** = {
============= ==========
============= ==========
'tau_refrac': 0.0
'a': 4.0
'tau_m': 9.3667
'e_rev_E': 0.0
'i_offset': 0.0
'cm': 0.281
'delta_T': 2.0
'v_init': -70.6
'v_thresh': -50.4
'b': 0.0805
'tau_syn_E': 5.0
'v_reset': -70.6
'v_spike': -40.0
'e_rev_I': -80.0
'tau_syn_I': 5.0
'tau_w': 144.0
'w_init': 0.0
'v_rest': -70.6
============= ==========
}
----
IF_facets_hardware1
-------------------
Leaky integrate and fire model with conductance-based synapses and fixed
threshold as it is resembled by the FACETS Hardware Stage 1. For further
details regarding the hardware model see the FACETS-internal Wiki:
https://facets.kip.uni-heidelberg.de/private/wiki/index.php/WP7_NNM
**__init__(self, parameters)**
**default_parameters** = {
============= ==========
============= ==========
'g_leak': 40.0
'e_rev_I': -80.0
'v_thresh': -55.0
'tau_syn_E': 30.0
'v_rest': -65.0
'tau_syn_I': 30.0
'v_reset': -80.0
============= ==========
}
----
HH_cond_exp
-----------
Single-compartment Hodgkin-Huxley model.
**__init__(self, parameters)**
**default_parameters** = {
============= ==========
============= ==========
'gbar_K': 6000.0
'e_rev_E': 0.0
'gbar_Na': 20000.0
'cm': 0.2
'e_rev_leak': -65.0
'e_rev_I': -80.0
'e_rev_K': -90.0
'v_init': -65.0
'e_rev_Na': 50.0
'tau_syn_E': 0.2
'tau_syn_I': 2.0
'v_offset': -63.0
'i_offset': 0.0
'g_leak': 10.0
============= ==========
}
----
SpikeSourcePoisson
------------------
Spike source, generating spikes according to a Poisson process.
**__init__(self, parameters)**
**default_parameters** = {
============= ==========
============= ==========
'duration': 1000000.0
'start': 0.0
'rate': 1.0
============= ==========
}
----
SpikeSourceArray
----------------
Spike source generating spikes at the times given in the spike_times array.
**__init__(self, parameters)**
**default_parameters** = {
=============== ==========
=============== ==========
'spike_times': []
=============== ==========
}
----
----
Specification of synaptic plasticity
====================================
----
SynapseDynamics
---------------
For specifying synapse short-term (faciliation, depression) and long-term
(STDP) plasticity. To be passed as the `synapse_dynamics` argument to
`Projection.!__init!__()` or `connect()`.
**__init__(self, fast=None, slow=None)**
Create a new specification for a dynamic synapse, combining a `fast`
component (short-term facilitation/depression) and a `slow` component
(long-term potentiation/depression).
**describe(self, template='standard')**
Return a human-readable description of the synaptic properties.
----
STDPMechanism
-------------
Specification of STDP models.
**__init__(self, timing_dependence=None, weight_dependence=None, voltage_dependence=None, dendritic_delay_fraction=1.0)**
**describe(self)**
Return a human-readable description of the STDP mechanism.
----
TsodyksMarkramMechanism
-----------------------
**__init__(self, U=0.5, tau_rec=100.0, tau_facil=0.0, u0=0.0, x0=1.0, y0=0.0)**
----
AdditiveWeightDependence
------------------------
The amplitude of the weight change is fixed for depression (`A_minus`)
and for potentiation (`A_plus`).
If the new weight would be less than `w_min` it is set to `w_min`. If it would
be greater than `w_max` it is set to `w_max`.
**__init__(self, w_min=0.0, w_max=1.0, A_plus=0.01, A_minus=0.01)**
----
MultiplicativeWeightDependence
------------------------------
The amplitude of the weight change depends on the current weight.
For depression, Dw propto w-w_min
For potentiation, Dw propto w_max-w
**__init__(self, w_min=0.0, w_max=1.0, A_plus=0.01, A_minus=0.01)**
----
AdditivePotentiationMultiplicativeDepression
--------------------------------------------
The amplitude of the weight change depends on the current weight for
depression (Dw propto w-w_min) and is fixed for potentiation.
**__init__(self, w_min=0.0, w_max=1.0, A_plus=0.01, A_minus=0.01)**
----
GutigWeightDependence
---------------------
The amplitude of the weight change depends on the current weight.
For depression, Dw propto w-w_min
For potentiation, Dw propto w_max-w
**__init__(self, w_min=0.0, w_max=1.0, A_plus=0.01, A_minus=0.01, mu_plus=0.5, mu_minus=0.5)**
----
SpikePairRule
-------------
**__init__(self, tau_plus=20.0, tau_minus=20.0)**
----
----
Current injection
=================
----
DCSource
--------
Source producing a single pulse of current of constant amplitude.
**__init__(self, amplitude=1.0, start=0.0, stop=None)**
Construct the current source.
Arguments:
start -- onset time of pulse in ms
stop -- end of pulse in ms
amplitude -- pulse amplitude in nA
**inject_into(self, cell_list)**
Inject this current source into some cells.
----
StepCurrentSource
-----------------
A step-wise time-varying current source.
**__init__(self, times, amplitudes)**
Construct the current source.
Arguments:
times -- list/array of times at which the injected current changes.
amplitudes -- list/array of current amplitudes to be injected at the
times specified in `times`.
The injected current will be zero up until the first time in `times`. The
current will continue at the final value in `amplitudes` until the end
of the simulation.
**inject_into(self, cell_list)**
Inject this current source into some cells.
----
ACSource
--------
Source producing a single pulse of current of constant amplitude.
**__init__(self, amplitude=1.0, offset=0.0, frequency=10, phase=0.0, start=0.0, stop=None)**
Construct the current source.
Arguments:
start -- onset time of pulse in ms
stop -- end of pulse in ms
amplitude -- pulse amplitude in nA
sine_amp -- sine amplitude in nA
frequency -- frequency in Hz
phase -- phase in degree
**inject_into(self, cell_list)**
Inject this current source into some cells.
----
NoisyCurrentSource
------------------
A Gaussian "white" noise current source. The current amplitude changes at fixed
intervals, with the new value drawn from a Gaussian distribution.
**__init__(self, mean, stdev, dt=None, start=0.0, stop=None, rng=None)**
Construct the current source.
Required arguments:
mean -- mean current amplitude in nA
stdev -- standard deviation of the current amplitude in nA
Optional arguments:
dt -- interval between updates of the current amplitude. Must be
a multiple of the simulation time step. If not specified,
the simulation time step will be used.
start -- onset of the current injection in ms. If not specified, the
current will begin at the start of the simulation.
stop -- end of the current injection in ms. If not specified, the
current will continue until the end of the simulation.
rng -- an RNG object from the `pyNN.random` module. For speed,
this should be a `NativeRNG` instance (uses the simulator's
internal random number generator). For reproducibility
across simulators, use one of the other RNG types. If not
specified, a NumpyRNG is used.
**inject_into(self, cell_list)**
Inject this current source into some cells.
----
----
File formats
============
----
BaseFile
--------
Base class for PyNN File classes.
**__del__(self)**
**__init__(self, filename, mode='r')**
Open a file with the given filename and mode.
**close(self)**
Close the file.
**get_metadata(self)**
Read metadata from the file and return a dict.
**read(self)**
Read data from the file and return a !NumPy array.
**write(self, data, metadata)**
Write data and metadata to file. `data` should be a !NumPy array,
`metadata` should be a dictionary.
----
StandardTextFile
----------------
Data and metadata is written as text. Metadata is written at the top of the
file, with each line preceded by "#". Data is written with one data point per line.
----
PickleFile
----------
Data and metadata are pickled and saved to file.
----
NumpyBinaryFile
---------------
Data and metadata are saved in .npz format, which is a zipped archive of
arrays.
----
HDF5ArrayFile
-------------
Data are saved as an array within a node named "data". Metadata are
saved as attributes of this node.
----
----
Exceptions
==========
----
InvalidParameterValueError
---------------------------
Inappropriate parameter value
----
NonExistentParameterError
-------------------------
Model parameter does not exist.
----
InvalidDimensionsError
----------------------
Argument has inappropriate shape/dimensions.
----
ConnectionError
---------------
Attempt to create an invalid connection or access a non-existent connection.
----
InvalidModelError
-----------------
Attempt to use a non-existent model type.
----
RoundingWarning
---------------
The argument has been rounded to a lower level of precision by the simulator.
----
NothingToWriteError
-------------------
There is no data available to write.
----
InvalidWeightError
------------------
Invalid value for the synaptic weight.
----
NotLocalError
-------------
Attempt to access a cell or connection that does not exist on this node (but exists elsewhere).
----
RecordingError
--------------
Attempt to record a variable that does not exist for this cell type.
----
----
The random module
=================
----
NumpyRNG
--------
Wrapper for the numpy.random.!RandomState class (Mersenne Twister PRNG).
**__getattr__(self, name)**
This is to give the PyNN RNGs the same methods as the wrapped RNGs (
numpy.random.!RandomState or the GSL RNGs.
**__init__(self, seed=None, rank=0, num_processes=1, parallel_safe=True)**
**describe(self)**
**next(self, n=1, distribution='uniform', parameters=[], mask_local=None)**
Return n random numbers from the distribution.
If n >= 0, return a numpy array,
if n < 0, raise an Exception.
----
GSLRNG
------
Wrapper for the GSL random number generators.
**__getattr__(self, name)**
This is to give GSLRNG the same methods as the GSL RNGs.
**__init__(self, seed=None, type='mt19937', rank=0, num_processes=1, parallel_safe=True)**
**next(self, n=1, distribution='uniform', parameters=[], mask_local=None)**
Return n random numbers from the distribution.
If n >= 0, return a numpy array,
if n < 0, raise an Exception.
----
NativeRNG
---------
Signals that the simulator's own native RNG should be used.
Each simulator module should implement a class of the same name which
inherits from this and which sets the seed appropriately.
**__init__(self, seed=None)**
**next(self, n=1, distribution='uniform', parameters=[])**
Return n random numbers from the distribution.
If n is 1, return a float, if n > 1, return a Numpy array,
if n <= 0, raise an Exception.
----
RandomDistribution
------------------
Class which defines a next(n) method which returns an array of n random
numbers from a given distribution.
**__init__(self, distribution='uniform', parameters=[], rng=None, boundaries=None, constrain='clip')**
If present, rng should be a NumpyRNG or GSLRNG object.
distribution should be the name of a method supported by the underlying
random number generator object.
parameters should be a list or tuple containing the arguments expected
by the underlying method in the correct order. named arguments are
not yet supported.
boundaries is a tuple (min, max) used to specify explicitly, for distribution
like Gaussian, Gamma or others, hard boundaries for the parameters. If
parameters are drawn outside those boundaries, the policy applied will depend
on the constrain parameter.
constrain control the policy for weights out of the specified boundaries.
If "clip", random numbers are clipped to the boundaries.
If "redraw", random numbers are drawn till they fall within the boundaries.
Note that NumpyRNG and GSLRNG distributions may not have the same names,
e.g., 'normal' for NumpyRNG and 'gaussian' for GSLRNG, and the
arguments may also differ.
**next(self, n=1, mask_local=None)**
Return n random numbers from the distribution.
----
----
The utility module
==================
colour(col, text)
-----------------
notify(msg='Simulation finished.', subject='Simulation finished.', smtphost=None, address=None)
-----------------------------------------------------------------------------------------------
Send an e-mail stating that the simulation has finished.
get_script_args(n_args, usage='')
---------------------------------
Get command line arguments.
This works by finding the name of the main script and assuming any
arguments after this in sys.argv are arguments to the script.
It would be nicer to use optparse, but this doesn't seem to work too well
with nrniv or mpirun.
init_logging(logfile, debug=False, num_processes=1, rank=0)
-----------------------------------------------------------
----
Timer
-----
For timing script execution.
**time_in_words(s)**
Formats a time in seconds as a string containing the time in days,
hours, minutes, seconds. Examples::
>>> time_in_words(1)
1 second
>>> time_in_words(123)
2 minutes, 3 seconds
>>> time_in_words(24*3600)
1 day
**__init__(self)**
**diff(self, format=None)**
Return the time since the last time elapsedTime() or diff() was called.
**elapsedTime(self, format=None)**
Return the elapsed time in seconds but keep the clock running.
**reset(self)**
Reset the time to zero, and start the clock.
**start(self)**
Start timing.
----