Skip to content

Pulses and Pulse Commands

Pulses and pulse commands and are a central part of your experiment. They control the qubit drive, the measurement, and when to trigger acquisition. In LabOne Q, pulse commands live within sections, which provide an framework to ensure consistent, deterministic timing. In this chapter, an overview of each pulse command is given. The API Reference gives a complete list of the arguments that each pulse command takes.

Play

The play command executes a pulse on a specified experimental signal line. This command is generally used for qubit control, drive lines or flux lines, on the signal generator channels of the SHFQC, SHFSG, or HDAWG.

The following example plays a drag pulse with default parameters from the built-in pulse library.

my_puse = pulse_library.drag()

exp.play(
    signal="drive",
    pulse=my_pulse
)
In addition to the required arguments, play allows you to specify the pulse in terms of its amplitude, phase, length etc. See the API documentation of the play command for further details.

Pulse Library

LabOne Q contains a built-in library of simple pulse shapes often used in experiments, including gaussian, flat-top gaussian, and DRAG pulses. You can also register your own pulse functional, as detailed in this notebook, or use complex or real arrays of data to define your pulses.

Acquire

acquire is used to make measurements a specified input signal line. In experiments using pulsed readout, an acquire command is preceded by a measurement pulse played on the measure line belonging to the same QA unit.

The acquire command picks up a returning signal on its signal line and stores it under a given handle. Depending on the acquisition_type specified in the acquire loop, a kernel may be needed for direct integration of the signal.

exp.acquire(
    signal="acquire",
    handle="my_handle",
    kernel=Pulse(...) # optional
    )

Measure

measure combines playing a measurement pulse and acquiring the returning signal on a measure/acquire pair of signal lines of the same QA unit.

exp.measure(
    acquire_signal="acquire",
    handle="my_handle",
    measure_signal="measure",
    measure_pulse=Pulse(...),
    integration_kernel=Pulse(...) # optional
    )

See the API documentation of the measure command for further details.

Delay

The delay command delays any subsequent operation on a given signal line for the provided time.

exp.delay(signal="drive",
time=1e-6)

Reserve

As detailed in the rules of DSL, LabOne Q optimizes experiment runtimes by shifting pulse commands next to the last operation of the same signal line. The reserve command allows you to prevent this:

with exp.Section("Section1"):
    exp.play(signal="drive1", ...)
with exp.Section("Section2"):
    exp.reserve(signal="drive1")
    exp.play(signal="drive2", ...)
In the above example, the reserve command prevents the play command on drive2 to be shifted next to the first play command on drive1. Note, that you can achieve the same by reserving drive2 in the first section. The delay command could also, in simple cases, result in the same timing behavior. However, as your experiment grows in complexity, the combination of reserve with sections and their rules eliminates the need to keep track of many delay commands across the experiment.

Call

The call command allows you to invoke you custom function with key-value pairs from a dictionary parameter_dict as arguments within a sequence of pulse commands as follows:

exp.call(
    func_name=my_custom_function,
    parameter_dict
)
This is relevant should you need to control external instruments and devices as part of your experiment.