Fix/tabor simulator tests

qctoolkit/hardware/awgs/tabor.py

@@ -83,10 +83,23 @@ def __hash__(self) -> int:
                           for data in (self.ch_a, self.ch_b, self.marker_a, self.marker_b)))
 
     def __eq__(self, other: 'TaborSegment'):
+        def compare_markers(marker_1, marker_2):
+            if marker_1 is None:
+                if marker_2 is None:
+                    return True
+                else:
+                    return not np.any(marker_2)
+
+            elif marker_2 is None:
+                return not np.any(marker_1)
+
+            else:
+                return np.array_equal(marker_1, marker_2)
+
         return (np.array_equal(self.ch_a, other.ch_a) and
                 np.array_equal(self.ch_b, other.ch_b) and
-                np.array_equal(self.marker_a, other.marker_a) and
-                np.array_equal(self.marker_b, other.marker_b))
+                compare_markers(self.marker_a, other.marker_a) and
+                compare_markers(self.marker_b, other.marker_b))
 
     @property
     def data_a(self) -> np.ndarray:
@@ -696,8 +709,10 @@ def iter_samples(self, channel: int,
             for _ in range(repetition):
                 yield from waveform
 
-    def get_as_single_waveform(self, channel: int, max_total_length: int=10**9) -> Optional[np.ndarray]:
-        waveforms = self.get_waveforms(channel)
+    def get_as_single_waveform(self, channel: int,
+                               max_total_length: int=10**9,
+                               with_marker: bool=False) -> Optional[np.ndarray]:
+        waveforms = self.get_waveforms(channel, with_marker=with_marker)
         repetitions = self.get_repetitions()
         waveform_lengths = np.fromiter((wf.size for wf in waveforms), count=len(waveforms), dtype=np.uint64)
 
@@ -716,8 +731,11 @@ def get_as_single_waveform(self, channel: int, max_total_length: int=10**9) -> O
             c_idx += mem
         return result
 
-    def get_waveforms(self, channel: int) -> List[np.ndarray]:
-        ch_getter = (operator.attrgetter('ch_a'), operator.attrgetter('ch_b'))[channel]
+    def get_waveforms(self, channel: int, with_marker: bool=False) -> List[np.ndarray]:
+        if with_marker:
+            ch_getter = (operator.attrgetter('data_a'), operator.attrgetter('data_b'))[channel]
+        else:
+            ch_getter = (operator.attrgetter('ch_a'), operator.attrgetter('ch_b'))[channel]
         return [ch_getter(self._segments[segment_no - 1])
                 for _, segment_no, _ in self._iter_segment_table_entry()]
 

tests/backward_compatibility/charge_scan_1/binary_program_validation.py

@@ -21,7 +21,7 @@ def validate_programs(program_AB, program_CD, loaded_data: dict, parameters):
 
     expected_samples_A = np.tile(for_A, (meas_time_multiplier * 192, 1, rep_count)).T.ravel()
     set_ignored_marker_data_to_zero(expected_samples_A)
-    samples_A = program_AB.get_as_single_waveform(0, expected_samples_A.size)
+    samples_A = program_AB.get_as_single_waveform(0, expected_samples_A.size, with_marker=True)
     np.testing.assert_equal(samples_A, expected_samples_A)
 
     del samples_A

tests/hardware/tabor_simulator_based_tests.py

@@ -111,7 +111,7 @@ def test_sample_rate(self):
         with self.assertRaises(TaborException):
             self.instrument.sample_rate(0)
 
-        self.instrument.send_cmd(':INST:SEL 1;')
+        self.instrument.send_cmd(':INST:SEL 1')
         self.instrument.send_cmd(':FREQ:RAST 2.3e9')
 
         self.assertEqual(2300000000, self.instrument.sample_rate(1))
@@ -196,14 +196,19 @@ def test_read_waveforms(self):
 
         waveforms = self.channel_pair.read_waveforms()
 
-        reformated = PlottableProgram._reformat_waveforms(waveforms)
+        segments = [TaborSegment.from_binary_segment(waveform)
+                    for waveform in waveforms]
 
         expected = [self.zero_segment, *self.segments]
-        for ex, r1, r2 in zip(expected, *reformated):
+
+        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]))

