API Reference: PyNN.brainscales2

pynn_brainscales.brainscales2.populations.Assembly : public pyNN.common.Assembly

Private Static Attributes

_simulator = simulator

class pynn_brainscales.brainscales2.simulator.BackgroundSpikeSourcePlacement

Tracks assignment of pyNN IDs of SpikeSourcePoissonOnChip based populations to the corresponding hardware entity, i.e.

BackgroundSpikeSourceOnDLS. We use one source on each hemisphere to ensure arbitrary routing works. Default constructed with reversed 1 to 1 permutation to yield better distribution for small networks.

:cvar default_permutation: Default permutation, where allocation is ordered to start at the highest-enum PADI-bus to reduce overlap with allocated neurons.

Public Functions

__init__(self, List[int] permutation=None)

:param permutation: Look up table for permutation.

Index: HW related population neuron enumeration. Value: HW neuron enumeration.

id2source(self, Union[List[ID], ID] neuron_id)

Get hardware coordinate from pyNN ID.

:param neuron_id: pyNN neuron ID

register_id(self, Union[List[ID], ID] neuron_id)

Register a new ID to placement.

:param neuron_id: pyNN neuron ID to be registered

Private Members

_pb_2_id

_permutation

Private Static Functions

_check_and_transform(list lut)

pynn_brainscales.brainscales2.projections.Connection : public pyNN.common.Connection

Store an individual plastic connection and information about it.

Provide an interface that allows access to the connection’s weight, delay and other attributes.

Public Functions

__init__(self, projection, pre_index, post_index, **parameters)

as_tuple(self, *attribute_names)

Public Members

changed_since_last_run

parameters

pop_post_index

pop_pre_index

postsynaptic_index

presynaptic_index

projection

Properties

delay = property(_get_delay, _set_delay)

weight = property(_get_weight, _set_weight)

Private Functions

_get_delay(self)

_get_weight(self)

_set_delay(self, new_delay)

_set_weight(self, new_weight)

Private Members

_delay

_weight

cells.HXNeuron : public StandardCellType , public cells.NetworkAddableCell

One to one representation of subset of parameter space of a lola.AtomicNeuron.

Parameter hierarchy is flattened. Defaults to “silent” neuron.

:param parameters: Mapping of parameters and corresponding values, e.g. dict. Either 1-dimensional or population size dimensions. Default values are overwritten for specified parameters.

Public Functions

__init__(self, **parameters)

parameters should be a mapping object, e.g.

a dict

apply_config(self, List[halco.AtomicNeuronOnDLS] coords)

Extract and apply config according to provided chip object.

:param coords: List of coordinates to look up coco. Needs same order and dimensions as parameter_space.

can_record(self, str variable)

create_hw_entity(cls, dict pynn_parameters)

Builds a Lola Neuron with the values from the dict ‘pynn_parameters’.

Public Static Functions

add_to_input_generator(Population population, grenade.InputGenerator builder)

Add external events to input generator.

:param population: Population to add featuring this cell’s celltype. :param builder: Input builder to add external events to.

add_to_network_graph(Population population, grenade.NetworkBuilder builder)

Add population to network builder.

:param population: Population to add featuring this cell’s celltype. :param builder: Network builder to add population to. :return: Descriptor of added population

get_default_values()

Get the default values of a LoLa Neuron.

get_values(lola.AtomicNeuron() atomic_neuron)

Get values of a LoLa Neuron instance as a dict.

Private Functions

_generate_hw_entity_setters(cls)

Builds setters for creation of Lola Neuron.

Private Members

_hw_entity_setters

_user_provided_parameters

Private Static Functions

_create_translation()

pynn_brainscales.brainscales2.simulator.ID : public int , public IDMixin

Public Functions

__init__(self, n)

Create an ID object with numerical value n.

Private Static Attributes

__doc__ = IDMixin.__doc__

class pynn_brainscales.brainscales2.InjectedConfiguration

User defined injected configuration.

:param pre_non_realtime: Injection written prior to
                          the non realtime configuration.
:param pre_realtime: Injection written prior to
                      the realtime configuration.
:param post_realtime: Injection written after the
                       the realtime configuration.

Public Static Attributes

default_factory

class pynn_brainscales.brainscales2.InjectedReadout

User defined injected readout.

:param pre_realtime: Injection of reads after the
                       the pre_realtime configuration.
:param post_realtime: Injection of reads after the
                       the post_realtime configuration.

Public Static Attributes

default_factory

