qtt.measurements package

Contains functions and structures for performing measurements

Subpackages

• qtt.measurements.acquisition package
  • Subpackages
    • qtt.measurements.acquisition.interfaces package
      • Submodules
      • qtt.measurements.acquisition.interfaces.acquisition_interface module
      • qtt.measurements.acquisition.interfaces.acquisition_scope_interface module
  • Submodules
  • qtt.measurements.acquisition.configuration_storage module
  • qtt.measurements.acquisition.uhfli_scope_reader module
  • qtt.measurements.acquisition.uhfli_stimulus module
• qtt.measurements.post_processing package
  • Subpackages
    • qtt.measurements.post_processing.interfaces package
      • Submodules
      • qtt.measurements.post_processing.interfaces.signal_processor_interface module
  • Submodules
  • qtt.measurements.post_processing.process_sawtooth_1d module
  • qtt.measurements.post_processing.process_sawtooth_2d module
  • qtt.measurements.post_processing.signal_processor_runner module

Submodules

qtt.measurements.scans module

Basic scan functions

This module contains functions for basic scans, e.g. scan1D, scan2D, etc. This is part of qtt.

qtt.measurements.scans.acquire_segments(station, parameters, average=True, mV_range=2000, save_to_disk=True, location=None, verbose=True, trigger_re_arm_compensation=False, trigger_re_arm_padding=True)

Record triggered segments as time traces into dataset. AWG must be already sending a trigger pulse per segment.

Note that if the requested period is equal or longer than the period on the AWG, then not all trigger events might be used by the M4i.

The saving to disk can take minutes or even longer.

Parameters

parameters (dict) –

dictionary containing the following compulsory parameters: minstrhandle (instrument handle): measurement instrument handle (m4i digitizer). read_ch (list of int): channel numbers to record. period (float): time in seconds to record for each segment. nsegments (int): number of segments to record. average (bool): if True, dataset will contain a single time trace with the average of all acquired segments;

if False, dataset will contain nsegments single time trace acquisitions.

verbose (bool): print to the console.

Returns

time trace(s) of the segments acquired.

Return type

alldata (dataset)

qtt.measurements.scans.awgGate(gate, station)

Return True if the specified gate can be controlled by the AWG

qtt.measurements.scans.ceilN(x, n)

qtt.measurements.scans.checkReversal(im0, verbose=0)

Check sign of a current scan

We assume that the current is either zero or positive Needed when the keithley (or some other measurement device) has been reversed

Parameters

im0 (array) – measured data

Returns

bool

qtt.measurements.scans.createScanJob(g1, r1, g2=None, r2=None, step=- 1, keithleyidx='keithley1')

Create a scan job

Parameters

• (str) (g1) –

• (array (r2) –

• list) (Range to step) –

• (str (g2) –

• optional) (Step value (default is -1)) –

• (array –

• list) –

• (int (step) –

• optional) –

qtt.measurements.scans.create_vectorscan(virtual_parameter, g_range=1, sweeporstepdata=None, remove_slow_gates=False, station=None, start=0, step=None)

Converts the sweepdata or stepdata of a scanjob in those needed for virtual vector scans

Parameters

• virtual_parameter (obj) – parameter of the virtual gate which is varied

• g_range (float) – scan range (total range)

• remove_slow_gates – Removes slow gates from the linear combination of gates. Useful if virtual gates include

• of slow gates (compensation) –

• a fast measurement should be run. (but) –

• station (None or qcodes.Station) – Used to access the virtual awg

• start (float) – start if the scanjob data

• step (None or float) – if not None, then add to the scanning field

Returns

sweepdata or stepdata needed in the scanjob for virtual vector scans

Return type

sweep_or_stepdata (dict)

qtt.measurements.scans.enforce_boundaries(scanjob, sample_data, eps=0.01)

Make sure a scanjob does not go outside sample boundaries

Parameters

• scanjob (scanjob_t or dict) –

• sample_data (sample_data_t) –

