def get_machine(): """ Get the SpiNNaker machine in use. :return: the machine object """ if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) return globals_variables.get_simulator().machine
def get_machine(): """ Get the spinnaker machine in use """ if not globals_variables.has_simulator(): raise ConfigurationException( "You currently have not ran setup, please do so before calling " "get_machine") return globals_variables.get_simulator().machine
def get_time_step(): """ The integration time step :return: get the time step of the simulation (in ms) """ if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) return float(__pynn["get_time_step"]()) / 1000.0
def get_current_time(): """ Gets the time within the simulation :return: returns the current time """ if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) return __pynn["get_current_time"]()
def run_until(tstop): """ Run until a (simulation) time period has completed. :param tstop: the time to stop at (in milliseconds) :return: the actual simulation time that the simulation stopped at """ if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) return __pynn["run_until"](tstop)
def get_max_delay(): """ The maximum allowed synaptic delay; delays will be clamped to be at\ most this. :return: returns the max delay of the simulation """ if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) return __pynn["get_max_delay"]()
def initialize(cells, **initial_values): """ Sets cells to be initialised to the given values :param cells: the cells to change params on :param initial_values: the params and there values to change :rtype: None """ if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) 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 simtime: time to run for (in milliseconds) :param callbacks: callbacks to run :return: the actual simulation time that the simulation stopped at """ if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) return __pynn["run"](simtime, callbacks=callbacks)
def reset(annotations=None): """ Resets the simulation to t = 0 :param annotations: the annotations to the data objects :rtype: None """ if annotations is None: annotations = {} if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) __pynn["reset"](annotations)
def rank(): """ The MPI rank of the current node. .. note:: Always 0 on SpiNNaker, whcih doesn't use MPI. :return: MPI rank """ if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) 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 """ if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) return __pynn["num_processes"]()
def create(cellclass, cellparams=None, n=1): """ Builds a population with certain params :param cellclass: population class :param cellparams: population params. :param n: n neurons :rtype: None """ if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) __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 pre: source pop :param post: destination pop :param weight: weight of the connections :param delay: the delay of the connections :param receptor_type: excitatory / inhibitatory :param p: probability :param rng: random number generator :rtype: None """ # pylint: disable=too-many-arguments if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) __pynn["connect"](pre, post, weight, delay, receptor_type, p, rng)
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. :param source: where to record from :param 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 :return: neo object """ if not globals_variables.has_simulator(): raise ConfigurationException(FAILED_STATE_MSG) return __pynn["record"](variables, source, filename, sampling_interval, annotations)
def setup(timestep=_pynn_control.DEFAULT_TIMESTEP, min_delay=_pynn_control.DEFAULT_MIN_DELAY, max_delay=_pynn_control.DEFAULT_MAX_DELAY, graph_label=None, database_socket_addresses=None, extra_algorithm_xml_paths=None, extra_mapping_inputs=None, extra_mapping_algorithms=None, extra_pre_run_algorithms=None, extra_post_run_algorithms=None, extra_load_algorithms=None, time_scale_factor=None, n_chips_required=None, n_boards_required=None, **extra_params): """ The main method needed to be called to make the PyNN 0.8 setup. Needs\ to be called before any other function :param timestep: the time step of the simulations :param min_delay: the min delay of the simulation :param max_delay: the max delay of the simulation :param graph_label: the label for the graph :param database_socket_addresses: the sockets used by external devices\ for the database notification protocol :param extra_algorithm_xml_paths: \ list of paths to where other XML are located :param extra_mapping_inputs: other inputs used by the mapping process :param extra_mapping_algorithms: \ other algorithms to be used by the mapping process :param extra_pre_run_algorithms: extra algorithms to use before a run :param extra_post_run_algorithms: extra algorithms to use after a run :param extra_load_algorithms: \ extra algorithms to use within the loading phase :param time_scale_factor: multiplicative factor to the machine time step\ (does not affect the neuron models accuracy) :param n_chips_required:\ Deprecated! Use n_boards_required instead. Must be None if n_boards_required specified. :type n_chips_required: int or None :param n_boards_required:\ if you need to be allocated a machine (for spalloc) before building\ your graph, then fill this in with a general idea of the number of boards you need so that the spalloc system can allocate you a machine\ big enough for your needs. :param extra_params: other stuff :return: rank thing :raises ConfigurationException if both n_chips_required and n_boards_required are used. """ # pylint: disable=too-many-arguments, too-many-function-args if pynn8_syntax: # setup PyNN common stuff pynn_common.setup(timestep, min_delay, max_delay, **extra_params) else: # setup PyNN common stuff pynn_common.setup(timestep, min_delay, **extra_params) # create stuff simulator if globals_variables.has_simulator(): # if already exists, kill and rebuild globals_variables.get_simulator().clear() # add default label if needed if graph_label is None: graph_label = "PyNN0.8_graph" # create the main object for all stuff related software SpiNNaker(database_socket_addresses=database_socket_addresses, extra_algorithm_xml_paths=extra_algorithm_xml_paths, extra_mapping_inputs=extra_mapping_inputs, extra_mapping_algorithms=extra_mapping_algorithms, extra_pre_run_algorithms=extra_pre_run_algorithms, extra_post_run_algorithms=extra_post_run_algorithms, extra_load_algorithms=extra_load_algorithms, time_scale_factor=time_scale_factor, timestep=timestep, min_delay=min_delay, max_delay=max_delay, graph_label=graph_label, n_chips_required=n_chips_required, n_boards_required=n_boards_required) # warn about kwargs arguments if extra_params: logger.warning( "Extra params {} have been applied to the setup " "command which we do not consider", extra_params) # get overloaded functions from PyNN in relation of our simulator object _create_overloaded_functions(globals_variables.get_simulator()) return rank()
def setup(timestep=_pynn_control.DEFAULT_TIMESTEP, min_delay=_pynn_control.DEFAULT_MIN_DELAY, max_delay=None, graph_label=None, database_socket_addresses=None, time_scale_factor=None, n_chips_required=None, n_boards_required=None, **extra_params): """ The main method needed to be called to make the PyNN 0.8 setup. Needs\ to be called before any other function :param timestep: the time step of the simulations in micro seconds if None the cfg value is used :type timestep: float or None :param min_delay: the min delay of the simulation :type min_delay: float or str :param max_delay: Ignored and logs a warning if provided :type max_delay: float or str or None :param graph_label: the label for the graph :type graph_label: str or None :param database_socket_addresses: the sockets used by external devices for the database notification protocol :type database_socket_addresses: iterable(~spinn_utilities.socket_address.SocketAddress) :param time_scale_factor: multiplicative factor to the machine time step (does not affect the neuron models accuracy) :type time_scale_factor: int or None :param n_chips_required: Deprecated! Use n_boards_required instead. Must be None if n_boards_required specified. :type n_chips_required: int or None :param n_boards_required: if you need to be allocated a machine (for spalloc) before building your graph, then fill this in with a general idea of the number of boards you need so that the spalloc system can allocate you a machine big enough for your needs. :type n_boards_required: int or None :param extra_params: other keyword argumets used to configure PyNN :return: MPI rank (always 0 on SpiNNaker) :rtype: int :raises ConfigurationException: if both ``n_chips_required`` and ``n_boards_required`` are used. """ # Check for "auto" values if timestep == "auto": timestep = SPYNNAKER_AUTO_TIMESTEP if min_delay == "auto": min_delay = timestep if max_delay: logger.warning( "max_delay is not supported by sPyNNaker so will be ignored") # pylint: disable=too-many-arguments, too-many-function-args # setup PyNN common stuff pynn_common.setup(timestep, min_delay, **extra_params) # create stuff simulator if globals_variables.has_simulator(): logger.warning("Calling setup a second time causes the previous " "simulator to be stopped and cleared.") # if already exists, kill and rebuild try: globals_variables.get_simulator().clear() except Exception: # pylint: disable=broad-except logger.exception("Error forcing previous simulation to clear") # add default label if needed if graph_label is None: graph_label = "PyNN0.8_graph" # create the main object for all stuff related software SpiNNaker(database_socket_addresses=database_socket_addresses, time_scale_factor=time_scale_factor, timestep=timestep, min_delay=min_delay, graph_label=graph_label, n_chips_required=n_chips_required, n_boards_required=n_boards_required) # warn about kwargs arguments if extra_params: logger.warning( "Extra params {} have been applied to the setup " "command which we do not consider", extra_params) # get overloaded functions from PyNN in relation of our simulator object _create_overloaded_functions(globals_variables.get_simulator()) return rank()