def test_change_armed_program_advanced_sequence(self):
channel_pair = TaborChannelPair(self.instrument,
identifier='asd',
channels=(1, 2))
# prevent entering and exiting configuration mode
channel_pair._configuration_guard_count = 2
self.instrument.paranoia_level = 0
self.instrument.logged_commands = []
self.instrument.logged_queries = []
self.instrument._send_binary_data_calls = []
self.reset_instrument_logs()
advanced_sequencer_table = [(2, 1, 0), (3, 2, 0)]
sequencer_tables = [[(3, 0, 0), (2, 1, 0), (1, 0, 0), (1, 2, 0),
(1, 3, 0)],
[(4, 1, 0), (2, 1, 0), (1, 0, 0), (1, 2, 0),
(1, 3, 0)]]
wf_idx2seg_idx = np.array([2, 5, 3, 1])
sequencer_tables = self.to_new_sequencer_tables(sequencer_tables)
advanced_sequencer_table = self.to_new_advanced_sequencer_table(
advanced_sequencer_table)
expected_sequencer_tables = [[(3, 3, 0), (2, 6, 0), (1, 3, 0),
(1, 4, 0), (1, 2, 0)],
[(4, 6, 0), (2, 6, 0), (1, 3, 0),
(1, 4, 0), (1, 2, 0)]]
program = DummyTaborProgramClass(
advanced_sequencer_table=advanced_sequencer_table,
sequencer_tables=sequencer_tables,
waveform_mode=TaborSequencing.ADVANCED)(None, None, None, None)
channel_pair._known_programs['test'] = TaborProgramMemory(
wf_idx2seg_idx, program)
channel_pair.change_armed_program('test')
expected_adv_seq_table_log = [([(1, 1, 1), (2, 2, 0),
(3, 3, 0)], ':ASEQ:DATA', None)]
expected_sequencer_table_log = [
((sequencer_table, ), dict(pref=':SEQ:DATA', paranoia_level=None))
for sequencer_table in [channel_pair._idle_sequence_table] +
expected_sequencer_tables
]
self.assert_written_sequencer_tables(channel_pair._idle_sequence_table,
*expected_sequencer_tables)
self.assert_written_advanced_sequencer_tables([(1, 1, 1), (2, 2, 0),
(3, 3, 0)])
def test_change_armed_program_single_waveform(self):
channel_pair = TaborChannelPair(self.instrument,
identifier='asd',
channels=(1, 2))
# prevent entering and exiting configuration mode
channel_pair._configuration_guard_count = 2
self.instrument.paranoia_level = 0
self.instrument.logged_commands = []
self.instrument.logged_queries = []
self.reset_instrument_logs()
advanced_sequencer_table = [(1, 1, 0)]
sequencer_tables = [[(10, 0, 0)]]
w2s = np.array([4])
sequencer_tables = self.to_new_sequencer_tables(sequencer_tables)
advanced_sequencer_table = self.to_new_advanced_sequencer_table(
advanced_sequencer_table)
expected_sequencer_table = [(10, 5, 0), (1, 1, 0), (1, 1, 0)]
program = DummyTaborProgramClass(
advanced_sequencer_table=advanced_sequencer_table,
sequencer_tables=sequencer_tables,
waveform_mode=TaborSequencing.SINGLE)(None, None, None, None)
channel_pair._known_programs['test'] = TaborProgramMemory(w2s, program)
channel_pair.change_armed_program('test')
expected_adv_seq_table_log = [([(1, 1, 1), (1, 2, 0),
(1, 1, 0)], ':ASEQ:DATA', None)]
expected_sequencer_table_log = [
((sequencer_table, ), dict(pref=':SEQ:DATA', paranoia_level=None))
for sequencer_table in
[channel_pair._idle_sequence_table, expected_sequencer_table]
]
self.assert_written_sequencer_tables(channel_pair._idle_sequence_table,
expected_sequencer_table)
self.assert_written_advanced_sequencer_tables([(1, 1, 1), (1, 2, 0),
(1, 1, 0)])
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)
