def do_run(plot): p.setup(timestep=1.0) cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -40.0 } # Parameters n = 256 weight_to_spike = 5.0 delay = 5 runtime = 200 # Populations exc_pop = p.Population(n, p.IF_curr_exp(**cell_params_lif), label='exc_pop') inh_pop = p.Population(n, p.IF_curr_exp(**cell_params_lif), label='inh_pop') # SpikeInjector injectionConnection = [(0, 0)] spikeArray = {'spike_times': [[0]]} inj_pop = p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1') # Projection for injector p.Projection(inj_pop, exc_pop, p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=delay)) # Set up fromfileconnector current_file_path = os.path.dirname(os.path.abspath(__file__)) file1 = os.path.join(current_file_path, "large.connections") file_connector1 = p.FromFileConnector(file1) # Projections between populations p.Projection(exc_pop, inh_pop, file_connector1, p.StaticSynapse(weight=2.0, delay=5)) p.Projection(inh_pop, exc_pop, file_connector1, p.StaticSynapse(weight=1.5, delay=10)) p.Projection(inh_pop, exc_pop, file_connector1, p.StaticSynapse(weight=1.0, delay=1)) exc_pop.record(['v', 'spikes']) inh_pop.record(['v', 'spikes']) p.run(runtime) v_exc = exc_pop.get_data('v') spikes_exc = exc_pop.get_data('spikes') if plot: # pylint: disable=no-member Figure( # raster plot of the presynaptic neurons' spike times Panel(spikes_exc.segments[0].spiketrains, yticks=True, markersize=1.2, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neurons Panel(v_exc.segments[0].filter(name='v')[0], ylabel="Membrane potential (mV)", data_labels=[exc_pop.label], yticks=True, xlim=(0, runtime), xticks=True), title="Testing FromFileConnector", annotations="Simulated with {}".format(p.name()) ) plt.show() p.end() return v_exc, spikes_exc
projections.append( p.Projection(populations[0], populations[0], p.FromListConnector(loopConnections))) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection))) populations[0].record('spikes') # Activate live output for the population p.external_devices.activate_live_output_for(populations[0], database_notify_host="localhost", database_notify_port_num=19999) # Start the simulation p.run(5000) spikes = populations[0].get_data("spikes") Figure( # raster plot of the presynaptic neuron spike times Panel(spikes.segments[0].spiketrains, yticks=True, markersize=0.2, xlim=(0, 5000)), title="Simple synfire chain example with injected spikes", annotations="Simulated with {}".format(p.name())) plt.show() p.end()
def do_run(plot): p.setup(timestep=1.0) cell_params_lif = { 'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } # Parameters nNeurons = 200 weight_to_spike = 2.0 delay = 17 runtime = 5000 p.set_number_of_neurons_per_core(p.IF_curr_exp, nNeurons / 2) # Populations pop = p.Population(nNeurons, p.IF_curr_exp(**cell_params_lif), label='pop_1') pop2 = p.Population(nNeurons, p.IF_curr_exp(**cell_params_lif), label='pop_2') # create loopConnections array for first population using numpy linspaces loopConnections = numpy.zeros((nNeurons, nNeurons)) for i in range(nNeurons): if i != (nNeurons - 1): loopConnections[i, i + 1] = True else: loopConnections[i, 0] = True # do the same for the second population, but just for even numbered neurons loopConnections2 = numpy.zeros((nNeurons, nNeurons)) for i in range(0, nNeurons, 2): if i != (nNeurons - 2): loopConnections2[i, i + 2] = True else: loopConnections2[i, 0] = True # SpikeInjector injectionConnection = numpy.zeros((1, nNeurons)) injectionConnection[0, 0] = True spikeArray = {'spike_times': [[0]]} inj_pop = p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1') # Projection for injector p.Projection(inj_pop, pop, p.ArrayConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=1)) p.Projection(inj_pop, pop2, p.ArrayConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=1)) # Projection within populations p.Projection(pop, pop, p.ArrayConnector(loopConnections), p.StaticSynapse(weight=weight_to_spike, delay=delay)) p.Projection(pop2, pop2, p.ArrayConnector(loopConnections2), p.StaticSynapse(weight=weight_to_spike, delay=delay)) pop.record(['v', 'spikes']) pop2.record(['v', 'spikes']) p.run(runtime) v = pop.get_data('v') spikes = pop.get_data('spikes') v2 = pop2.get_data('v') spikes2 = pop2.get_data('spikes') if plot: Figure( # raster plot of the presynaptic neurons' spike times Panel(spikes.segments[0].spiketrains, yticks=True, markersize=1.2, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neurons Panel(v.segments[0].filter(name='v')[0], ylabel="Membrane potential (mV)", data_labels=[pop.label], yticks=True, xlim=(0, runtime), xticks=True), Panel(spikes2.segments[0].spiketrains, yticks=True, markersize=1.2, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neurons Panel(v2.segments[0].filter(name='v')[0], ylabel="Membrane potential (mV)", data_labels=[pop2.label], yticks=True, xlim=(0, runtime), xticks=True), title="Testing ArrayConnector", annotations="Simulated with {}".format(p.name())) plt.show() p.end() return v, spikes, v2, spikes2
# Set up callbacks to occur when spikes are received live_spikes_connection_receive.add_receive_callback( "pop_forward", receive_spikes) live_spikes_connection_receive.add_receive_callback( "pop_backward", receive_spikes) # Run the simulation on spiNNaker Frontend.run(run_time) spikes_forward = pop_forward.get_data('spikes') spikes_backward = pop_backward.get_data('spikes') Figure( # raster plot of the presynaptic neuron spike times Panel(spikes_forward.segments[0].spiketrains, yticks=True, markersize=0.2, xlim=(0, run_time)), Panel(spikes_backward.segments[0].spiketrains, yticks=True, markersize=0.2, xlim=(0, run_time)), title="Simple synfire chain example with injected spikes", annotations="Simulated with {}".format(Frontend.name())) plt.show() # Clear data structures on spiNNaker to leave the machine in a clean state for # future executions Frontend.end()
def do_run(plot): p.setup(timestep=1.0) cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -40.0 } def create_grid(n, label, dx=1.0, dy=1.0): grid_structure = p.Grid2D(dx=dx, dy=dy, x0=0.0, y0=0.0) return p.Population(n*n, p.IF_curr_exp(**cell_params_lif), structure=grid_structure, label=label) n = 4 weight_to_spike = 5.0 delay = 5 runtime = 200 # Network grid = create_grid(n, 'grid') # SpikeInjector injectionConnection = [(0, 0)] spikeArray = {'spike_times': [[0]]} inj_pop = p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1') p.Projection(inj_pop, grid, p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=delay)) # Connectors exc_connector = p.AllToAllConnector() inh_connector = p.FixedProbabilityConnector(0.5, rng=NumpyRNG(seed=10101)) # Wire grid exc_proj = p.Projection(grid, grid, exc_connector, p.StaticSynapse( weight="1.0 + (2.0*exp(-d))", delay=5)) inh_proj = p.Projection(grid, grid, inh_connector, p.StaticSynapse( weight=1.5, delay="2 + 2.0*d")) grid.record(['v', 'spikes']) p.run(runtime) v = grid.get_data('v') spikes = grid.get_data('spikes') exc_weights_delays = exc_proj.get(['weight', 'delay'], 'list') inh_weights_delays = inh_proj.get(['weight', 'delay'], 'list') if plot: Figure( # raster plot of the presynaptic neurons' spike times Panel(spikes.segments[0].spiketrains, yticks=True, markersize=0.2, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neurons Panel(v.segments[0].filter(name='v')[0], ylabel="Membrane potential (mV)", data_labels=[grid.label], yticks=True, xlim=(0, runtime), xticks=True), title="Simple 2D grid distance-dependent weights and delays", annotations="Simulated with {}".format(p.name()) ) plt.show() p.end() return exc_weights_delays, inh_weights_delays
def __init__(self): # initial call to set up the front end (pynn requirement) Frontend.setup(timestep=1.0, min_delay=1.0, max_delay=144.0) use_c_visualiser = True use_spike_injector = True # neurons per population and the length of runtime in ms for the # simulation, as well as the expected weight each spike will contain self.n_neurons = 100 # set up gui p = None if use_spike_injector: from multiprocessing import Process from multiprocessing import Event ready = Event() p = Process(target=GUI, args=[self.n_neurons, ready]) p.start() ready.wait() # different runtimes for demostration purposes run_time = None if not use_c_visualiser and not use_spike_injector: run_time = 1000 elif use_c_visualiser and not use_spike_injector: run_time = 10000 elif use_c_visualiser and use_spike_injector: run_time = 100000 elif not use_c_visualiser and use_spike_injector: run_time = 10000 weight_to_spike = 2.0 # neural parameters of the IF_curr model used to respond to injected # spikes. # (cell params for a synfire chain) cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } ################################## # Parameters for the injector population. This is the minimal set of # parameters required, which is for a set of spikes where the key is # not important. Note that a virtual key *will* be assigned to the # population, and that spikes sent which do not match this virtual key # will be dropped; however, if spikes are sent using 16-bit keys, they # will automatically be made to match the virtual key. The virtual # key assigned can be obtained from the database. ################################## cell_params_spike_injector = { # The port on which the spiNNaker machine should listen for # packets. Packets to be injected should be sent to this port on # the spiNNaker machine 'port': 12345 } ################################## # Parameters for the injector population. Note that each injector # needs to be given a different port. The virtual key is assigned # here, rather than being allocated later. As with the above, spikes # injected need to match this key, and this will be done automatically # with 16-bit keys. ################################## cell_params_spike_injector_with_key = { # The port on which the spiNNaker machine should listen for # packets. Packets to be injected should be sent to this port on # the spiNNaker machine 'port': 12346, # This is the base key to be used for the injection, which is used # to allow the keys to be routed around the spiNNaker machine. # This assignment means that 32-bit keys must have the high-order # 16-bit set to 0x7; This will automatically be prepended to # 16-bit keys. 'virtual_key': 0x70000 } # create synfire populations (if cur exp) pop_forward = Frontend.Population( self.n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_forward') pop_backward = Frontend.Population( self.n_neurons, Frontend.IF_curr_exp(**cell_params_lif), label='pop_backward') # Create injection populations injector_forward = None injector_backward = None if use_spike_injector: injector_forward = Frontend.Population( self.n_neurons, Frontend.external_devices.SpikeInjector( **cell_params_spike_injector_with_key), label='spike_injector_forward') injector_backward = Frontend.Population( self.n_neurons, Frontend.external_devices.SpikeInjector( **cell_params_spike_injector), label='spike_injector_backward') else: spike_times = [] for _ in range(0, self.n_neurons): spike_times.append([]) spike_times[0] = [0] spike_times[20] = [(run_time / 100) * 20] spike_times[40] = [(run_time / 100) * 40] spike_times[60] = [(run_time / 100) * 60] spike_times[80] = [(run_time / 100) * 80] cell_params_forward = {'spike_times': spike_times} spike_times_backwards = [] for _ in range(0, self.n_neurons): spike_times_backwards.append([]) spike_times_backwards[0] = [(run_time / 100) * 80] spike_times_backwards[20] = [(run_time / 100) * 60] spike_times_backwards[40] = [(run_time / 100) * 40] spike_times_backwards[60] = [(run_time / 100) * 20] spike_times_backwards[80] = [0] cell_params_backward = {'spike_times': spike_times_backwards} injector_forward = Frontend.Population( self.n_neurons, Frontend.SpikeSourceArray( **cell_params_forward), label='spike_injector_forward') injector_backward = Frontend.Population( self.n_neurons, Frontend.SpikeSourceArray( **cell_params_backward), label='spike_injector_backward') # Create a connection from the injector into the populations Frontend.Projection( injector_forward, pop_forward, Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=weight_to_spike)) Frontend.Projection( injector_backward, pop_backward, Frontend.OneToOneConnector(), Frontend.StaticSynapse(weight=weight_to_spike)) # Synfire chain connections where each neuron is connected to its next # neuron # NOTE: there is no recurrent connection so that each chain stops once # it reaches the end loop_forward = list() loop_backward = list() for i in range(0, self.n_neurons - 1): loop_forward.append((i, (i + 1) % self.n_neurons, weight_to_spike, 3)) loop_backward.append(((i + 1) % self.n_neurons, i, weight_to_spike, 3)) Frontend.Projection(pop_forward, pop_forward, Frontend.FromListConnector(loop_forward)) Frontend.Projection(pop_backward, pop_backward, Frontend.FromListConnector(loop_backward)) # record spikes from the synfire chains so that we can read off valid # results in a safe way afterwards, and verify the behavior pop_forward.record('spikes') pop_backward.record('spikes') # Activate the sending of live spikes Frontend.external_devices.activate_live_output_for( pop_forward, database_notify_host="localhost", database_notify_port_num=19996) Frontend.external_devices.activate_live_output_for( pop_backward, database_notify_host="localhost", database_notify_port_num=19996) if not use_c_visualiser: # if not using the c visualiser, then a new spynnaker live spikes # connection is created to define that there are python code which # receives the outputted spikes. live_spikes_connection_receive = \ Frontend.external_devices.SpynnakerLiveSpikesConnection( receive_labels=["pop_forward", "pop_backward"], local_port=19999, send_labels=None) # Set up callbacks to occur when spikes are received live_spikes_connection_receive.add_receive_callback( "pop_forward", receive_spikes) live_spikes_connection_receive.add_receive_callback( "pop_backward", receive_spikes) # Run the simulation on spiNNaker Frontend.run(run_time) # Retrieve spikes from the synfire chain population spikes_forward = pop_forward.get_data('spikes') spikes_backward = pop_backward.get_data('spikes') # Clear data structures on spiNNaker to leave the machine in a clean # state for future executions Frontend.end() if use_spike_injector: p.join() Figure( # raster plot of the presynaptic neuron spike times Panel(spikes_forward.segments[0].spiketrains, yticks=True, markersize=0.2, xlim=(0, run_time)), Panel(spikes_backward.segments[0].spiketrains, yticks=True, markersize=0.2, xlim=(0, run_time)), title="Simple synfire chain example with injected spikes", annotations="Simulated with {}".format(Frontend.name()) ) plt.show()
def do_run(plot): p.setup(timestep=1.0) cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -40.0 } # Parameters n = 6 weight_to_spike = 3.0 delay = 2 runtime = 200 # Network population pop_1 = p.Population(n, p.IF_curr_exp(**cell_params_lif), label='pop_1') pop_2 = p.Population(n/2, p.IF_curr_exp(**cell_params_lif), label='pop_2') # SpikeInjector injectionConnection = [(0, n/2)] spikeArray = {'spike_times': [[0]]} inj_pop = p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1') # Projection for injector p.Projection(inj_pop, pop_1, p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=delay)) # Index-based connectors index_based_exc = "(i+j)/"+str(n*(n-n/2.0)) index_based_exc2 = "2.0*(i+j)/"+str(n*(n-n/2.0)) index_based_inh = "(i+j)/"+str(n*(n+n/2.0)) print('index_based_exc: ', index_based_exc) print('index_based_exc2: ', index_based_exc2) exc_connector = p.IndexBasedProbabilityConnector( index_based_exc, allow_self_connections=True) inh_connector = p.IndexBasedProbabilityConnector( index_based_inh, allow_self_connections=False) exc_connector2 = p.IndexBasedProbabilityConnector( index_based_exc2, allow_self_connections=True) # Projections within populations p.Projection(pop_1, pop_1, exc_connector, p.StaticSynapse(weight=2.0, delay=5)) p.Projection(pop_1, pop_1, inh_connector, p.StaticSynapse(weight=1.5, delay=5)) p.Projection(pop_1, pop_2, exc_connector2, p.StaticSynapse(weight=1.5, delay=2)) pop_1.record(['v', 'spikes']) pop_2.record(['v', 'spikes']) p.run(runtime) v = pop_1.get_data('v') spikes = pop_1.get_data('spikes') v2 = pop_2.get_data('v') spikes2 = pop_2.get_data('spikes') if plot: Figure( # raster plot of the presynaptic neurons' spike times Panel(spikes.segments[0].spiketrains, yticks=True, markersize=2.0, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neurons Panel(v.segments[0].filter(name='v')[0], ylabel="Membrane potential pop 1 (mV)", data_labels=[pop_1.label], yticks=True, xlim=(0, runtime), xticks=True), # raster plot of the presynaptic neurons' spike times Panel(spikes2.segments[0].spiketrains, yticks=True, markersize=2.0, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neurons Panel(v2.segments[0].filter(name='v')[0], ylabel="Membrane potential pop 2 (mV)", data_labels=[pop_2.label], yticks=True, xlim=(0, runtime), xticks=True), title="Simple index-based probability connector", annotations="Simulated with {}".format(p.name()) ) plt.show() p.end() return v, spikes, v2, spikes2
# Synapse value as weight = 5.0 nA, delay = 2 ms static_synapse = sim.StaticSynapse( weight = 5.0, delay = 2 ) sim.Projection( pop_input, pop_output, sim.OneToOneConnector(), synapse_type = static_synapse, label = "LIF - alpha function Projection" ) # == Instrument the network ==================================================== # Record all to observe. pop_output.record( "all" ) # === Run the simulation ======================================================= sim.run( sim_time ) # === Plot the results ========================================================= from util.basic_visualizer import * plot( [pop_output], "IF_curr_alpha Neuron Model Examination", "Simulated with {}".format( sim.name() ) ) # === Clean up and quit ======================================================== sim.end()
def do_run(plot): p.setup(timestep=1.0) cell_params_lif = { 'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } def create_grid(n, label, dx=1.0, dy=1.0): grid_structure = p.Grid2D(dx=dx, dy=dy, x0=0.0, y0=0.0) return p.Population(n * n, p.IF_curr_exp(**cell_params_lif), structure=grid_structure, label=label) # Parameters n = 5 weight_to_spike = 2.0 delay = 2 runtime = 1000 p.set_number_of_neurons_per_core(p.IF_curr_exp, 100) # Network population small_world = create_grid(n, 'small_world') # SpikeInjector injectionConnection = [(0, 0)] spikeArray = {'spike_times': [[0]]} inj_pop = p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1') # Injector projection p.Projection(inj_pop, small_world, p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=delay)) # Connectors degree = 2.0 rewiring = 0.4 small_world_connector = p.SmallWorldConnector(degree, rewiring) # Projection for small world grid sw_pro = p.Projection(small_world, small_world, small_world_connector, p.StaticSynapse(weight=2.0, delay=5)) small_world.record(['v', 'spikes']) p.run(runtime) v = small_world.get_data('v') spikes = small_world.get_data('spikes') weights = sw_pro.get('weight', 'list') if plot: Figure( # raster plot of the presynaptic neuron spike times Panel(spikes.segments[0].spiketrains, yticks=True, markersize=0.2, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neuron Panel(v.segments[0].filter(name='v')[0], ylabel="Membrane potential (mV)", data_labels=[small_world.label], yticks=True, xlim=(0, runtime), xticks=True), title="Simple small world connector", annotations="Simulated with {}".format(p.name())) plt.show() p.end() return v, spikes, weights
def do_run(plot): p.setup(timestep=1.0) cell_params_lif = { 'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -40.0 } def create_grid(n, label, dx=1.0, dy=1.0): grid_structure = p.Grid2D(dx=dx, dy=dy, x0=0.0, y0=0.0) return p.Population(n * n, p.IF_curr_exp(**cell_params_lif), structure=grid_structure, label=label) # Parameters n = 10 weight_to_spike = 5.0 delay = 5 runtime = 200 # Network population grid = create_grid(n, 'grid') # SpikeInjector injectionConnection = [(0, n * n // 2)] spikeArray = {'spike_times': [[5]]} inj_pop = p.Population(1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1') projections = list() # Projection for injector projections.append( p.Projection(inj_pop, grid, p.FromListConnector(injectionConnection), p.StaticSynapse(weight=weight_to_spike, delay=delay))) # Simple connectors dist_dep_exc = "d<2.1" dist_dep_inh = "d<1.1" exc_connector = p.DistanceDependentProbabilityConnector( dist_dep_exc, allow_self_connections=True) inh_connector = p.DistanceDependentProbabilityConnector( dist_dep_inh, allow_self_connections=True) # Projections within grid projections.append( p.Projection(grid, grid, exc_connector, p.StaticSynapse(weight=5.0, delay=10), receptor_type='excitatory')) projections.append( p.Projection(grid, grid, inh_connector, p.StaticSynapse(weight=2.0, delay=10), receptor_type='inhibitory')) pre_weights = list() for projection in projections: pre_weights.append(projection.get('weight', 'list')) grid.record(['v', 'spikes']) inj_pop.record(['spikes']) p.run(runtime) v = grid.get_data('v') spikes = grid.get_data('spikes') stim_spikes = inj_pop.get_data('spikes') if plot: Figure( # raster plot of the stimulus spike times Panel(stim_spikes.segments[0].spiketrains, yticks=True, markersize=1.5, xlim=(0, runtime), xticks=True), # raster plot of the presynaptic neurons' spike times Panel(spikes.segments[0].spiketrains, yticks=True, markersize=0.2, xlim=(0, runtime), xticks=True), # membrane potential of the postsynaptic neurons Panel(v.segments[0].filter(name='v')[0], ylabel="Membrane potential (mV)", data_labels=[grid.label], yticks=True, xlim=(0, runtime), xticks=True), title="Simple grid distance-dependent prob connector", annotations="Simulated with {}".format(p.name())) plt.show() post_weights = list() for projection in projections: post_weights.append(projection.get('weight', 'list')) p.end() return v, spikes, pre_weights, post_weights