def test_tf_change_locals(self): @nrp.MapVariable("shared_var", initial_value=2) @nrp.Neuron2Robot(Topic("/vars/shared1", float)) def echo_shared_var(t, shared_var): shared_var.value = shared_var.value + t return shared_var.value @nrp.MapVariable("shared_var", initial_value=5) @nrp.Neuron2Robot(Topic("/vars/shared2", float)) def echo_shared_var2(t, shared_var): shared_var.value = shared_var.value - t return shared_var.value nrp.initialize("MyTransferFunctions") topic1 = echo_shared_var.topic topic2 = echo_shared_var2.topic config.active_node.run_neuron_to_robot(1) config.active_node.run_robot_to_neuron(1) config.active_node.run_neuron_to_robot(2) config.active_node.run_robot_to_neuron(2) self.assertEqual(len(topic1.sent), 2) self.assertEqual(len(topic2.sent), 2) self.assertListEqual(topic1.sent, [3, 5]) self.assertListEqual(topic2.sent, [4, 2])
def test_tf_delete(self, mock_cleanup): nrp.start_new_tf_manager() brain = MockBrainCommunicationAdapter() robot = MockRobotCommunicationAdapter() config.active_node.brain_adapter = brain nrp.set_nest_adapter(brain) nrp.set_robot_adapter(robot) @nrp.MapCSVRecorder("recorder1", filename = "1", headers=["Name", "time", "Position"]) @nrp.MapSpikeSink("neuron0", nrp.brain.actors[slice(0, 2, 1)], nrp.leaky_integrator_alpha, v_rest=1.0, updates=[(1.0, 0.3)]) @nrp.Neuron2Robot(Husky.RightArm.pose) def right_arm(t, neuron0, recorder1): return neuron0.voltage * 1.345 @nrp.MapCSVRecorder("recorder2", filename = "2", headers=["Name", "time", "Position"]) @nrp.MapSpikeSink("neuron1", nrp.brain.actors[slice(2, 4, 1)], nrp.leaky_integrator_alpha, updates=[(1.0, 0.4)], v_rest=1.0) @nrp.MapSpikeSink("neuron2", nrp.brain.actors[slice(4, 6, 1)], nrp.leaky_integrator_alpha, updates=[(1.0, 0.4)], v_rest=1.0) @nrp.Neuron2Robot(Husky.LeftArm.twist) def left_arm_tw(t, neuron1, neuron2, recorder2): if neuron1.voltage < 0.678: if neuron2.voltage > 0.345: return 0.756 else: return 1.123 else: if neuron2.voltage < 0.789: return 0.632 else: return 0.256 nrp.initialize("MyTransferFunctions") # Delete an existing transfer function self.assertEqual(2, len(nrp.get_transfer_functions())) self.assertEqual(True, nrp.delete_transfer_function("left_arm_tw")) self.assertEqual(1, len(nrp.get_transfer_functions())) self.assertEqual(mock_cleanup.call_count, 1) # Try to delete it again self.assertEqual(False, nrp.delete_transfer_function("left_arm_tw")) self.assertEqual(1, len(nrp.get_transfer_functions())) # Delete another existing transfer function self.assertEqual(True, nrp.delete_transfer_function("right_arm")) self.assertEqual(0, len(nrp.get_transfer_functions())) self.assertEqual(0, len(config.active_node.brain_adapter.detector_devices)) self.assertEqual(mock_cleanup.call_count, 2)
def test_tf_globals(self): self.assertEquals(len(config.active_node.global_data), 0) @nrp.MapVariable("shared_var", initial_value=2, scope=nrp.GLOBAL) @nrp.Neuron2Robot(Topic("/vars/shared1", float)) def echo_shared_var(t, shared_var): shared_var.value = shared_var.value + t return shared_var.value @nrp.MapVariable("shared_var", scope=nrp.GLOBAL) @nrp.Neuron2Robot(Topic("/vars/shared2", float)) def echo_shared_var2(t, shared_var): shared_var.value = shared_var.value - t return shared_var.value @nrp.MapVariable("shared_var2", global_key="second_var", initial_value=5, scope=nrp.GLOBAL) @nrp.Neuron2Robot(Topic("/vars/shared3", float)) def echo_shared_var3(t, shared_var2): shared_var2.value = shared_var2.value - t return shared_var2.value nrp.initialize("MyTransferFunctions") self.assertEquals(len(config.active_node.global_data), 2) self.assertIn("shared_var", config.active_node.global_data) self.assertIn("second_var", config.active_node.global_data) topic1 = echo_shared_var.topic topic2 = echo_shared_var2.topic topic3 = echo_shared_var3.topic config.active_node.run_neuron_to_robot(1) config.active_node.run_neuron_to_robot(2) self.assertEqual(len(topic1.sent), 2) self.assertEqual(len(topic2.sent), 2) self.assertEqual(len(topic3.sent), 2) self.assertListEqual(topic1.sent, [3, 4]) self.assertListEqual(topic2.sent, [2, 2]) self.assertListEqual(topic3.sent, [4, 2])
def test_spike_recorder_monitor(self): nrp.start_new_tf_manager() self.init_adapters() @nrp.NeuronMonitor(nrp.brain.foo, nrp.spike_recorder) def my_monitor(t): return True nrp.initialize("test") my_monitor.run(42.0) msg = my_monitor.publisher.sent[-1] self.assertIsInstance(msg, SpikeEvent) self.assertEqual(msg.simulationTime, 42.0) self.assertEqual(msg.monitorName, "my_monitor") self.assertEqual(msg.neuronCount, 42) self.assertEqual(len(msg.spikes), 0) my_monitor.unregister() self.assertIsNone(my_monitor.device)
def test_population_rate_monitor(self): nrp.start_new_tf_manager() self.init_adapters() @nrp.NeuronMonitor(nrp.brain.foo, nrp.population_rate) def my_monitor(t): return True nrp.initialize("test") my_monitor.run(42.0) msg = my_monitor.publisher.sent[-1] self.assertIsInstance(msg, SpikeRate) self.assertEqual(msg.simulationTime, 42.0) self.assertEqual(msg.monitorName, "my_monitor") self.assertEqual(msg.rate, my_monitor.device.rate) my_monitor.unregister() self.assertIsNone(my_monitor.device)
def test_all_right(self): nrp.start_new_tf_manager() brain = MockBrainCommunicationAdapter() robot = MockRobotCommunicationAdapter() @nrp.MapSpikeSink("neuron0", nrp.map_neurons(range(0, 2), lambda i: nrp.brain.actors[i]), nrp.leaky_integrator_alpha, v_rest=1.0, updates=[(1.0, [0.3, 0.0])]) @nrp.Neuron2Robot(Husky.RightArm.pose) def right_arm(t, neuron0): return np.sum(neuron0.voltage) * 1.345 # Here is a another transfer function from neurons to robot messages # This time, the neuron parameter is explicitly mapped to an array of neurons # More precisely, the parameter is mapped to a group of __devices that are each connected to a single neuron # The neuron2 parameter will thus be a list of recorders @nrp.MapSpikeSink("neurons", nrp.chain_neurons(nrp.brain.actors[slice(2, 4, 1)], nrp.brain.actors[slice(4, 6, 1)]), nrp.leaky_integrator_alpha, updates=[(1.0, [0.4, 0.4])], v_rest=1.0) @nrp.Neuron2Robot(Husky.LeftArm.twist) def left_arm_tw(t, neurons): if neurons[0].voltage < 0.678: if neurons[1].voltage > 0.345: return 0.756 else: return 1.123 else: if neurons[1].voltage < 0.789: return 0.632 else: return 0.256 nrp.set_nest_adapter(brain) nrp.set_robot_adapter(robot) brain.__dict__["actors"] = MockPopulation(range(0, 60)) brain.__dict__["sensors"] = MockPopulation(range(45, 645)) config.brain_root = brain nrp.initialize("MyTransferFunctions") husky_right_arm = right_arm.topic husky_left_arm = left_arm_tw.topic brain.refresh_buffers(0.5) robot.refresh_buffers(0.5) config.active_node.run_neuron_to_robot(0.5) config.active_node.run_robot_to_neuron(0.5) brain.refresh_buffers(1.5) robot.refresh_buffers(1.5) config.active_node.run_neuron_to_robot(1.5) config.active_node.run_robot_to_neuron(1.5) self.assertIsInstance(husky_right_arm, MockPublishedTopic) self.assertIsInstance(husky_left_arm, MockPublishedTopic) self.assertEqual(len(husky_right_arm.sent), 2) self.assertEqual(len(husky_left_arm.sent), 2) self.assertEqual(husky_right_arm.sent[0], 1.345 * 2.0) self.assertEqual(husky_right_arm.sent[1], 1.345 * 0.3) self.assertEqual(husky_left_arm.sent[0], 0.256) self.assertEqual(husky_left_arm.sent[1], 0.756) config.active_node.reset()
def test_all_right(self): nrp.start_new_tf_manager() brain = MockBrainCommunicationAdapter() robot = MockRobotCommunicationAdapter() @nrp.MapSpikeSink("neuron0", nrp.brain.actors[slice(0, 2, 1)], nrp.leaky_integrator_alpha, v_rest=1.0, updates=[(1.0, 0.3)]) @nrp.Neuron2Robot(Husky.RightArm.pose) def right_arm(t, neuron0): return neuron0.voltage * 1.345 @nrp.MapSpikeSink("neuron1", nrp.brain.actors[slice(2, 4, 1)], nrp.leaky_integrator_alpha, updates=[(1.0, 0.4)], v_rest=1.0) @nrp.MapSpikeSink("neuron2", nrp.brain.actors[slice(4, 6, 1)], nrp.leaky_integrator_alpha, updates=[(1.0, 0.4)], v_rest=1.0) @nrp.Neuron2Robot(Husky.LeftArm.twist) def left_arm_tw(t, neuron1, neuron2): if neuron1.voltage < 0.678: if neuron2.voltage > 0.345: return 0.756 else: return 1.123 else: if neuron2.voltage < 0.789: return 0.632 else: return 0.256 # Here is an example of a transfer function mapping robot sensor data to spikes # As the image processing is a common task, this is done through a specialized # device in the neuronal simulator. However, this device might not be mapped to # physical Nest device, but do some processing internally and use a less specialized # device type internally @nrp.MapRobotSubscriber("camera", Husky.Eye.camera) @nrp.MapSpikeSource("camera_device", nrp.brain.sensors[slice(0, 600, 1)], TestDevice()) @nrp.Robot2Neuron() def transform_camera(t, camera, camera_device): if camera.changed: camera_device.inner.amplitude = 42.0 nrp.set_nest_adapter(brain) nrp.set_robot_adapter(robot) brain.__dict__["actors"] = MockPopulation(range(0, 60)) brain.__dict__["sensors"] = MockPopulation(range(45, 645)) config.brain_root = brain nrp.initialize("MyTransferFunctions") husky_right_arm = right_arm.topic husky_left_arm = left_arm_tw.topic camera = transform_camera.camera camera_device = transform_camera.camera_device brain.refresh_buffers(0.5) robot.refresh_buffers(0.5) config.active_node.run_neuron_to_robot(0.5) config.active_node.run_robot_to_neuron(0.5) camera.value = "Definitely not an image" brain.refresh_buffers(1.5) robot.refresh_buffers(1.5) config.active_node.run_neuron_to_robot(1.5) config.active_node.run_robot_to_neuron(1.5) assert isinstance(husky_right_arm, MockPublishedTopic) assert isinstance(husky_left_arm, MockPublishedTopic) assert len(husky_right_arm.sent) == 2 assert len(husky_left_arm.sent) == 2 assert husky_right_arm.sent[0] == 1.345 assert husky_right_arm.sent[1] == 1.345 * 0.3 assert husky_left_arm.sent[0] == 0.256 assert husky_left_arm.sent[1] == 0.756 assert camera_device.inner.amplitude == 42.0 config.active_node.reset()