qtt.instrument_drivers package¶

Subpackages¶

Submodules¶

qtt.instrument_drivers.BlueforsMonitor module¶

class qtt.instrument_drivers.BlueforsMonitor.BlueforsApp[source]¶

Bases: object

check_directory()[source]¶

main(argv)[source]¶

print_header()[source]¶

print_settings()[source]¶

print_usage(status=0)[source]¶

set_directory(directory: str)[source]¶

set_password(password: str)[source]¶

set_portnumber(port: str)[source]¶

set_username(username: str)[source]¶

class qtt.instrument_drivers.BlueforsMonitor.FridgeDataReceiver(name, **kwargs)[source]¶

Bases: qtt.instrument_drivers.DistributedInstrument.InstrumentDataClient

Receives temperature and pressure data from the Bluefors fridge with server connection.

class qtt.instrument_drivers.BlueforsMonitor.FridgeDataSender(folder_path, **kwargs)[source]¶

Bases: object

Sends temperature and pressure data of the Bluefors fridge to the proxy client connections.

get_datetime()[source]¶

get_pressures()[source]¶

get_status(item)[source]¶

get_temperatures()[source]¶

qtt.instrument_drivers.DistributedInstrument module¶

class qtt.instrument_drivers.DistributedInstrument.InstrumentDataClient(name, address='localhost', port=8080, user=None, password=None, **kwargs)[source]¶

Bases: qcodes.instrument.base.Instrument

A proxy client for collecting instrument measurable quantities from a server.

Parameters

name (str) – the name of the instrument.
address (str) – the ip-address of the server.
port (int) – the port number of the proxy server.
user (str) – a username for protection.
password (str) – a password for protection.

add_measurable_quantity(name='quantity', unit='arb.', default_value=None, doc_string='Unknown', command_name='', params=None)[source]¶: Adds a instument function to the dataclient.

class qtt.instrument_drivers.DistributedInstrument.InstrumentDataServer(functions, address='*', port=8080, user=None, password=None)[source]¶

Bases: object

Represents a server proxy for sending instrument measurable quantities to a client.

Parameters

functions (dict) – the instrument functions.
address (str) – the ip-address of the server.
port (int) – the port number of the proxy server.
user (str) – a username for protection.
password (str) – a password for protection.

run()[source]¶: Starts the server proxy and blocks the current thread. A keyboard interuption will stop and clean-up the server proxy.

start()[source]¶: Starts the server proxy.

stop()[source]¶: Stops the server proxy.

qtt.instrument_drivers.FPGA_ave module¶

class qtt.instrument_drivers.FPGA_ave.FPGA_ave(name, address, mirrorfactors=[1, 1], verbose=1, **kwargs)[source]¶

Bases: qcodes.instrument.visa.VisaInstrument

This is the python driver for the FPGA averaging, it communicates with the FPGA to get an average of a pulse

Usage: Initialize with <name> = instruments.create(‘name’, ‘FPGA_AVE’, address=’<COM PORT>’) <COM PORT> = COM5 e.g.

ask_from_serial(address, register=255)[source]¶

ask_from_serial_signed(address, register=255)[source]¶

get_ch1_data(address=2, checkdone=True, buf=True)[source]¶: Reads signed data out of the FPGA

get_ch1_datapoint_num()[source]¶: Get the total number of cycles which are averaged in FPGA

get_ch2_data(address=6, checkdone=True)[source]¶: Reads signed data out of the FPGA

get_ch2_datapoint_num()[source]¶: Get the total number of cycles which are averaged in FPGA

get_data(address=2)[source]¶: Read data ch1, unsigned

get_idn()[source]¶

Parse a standard VISA *IDN? response into an ID dict.

Even though this is the VISA standard, it applies to various other types as well, such as IPInstruments, so it is included here in the Instrument base class.

Override this if your instrument does not support *IDN? or returns a nonstandard IDN string. This string is supposed to be a comma-separated list of vendor, model, serial, and firmware, but semicolon and colon are also common separators so we accept them here as well.

Returns: A dict containing vendor, model, serial, and firmware.

