Tutorial: ScheduleGettable#

1D iterative measurement loop#

Setup and hardware configuration

The device setup and hardware configuration for this tutorial can be viewed in the collapsed code cells. In places where you would communicate with actual hardware, dummy objects have been used. If you want to learn more about how to set up the QuantumDevice and hardware configuration, please see our other tutorials, in particular Tutorial: Running an Experiment and Tutorial: Compiling to Hardware.

Set up the quantum device, dummy hardware and hardware configuration Hide code cell content

from qblox_instruments import Cluster, ClusterType
from quantify_core.data import handling as dh

from quantify_scheduler.device_under_test.quantum_device import QuantumDevice
from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement
from quantify_scheduler.instrument_coordinator import InstrumentCoordinator
from quantify_scheduler.instrument_coordinator.components.qblox import ClusterComponent
from quantify_scheduler.helpers.qblox_dummy_instrument import start_dummy_cluster_armed_sequencers


# First, don't forget to set the data directory!
dh.set_datadir()  # change me!

# We define a single transmon qubit as an element (BasicTransmonElement) of the
# QuantumDevice, and populate the parameters with some reasonable values.

# Device parameters
ACQ_DELAY = 100e-9
FREQ_01 = 4e9
READOUT_AMP = 0.1
READOUT_FREQ = 4.3e9
PI_PULSE_AMP = 0.15
LO_FREQ_QUBIT = 3.9e9
LO_FREQ_READOUT = 4.5e9

single_qubit_device = QuantumDevice("single_qubit_device")

q0 = BasicTransmonElement("q0")
single_qubit_device.add_element(q0)

# Assign device parameters to transmon element
q0.measure.pulse_amp(READOUT_AMP)
q0.clock_freqs.readout(READOUT_FREQ)
q0.clock_freqs.f01(FREQ_01)
q0.measure.acq_delay(ACQ_DELAY)
q0.rxy.amp180(PI_PULSE_AMP)

# For this example, we will set up a Qblox cluster hardware setup with two modules: a
# QRM-RF and a QCM-RF.

# Note: if you are connecting to an actual cluster, you would provide the
# 'identifier' argument (the ip address, device name or serial number) instead
# of the 'dummy_cfg' argument.
cluster = Cluster(
    "cluster",
    dummy_cfg={
        1: ClusterType.CLUSTER_QRM_RF,
        2: ClusterType.CLUSTER_QCM_RF,
    },
)

ic_cluster = ClusterComponent(cluster)

# Temporarily fixing dummy cluster's deficiency.
cluster.start_sequencer = lambda : start_dummy_cluster_armed_sequencers(ic_cluster)

# We create an InstrumentCoordinator to control the cluster and add it to the
# QuantumDevice.

instrument_coordinator = InstrumentCoordinator("instrument_coordinator")
instrument_coordinator.add_component(ic_cluster)

single_qubit_device.instr_instrument_coordinator(instrument_coordinator.name)

# A basic hardware configuration will be used for the two cluster modules.

hardware_cfg = {
    "config_type": "quantify_scheduler.backends.qblox_backend.QbloxHardwareCompilationConfig",
    "hardware_description": {
        f"{cluster.name}": {
            "instrument_type": "Cluster",
            "modules": {
                "1": {
                    "instrument_type": "QRM_RF"
                },
                "2": {
                    "instrument_type": "QCM_RF"
                }
            },
            "ref": "internal"
        }
    },
    "hardware_options": {
        "modulation_frequencies": {
            "q0:res-q0.ro": {
                "lo_freq": LO_FREQ_READOUT
            },
            "q0:mw-q0.01": {
                "lo_freq": LO_FREQ_QUBIT
            }
        }
    },
    "connectivity": {
        "graph": [
            [f"{cluster.name}.module1.complex_output_0", "q0:res"],
            [f"{cluster.name}.module2.complex_output_0", "q0:mw"]
        ]
    }
}


# This hardware configuration should also be added to the quantum device.
single_qubit_device.hardware_config(hardware_cfg)

Data will be saved in:
/root/quantify-data

For this experiment, we have set up a basic QuantumDevice called single_qubit_device, representing a single transmon qubit.

We’ll now define the schedule function. A valid schedule function must contain a repetitions (integer) parameter (see Repetitions), and can contain any number of additional parameters. It must return a Schedule object.

