schedules#

Module containing a standard library of schedules for common experiments as well as the ScheduleBase, Schedule, and CompiledSchedule classes.

Tip

The source code of the schedule generating functions in this module can serve as examples when creating schedules for custom experiments.

Subpackages#

_visualization

Submodules#

Package Contents#

Classes#

`CompiledSchedule`	A schedule that contains compiled instructions ready for execution using the `InstrumentCoordinator`.
`Schedulable`	A representation of an element on a schedule.
`Schedule`	A modifiable schedule.

Functions#

`heterodyne_spec_sched`(...)	Generate a schedule for performing heterodyne spectroscopy.
`heterodyne_spec_sched_nco`(...)	Generate a batched schedule for performing fast heterodyne spectroscopy
`nv_dark_esr_sched`(...)	Generates a schedule for a dark ESR experiment on an NV-center.
`two_tone_spec_sched`(...)	Generate a schedule for performing two-tone spectroscopy.
`two_tone_spec_sched_nco`(...)	Generate a batched schedule for performing fast two-tone spectroscopy using
`allxy_sched`(, repetitions)	Generate a schedule for performing an AllXY experiment.
`echo_sched`(...)	Generate a schedule for performing an Echo experiment to measure the qubit
`rabi_pulse_sched`(...)	Generate a schedule for performing a Rabi experiment using a
`rabi_sched`(...)	Generate a schedule for performing a Rabi using a Gaussian pulse.
`ramsey_sched`(...)	Generate a schedule for performing a Ramsey experiment to measure the
`readout_calibration_sched`(...)	A schedule for readout calibration. Prepares a state and immediately performs
`t1_sched`(→ quantify_scheduler.schedules.schedule.Schedule)	Generate a schedule for performing a \(T_1\) experiment to measure the qubit
`trace_schedule`(...)	Generate a schedule to perform raw trace acquisition.
`trace_schedule_circuit_layer`(...)	Generate a simple schedule at circuit layer to perform raw trace acquisition.
`two_tone_trace_schedule`(...)	Generate a schedule for performing a two-tone raw trace acquisition.

class CompiledSchedule(schedule: Schedule)[source]#

Bases: ScheduleBase

A schedule that contains compiled instructions ready for execution using the InstrumentCoordinator.

The CompiledSchedule differs from a Schedule in that it is considered immutable (no new operations or resources can be added), and that it contains compiled_instructions.

Tip

A CompiledSchedule can be obtained by compiling a Schedule using compile().

schema_filename = 'schedule.json'#

_hardware_timing_table: pandas.DataFrame#

_hardware_waveform_dict: dict[str, numpy.ndarray]#

property compiled_instructions: dict[str, quantify_scheduler.resources.Resource]#

A dictionary containing compiled instructions.

The contents of this dictionary depend on the backend it was compiled for. However, we assume that the general format consists of a dictionary in which the keys are instrument names corresponding to components added to a InstrumentCoordinator, and the values are the instructions for that component.

These values typically contain a combination of sequence files, waveform definitions, and parameters to configure on the instrument.

classmethod is_valid(object_to_be_validated: Any) → bool[source]#

Check if the contents of the object_to_be_validated are valid.

Additionally checks if the object_to_be_validated is an instance of CompiledSchedule.

property hardware_timing_table: pandas.io.formats.style.Styler#

Return a timing table representing all operations at the Control-hardware layer.

Note that this timing table is typically different from the .timing_table in that it contains more hardware specific information such as channels, clock cycles and samples and corrections for things such as gain.

This hardware timing table is intended to provide a more

This table is constructed based on the timing_table and modified during compilation in one of the hardware back ends and optionally added to the schedule. Not all back ends support this feature.

property hardware_waveform_dict: dict[str, numpy.ndarray]#

Return a waveform dictionary representing all waveforms at the Control-hardware layer.

Where the waveforms are represented as abstract waveforms in the Operations, this dictionary contains the numerical arrays that are uploaded to the hardware.

This dictionary is constructed during compilation in the hardware back ends and: optionally added to the schedule. Not all back ends support this feature.