get_measurement_done(ch=[1, 2])[source]¶: Returns one if the measurement is done, else returns zero

get_sampling_frequency()[source]¶: Get the total number of cycles which are averaged in FPGA

get_sampling_frequency_ratio()[source]¶: Get the total number of cycles which are averaged in FPGA

get_total_cycle_num()[source]¶: Get the total number of cycles which are averaged in FPGA

readFPGA(FPGA_mode=0, ReadDevice=['FPGA_ch1', 'FPGA_ch2'], Naverage=1, verbose=1, waittime=0)[source]¶: Basic function to read the data from the FPGA memory.

read_raw_bytes(size=None)[source]¶: Returns the values that are in the FPGA buffer. Replacement for read_raw in messagebased.py, also see: https://github.com/hgrecco/pyvisa/issues/93 https://github.com/hgrecco/pyvisa/issues/190

serial(here)[source]¶

set_(value)[source]¶: Set the number of traces over which pulse events will be counted

set_sampling_frequency(value)[source]¶: Set the total number of cycles which are averaged in FPGA, maximum samp freq=1 MHz and minimum is freq=763.

set_total_cycle_num(value)[source]¶: Set the total number of cycles which are averaged in FPGA

start()[source]¶

write_to_serial(address, value)[source]¶

qtt.instrument_drivers.ILM200 module¶

class qtt.instrument_drivers.ILM200.OxfordInstruments_ILM200(name, address, number=1, **kwargs)[source]¶

Bases: qcodes.instrument.visa.VisaInstrument

This is the qcodes driver for the Oxford Instruments ILM 200 Helium Level Meter.

Usage: Initialize with <name> = instruments.create(‘name’, ‘OxfordInstruments_ILM200’, address=’<Instrument address>’) <Instrument address> = ASRL4::INSTR

Note: Since the ISOBUS allows for several instruments to be managed in parallel, the command which is sent to the device starts with ‘@n’, where n is the ISOBUS instrument number.

close()[source]¶: Safely close connection

get_all()[source]¶

Reads all implemented parameters from the instrument, and updates the wrapper.

Input:: None
Output:: None

get_idn()[source]¶

Overides the function of Instrument since ILM does not support ‘*IDN?’

This string is supposed to be a comma-separated list of vendor, model, serial, and firmware, but semicolon and colon are also common separators so we accept them here as well.

Returns: A dict containing vendor, model, serial, and firmware.
Return type: idn (dict)

local()[source]¶

Set control to local & locked

Input:: None
Output:: None

remote()[source]¶

Set control to remote & locked

Input:: None
Output:: None

set_remote_status(mode)[source]¶

Set remote control status.

Input:: mode(int) : 0 : “Local and locked”, 1 : “Remote and locked”, 2 : “Local and unlocked”, 3 : “Remote and unlocked”,
Output:: None

set_to_fast()[source]¶: Set helium meter channel 1 to fast mode.

set_to_slow()[source]¶: Set helium meter channel 1 to slow mode.

qtt.instrument_drivers.TimeStamp module¶

class qtt.instrument_drivers.TimeStamp.TimeStampInstrument(name, **kwargs)[source]¶

Bases: qcodes.instrument.base.Instrument

Instrument that generates a timestamp

reset()[source]¶: Reset the timestamp offset such that the timestamps start at 0

qtt.instrument_drivers.gates module¶

Created on Wed Feb 8 13:36:01 2017

@author: diepencjv

class qtt.instrument_drivers.gates.VirtualDAC(name, instruments, gate_map, rc_times=None, **kwargs)[source]¶

Bases: qcodes.instrument.base.Instrument

This class maps the dacs of IVVI(‘s) to named gates.

The main functionality is the renaming of numbered dacs of one or multiple DAC instruments (for example an IVVI or SPI D5a module) to gates, which in general have names describing their main purpose or position on the sample.

name¶

The name given to the VirtualDAC object

Type: str

instruments¶

a list of qcodes instruments

Type: list

gate_map¶

the map between IVVI dac and gate