The schedule function can be parameterized to loop over different values. The parameters can be scalars or arrays. For example, the schedule function defined below takes an array of values for the parameter times. This is called a batched measurement, as will be explained further in this tutorial.

from quantify_scheduler import Schedule
from quantify_scheduler.operations.gate_library import Measure, Reset, X

def t1_sched(times, repetitions=1):
    schedule = Schedule("T1", repetitions)
    for i, tau in enumerate(times):
        schedule.add(Reset("q0"), label=f"Reset {i}")
        schedule.add(X("q0"), label=f"pi {i}")
        # Measure tau seconds after the start of the X gate
        schedule.add(
            Measure("q0", acq_index=i),
            ref_pt="start",
            rel_time=tau,
            label=f"Measurement {i}",
        )
    return schedule

Now, let’s create the ScheduleGettable. The ScheduleGettable provides a convenient way to compile and execute schedules in just a few lines of code. The parameters can be set directly, with arrays and scalars, or through QCoDeS parameters, as shown below.

import numpy as np

from qcodes.instrument.parameter import ManualParameter

from quantify_scheduler.gettables import ScheduleGettable

# The points we want to measure.
times = np.linspace(start=1.6e-7, stop=4.976e-5, num=125)

# As QCoDeS parameter:
time = ManualParameter("sample", label="Sample time", unit="s")
# Set the parameter. This can be done even after defining the gettable!
time(times)

# Or as array:
time = times

# Configure the gettable
gettable = ScheduleGettable(
    quantum_device=single_qubit_device,
    schedule_function=t1_sched,
    schedule_kwargs={"times": time},
    batched=True
)

Note that batched=True here. This means we are doing a batched measurement, which simply means that we tell the ScheduleGettable to expect an array of values in the acquisition result. In this case, our schedule function creates one schedule for an array of times, and it includes an acquisition (the Measure operation) for each point.

Let’s now run the experiment and retrieve the acquisitions using the get() method.

import matplotlib.pyplot as plt


data = gettable.get()

plt.plot(times, data[0], '.', label="real")
plt.plot(times, data[1], '.', label="imaginary")
plt.legend()
plt.xlabel("Idle time (s)")
plt.ylabel("Voltage (V)")
plt.show()

../_images/c662466934a66d08b65dbee65015fa8af5eb2611b04afbc7b63b670ae662b296.png

Note that the data used here is the same as in Tutorial: Running an Experiment. The example dataset can be downloaded here.

As we defined 125 points in our times array which were measured in 125 different acq_indexes, the acquisition result also contains 125 I values (in data[0][:]) and 125 Q values (in data[1][:]). The general format of the data returned by the ScheduleGettable is also explained in the user guide.

Trace measurement#

The previous experiment’s acquisition results had one data point for each acquisition in the schedule. For a trace measurement, the data format is slightly different. To illustrate this, let us set up an experiment with a trace measurement.

from quantify_scheduler.operations.pulse_library import IdlePulse, SoftSquarePulse


def trace_schedule(pulse_amp, acq_delay, port="q0:res", clock="q0.ro", repetitions=1):
    schedule = Schedule("Trace a pulse", repetitions=repetitions)

    schedule.add(
        SoftSquarePulse(
            duration=q0.measure.integration_time(),
            amp=pulse_amp,
            port=port,
            clock=clock,
        ),
        label="trace_pulse",
    )

    # Add acq_delay to compensate for time-of-flight of the pulse
    schedule.add(
        Measure(q0.name, acq_protocol="Trace"),
        ref_pt="start",
        rel_time=acq_delay,
        label="acquisition"
    )

    return schedule

Again, we define the gettable and run the experiment.

gettable = ScheduleGettable(
    quantum_device=single_qubit_device,
    schedule_function=trace_schedule,
    schedule_kwargs={
        "pulse_amp": 0.5,
        "acq_delay": 100e-9,
        },
    batched=True,
)

data = gettable.get()

plt.plot(np.arange(1000)/1e9, data[0], '.', label="real")
plt.plot(np.arange(1000)/1e9, data[1], '.', label="imaginary")
plt.legend()
plt.xlabel("Time (s)")
plt.ylabel("Voltage (V)")
plt.show()