qtt.measurements.scans.fastScan(scanjob, station)

Returns whether we can do a fast scan using an awg

Parameters

scanjob –

Returns

f (int): 0: no fast scan possible, 1: scan2Dfast, 2: all axis

qtt.measurements.scans.fixReversal(im0, verbose=0)

Fix sign of a current scan

We assume that the current is either zero or positive Needed when the keithley (or some other measurement device) has been reversed

qtt.measurements.scans.floorN(x, n)

qtt.measurements.scans.getDefaultParameter(data)

Return name of the main array in the dataset

qtt.measurements.scans.get_instrument(instr, station=None)

Return handle to instrument

Parameters

instr (str, Instrument, tuple, list) – name of instrument or handle or pair (handle, channel)

qtt.measurements.scans.get_instrument_parameter(handle)

Return handle to instrument parameter or channel

Parameters

• handle (tuple or str) – name of instrument or handle. Tuple is a pair (instrument, paramname). A string is

• the form 'instrument.parameter' (of) –

• 'keithley3.amplitude' (e.g.) –

Returns

h (object)

qtt.measurements.scans.get_measurement_params(station, mparams)

Get qcodes parameters from an index or string or parameter

qtt.measurements.scans.get_minstrument_channels(minstrument)

qtt.measurements.scans.get_param(gates, sweepgate)

Get qcodes parameter from scanjob argument

qtt.measurements.scans.get_param_name(gates, sweepgate)

Get qcodes parameter name from scanjob argument

qtt.measurements.scans.get_sampling_frequency(instrument_handle)

Return sampling frequency of acquisition device

Parameters

instrument_handle (str or Instrument) – handle to instrument

Returns

sampling frequency

Return type

float

qtt.measurements.scans.get_uhfli_scope_records(device, daq, scopeModule, number_of_records=1, timeout=30)

Obtain scope records from the device using an instance of the Scope Module.

qtt.measurements.scans.instrumentName(namebase)

Return name for qcodes instrument that is available

Parameters

namebase (str) –

Returns

name (str)

qtt.measurements.scans.lin_comb_type

alias of dict

qtt.measurements.scans.makeDataset_sweep(data, sweepgate, sweeprange, sweepgate_value=None, ynames=None, gates=None, fig=None, location=None, loc_record=None)

Convert the data of a 1D sweep to a DataSet.

Note: sweepvalues are only an approximation

Args:

data (1D array or kxN array) sweepgate (str) sweeprange (float)

Returns

dataset

qtt.measurements.scans.makeDataset_sweep_2D(data, gates, sweepgates, sweepranges, measure_names='measured', location=None, loc_record=None, fig=None)

Convert the data of a 2D sweep to a DataSet.

qtt.measurements.scans.makeScanjob(sweepgates, values, sweepranges, resolution)

Create a scanjob from sweep ranges and a centre

qtt.measurements.scans.measure_raw_segment_m4i(digitizer, period, read_ch, mV_range, Naverage=100, verbose=0, trigger_re_arm_compensation=False, trigger_re_arm_padding=True)

Record a trace from the digitizer

Parameters

• digitizer (obj) – handle to instrument

• period (float) – length of segment to read

• read_ch (list) – channels to read from the instrument

• mV_range (float) – range for input

• Naverage (int) – number of averages to perform

• verbose (int) – verbosity level

• trigger_arm_compensation (bool) – In block average mode the M4i needs a time of 40 samples + pretrigger to re-arm the triggering. With this option this is compensated for by measuring less samples and padding with zeros.

• trigger_re_arm_padding (bool) – If True then remove any samples from the trigger re-arm compensation with zeros.

qtt.measurements.scans.measure_segment_scope_reader(scope_reader, waveform, number_of_averages, process=True, **kwargs)

Measure block data with scope reader.

Parameters

• scope_reader (AcquisitionScopeInterface) – Instance of scope reader.

• waveform (dict) – Information about the waveform that is to be collected.