pynn_brainscales.brainscales2.recording.MADCRecorderSetting : public NamedTuple

cells.NetworkAddableCell : public ABC

Subclassed by cells.HXNeuron, cells.SpikeSourceArray, cells.SpikeSourcePoisson, cells.SpikeSourcePoissonOnChip

Public Static Functions

add_to_input_generator(Population population, grenade.InputGenerator builder)

Add external events to input generator.

:param population: Population to add featuring this cell’s celltype. :param builder: Input builder to add external events to.

add_to_network_graph(Population population, grenade.NetworkBuilder builder)

Add population to network builder.

:param population: Population to add featuring this cell’s celltype. :param builder: Network builder to add population to. :return: Descriptor of added population

class pynn_brainscales.brainscales2.simulator.NeuronPlacement

Tracks assignment of pyNN IDs of HXNeuron based populations to the corresponding hardware entity, i.e.

AtomicNeuronOnDLS. Default constructed with 1 to 1 permutation.

:param neuron_id: Look up table for permutation. Index: HW related population neuron enumeration. Value: HW neuron enumeration.

Public Functions

__init__(self, List[int] permutation=None)

id2atomicneuron(self, Union[List[ID], ID] neuron_id)

Get hardware coordinate from pyNN ID.

:param neuron_id: pyNN neuron ID

id2hwenum(self, Union[List[ID], ID] neuron_id)

Get hardware coordinate as plain int from pyNN ID.

:param neuron_id: pyNN neuron ID

register_id(self, Union[List[ID], ID] neuron_id)

Register a new ID to placement.

:param neuron_id: pyNN neuron ID to be registered

Private Members

_id_2_an

_permutation

Private Static Functions

_check_and_transform(list lut)

class pynn_brainscales.brainscales2.plasticity_rules.PlasticityRule

Plasticity rule base class.

Inheritance is to be used for actual implementations. Periodic timing information is provided via class Timer. The kernel implementation is required to be in the form of C++-based PPU kernel code.

Public Functions

__init__(self, Timer timer)

Create a new plasticity rule with timing information.

:param timer: Timer object.

add_to_network_graph(self, grenade.NetworkBuilder builder)

generate_kernel(self)

Generate plasticity rule kernel to be compiled into PPU program.

The interface to be adhered to is the same as in the empty implementation below. PLASTICITY_RULE_KERNEL is the generic name of the kernel function, which will be expanded to a unique implementation-defined name upon compilation to allow for multiple kernels.

:return: PPU-code of plasticity-rule kernel as string.

Public Members

changed_since_last_run

Properties

timer = property(_get_timer, _set_timer)

Private Functions

_add_projection(self, Projection new_projection)

_get_timer(self)

_remove_projection(self, Projection old_projection)

_set_timer(self, new_timer)

Private Members

_projections

_timer

Private Static Attributes

_simulator = simulator

pynn_brainscales.brainscales2.examples.plasticity_rule.PlasticSynapse : public pynn.PlasticityRule , public pynn.standardmodels.synapses.StaticSynapse

Public Functions

__init__(self, pynn.Timer timer, float weight)

generate_kernel(self)

Generate plasticity rule kernel to be compiled into PPU program.

:return: PPU-code of plasticity-rule kernel as string.

pynn_brainscales.brainscales2.populations.Population : public pyNN.common.Population

Public Members

all_cells

changed_since_last_run

Public Static Attributes

changed_since_last_run = True

Private Functions

_create_cells(self)

_get_parameters(self, *names)

Return a ParameterSpace containing native parameters.

_get_view(self, selector, label=None)

_set_initial_value_array(self, variable, value)

_set_parameters(self, parameter_space)

parameter_space should contain native parameters

Private Members

_mask_local

Private Static Attributes

__doc__ = pyNN.common.Population.__doc__

_assembly_class = Assembly

_recorder_class = Recorder

_simulator = simulator

pynn_brainscales.brainscales2.populations.PopulationView : public pyNN.common.PopulationView

Private Functions

_get_parameters(self, *names)

Return a ParameterSpace containing native parameters.

_get_view(self, selector, label=None)

_set_parameters(self, parameter_space)

parameter_space should contain native parameters

Private Static Attributes

_assembly_class = Assembly

_simulator = simulator

pynn_brainscales.brainscales2.projections.Projection : public pyNN.common.Projection

Public Functions

__init__(self, presynaptic_neurons, postsynaptic_neurons, connector, synapse_type=None, source=None, receptor_type=None, space=Space(), label=None)

