device_under_test#

Module containing instruments that represent quantum devices and elements.

The elements and their components are intended to generate valid device configuration files for compilation from the quantum-circuit layer to the quantum-device layer description.

Submodules#

Package Contents#

Classes#

CompositeSquareEdge

An example Edge implementation which connects two BasicTransmonElements.

BasicElectronicNVElement

A device element representing an electronic qubit in an NV center.

QuantumDevice

The QuantumDevice directly represents the device under test (DUT).

BasicSpinElement

A device element representing a Loss–DiVincenzo Spin qubit.

BasicTransmonElement

A device element representing a single fixed-frequency transmon qubit.

class CompositeSquareEdge(parent_element_name: str, child_element_name: str, **kwargs)[source]#

Bases: quantify_scheduler.device_under_test.edge.Edge

An example Edge implementation which connects two BasicTransmonElements.

This edge implements a square flux pulse and two virtual z phase corrections for the CZ operation between the two BasicTransmonElements.

cz_data#
generate_edge_config() dict[str, dict[str, quantify_scheduler.backends.graph_compilation.OperationCompilationConfig]][source]#

Generate valid device config.

Fills in the edges information to produce a valid device config for the quantify-scheduler making use of the compile_circuit_to_device_with_config_validation() function.

class BasicElectronicNVElement(name: str, **kwargs)[source]#

Bases: quantify_scheduler.device_under_test.device_element.DeviceElement

A device element representing an electronic qubit in an NV center.

The submodules contain the necessary qubit parameters to translate higher-level operations into pulses. Please see the documentation of these classes.

submodules_to_add#
submodule_data#
spectroscopy_operation: SpectroscopyOperationHermiteMW#

Submodule SpectroscopyOperationHermiteMW.

ports: Ports#

Submodule Ports.

clock_freqs: ClockFrequencies#

Submodule ClockFrequencies.

reset: ResetSpinpump#

Submodule ResetSpinpump.

charge_reset: ChargeReset#

Submodule ChargeReset.

measure: Measure#

Submodule Measure.

pulse_compensation: quantify_scheduler.device_under_test.transmon_element.PulseCompensationModule#

Submodule PulseCompensationModule.

cr_count: CRCount#

Submodule CRCount.

rxy: RxyHermite#

Submodule Rxy.

_generate_config() dict[str, dict[str, quantify_scheduler.backends.graph_compilation.OperationCompilationConfig]][source]#

Generate part of the device configuration specific to a single qubit.

This method is intended to be used when this object is part of a device object containing multiple elements.

generate_device_config() quantify_scheduler.backends.graph_compilation.DeviceCompilationConfig[source]#

Generate a valid device config for the quantify-scheduler.

This makes use of the compile_circuit_to_device_with_config_validation() function.

This enables the settings of this qubit to be used in isolation.

class QuantumDevice(name: str)[source]#

Bases: qcodes.instrument.base.Instrument

The QuantumDevice directly represents the device under test (DUT).

This contains a description of the connectivity to the control hardware as well as parameters specifying quantities like cross talk, attenuation and calibrated cable-delays. The QuantumDevice also contains references to individual DeviceElements, representations of elements on a device (e.g, a transmon qubit) containing the (calibrated) control-pulse parameters.

This object can be used to generate configuration files for the compilation step from the gate-level to the pulse level description. These configuration files should be compatible with the compile() function.

elements#
edges#
instr_measurement_control#
instr_instrument_coordinator#
cfg_sched_repetitions#
keep_original_schedule#
hardware_config#
scheduling_strategy#
_instrument_references#
to_json() str[source]#

Convert the QuantumDevice data structure to a JSON string.

Returns:

The json string containing the serialized QuantumDevice.

to_json_file(path: str | None = None, add_timestamp: bool = True) str[source]#

Convert the QuantumDevice data structure to a JSON string and store it in a file.

Parameters:
  • path – The path to the directory where the file is created.

  • add_timestamp – Specify whether or not to append timestamp to the filename. Default is True.

Returns:

The name of the file containing the serialized QuantumDevice.

classmethod from_json(data: str) QuantumDevice[source]#

Convert the JSON data to a QuantumDevice.

Parameters:

data – The JSON data in str format.

Returns:

The deserialized QuantumDevice object.

classmethod from_json_file(filename: str) QuantumDevice[source]#

Read JSON data from a file and convert it to a QuantumDevice.

Parameters:

filename – The name of the file containing the serialized QuantumDevice.

Returns:

The deserialized QuantumDevice object.

generate_compilation_config() quantify_scheduler.backends.graph_compilation.SerialCompilationConfig[source]#

Generate a config for use with a QuantifyCompiler.

generate_hardware_config() dict[str, Any][source]#

Generate a valid hardware configuration describing the quantum device.

