def do0d(*inst_meas, do_plots=True, use_threads=False):
"""
Args:
*inst_meas:
do_plots: Default True: If False no plots are produced.
Data is still saved and can be displayed with show_num.
use_threads: If True and if multiple things are being measured,
multiple threads will be used to parallelise the waiting.
Returns:
plot, data : returns the plot and the dataset
"""
measurement = qc.Measure(*inst_meas)
meas_params = _select_plottables(inst_meas)
plot, data = _do_measurement_single(
measurement, meas_params, do_plots=do_plots, use_threads=use_threads)
return plot, data
def doFastSweep(self, start: float, stop: float, steps: int,
mode: str) -> DataSet:
"""
Perform a fast sweep using a deployed lua script and
return a QCoDeS DataSet with the sweep.
Args:
start: starting sweep value (V or A)
stop: end sweep value (V or A)
steps: number of steps
mode: What kind of sweep to make.
'IV' (I versus V) or 'VI' (V versus I)
"""
# prepare setpoints, units, name
self.fastsweep.prepareSweep(start, stop, steps, mode)
data = qc.Measure(self.fastsweep).run()
return data
def measure(meas_param, do_plots=True):
"""
Function which measures the specified parameter and optionally
plots the results.
Args:
meas_param: parameter to measure
do_plots: Default True: If False no plots are produced.
Data is still saved and can be displayed with show_num.
Returns:
data (qcodes dataset)
plot: QT plot
"""
measurement = qc.Measure(meas_param)
meas_params = _select_plottables(meas_param)
plot, data = _do_measurement_single(measurement,
meas_params,
do_plots=do_plots)
return data, plot
def test_can_measure(self):
qcodes.Measure(self.param).run()
"""
import qcodes as qc
from qdev_wrappers.alazar_controllers.alazar_channel import AlazarChannel
alazar_ctrl.int_delay(2e-7)
alazar_ctrl.int_time(2e-6)
#%%
alazar_sample_chan.num_averages(1000)
alazar_sample_chan.alazar_channel('A')
alazar_sample_chan.prepare_channel()
# Measure this
data1 = qc.Measure(alazar_sample_chan.data).run()
qc.MatPlot(data1.AlazarController_AlazarSampleChannel_data)
#%%
alazar_records_chan.num_averages(1000)
alazar_records_chan.records_per_buffer(100)
alazar_records_chan.alazar_channel('A')
alazar_records_chan.prepare_channel()
# Measure this
data1 = qc.Measure(alazar_records_chan.data).run()
qc.MatPlot(data1.AlazarController_AlazarRecordChannel_data)
#%%
def initialize_measurement(self):
self.measurement = qc.Measure(self.acquisition_parameter)
return self.measurement