• number_of_averages (int) – Number of times the sample is collected.

• process (bool) – If True, cut off the downward sawtooth slopes from the data.

Returns

An array of arrays, one array per input channel.

Return type

data (numpy array)

qtt.measurements.scans.measure_segment_uhfli(zi, waveform, channels, number_of_averages=100, **kwargs)

Measure block data with Zurich Instruments UHFLI

Parameters

• zi (ZIUHFL) – Instance of QCoDeS driver for ZI UHF-LI

• waveform (dict) – Information about the waveform that is to be collected

• channels (list) – List of channels to read from, can be 1, 2 or both.

• number_of_averages (int) – Number of times the sample is collected

Returns

An array of arrays, one array per input channel.

Return type

data (numpy array)

qtt.measurements.scans.measuresegment(waveform, Naverage, minstrhandle, read_ch, mV_range=2000, process=True, device_parameters=None)

Wrapper to identify measurement instrument and run appropriate acquisition function. Supported instruments: m4i digitizer, ZI UHF-LI

Parameters

• waveform (dict) – waveform specification

• Naverage (int) – number of averages to perform

• minstrhandle (str or Instrument) – handle to acquisition device

• read_ch (list) – channels to read from the instrument

• mV_range (float) – range for input

• process (bool) – If True, process the segment data from scope reader

• device_parameters (dict) – dictionary passed as keyword parameters to the measurement methods

Returns

recorded and processed data

Return type

data (numpy array)

qtt.measurements.scans.measuresegment_m4i(digitizer, waveform, read_ch, mV_range, Naverage=100, process=False, verbose=0, fig=None, trigger_re_arm_compensation=False, trigger_re_arm_padding=True)

Measure block data with M4i

Parameters

• digitizer (object) – handle to instrument

• waveform (dict) – waveform specification

• read_ch (list) – channels to read from the instrument

• mV_range (float) – range for input

• Naverage (int) – number of averages to perform

• verbose (int) – verbosity level

• trigger_re_arm_compensation (bool) – Passed to raw measurement function

• trigger_re_arm_padding (bool) – Passed to raw measurement function

Returns

recorded and processed data

Return type

data (numpy array)

qtt.measurements.scans.parse_minstrument(scanjob)

Extract the parameters to be measured from the scanjob

qtt.measurements.scans.plot1D(data, fig=100, mstyle='-b')

Show result of a 1D scan

qtt.measurements.scans.plotData(alldata, diff_dir=None, fig=1)

Plot a dataset and optionally differentiate

qtt.measurements.scans.process_1d_sawtooth(data, width, period, samplerate, resolution=None, padding=0, start_zero=False, fig=None, verbose=0)

Process data from the M4i and a sawtooth trace

This is done to remove the extra padded data of the digitizer and to extract the forward trace of the sawtooth.

Parameters

• data (Nxk array) –

• width (float) – width of the sawtooth

• period (float) –

• samplerate (float) – sample rate of digitizer

Returns

processed_data (Nxk array): processed data rr (tuple)

qtt.measurements.scans.process_2d_sawtooth(data, period, samplerate, resolution, width, verbose=0, start_zero=True, fig=None)

Extract a 2D image from a double sawtooth signal

Parameters

• data (numpy array) – measured trace

• period (float) – period of the full signal

• samplerate (float) – sample rate of the acquisition device

• resolution (list) – resolution nx, ny. The nx corresonds to the fast oscillating sawtooth

• width (list of float) – width paramter of the sawtooth signals

• verbose (int) – verbosity level

• start_zero (bool) – Default is True

• fig (int or None) – figure handle

Returns

processed_data (list of arrays): the extracted 2D arrays results (dict): contains metadata

class qtt.measurements.scans.sample_data_t

Bases: dict

Hold all kind of sample specific data

The structure is that of a dictionary. Typical fields:

gate_boundaries (dict): dictionary with gate boundaries

gate_boundaries(gate)

restrict_boundaries(gate, value)

