def test_build_connect():
projection_class = Mock()
connector_class = Mock(return_value="connector")
syn_class = Mock(return_value="syn")
connect_function = common.build_connect(projection_class, connector_class,
syn_class)
assert isfunction(connect_function)
prj = connect_function("source", "target", "weight", "delay",
"receptor_type", "p", "rng")
syn_class.assert_called_with(weight="weight", delay="delay")
connector_class.assert_called_with(p_connect="p", rng="rng")
projection_class.assert_called_with("source",
"target",
"connector",
synapse_type="syn",
receptor_type="receptor_type")
class MockID(common.IDMixin):
def as_view(self):
return "view"
prj = connect_function(MockID(), MockID(), "weight", "delay",
"receptor_type", "p", "rng")
projection_class.assert_called_with("view",
"view",
"connector",
synapse_type="syn",
receptor_type="receptor_type")
def _create_overloaded_functions(spinnaker_simulator):
""" Creates functions that the main PyNN interface supports\
(given from PyNN)
:param spinnaker_simulator: the simulator object we use underneath
:rtype: None
"""
# overload the failed ones with now valid ones, now that we're in setup
# phase.
__pynn["run"], __pynn["run_until"] = pynn_common.build_run(
spinnaker_simulator)
__pynn["get_current_time"], __pynn["get_time_step"], \
__pynn["get_min_delay"], __pynn["get_max_delay"], \
__pynn["num_processes"], __pynn["rank"] = \
pynn_common.build_state_queries(spinnaker_simulator)
__pynn["reset"] = pynn_common.build_reset(spinnaker_simulator)
__pynn["create"] = pynn_common.build_create(Population)
__pynn["connect"] = pynn_common.build_connect(Projection,
FixedProbabilityConnector,
StaticSynapse)
__pynn["record"] = pynn_common.build_record(spinnaker_simulator)
def test_build_connect():
projection_class = Mock()
connector_class = Mock(return_value="connector")
connect_function = common.build_connect(projection_class, connector_class)
assert isfunction(connect_function)
prj = connect_function("source", "target", "weight", "delay", "synapse_type", "p", "rng")
connector_class.assert_called_with(p_connect="p", weights="weight", delays="delay")
projection_class.assert_called_with("source", "target", "connector", target="synapse_type", rng="rng")
class MockID(common.IDMixin):
def as_view(self):
return "view"
prj = connect_function(MockID(), MockID(), "weight", "delay", "synapse_type", "p", "rng")
projection_class.assert_called_with("view", "view", "connector", target="synapse_type", rng="rng")
def end(compatible_output=True):
"""Do any necessary cleaning up before exiting."""
for (population, variables, filename) in simulator.state.write_on_end:
io = get_io(filename)
population.write_data(io, variables)
simulator.state.write_on_end = []
# should have common implementation of end()
run, run_until = common.build_run(simulator)
run_for = run
reset = common.build_reset(simulator)
initialize = common.initialize
get_current_time, get_time_step, get_min_delay, get_max_delay, \
num_processes, rank = common.build_state_queries(simulator)
create = common.build_create(Population)
connect = common.build_connect(Projection, FixedProbabilityConnector, StaticSynapse)
record = common.build_record(simulator)
record_v = lambda source, filename: record(['v'], source, filename)
record_gsyn = lambda source, filename: record(['gsyn_exc', 'gsyn_inh'], source, filename)
synapse_object = target._cell.esyn
elif self.synapse_type == "inhibitory":
synapse_object = target._cell.isyn
else:
synapse_object = getattr(target._cell, self.synapse_type)
source._cell.source.connect('event', synapse_object, 'synapse')
synapse_object.n_incoming_connections += 1
index = synapse_object.n_incoming_connections - 1
synapse_object.setWeight(index, weight)
synapse_object.setDelay(index, delay)
self.connections.append((source, target, index))
# ==============================================================================
# Low-level API for creating, connecting and recording from individual neurons
# ==============================================================================
create = common.build_create(Population)
connect = common.build_connect(Projection, FixedProbabilityConnector)
set = common.set
record = common.build_record('spikes', simulator)
record_v = common.build_record('v', simulator)
record_gsyn = common.build_record('gsyn', simulator)
# ==============================================================================
def end(compatible_output=True):
"""Do any necessary cleaning up before exiting."""
for (population, variables, filename) in simulator.state.write_on_end:
io = get_io(filename)
population.write_data(io, variables)
simulator.state.write_on_end = []
# should have common implementation of end()
run, run_until = common.build_run(simulator)
run_for = run
reset = common.build_reset(simulator)
initialize = common.initialize
get_current_time, get_time_step, get_min_delay, get_max_delay, \
num_processes, rank = common.build_state_queries(simulator)
create = common.build_create(Population)
connect = common.build_connect(Projection, FixedProbabilityConnector,
StaticSynapse)
record = common.build_record(simulator)
record_v = lambda source, filename: record(['v'], source, filename)
record_gsyn = lambda source, filename: record(['gsyn_exc', 'gsyn_inh'], source,
filename)
