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)