/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:634: RuntimeWarning: Operation is interrupting previous Pulse because it starts before the previous ends, offending operation: Pulse "SquarePulse" (t0=1.0000000000000001e-07, duration=3e-07)
  warnings.warn(

../_images/82d1184bf0347c212f1b1847c602baf859bb2152ee98ed68aa6c447b9234a1e5.png

This time, there is only one acquisition operation in the schedule. The measurement result contains two arrays: one for the I values (data[0][:]), and one for the Q values (data[1][:]) of the acquired trace.

Repetitions#

Repetition defines how many times the defined schedule will run on the hardware. Running the schedule multiple times can be useful for example if the user would like to reduce errors of acquisitions by averaging the result of multiple measurements.

There are multiple ways the repetitions can be set. They are not completely independent of each other, and which setting will be taken into account depends on how you create and use the schedule.

QuantumDevice: via cfg_sched_repetitions (by default it is 1024),
schedule function: via the repetitions function argument,
Schedule object: via the repetitions function argument of its constructor, or via its repetitions attribute directly,
(ScheduleGettable: currently, it is not possible to supply repetitions via schedule_kwargs).

Ultimately, the Schedule object is what governs the repetitions, via its repetitions attribute.

When using a schedule function, the repetitions function argument sets the repetitions, provided that the schedule function passes it to the Schedule object. This is true for the pre-defined schedules, see quantify_scheduler.schedules.

However, if the experiment is run using ScheduleGettable, this repetitions function argument is set to QuantumDevice.cfg_sched_repetitions. Hence, typically, the schedule will run QuantumDevice.cfg_sched_repetitions times.

Possible mistake: ignoring `repetitions` argument#

Keep in mind that the schedule function should pass the repetitions argument to the Schedule initializer, otherwise both QuantumDevice.cfg_sched_repetitions and the repetitions argument of the schedule function will be ignored. For example, in the following setup, the repetitions will always be 1 (default for the Schedule object), even if cfg_sched_repetitions is set to 2.

def schedule_function(q0: str, repetitions: int):
    schedule = Schedule("Example schedule")
    schedule.add(Measure(q0, acq_index=0))
    return schedule

from quantify_scheduler.device_under_test.quantum_device import QuantumDevice
quantum_device = QuantumDevice(name="quantum_sample")
quantum_device.cfg_sched_repetitions(2)

from quantify_scheduler.gettables import ScheduleGettable
schedule_gettable = ScheduleGettable(
    quantum_device=quantum_device,
    schedule_function=schedule_function,
    schedule_kwargs={"q0": "q0"},
)

Possible mistake: ignoring `cfg_sched_repetitions` default value#

Also note, that the default value of the repetitions argument of the schedule function will be ignored if ScheduleGettable is used, and it will be set to QuantumDevice.cfg_sched_repetitions. For example, in the following setup, repetitions will be 1024 (default for QuantumDevice), even if the default argument for repetitions is 2.

def schedule_function(q0: str, repetitions: int = 2):
    schedule = Schedule("Example schedule", repetitions=repetitions)
    schedule.add(Measure(q0, acq_index=0))
    return schedule

from quantify_scheduler.device_under_test.quantum_device import QuantumDevice
quantum_device = QuantumDevice(name="quantum_sample")

from quantify_scheduler.gettables import ScheduleGettable
schedule_gettable = ScheduleGettable(
    quantum_device=quantum_device,
    schedule_function=schedule_function,
    schedule_kwargs={"q0": "q0"},
)

Tutorial: ScheduleGettable#

1D iterative measurement loop#

Trace measurement#

MeasurementControl#

Repetitions#

Possible mistake: ignoring `repetitions` argument#

Possible mistake: ignoring `cfg_sched_repetitions` default value#

2D (and ND) measurement loops#

Batched 2D experiment#

Tutorial: ScheduleGettable#

1D iterative measurement loop#

Trace measurement#

MeasurementControl#

Repetitions#

Possible mistake: ignoring repetitions argument#

Possible mistake: ignoring cfg_sched_repetitions default value#

2D (and ND) measurement loops#

Batched 2D experiment#

Possible mistake: ignoring `repetitions` argument#

Possible mistake: ignoring `cfg_sched_repetitions` default value#