tests/hardware/tabor_tests.py

@@ -118,6 +118,31 @@ def test_from_binary_data(self):
 
         self.assertEqual(segment, reconstructed)
 
+    def test_eq(self):
+        ch_a = np.asarray(100 + np.arange(32), dtype=np.uint16)
+        ch_b = np.asarray(1000 + np.arange(32), dtype=np.uint16)
+
+        marker_ones = np.ones(16, dtype=bool)
+        marker_random = np.asarray(list(range(5)) + list(range(6)) + list(range(5)), dtype=np.uint16)
+        marker_zeros = np.zeros(16, dtype=bool)
+
+        segment_1 = TaborSegment(ch_a=ch_a, ch_b=ch_b, marker_a=marker_ones, marker_b=marker_random)
+        segment_2 = TaborSegment(ch_a=ch_a, ch_b=ch_a, marker_a=marker_ones, marker_b=marker_random)
+
+        segment_a0 = TaborSegment(ch_a=ch_a, ch_b=ch_b, marker_a=marker_zeros, marker_b=marker_random)
+        segment_anone = TaborSegment(ch_a=ch_a, ch_b=ch_b, marker_a=None, marker_b=marker_random)
+        segment_none = TaborSegment(ch_a=ch_a, ch_b=ch_b, marker_a=None, marker_b=None)
+
+        self.assertEqual(segment_1, segment_1)
+        self.assertNotEqual(segment_1, segment_2)
+
+        self.assertEqual(segment_a0, segment_anone)
+        self.assertEqual(segment_anone, segment_a0)
+        self.assertEqual(segment_anone, segment_anone)
+        self.assertNotEqual(segment_anone, segment_none)
+        self.assertEqual(segment_none, segment_none)
+        self.assertNotEqual(segment_a0, segment_1)
+
 
 class TaborProgramTests(unittest.TestCase):
     def __init__(self, *args, **kwargs):
@@ -372,23 +397,20 @@ def test_config_guard(self):
 
 class PlottableProgramTests(unittest.TestCase):
     def setUp(self):
-        def make_read_waveform(data):
-            assert len(data) % 16 == 0
+        self.ch_a = [np.arange(16, dtype=np.uint16),      np.arange(32, 64, dtype=np.uint16)]
+        self.ch_b = [1000 + np.arange(16, dtype=np.uint16),  1000 + np.arange(32, 64, dtype=np.uint16)]
 
-            ch_0 = []
-            ch_1 = []
-            for i, x in enumerate(data):
-                ch_0.append(x+1000)
-                ch_1.append(x)
+        self.marker_a = [np.ones(8, bool), np.array([0, 1]*8, dtype=bool)]
+        self.marker_b = [np.array([0, 0, 0, 1]*2, bool), np.array([1, 0, 1, 1] * 4, dtype=bool)]
 
-            #ch_0.extend(ch_0[-1:]*16)
-            #ch_1.extend(ch_1[-1:]*16)
+        self.segments = [TaborSegment(ch_a, ch_b, marker_a, marker_b)
+                         for ch_a, ch_b, marker_a, marker_b in zip(self.ch_a, self.ch_b, self.marker_a, self.marker_b)]
 
-            ch_0 = np.array(ch_0, dtype=np.uint16)
-            ch_1 = np.array(ch_1, dtype=np.uint16)
-            return np.concatenate((ch_0.reshape((-1, 16)), ch_1.reshape((-1, 16))), 1).ravel()
+        self.sequencer_tables = [[(1, 1, 0), (1, 2, 0)],
+                                 [(1, 1, 0), (2, 2, 0), (1, 1, 0)]]
+        self.adv_sequencer_table = [(1, 1, 0), (1, 2, 0), (2, 1, 0)]
 
