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 measure_awg_to_plunger(station, gate, minstrument, scanrange=30, step=0.5):
""" Performing a scan2Dfast measurement, same gate on both axis, where the one axis is sweeped with the awg
and one axis is stepped with the DAC's. Measurement should be centred around an addition line. From the slope
of the addition line the awg to plunger conversion factor can be checked with the function analyse_awg_to_plunger.
Args:
station (QCoDeS station): measurement setup.
gate (str): gate for which the awg to plunger conversion.
minstrument (str, int): list with the name of the measurement instrument (str), and the channel number (int).
scanrange (float): sweep- and steprange (mV), making a square 2d measurement.
step (float): stepsize (mV).
Returns:
result (dict): resultresult (dic): result dictionary of the function measure_awg_to_plunger,
shape: result = {'type': 'awg_to_plunger', 'awg_to_plunger': None, 'dataset': ds.location}.
"""
gates = station.gates
value0 = gates.get(gate)
scanjob = scanjob_t({'sweepdata': {'param': gate, 'range': scanrange}, 'stepdata': {
'param': gate, 'range': scanrange, 'step': step, 'start': value0 - scanrange / 2}})
scanjob['minstrument'] = minstrument
scanjob['minstrumenthandle'] = minstrument
scanjob['Naverage'] = 500
scanjob.setWaitTimes(station)
scanjob['wait_time_startscan'] += .5
ds = scan2Dfast(station, scanjob)
result = {'type': 'awg_to_plunger', 'awg_to_plunger': None, 'dataset': ds.location}
return result
def test_convert_scanjob_vec_regression(self):
station = qcodes.Station()
ivvi = VirtualIVVI(name='ivvi', model=None)
gates = qtt.instrument_drivers.gates.VirtualDAC('gates',
instruments=[ivvi],
gate_map={
'P1': (0, 1),
'P2': (0, 2)
})
station.add_component(gates)
num = 566
scanjob = scanjob_t({
'minstrument': [1],
'minstrumenthandle': ('m4i', [1]),
'wait_time_startscan': 0.04,
'stepdata': {
'wait_time': 0.2
},
'Naverage': 2000,
'sweepdata': {
'period': 0.0005,
'param': 'P1',
'range': -5,
'step': -0.01098901098901099,
'start': 714.84130859375,
'end': 709.84130859375
},
'scantype': 'scan1Dfast'
})
_, s = scanjob._convert_scanjob_vec(station=station, sweeplength=num)
self.assertEqual(len(s), num)
gates.close()
ivvi.close()
def test_fastScan_no_awg(self):
station = MagicMock()
station.awg = None
station.virtual_awg = None
scanjob = scanjob_t({'sweepdata': dict({'param': {'dac1': 1}, 'start': 0, 'range': 10, 'step': 2}), 'minstrument': []})
self.assertEqual(fastScan(scanjob, station), 0)
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_scan1D_no_gates(self):
p = Parameter('p', set_cmd=None)
r = VoltageDivider(p, 4)
scanjob = scanjob_t({'sweepdata': {'param': p, 'start': 0, 'end': 10, 'step': 2}, 'minstrument': [r]})
station=qcodes.Station()
dataset = scan1D(station, scanjob, liveplotwindow=False, verbose=0)
default_record_label = 'scan1D'
self.assertTrue(default_record_label in dataset.location)
def one_dot(fig=None, verbose=0):
nr_dots = 3
station = initialize(reinit=True,
nr_dots=nr_dots,
maxelectrons=2,
verbose=verbose)
gates = station.gates
gv = {
'B0': -300.000,
'B1': 0.487,
'B2': -0.126,
'B3': 0.000,
'D0': 0.111,
'O1': -0.478,
'O2': 0.283,
'O3': 0.404,
'O4': 0.070,
'O5': 0.392,
'P1': 0.436,
'P2': 0.182,
'P3': 39.570,
'SD1a': -0.160,
'SD1b': -0.022,
'SD1c': 0.425,
'bias_1': -0.312,
'bias_2': 0.063
}
gates.resetgates(gv, gv, verbose=verbose)
start = -250
scanjob = scanjob_t({
'sweepdata':
dict({
'param': 'B0',
'start': start,
'end': start + 200,
'step': 4.,
'wait_time': 0.
}),
'minstrument': ['keithley3.amplitude']
})
scanjob['stepdata'] = dict({
'param': 'B1',
'start': start,
'end': start + 200,
'step': 5.
})
data = scan2D(station, scanjob, verbose=verbose)
x = onedotGetBalance(dataset=data, verbose=verbose, fig=fig)
results = x[0]
_, _ = onedotGetBalanceFine(impixel=None,
dd=data,
verbose=verbose,
fig=fig)
plot_onedot(results, ds=data, fig=fig, verbose=verbose)
def test_scanjob_record_label(self):
p = Parameter('p', set_cmd=None)
r = VoltageDivider(p, 4)
record_label='123unittest123'
scanjob = scanjob_t({'sweepdata': dict(
{'param': p, 'start': 0, 'end': 10, 'step': 2, 'wait_time': 0.}), 'minstrument': [r]})
scanjob['dataset_label']=record_label
station=qcodes.Station()
dataset = scan1D(station, scanjob, liveplotwindow=False, verbose=0)
self.assertTrue(dataset.location.endswith(record_label))
def test_convert_scanjob_vec_scan1Dfast_range(self):
gates = VirtualIVVI(
name=qtt.measurements.scans.instrumentName('gates'), model=None)
station = qcodes.Station(gates)
station.gates = gates
# exclusive end-value
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': 'dac1',
'range': 8,
'step': 2
}
})
_, sweepvalues = scanjob._convert_scanjob_vec(station)
actual_values = list(sweepvalues)
expected_values = [-4.0, -2.0, 0.0, 2.0]
for actual_val, expected_val in zip(actual_values, expected_values):
self.assertAlmostEqual(actual_val, expected_val, 12)
self.assertEqual(len(actual_values), 4)
# inclusive end-value
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': 'dac1',
'range': 8,
'step': 2
}
})
_, sweepvalues = scanjob._convert_scanjob_vec(station, sweeplength=5)
actual_values = list(sweepvalues)
expected_values = [-4.0, -2.0, 0.0, 2.0, 4.0]
for actual_val, expected_val in zip(actual_values, expected_values):
self.assertAlmostEqual(actual_val, expected_val, 12)
self.assertEqual(len(actual_values), 5)
gates.close()
def measure_awg_to_plunger(station,
gate,
minstrument,
sweeprange=100,
method='hough'):
""" Perform measurement for awg to plunger using 2D fast scan check?
Args:
station (str): name of station
gate (int): plunger gate number
minstrument:
sweeprange (int): sweeprange in mV?
method: Not used
Returns:
result: (qcodes.DataSet)
"""
from qtt.measurements.scans import scanjob_t
gates = station.gates
value0 = gates.get(gate)
scanjob = scanjob_t({
'sweepdata': {
'param': gate,
'range': sweeprange
},
'stepdata': {
'param': gate,
'range': 100,
'step': 3,
'start': value0 - sweeprange / 2
}
})
scanjob['minstrument'] = minstrument
scanjob['minstrumenthandle'] = minstrument
scanjob['Naverage'] = 100
scanjob.setWaitTimes(station)
scanjob['wait_time_startscan'] += .2
ds = qtt.measurements.scans.scan2Dfast(station, scanjob)
result = {
'type': 'awg_to_plunger',
'awg_to_plunger': None,
'dataset': ds.location
}
return result
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_convert_scanjob_vec_values_raises_exception(self):
p = Parameter('p', set_cmd=None)
gates = VirtualIVVI(
name=qtt.measurements.scans.instrumentName('gates'), model=None)
station = qcodes.Station(gates)
station.gates = gates
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': p,
'start': 20,
'end': 20,
'step': .0075
}
})
self.assertRaises(ValueError, scanjob._convert_scanjob_vec, station)
self.assertRaises(ValueError,
scanjob._convert_scanjob_vec,
station,
sweeplength=1)
gates.close()
def test_convert_scanjob_vec_scan1Dfast_adjust_sweeplength(self):
p = Parameter('p', set_cmd=None)
gates = VirtualIVVI(
name=qtt.measurements.scans.instrumentName('gates'), model=None)
station = qcodes.Station(gates)
station.gates = gates
# inclusive end-value
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': p,
'start': -2,
'end': 2,
'step': .4
}
})
_, sweepvalues = scanjob._convert_scanjob_vec(station, sweeplength=5)
actual_values = list(sweepvalues)
expected_values = [-2.0, -1.0, 0.0, 1.0, 2.0]
self.assertEqual(expected_values, actual_values)
self.assertEqual(len(actual_values), 5)
gates.close()
def test_convert_scanjob_vec_scan1Dfast(self):
p = Parameter('p', set_cmd=None)
gates = VirtualIVVI(
name=qtt.measurements.scans.instrumentName('gates'), model=None)
station = qcodes.Station(gates)
station.gates = gates
# exclusive end-value
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': p,
'start': -2.,
'end': 2.,
'step': .4
}
})
_, sweepvalues = scanjob._convert_scanjob_vec(station)
actual_values = list(sweepvalues)
expected_values = [
-2.0, -1.6, -1.2, -0.8, -0.4, 0.0, 0.4, 0.8, 1.2, 1.6
]
for actual_val, expected_val in zip(actual_values, expected_values):
self.assertAlmostEqual(actual_val, expected_val, 12)
self.assertEqual(len(actual_values), 10)
# exclusive: end - start < step
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': p,
'start': 20,
'end': 20.0050,
'step': .0075
}
})
_, sweepvalues = scanjob._convert_scanjob_vec(station)
actual_values = list(sweepvalues)
expected_values = [20.0]
for actual_val, expected_val in zip(actual_values, expected_values):
self.assertAlmostEqual(actual_val, expected_val, 12)
self.assertEqual(len(actual_values), 1)
# inclusive end-value
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': p,
'start': -2.,
'end': 2.,
'step': .4
}
})
_, sweepvalues = scanjob._convert_scanjob_vec(station, sweeplength=11)
actual_values = list(sweepvalues)
expected_values = [
-2.0, -1.6, -1.2, -0.8, -0.4, 0.0, 0.4, 0.8, 1.2, 1.6, 2.0
]
for actual_val, expected_val in zip(actual_values, expected_values):
self.assertAlmostEqual(actual_val, expected_val, 12)
self.assertEqual(len(actual_values), 11)
gates.close()
logviewer.show()
#%% Read out instruments
print('value: %f' % keithley3.readnext())
snapshotdata = station.snapshot()
#%% Simple 1D scan loop
param_left = station.model.bottomgates[0]
param_right = station.model.bottomgates[-1]
scanjob = scanjob_t({
'sweepdata':
dict({
'param': param_right,
'start': -500,
'end': 1,
'step': .8,
'wait_time': 3e-3
}),
'minstrument': ['keithley3.amplitude']
})
data1d = qtt.measurements.scans.scan1D(station,
scanjob,
location=None,
verbose=1)
#%% Save the current state of the system to disk
save_state(station)
#%% Print the scanned data
gates = VirtualIVVI('gates', gates=['P1', 'P2'], model=None)
station = Station(virtual_awg, scope_reader.adapter.instrument, awg_adapter.instrument, gates)
#%% Enable the stimulus
demodulator = 1
signal_output = 1
oscillator = demodulator
update_stimulus(is_enabled=True, signal_output=signal_output, amplitude=0.1, oscillator=oscillator)
#%% Sensing a resonance
signal_input = signal_output
scanjob = scanjob_t(wait_time_startscan=1)
scanjob.add_sweep(param=stimulus.set_oscillator_frequency(oscillator), start=140e6, end=180e6, step=0.2e6)
scanjob.add_minstrument([scope_reader.acquire_single_sample(demodulator, 'R', partial=True),
scope_reader.acquire_single_sample(demodulator, 'x', partial=True),
scope_reader.acquire_single_sample(demodulator, 'y', partial=True)])
data_set = scan1D(station, scanjob)
plt.clf()
plt.plot(data_set.arrays[f'oscillator{demodulator}_freq'], data_set.arrays[f'demod{demodulator}_R'])
plt.plot(data_set.arrays[f'oscillator{demodulator}_freq'], data_set.arrays[f'demod{demodulator}_x'])
plt.plot(data_set.arrays[f'oscillator{demodulator}_freq'], data_set.arrays[f'demod{demodulator}_y'])
plt.show()
#%% 1D readout
from qtt.instrument_drivers.gates import VirtualDAC
from qtt.instrument_drivers.virtual_instruments import VirtualIVVI
from qcodes.station import Station
ivvi = VirtualIVVI(name='ivvi', model=None)
gates = VirtualDAC('gates', [ivvi], {'C1': (0, 1), 'C2': (0, 2)})
station = Station(ivvi, gates, virtual_awg, awg_1, digitizer)
#%%
from qtt.measurements.scans import scan1Dfast, scanjob_t
scanjob = scanjob_t({'minstrument': [1],'Naverage':100,'wait_time_start_scan':2,
'sweepdata': {'param': 'C2','start': 100,'end': 250, 'step': 1,'wait_time': 0.28}})
dataset_measurement_fast = scan1Dfast(station, scanjob)
logviewer = DataViewer()
logviewer.show()
#%%
vm = VideoMode(station, 'C1', 50, minstrument=(digitizer.name,[3]), resolution = 50, diff_dir=[None, 'g'])
vm.stopreadout()
vm.updatebg()
#%%
def test_convert_scanjob_vec_scan1Dfast_adjust_sweeplength_adjusted_end(
self):
p = Parameter('p', set_cmd=None)
gates = VirtualIVVI(
name=qtt.measurements.scans.instrumentName('gates'), model=None)
station = qcodes.Station(gates)
station.gates = gates
# exclusive end-value
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': p,
'start': -20,
'end': 20,
'step': .0075
}
})
_, sweepvalues = scanjob._convert_scanjob_vec(station)
actual_values = list(sweepvalues)
self.assertEqual(actual_values[0], -20.0)
self.assertAlmostEqual(actual_values[-1], 20.0 - 0.0025, 10)
self.assertEqual(len(actual_values), 5334)
# inclusive end-value
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': p,
'start': -20,
'end': 20,
'step': .0075
}
})
_, sweepvalues = scanjob._convert_scanjob_vec(station,
sweeplength=40 / .0075 +
1)
actual_values = list(sweepvalues)
self.assertEqual(actual_values[0], -20.0)
self.assertAlmostEqual(actual_values[-1], 20.0 - .0025, 10)
self.assertAlmostEqual(scanjob['sweepdata']['end'], 20, 10)
self.assertEqual(len(actual_values), 5334)
# exclusive end-value
scanjob = scanjob_t({
'scantype':
'scan1Dfast',
'sweepdata':
dict({
'param': p,
'start': -500,
'end': 1,
'step': .8,
'wait_time': 3e-3
})
})
_, sweepvalues = scanjob._convert_scanjob_vec(station)
actual_values = list(sweepvalues)
self.assertEqual(actual_values[0], -500.0)
self.assertAlmostEqual(actual_values[-1], 1 - 0.2, 10)
self.assertAlmostEqual(scanjob['sweepdata']['end'], 1, 10)
self.assertEqual(len(actual_values), 627)
# inclusive end-value
scanjob = scanjob_t({
'scantype':
'scan1Dfast',
'sweepdata':
dict({
'param': p,
'start': -500,
'end': 1,
'step': .8,
'wait_time': 3e-3
})
})
_, sweepvalues = scanjob._convert_scanjob_vec(station,
sweeplength=(501 / .8) +
1)
actual_values = list(sweepvalues)
self.assertEqual(actual_values[0], -500.0)
self.assertAlmostEqual(actual_values[-1], 0.8, 10)
self.assertAlmostEqual(scanjob['sweepdata']['end'], 1, 10)
self.assertEqual(len(actual_values), 627)
gates.close()
def test_convert_scanjob_vec_range_values_will_not_raise_exception(self):
p = Parameter('p', set_cmd=None)
gates = VirtualIVVI(
name=qtt.measurements.scans.instrumentName('gates'), model=None)
station = qcodes.Station(gates)
station.gates = gates
idx = 1
for idx in range(1, 5):
for start in range(-5, 1):
for end in range(1, 5):
for step_in_range in range(1, 5):
step = step_in_range / (idx * 10)
# exclusive end-value
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': p,
'start': start,
'end': end,
'step': step
}
})
_ = scanjob._convert_scanjob_vec(station)
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': p,
'start': start,
'end': end,
'step': step
}
})
# inclusive end-value
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': p,
'start': start,
'end': end,
'step': step
}
})
# generate a sweeplength so that the step-value doesn't change
_ = scanjob._convert_scanjob_vec(
station, sweeplength=((end - start) / step) + 1)
scanjob = scanjob_t({
'scantype': 'scan1Dfast',
'sweepdata': {
'param': p,
'start': start,
'end': end,
'step': step
}
})
# all the conversions were successful
self.assertEqual(idx, 4)
gates.close()