Create a new projection, connecting the pre- and post-synaptic neurons.

:param presynaptic_neurons: Population, PopulationView or Assembly object.

:param postsynaptic_neurons: Population, PopulationView or Assembly object.

:param connector: a Connector object, encapsulating the algorithm to use for connecting the neurons.

:param synapse_type: a SynapseType object specifying which synaptic connection mechanisms to use, defaults to None

:param source: string specifying which attribute of the presynaptic cell signals action potentials. This is only needed for multicompartmental cells with branching axons or dendrodendritic synapses. All standard cells have a single source, and this is the default, defaults to None

:param receptor_type: string specifying which synaptic receptor_type type on the postsynaptic cell to connect to. For standard cells, this can be ‘excitatory’ or ‘inhibitory’. For non-standard cells, it could be ‘NMDA’, etc. If receptor_type is not given, the default values of ‘excitatory’ is used, defaults to None

:param space: Space object, determining how distances should be calculated for distance-dependent wiring schemes or parameter values, defaults to Space()

:param label: a name for the projection (one will be auto-generated if this is not supplied), defaults to None

__getitem__(self, i)

Return the *i*th connection within the Projection.

__len__(self)

Return the total number of local connections.

__setattr__(self, name, value)

placed_connections(self)

Query the last routing run for placement of this projection.

Public Members

changed_since_last_run

connections

Public Static Functions

add_to_network_graph(List[Population] populations, Projection projection, grenade.NetworkBuilder builder)

Private Functions

_convergent_connect(self, presynaptic_indices, postsynaptic_index, **connection_parameters)

Connect a neuron to one or more other neurons with a static connection.

_set_attributes(self, parameter_space)

_set_initial_value_array(self, variable, initial_value)

Private Static Attributes

_simulator = simulator

_static_synapse_class = StaticSynapse

pynn_brainscales.brainscales2.recording.Recorder : public pyNN.recording.Recorder

Public Functions

__init__(self, population, file=None)

record(self, variables, ids, sampling_interval=None)

Public Members

changed_since_last_run

Public Static Attributes

madc_variables = ["v", "exc_synin", "inh_synin", "adaptation"]

Private Functions

_clear_simulator(self)

_get_current_segment(self, filter_ids=None, variables='all', clear=False)

_local_count(self, variable, filter_ids)

_record(self, variable, new_ids, sampling_interval=None)

_reset(self)

Private Static Functions

_get_spiketimes(ids, clear=None)

Returns a dict containing the neuron_id and its spiketimes.

Private Static Attributes

_simulator = simulator

cells.SpikeSourceArray : public cells.NetworkAddableCell

Spike source generating spikes at the times [ms] given in the spike_times array.

Public Functions

can_record(self, str variable)

Public Static Functions

add_to_input_generator(Population population, grenade.InputGenerator builder)

Add external events to input generator.

:param population: Population to add featuring this cell’s celltype. :param builder: Input builder to add external events to.

add_to_network_graph(Population population, grenade.NetworkBuilder builder)

Add population to network builder.

:param population: Population to add featuring this cell’s celltype. :param builder: Network builder to add population to. :return: Descriptor of added population

Public Static Attributes

default_parameters = {'spike_times': ArrayParameter([])}

recordable = []

translations = build_translations(('spike_times', 'spike_times'),)

cells.SpikeSourcePoisson : public cells.NetworkAddableCell

Spike source, generating spikes according to a Poisson process.

Public Functions

__init__(self, start, rate, duration)

can_record(self, str variable)

get_spike_times(self)

When this function is called for the first time, the spike times for a Poisson stimulation are calculated and saved, so that all neurons connected to it receive the same stimulation.

When a parameter was changed (compared to the last calculation of the spike time), the times are recalculated.

:return: (unsorted) spike times for each neuron in the population.

Public Static Functions

add_to_input_generator(Population population, grenade.InputGenerator builder)

Add external events to input generator.

:param population: Population to add featuring this cell’s celltype. :param builder: Input builder to add external events to.

add_to_network_graph(Population population, grenade.NetworkBuilder builder)

Add population to network builder.

:param population: Population to add featuring this cell’s celltype. :param builder: Network builder to add population to. :return: Descriptor of added population

Public Static Attributes

recordable = []

translations = build_translations(('start', 'start'),('rate', 'rate'),('duration', 'duration'),)

Private Members

_spike_times

_used_parameters

cells.SpikeSourcePoissonOnChip : public StandardCellType , public cells.NetworkAddableCell

