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()