def exec_general(self, data_1, data_2, fill_value=None):
tabor_segments = [
TaborSegment.from_sampled(d1, d2, None, None)
for d1, d2 in zip(data_1, data_2)
]
expected_length = (sum(segment.num_points
for segment in tabor_segments) + 16 *
(len(tabor_segments) - 1)) * 2
offset = 0
pyte_result = 15000 * np.ones(expected_length, dtype=np.uint16)
for i, segment in enumerate(tabor_segments):
offset = pytabor.make_combined_wave(segment.ch_a,
segment.ch_b,
dest_array=pyte_result,
dest_array_offset=offset,
add_idle_pts=i > 0)
self.assertEqual(expected_length, offset)
result = make_combined_wave(tabor_segments)
np.testing.assert_equal(pyte_result, result)
dest_array = 15000 * np.ones(expected_length, dtype=np.uint16)
result = make_combined_wave(tabor_segments,
destination_array=dest_array)
np.testing.assert_equal(pyte_result, result)
# test that the destination array data is not copied
self.assertEqual(dest_array.__array_interface__['data'],
result.__array_interface__['data'])
with self.assertRaises(ValueError):
make_combined_wave(tabor_segments, destination_array=np.ones(16))
def exec_general(self, data_1, data_2):
tabor_segments = [
TaborSegment.from_sampled(d1, d2, None, None)
for d1, d2 in zip(data_1, data_2)
]
expected_length = (sum(segment.num_points
for segment in tabor_segments) + 16 *
(len(tabor_segments) - 1)) * 2
result = make_combined_wave(tabor_segments)
self.assertEqual(len(result), expected_length)
self.validate_result(tabor_segments, result)
destination_array = np.empty(expected_length, dtype=np.uint16)
result = make_combined_wave(tabor_segments,
destination_array=destination_array)
self.validate_result(tabor_segments, result)
self.assertEqual(destination_array.data, result.data)
def _amend_segments(self, segments: List[TaborSegment]) -> np.ndarray:
new_lengths = np.asarray([s.num_points for s in segments],
dtype=np.uint32)
wf_data = make_combined_wave(segments)
trac_len = len(wf_data) // 2
segment_index = len(self._segment_capacity)
first_segment_number = segment_index + 1
self.device.send_cmd(':TRAC:DEF {},{}'.format(first_segment_number,
trac_len),
paranoia_level=self.internal_paranoia_level)
self.device.send_cmd(':TRAC:SEL {}'.format(first_segment_number),
paranoia_level=self.internal_paranoia_level)
self.device.send_cmd(':TRAC:MODE COMB',
paranoia_level=self.internal_paranoia_level)
self.device.send_binary_data(pref=':TRAC:DATA', bin_dat=wf_data)
old_to_update = np.count_nonzero(
self._segment_capacity != self._segment_lengths)
segment_capacity = np.concatenate(
(self._segment_capacity, new_lengths))
segment_lengths = np.concatenate((self._segment_lengths, new_lengths))
segment_references = np.concatenate(
(self._segment_references, np.ones(len(segments), dtype=int)))
segment_hashes = np.concatenate(
(self._segment_hashes, [hash(s) for s in segments]))
if len(segments) < old_to_update:
for i, segment in enumerate(segments):
current_segment_number = first_segment_number + i
self.device.send_cmd(
':TRAC:DEF {},{}'.format(current_segment_number,
segment.num_points),
paranoia_level=self.internal_paranoia_level)
else:
# flush the capacity
self.device.download_segment_lengths(segment_capacity)
# update non fitting lengths
for i in np.flatnonzero(segment_capacity != segment_lengths):
self.device.send_cmd(
':TRAC:DEF {},{}'.format(i + 1, segment_lengths[i]),
paranoia_level=self.internal_paranoia_level)
self._segment_capacity = segment_capacity
self._segment_lengths = segment_lengths
self._segment_hashes = segment_hashes
self._segment_references = segment_references
return segment_index + np.arange(len(segments), dtype=np.int64)
def test_empty_segment_list(self):
combined = make_combined_wave([])
self.assertIsInstance(combined, np.ndarray)
self.assertIs(combined.dtype, np.dtype('uint16'))
self.assertEqual(len(combined), 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)