def __init__(self, tabor_device: TaborAWGRepresentation, channels: Tuple[int, int], identifier: str):
super().__init__(identifier)
self._device = weakref.ref(tabor_device)
self._configuration_guard_count = 0
self._is_in_config_mode = False
if channels not in ((1, 2), (3, 4)):
raise ValueError('Invalid channel pair: {}'.format(channels))
self._channels = channels
self._idle_segment = TaborSegment.from_sampled(voltage_to_uint16(voltage=np.zeros(192),
output_amplitude=0.5,
output_offset=0., resolution=14),
voltage_to_uint16(voltage=np.zeros(192),
output_amplitude=0.5,
output_offset=0., resolution=14),
None, None)
self._idle_sequence_table = [(1, 1, 0), (1, 1, 0), (1, 1, 0)]
self._known_programs = dict() # type: Dict[str, TaborProgramMemory]
self._current_program = None
self._segment_lengths = None
self._segment_capacity = None
self._segment_hashes = None
self._segment_references = None
self._sequencer_tables = None
self._advanced_sequence_table = None
self._internal_paranoia_level = 0
self.clear()
def test_sampled_segments(self):
def my_gen(gen):
alternating_on_off = itertools.cycle((np.ones(192), np.zeros(192)))
chan_gen = gen
while True:
for _ in range(2):
yield next(chan_gen)
yield next(alternating_on_off)[::2]
yield np.zeros(192)[::2]
with self.assertRaisesRegex(ValueError, "non integer length"):
root_loop = LoopTests.get_test_loop(
WaveformGenerator(waveform_data_generator=my_gen(
self.waveform_data_generator),
duration_generator=itertools.repeat(1 / 200),
num_channels=4))
TaborProgram(root_loop, self.instr_props, ('A', 'B'), (None, None),
**self.program_entry_kwargs)
root_loop = LoopTests.get_test_loop(
WaveformGenerator(waveform_data_generator=my_gen(
self.waveform_data_generator),
duration_generator=itertools.repeat(1),
num_channels=4))
prog = TaborProgram(root_loop, self.instr_props, ('A', 'B'),
(None, None), **self.program_entry_kwargs)
sampled, sampled_length = prog.get_sampled_segments()
self.assertEqual(len(sampled), 3)
prog = TaborProgram(root_loop, self.instr_props, ('A', 'B'),
('C', None), **self.program_entry_kwargs)
sampled, sampled_length = prog.get_sampled_segments()
self.assertEqual(len(sampled), 6)
iteroe = my_gen(self.waveform_data_generator)
for i, sampled_seg in enumerate(sampled):
data = [next(iteroe) for _ in range(4)]
data = (voltage_to_uint16(data[0], 1., 0., 14),
voltage_to_uint16(data[1], 1., 0., 14), data[2], data[3])
if i % 2 == 0:
np.testing.assert_equal(sampled_seg.marker_a,
np.ones(192, dtype=np.uint16)[::2])
else:
np.testing.assert_equal(sampled_seg.marker_a,
np.zeros(192, dtype=np.uint16)[::2])
np.testing.assert_equal(sampled_seg.marker_b,
np.zeros(192, dtype=np.uint16)[::2])
np.testing.assert_equal(sampled_seg.ch_a, data[0])
np.testing.assert_equal(sampled_seg.ch_b, data[1])
def _channel_data(self, waveform: Waveform, time: np.ndarray, channel_idx: int):
if self._channels[channel_idx] is None:
return np.full_like(time, 8192, dtype=np.uint16)
else:
return voltage_to_uint16(
self._voltage_transformations[channel_idx](
waveform.get_sampled(channel=self._channels[channel_idx],
sample_times=time)),
self._amplitudes[channel_idx],
self._offsets[channel_idx],
resolution=14)
def test_voltage_to_uint16(self):
with self.assertRaises(ValueError):
voltage_to_uint16(np.zeros(0), 0, 0, 0)
linspace_voltage = np.linspace(0, 1, 128)
with self.assertRaises(ValueError):
voltage_to_uint16(linspace_voltage, 0.9, 0, 1)
with self.assertRaises(ValueError):
voltage_to_uint16(linspace_voltage, 1.1, -1, 1)
expected_data = np.arange(0, 128, dtype=np.uint16)
received_data = voltage_to_uint16(linspace_voltage, 0.5, 0.5, 7)
self.assertTrue(np.all(expected_data == received_data))
def _make_binary_waveform(waveform: QuPulseWaveform, time_array: np.ndarray,
channel: Optional[ChannelID],
marker_1: Optional[ChannelID],
marker_2: Optional[ChannelID],
voltage_transformation: Callable,
voltage_to_uint16_kwargs: dict) -> tek_awg.Waveform:
def sample_channel(ch_id: Optional[ChannelID]):
if ch_id is None:
return np.zeros_like(time_array)
else:
return waveform.get_sampled(channel=ch_id, sample_times=time_array)
channel_volts, marker_1_data, marker_2_data = map(
sample_channel, (channel, marker_1, marker_2))
channel_volts = voltage_transformation(channel_volts)
channel_data = voltage_to_uint16(channel_volts, **voltage_to_uint16_kwargs)
return tek_awg.Waveform(channel=channel_data,
marker_1=marker_1_data,
marker_2=marker_2_data)
def test_zero_level_14bit(self):
zero_level = voltage_to_uint16(np.zeros(1), 0.5, 0., 14)
self.assertEqual(zero_level, 8192)
def test_sampled_segments(self):
def my_gen(gen):
alternating_on_off = itertools.cycle((np.ones(192), np.zeros(192)))
chan_gen = gen
while True:
for _ in range(2):
yield next(chan_gen)
yield next(alternating_on_off)[::2]
yield np.zeros(192)[::2]
sample_rate = 10**9
with self.assertRaises(TaborException):
root_loop = LoopTests.get_test_loop(
WaveformGenerator(waveform_data_generator=my_gen(
self.waveform_data_generator),
duration_generator=itertools.repeat(12),
num_channels=4))
mcp = MultiChannelProgram(InstructionBlock(), tuple())
mcp.programs[frozenset(('A', 'B', 'C', 'D'))] = root_loop
TaborProgram(root_loop, self.instr_props, ('A', 'B'),
(None, None)).sampled_segments(
8000, (1., 1.), (0, 0),
(lambda x: x, lambda x: x))
root_loop = LoopTests.get_test_loop(
WaveformGenerator(waveform_data_generator=my_gen(
self.waveform_data_generator),
duration_generator=itertools.repeat(192),
num_channels=4))
mcp = MultiChannelProgram(InstructionBlock(), tuple())
mcp.programs[frozenset(('A', 'B', 'C', 'D'))] = root_loop
prog = TaborProgram(root_loop, self.instr_props, ('A', 'B'),
(None, None))
sampled, sampled_length = prog.sampled_segments(
sample_rate, (1., 1.), (0, 0), (lambda x: x, lambda x: x))
self.assertEqual(len(sampled), 3)
prog = TaborProgram(root_loop, self.instr_props, ('A', 'B'),
('C', None))
sampled, sampled_length = prog.sampled_segments(
sample_rate, (1., 1.), (0, 0), (lambda x: x, lambda x: x))
self.assertEqual(len(sampled), 6)
iteroe = my_gen(self.waveform_data_generator)
for i, sampled_seg in enumerate(sampled):
data = [next(iteroe) for _ in range(4)]
data = (voltage_to_uint16(data[0], 1., 0., 14),
voltage_to_uint16(data[1], 1., 0., 14), data[2], data[3])
if i % 2 == 0:
np.testing.assert_equal(sampled_seg.marker_a,
np.ones(192, dtype=np.uint16)[::2])
else:
np.testing.assert_equal(sampled_seg.marker_a,
np.zeros(192, dtype=np.uint16)[::2])
np.testing.assert_equal(sampled_seg.marker_b,
np.zeros(192, dtype=np.uint16)[::2])
np.testing.assert_equal(sampled_seg.ch_a, data[0])
np.testing.assert_equal(sampled_seg.ch_b, data[1])
