quantify_scheduler.schedules.schedule

Module containing the core concepts of the scheduler.

Module Contents

Classes

ScheduleBase

The ScheduleBase is a data structure that is at

Schedule

A modifiable schedule.

Schedulable

This class represents an element on a schedule. All elements on a schedule are

CompiledSchedule

A schedule that contains compiled instructions ready for execution using

AcquisitionMetadata

Class to provide a description of the shape and type of data that a schedule will

class ScheduleBase(**kwargs)[source]

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

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.

type

object

properties

  • name

Name of the schedule.

type

string

  • repetitions

The amount of times the schedule will be repeated.

type

integer

default

1

  • schedulables

A dictionary containing schedulables.

type

object

  • operation_dict

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

type

object

  • resource_dict

A dictionary of resources.

type

object

  • compiled_instructions

A containing compiled instructions.

type

object

additionalProperties

False

property name: str[source]

Returns the name of the schedule.

property repetitions: int[source]

Returns the amount of times this Schedule will be repeated.

Returns

The repetitions count.

property operations: Dict[str, quantify_scheduler.operations.operation.Operation][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_repr']

The label is used as a unique identifier that can be used as a reference for other operations, the operation_repr refers to the string representation of a operation in operations.

Note

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 timing_table: pandas.io.formats.style.Styler[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.

Parameters

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

Returns

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 data frame can be accessed through the .data attribute of the Styler.

Raises

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

__repr__() str[source]

Return repr(self).

to_json() str[source]

Converts the Schedule data structure to a JSON string.

Returns

The json string result.

classmethod from_json(data: str) Schedule[source]

Converts the JSON data to a Schedule.

Parameters

data – The JSON data.

Returns

The Schedule object.

plot_circuit_diagram(figsize: Tuple[int, int] = None, ax: Optional[matplotlib.axes.Axes] = None, plot_backend: Literal[mpl] = 'mpl') Tuple[matplotlib.figure.Figure, Union[matplotlib.axes.Axes, List[matplotlib.axes.Axes]]][source]

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

The circuit diagram visualization visualizes the schedule at the quantum circuit layer. This visualization provides no timing information, only showing the order of operations. 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 circuit_diagram.circuit_diagram_matplotlib().

Parameters
  • 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

Returns

  • fig – matplotlib figure object.

  • ax – matplotlib axis object.

plot_pulse_diagram(port_list: Optional[List[str]] = 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: Optional[dict] = None) Union[Tuple[matplotlib.figure.Figure, matplotlib.axes.Axes], plotly.graph_objects.Figure][source]

Creates 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 pulse_diagram.pulse_diagram_matplotlib() and pulse_diagram.pulse_diagram_plotly().

port_list :

A list of ports to show. if set to None will use the first 8 ports it encounters in the sequence.

modulation :

Determines if modulation is included in the visualization.

modulation_if :

Modulation frequency used when modulation is set to “if”.

sampling_rate :

The time resolution used to sample the schedule in Hz.

plot_backend:

Plotting library to use, can either be ‘mpl’ or ‘plotly’.

plot_kwargs:

Dictionary of keyword arguments to pass to the plotting backend

Returns

the plot

Return type

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

get_schedule_duration()[source]

Method to find the duration of the schedule.

Returns

schedule_duration – Duration of current schedule

Return type

float

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.

schema_filename = schedule.json[source]
add_resources(resources_list: list) None[source]

Add wrapper for adding multiple resources

add_resource(resource) None[source]

Add a resource such as a channel or qubit to the schedule.

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

Add an quantify_scheduler.operations.operation.Operation to the schedule.

Parameters
  • operation – The operation to add to the schedule

  • 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’).

  • ref_pt_new – reference point in added operation must be one of (‘start’, ‘center’, ‘end’).

  • 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.

Returns

returns the schedulable created on the schedule

__getstate__()[source]
__setstate__(state)[source]
class Schedulable(name, operation_repr, schedule, data: dict = None)[source]

Bases: quantify_scheduler.json_utils.JSONSchemaValMixin, collections.UserDict

This class represents 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.

schema_filename = schedulable.json[source]
add_timing_constraint(rel_time: float = 0, ref_schedulable: Schedulable = None, ref_pt: Literal[start, center, end] = 'end', ref_pt_new: Literal[start, center, end] = 'start')[source]

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 schedulable must be one of (‘start’, ‘center’, ‘end’).

  • ref_pt_new – reference point in added schedulable must be one of (‘start’, ‘center’, ‘end’).

__str__()[source]

Return str(self).

__getstate__()[source]
__setstate__(state)[source]
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 qcompile().

property compiled_instructions: Dict[str, quantify_scheduler.resources.Resource][source]

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.

property hardware_timing_table: pandas.io.formats.style.Styler[source]

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

Returns 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.

schema_filename = schedule.json[source]
classmethod is_valid(object_to_be_validated) bool[source]

Checks if the contents of the object_to_be_validated are valid according to the schema. Additionally checks if the object_to_be_validated is an instance of CompiledSchedule

class AcquisitionMetadata[source]

Class to provide a description of the shape and type of data that a schedule will return when executed.

Note

The acquisition protocol, bin-mode and return types are assumed to be the same for all acquisitions in a schedule.

acq_protocol :str[source]

The acquisition protocol that is used for all acquisitions in the schedule.

bin_mode :quantify_scheduler.enums.BinMode[source]

How the data is stored in the bins indexed by acq_channel and acq_index.

acq_return_type :Type[source]

The datatype returned by the individual acquisitions.

acq_indices :Dict[int, List[int]][source]

A dictionary containing the acquisition channel as key and a list of acquisition indices that are used for every channel.

__getstate__()[source]
__setstate__(state)[source]