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)