Spike source, generating spikes according to a Poisson process.

Public Functions

__init__(self, rate, seed)

can_record(self, str variable)

Public Static Functions

add_to_input_generator(Population population, grenade.InputGenerator builder)

Add external events to input generator.

:param population: Population to add featuring this cell’s celltype. :param builder: Input builder to add external events to.

add_to_network_graph(Population population, grenade.NetworkBuilder builder)

Add population to network builder.

:param population: Population to add featuring this cell’s celltype. :param builder: Network builder to add population to. :return: Descriptor of added population

Public Static Attributes

recordable = []

translations = build_translations(('rate', 'rate'),('seed', 'seed'),)

Private Static Attributes

_simulator = simulator

pynn_brainscales.brainscales2.simulator.State : public BaseState

Represent the simulator state.

Public Functions

__init__(self)

clear(self)

prepare_static_config(self)

reset(self)

Reset the state of the current network to time t = 0.

run(self, Optional[float] runtime)

Performs a hardware run for runtime milliseconds.

If runtime is None, we only perform preparatory steps.

run_until(self, tstop)

Public Members

background_spike_source_placement

conn

conn_comes_from_outside

conn_manager

current_sources

grenade_chip_config

grenade_network

grenade_network_graph

id_counter

initial_config

injected_config

injected_readout

injection_post_realtime

injection_pre_realtime

injection_pre_static_config

log

madc_recorder

madc_samples

max_delay

min_delay

mpi_rank

neuron_placement

num_processes

plasticity_rules

populations

post_realtime_read

post_realtime_tickets

pre_realtime_read

pre_realtime_tickets

projections

recorders

running

segment_counter

spikes

t

t_start

times

Private Functions

_configure_hxneuron(self, lola.Chip config, ID neuron_id, dict parameters, bool enable_spike_output)

Places Neuron in Population “pop” on chip and configures spike and v recording.

_configure_recorders_populations(self, lola.Chip config)

_generate_inputs(self, grenade.NetworkGraph network_graph)

Generate external input events from the routed network graph representation.

_generate_network_graph(self)

Generate placed and routed executable network graph representation.

_generate_playback_hooks(self)

_get_post_realtime_read(self)

Redeem tickets of injected readout after post_realtime section to get information after execution.

:return: Dictionary with coordinates as keys and read container as values.

_get_pre_realtime_read(self)

Redeem tickets of injected readout after pre_realtime section to get information after execution.

:return: Dictionary with coordinates as keys and read container as values.

_prepare_post_realtime_read(self, sta.PlaybackProgramBuilder builder)

Prepare injected readout after post_realtime configuration.

This generates tickets to access the read information and ensures completion via a barrier. :param builder: Builder to append instructions to.

_prepare_pre_realtime_read(self, sta.PlaybackProgramBuilder builder)

Prepare injected readout after pre_realtime configuration and before realtime experiment section.

This generates tickets to access the read information and ensures completion via a barrier. :param builder: Builder to append instructions to.

_recorders_populations_changed(self)

Collect populations which configurations were changed.

This includes changes in:

• neuron parameters

• recorder settings

• out-going synaptic connections

:return: Populations which were subject to a change mentioned above.

_reset_changed_since_last_run(self)

Reset changed_since_last_run flag to track incremental changes for the next run.

_spike_source_indices(self)

Collect all neurons which serve as a spike source.

Check each projection and collect populations and their neurons which serve as spike sources.

:return: Sets cell ids of neurons which serve as spike sources. These sets are organized in populations which they belong to.

Private Static Functions

_configure_routing(lola.Chip config)

Configure global routing-related but static parameters.

:param config: Chip configuration to add configuration to :return: Altered chip configuration

_get_spikes(grenade.NetworkGraph network_graph, grenade.IODataMap outputs)

Get spikes indexed via neuron IDs.

:param network_graph: Network graph to use for lookup of spike label <-> ID relation :param outputs: All outputs of a single execution to extract spikes from :return: Spikes as dict with atomic neuron enum value as key and numpy array of times as value

_get_v(grenade.NetworkGraph network_graph, grenade.IODataMap outputs)

Get MADC samples with times in ms.

:param network_graph: Network graph to use for lookup of MADC output vertex descriptor :param outputs: All outputs of a single execution to extract samples from :return: Times and sample values as numpy array

class synapses.StaticSynapse

Synaptic connection with fixed weight and delay.

Public Static Attributes

translations = build_translations(('weight', 'weight'),('delay', 'delay'))