qtt.measurements.scans.scan1D(station, scanjob, location=None, liveplotwindow=None, plotparam='measured', verbose=1, extra_metadata=None)

Simple 1D scan.

Parameters

• station (object) – contains all data on the measurement station

• scanjob (scanjob_t) – data for scan

• extra_metadata (None or dict) – additional metadata to be included in the dataset

Returns

contains the measurement data and metadata

Return type

alldata (DataSet)

qtt.measurements.scans.scan1Dfast(station, scanjob, location=None, liveplotwindow=None, delete=True, verbose=1, plotparam=None, extra_metadata=None)

Fast 1D scan. The scan is performed by putting a sawtooth signal on the AWG and measuring with a fast acquisition device.

Parameters

• station (object) – contains all data on the measurement station

• scanjob (scanjob_t) – data for scan

• extra_metadata (None or dict) – additional metadata to be included in the dataset

Returns

contains the measurement data and metadata

Return type

DataSet

qtt.measurements.scans.scan2D(station, scanjob, location=None, liveplotwindow=None, plotparam='measured', diff_dir=None, write_period=None, update_period=5, verbose=1, extra_metadata=None)

Make a 2D scan and create dictionary to store on disk.

For 2D vector scans see also the documentation of the _convert_scanjob_vec method of the scanjob_t class.

Parameters

• station (object) – contains all the instruments

• scanjob (scanjob_t) – data for scan

• write_period (float) – save-to-disk interval in lines, None for no writing before finished

• update_period (float) – liveplot update interval in lines, None for no updates

• extra_metadata (None or dict) – additional metadata to be included in the dataset

Returns

contains the measurement data and metadata

Return type

alldata (DataSet)

qtt.measurements.scans.scan2Dfast(station, scanjob, location=None, liveplotwindow=None, plotparam='measured', diff_dir=None, verbose=1, extra_metadata=None)

Make a 2D scan and create qcodes dataset to store on disk.

Parameters

• station (object) – contains all the instruments

• scanjob (scanjob_t) – data for scan

• extra_metadata (None or dict) – additional metadata to be included in the dataset

Returns

contains the measurement data and metadata

Return type

alldata (DataSet)

qtt.measurements.scans.scan2Dturbo(station, scanjob, location=None, liveplotwindow=None, delete=True, verbose=1)

Perform a very fast 2d scan by varying two physical gates with the AWG.

The function assumes the station contains an acquisition device that is supported by the measuresegment function. The number of the measurement channels is supplied via the minstrument field in the scanjob.

Parameters

• station (object) – contains all the instruments

• scanjob (scanjob_t) – data for scan

Returns

contains the measurement data and metadata

Return type

alldata (DataSet)

class qtt.measurements.scans.scanjob_t

Bases: dict

Structure that contains information about a scan

A typical scanjob contains the following (optional) fields:

Fields:

sweepdata (dict): stepdata (dict) minstrument (str, Parameter or tuple) wait_time_startscan (float):

The sweepdata and stepdata are structures with the following fields:

param (str, Parameter or dict): parameter to vary start, end, step (float) wait_time (float)

Note: currently the scanjob_t is a thin wrapper around a dict.

add_minstrument(minstrument)

Add measurement instrument to scan job

add_sweep(param, start, end, step, **kwargs)

Add sweep to scan job

check_format()

Check the format of the scanjob for consistency and legacy style arguments

parse_param(field, station, paramtype='slow')

Process str params for virtual gates

setWaitTimes(station, min_time=0)

Set default waiting times based on gate filtering

qtt.measurements.scans.select_digitizer_memsize(digitizer, period, trigger_delay=None, nsegments=1, verbose=1)

Select suitable memory size for a given period

Parameters

• digitizer (object) – handle to instrument

• period (float) – period of signal to measure

• trigger_delay (float) – delay in seconds between ingoing signal and returning signal

• nsegments (int) – number of segments of period length to fit in memory

Returns

memsize (int)

