Module containing the core concepts of the scheduler.

Module Contents#



Interface to be used for Schedule.


A modifiable schedule.


A representation of an element on a schedule.


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


A description of the shape and type of data that a schedule will return when executed.

class ScheduleBase(dict=None, /, **kwargs)[source]#

Bases: quantify_scheduler.json_utils.JSONSchemaValMixin, collections.UserDict, abc.ABC

Interface to be used for Schedule.

The ScheduleBase is a data structure that is at the core of the Quantify-scheduler and describes when what operations are applied where.

The ScheduleBase is a collection of quantify_scheduler.operations.operation.Operation objects and timing constraints that define relations between the operations.

The schedule data structure is based on a dictionary. This dictionary contains:

The Schedule provides an API to create schedules. The CompiledSchedule represents a schedule after it has been compiled for execution on a backend.

The Schedule contains information on the operations and schedulables. The operations is a dictionary of all unique operations used in the schedule and contain the information on what operation to apply where. The schedulables is a dictionary of Schedulables describing timing constraints between operations, i.e. when to apply an operation.

JSON schema of a valid Schedule

JSON schema for a quantify schedule.




  • name

Name of the schedule.



  • repetitions

The amount of times the schedule will be repeated.





  • schedulables

A dictionary containing schedulables.



  • operation_dict

A dictionary of operations. Keys correspond to the hash attribute of operations.



  • resource_dict

A dictionary of resources.



  • compiled_instructions

A containing compiled instructions.



  • duration

Duration of the schedule.





property name: str[source]#

Returns the name of the schedule.

property repetitions: int[source]#

Returns the amount of times this Schedule will be repeated.


The repetitions count.

property operations: dict[str, quantify_scheduler.operations.operation.Operation | Schedule][source]#

A dictionary of all unique operations used in the schedule.

This specifies information on what operation to apply where.

The keys correspond to the hash and values are instances of quantify_scheduler.operations.operation.Operation.

property schedulables: dict[str, Any][source]#

A list of schedulables describing the timing of operations.