Private Functions

_get_minimum_delay(self)

class pynn_brainscales.brainscales2.plasticity_rules.Timer

Periodic timer information for plasticity rule execution.

Public Functions

__init__(self, **parameters)

to_grenade(self)

Public Members

parameters

Properties

num_periods = property(_get_num_periods, _set_num_periods)

period = property(_get_period, _set_period)

start = property(_get_start, _set_start)

Private Functions

_get_num_periods(self)

_get_period(self)

_get_start(self)

_set_num_periods(self, new_num_periods)

_set_period(self, new_period)

_set_start(self, new_start)

Private Members

_num_periods

_period

_start

module cells

namespace pyNN

namespace pynn

namespace common

namespace recording

namespace standardmodels

namespace synapses

module pynn_brainscales

module pynn_brainscales.brainscales2

Functions

end()

Do any necessary cleaning up before exiting.

get_backend_statistics()

Get statistics of placement and routing like amount of time spent and number of hardware entities used.

:raises RuntimeError: If the simulator is not active, i.e. pynn.setup() was not called. :raises RuntimeError: If the routing and placement step were not performed, i.e. pynn.run() was not called. :return: Statistics object.

get_post_realtime_read()

Get injected read results of after post_realtime section.

:return: Dictionary with coordinates as keys and read container as values.

get_pre_realtime_read()

Get injected read results of after pre_realtime section.

:return: Dictionary with coordinates as keys and read container as values.

list_standard_models()

Return a list of all the StandardCellType classes available for this simulator.

run(*args, **kwargs)

setup(timestep=simulator.State.dt, min_delay=DEFAULT_MIN_DELAY, **extra_params)

Should be called at the very beginning of a script.

:param extra_params: most params come from pynn.common.setup neuronPermutation: List providing lookup for custom pyNN neuron to hardware neuron. Index: HW related population neuron enumeration. Value: HW neuron enumeration. Can be shorter than total HW neuron count. E.g. [2,4,5] results in the first neuron of the first HXNeuron population to be assigned to AtomicNeuronOnDLS(Enum(2)) and so forth. backgroundPermutation: List providing lookup for custom pyNN background spike source to hardware entity. Index: HW related population source enumeration. Value: HW source enumeration. Can be shorter than total HW source count. E.g. [2,3] results in the first population to be assigned to PADIBusOnPADIBusBlock(2) and so forth. enable_neuron_bypass: Enable neuron bypass mode: neurons forward spikes arriving at the synaptic input (i.e. no leaky integration is happening); defaults to False. initial_config: Initial configuration of the entire chip. Can for example be used to manually apply a calibration result. injected_config: Optional user defined injected configuration. injected_readout: Optional user defined injected readout.

Variables

__all__ = ["list_standard_models", "setup", "end", "run", "run_until","run_for", "reset", "initialize", "get_current_time", "create","connect", "set", "record", "logger"]

connect = common.build_connect(Projection, FixedProbabilityConnector,                                synapses.StaticSynapse)

create = common.build_create(Population)

initialize = common.initialize

num_processes

rank

record = common.build_record(simulator)

reset = common.build_reset(simulator)

run_for = run

set = common.set

module examples

module pynn_brainscales.brainscales2.examples.crossbar_event_counter_read

Functions

main(int num_spikes=200, float runtime=20.)

This example shows readout of the event output counters in the routing crossbar via injected reads.

:param num_spikes: Number of spikes to inject during the experiment. :param runtime: Runtime of the experiment [ms]. :return: Difference between counter values before the experiment and after the experiment. The results are saved in a dictionary with an entry for each crossbar output.

Variables

ds = main()

level

log = pynn.logger.get("crossbar_event_counter_read")

module pynn_brainscales.brainscales2.examples.external_input

Functions

main(dict params)

Variables