class Schedulable(name: str, operation_id: str, control_flow: quantify_scheduler.operations.operation.Operation | None = None)[source]#

Bases: quantify_scheduler.json_utils.JSONSchemaValMixin, collections.UserDict

A representation of an element on a schedule.

All elements on a schedule are schedulables. A schedulable contains all information regarding the timing of this element as well as the operation being executed by this element. This operation is currently represented by an operation ID.

Schedulables can contain an arbitrary number of timing constraints to determine the timing. Multiple different constraints are currently resolved by delaying the element until after all timing constraints have been met, to aid compatibility. To specify an exact timing between two schedulables, please ensure to only specify exactly one timing constraint.

Parameters:

name – The name of this schedulable, by which it can be referenced by other schedulables. Separate schedulables cannot share the same name.
operation_id – Reference to the operation which is to be executed by this schedulable.

schema_filename = 'schedulable.json'#

add_timing_constraint(rel_time: float = 0, ref_schedulable: Schedulable | str | None = None, ref_pt: Literal['start', 'center', 'end'] | None = None, ref_pt_new: Literal['start', 'center', 'end'] | None = None) → None[source]#

Add timing constraint.

A timing constraint constrains the operation in time by specifying the time ("rel_time") between a reference schedulable and the added schedulable. The time can be specified with respect to the “start”, “center”, or “end” of the operations. The reference schedulable ("ref_schedulable") is specified using its name property. See also schedulables.

Parameters:

rel_time – relative time between the reference schedulable and the added schedulable. the time is the time between the “ref_pt” in the reference operation and “ref_pt_new” of the operation that is added.
ref_schedulable – name of the reference schedulable. If set to None, will default to the last added operation.
ref_pt – reference point in reference operation must be one of "start", "center", "end", or None; in case of None, determine_absolute_timing() assumes "end".
ref_pt_new – reference point in added operation must be one of "start", "center", "end", or None; in case of None, determine_absolute_timing() assumes "start".

property hash: str#: A hash based on the contents of the Operation.

class Schedule(name: str, repetitions: int = 1, data: dict = None)[source]#

Bases: ScheduleBase

A modifiable schedule.

Operations quantify_scheduler.operations.operation.Operation can be added using the add() method, allowing precise specification when to perform an operation using timing constraints.

When adding an operation, it is not required to specify how to represent this quantify_scheduler.operations.operation.Operation on all layers. Instead, this information can be added later during compilation. This allows the user to effortlessly mix the gate- and pulse-level descriptions as required for many (calibration) experiments.

Parameters:

name – The name of the schedule
repetitions – The amount of times the schedule will be repeated, by default 1
data – A dictionary containing a pre-existing schedule, by default None

schema_filename = 'schedule.json'#

add_resources(resources_list: list) → None[source]#: Add wrapper for adding multiple resources.

add_resource(resource: quantify_scheduler.resources.Resource) → None[source]#: Add a resource such as a channel or qubit to the schedule.

add(operation: quantify_scheduler.operations.operation.Operation | Schedule, rel_time: float = 0, ref_op: Schedulable | str | None = None, ref_pt: Literal['start', 'center', 'end'] | None = None, ref_pt_new: Literal['start', 'center', 'end'] | None = None, label: str | None = None, control_flow: quantify_scheduler.operations.control_flow_library.ControlFlowSpec | None = None) → Schedulable[source]#

Add an operation or a subschedule to the schedule.

Parameters:

operation – The operation to add to the schedule, or another schedule to add as a subschedule.
rel_time – relative time between the reference operation and the added operation. the time is the time between the “ref_pt” in the reference operation and “ref_pt_new” of the operation that is added.
ref_op – reference schedulable. If set to None, will default to the last added operation.
ref_pt – reference point in reference operation must be one of "start", "center", "end", or None; in case of None, determine_absolute_timing() assumes "end".
ref_pt_new – reference point in added operation must be one of "start", "center", "end", or None; in case of None, determine_absolute_timing() assumes "start".
label – a unique string that can be used as an identifier when adding operations. if set to None, a random hash will be generated instead.
control_flow – Virtual operation describing if the operation should be subject to control flow (loop, conditional, …). See control flow reference documentation for a detailed explanation.

