qat.experimental.frontend.importer.pulse.builder module

class PulseKernelBuilder(name, shots=None)

Bases: object

Base class for importers that translate a program into the Pulse dialect.

Provides common machinery for assembling programs at the pulse-level, which can be used to assemble a pulse-level kernel.

It does not yet support custom control flow constructs, but it provides the ability to pass through the number of shots, and eventually sweep parameters, which is then used to build the structured control flow around the program. Likewise, it does not support parameterisation of arguments in the operations it constructs (or kernel arguments). This is likely to change in the future.

Warning

This is intended for internal compiler use and is not part of the public API. We use it in our importers for pulse-level programs, and it is a useful tool for testing. We cannot guarantee that it will remain stable or supported in future releases. Use with caution.

The builder allows for symbolic construction of frames, waveforms and acquisition results that can be used in subsequent operations. The methods to build operations return the builder instance to allow for method chaining. For example,

kernel = (
    PulseKernelBuilder("my_kernel", shots=1000)
    .create_frame("q0/drive", 4.8e9, "q0")
    .create_frame("q0/readout", 8.8e9, "r0")
    .create_frame("q0/acquire", 8.8e9, "r0")
    .phase_set("q0/drive", 0.0)
    .phase_set("q0/acquire", 0.0)
    .create_gaussian_waveform("q0/drive", 0.5, 80e-9, 0.47, False)
    .create_square_waveform("q0/readout", 0.5, 800e-9)
    .pulse("q0/drive", "q0/drive")
    .phase_shift("q0/drive", 1.57)
    .pulse("q0/drive", "q0/drive")
    .synchronize("q0/drive", "q0/readout", "q0/acquire")
    .pulse("q0/readout", "q0/readout")
    .wait("q0/acquire", 80e-9)
    .acquire("q0/acquire", "q0_meas", 800e-9, integrate=True)
    .synchronize("q0/drive", "q0/readout", "q0/acquire")
    .wait("q0/drive", 500e-6)
    .synchronize("q0/drive", "q0/readout", "q0/acquire")
)

The previous program would implement a simple experiment to drive a qubit and measure it, with a reset time between shots.

Initialise a new PulseKernelBuilder.

Parameters:

name¶ (str) – The name of the kernel to build.
shots¶ (Optional[int]) – The number of shots to run the kernel for. Setting it to None (default) will add no shots.

acquire(frame_name, acquire_name, duration, weights=None, integrate=True)

Add an acquire operation to the pulse block.

Parameters:

frame_name¶ (str) – The name of the frame to acquire from.
acquire_name¶ (str) – The name used to track the acquisition result that can be used in post-processing.
duration¶ (float) – The duration of the acquisition.
weights¶ (Optional[list[float | complex]]) – The weights to use for the acquisition.
integrate¶ (bool) – Whether to integrate the acquisition result to give an IQ value.

Return type: