def setUp(self):
gate_map = {
'T': (0, 15), 'P1': (0, 3), 'P2': (0, 4),
'L': (0, 5), 'D1': (0, 6), 'R': (0, 7)}
self.ivvi = VirtualIVVI(instrumentName('ivvi'), model=None)
self.gates = VirtualDAC(instrumentName('gates'), instruments=[self.ivvi], gate_map=gate_map)
def test_scan1D(self, verbose=0):
p = Parameter('p', set_cmd=None)
q = Parameter('q', set_cmd=None)
r = VoltageDivider(p, 4)
_ = MultiParameter(instrumentName('multi_param'), [p, q])
gates = VirtualIVVI(
name=qtt.measurements.scans.instrumentName('gates'), model=None)
station = qcodes.Station(gates)
station.gates = gates
if verbose:
print('test_scan1D: running scan1D')
scanjob = scanjob_t({'sweepdata': dict(
{'param': p, 'start': 0, 'end': 10, 'step': 2, 'wait_time': 0.}), 'minstrument': [r]})
_ = scan1D(station, scanjob, liveplotwindow=False, verbose=0)
scanjob = scanjob_t({'sweepdata': dict(
{'param': p, 'start': 0, 'end': 10, 'step': 2, 'wait_time': 0.}), 'minstrument': [q, r]})
_ = scan1D(station, scanjob, liveplotwindow=False, verbose=0)
scanjob = scanjob_t({'sweepdata': dict(
{'param': 'dac1', 'start': 0, 'end': 10, 'step': 2}), 'minstrument': [r]})
_ = scan1D(station, scanjob, liveplotwindow=False, verbose=0)
scanjob = scanjob_t({'sweepdata': dict(
{'param': {'dac1': 1}, 'start': 0, 'range': 10, 'step': 2}), 'minstrument': [r]})
data = scan1D(station, scanjob, liveplotwindow=False, verbose=0, extra_metadata={'hi': 'world'})
self.assertTrue('hi' in data.metadata)
gates.close()
def test_set_dacs(self):
virtual_dac = VirtualDAC(instrumentName('gates'),
instruments=[],
gate_map={})
virtual_dac.add_instruments([self.ivvi])
self.assertIs(self.ivvi, virtual_dac.instruments[0])
virtual_dac.close()
def test_add_instruments(self):
ivvi1 = VirtualIVVI(instrumentName('ivvi'), model=None)
ivvi2 = VirtualIVVI(instrumentName('ivv2'), model=None)
instruments = [ivvi1, ivvi2]
virtual_dac = VirtualDAC(instrumentName('gates'), instruments=[], gate_map={})
virtual_dac.add_instruments(instruments)
self.assertEqual(2, len(virtual_dac.instruments))
self.assertEqual(instruments, virtual_dac.instruments)
virtual_dac.add_instruments(instruments)
self.assertEqual(2, len(virtual_dac.instruments))
self.assertEqual(instruments, virtual_dac.instruments)
virtual_dac.close()
ivvi1.close()
ivvi2.close()
def test_named_instruments(self):
gate_map = {'P1': (0, 1), 'P2': (0, 2), 'P1named': (self.ivvi.name, 1)}
gates = VirtualDAC(instrumentName('gates'), instruments=[self.ivvi], gate_map=gate_map)
expected_value = 20.
gates.P1.set(expected_value)
self.assertEqual(gates.P1named.get(), expected_value)
gates.close()
def test_mock2d(self):
np.random.seed(2019)
mock_callback = MockCallback_2d(instrumentName('dummy2d'))
data_reshaped = mock_callback()
mock_callback.close()
self.assertEqual(data_reshaped.size, 6400)
self.assertAlmostEqual(data_reshaped.min(), 2.996900483446681e-05, 6)
self.assertAlmostEqual(data_reshaped.max(), 4.122574793363507, 6)
self.assertAlmostEqual(data_reshaped.sum(), 3440.344282085355, 3)
def test_restrict_boundaries(self):
gate_map = {'P1': (0, 1), 'P2': (0, 2), 'P3': (0, 3)}
virtual_dac = VirtualDAC(instrumentName('test'), instruments=[self.ivvi], gate_map=gate_map)
gate_boundaries = {'P1': (0, 100), 'P2': (0, 100)}
virtual_dac.set_boundaries(gate_boundaries)
virtual_dac.restrict_boundaries({'P1': (-50, 50), 'P3': (0, 1)})
self.assertEqual(virtual_dac.get_boundaries(), {'P1': (0, 50), 'P2': (0, 100), 'P3': (0, 1)})
self.assertEqual(self.ivvi.dac1.vals.valid_values, (0, 50))
virtual_dac.close()
def test_get_boundaries(self):
gate_map = {'P1': (0, 1), 'P2': (0, 2), 'P3': (0, 3)}
virtual_dac = VirtualDAC(instrumentName('gates'), instruments=[self.ivvi], gate_map=gate_map)
gate_boundaries = {'P1': (0, 1), 'P2': (-42, 42), 'P3': (-100, 100)}
virtual_dac.set_boundaries(gate_boundaries)
boundaries = virtual_dac.get_boundaries()
self.assertDictEqual(gate_boundaries, boundaries)
virtual_dac.close()
def test_get_instrument_parameter(self):
instrument = VirtualIVVI(instrumentName('test'), None)
ix, p = get_instrument_parameter((instrument.name, 'dac2'))
self.assertEqual(id(ix), id(instrument))
self.assertEqual(id(p), id(instrument.dac2))
ix, p = get_instrument_parameter((instrument, 'dac2'))
self.assertEqual(id(p), id(instrument.dac2))
ix, p = get_instrument_parameter(instrument.name + '.dac2')
self.assertEqual(id(p), id(instrument.dac2))
instrument.close()
def test_VirtualGates_serialization(self):
""" Test for virtual gates object """
gates = VirtualIVVI(
name=instrumentName('ivvi_dummy_serialization_test'),
model=None,
gates=['P1', 'P2', 'P3', 'P4'])
virts = VirtualGates(instrumentName('testvgates'), gates,
self.crosscap_map)
vgdict = virts.to_dictionary()
vx = VirtualGates.from_dictionary(vgdict,
gates,
name=instrumentName('vgdummy'))
np.testing.assert_almost_equal(vx.get_crosscap_matrix_inv(),
virts.get_crosscap_matrix_inv())
self.assertTrue(vx.pgates() == ['P%d' % i for i in range(1, 4)])
vx.close()
gates.close()
virts.close()
def test_scan2D(verbose=0):
p = Parameter('p', set_cmd=None)
q = Parameter('q', set_cmd=None)
r = VoltageDivider(p, 4)
_ = MultiParameter(instrumentName('multi_param'), [p, q])
gates = VirtualIVVI(
name=qtt.measurements.scans.instrumentName('gates'), model=None)
station = qcodes.Station(gates)
station.gates = gates
if verbose:
print('test_scan2D: running scan2D')
scanjob = scanjob_t({'sweepdata': dict(
{'param': p, 'start': 0, 'end': 10, 'step': 2}), 'minstrument': [r]})
scanjob['stepdata'] = dict(
{'param': q, 'start': 24, 'end': 30, 'step': 1.})
_ = scan2D(station, scanjob, liveplotwindow=False, verbose=0)
scanjob = scanjob_t({'sweepdata': dict({'param': {
'dac1': 1, 'dac2': .1}, 'start': 0, 'range': 10, 'step': 2}), 'minstrument': [r]})
scanjob['stepdata'] = dict(
{'param': {'dac2': 1}, 'start': 24, 'range': 6, 'end': np.NaN, 'step': 1.})
_ = scan2D(station, scanjob, liveplotwindow=False, verbose=0)
scanjob = scanjob_t({'sweepdata': dict(
{'param': {'dac1': 1}, 'start': 0, 'range': 10, 'step': 2}), 'minstrument': [r]})
scanjob['stepdata'] = {'param': MultiParameter('multi_param', [gates.dac2, gates.dac3])}
scanjob['stepvalues'] = np.array([[2 * i, 3 * i] for i in range(10)])
try:
with warnings.catch_warnings():
warnings.simplefilter('ignore')
data = scan2D(station, scanjob, liveplotwindow=False, verbose=0)
except Exception as ex:
print(ex)
warnings.warn('MultiParameter test failed!')
# not supported:
try:
scanjob = scanjob_t({'sweepdata': dict({'param': {
'dac1': 1}, 'start': 0, 'range': 10, 'step': 2, 'wait_time': 0.}), 'minstrument': [r]})
scanjob['stepdata'] = dict(
{'param': q, 'start': 24, 'range': 6, 'end': np.NaN, 'step': 1.})
_ = scan2D(station, scanjob, liveplotwindow=False, verbose=0)
except Exception as ex:
if verbose:
print('combination of Parameter and vector argument not supported')
gates.close()
def test_set_gate_map(self):
gate_map = {'P1': (0, 1), 'P2': (0, 2), 'P3': (0, 3)}
virtual_dac = VirtualDAC(instrumentName('gates'), instruments=[self.ivvi], gate_map=gate_map)
self.assertDictEqual(gate_map, virtual_dac.gate_map)
self.assertTrue(hasattr(virtual_dac, 'P1'))
self.assertTrue(hasattr(virtual_dac, 'P2'))
self.assertTrue(hasattr(virtual_dac, 'P3'))
new_gate_map = {'C1': (0, 11), 'C2': (0, 12), 'C3': (0, 13)}
virtual_dac.gate_map = new_gate_map
self.assertFalse(hasattr(virtual_dac, 'P1'))
self.assertFalse(hasattr(virtual_dac, 'P2'))
self.assertFalse(hasattr(virtual_dac, 'P3'))
self.assertTrue(hasattr(virtual_dac, 'C1'))
self.assertTrue(hasattr(virtual_dac, 'C2'))
self.assertTrue(hasattr(virtual_dac, 'C3'))
self.assertDictEqual(new_gate_map, virtual_dac.gate_map)
virtual_dac.close()
def test_convert_scanjob_vec_scan2Dfast(self):
p = Parameter('p', set_cmd=None)
q = Parameter('q', set_cmd=None)
r = VoltageDivider(p, 4)
_ = MultiParameter(instrumentName('multi_param'), [p, q])
gates = VirtualIVVI(
name=qtt.measurements.scans.instrumentName('gates'), model=None)
station = qcodes.Station(gates)
station.gates = gates
scanjob = scanjob_t({
'scantype':
'scan2Dfast',
'sweepdata':
dict({
'param': p,
'start': 0,
'end': 10,
'step': 4
}),
'minstrument': [r]
})
scanjob['stepdata'] = dict({
'param': q,
'start': 24,
'end': 32,
'step': 1.
})
stepvalues, sweepvalues = scanjob._convert_scanjob_vec(station, 3, 5)
actual_stepvalues = list(stepvalues)
expected_stepvalues = [24.0, 28.0, 32.0]
self.assertEqual(expected_stepvalues, actual_stepvalues)
self.assertEqual(len(actual_stepvalues), 3)
actual_sweepvalues = list(sweepvalues)
expected_sweepvalues = [0, 2.5, 5.0, 7.5, 10.0]
self.assertEqual(expected_sweepvalues, actual_sweepvalues)
self.assertEqual(len(actual_sweepvalues), 5)
gates.close()
def test_virtual_gates(verbose=0):
""" Test for virtual gates object """
from qtt.instrument_drivers.virtual_instruments import VirtualIVVI
from qtt.measurements.scans import instrumentName
import pickle
gates = VirtualIVVI(name=instrumentName('testivvi'),
model=None,
gates=['P1', 'P2', 'P3', 'P4'])
crosscap_map = OrderedDict(
(('VP1', OrderedDict((('P1', 1), ('P2', 0.6), ('P3', 0)))),
('VP2', OrderedDict((('P1', 0.3), ('P2', 1), ('P3', 0.3)))),
('VP3', OrderedDict((('P1', 0), ('P2', 0), ('P3', 1))))))
vgates = virtual_gates(instrumentName('testvgates'), gates, crosscap_map)
vp1 = vgates.VP1()
if verbose:
print('before set: VP1 {}'.format(vp1))
vgates.VP1.set(10)
vp1 = vgates.VP1()
if verbose:
print('after set: VP1 {}'.format(vp1))
vgates.VP1.set(10)
vp1 = vgates.VP1()
if verbose:
print('after second set: VP1 {}'.format(vp1))
vgates_matrix = vgates.convert_map_to_matrix(crosscap_map)
_ = vgates.convert_matrix_to_map(vgates_matrix)
vgates.multi_set({'VP1': 10, 'VP2': 20, 'VP3': 30})
all_values = vgates.allvalues()
crosscap_matrix = vgates.get_crosscap_matrix()
assert (crosscap_matrix[0][0] == 1.0)
assert (crosscap_matrix[0][1] == 0.6)
vgates.set_distances(1.0 / np.arange(1, 5))
_ = vgates.to_dictionary()
pickled_virtual_gates = pickle.dumps(vgates)
extended_vgates = pickle.loads(pickled_virtual_gates)
v_gates = vgates.vgates() + ['vP4']
p_gates = vgates.pgates() + ['P4']
extended_vgates = extend_virtual_gates(v_gates,
p_gates,
vgates,
name='vgates')
if verbose:
extended_vgates.print_matrix()
_ = update_cc_matrix(vgates, update_cc=np.eye(3), verbose=0)
update_matrix = 0.1 * np.random.rand(3, 3)
np.fill_diagonal(update_matrix, 1)
# test normalization of virtual gate matrix
extended_vgates, _, _ = update_cc_matrix(vgates,
update_cc=update_matrix,
verbose=0)
np.testing.assert_almost_equal(
extended_vgates.get_crosscap_matrix(),
update_matrix.dot(vgates.get_crosscap_matrix()))
# test normalization of virtual gate matrix
serialized_matrix = extended_vgates.get_crosscap_matrix()
extended_vgates.normalize_matrix()
crosscap_matrix = extended_vgates.get_crosscap_matrix()
for row in range(serialized_matrix.shape[0]):
np.testing.assert_almost_equal(
serialized_matrix[row] / serialized_matrix[row][row],
crosscap_matrix[row])
assert (np.all(crosscap_matrix.diagonal() == 1.0))
vgates.close()
extended_vgates.close()
gates.close()
def test_VirtualGates(self, verbose=0):
""" Test for virtual gates object """
gates = VirtualIVVI(name=instrumentName('testivvi'),
model=None,
gates=['P1', 'P2', 'P3', 'P4'])
vgates = VirtualGates(instrumentName('testvgates'), gates,
self.crosscap_map)
vp1 = vgates.VP1()
if verbose:
print('before set: VP1 {}'.format(vp1))
vgates.VP1.set(10)
vp1 = vgates.VP1()
if verbose:
print('after set: VP1 {}'.format(vp1))
vgates.VP1.set(10)
vp1 = vgates.VP1()
if verbose:
print('after second set: VP1 {}'.format(vp1))
vgates_matrix = vgates.convert_map_to_matrix(self.crosscap_map)
_ = vgates.convert_matrix_to_map(vgates_matrix)
vgates.multi_set({'VP1': 10, 'VP2': 20, 'VP3': 30})
all_values = vgates.allvalues()
self.assertTrue(isinstance(all_values, dict))
crosscap_matrix = vgates.get_crosscap_matrix()
self.assertEqual(1.0, crosscap_matrix[0][0])
self.assertEqual(0.6, crosscap_matrix[0][1])
vgates.set_distances(1.0 / np.arange(1, 5))
vgates_dictionary = vgates.to_dictionary()
vgates_new = VirtualGates.from_dictionary(vgates_dictionary, gates,
'new_vgates')
self.assertEqual(vgates_new.name, 'new_vgates')
self.assertEqual(vgates_new.pgates(), vgates.pgates())
vgates_new.close()
v_gates = vgates.vgates() + ['vP4']
p_gates = vgates.pgates() + ['P4']
extended_vgates = extend_virtual_gates(v_gates,
p_gates,
vgates,
name='vgates')
if verbose:
extended_vgates.print_matrix()
extended_vgates.close()
newvg, _, _ = update_cc_matrix(vgates,
update_cc=np.eye(3),
verbose=verbose)
newvg.close()
update_matrix = 0.1 * np.random.rand(3, 3)
np.fill_diagonal(update_matrix, 1)
# test normalization of virtual gate matrix
extended_vgates, _, _ = update_cc_matrix(vgates,
update_cc=update_matrix,
verbose=verbose)
np.testing.assert_almost_equal(
extended_vgates.get_crosscap_matrix(),
update_matrix.dot(vgates.get_crosscap_matrix()))
# test normalization of virtual gate matrix
serialized_matrix = extended_vgates.get_crosscap_matrix()
extended_vgates.normalize_matrix()
crosscap_matrix = extended_vgates.get_crosscap_matrix()
for row in range(serialized_matrix.shape[0]):
np.testing.assert_almost_equal(
serialized_matrix[row] / serialized_matrix[row][row],
crosscap_matrix[row])
cc_matrix_diagonal = crosscap_matrix.diagonal()
np.testing.assert_almost_equal(cc_matrix_diagonal, 1.)
vgates.close()
extended_vgates.close()
gates.close()
