예제 #1
0
    def test_basic(self):
        p1 = AbortingGetter('p1', count=2, vals=Numbers(-10, 10), set_cmd=None)
        sv = p1[1:3:1]
        loop = Loop(sv)

        # not sure why you'd do it, but you *can* snapshot a Loop
        expected = {
            '__class__': 'qcodes.loops.Loop',
            'sweep_values': sv.snapshot(),
            'delay': 0,
            'then_actions': []
        }
        self.assertEqual(loop.snapshot(), expected)
        loop = loop.then(Task(p1.set, 0), Wait(0.123))
        expected['then_actions'] = [{
            'type': 'Task',
            'func': repr(p1.set)
        }, {
            'type': 'Wait',
            'delay': 0.123
        }]

        # then test snapshot on an ActiveLoop
        breaker = BreakIf(lambda: p1.get_latest() > 3)
        self.assertEqual(breaker.snapshot()['type'], 'BreakIf')
        loop = loop.each(p1, breaker)
        expected['__class__'] = 'qcodes.loops.ActiveLoop'
        expected['actions'] = [p1.snapshot(), breaker.snapshot()]

        self.assertEqual(loop.snapshot(), expected)
예제 #2
0
    def test_then_construction(self):
        loop = Loop(self.p1[1:6:1])
        task1 = Task(self.p1.set, 2)
        task2 = Wait(0.02)
        loop2 = loop.then(task1)
        loop3 = loop2.then(task2, task1)
        loop4 = loop3.then(task2, overwrite=True)
        loop5 = loop4.each(self.p1, BreakIf(lambda: self.p1.get() >= 3))
        loop6 = loop5.then(task1)
        loop7 = loop6.then(task1, overwrite=True)

        # original loop is untouched, same as .each and .loop
        self.assertEqual(loop.then_actions, ())

        # but loop2 has the task we asked for
        self.assertEqual(loop2.then_actions, (task1, ))

        # loop3 gets the other tasks appended
        self.assertEqual(loop3.then_actions, (task1, task2, task1))

        # loop4 gets only the new one
        self.assertEqual(loop4.then_actions, (task2, ))

        # tasks survive .each
        self.assertEqual(loop5.then_actions, (task2, ))

        # and ActiveLoop.then works the same way as Loop.then
        self.assertEqual(loop6.then_actions, (task2, task1))
        self.assertEqual(loop7.then_actions, (task1, ))

        # .then rejects Loops and others that are valid loop actions
        for action in (loop2, loop7, BreakIf(lambda: self.p1() >= 3), self.p1,
                       True, 42):
            with self.assertRaises(TypeError):
                loop.then(action)
예제 #3
0
    def test_basic(self):
        p1 = AbortingGetter('p1', count=2, vals=Numbers(-10, 10))
        sv = p1[1:3:1]
        loop = Loop(sv)

        # not sure why you'd do it, but you *can* snapshot a Loop
        expected = {
            '__class__': 'qcodes.loops.Loop',
            'sweep_values': sv.snapshot(),
            'delay': 0,
            'then_actions': []
        }
        self.assertEqual(loop.snapshot(), expected)
        loop = loop.then(Task(p1.set, 0), Wait(0.123))
        expected['then_actions'] = [{
            'type': 'Task',
            'func': repr(p1.set)
        }, {
            'type': 'Wait',
            'delay': 0.123
        }]

        # then test snapshot on an ActiveLoop
        breaker = BreakIf(p1.get_latest > 3)
        self.assertEqual(breaker.snapshot()['type'], 'BreakIf')
        # TODO: once we have reprs for DeferredOperations, test that
        # the right thing shows up in breaker.snapshot()['condition']
        loop = loop.each(p1, breaker)
        expected['__class__'] = 'qcodes.loops.ActiveLoop'
        expected['actions'] = [p1.snapshot(), breaker.snapshot()]

        self.assertEqual(loop.snapshot(), expected)
예제 #4
0
    def test_tasks_waits(self):
        delay0 = 0.01
        delay1 = 0.03
        loop = Loop(self.p1[1:3:1], delay0).each(Task(self.p2.set, -1),
                                                 Wait(delay1), self.p2,
                                                 Task(self.p2.set, 1), self.p2)
        delay_array = []
        loop._monitor = FakeMonitor(delay_array)

        # give it a "process" as if it was run in the bg before,
        # check that this gets cleared
        loop.process = 'TDD'

        data = loop.run_temp()

        self.assertFalse(hasattr(loop, 'process'))

        self.assertEqual(data.p1_set.tolist(), [1, 2])
        self.assertEqual(data.p2_2.tolist(), [-1, -1])
        self.assertEqual(data.p2_4.tolist(), [1, 1])

        self.assertEqual(len(delay_array), 4)
        for i, delay in enumerate(delay_array):
            target = delay1 if i % 2 else delay0
            self.assertLessEqual(delay, target)
            self.assertGreater(delay, target - 0.001)