Type: dict

rc_times¶

dictionary with rc times for the gates

Type: dict

add_instruments(instruments)[source]¶

Add instruments to the virtual dac.

Parameters: instruments (list) – a list of qcodes instruments

allvalues()[source]¶: Return all gate values in a simple dict.

allvalues_string(fmt='%.3f')[source]¶: Return all gate values in string format.

property gate_map¶: A map between IVVI dac and gate.

get_all(verbose=0)[source]¶: Returns all gate values.

get_boundaries()[source]¶

Get boundaries on the values that can be set on the gates.

Returns: A range of allowed values per parameter.
Return type: dict

get_idn()[source]¶: Overrule because the default VISA command does not work.

get_instrument_parameter(g)[source]¶: Returns the dac parameter mapped to this gate.

property instruments¶: A list of QCoDeS instruments.

resetgates(activegates, basevalues=None, verbose=2)[source]¶

Reset a set of gates to new values.

If no new values are specified the gates will be reset to zero.

Parameters

activegates (list or dict) – gates to reset
basevalues (dict) – new values for the gates
verbose (int) – output level

resettodataset(dataset)[source]¶: Reset gates to the values from a previous dataset :param dataset: the dataset or location to load from. :type dataset: DataSet or str

restrict_boundaries(gate_boundaries)[source]¶

Restrict boundaries values that can be set on the gates.

Parameters: gate_boundaries (dict) – For each gate a range used to restrict the current boundaries to

set_boundaries(gate_boundaries)[source]¶

Set boundaries on the values that can be set on the gates.

Assigns a range of values to the validator of a parameter.

Parameters: gate_boundaries (dict) – a range of allowed values per parameter.

set_overshoot(gate, value, extra_delay=0.02, overshoot=4)[source]¶

Set gate to a value with overshoot

This function can be used for gates with a slow RC value on the bias-T. The actual overshoot is determined by the rc_times in the object.

Parameters

gate (str) – gate to set
value (float) – value to set at the gate
extra_delay (float) –
…
overshoot (float) – overshoot factor

visualize(fig=1)[source]¶: Create a graphical representation of the system (needs graphviz).

qtt.instrument_drivers.gates.virtual_IVVI¶: alias of qtt.instrument_drivers.gates.VirtualDAC

qtt.instrument_drivers.parameter_scaler module¶

class qtt.instrument_drivers.parameter_scaler.ParameterScaler(output: qcodes.instrument.parameter.Parameter, division: Optional[Union[int, float, qcodes.instrument.parameter.Parameter]] = None, gain: Optional[Union[int, float, qcodes.instrument.parameter.Parameter]] = None, name: Optional[str] = None, label: Optional[str] = None, unit: Optional[str] = None)[source]¶

Bases: qcodes.instrument.parameter.Parameter

Deprecated class, use qcodes.ScaledParameter instead

class qtt.instrument_drivers.parameter_scaler.Role(value)[source]¶

Bases: enum.Enum

An enumeration.

DIVISION = 2¶

GAIN = 1¶

qtt.instrument_drivers.simulation_instruments module¶

Contains simulated instruments

class qtt.instrument_drivers.simulation_instruments.SimulationAWG(name, **kwargs)[source]¶

Bases: qcodes.instrument.base.Instrument

awg_gate(name)[source]¶

stop()[source]¶

sweep_2D(samp_freq, sweepgates, sweepranges, resolution)[source]¶

sweep_2D_virt(samp_freq, gates_horz, gates_vert, sweepranges, resolution)[source]¶

sweep_gate(gate, sweeprange, period, width=0.95, wave_name=None, delete=True)[source]¶

sweep_gate_virt(fast_sweep_gates, sweeprange, period, delete=None)[source]¶

class qtt.instrument_drivers.simulation_instruments.SimulationDigitizer(name, model=None, **kwargs)[source]¶

Bases: qcodes.instrument.base.Instrument

measuresegment(waveform, channels=[0])[source]¶

Measure a segment of data

Parameters

waveform (object) – waveform currently on AWG
channels (list) – channels to measure