cell_params = {"threshold_v_threshold": 300,"leak_v_leak": 750,"leak_i_bias": 420,"leak_enable_division": True,"reset_v_reset": 200,"reset_i_bias": 950,"reset_enable_multiplication": True,"threshold_enable": True,"membrane_capacitance_capacitance": 4,"refractory_period_refractory_time": 250,"excitatory_input_enable": True,"excitatory_input_i_bias_tau": 150,"excitatory_input_i_bias_gm": 200,# FIXME: replace by i_drop_input and i_shift_reference# "excitatory_input_v_syn": 700}

level

log = pynn.logger.get("external_input")

spiketimes = main(cell_params)

module pynn_brainscales.brainscales2.examples.internal_projections

Functions

main()

Variables

level

log = pynn.logger.get("internal_projections")

spikenumber = main()

module pynn_brainscales.brainscales2.examples.isi_calib

Functions

calibrate_isi(float target_isi)

get_isi(int tau_ref)

Variables

cell_params = {"threshold_v_threshold": 400,"leak_v_leak": 1022,"leak_i_bias": 950,"reset_v_reset": 400,"reset_i_bias": 950,"threshold_enable": True,"membrane_capacitance_capacitance": 32}

level

main_log = pynn.logger.get("isi_calib")

result_isi

result_tau_ref

module pynn_brainscales.brainscales2.examples.leak_over_threshold

Functions

main(dict params)

Variables

cell_params = {"threshold_v_threshold": 350,"leak_v_leak": 1022,"leak_i_bias": 320,"reset_v_reset": 400,"reset_i_bias": 950,"reset_enable_multiplication": True,"threshold_enable": True,"membrane_capacitance_capacitance": 63,"refractory_period_refractory_time": 95}

level

module pynn_brainscales.brainscales2.examples.plasticity_rule

Functions

main(dict params)

Variables

cell_params = {"threshold_v_threshold": 300,"leak_v_leak": 750,"leak_i_bias": 420,"leak_enable_division": True,"reset_v_reset": 200,"reset_i_bias": 950,"reset_enable_multiplication": True,"threshold_enable": True,"membrane_capacitance_capacitance": 4,"refractory_period_refractory_time": 250,"excitatory_input_enable": True,"excitatory_input_i_bias_tau": 150,"excitatory_input_i_bias_gm": 200,# FIXME: replace by i_drop_input and i_shift_reference# "excitatory_input_v_syn": 700}

level

log = pynn.logger.get("plasticity_rule")

spiketimes = main(cell_params)

module pynn_brainscales.brainscales2.examples.single_neuron_demo

Functions

plot_membrane_dynamics(Population population, segment_id=-1)

Plot the membrane potential of the neuron in a given population view.

Only population views of size 1 are supported. :param population: Population, membrane traces and spikes are plotted for. :param segment_id: Index of the neo segment to be plotted. Defaults to -1, encoding the last recorded segment.

Variables

exc_spiketimes = [0.01, 0.05, 0.07, 0.08]

exc_stim_pop = pynn.Population(1, SpikeSourceArray(spike_times=exc_spiketimes))

inh_spiketimes = [0.03]

inh_stim_pop = pynn.Population(1, SpikeSourceArray(spike_times=inh_spiketimes))

level

logger = pynn.logger.get("single_neuron_demo")

p_view = pynn.PopulationView(pop, [neuron_id])

pop = pynn.Population(1, pynn.cells.HXNeuron(# Leak potential, range: 300-1000leak_v_leak=700,# Leak conductance, range: 0-1022leak_i_bias=1022))

receptor_type

stimulated_p

synapse_type

module pynn_brainscales.brainscales2.helper

Functions

chip_from_file(str path)

Extract chip config from coco file dump.

:param path: path to file containing coco dump.

chip_from_nightly()

Extract chip config from nightly calibration.

chip_from_portable_binary(bytes data)

Convert portable binary data to chip object.

:param data: Coco list in portable binary format. :return: lola chip configuration.

get_unique_identifier()

Retrieve the unique identifier of the current chip.

Set by Slurm when allocating resources.

nightly_calib_path()

Find path for nightly calibration.

nightly_calib_url()

Find url for nightly calibration.

module plasticity_rules

module populations

module projections

module recording

module pynn_brainscales.brainscales2.simulator

Variables

name = "HX"

namespace std

STL namespace.

module synapses

file __init__.py

file __init__.py

file __init__.py

file crossbar_event_counter_read.py

file external_input.py

file internal_projections.py

file isi_calib.py

file leak_over_threshold.py

file plasticity_rule.py

file single_neuron_demo.py

file helper.py

file plasticity_rules.py

file populations.py

file projections.py

file recording.py

file simulator.py

file cells.py

file synapses.py

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/pynn-brainscales/brainscales2

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/pynn-brainscales/brainscales2/pynn_brainscales/brainscales2

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/pynn-brainscales/brainscales2/pynn_brainscales/brainscales2/examples

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/pynn-brainscales

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/pynn-brainscales/brainscales2/pynn_brainscales

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/pynn-brainscales/brainscales2/pynn_brainscales/brainscales2/standardmodels