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.

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.

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: qcodes.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: Union[int, float, qcodes.instrument.parameter.Parameter] = None, gain: Union[int, float, qcodes.instrument.parameter.Parameter] = None, name: str = None, label: str = None, unit: str = None)[source]¶

Bases: qcodes.instrument.parameter.Parameter

To be used when you use a physical voltage divider or an amplifier to set or get a quantity.

Initialize the parameter by passing the parameter to be measured/set and the value of the division OR the gain.

The scaling value can be either a scalar value or a Qcodes Parameter.

The parameter scaler acts a your original parameter, but will set the right value, and store the gain/division in the metadata.

Examples

Resistive voltage divider >>> vd = ParameterScaler(dac.chan0, division = 10)

Voltage multiplier >>> vb = ParameterScaler(dac.chan0, gain = 30, name = ‘Vb’)

Transimpedance amplifier >>> Id = ParameterScaler(multimeter.amplitude, division = 1e6, name = ‘Id’, unit = ‘A’)

Parameters:

output – Physical Parameter that need conversion
division – the division value
gain – the gain value
label – label of this parameter, by default uses ‘output’ label but attaches _amplified or _attenuated depending if gain or division has been specified
name – name of this parameter, by default uses ‘output’ name but attaches _amplified or _attenuated depending if gain or division has been specified
unit – resulting unit. Use the one of ‘output’ by default

division¶

gain¶

get_instrument_value() → Union[int, float][source]¶

Returns:	value at which the attached parameter is (i.e. does not account for the scaling)
Return type:	number

get_raw() → Union[int, float][source]¶

Returns:	value at which was set at the sample
Return type:	number

set_raw(value: Union[int, float]) → None[source]¶: Se the value on the instrument, accounting for the scaling

class qtt.instrument_drivers.parameter_scaler.Role[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

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 g2 (g1,) – 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_gates.virtual_gates(name, gates_instr, crosscap_map, **kwargs)¶

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.

qtt.instrument_drivers.virtual_gates.name¶

The name of the virtual gate object

Type:	string

qtt.instrument_drivers.virtual_gates.gates_instr¶

The instrument of physical gates

Type:	Instrument

Functions:

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