Returns:

Returns the schedulable created in the schedule.

_add(operation: quantify_scheduler.operations.operation.Operation | Schedule, rel_time: float = 0, ref_op: Schedulable | str | None = None, ref_pt: Literal['start', 'center', 'end'] | None = None, ref_pt_new: Literal['start', 'center', 'end'] | None = None, label: str | None = None) → Schedulable[source]#

_validate_add_arguments(operation: quantify_scheduler.operations.operation.Operation | Schedule, label: str, control_flow: quantify_scheduler.operations.operation.Operation | None) → None[source]#

heterodyne_spec_sched(pulse_amp: float, pulse_duration: float, frequency: float, acquisition_delay: float, integration_time: float, port: str, clock: str, init_duration: float = 1e-05, repetitions: int = 1, port_out: str | None = None) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a schedule for performing heterodyne spectroscopy.

Parameters:

pulse_amp – Amplitude of the spectroscopy pulse in Volt.
pulse_duration – Duration of the spectroscopy pulse in seconds.
frequency – Frequency of the spectroscopy pulse in Hertz.
acquisition_delay – Start of the data acquisition with respect to the start of the spectroscopy pulse in seconds.
integration_time – Integration time of the data acquisition in seconds.
port – Location on the device where the acquisition is performed.
clock – Reference clock used to track the spectroscopy frequency.
init_duration – The relaxation time or dead time.
repetitions – The amount of times the Schedule will be repeated.
port_out – Output port on the device where the pulse should be applied. If None, then use the same as port.

heterodyne_spec_sched_nco(pulse_amp: float, pulse_duration: float, frequencies: numpy.ndarray, acquisition_delay: float, integration_time: float, port: str, clock: str, init_duration: float = 1e-05, repetitions: int = 1, port_out: str | None = None) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a batched schedule for performing fast heterodyne spectroscopy using the SetClockFrequency operation for doing an NCO sweep.

Example use of the heterodyne_spec_sched_nco schedule

import numpy as np
from qcodes.instrument.parameter import ManualParameter

from quantify_scheduler.gettables import ScheduleGettable
from quantify_scheduler.device_under_test.quantum_device import QuantumDevice
from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement
from quantify_scheduler.schedules.spectroscopy_schedules import heterodyne_spec_sched_nco

quantum_device = QuantumDevice(name="quantum_device")
q0 = BasicTransmonElement("q0")
quantum_device.add_element(q0)

...

# Manual parameter for batched schedule
ro_freq = ManualParameter("ro_freq", unit="Hz")
ro_freq.batched = True
ro_freqs = np.linspace(start=4.5e9, stop=5.5e9, num=11)
quantum_device.cfg_sched_repetitions(5)

# Configure the gettable
qubit = quantum_device.get_element("q0")
schedule_kwargs = {
    "pulse_amp": qubit.measure.pulse_amp(),
    "pulse_duration": qubit.measure.pulse_duration(),
    "frequencies": ro_freqs,
    "acquisition_delay": qubit.measure.acq_delay(),
    "integration_time": qubit.measure.integration_time(),
    "port": qubit.ports.readout(),
    "clock": qubit.name + ".ro",
    "init_duration": qubit.reset.duration(),
}
spec_gettable = ScheduleGettable(
    quantum_device=quantum_device,
    schedule_function=heterodyne_spec_sched_nco,
    schedule_kwargs=schedule_kwargs,
    real_imag=False,
    batched=True,
)

...

quantum_device.close()
q0.close()

Parameters:

pulse_amp – Amplitude of the spectroscopy pulse in Volt.
pulse_duration – Duration of the spectroscopy pulse in seconds.
frequencies – Sample frequencies for the spectroscopy pulse in Hertz.
acquisition_delay – Start of the data acquisition with respect to the start of the spectroscopy pulse in seconds.
integration_time – Integration time of the data acquisition in seconds.
port – Location on the device where the acquisition is performed.
clock – Reference clock used to track the spectroscopy frequency.
init_duration – The relaxation time or dead time.
repetitions – The amount of times the Schedule will be repeated.
port_out – Output port on the device where the pulse should be applied. If None, then use the same as port.

