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.

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.

Examples

Qubit parameters can be set through submodule attributes

from quantify_scheduler import BasicElectronicNVElement

qubit = BasicElectronicNVElement("q2")

qubit.rxy.amp180(0.1)
qubit.measure.pulse_amplitude(0.25)
qubit.measure.pulse_duration(300e-9)
qubit.measure.acq_delay(430e-9)
qubit.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]][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: 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[source]#

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

Examples

Qubit parameters can be set through submodule attributes

from quantify_scheduler import BasicSpinElement

qubit = BasicSpinElement("q1")

qubit.rxy.amp180(0.1)
qubit.measure.pulse_amp(0.25)
qubit.measure.pulse_duration(300e-9)
qubit.measure.acq_delay(430e-9)
qubit.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]][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.

Examples

Qubit parameters can be set through submodule attributes

from quantify_scheduler import BasicTransmonElement

qubit = BasicTransmonElement("q3")

qubit.rxy.amp180(0.1)
qubit.measure.pulse_amp(0.25)
qubit.measure.pulse_duration(300e-9)
qubit.measure.acq_delay(430e-9)
qubit.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]][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.