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

• composite_square_edge
• device_element
• edge
• hardware_config
• mock_setup
• nv_element
• quantum_device
• spin_edge
• spin_element
• transmon_element

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)

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.

generate_edge_config() → dict[str, dict[str, quantify_scheduler.backends.graph_compilation.OperationCompilationConfig]]

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)

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 device element parameters to translate higher-level operations into pulses. Please see the documentation of these classes.

Examples

Qubit parameters can be set through submodule attributes

from quantify_scheduler import BasicElectronicNVElement

device_element = BasicElectronicNVElement("q2")

device_element.rxy.amp180(0.1)
device_element.measure.pulse_amplitude(0.25)
device_element.measure.pulse_duration(300e-9)
device_element.measure.acq_delay(430e-9)
device_element.measure.acq_duration(1e-6)
...

Ellipsis

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]]

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

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)

Bases: quantify_scheduler.json_utils.JSONSerializableMixin, 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: quantify_scheduler.device_under_test.hardware_config.HardwareConfig

The input dictionary used to generate a valid HardwareCompilationConfig using generate_hardware_compilation_config(). This configures the compilation from the quantum-device layer to the control-hardware layer.

Useful methods to write and reload the configuration from a json file are load_from_json_file() and write_to_json_file().

scheduling_strategy

_instrument_references

to_json() → str

Convert the QuantumDevice data structure to a JSON string. Overrides the base mixin method to perform additional checks.

Returns:

The json string containing the serialized QuantumDevice.

generate_compilation_config() → quantify_scheduler.backends.graph_compilation.SerialCompilationConfig

Generate a config for use with a QuantifyCompiler.

generate_hardware_config() → dict[str, Any]

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

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

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

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

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

Removes an element by name.

Parameters:

name – The element name.

get_edge(name: str) → qcodes.instrument.base.Instrument

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

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

Remove an edge by name.

Parameters:

edge_name – The edge name.

class BasicSpinElement(name: str, **kwargs: Any)

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 particle is coupled to a resonator.

Examples

Qubit parameters can be set through submodule attributes

from quantify_scheduler import BasicSpinElement

device_element = BasicSpinElement("q1")

device_element.rxy.amp180(0.1)
device_element.measure.pulse_amp(0.25)
device_element.measure.pulse_duration(300e-9)
device_element.measure.acq_delay(430e-9)
device_element.measure.integration_time(1e-6)
...

Ellipsis

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.

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]]

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

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)

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.

Examples

Qubit parameters can be set through submodule attributes

from quantify_scheduler import BasicTransmonElement

device_element = BasicTransmonElement("q3")

device_element.rxy.amp180(0.1)
device_element.measure.pulse_amp(0.25)
device_element.measure.pulse_duration(300e-9)
device_element.measure.acq_delay(430e-9)
device_element.measure.integration_time(1e-6)
...

Ellipsis

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.

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]]

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

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 device element to be used in isolation.