nv_dark_esr_sched(qubit: str, repetitions: int = 1) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generates a schedule for a dark ESR experiment on an NV-center.

The spectroscopy frequency is taken from the device element. Please use the clock specified in the spectroscopy_operation entry of the device config.

This schedule can currently not be compiled with the Zurich Instruments backend.

Parameters:

qubit – Name of the DeviceElement representing the NV-center.
repetitions – Number of schedule repetitions.

Returns:

Schedule with a single frequency

two_tone_spec_sched(spec_pulse_amp: float, spec_pulse_duration: float, spec_pulse_port: str, spec_pulse_clock: str, spec_pulse_frequency: float, ro_pulse_amp: float, ro_pulse_duration: float, ro_pulse_delay: float, ro_pulse_port: str, ro_pulse_clock: str, ro_pulse_frequency: float, ro_acquisition_delay: float, ro_integration_time: float, init_duration: float = 1e-05, repetitions: int = 1) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a schedule for performing two-tone spectroscopy.

Parameters:

spec_pulse_amp – Amplitude of the spectroscopy pulse in Volt.
spec_pulse_duration – Duration of the spectroscopy pulse in seconds.
spec_pulse_port – Location on the device where the spectroscopy pulse should be applied.
spec_pulse_clock – Reference clock used to track the spectroscopy frequency.
spec_pulse_frequency – Frequency of the spectroscopy pulse in Hertz.
ro_pulse_amp – Amplitude of the readout (spectroscopy) pulse in Volt.
ro_pulse_duration – Duration of the readout (spectroscopy) pulse in seconds.
ro_pulse_delay – Time between the end of the spectroscopy pulse and the start of the readout (spectroscopy) pulse.
ro_pulse_port – Location on the device where the readout (spectroscopy) pulse should be applied.
ro_pulse_clock – Reference clock used to track the readout (spectroscopy) frequency.
ro_pulse_frequency – Frequency of the readout (spectroscopy) pulse in Hertz.
ro_acquisition_delay – Start of the data acquisition with respect to the start of the readout pulse in seconds.
ro_integration_time – Integration time of the data acquisition in seconds.
init_duration – The relaxation time or dead time.
repetitions – The amount of times the Schedule will be repeated.

two_tone_spec_sched_nco(spec_pulse_amp: float, spec_pulse_duration: float, spec_pulse_port: str, spec_pulse_clock: str, spec_pulse_frequencies: numpy.ndarray, ro_pulse_amp: float, ro_pulse_duration: float, ro_pulse_delay: float, ro_pulse_port: str, ro_pulse_clock: str, ro_pulse_frequency: float, ro_acquisition_delay: float, ro_integration_time: float, init_duration: float, repetitions: int = 1) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a batched schedule for performing fast two-tone spectroscopy using the SetClockFrequency operation for doing an NCO sweep.

For long-lived qubits, it is advisable to use a small number of repetitions and compensate by doing continuous spectroscopy (low amplitude, long duration pulse with simultaneous long readout).

The “dead-time” between two data points needs to be sufficient to properly reset the qubit. That means that init_duration should be >> T1 (so typically >200us).

Example use of the two_tone_spec_sched_nco schedule

import numpy as np
from qcodes.instrument.parameter import ManualParameter

from quantify_scheduler.gettables import ScheduleGettable
from quantify_scheduler.device_under_test.quantum_device import QuantumDevice
from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement
from quantify_scheduler.schedules.spectroscopy_schedules import two_tone_spec_sched_nco

quantum_device = QuantumDevice(name="quantum_device")
q0 = BasicTransmonElement("q0")
quantum_device.add_element(q0)

...

# Manual parameter for batched schedule
spec_freq = ManualParameter("spec_freq", unit="Hz")
spec_freq.batched = True
spec_freqs = np.linspace(start=4.5e9, stop=5.5e9, num=11)
quantum_device.cfg_sched_repetitions(5)