myhoneycomb(multiprocess=False, verbose=0)[source]¶

Parameters

multiprocess (bool) – honeycomb simulation multiprocess
verbose (int) – verbosity of the method (0 == none)

qtt.instrument_drivers.virtual_awg module¶

Created on Wed Aug 31 13:04:09 2016

@author: diepencjv

qtt.instrument_drivers.virtual_awg.plot_wave_raw(wave_raw, samplerate=None, station=None)[source]¶

Plot the raw wave

Parameters: wave_raw (array) – raw data which represents the waveform
Returns: the plot showing the data
Return type: plot (QtPlot)

qtt.instrument_drivers.virtual_awg.sweep_2D_process(data, waveform, diff_dir=None)[source]¶

Process data from sweep_2D

Parameters

data (list) – the raw measured data
waveform (dict) – The waveforms that was sent with the AWG.

Returns

the processed data

Return type

data_processed (list)

class qtt.instrument_drivers.virtual_awg.virtual_awg(name, instruments=[], awg_map=None, hardware=None, verbose=1, **kwargs)[source]¶

Bases: qcodes.instrument.base.Instrument

_awgs¶

handles to instruments

Type: list

awg_map¶

Type: dict

hardware¶

contains AWG to plunger values

Type: Instrument

corr¶

unknown

Type: float

delay_FPGA¶

time delay of signals going through fridge

Type: float

awg_gate(gate)[source]¶

Return true of the gate can be controlled by the awg

Parameters: () (gate) –

check_amplitude(gate, mvrange)[source]¶

Calculates the lowest allowable AWG peak-to-peak amplitude based on the ranges to be applied to the gates. If the AWG amplitude is too low, it gives a warning and increases the amplitude.

Parameters

gate (str) – name of the gate to check
mvrange (float) – voltage range, in mV, that the gate needs to reach

check_frequency_waveform(period, width)[source]¶: Check whether a sawtooth waveform with specified period can be generated

get_idn()[source]¶: Overrule because the default VISA command does not work

make_pulses(voltages, waittimes, reps=1, filtercutoff=None, mvrange=None)[source]¶

Make a pulse sequence with custom voltage levels and wait times at each level.

Parameters

voltages (list of floats) – voltage levels to be applied in the sequence
waittimes (list of floats) – duration of each pulse in the sequence
reps (int) – number of times to repeat the pulse sequence in the waveform
filtercutoff (float) – cutoff frequency of a 1st order butterworth filter to make the pulse steps smoother

Returns

raw data which represents the waveform

Return type

wave_raw (array)

make_sawtooth(sweeprange, period, width=0.95, repetitionnr=1, start_zero=False)[source]¶

Make a sawtooth with a decline width determined by width. Not yet scaled with awg_to_plunger value.

Parameters

sweeprange (float) – the range of voltages to sweep over
period (float) – the period of the triangular signal

Returns

raw data which represents the waveform

Return type

wave_raw (array)

pulse_gates(gate_voltages, waittimes, reps=1, filtercutoff=None, reset_to_zero=False, delete=True)[source]¶

Send a pulse sequence with the AWG that can span over any gate space. Sends a marker to measurement instrument at the start of the sequence. Only works with physical gates.

Parameters

gate_voltages (dict) – keys are gates to apply the sequence to, and values
arrays with the voltage levels to be applied in the sequence (are) –
waittimes (list of floats) – duration of each pulse in the sequence
reset_to_zero (bool) – if True, the function offsets the voltages values so that the last point is 0V on all gates (i.e. it centers the pulse sequence on the last point).

Returns

The waveform being send with the AWG. sweep_info (dict): the keys are tuples of the awgs and channels to activate

Return type

waveform (dict)

reset_AWG(clock=100000000.0)[source]¶: Reset AWG to videomode and scanfast

set_amplitude(amplitude)[source]¶

Set the AWG peak-to-peak amplitude for all channels

Parameters: amplitude (float) – peak-to-peak amplitude (V)

stop(verbose=0)[source]¶: Stops all AWGs and turns of all channels