qtt.measurements.scans.select_m4i_memsize(digitizer, period, trigger_delay=None, nsegments=1, verbose=1, trigger_re_arm_compensation=False)

Select suitable memory size for a given period

The selected memory size is the period times the sample rate, but rounded above to a multiple of 16. Additionally, extra pixels are added because of pretrigger_memsize requirements of the m4i.

Parameters

• digitizer (object) –

• period (float) – period of signal to measure

• trigger_delay (float) – delay in seconds between ingoing signal and returning signal

• nsegments (int) – number of segments of period length to fit in memory

• trigger_arm_compensation (bool) – In block average mode the M4i needs a time of 40 samples + pretrigger to re-arm the triggering. With this option the segment size is reduced. The signal_end can be larger then the segment size.

Returns

total memory size selected pre_trigger (int): size of pretrigger selected signal_start (int): starting position of signal in pixels signal_end (int): end position of signal in pixels

Return type

memsize (int)

qtt.measurements.scans.single_shot_readout(minstparams, length, shots, threshold=None)

Acquires several measurement traces, averages the signal over the entire trace for each shot and returns the proportion of shots that are above a defined threshold. NOTE: The AWG marker delay should be set so that the triggered acquisition starts at the correct part of the readout pulse.

Parameters

• minstparams (dict) – required parameters of the digitizer (handle, read_ch, mV_range)

• length (float) – length of each shot, in seconds

• shots (int) – number of shots to acquire

• threshold (float) – signal discrimination threshold. If None, readout proportion is not calculated.

Returns

proportion of shots above the threshold allshots (array of floats): average signal of every shot taken

Return type

proportion (float [0,1])

qtt.measurements.scans.waitTime(gate, station=None, gate_settle=None, default=0.001)

Return settle times for gates on a station

qtt.measurements.storage module

qtt.measurements.storage.list_states(verbose=1)

List available states of the system

Parameters

verbose (int) –

Returns

List of string tags

Return type

states (list)

See also

load_state

qtt.measurements.storage.load_state(tag=None, station=None, verbose=1, statefile=None)

Load state of the system from disk

Parameters

• tag (str) – identifier of state to load

• station (None or qcodes station) – If defined apply the gatevalues loaded from disk

• verbose (int) – verbosity level

• statefile (str) – file with the state of the system

Returns

Dictionary with state of the system virtual_gates (None or object): reconstructed virtual gates

Return type

state (dict)

qtt.measurements.storage.save_state(station, tag=None, overwrite=False, virtual_gates=None, data=None, verbose=1, statefile=None)

Save current state of the system to disk

Parameters

• station (qcodes station) –

• tag (str or None) –

• overwrite (bool) – If True overwrite existing data, otherwise raise error

• virtual_gates (None or virtual_gates) – virtual gates object to store

• data (None or object) – optional extra data

• verbose (int) – verbosity level

• statefile (str) – file with the state of the system

Example

save_state(station, tag=’tripledot1’)

The data is written to an HDF5 file. The default location is the user home directory with name qtt_statefile.hdf5.

To install hickle: pip install git+https://github.com/telegraphic/hickle.git@dev

qtt.measurements.ttrace module

qtt.measurements.videomode module

Contains code for the VideoMode tools

class qtt.measurements.videomode.VideoMode(station, sweepparams=None, sweepranges=None, minstrument=None, nplots=None, Naverage=10, resolution=(96, 96), sample_rate='default', diff_dir=None, verbose=1, dorun=True, show_controls=True, add_ppt=True, crosshair=False, averaging=True, name=None, mouse_click_callback=None, videomode_processor=None)

Bases: object

Controls the videomode tool.

The VideoMode tools allows for fast plotting of measurement results. The basic operation of the VideoMode consists of the following stages:

1. Initialize. For example start a periodic waveform on the AWG

2. Start the readout. This starts a loop with the following steps: - Measure data - Post-process data - Plot data The loop continues running in the background untill the user aborts the loop.

3. Stop the readout. This stops the measure-process-plot loop