# Configure the gettable
qubit = quantum_device.get_element("q0")
schedule_kwargs = {
    "spec_pulse_amp": 0.5,
    "spec_pulse_duration": 8e-6,
    "spec_pulse_port": qubit.ports.microwave(),
    "spec_pulse_clock": qubit.name + ".01",
    "spec_pulse_frequencies": spec_freqs,
    "ro_pulse_amp": qubit.measure.pulse_amp(),
    "ro_pulse_duration": qubit.measure.pulse_duration(),
    "ro_pulse_delay": 300e-9,
    "ro_pulse_port": qubit.ports.readout(),
    "ro_pulse_clock": qubit.name + ".ro",
    "ro_pulse_frequency": 7.04e9,
    "ro_acquisition_delay": qubit.measure.acq_delay(),
    "ro_integration_time": qubit.measure.integration_time(),
    "init_duration": 300e-6,
}
spec_gettable = ScheduleGettable(
    quantum_device=quantum_device,
    schedule_function=two_tone_spec_sched_nco,
    schedule_kwargs=schedule_kwargs,
    real_imag=False,
    batched=True,
)

...

quantum_device.close()
q0.close()

Parameters:

spec_pulse_amp – Amplitude of the spectroscopy pulse in Volt.
spec_pulse_duration – Duration of the spectroscopy pulse in seconds.
spec_pulse_port – Location on the device where the spectroscopy pulse should be applied.
spec_pulse_clock – Reference clock used to track the spectroscopy frequency.
spec_pulse_frequencies – Sample frequencies for the spectroscopy pulse in Hertz.
ro_pulse_amp – Amplitude of the readout (spectroscopy) pulse in Volt.
ro_pulse_duration – Duration of the readout (spectroscopy) pulse in seconds.
ro_pulse_delay – Time between the end of the spectroscopy pulse and the start of the readout (spectroscopy) pulse.
ro_pulse_port – Location on the device where the readout (spectroscopy) pulse should be applied.
ro_pulse_clock – Reference clock used to track the readout (spectroscopy) frequency.
ro_pulse_frequency – Frequency of the readout (spectroscopy) pulse in Hertz.
ro_acquisition_delay – Start of the data acquisition with respect to the start of the readout pulse in seconds.
ro_integration_time – Integration time of the data acquisition in seconds.
init_duration – The relaxation time or dead time.
repetitions – The amount of times the Schedule will be repeated.

allxy_sched(qubit: str, element_select_idx: numpy.ndarray | int = np.arange(21), repetitions: int = 1) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a schedule for performing an AllXY experiment.

Schedule sequence: Reset – Rxy[0] – Rxy[1] – Measure

for a specific set of combinations of x90, x180, y90, y180 and idle rotations.

See section 2.3.2 of Reed [Ree13] for an explanation of the AllXY experiment and it’s applications in diagnosing errors in single-qubit control pulses.

Parameters:

qubit – the name of the qubit e.g., "q0" to perform the experiment on.
element_select_idx – the index of the particular element of the AllXY experiment to exectute.
repetitions – The amount of times the Schedule will be repeated.

Returns:

An experiment schedule.

echo_sched(times: numpy.ndarray | float, qubit: str, repetitions: int = 1) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a schedule for performing an Echo experiment to measure the qubit echo-dephasing time \(T_2^{E}\).

Schedule sequence: Reset – pi/2 – Idle(tau/2) – pi – Idle(tau/2) – pi/2 – Measure

See section III.B.2. of Krantz et al. [KKY+19] for an explanation of the Bloch-Redfield model of decoherence and the echo experiment.

Parameters:

qubit – the name of the qubit e.g., “q0” to perform the echo experiment on.
times – an array of wait times. Used as tau/2 wait time between the start of the first pi/2 pulse and pi pulse, tau/2 wait time between the start of the pi pulse and the final pi/2 pulse.
repetitions – The amount of times the Schedule will be repeated.

Returns:

An experiment schedule.