-        self.read_waveforms = [make_read_waveform(np.arange(32)), make_read_waveform(np.arange(32, 48))]
+        self.read_segments = [segment.get_as_binary() for segment in self.segments]
         self.read_sequencer_tables = [(np.array([1, 1]),
                                        np.array([1, 2]),
                                        np.array([0, 0])),
@@ -400,12 +422,12 @@ def make_read_waveform(data):
                                          np.array([1, 2, 1]),
                                          np.array([0, 0, 0]))
 
-        self.waveforms = ((np.arange(32, dtype=np.uint16), np.arange(32, 48, dtype=np.uint16)),
-                          (1000+np.arange(32, dtype=np.uint16), 1000+np.arange(32, 48, dtype=np.uint16)))
-        self.segments = [TaborSegment.from_binary_data(a, b) for a, b in zip(*self.waveforms)]
-        self.sequencer_tables = [[(1, 1, 0), (1, 2, 0)],
-                                 [(1, 1, 0), (2, 2, 0), (1, 1, 0)]]
-        self.adv_sequencer_table = [(1, 1, 0), (1, 2, 0), (2, 1, 0)]
+        self.selection_order = [0, 1,
+                                0, 1, 1, 0,
+                                0, 1, 0, 1]
+        self.selection_order_without_repetition = [0, 1,
+                                                   0, 1, 0,
+                                                   0, 1, 0, 1]
 
     def test_init(self):
         prog = PlottableProgram(self.segments, self.sequencer_tables, self.adv_sequencer_table)
@@ -414,7 +436,7 @@ def test_init(self):
         self.assertEqual(self.adv_sequencer_table, prog._advanced_sequence_table)
 
     def test_from_read_data(self):
-        prog = PlottableProgram.from_read_data(self.read_waveforms,
+        prog = PlottableProgram.from_read_data(self.read_segments,
                                                self.read_sequencer_tables,
                                                self.read_adv_sequencer_table)
         self.assertEqual(self.segments, prog._segments)
@@ -424,9 +446,7 @@ def test_from_read_data(self):
     def test_iter(self):
         prog = PlottableProgram(self.segments, self.sequencer_tables, self.adv_sequencer_table)
 
-        ch = itertools.chain(range(32), range(32, 48),
-                             range(32), range(32, 48), range(32, 48), range(32),
-                             range(32), range(32, 48), range(32), range(32, 48))
+        ch = itertools.chain.from_iterable(self.ch_a[idx] for idx in self.selection_order)
         ch_0 = np.fromiter(ch, dtype=np.uint16)
         ch_1 = ch_0 + 1000
 
@@ -466,15 +486,19 @@ def test_eq(self):
     def test_get_waveforms(self):
         prog = PlottableProgram(self.segments, self.sequencer_tables, self.adv_sequencer_table)
 
-        expected_waveforms_0 = [np.arange(32), np.arange(32, 48), np.arange(32),
-                                np.arange(32, 48), np.arange(32), np.arange(32),
-                                np.arange(32, 48), np.arange(32), np.arange(32, 48)]
+        # omit first wave
+        expected_waveforms_0 = [self.ch_a[idx] for idx in self.selection_order_without_repetition]
+        expected_waveforms_1 = [self.ch_b[idx] for idx in self.selection_order_without_repetition]
 
         np.testing.assert_equal(expected_waveforms_0, prog.get_waveforms(0))
-
-        expected_waveforms_1 = [wf + 1000 for wf in expected_waveforms_0]
         np.testing.assert_equal(expected_waveforms_1, prog.get_waveforms(1))
 
+        expected_waveforms_0_marker = [self.segments[idx].data_a for idx in self.selection_order_without_repetition]
+        expected_waveforms_1_marker = [self.segments[idx].data_b for idx in self.selection_order_without_repetition]
+
+        np.testing.assert_equal(expected_waveforms_0_marker, prog.get_waveforms(0, with_marker=True))
+        np.testing.assert_equal(expected_waveforms_1_marker, prog.get_waveforms(1, with_marker=True))
+
     def test_get_repetitions(self):
         prog = PlottableProgram(self.segments, self.sequencer_tables, self.adv_sequencer_table)