Merge pull request #881 from qutech/issues/857_evaluate_bug

complicated test for linspacebuilder

Author: Nomos11

qupulse/program/linspace.py

@@ -327,7 +327,22 @@ class DepState:
     iterations: Tuple[int, ...]
 
     def required_increment_from(self, previous: 'DepState', factors: Sequence[float]) -> float:
-        assert len(self.iterations) == len(previous.iterations)
+        """Calculate the required increment from the previous state to the current given the factors that determine
+        the voltage dependency of each index.
+
+        By convention there are only two possible values for each iteration index integer in self: 0 or the last index
+        The three possible increments for each iteration are none, regular and jump to next line.
+        
+        The previous dependency state can have a different iteration length if the trailing factors now or during the
+        last iteration are zero.
+
+        Args:
+            previous: The previous state to calculate the required increment from. It has to belong to the same DepKey.
+            factors: The number of factors has to be the same as the current number of iterations.
+
+        Returns:
+            The increment
+        """
         assert len(self.iterations) == len(factors)
 
         increment = self.base - previous.base

tests/program/linspace_tests.py

@@ -63,6 +63,141 @@ def test_output(self):
         assert_vm_output_almost_equal(self, self.output, vm.history)
 
 
+class SequencedRepetitionTest(TestCase):
+    def setUp(self):
+        
+        base_time = 1e2
+        rep_factor = 2
+          
+        wait = AtomicMultiChannelPT(
+            ConstantPT(f'{base_time}', {'a': '-1. + idx_a * 0.01', }),
+            ConstantPT(f'{base_time}', {'b': '-0.5 + idx_b * 0.05'})
+            )
+        
+        dependent_constant = AtomicMultiChannelPT(
+            ConstantPT(base_time, {'a': '-1.0 '}),
+            ConstantPT(base_time, {'b': '-0.5 + idx_b*0.05',}),            
+            )
+        
+        dependent_constant2 = AtomicMultiChannelPT(
+            ConstantPT(base_time, {'a': '-0.5 '}),
+            ConstantPT(base_time, {'b': '-0.3 + idx_b*0.05',}),            
+            )
+        
+        #not working
+        self.pulse_template = (
+                dependent_constant @
+                dependent_constant2.with_repetition(rep_factor) @
+                wait.with_iteration('idx_a', rep_factor)
+        ).with_iteration('idx_b', rep_factor)
+
+        wait_hold = LinSpaceHold(
+            bases=(-1.0, -0.5),
+            factors=((0.0, 0.01), (0.05, 0.0),),
+            duration_base=TimeType.from_float(base_time),
+            duration_factors=None
+        )
+        dependent_hold_1 = LinSpaceHold(
+            bases=(-1.0, -0.5),
+            factors=(None, (0.05,),),
+            duration_base=TimeType.from_float(base_time),
+            duration_factors=None
+        )
+        dependent_hold_2 = LinSpaceHold(
+            bases=(-0.5, -0.3),
+            factors=(None, (0.05,),),
+            duration_base=TimeType.from_float(base_time),
+            duration_factors=None
+        )
+
+        self.program = LinSpaceIter(
+             length=rep_factor,
+             body=(
+                 dependent_hold_1,
+                 LinSpaceRepeat(body=(dependent_hold_2,), count=rep_factor),
+                 LinSpaceIter(body=(wait_hold,), length=rep_factor),
+             )
+        )
+
+        self.commands = [
+            Set(channel=0, value=-1.0, key=DepKey(factors=())),
+            Set(channel=1, value=-0.5, key=DepKey(factors=(50000000,))),
+            Wait(duration=TimeType(100, 1)),
+
+            Set(channel=0, value=-0.5, key=DepKey(factors=())),
+            Increment(channel=1, value=0.2, dependency_key=DepKey(factors=(50000000,))),
+            Wait(duration=TimeType(100, 1)),
+
+            # This is the repetition
+            LoopLabel(idx=0, count=1),
+                Wait(duration=TimeType(100, 1)),
+            LoopJmp(idx=0),
+
+            Set(channel=0, value=-1.0, key=DepKey(factors=(0, 10000000))),
+            Increment(channel=1, value=-0.2, dependency_key=DepKey(factors=(50000000,))),
+            Wait(duration=TimeType(100, 1)),
+
+            LoopLabel(idx=1, count=1),
+                Increment(channel=0, value=0.01, dependency_key=DepKey(factors=(0, 10000000))),
+                Wait(duration=TimeType(100, 1)),
+            LoopJmp(idx=1),
+
+            LoopLabel(idx=2, count=1),
+                Set(channel=0, value=-1.0, key=DepKey(factors=())),
+                Increment(channel=1, value=0.05, dependency_key=DepKey(factors=(50000000,))),
+                Wait(duration=TimeType(100, 1)),
+                Set(channel=0, value=-0.5, key=DepKey(factors=())),
+                Increment(channel=1, value=0.2, dependency_key=DepKey(factors=(50000000,))),
+                Wait(duration=TimeType(100, 1)),
+
+                # next repetition
+                LoopLabel(idx=3, count=1),
+                    Wait(duration=TimeType(100, 1)),
+                LoopJmp(idx=3),
+
+                Increment(channel=0,
+                   value=-0.01,
+                   dependency_key=DepKey(factors=(0, 10000000))),
+                Increment(channel=1, value=-0.2, dependency_key=DepKey(factors=(50000000,))),
+                Wait(duration=TimeType(100, 1)),
+
+                LoopLabel(idx=4, count=1),
+                    Increment(channel=0, value=0.01, dependency_key=DepKey(factors=(0, 10000000))),
+                    Wait(duration=TimeType(100, 1)),
+                LoopJmp(idx=4),
+            LoopJmp(idx=2)]
+
+        time = TimeType(0)
+        self.output = []
+        for idx_b in range(rep_factor):
+            # does not account yet for floating poit errors. We would need to sum here
+            self.output.append((time, (-1.0, -0.5 + idx_b * 0.05)))
+            time += TimeType.from_float(base_time)
+
+            for _ in range(rep_factor):
+                self.output.append((time, (-0.5, -0.3 + idx_b * 0.05)))
+                time += TimeType.from_float(base_time)
+
+            for idx_a in range(rep_factor):
+                self.output.append((time, (-1.0 + 0.01 * idx_a, -0.5 + idx_b * 0.05)))
+                time += TimeType.from_float(base_time)
+
+    def test_program_1(self):
+        program_builder = LinSpaceBuilder(('a','b'))
+        program_1 = self.pulse_template.create_program(program_builder=program_builder)
+        self.assertEqual([self.program], program_1)
+
+    def test_commands_1(self):
+        commands = to_increment_commands([self.program])
+        self.assertEqual(self.commands, commands)
+
+    def test_output_1(self):
+        vm = LinSpaceVM(2)
+        vm.set_commands(commands=self.commands)
+        vm.run()
+        assert_vm_output_almost_equal(self, self.output, vm.history)
+
+
 class PlainCSDTest(TestCase):
     def setUp(self):
         hold = ConstantPT(10**6, {'a': '-1. + idx_a * 0.01', 'b': '-.5 + idx_b * 0.02'})