rabi_pulse_sched(mw_G_amp: float, mw_D_amp: float, mw_frequency: float, mw_clock: str, mw_port: str, mw_pulse_duration: float, ro_pulse_amp: float, ro_pulse_duration: float, ro_pulse_delay: float, ro_pulse_port: str, ro_pulse_clock: str, ro_pulse_frequency: float, ro_acquisition_delay: float, ro_integration_time: float, init_duration: float, repetitions: int = 1) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a schedule for performing a Rabi experiment using a quantify_scheduler.waveforms.drag() pulse.

Note

This function allows specifying a Rabi experiment directly using the pulse-level abstraction. For most applications we recommend using rabi_sched() instead.

Parameters:

mw_G_amp – amplitude of the gaussian component of a DRAG pulse.
mw_D_amp – amplitude of the derivative-of-gaussian component of a DRAG pulse.
mw_frequency – frequency of the DRAG pulse.
mw_clock – reference clock used to track the qubit 01 transition.
mw_port – location on the device where the pulse should be applied.
mw_pulse_duration – duration of the DRAG pulse. Corresponds to 4 sigma.
ro_pulse_amp – amplitude of the readout pulse in Volt.
ro_pulse_duration – duration of the readout pulse in seconds.
ro_pulse_delay – time between the end of the spectroscopy pulse and the start of the readout pulse.
ro_pulse_port – location on the device where the readout pulse should be applied.
ro_pulse_clock – reference clock used to track the readout frequency.
ro_pulse_frequency – frequency of the spectroscopy pulse and of the data acquisition in Hertz.
ro_acquisition_delay – start of the data acquisition with respect to the start of the readout pulse in seconds.
ro_integration_time – integration time of the data acquisition in seconds.
init_duration – The relaxation time or dead time.
repetitions – The amount of times the Schedule will be repeated.

rabi_sched(pulse_amp: numpy.ndarray | float, pulse_duration: numpy.ndarray | float, frequency: float, qubit: str, port: str = None, clock: str = None, repetitions: int = 1) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a schedule for performing a Rabi using a Gaussian pulse.

Schedule sequence: Reset – DRAG – Measure

Parameters:

pulse_amp – amplitude of the Rabi pulse in V.
pulse_duration – duration of the Gaussian shaped Rabi pulse. Corresponds to 4 sigma.
frequency – frequency of the qubit 01 transition.
qubit – the qubit on which to perform a Rabi experiment.
port – location on the chip where the Rabi pulse should be applied. if set to None, will use the naming convention "<qubit>:mw" to infer the port.
clock – name of the location in frequency space where to apply the Rabi pulse. if set to None, will use the naming convention "<qubit>.01" to infer the clock.
repetitions – The amount of times the Schedule will be repeated.

ramsey_sched(times: numpy.ndarray | float, qubit: str, artificial_detuning: float = 0, repetitions: int = 1) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a schedule for performing a Ramsey experiment to measure the dephasing time \(T_2^{\star}\).

Schedule sequence: Reset – pi/2 – Idle(tau) – pi/2 – Measure

See section III.B.2. of Krantz et al. [KKY+19] for an explanation of the Bloch-Redfield model of decoherence and the Ramsey experiment.

Parameters:

times – an array of wait times tau between the start of the first pi/2 pulse and the start of the second pi/2 pulse.
artificial_detuning – frequency in Hz of the software emulated, or artificial qubit detuning, which is implemented by changing the phase of the second pi/2 (recovery) pulse. The artificial detuning changes the observed frequency of the Ramsey oscillation, which can be useful to distinguish a slow oscillation due to a small physical detuning from the decay of the dephasing noise.
qubit – the name of the qubit e.g., "q0" to perform the Ramsey experiment on.
repetitions – The amount of times the Schedule will be repeated.

Returns:

An experiment schedule.

readout_calibration_sched(qubit: str, prepared_states: list[int], repetitions: int = 1, acq_protocol: Literal['SSBIntegrationComplex', 'ThresholdedAcquisition'] = 'SSBIntegrationComplex') → quantify_scheduler.schedules.schedule.Schedule[source]#

A schedule for readout calibration. Prepares a state and immediately performs a measurement.

Parameters:

