def get_current_time():
""" Gets the time within the simulation
:return: returns the current time
"""
globals_variables.check_simulator()
return __pynn["get_current_time"]()
def record(variables,
source,
filename,
sampling_interval=None,
annotations=None):
""" Sets variables to be recorded.
:param variables: may be either a single variable name or a list of
variable names. For a given celltype class, celltype.recordable
contains a list of variables that can be recorded for that celltype.
:type variables: str or list(str)
:param source: where to record from
:type source: ~spynnaker.pyNN.models.populations.Population or
~spynnaker.pyNN.models.populations.PopulationView
:param str filename: file name to write data to
:param sampling_interval:
how often to sample the recording, not ignored so far
:param annotations: the annotations to data writers
:type annotations: dict(str, ...)
:return: neo object
:rtype: ~neo.core.Block
"""
globals_variables.check_simulator()
return __pynn["record"](variables, source, filename, sampling_interval,
annotations)
def get_machine():
""" Get the SpiNNaker machine in use.
:return: the machine object
:rtype: ~spinn_machine.Machine
"""
globals_variables.check_simulator()
return globals_variables.get_simulator().machine
def get_time_step():
""" The integration time step
:return: get the time step of the simulation (in ms)
:rtype: float
"""
globals_variables.check_simulator()
return float(__pynn["get_time_step"]())
def run_until(tstop):
""" Run until a (simulation) time period has completed.
:param float tstop: the time to stop at (in milliseconds)
:return: the actual simulation time that the simulation stopped at
:rtype: float
"""
globals_variables.check_simulator()
return __pynn["run_until"](tstop)
def get_min_delay():
""" The minimum allowed synaptic delay; delays will be clamped to be at\
least this.
:return: returns the min delay of the simulation
:rtype: int
"""
globals_variables.check_simulator()
return __pynn["get_min_delay"]()
def initialize(cells, **initial_values):
""" Sets cells to be initialised to the given values
:param cells: the cells to change params on
:type cells: ~spynnaker.pyNN.models.populations.Population or
~spynnaker.pyNN.models.populations.PopulationView
:param initial_values: the params and their values to change
"""
globals_variables.check_simulator()
pynn_common.initialize(cells, **initial_values)
def run(simtime, callbacks=None):
""" The run() function advances the simulation for a given number of \
milliseconds, e.g.:
:param float simtime: time to run for (in milliseconds)
:param callbacks: callbacks to run
:return: the actual simulation time that the simulation stopped at
:rtype: float
"""
globals_variables.check_simulator()
return __pynn["run"](simtime, callbacks=callbacks)
def reset(annotations=None):
""" Resets the simulation to t = 0
:param annotations: the annotations to the data objects
:type annotations: dict(str, ...)
:rtype: None
"""
if annotations is None:
annotations = {}
globals_variables.check_simulator()
__pynn["reset"](annotations)
def rank():
""" The MPI rank of the current node.
.. note::
Always 0 on SpiNNaker, which doesn't use MPI.
:return: MPI rank
:rtype: int
"""
globals_variables.check_simulator()
return __pynn["rank"]()
def num_processes():
""" The number of MPI processes.
.. note::
Always 1 on SpiNNaker, which doesn't use MPI.
:return: the number of MPI processes
:rtype: int
"""
globals_variables.check_simulator()
return __pynn["num_processes"]()
def create(cellclass, cellparams=None, n=1):
""" Builds a population with certain params
:param cellclass: population class
:type cellclass: type or AbstractPyNNModel
:param cellparams: population params.
:param int n: n neurons
:rtype: ~spynnaker.pyNN.models.populations.Population
"""
globals_variables.check_simulator()
return __pynn["create"](cellclass, cellparams, n)
def connect(pre,
post,
weight=0.0,
delay=None,
receptor_type=None,
p=1,
rng=None):
""" Builds a projection
:param ~spynnaker.pyNN.models.populations.Population pre: source pop
:param ~spynnaker.pyNN.models.populations.Population post: destination pop
:param float weight: weight of the connections
:param float delay: the delay of the connections
:param str receptor_type: excitatory / inhibitory
:param float p: probability
:param ~pyNN.random.NumpyRNG rng: random number generator
"""
# pylint: disable=too-many-arguments
globals_variables.check_simulator()
__pynn["connect"](pre, post, weight, delay, receptor_type, p, rng)