4. Stop. This stops all activity (e.g. both the readout loop and and activity on the AWG)

station

contains all the information about the set-up

Type

qcodes station

videomode_processor

class performing the measurements and post-processing

Type

VideoModeProcessor

Naverage

the number of times the raw measurement data should be averaged

Type

Parameter

addPPT()

Copy image of videomode window to PPT

static all_instances(verbose=1)

Return all VideoMode instances

close()

Stop the videomode and close the GUI

crosshair(*args, **kwargs)

Enable or disable a crosshair in the plotting windows

static destruct()

Stop all VideoMode instances and cleanup

enable_averaging_slot(averaging=None, *args, **kwargs)

Update the averaging mode of the widget

get_dataset()

Return latest recorded dataset

Returns

alldata (dataset or list of datasets)

static get_instance(idx)

Return instance by index

initialize()

Initialize the videomode tool for the readout loop

is_running()

Return True if the readout loop is running

run(start_readout=True)

Initialize the tool and start the readout loop

set_videomode_name(name)

Set the name for this instance of the tool

single()

Do a single scan with a lot averaging.

Note: this does not yet support the usage of linear combinations of gates (a.k.a. virtual gates).

startreadout(callback=None, rate=30, maxidx=None)

Start the readout loop

Parameters

rate (float) – sample rate in ms

stop()

Stops the readout loop and the input signals

static stop_all_instances()

Stop readout on all all VideoMode instances

stop_videomode()

stopreadout()

Stop the readout loop

updatebg()

Update function for the tool

Calls the videomode_processor.measure() and videomode_processor.process() and updates the GUI

videomode_class_index = 0

qtt.measurements.videomode.add_sawtooth_videomode_processor(videomode, sweepparams, sweepranges, resolution, sample_rate, minstrument)

Add all required variables to the VideoMode for the VideomodeSawtoothMeasurement

qtt.measurements.videomode_processor module

class qtt.measurements.videomode_processor.DummyVideoModeProcessor(station, verbose=1)

Bases: qtt.measurements.videomode_processor.VideoModeProcessor

initialize(videomode)

measure(videomode)

ppt_notes()

Generate notes to be added in a powerpoint slide

process(measurement_data, videomode)

scan_dimension()

Return the dimension of the data to be shown (1 or 2)

stop()

class qtt.measurements.videomode_processor.VideoModeProcessor

Bases: abc.ABC

Base class for VideoMode processing functionality

acquisition_device_type()

Return type of acquisition device

Returns

Device type as a string. Can be

create_dataset(processed_data, metadata)

classmethod default_processing(measurement_data, videomode)

classmethod extend_videomode_name(name)

String to append to VideoMode name

abstract initialize(videomode)

abstract measure(videomode)

classmethod plot_title(index)

Return title for plot window

classmethod ppt_notes()

Generate notes to be added in a powerpoint slide

abstract process(measurement_data, videomode)

abstract scan_dimension()

Return the dimension of the data to be shown (1 or 2)

abstract stop()

class qtt.measurements.videomode_processor.VideomodeSawtoothMeasurement(station, verbose=1)

Bases: qtt.measurements.videomode_processor.VideoModeProcessor

create_dataset(processed_data, metadata)

extend_videomode_name(name)

String to append to VideoMode name

initialize(videomode)

measure(videomode)

parse_instrument(measurement_instrument_handle, sample_rate)

plot_title(index)

Return title for plot window

ppt_notes()

Generate notes to be added in a powerpoint slide

process(measurement_data, videomode)

scan_dimension()

Return the dimension of the data to be shown (1 or 2)

set_properties(waveform, measurement_instrument, resolution=None)

Create callback object for videmode data

Parameters

• station (QCoDeS station) –

• waveform –

• measurement_instrument (tuple) – instrumentname, channel

• diff_dir (list or (int, str)) – differentiation modes for the data

set_scan_parameters(scan_parameters)

stop()

update_position(position, verbose=1)