qubit – the name of the qubit e.g., "q0" to perform the experiment on.
prepared_states – the states to prepare the qubit in before measuring as in integer corresponding to the ground (0), first-excited (1) or second-excited (2) state.
repetitions – The number of shots to acquire, sets the number of times the schedule will be repeated.
acq_protocol – The acquisition protocol used for the readout calibration. By default “SSBIntegrationComplex”, but “ThresholdedAcquisition” can be used for verifying thresholded acquisition parameters with this function (see Tutorial: Conditional Reset).

Returns:

An experiment schedule.

Raises:

ValueError – If the prepared state is not either 0, 1, or 2.
NotImplementedError – If the prepared state is 2.

t1_sched(times: numpy.ndarray | float, qubit: str, repetitions: int = 1) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a schedule for performing a \(T_1\) experiment to measure the qubit relaxation time.

Schedule sequence: Reset – pi – Idle(tau) – Measure

See section III.B.2. of Krantz et al. [KKY+19] for an explanation of the Bloch-Redfield model of decoherence and the \(T_1\) experiment.

Parameters:

times – an array of wait times tau between the start of pi-pulse and the measurement.
qubit – the name of the qubit e.g., "q0" to perform the T1 experiment on.
repetitions – The amount of times the Schedule will be repeated.

Returns:

An experiment schedule.

trace_schedule(pulse_amp: float, pulse_duration: float, pulse_delay: float, frequency: float, acquisition_delay: float, integration_time: float, port: str, clock: str, init_duration: float = 0.0002, repetitions: int = 1) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a schedule to perform raw trace acquisition.

Parameters:

pulse_amp – The amplitude of the pulse in Volt.
pulse_duration – The duration of the pulse in seconds.
pulse_delay – The pulse delay in seconds.
frequency – The frequency of the pulse and of the data acquisition in Hertz.
acquisition_delay – The start of the data acquisition with respect to the start of the pulse in seconds.
integration_time – The time in seconds to integrate.
port – The location on the device where the pulse should be applied.
clock – The reference clock used to track the pulse frequency.
init_duration – The relaxation time or dead time.
repetitions – The amount of times the Schedule will be repeated.

Returns:

The Raw Trace acquisition Schedule.

trace_schedule_circuit_layer(qubit_name: str, repetitions: int = 1) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a simple schedule at circuit layer to perform raw trace acquisition.

Parameters:

qubit_name – Name of a device element.
repetitions – The amount of times the Schedule will be repeated.

Returns:

The Raw Trace acquisition Schedule.

two_tone_trace_schedule(qubit_pulse_amp: float, qubit_pulse_duration: float, qubit_pulse_frequency: float, qubit_pulse_port: str, qubit_pulse_clock: str, ro_pulse_amp: float, ro_pulse_duration: float, ro_pulse_delay: float, ro_pulse_port: str, ro_pulse_clock: str, ro_pulse_frequency: float, ro_acquisition_delay: float, ro_integration_time: float, init_duration: float = 0.0002, repetitions: int = 1) → quantify_scheduler.schedules.schedule.Schedule[source]#

Generate a schedule for performing a two-tone raw trace acquisition.

Parameters:

qubit_pulse_amp – The amplitude of the pulse in Volt.
qubit_pulse_duration – The duration of the pulse in seconds.
qubit_pulse_frequency – The pulse frequency in Hertz.
qubit_pulse_port – The location on the device where the qubit pulse should be applied.
qubit_pulse_clock – The reference clock used to track the pulse frequency.
ro_pulse_amp – The amplitude of the readout pulse in Volt.
ro_pulse_duration – The duration of the readout pulse in seconds.
ro_pulse_delay – The time between the end of the pulse and the start of the readout pulse.
ro_pulse_port – The location on the device where the readout pulse should be applied.
ro_pulse_clock – The reference clock used to track the readout pulse frequency.
ro_pulse_frequency – The readout pulse frequency in Hertz.
ro_acquisition_delay – The start of the data acquisition with respect to the start of the pulse in seconds.
ro_integration_time – The integration time of the data acquisition in seconds.
init_duration – The relaxation time or dead time.
repetitions – The amount of times the Schedule will be repeated.

Returns:

The Two-tone Trace acquisition Schedule.