def test_cleanup(self):
channel_pair = TaborChannelPair(self.instrument,
identifier='asd',
channels=(1, 2))
self.instrument.paranoia_level = 0
self.reset_instrument_logs()
channel_pair._segment_references = np.array([1, 2, 0, 1],
dtype=np.uint32)
channel_pair._segment_capacity = 192 + np.array([0, 16, 32, 32],
dtype=np.uint32)
channel_pair._segment_lengths = 192 + np.array([0, 0, 16, 16],
dtype=np.uint32)
channel_pair._segment_hashes = np.array([1, 2, 3, 4], dtype=np.int64)
channel_pair.cleanup()
np.testing.assert_equal(channel_pair._segment_references,
np.array([1, 2, 0, 1], dtype=np.uint32))
np.testing.assert_equal(
channel_pair._segment_capacity,
192 + np.array([0, 16, 32, 32], dtype=np.uint32))
np.testing.assert_equal(
channel_pair._segment_lengths,
192 + np.array([0, 0, 16, 16], dtype=np.uint32))
np.testing.assert_equal(channel_pair._segment_hashes,
np.array([1, 2, 3, 4], dtype=np.int64))
channel_pair._segment_references = np.array([1, 2, 0, 1, 0],
dtype=np.uint32)
channel_pair._segment_capacity = 192 + np.array([0, 16, 32, 32, 32],
dtype=np.uint32)
channel_pair._segment_lengths = 192 + np.array([0, 0, 16, 16, 0],
dtype=np.uint32)
channel_pair._segment_hashes = np.array([1, 2, 3, 4, 5],
dtype=np.int64)
channel_pair.cleanup()
np.testing.assert_equal(channel_pair._segment_references,
np.array([1, 2, 0, 1], dtype=np.uint32))
np.testing.assert_equal(
channel_pair._segment_capacity,
192 + np.array([0, 16, 32, 32], dtype=np.uint32))
np.testing.assert_equal(
channel_pair._segment_lengths,
192 + np.array([0, 0, 16, 16], dtype=np.uint32))
np.testing.assert_equal(channel_pair._segment_hashes,
np.array([1, 2, 3, 4], dtype=np.int64))
def test_upload_segment(self):
channel_pair = TaborChannelPair(self.instrument,
identifier='asd',
channels=(1, 2))
self.reset_instrument_logs()
channel_pair._segment_references = np.array([1, 2, 0, 1],
dtype=np.uint32)
channel_pair._segment_capacity = 192 + np.array([0, 16, 32, 32],
dtype=np.uint32)
channel_pair._segment_lengths = channel_pair._segment_capacity.copy()
channel_pair._segment_hashes = np.array([1, 2, 3, 4], dtype=np.int64)
# prevent entering and exiting configuration mode
channel_pair._configuration_guard_count = 2
segment = TaborSegment.from_sampled(
np.ones(192 + 16, dtype=np.uint16),
np.zeros(192 + 16, dtype=np.uint16), None, None)
segment_binary = segment.get_as_binary()
with self.assertRaises(ValueError):
channel_pair._upload_segment(3, segment)
with self.assertRaises(ValueError):
channel_pair._upload_segment(0, segment)
channel_pair._upload_segment(2, segment)
np.testing.assert_equal(
channel_pair._segment_capacity,
192 + np.array([0, 16, 32, 32], dtype=np.uint32))
np.testing.assert_equal(
channel_pair._segment_lengths,
192 + np.array([0, 16, 16, 32], dtype=np.uint32))
np.testing.assert_equal(
channel_pair._segment_hashes,
np.array([1, 2, hash(segment), 4], dtype=np.int64))
expected_commands = [
':INST:SEL 1', ':INST:SEL 1', ':INST:SEL 1', ':TRAC:DEF 3, 208',
':TRAC:SEL 3', ':TRAC:MODE COMB'
]
expected_log = [
((),
dict(cmd_str=cmd,
paranoia_level=channel_pair.internal_paranoia_level))
for cmd in expected_commands
]
self.assertAllCommandLogsEqual(expected_log)
self.assert_written_segment_data(segment_binary)
def test_free_program(self):
channel_pair = TaborChannelPair(self.instrument,
identifier='asd',
channels=(1, 2))
with self.assertRaises(KeyError):
channel_pair.free_program('test')
program = TaborProgramMemory(np.array([1, 2], dtype=np.int64), None)
channel_pair._segment_references = np.array([1, 3, 1, 0])
channel_pair._known_programs['test'] = program
self.assertIs(channel_pair.free_program('test'), program)
np.testing.assert_equal(channel_pair._segment_references,
np.array([1, 2, 0, 0]))
def test_amend_segments_iter(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.reset_instrument_logs()
channel_pair._segment_references = np.array([1, 2, 0, 1],
dtype=np.uint32)
channel_pair._segment_capacity = 192 + np.array([0, 16, 32, 32],
dtype=np.uint32)
channel_pair._segment_lengths = 192 + np.array([0, 0, 16, 16],
dtype=np.uint32)
channel_pair._segment_hashes = np.array([1, 2, 3, 4], dtype=np.int64)
data = np.ones(192, dtype=np.uint16)
segments = [
TaborSegment.from_sampled(0 * data, 1 * data, None, None),
TaborSegment.from_sampled(1 * data, 2 * data, None, None)
]
indices = channel_pair._amend_segments(segments)
expected_references = np.array([1, 2, 0, 1, 1, 1], dtype=np.uint32)
expected_capacities = 192 + np.array([0, 16, 32, 32, 0, 0],
dtype=np.uint32)
expected_lengths = 192 + np.array([0, 0, 16, 16, 0, 0],
dtype=np.uint32)
expected_hashes = np.array(
[1, 2, 3, 4, hash(segments[0]),
hash(segments[1])], dtype=np.int64)
np.testing.assert_equal(channel_pair._segment_references,
expected_references)
np.testing.assert_equal(channel_pair._segment_capacity,
expected_capacities)
np.testing.assert_equal(channel_pair._segment_lengths,
expected_lengths)
np.testing.assert_equal(channel_pair._segment_hashes, expected_hashes)
np.testing.assert_equal(indices, np.array([4, 5], dtype=np.int64))
expected_commands = [
':INST:SEL 1', ':TRAC:DEF 5,{}'.format(2 * 192 + 16),
':TRAC:SEL 5', ':TRAC:MODE COMB', ':TRAC:DEF 5,192',
':TRAC:DEF 6,192'
]
expected_log = [
((),
dict(cmd_str=cmd,
paranoia_level=channel_pair.internal_paranoia_level))
for cmd in expected_commands
]
self.assertAllCommandLogsEqual(expected_log)
# no segment lengths written
self.assert_written_segment_lengths()
expected_bin_blob = make_combined_wave(segments)
self.assert_written_segment_data(expected_bin_blob)
def test_find_place_for_segments_in_memory(self):
def hash_based_on_dir(ch):
hash_list = []
for d in dir(ch):
o = getattr(ch, d)
if isinstance(o, np.ndarray):
hash_list.append(hash(o.tobytes()))
else:
try:
hash_list.append(hash(o))
except TypeError:
pass
return hash(tuple(hash_list))
channel_pair = TaborChannelPair(self.instrument,
identifier='asd',
channels=(1, 2))
# empty
segments = np.asarray([-5, -6, -7, -8, -9])
segment_lengths = 192 + np.asarray([32, 16, 64, 32, 16])
hash_before = hash_based_on_dir(channel_pair)
w2s, ta, ti = channel_pair._find_place_for_segments_in_memory(
segments, segment_lengths)
self.assertEqual(w2s.tolist(), [-1, -1, -1, -1, -1])
self.assertEqual(ta.tolist(), [True, True, True, True, True])
self.assertEqual(ti.tolist(), [-1, -1, -1, -1, -1])
self.assertEqual(hash_before, hash_based_on_dir(channel_pair))
# all new segments
channel_pair._segment_capacity = 192 + np.asarray([0, 16, 32, 16, 0],
dtype=np.uint32)
channel_pair._segment_hashes = np.asarray([1, 2, 3, 4, 5],
dtype=np.int64)
channel_pair._segment_references = np.asarray([1, 1, 1, 2, 1],
dtype=np.int32)
hash_before = hash_based_on_dir(channel_pair)
w2s, ta, ti = channel_pair._find_place_for_segments_in_memory(
segments, segment_lengths)
self.assertEqual(w2s.tolist(), [-1, -1, -1, -1, -1])
self.assertEqual(ta.tolist(), [True, True, True, True, True])
self.assertEqual(ti.tolist(), [-1, -1, -1, -1, -1])
self.assertEqual(hash_before, hash_based_on_dir(channel_pair))
# some known segments
channel_pair._segment_capacity = 192 + np.asarray(
[0, 16, 32, 64, 0, 16], dtype=np.uint32)
channel_pair._segment_hashes = np.asarray([1, 2, 3, -7, 5, -9],
dtype=np.int64)
channel_pair._segment_references = np.asarray([1, 1, 1, 2, 1, 3],
dtype=np.int32)
hash_before = hash_based_on_dir(channel_pair)
w2s, ta, ti = channel_pair._find_place_for_segments_in_memory(
segments, segment_lengths)
self.assertEqual(w2s.tolist(), [-1, -1, 3, -1, 5])
self.assertEqual(ta.tolist(), [True, True, False, True, False])
self.assertEqual(ti.tolist(), [-1, -1, -1, -1, -1])
self.assertEqual(hash_before, hash_based_on_dir(channel_pair))
# insert some segments with same length
channel_pair._segment_capacity = 192 + np.asarray(
[0, 16, 32, 64, 0, 16], dtype=np.uint32)
channel_pair._segment_hashes = np.asarray([1, 2, 3, 4, 5, 6],
dtype=np.int64)
channel_pair._segment_references = np.asarray([1, 0, 1, 0, 1, 3],
dtype=np.int32)
hash_before = hash_based_on_dir(channel_pair)
w2s, ta, ti = channel_pair._find_place_for_segments_in_memory(
segments, segment_lengths)
self.assertEqual(w2s.tolist(), [-1, -1, -1, -1, -1])
self.assertEqual(ta.tolist(), [True, False, False, True, True])
self.assertEqual(ti.tolist(), [-1, 1, 3, -1, -1])
self.assertEqual(hash_before, hash_based_on_dir(channel_pair))
# insert some segments with smaller length
channel_pair._segment_capacity = 192 + np.asarray(
[0, 80, 32, 64, 96, 16], dtype=np.uint32)
channel_pair._segment_hashes = np.asarray([1, 2, 3, 4, 5, 6],
dtype=np.int64)
channel_pair._segment_references = np.asarray([1, 0, 1, 1, 0, 3],
dtype=np.int32)
hash_before = hash_based_on_dir(channel_pair)
w2s, ta, ti = channel_pair._find_place_for_segments_in_memory(
segments, segment_lengths)
self.assertEqual(w2s.tolist(), [-1, -1, -1, -1, -1])
self.assertEqual(ta.tolist(), [True, True, False, False, True])
self.assertEqual(ti.tolist(), [-1, -1, 4, 1, -1])
self.assertEqual(hash_before, hash_based_on_dir(channel_pair))
# mix everything
segments = np.asarray([-5, -6, -7, -8, -9, -10, -11])
segment_lengths = 192 + np.asarray([32, 16, 64, 32, 16, 0, 0])
channel_pair._segment_capacity = 192 + np.asarray(
[0, 80, 32, 64, 32, 16], dtype=np.uint32)
channel_pair._segment_hashes = np.asarray([1, 2, 3, 4, -8, 6],
dtype=np.int64)
channel_pair._segment_references = np.asarray([1, 0, 1, 0, 1, 0],
dtype=np.int32)
hash_before = hash_based_on_dir(channel_pair)
w2s, ta, ti = channel_pair._find_place_for_segments_in_memory(
segments, segment_lengths)
self.assertEqual(w2s.tolist(), [-1, -1, -1, 4, -1, -1, -1])
self.assertEqual(ta.tolist(),
[False, True, False, False, True, True, True])
self.assertEqual(ti.tolist(), [1, -1, 3, -1, -1, -1, -1])
self.assertEqual(hash_before, hash_based_on_dir(channel_pair))
def test_upload(self):
segments = np.array([1, 2, 3, 4, 5])
segment_lengths = np.array([0, 16, 0, 16, 0], dtype=np.uint16).tolist()
segment_references = np.array([1, 1, 2, 0, 1], dtype=np.uint32)
w2s = np.array([-1, -1, 1, 2, -1], dtype=np.int64)
ta = np.array([True, False, False, False, True])
ti = np.array([-1, 3, -1, -1, -1])
channels = (1, None)
markers = (None, None)
voltage_transformations = (lambda x: x, lambda x: x)
sample_rate = TimeType.from_fraction(1, 1)
with mock.patch('qupulse.hardware.awgs.tabor.TaborProgram',
specs=TaborProgram) as DummyTaborProgram:
tabor_program = DummyTaborProgram.return_value
tabor_program.get_sampled_segments.return_value = (segments,
segment_lengths)
program = Loop(waveform=DummyWaveform(duration=192))
channel_pair = TaborChannelPair(self.instrument,
identifier='asd',
channels=(1, 2))
channel_pair._segment_references = segment_references
def dummy_find_place(segments_, segement_lengths_):
self.assertIs(segments_, segments)
self.assertIs(segment_lengths, segement_lengths_)
return w2s, ta, ti
def dummy_upload_segment(segment_index, segment):
self.assertEqual(segment_index, 3)
self.assertEqual(segment, 2)
def dummy_amend_segments(segments_):
np.testing.assert_equal(segments_, np.array([1, 5]))
return np.array([5, 6], dtype=np.int64)
self.instrument.amplitude = mock.Mock(return_value=1.)
self.instrument.sample_rate = mock.Mock(return_value=10**9)
channel_pair._find_place_for_segments_in_memory = dummy_find_place
channel_pair._upload_segment = dummy_upload_segment
channel_pair._amend_segments = dummy_amend_segments
channel_pair.upload('test', program, channels, markers,
voltage_transformations)
DummyTaborProgram.assert_called_once_with(
program,
channels=tuple(channels),
markers=markers,
device_properties=channel_pair.device.dev_properties,
sample_rate=sample_rate,
amplitudes=(.5, .5),
offsets=(0., 0.),
voltage_transformations=voltage_transformations)
self.assertEqual(self.instrument.amplitude.call_args_list,
[mock.call(1), mock.call(2)])
self.instrument.sample_rate.assert_called_once_with(1)
# the other references are increased in amend and upload segment method
np.testing.assert_equal(channel_pair._segment_references,
np.array([1, 2, 3, 0, 1]))
self.assertEqual(len(channel_pair._known_programs), 1)
np.testing.assert_equal(
channel_pair._known_programs['test'].waveform_to_segment,
np.array([5, 3, 1, 2, 6], dtype=np.int64))