class TaborMemoryReadTests(TaborSimulatorBasedTest): def setUp(self): super().setUp() ramp_up = np.linspace(0, 2**14-1, num=192, dtype=np.uint16) ramp_down = ramp_up[::-1] zero = np.ones(192, dtype=np.uint16) * 2**13 sine = ((np.sin(np.linspace(0, 2*np.pi, 192+64)) + 1) / 2 * (2**14 - 1)).astype(np.uint16) self.segments = [TaborSegment.from_sampled(ramp_up, ramp_up, None, None), TaborSegment.from_sampled(ramp_down, zero, None, None), TaborSegment.from_sampled(sine, sine, None, None)] self.zero_segment = TaborSegment.from_sampled(zero, zero, None, None) # program 1 self.sequence_tables_raw = [[(10, 0, 0), (10, 1, 0), (10, 0, 0), (10, 1, 0)], [(1, 0, 0), (1, 1, 0), (1, 0, 0), (1, 1, 0)]] self.advanced_sequence_table = [(1, 1, 0), (1, 2, 0)] self.sequence_tables = self.to_new_sequencer_tables(self.sequence_tables_raw) self.advanced_sequence_table = self.to_new_advanced_sequencer_table(self.advanced_sequence_table) self.channel_pair = TaborChannelPair(self.instrument, (1, 2), 'tabor_unit_test') def arm_program(self, sequencer_tables, advanced_sequencer_table, mode, waveform_to_segment_index): class DummyProgram: @staticmethod def get_sequencer_tables(): return sequencer_tables @staticmethod def get_advanced_sequencer_table(): return advanced_sequencer_table @staticmethod def update_volatile_parameters(parameters): modifications = {1: TableEntry(repetition_count=5, element_number=2, jump_flag=0), (0, 1): TableDescription(repetition_count=50, element_id=1, jump_flag=0)} return modifications markers = (None, None) channels = (1, 2) waveform_mode = mode self.channel_pair._known_programs['dummy_program'] = (waveform_to_segment_index, DummyProgram) self.channel_pair.change_armed_program('dummy_program') def test_read_waveforms(self): self.channel_pair._amend_segments(self.segments) waveforms = self.channel_pair.read_waveforms() segments = [TaborSegment.from_binary_segment(waveform) for waveform in waveforms] expected = [self.zero_segment, *self.segments] for ex, r in zip(expected, segments): ex1, ex2 = ex.data_a, ex.data_b r1, r2 = r.data_a, r.data_b np.testing.assert_equal(ex1, r1) np.testing.assert_equal(ex2, r2) self.assertEqual(expected, segments) def test_read_sequence_tables(self): self.channel_pair._amend_segments(self.segments) self.arm_program(self.sequence_tables, self.advanced_sequence_table, None, np.asarray([1, 2])) sequence_tables = self.channel_pair.read_sequence_tables() actual_sequence_tables = [self.channel_pair._idle_sequence_table] + [[(rep, index+2, jump) for rep, index, jump in table] for table in self.sequence_tables_raw] expected = list(tuple(np.asarray(d) for d in zip(*table)) for table in actual_sequence_tables) np.testing.assert_equal(sequence_tables, expected) def test_read_advanced_sequencer_table(self): self.channel_pair._amend_segments(self.segments) self.arm_program(self.sequence_tables, self.advanced_sequence_table, None, np.asarray([1, 2])) actual_advanced_table = [(1, 1, 1)] + [(rep, idx+1, jmp) for rep, idx, jmp in self.advanced_sequence_table] expected = list(np.asarray(d) for d in zip(*actual_advanced_table)) advanced_table = self.channel_pair.read_advanced_sequencer_table() np.testing.assert_equal(advanced_table, expected) def test_set_volatile_parameter(self): self.channel_pair._amend_segments(self.segments) self.arm_program(self.sequence_tables, self.advanced_sequence_table, None, np.asarray([1, 2])) para = {'a': 5} actual_sequence_tables = [self.channel_pair._idle_sequence_table] + [[(rep, index + 2, jump) for rep, index, jump in table] for table in self.sequence_tables_raw] actual_advanced_table = [(1, 1, 1)] + [(rep, idx + 1, jmp) for rep, idx, jmp in self.advanced_sequence_table] self.channel_pair.set_volatile_parameters('dummy_program', parameters=para) actual_sequence_tables[1][1] = (50, 3, 0) actual_advanced_table[2] = (5, 3, 0) sequence_table = self.channel_pair.read_sequence_tables() expected = list(tuple(np.asarray(d) for d in zip(*table)) for table in actual_sequence_tables) np.testing.assert_equal(sequence_table, expected) advanced_table = self.channel_pair.read_advanced_sequencer_table() expected = list(np.asarray(d) for d in zip(*actual_advanced_table)) np.testing.assert_equal(advanced_table, expected)
def test_set_volatile_parameters(self): channel_pair = TaborChannelPair(self.instrument, identifier='asd', channels=(1, 2)) parameters = {'var': 2} modifications = { 1: TableEntry(repetition_count=5, element_number=1, jump_flag=0), (0, 1): TableDescription(repetition_count=10, element_id=0, jump_flag=0) } invalid_modification = { 1: TableEntry(repetition_count=0, element_number=1, jump_flag=0) } no_modifications = {} program_mock = mock.Mock(TaborProgram) program_memory = TaborProgramMemory(waveform_to_segment=np.array( [1, 4]), program=program_mock) expected_commands = { ':ASEQ:DEF 2,2,5,0', ':SEQ:SEL 2', ':SEQ:DEF 1,2,10,0' } channel_pair._known_programs['active_program'] = program_memory channel_pair._known_programs['other_program'] = program_memory channel_pair._current_program = 'active_program' with mock.patch.object(program_mock, 'update_volatile_parameters', return_value=modifications) as update_prog: with mock.patch.object( channel_pair, '_execute_multiple_commands_with_config_guard') as ex_com: #with mock.patch.object(channel_pair.device.main_instrument, 'send_query'): channel_pair.set_volatile_parameters('other_program', parameters) ex_com.assert_not_called() update_prog.assert_called_once_with(parameters) channel_pair.set_volatile_parameters('active_program', parameters) self.assertEqual(1, ex_com.call_count) actual_commands, = ex_com.call_args[0] self.assertEqual(expected_commands, set(actual_commands)) self.assertEqual(len(expected_commands), len(actual_commands)) assert update_prog.call_count == 2 update_prog.assert_called_with(parameters) with mock.patch.object(program_mock, 'update_volatile_parameters', return_value=no_modifications) as update_prog: with mock.patch.object( channel_pair, '_execute_multiple_commands_with_config_guard') as ex_com: channel_pair.set_volatile_parameters('active_program', parameters) ex_com.assert_not_called() update_prog.assert_called_once_with(parameters) with mock.patch.object( program_mock, 'update_volatile_parameters', return_value=invalid_modification) as update_prog: with mock.patch.object( channel_pair, '_execute_multiple_commands_with_config_guard') as ex_com: with self.assertRaises(ValueError): channel_pair.set_volatile_parameters( 'active_program', parameters) ex_com.assert_not_called() update_prog.assert_called_once_with(parameters)