A schedulable uses timing constraints to constrain the operation in time by specifying the time ("rel_time") between a reference operation and the added operation. The time can be specified with respect to a reference point ("ref_pt"') on the reference operation (:code:”ref_op”) and a reference point on the next added operation (:code:”ref_pt_new”’). A reference point can be either the “start”, “center”, or “end” of an operation. The reference operation ("ref_op") is specified using its label property.

Each item in the list represents a timing constraint and is a dictionary with the following keys:

['label', 'rel_time', 'ref_op', 'ref_pt_new', 'ref_pt', 'operation_id']

The label is used as a unique identifier that can be used as a reference for other operations, the operation_id refers to the hash of an operation in operations.


timing constraints are not intended to be modified directly. Instead use the add()

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

A dictionary containing resources.

Keys are names (str), values are instances of Resource.

property hash: str[source]#

A hash based on the contents of the Schedule.

property timing_table:[source]#

A styled pandas dataframe containing the absolute timing of pulses and acquisitions in a schedule.

This table is constructed based on the abs_time key in the schedulables. This requires the timing to have been determined.

The table consists of the following columns:

  • operation: a repr of Operation corresponding to the pulse/acquisition.

  • waveform_op_id: an id corresponding to each pulse/acquisition inside an Operation.

  • port: the port the pulse/acquisition is to be played/acquired on.

  • clock: the clock used to (de)modulate the pulse/acquisition.

  • abs_time: the absolute time the pulse/acquisition is scheduled to start.

  • duration: the duration of the pulse/acquisition that is scheduled.

  • is_acquisition: whether the pulse/acquisition is an acquisition or not (type numpy.bool_).

  • wf_idx: the waveform index of the pulse/acquisition belonging to the Operation.

  • operation_hash: the unique hash corresponding to the Schedulable that the pulse/acquisition belongs to.


schedule = Schedule("demo timing table")
schedule.add(Reset("q0", "q4"))
schedule.add(Measure("q0", acq_index=0))
schedule.add(Measure("q4", acq_index=0))

compiled_schedule = compiler.compile(schedule)
  waveform_op_id port clock abs_time duration is_acquisition operation wf_idx operation_hash
0 Reset('q0','q4')_acq_0 None cl0.baseband 0.0 ns 200,000.0 ns False Reset('q0','q4') 0 2509517595986024315
1 Reset('q0','q4')_acq_1 None cl0.baseband 0.0 ns 200,000.0 ns False Reset('q0','q4') 1 2509517595986024315
2 X(qubit='q0')_acq_0 q0:mw q0.01 200,000.0 ns 20.0 ns False X(qubit='q0') 0 5960549987808152712
3 Y(qubit='q4')_acq_0 q4:mw q4.01 200,020.0 ns 20.0 ns False Y(qubit='q4') 0 -8380126630911543856
4 Measure('q0', acq_index=0, acq_protocol="None", bin_mode=None)_acq_0 None 200,040.0 ns 0.0 ns False Measure('q0', acq_index=0, acq_protocol="None", bin_mode=None) 0 -7218704376116442666
5 Measure('q0', acq_index=0, acq_protocol="None", bin_mode=None)_acq_1 q0:res 200,040.0 ns 300.0 ns False Measure('q0', acq_index=0, acq_protocol="None", bin_mode=None) 1 -7218704376116442666
6 Measure('q0', acq_index=0, acq_protocol="None", bin_mode=None)_acq_0 q0:res 200,140.0 ns 1,000.0 ns True Measure('q0', acq_index=0, acq_protocol="None", bin_mode=None) 0 -7218704376116442666
7 Measure('q4', acq_index=0, acq_protocol="None", bin_mode=None)_acq_0 None 201,140.0 ns 0.0 ns False Measure('q4', acq_index=0, acq_protocol="None", bin_mode=None) 0 5349603044738011506
8 Measure('q4', acq_index=0, acq_protocol="None", bin_mode=None)_acq_1 q4:res 201,140.0 ns 300.0 ns False Measure('q4', acq_index=0, acq_protocol="None", bin_mode=None) 1 5349603044738011506
9 Measure('q4', acq_index=0, acq_protocol="None", bin_mode=None)_acq_0 q4:res 201,240.0 ns 1,000.0 ns True Measure('q4', acq_index=0, acq_protocol="None", bin_mode=None) 0 5349603044738011506

schedule – a schedule for which the absolute timing has been determined.


styled_timing_table, a pandas Styler containing a dataframe with an overview of the timing of the pulses and acquisitions present in the schedule. The dataframe can be accessed through the .data attribute of the Styler.


ValueError – When the absolute timing has not been determined during compilation.

property duration: float | None[source]#

Determine the cached duration of the schedule.

Will return None if get_schedule_duration() has not been called before.

to_json() str[source]#

Convert the Schedule data structure to a JSON string.


The json string result.

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

Convert the JSON data to a Schedule.


data – The JSON data.


The Schedule object.

plot_circuit_diagram(figsize: tuple[int, int] = None, ax: matplotlib.axes.Axes | None = None, plot_backend: Literal[mpl] = 'mpl') tuple[matplotlib.figure.Figure, matplotlib.axes.Axes | list[matplotlib.axes.Axes]][source]#

Create a circuit diagram visualization of the schedule using the specified plotting backend.

The circuit diagram visualization depicts the schedule at the quantum circuit layer. Because quantify-scheduler uses a hybrid gate-pulse paradigm, operations for which no information is specified at the gate level are visualized using an icon (e.g., a stylized wavy pulse) depending on the information specified at the quantum device layer.

Alias of quantify_scheduler.schedules._visualization.circuit_diagram.circuit_diagram_matplotlib().

  • schedule – the schedule to render.

  • figsize – matplotlib figsize.

  • ax – Axis handle to use for plotting.

  • plot_backend – Plotting backend to use, currently only ‘mpl’ is supported


  • fig – matplotlib figure object.

  • ax – matplotlib axis object.

Each gate, pulse, measurement, and any other operation are plotted in the order of execution, but no timing information is provided.


from quantify_scheduler import Schedule
from quantify_scheduler.operations.gate_library import Reset, X90, CZ, Rxy, Measure

sched = Schedule(f"Bell experiment on q0-q1")

sched.add(Reset("q0", "q1"))
sched.add(X90("q1"), ref_pt="start", rel_time=0)
sched.add(CZ(qC="q0", qT="q1"))
sched.add(Rxy(theta=45, phi=0, qubit="q0") )
sched.add(Measure("q0", acq_index=0))
sched.add(Measure("q1", acq_index=0), ref_pt="start")



Gates that are started simultaneously on the same qubit will overlap.

from quantify_scheduler import Schedule
from quantify_scheduler.operations.gate_library import X90, Measure

sched = Schedule(f"overlapping gates")

sched.add(Measure("q0"), ref_pt="start", rel_time=0)


If the pulse’s port address was not found then the pulse will be plotted on the ‘other’ timeline.

plot_pulse_diagram(port_list: list[str] | None = None, sampling_rate: float = 1000000000.0, modulation: Literal[off, if, clock] = 'off', modulation_if: float = 0.0, plot_backend: Literal[mpl, plotly] = 'mpl', plot_kwargs: dict | None = None, **backend_kwargs: Any) tuple[matplotlib.figure.Figure, matplotlib.axes.Axes] | plotly.graph_objects.Figure[source]#

Create a visualization of all the pulses in a schedule using the specified plotting backend.

The pulse diagram visualizes the schedule at the quantum device layer. For this visualization to work, all operations need to have the information present (e.g., pulse info) to represent these on the quantum-circuit level and requires the absolute timing to have been determined. This information is typically added when the quantum-device level compilation is performed.

Alias of quantify_scheduler.schedules._visualization.pulse_diagram.pulse_diagram_matplotlib() and quantify_scheduler.schedules._visualization.pulse_diagram.pulse_diagram_plotly().


the plot

Return type:

Union[Tuple[Figure, Axes], plotly.graph_objects.Figure]


A simple plot with matplotlib can be created as follows:

from quantify_scheduler.backends.graph_compilation import SerialCompiler
from quantify_scheduler.device_under_test.quantum_device import QuantumDevice
from quantify_scheduler.operations.pulse_library import DRAGPulse, SquarePulse, RampPulse
from quantify_scheduler.resources import ClockResource

schedule = Schedule("Multiple waveforms")
schedule.add(DRAGPulse(G_amp=0.2, D_amp=0.2, phase=0, duration=4e-6, port="P", clock="C"))
schedule.add(RampPulse(amp=0.2, offset=0.0, duration=6e-6, port="P"))
schedule.add(SquarePulse(amp=0.1, duration=4e-6, port="Q"), ref_pt='start')
schedule.add_resource(ClockResource(name="C", freq=4e9))

quantum_device = QuantumDevice("quantum_device")
device_compiler = SerialCompiler("Device compiler", quantum_device)
compiled_schedule = device_compiler.compile(schedule)

_ = compiled_schedule.plot_pulse_diagram(sampling_rate=20e6)

The backend can be changed to the plotly backend by specifying the plot_backend=plotly argument. With the plotly backend, pulse diagrams include a separate plot for each port/clock combination:

compiled_schedule.plot_pulse_diagram(sampling_rate=20e6, plot_backend='plotly')