sweep_2D(samp_freq, sweepgates, sweepranges, resolution, width=0.95, comp=None, delete=True)[source]¶

Send sawtooth signals to the sweepgates which effectively do a 2D scan.

The first sweepgate is the fast changing gate (on the horizontal axis).

Parameters

samp_freq (float) – sampling frequency of the measurement instrument in Hertz.
sweepgates (list) – two strings with names of gates to sweep
sweepranges (list) – two floats for sweepranges in milliVolts

Returns

The waveforms being send with the AWG. sweep_info (dict): the keys are tuples of the awgs and channels to activate

Return type

waveform (dict)

sweep_2D_process(data, waveform, diff_dir=None)[source]¶

Process data from sweep_2D

Parameters

data (list) – the raw measured data
waveform (dict) – The waveforms that was sent with the AWG.

Returns

the processed data

Return type

data_processed (list)

sweep_2D_virt(samp_freq, gates_horz, gates_vert, sweepranges, resolution, width=0.95, delete=True)[source]¶

Send sawtooth signals to the linear combinations of gates set by gates_horz and gates_vert which effectively do a 2D scan of two virtual gates.

The horizontal direction is the direction where the AWG signal is changing fastest. It is the first element in the resolution and sweepranges.

Parameters

samp_freq (float) – sampling frequency of the measurement instrument in Hertz.
gates_horz (dict) – the gates for the horizontal direction and their coefficients
gates_vert (dict) – the gates for the vertical direction and their coefficients
sweepranges (list) – two floats for sweepranges in milliVolts
resolution (list) – two ints for numbers of pixels

Returns

The waveforms being send with the AWG. sweep_info (dict): the keys are tuples of the awgs and channels to activate

Return type

waveform (dict)

sweep_gate(gate, sweeprange, period, width=0.95, wave_name=None, delete=True)[source]¶

Send a sawtooth signal with the AWG to a gate to sweep. Also send a marker to the measurement instrument.

Parameters

gate (string) – the name of the gate to sweep
sweeprange (float) – the range of voltages to sweep over
period (float) – the period of the triangular signal

Returns

The waveform being send with the AWG. sweep_info (dict): the keys are tuples of the awgs and channels to activate

Return type

waveform (dict)

Example

>>> waveform, sweep_info = sweep_gate('P1',sweeprange=60,period=1e-3)

sweep_gate_virt(gate_comb, sweeprange, period, width=0.95, delete=True)[source]¶

Send a sawtooth signal with the AWG to a linear combination of gates to sweep. Also send a marker to the measurement instrument.

Parameters

gate_comb (dict) – the gates to sweep and the coefficients as values
sweeprange (float) – the range of voltages to sweep over
period (float) – the period of the triangular signal

Returns

The waveform being send with the AWG. sweep_info (dict): the keys are tuples of the awgs and channels to activate

Return type

waveform (dict)

sweep_init(waveforms, period=0.001, delete=True, samp_freq=None)[source]¶

Send waveform(s) to gate(s)

Parameters

waveforms (dict) – the waveforms with the gates as keys
period (float) – period of the waveform in seconds

Returns

the keys are tuples of the awgs and channels to activate

Return type

sweep_info (dict)

>> sweep_info = sweep_init(waveforms)

sweep_process(data, waveform, Naverage=1, direction='forwards', start_offset=1)[source]¶

Process the data returned by reading out based on the shape of the sawtooth send with the AWG.

Parameters

data (list or Nxk array) – the data (N is the number of samples)
waveform (dict) – contains the wave and the sawtooth width
Naverage (int) – number of times the signal was averaged
direction (string) – option to use backwards signal i.o. forwards

Returns

The data after dropping part of it.

Return type

data_processed (array)

Example

>> data_processed = sweep_process(data, waveform, 25)

sweep_run(sweep_info)[source]¶

Activate AWG(s) and channel(s) for the sweep(s).

Parameters: sweep_info (dict) – the keys are tuples of the awgs and channels to activate

sweepandpulse_gate(sweepdata, pulsedata, wave_name=None, delete=True, shift_zero=True)[source]¶

