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.
`ChargeSensor`	A device element representing a Charge Senseor connected to a tank circuit to perform
`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 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: SpectroscopyOperationNV#: Submodule SpectroscopyOperationNV.

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: RxyNV#: 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.yaml_utils.YAMLSerializable, quantify_scheduler.json_utils.JSONSerializable, 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.

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. Has to follow the convention "{element_0}_{element_1}".

get_edge(name: str) → quantify_scheduler.device_under_test.edge.Edge[source]#

Returns an edge by name.

Parameters:

name – The edge name. Has to follow the convention "{element_0}_{element_1}".

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 to add.

remove_edge(edge_name: str) → None[source]#

Remove an edge by name.

Parameters:: edge_name – The edge name connecting the elements. Has to follow the convention "{element_0}_{element_1}".

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

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]][source]#

Generate part of the device configuration specific to a single qubit trapped in a quantum dot. A resonator to perform dispersive readout is attached to the gate to perform charge sensing.

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 ChargeSensor(name: str, **kwargs: Any)[source]#

Bases: quantify_scheduler.device_under_test.device_element.DeviceElement

A device element representing a Charge Senseor connected to a tank circuit to perform dispersive readoud.

Examples

Sensor parameters can be set through submodule attributes

from quantify_scheduler import ChargeSensor

sensor = ChargeSensor("s1")

sensor.measure.pulse_amp(0.25)
sensor.measure.pulse_duration(300e-9)
sensor.measure.acq_delay(430e-9)
sensor.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.

measure: DispersiveMeasurementSpin#: Submodule DispersiveMeasurementSpin.

pulse_compensation: quantify_scheduler.device_under_test.transmon_element.PulseCompensationModule#: Submodule PulseCompensationModule.

ports: PortsChargeSensor#: Submodule PortsSpin.

clock_freqs: ClocksFrequenciesSensor#: 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

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

device_under_test#

Submodules#

Package Contents#

Classes#

This Page