Returns:

  • The hardware configuration file used for compiling from the quantum-device layer to a hardware backend.

  • .. warning – The config currently has to be specified by the user using the hardware_config parameter.

generate_device_config() quantify_scheduler.backends.graph_compilation.DeviceCompilationConfig[source]#

Generate a device config.

This config is used to compile from the quantum-circuit to the quantum-device layer.

generate_hardware_compilation_config() quantify_scheduler.backends.types.common.HardwareCompilationConfig | None[source]#

Generate a hardware compilation config.

The compilation config is used to compile from the quantum-device to the control-hardware layer.

get_element(name: str) quantify_scheduler.device_under_test.device_element.DeviceElement[source]#

Return a DeviceElement by name.

Parameters:

name – The element name.

Returns:

The element.

Raises:

KeyError – If key name is not present in self.elements.

add_element(element: quantify_scheduler.device_under_test.device_element.DeviceElement) None[source]#

Add an element to the elements collection.

Parameters:

element – The element to add.

Raises:
  • ValueError – If a element with a duplicated name is added to the collection.

  • TypeError – If element is not an instance of the base element.

remove_element(name: str) None[source]#

Removes an element by name.

Parameters:

name – The element name.

get_edge(name: str) qcodes.instrument.base.Instrument[source]#

Returns an edge by name.

Parameters:

name – The edge name.

Returns:

The edge.

Raises:

KeyError – If key name is not present in self.edges.

add_edge(edge: quantify_scheduler.device_under_test.edge.Edge) None[source]#

Add the edges.

Parameters:

edge – The edge name connecting the elements. Has to follow the convention ‘element_0’-‘element_1’

remove_edge(edge_name: str) None[source]#

Remove an edge by name.

Parameters:

edge_name – The edge name.

class BasicSpinElement(name: str, **kwargs: Any)[source]#

Bases: quantify_scheduler.device_under_test.device_element.DeviceElement

A device element representing a Loss–DiVincenzo Spin qubit. The element refers to the intrinsic spin-1/2 degree of freedom of individual electrons/holes trapped in quantum dots. The charge of the particule is coupled to a resonator.

Parameters:
  • name – The name of the spin element.

  • kwargs – Can be used to pass submodule initialization data by using submodule name as keyword and as argument a dictionary containing the submodule parameter names and their value.

submodules_to_add#
submodule_data#
reset: quantify_scheduler.device_under_test.transmon_element.IdlingReset#

Submodule IdlingReset.

rxy: RxyGaussian#

Submodule RxyGaussian.

measure: DispersiveMeasurementSpin#

Submodule DispersiveMeasurementSpin.

pulse_compensation: quantify_scheduler.device_under_test.transmon_element.PulseCompensationModule#

Submodule PulseCompensationModule.

ports: PortsSpin#

Submodule PortsSpin.

clock_freqs: ClocksFrequenciesSpin#

Submodule ClocksFrequenciesSpin.

_generate_config() dict[str, dict[str, quantify_scheduler.backends.graph_compilation.OperationCompilationConfig]][source]#

Generate part of the device configuration specific to a single qubit.

This method is intended to be used when this object is part of a device object containing multiple elements.

generate_device_config() quantify_scheduler.backends.graph_compilation.DeviceCompilationConfig[source]#

Generate a valid device config.

The config will be used for the quantify-scheduler making use of the compile_circuit_to_device_with_config_validation() function.

This enables the settings of this qubit to be used in isolation.

class BasicTransmonElement(name: str, **kwargs)[source]#

Bases: quantify_scheduler.device_under_test.device_element.DeviceElement

A device element representing a single fixed-frequency transmon qubit.

The qubit is coupled to a readout resonator.

Parameters:
  • name – The name of the transmon element.

  • kwargs – Can be used to pass submodule initialization data by using submodule name as keyword and as argument a dictionary containing the submodule parameter names and their value.

submodules_to_add#
submodule_data#
reset: IdlingReset#

Submodule IdlingReset.

rxy: RxyDRAG#

Submodule RxyDRAG.

measure: DispersiveMeasurement#

Submodule DispersiveMeasurement.

pulse_compensation: PulseCompensationModule#

Submodule PulseCompensationModule.

ports: Ports#

Submodule Ports.

clock_freqs: ClocksFrequencies#

Submodule ClocksFrequencies.

_generate_config() dict[str, dict[str, quantify_scheduler.backends.graph_compilation.OperationCompilationConfig]][source]#

Generate part of the device configuration specific to a single qubit.

This method is intended to be used when this object is part of a device object containing multiple elements.

generate_device_config() quantify_scheduler.backends.graph_compilation.DeviceCompilationConfig[source]#

Generate a valid device config.

The config will be used for the quantify-scheduler making use of the compile_circuit_to_device_with_config_validation() function.

This enables the settings of this qubit to be used in isolation.