Makes and outputs a waveform which overlays a sawtooth signal to sweep a gate, with a pulse sequence. A marker is sent to the measurement instrument at the start of the waveform. IMPORTANT: The function offsets the voltages values so that the last point is 0 V on all gates (i.e. it centers the pulse sequence on the last point)

Parameters

sweepdata (dict) – inputs for the sawtooth (gate, sweeprange, period, width). See sweep_gate for more info.
pulsedata (dict) – inputs for the pulse sequence (gate_voltages, waittimes). See pulse_gates for more info.

Returns

The waveform being sent with the AWG. sweep_info (dict): the keys are tuples of the awgs and channels to activate

Return type

waveform (dict)

qtt.instrument_drivers.virtual_gates module¶

Created on Thu Dec 8 10:37:36 2016

@author: diepencjv, eendebakpt

class qtt.instrument_drivers.virtual_gates.VirtualGates(name, gates_instr, crosscap_map, **kwargs)[source]¶

Bases: qcodes.instrument.base.Instrument

A virtual gate instrument to control linear combinations of gates.

The virtual gates can be defined, such that when changing one of the virtual gates, the others are not influenced. The virtual gates can be used for changing only one physical parameter, e.g. a chemical potential or a tunnel coupling.

Note: They do not (yet?) have an offset relative to the physical parameters. The sweepmap describes a submatrix of the inverse of the virt_gate_map.

name¶

The name of the virtual gate object

Type: string

gates_instr¶

The instrument of physical gates

Type: Instrument

Functions:

allvalues(get_latest=False)[source]¶: Return all virtual gate voltage values in a dict.

convert_map_to_matrix(base_map, gates=None, vgates=None)[source]¶

Convert map of the crosscap form to matrix

Parameters: base_map (ordered_dict) – Crosscap map or its inverse. gates (list or None): list of gate names (columns of matrix) vgates (list or None): list of virtual gate names (rows of matrix)
Returns: Matrix with its elements orderd with given gate order.
Return type: converted_matrix (array)

convert_matrix_to_map(base_matrix, gates=None, vgates=None)[source]¶

Convert ordered matrix to map.

Parameters: base_matrix (array) – Matrix with its elements ordered with given gate order. gates (list or None): list of gate names (columns of matrix) vgates (list or None): list of virtual gate names (rows of matrix)
Returns: Map after conversion.
Return type: converted_map (ordered_dict)

static from_dictionary(vgdict, gates, name=None)[source]¶: Convert dictionary to virtual gate matrix object

get_crosscap_map()[source]¶: Gets the current cross-capacitance map.

get_crosscap_map_inv()[source]¶: Gets the current inverse of cross-capacitance map.

get_crosscap_matrix()[source]¶: Gets the current cross-capacitance matrix.

get_crosscap_matrix_inv()[source]¶: Gets the current inverse of cross-capacitance matrix.

multi_set(increment_map)[source]¶

Update multiple parameters at once

Parameters: increment_map (dict) – dictionary with keys the gate names and values the increments

normalize_matrix()[source]¶: Normalize the rows of the matrix by dividing each row by the diagonal coefficient

pgates()[source]¶: Return the names of the physical gates

plot_matrix(fig=10, inverse=False)[source]¶

Plot the cross-capacitance matrix as a figure

Parameters

fig (int) – number of figure window
inverse (bool) – If True then plot the inverse matrix

print_inverse_matrix()[source]¶

static print_map(base_map)[source]¶

Show map as table.

Parameters: base_map (dict) – Map of what to show. Either a crosscap_map or a crosscap_map_inv.

print_matrix()[source]¶

ratio(target, g1, g2, laplace=0)[source]¶

Return ratio of influence of two gates

Parameters

target (str) – target gate
g1 (str) – gates
g2 (str) – gates
laplace (float) – parameter for Laplacian smoothing

Returns: ratio (float)

resetgates(activegates, basevalues=None, verbose=0)[source]¶

Reset a set of gates to new values.

