def testLoopCombinedParameterPrintTask(self, npoints, x_start_stop, y_start_stop, z_start_stop): x_set = np.linspace(x_start_stop[0], x_start_stop[1], npoints) y_set = np.linspace(y_start_stop[0], y_start_stop[1], npoints) z_set = np.linspace(z_start_stop[0], z_start_stop[1], npoints) setpoints = np.hstack( (x_set.reshape(npoints, 1), y_set.reshape(npoints, 1), z_set.reshape(npoints, 1))) parameters = [ Parameter(name, get_cmd=None, set_cmd=None) for name in ["X", "Y", "Z"] ] sweep_values = combine(*parameters, name="combined").sweep(setpoints) def ataskfunc(): a = 1 + 1 def btaskfunc(): b = 1 + 2 atask = Task(ataskfunc) btask = Task(btaskfunc) loop = Loop(sweep_values).each(atask, btask) data = loop.run(quiet=True) np.testing.assert_array_equal(data.arrays['X'].ndarray, x_set) np.testing.assert_array_equal(data.arrays['Y'].ndarray, y_set) np.testing.assert_array_equal(data.arrays['Z'].ndarray, z_set)
def testLoopCombinedParameterPrintTask(self, npoints, x_start_stop, y_start_stop, z_start_stop): x_set = np.linspace(x_start_stop[0], x_start_stop[1], npoints) y_set = np.linspace(y_start_stop[0], y_start_stop[1], npoints) z_set = np.linspace(z_start_stop[0], z_start_stop[1], npoints) setpoints = np.hstack((x_set.reshape(npoints, 1), y_set.reshape(npoints, 1), z_set.reshape(npoints, 1))) parameters = [Parameter(name, get_cmd=None, set_cmd=None) for name in ["X", "Y", "Z"]] sweep_values = combine(*parameters, name="combined").sweep(setpoints) def ataskfunc(): a = 1+1 def btaskfunc(): b = 1+2 atask = Task(ataskfunc) btask = Task(btaskfunc) loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'printTask'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(sweep_values).each(atask, btask) data = loop.run(location=loc_provider, quiet=True) np.testing.assert_array_equal(data.arrays['X'].ndarray, x_set) np.testing.assert_array_equal(data.arrays['Y'].ndarray, y_set) np.testing.assert_array_equal(data.arrays['Z'].ndarray, z_set)
def test_loop_measure_channels_by_name(dci, values): p1 = Parameter(name='p1', vals=Numbers(-10, 10), get_cmd=None, set_cmd=None) for i in range(4): dci.channels[i].temperature(values[i]) loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'channelsByName'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(p1.sweep(-10, 10, 1), 1e-6).each( dci.A.temperature, dci.B.temperature, dci.C.temperature, dci.D.temperature ) data = loop.run(location=loc_provider) assert data.p1_set.ndarray.shape == (21, ) for i, chan in enumerate(['A', 'B', 'C', 'D']): assert getattr( data, f'dci_Chan{chan}_temperature' ).ndarray.shape == (21,) assert getattr( data, f'dci_Chan{chan}_temperature' ).ndarray.max() == values[i] assert getattr( data, f'dci_Chan{chan}_temperature' ).ndarray.min() == values[i]
def _QCoDeS_Loop(self, measured_parameter, sweeped_parameter, sweep_value=[0, 0, 0], **kw): Sweep_Values = sweeped_parameter[ sweep_value[0]:sweep_value[1]:sweep_value[2]] # Sweep_Values2 = sweeped_parameter2[sweep_value2[0]:sweep_value2[1]:sweep_value2[2]] LOOP = Loop(sweep_values=Sweep_Values).each(measured_parameter) data_set = LOOP.get_data_set( location=None, loc_record={ 'name': 'Chevron Pattern', 'label': 'frequency-burst_time' }, io=self.data_IO, ) data_set = LOOP.run() return data_set
def test_loop_measure_channels_by_name(self, values): p1 = Parameter(name='p1', vals=Numbers(-10, 10), get_cmd=None, set_cmd=None) for i in range(4): self.instrument.channels[i].temperature(values[i]) loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'channelsByName'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(p1.sweep(-10, 10, 1), 1e-6).each(self.instrument.A.temperature, self.instrument.B.temperature, self.instrument.C.temperature, self.instrument.D.temperature) data = loop.run(location=loc_provider) self.assertEqual(data.p1_set.ndarray.shape, (21, )) for i, chan in enumerate(['A', 'B', 'C', 'D']): self.assertEqual( getattr(data, 'testchanneldummy_Chan{}_temperature'.format( chan)).ndarray.shape, (21, )) self.assertEqual( getattr(data, 'testchanneldummy_Chan{}_temperature'.format( chan)).ndarray.max(), values[i]) self.assertEqual( getattr(data, 'testchanneldummy_Chan{}_temperature'.format( chan)).ndarray.min(), values[i])
def test_bad_actors(self): def f(): return 42 class NoName: def get(self): return 42 class HasName: def get(self): return 42 name = 'IHazName!' class HasNames: def get(self): return 42 names = 'Namezz' # first two minimal working gettables Loop(self.p1[1:3:1]).each(HasName()) Loop(self.p1[1:3:1]).each(HasNames()) for bad_action in (f, 42, NoName()): with self.assertRaises(TypeError): # include a good action too, just to make sure we look # at the whole list Loop(self.p1[1:3:1]).each(self.p1, bad_action) with self.assertRaises(ValueError): # invalid sweep values Loop(self.p1[-20:20:1]).each(self.p1)
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)
def testLoopCombinedParameterTwice(self, npoints, x_start_stop, y_start_stop, z_start_stop): x_set = np.linspace(x_start_stop[0], x_start_stop[1], npoints) y_set = np.linspace(y_start_stop[0], y_start_stop[1], npoints) z_set = np.linspace(z_start_stop[0], z_start_stop[1], npoints) setpoints = np.hstack( (x_set.reshape(npoints, 1), y_set.reshape(npoints, 1), z_set.reshape(npoints, 1))) parameters = [ Parameter(name, get_cmd=None, set_cmd=None) for name in ["X", "Y", "Z"] ] sweep_values = combine(*parameters, name="combined").sweep(setpoints) def wrapper(): counter = 0 def inner(): nonlocal counter counter += 1 return counter return inner self.dmm.voltage.get = wrapper() loop = Loop(sweep_values).each(self.dmm.voltage, self.dmm.voltage) data = loop.run(quiet=True) np.testing.assert_array_equal(data.arrays['X'].ndarray, x_set) np.testing.assert_array_equal(data.arrays['Y'].ndarray, y_set) np.testing.assert_array_equal(data.arrays['Z'].ndarray, z_set) np.testing.assert_array_equal(data.arrays['dmm_voltage_0'].ndarray, np.arange(1, npoints * 2, 2)) np.testing.assert_array_equal(data.arrays['dmm_voltage_1'].ndarray, np.arange(2, npoints * 2 + 1, 2))
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)
def test_loop_arrayparameter_by_name(self): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'arrayParamByName'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(self.instrument.A.temperature.sweep(0, 10, 1), 0.1) data = loop.each(self.instrument.A.dummy_array_parameter)\ .run(location=loc_provider) self._verify_array_data(data)
def test_loop_arrayparameter_by_index(dci): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'arrayParamByIndex'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(dci.channels[0].temperature.sweep(0, 10, 1), 0.1) data = loop.each(dci.A.dummy_array_parameter)\ .run(location=loc_provider) _verify_array_data(data)
def test_loop_measure_all_channels(self): p1 = Parameter(name='p1', vals=Numbers(-10, 10), get_cmd=None, set_cmd=None) loop = Loop(p1.sweep(-10, 10, 1), 1e-6).each(self.instrument.channels.temperature) data = loop.run() self.assertEqual(data.p1_set.ndarray.shape, (21, )) self.assertEqual(len(data.arrays), 7) for chan in ['A', 'B', 'C', 'D', 'E', 'F']: self.assertEqual(getattr(data, 'testchanneldummy_Chan{}_temperature'.format(chan)).ndarray.shape, (21,))
def test_loop_slicing_arrayparameter(dci): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'loopSlicing'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(dci.A.temperature.sweep(0, 10, 1), 0.1) data = loop.each(dci.channels[0:2].dummy_array_parameter)\ .run(location=loc_provider) _verify_array_data(data, channels=('A', 'B'))
def test_measurement_with_many_nans(self): loop = Loop(self.p1.sweep(0, 1, num=10), delay=0.05).each(self.p4_crazy) ds = loop.get_data_set() loop.run() # assert that both the snapshot and the datafile are there self.assertEqual(len(os.listdir(ds.location)), 2)
def test_loop_simple(dci): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'loopSimple'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(dci.channels[0].temperature.sweep(0, 300, 10), 0.001).each(dci.A.temperature) data = loop.run(location=loc_provider) assert_array_equal(data.dci_ChanA_temperature_set.ndarray, data.dci_ChanA_temperature.ndarray)
def test_loop_multiparameter_by_name(dci): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'multiParamByName'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(dci.A.temperature.sweep(0, 10, 1), 0.1) data = loop.each(dci.A.dummy_multi_parameter)\ .run(location=loc_provider) _verify_multiparam_data(data) assert 'multi_setpoint_param_this_setpoint_set' in data.arrays.keys()
def test_loop_multiparameter_by_index(self): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'loopByIndex'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(self.instrument.channels[0].temperature.sweep(0, 10, 1), 0.1) data = loop.each(self.instrument.A.dummy_multi_parameter)\ .run(location=loc_provider) self._verify_multiparam_data(data)
def test_delay0(self, sleep_mock): self.p2.set(3) loop = Loop(self.p1[1:3:1]).each(self.p2) self.assertEqual(loop.delay, 0) data = loop.run_temp() self.assertEqual(data.p1_set.tolist(), [1, 2]) self.assertEqual(data.p2.tolist(), [3, 3]) self.assertEqual(sleep_mock.call_count, 0)
def test_halt_quiet(self): p1 = AbortingGetter('p1', count=2, vals=Numbers(-10, 10), msg=ActiveLoop.HALT) loop = Loop(p1[1:6:1], 0.005).each(p1) p1.set_queue(loop.signal_queue) # does not raise, just quits, but the data set looks the same # as in test_halt data = loop.run_temp() self.check_data(data)
def test_breakif(self): nan = float('nan') loop = Loop(self.p1[1:6:1]) data = loop.each(self.p1, BreakIf(self.p1 >= 3)).run_temp() self.assertEqual(repr(data.p1.tolist()), repr([1., 2., 3., nan, nan])) data = loop.each(BreakIf(self.p1.get_latest >= 3), self.p1).run_temp() self.assertEqual(repr(data.p1.tolist()), repr([1., 2., nan, nan, nan])) with self.assertRaises(TypeError): BreakIf(True) with self.assertRaises(TypeError): BreakIf(self.p1.set)
def test_loop_measure_channels_individually(self): p1 = ManualParameter(name='p1', vals=Numbers(-10, 10)) loop = Loop(p1.sweep(-10, 10, 1), 1e-6).each(self.instrument.channels[0].temperature, self.instrument.channels[1].temperature, self.instrument.channels[2].temperature, self.instrument.channels[3].temperature) data = loop.run() self.assertEqual(data.p1_set.ndarray.shape, (21, )) for chan in ['A', 'B', 'C', 'D']: self.assertEqual( getattr(data, 'testchanneldummy_Chan{}_temperature'.format( chan)).ndarray.shape, (21, ))
def test_halt(self): abort_after = 3 self.res = list(np.arange(0, abort_after-1, 1.)) [self.res.append(float('nan')) for i in range(0, abort_after-1)] p1 = AbortingGetter('p1', count=abort_after, vals=Numbers(-10, 10), set_cmd=None) loop = Loop(p1.sweep(0, abort_after, 1), 0.005).each(p1) # we want to test what's in data, so get it ahead of time # because loop.run will not return. data = loop.get_data_set(location=False) loop.run(quiet=True) self.assertEqual(repr(data.p1.tolist()), repr(self.res))
def test_loop_measure_channels_by_name(self, values): p1 = Parameter(name='p1', vals=Numbers(-10, 10), get_cmd=None, set_cmd=None) for i in range(4): self.instrument.channels[i].temperature(values[i]) loop = Loop(p1.sweep(-10, 10, 1), 1e-6).each(self.instrument.A.temperature, self.instrument.B.temperature, self.instrument.C.temperature, self.instrument.D.temperature) data = loop.run() self.assertEqual(data.p1_set.ndarray.shape, (21, )) for i, chan in enumerate(['A', 'B', 'C', 'D']): self.assertEqual(getattr(data, 'testchanneldummy_Chan{}_temperature'.format(chan)).ndarray.shape, (21,)) self.assertEqual(getattr(data, 'testchanneldummy_Chan{}_temperature'.format(chan)).ndarray.max(), values[i]) self.assertEqual(getattr(data, 'testchanneldummy_Chan{}_temperature'.format(chan)).ndarray.min(), values[i])
def test_nesting(self): loop = Loop(self.p1[1:3:1], 0.001).loop(self.p2[3:5:1], 0.001).loop(self.p3[5:7:1], 0.001) active_loop = loop.each(self.p1, self.p2, self.p3) data = active_loop.run_temp() self.assertEqual(data.p1_set.tolist(), [1, 2]) self.assertEqual(data.p2_set.tolist(), [[3, 4]] * 2) self.assertEqual(data.p3_set.tolist(), [[[5, 6]] * 2] * 2) self.assertEqual(data.p1.tolist(), [[[1, 1]] * 2, [[2, 2]] * 2]) self.assertEqual(data.p2.tolist(), [[[3, 3], [4, 4]]] * 2) self.assertEqual(data.p3.tolist(), [[[5, 6]] * 2] * 2)
def test_repr(self): loop2 = Loop(self.p2[3:5:1], 0.001).each(self.p2) loop = Loop(self.p1[1:3:1], 0.001).each(self.p3, self.p2, loop2, self.p1) active_loop = loop data = active_loop.run_temp() expected = ('DataSet:\n' ' location = False\n' ' <Type> | <array_id> | <array.name> | <array.shape>\n' ' Setpoint | p1_set | p1 | (2,)\n' ' Measured | p3 | p3 | (2,)\n' ' Measured | p2_1 | p2 | (2,)\n' ' Setpoint | p2_set | p2 | (2, 2)\n' ' Measured | p2_2_0 | p2 | (2, 2)\n' ' Measured | p1 | p1 | (2,)') self.assertEqual(data.__repr__(), expected)
def test_loop_measure_all_channels(dci): p1 = Parameter(name='p1', vals=Numbers(-10, 10), get_cmd=None, set_cmd=None) loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'allChannels'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(p1.sweep(-10, 10, 1), 1e-6).\ each(dci.channels.temperature) data = loop.run(location=loc_provider) assert data.p1_set.ndarray.shape == (21, ) assert len(data.arrays) == 7 for chan in ['A', 'B', 'C', 'D', 'E', 'F']: assert getattr(data, f'dci_Chan{chan}_temperature').ndarray.shape == (21, )
def set_sweep_with_calibration(self, repetition=False, plot_average=False, **kw): self.plot_average = plot_average for i in range(self.qubit_number): d = i if i == 1 else 2 self.plot.append( QtPlot(window_title='raw plotting qubit_%d' % d, remote=False)) # self.plot.append(MatPlot(figsize = (8,5))) if plot_average: # self.average_plot.append(QtPlot(window_title = 'average data qubit_%d'%d, remote = False)) self.average_plot.append(MatPlot(figsize=(8, 5))) for seq in range(len(self.sequencer)): self.sequencer[seq].set_sweep() self.make_all_segment_list(seq) if repetition is True: count = kw.pop('count', 1) Count_Calibration = StandardParameter(name='Count', set_cmd=self.function) Sweep_Count_Calibration = Count_Calibration[1:2:1] Count = StandardParameter(name='Count', set_cmd=self.delete) Sweep_Count = Count[1:count + 1:1] self.digitizer, self.dig = set_digitizer(self.digitizer, len(self.X_sweep_array), self.qubit_number, self.seq_repetition) loop1 = Loop(sweep_values=Sweep_Count_Calibration).each(self.dig) Loop_Calibration = loop1.with_bg_task( bg_final_task=self.update_calibration, ) calibrated_parameter = update_calibration if self.Loop is None: self.Loop = Loop(sweep_values=Sweep_Count).each( calibrated_parameter, self.dig) else: raise TypeError('calibration not set') return True
def test_loop_measure_channels_individually(dci): p1 = Parameter(name='p1', vals=Numbers(-10, 10), get_cmd=None, set_cmd=None) loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'channelsIndividually'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) loop = Loop(p1.sweep(-10, 10, 1), 1e-6).each(dci.channels[0].temperature, dci.channels[1].temperature, dci.channels[2].temperature, dci.channels[3].temperature) data = loop.run(location=loc_provider) assert data.p1_set.ndarray.shape == (21, ) for chan in ['A', 'B', 'C', 'D']: assert getattr(data, f'dci_Chan{chan}_temperature').ndarray.shape == (21, )
def test_default_measurement(self): self.p2.set(4) self.p3.set(5) data = Loop(self.p1[1:3:1], 0.001).run_temp() self.assertEqual(data.p1_set.tolist(), [1, 2]) self.assertEqual(data.p2.tolist(), [4, 4]) self.assertEqual(data.p3.tolist(), [5, 5]) data = Loop(self.p1[1:3:1], 0.001).each(Loop(self.p2[3:5:1], 0.001)).run_temp() self.assertEqual(data.p1_set.tolist(), [1, 2]) self.assertEqual(data.p2.tolist(), [[3, 4], [3, 4]]) self.assertEqual(data.p2_set.tolist(), [[3, 4], [3, 4]]) self.assertEqual(data.p3.tolist(), [[5, 5]] * 2)
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)