예제 #5
0
    def test_bad_delay(self):
        for val, err in [(-1, ValueError), (-0.1, ValueError),
                         (None, TypeError), ('forever', TypeError)]:
            with self.assertRaises(err):
                Loop(self.p1[1:3:1], val)

            with self.assertRaises(err):
                Wait(val)
예제 #6
0
 def test_bare_wait(self):
     # Wait gets transformed to a Task, but is also callable on its own
     t0 = time.perf_counter()
     Wait(0.05)()
     delay = time.perf_counter() - t0
     # TODO: On Mac delay is always at least the time you waited, but on
     # Windows it is sometimes less? need to investigate the precision here.
     self.assertGreaterEqual(delay, 0.04)
     self.assertLessEqual(delay, 0.06)
예제 #7
0
 def test_bare_wait(self):
     # Wait gets transformed to a Task, but is also callable on its own
     t0 = time.perf_counter()
     Wait(0.05)()
     delay = time.perf_counter() - t0
     # TODO: On Mac delay is always at least the time you waited, but on
     # Windows it is sometimes less? need to investigate the precision here.
     self.assertGreaterEqual(delay, 0.04)
     # On slow CI machines, there can be a significant additional delay.
     # So what are we even testing here..?
     self.assertLessEqual(delay, 0.07)
예제 #8
0
    def test_then_action(self):
        self.maxDiff = None
        nan = float('nan')
        self.p1.set(5)
        f_calls, g_calls = [], []

        def f():
            f_calls.append(1)

        def g():
            g_calls.append(1)

        breaker = BreakIf(lambda: self.p1() >= 3)
        ts1 = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        # evaluate param snapshots now since later value will change
        p1snap = self.p1.snapshot()
        self.p2.set(2)
        p2snap = self.p2.snapshot()
        self.p3.set(3)
        p3snap = self.p3.snapshot()
        data = Loop(self.p1[1:6:1]).each(self.p1,
                                         breaker).then(Task(self.p1.set, 2),
                                                       Wait(0.01),
                                                       Task(f)).run_temp()
        ts2 = datetime.now().strftime('%Y-%m-%d %H:%M:%S')

        self.assertEqual(repr(data.p1.tolist()), repr([1., 2., 3., nan, nan]))
        self.assertEqual(self.p1.get(), 2)
        self.assertEqual(len(f_calls), 1)

        # this loop makes use of all the features, so use it to test
        # DataSet metadata
        loopmeta = data.metadata['loop']
        default_meas_meta = data.metadata['station']['default_measurement']
        # assuming the whole loop takes < 1 sec, all timestamps
        # should each be the same as one of the bounding times
        self.check_snap_ts(loopmeta, 'ts_start', (ts1, ts2))
        self.check_snap_ts(loopmeta, 'ts_end', (ts1, ts2))
        self.check_snap_ts(loopmeta['sweep_values']['parameter'], 'ts',
                           (ts1, ts2))
        self.check_snap_ts(loopmeta['actions'][0], 'ts', (ts1, ts2))
        self.check_snap_ts(default_meas_meta[0], 'ts', (ts1, ts2, None))
        self.check_snap_ts(default_meas_meta[1], 'ts', (ts1, ts2, None))
        del p1snap['ts'], p2snap['ts'], p3snap['ts']

        self.assertEqual(
            data.metadata, {
                'station': {
                    'instruments': {},
                    'parameters': {},
                    'components': {},
                    'default_measurement': [p2snap, p3snap]
                },
                'loop': {
                    'use_threads':
                    False,
                    '__class__':
                    'qcodes.loops.ActiveLoop',
                    'sweep_values': {
                        'parameter':
                        p1snap,
                        'values': [{
                            'first': 1,
                            'last': 5,
                            'num': 5,
                            'type': 'linear'
                        }]
                    },
                    'delay':
                    0,
                    'actions': [p1snap, breaker.snapshot()],
                    'then_actions': [{
                        'type': 'Task',
                        'func': repr(self.p1.set)
                    }, {
                        'type': 'Wait',
                        'delay': 0.01
                    }, {
                        'type': 'Task',
                        'func': repr(f)
                    }]
                }
            })

        # now test a nested loop with .then inside and outside
        f_calls[:] = []

        Loop(self.p1[1:3:1]).each(
            Loop(self.p2[1:3:1]).each(self.p2).then(Task(g))).then(
                Task(f)).run_temp()

        self.assertEqual(len(f_calls), 1)
        self.assertEqual(len(g_calls), 2)

        # Loop.loop nesting always just makes the .then actions run after
        # the outer loop
        f_calls[:] = []
        Loop(self.p1[1:3:1]).then(Task(f)).loop(self.p2[1:3:1]).each(
            self.p1).run_temp()
        self.assertEqual(len(f_calls), 1)

        f_calls[:] = []
        Loop(self.p1[1:3:1]).loop(self.p2[1:3:1]).then(Task(f)).each(
            self.p1).run_temp()
        self.assertEqual(len(f_calls), 1)

        f_calls[:] = []
        Loop(self.p1[1:3:1]).loop(self.p2[1:3:1]).each(self.p1).then(
            Task(f)).run_temp()
        self.assertEqual(len(f_calls), 1)