If no new values are specified the virtual gates will be reset to zero.

Parameters

activegates (list or dict) – Virtual gates to reset
basevalues (dict) – New values for the gates
verbose (int) – Output level

set_crosscap_map(replace_map, verbose=0)[source]¶

Sets the cross-capacitance map by replacing the specified map. Then updates the connected parameters in memory.

Parameters

replace_map (dict) –

Map containing replacing values. Uses an arbitrary part of the dict inside the full map. Order of gates does not matter.

Example: {‘VP2’: {‘P2’: 0.4}, ‘VP2’: {‘P1’: 0.4, ‘P3’: 0.1}}

set_crosscap_map_inv(replace_map, verbose=0)[source]¶

Sets the inverse of the cross-capacitance map by replacing the specified map. Then updates the connected parameters in memory.

Parameters

replace_map (dict) –

Map containing replacing values. Uses an arbitrary part of the dict inside the full map. Order of gates does not matter.

Example: {‘P1’: {‘VP2’: -0.4}, ‘P2’: {‘VP1’: -0.4, ‘VP3’: -0.1}}

set_crosscap_matrix(cc)[source]¶: Sets the cross-capacitance matrix. Update the dependent variables

set_distances(dists)[source]¶: Update the cross-capacitance matrix based on a list of distances

setgates(values, verbose=0)[source]¶

Set gates to new values.

Parameters

values (dict) – keys are gate names, values are values to be set
verbose (int) – Output level

to_dictionary()[source]¶: Convert a virtual gates object to a dictionary for storage

vgates()[source]¶: Return the names of the virtual gates

qtt.instrument_drivers.virtual_gates.create_virtual_matrix_dict(virt_basis, physical_gates, c=None, verbose=1)[source]¶

Converts the virtual gate matrix into a virtual gate mapping

Parameters

virt_basis (list) – containing all the virtual gates in the setup
physical_gates (list) – containing all the physical gates in the setup
c (array or None) – virtual gate matrix

Returns

dictionary, mapping of the virtual gates

Return type

virtual_matrix (dict)

qtt.instrument_drivers.virtual_gates.extend_virtual_gates(vgates, pgates, virts, name='vgates', verbose=0)[source]¶: Create a new virtual gates object based on another virtual gates object

qtt.instrument_drivers.virtual_gates.set_distance_matrix(virt_gates, dists)[source]¶

Update the cross capacitance matrix for a virtual_gate matrix

Parameters

virt_gates (VirtualGates) – virtual gates object
dists (list) – list of distances between dots

qtt.instrument_drivers.virtual_gates.update_cc_matrix(virt_gates, update_cc, old_cc=None, verbose=1)[source]¶

Create a new virtual gates object using an update matrix

Parameters

virt_gates (VirtualGates) – virtual gates object
update_cc (array) – update to cc matrix
old_cc (array or None) – if None, then get the old cc matrix from the virt_gates
verbose (int) – verbosity level

Returns

new_cc (array): results (dict): dictionary with additional results

Return type

new_virt_gates (virtual gates)

qtt.instrument_drivers.virtual_instruments module¶

Toy model to test TNO algorithms with Qcodes

@author: eendebakpt

class qtt.instrument_drivers.virtual_instruments.VirtualIVVI(name, model, gates=['dac1', 'dac2', 'dac3', 'dac4', 'dac5', 'dac6', 'dac7', 'dac8', 'dac9', 'dac10', 'dac11', 'dac12', 'dac13', 'dac14', 'dac15', 'dac16'], dac_unit='a.u.', **kwargs)[source]¶

Bases: qcodes.instrument.base.Instrument

allvalues()[source]¶

Return all DAC values

Returns: dictionary with all DAC values
Return type: dict

get_idn()[source]¶: Overwrites the get_idn function using constants as the virtual device does not have a proper *IDN function.

class qtt.instrument_drivers.virtual_instruments.VirtualMeter(name, model=None, **kwargs)[source]¶

Bases: qcodes.instrument.base.Instrument

get_idn()[source]¶: Overrule because the default get_idn yields a warning