Acquisitions#

Introduction#

This tutorial provides examples of how to add acquisitions to schedules and retrieve the corresponding results.

The fundamental data structure returned by an acquisition is an xarray.Dataset (official documentation), which consists of multiple xarray.DataArray.

Initial setup#

First, we set up the connection to the cluster and hardware configuration.

The introduction and parametrization of a qubit is not mandatory for running acquisitions. Hence schedules presented in this tutorial will remain at the pulse-level description, and we only define the hardware_configuration and not the quantum_device_configuration.

[1]:

from typing import Any

import xarray

from qblox_scheduler import HardwareAgent

[2]:

hardware_config: dict[str, Any] = {
    "version": "0.2",
    "config_type": "QbloxHardwareCompilationConfig",
    "hardware_description": {
        "cluster0": {
            "instrument_type": "Cluster",
            "modules": {"4": {"instrument_type": "QRM"}},
            "ref": "internal",
            "ip": "10.10.200.42",
        }
    },
    "hardware_options": {},
    "connectivity": {
        "graph": [
            ["cluster0.module4.complex_output_0", "q0:port"],
            ["cluster0.module4.complex_input_0", "q0:port"],
        ]
    },
}

hardware_agent: HardwareAgent = HardwareAgent(hardware_configuration=hardware_config)
cluster = hardware_agent.get_clusters()["cluster0"]

Pulse-level acquisitions#

Pulse-level acquisitions define when and how to store and retrieve input signals coming from the device. They are described by their timing information (start time and length), protocol, acq_label and coordinates.

Timing information specifies when the acquisition happens on the schedule.
Protocol defines which hardware or software formatting is done on the input signal.
acq_label and coordinates together identify acquisitions and data points for the user in the returned dataset: acq_label identifies a particular DataArray, while every point within such an array is identified by automatically-generated indices and assigned coordinates. These assigned coordinates are user-defined tags attached to the acquisitions which can be used for differentiating acquisitions or reshaping data arrays for further analysis.

In the following subsections we give examples for the supported acquisition protocols.

We assume, that these tutorials are run on a Qblox QRM module. On the QRM module \(\text{O}^{[1]}\) is connected to \(\text{I}^{[1]}\) and \(\text{O}^{[2]}\) is connected to \(\text{I}^{[2]}\).

The physical length of the cables connecting output to input channels introduces a delay before a sent signal is received. This delay is known as the TIME_OF_FLIGHT.

Thresholded acquisition#

With thresholded acquisition, we can map a complex input signal to either a 0 or a 1, by comparing the data to a threshold value. It is similar to the IQ integration acquisition described above, but after integration, the I-Q data points are first rotated by an angle and then compared to a threshold value to assign the results to either a “0” or to a “1”. See the illustration below.

th_acq

Here the threshold line is controlled by the qubit settings: acq_rotation and acq_threshold. By default (left figure) we have acq_rotation=0 and acq_threshold=0, where every measured (integrated) data point with I<0 is assigned the state “0”, and the remaining data points are assigned the state “1”. The first setting, acq_rotation, rotates the threshold line by an angle in degrees (0 - 360), clockwise. The second setting, acq_threshold, sets the threshold that is compared to the rotated integrated acquisition result.

Note: The qblox-instruments parameter thresholded_acq_threshold corresponds to a voltage obtained from an integrated acquisition, before normalizing with respect to the integration time. The qblox-scheduler parameter acq_threshold corresponds to an acquired voltage after normalizing with respect to the integration time (e.g. as obtained from a regular IQ integration acquisition).

Setting up the schedule#

Let’s consider a simple example where one acquires a pulse, whose amplitude is swept over. In the IQ plane, the corresponding data points are distributed along a line crossing the origin. Let’s use the threshold acquisition such that –after rotation in the IQ plane– points with positive real part are counted as being in the \(|1\rangle\) state, otherwise \(|0\rangle\) state. This can for example be applied for state measurement of a transmon.

Let’s first proceed to raw measurement of the points, and plot it in the IQ plane.

[26]:

# parameters for the experiment
# --------------------------------
PULSE_DURATION: float = 1e-6
ACQ_DURATION: float = 0.8 * PULSE_DURATION
TIME_OF_FLIGHT: float = 148e-9

[27]:

from qblox_scheduler import ClockResource, DType, IQIntegration, Schedule, linspace

schedule: Schedule = Schedule("IQ_acquisition")
schedule.add_resource(ClockResource(name="clock", freq=80e6))

with schedule.loop(linspace(-1.0, 1.0, 6, dtype=DType.AMPLITUDE)) as amp:
    schedule.add(
        SquarePulse(
            duration=PULSE_DURATION,
            amplitude=amp,
            port="q0:port",
            clock="clock",
        ),
    )
    schedule.add(
        IQIntegration(
            duration=ACQ_DURATION,
            port="q0:port",
            clock="clock",
            acq_label="data",
            coords={"amp": amp},
        ),
        ref_pt="start",
        rel_time=TIME_OF_FLIGHT,
    )

Then we fit the corresponding line on which these points are aligned in the IQ plane.

[28]:

import numpy as np
from numpy.polynomial.polynomial import Polynomial

if cluster.is_dummy:
    xr_raw_data = xr.open_dataset("./utils/data/data_thresholded_raw.hdf5", engine="h5netcdf")
else:
    xr_raw_data = hardware_agent.run(schedule)

# linear fit of the acquired data: y = mx + p
p, m = Polynomial.fit(x=xr_raw_data.data.real, y=xr_raw_data.data.imag, deg=1).convert().coef

# angle of the threshold line (orthogonal to the linear fit)
angle_cutoff: float = np.atan(m) + np.pi / 2

# slope of the orthogonal line (threshold line)
m_cutoff: float = np.tan(angle_cutoff)

print(f"Angle of the threshold line with the I axis: {np.rad2deg(angle_cutoff):.2f}°")

Angle of the threshold line with the I axis: 21.22°

And let’s plot it in a graph:

[29]:

from matplotlib import pyplot as plt

# making the plot
fig, ax = plt.subplots()

# plotting parameters
ax_range = 0.5
ymin, ymax = -ax_range, ax_range
x_fill = np.linspace(-ax_range, ax_range, 200)


ax.set_xlim([-ax_range, ax_range])
ax.set_ylim([-ax_range, ax_range])
ax.set_aspect("equal", adjustable="box")
ax.grid()
ax.set_xlabel("I (a.u.)")
ax.set_ylabel("Q (a.u.)")
ax.set_title("Acquired data plotted in the IQ plane")

# plotting the fitted line of data points
plt.axline((0, p), slope=m, linestyle="--")

# plotting the threshold line
plt.axline((0, p), slope=m_cutoff, linestyle="--", color="k")


# --- Shading the areas ✨ ---
# 1. Calculate the y-values of the cutoff line for the x-values
y_fill_line = m_cutoff * x_fill + p

# 2. Shade the area ABOVE the cutoff line
ax.fill_between(x_fill, y_fill_line, ymax, color="lightblue", alpha=0.5, label="Above Cutoff")

# 3. Shade the area BELOW the cutoff line
ax.fill_between(x_fill, ymin, y_fill_line, color="lightcoral", alpha=0.5, label="Below Cutoff")

# 4. Label the areas
ax.text(0.1, 0.3, '"$|0\\rangle$" state', fontsize=16)
ax.text(0.2, -0.2, '"$|1\\rangle$" state', fontsize=16)
# -----------------

# plotting the data
ax.scatter(x=xr_raw_data.data.real, y=xr_raw_data.data.imag)

[29]:

<matplotlib.collections.PathCollection at 0x7f3a90a574d0>

findfont: Failed to find font weight 300 for STIXGeneral, now using 400.
findfont: Failed to find font weight 300 for STIXGeneral, now using 400.
findfont: Failed to find font weight 300 for STIXNonUnicode, now using 400.
findfont: Failed to find font weight 300 for STIXNonUnicode, now using 400.
findfont: Failed to find font weight 300 for STIXSizeOneSym, now using 400.
findfont: Failed to find font weight 300 for STIXSizeTwoSym, now using 400.
findfont: Failed to find font weight 300 for STIXSizeThreeSym, now using 400.
findfont: Failed to find font weight 300 for STIXSizeFourSym, now using 400.
findfont: Failed to find font weight 300 for STIXSizeFiveSym, now using 400.
findfont: Failed to find font weight 300 for cmmi10, now using 400.
findfont: Failed to find font weight 300 for cmsy10, now using 400.
findfont: Failed to find font weight 300 for cmr10, now using 400.
findfont: Failed to find font weight 300 for cmtt10, now using 400.
findfont: Failed to find font weight 300 for cmti10, now using 400.
findfont: Failed to find font weight 300 for cmb10, now using 400.
findfont: Failed to find font weight 300 for cmss10, now using 400.
findfont: Failed to find font weight 300 for cmex10, now using 400.
findfont: Failed to find font weight 300 for DejaVu Sans, now using 400.
findfont: Failed to find font weight 300 for DejaVu Sans, now using 400.
findfont: Failed to find font weight 300 for DejaVu Sans Mono, now using 400.
findfont: Failed to find font weight 300 for DejaVu Sans Display, now using 400.

../../../../_images/products_qblox_scheduler_tutorials_any_acquisitions_54_2.png

Thresholded acquisition using ‘ThresholdedIQIntegration’#

We proceed next to the thresholded acquisition. Since we want to separate positive and negative real parts, we set the threshold to 0. With the previous fit of the raw data, we also already computed the value angle_cutoff from which the data should be rotated before comparison.

[30]:

from qblox_scheduler import (
    ClockResource,
    DType,
    Schedule,
    SquarePulse,
    ThresholdedIQIntegration,
    linspace,
)

THRESHOLD: float = 0.0

thres_acq_sched: Schedule = Schedule("thresholded_acquisition")
thres_acq_sched.add_resource(ClockResource(name="clock", freq=80e6))

with thres_acq_sched.loop(linspace(-1.0, 1.0, 6, dtype=DType.AMPLITUDE)) as amp:
    thres_acq_sched.add(
        SquarePulse(
            duration=PULSE_DURATION,
            amplitude=amp,
            port="q0:port",
            clock="clock",
        ),
    )
    thres_acq_sched.add(
        ThresholdedIQIntegration(
            duration=ACQ_DURATION,
            port="q0:port",
            clock="clock",
            acq_label="data",
            acq_rotation=angle_cutoff,
            acq_threshold=THRESHOLD,
            coords={"amp": amp},
        ),
        ref_pt="start",
        rel_time=TIME_OF_FLIGHT,
    )

[31]:

if cluster.is_dummy:
    xr_data_thresholded = xr.open_dataset("./utils/data/data_thresholded.hdf5", engine="h5netcdf")
    xr_data_thresholded.coords["amp"].values
    xr_data_thresholded.data.data
else:
    xr_data_thresholded: xarray.Dataset = hardware_agent.run(thres_acq_sched)

As expected, the 3 first points are identified as being in the 0 state (I values below threshold), and the 3 last points are indeed in the 1 state (above threshold).

Trigger count acquisition#

The trigger count acquisition protocol is used for measuring how many times the input signal goes over some limit. This protocol is used, for example, in cases where one wants to count the number of detection events in an experiment.

The trigger count protocol is currently only available on two module types: the QRM (baseband) and the QTM.

Similarly to what was discussed above with the IQ integration acquisition, we can make use of the coords argument to append or average the number of trigger events received during a given acquisition window. If a loop reference is set as being a coordinate of the acquisition, the number of counts is appended at each iteration of the loop.

In addition, there is the TriggerCountDistribution protocol which offers the distribution mode. It can only be used with the QRM.

In the TriggerCountDistribution protocol, the result is a distribution that maps the trigger count numbers to the number of occurrences of each trigger count number. This provides insights into the overall occurrence of triggers when running the acquisition multiple times. For example, imagine an experiment where a TriggerCount acquisition runs three times and detects [1, 3, 1] triggers respectively. In distribution mode, the instrument directly compiles a histogram of these results. It would report that a count of ‘1’ occurred twice and a count of ‘3’ occurred once, returning a result like {1: 2, 3: 1}. The dictionary notation shows the number of triggers as keys and their corresponding frequencies as values. Moreover, in TriggerCountDistribution there is no need to store and transfer the result of each individual acquisition and the distribution is handled on the Qblox hardware, TriggerCountDistribution is much faster than TriggerCount for the same amount of acquisitions.

For the input signal to be registered as counts, we need to set an acquisition threshold. The threshold is set for the QRM via the ttl_acq_threshold in the TTL acquisition threshold field, while for the QTM this threshold is set via the field analog_threshold in the digitization threshold hardware option.

Setting up the schedule#

Let’s have an illustrative example showing how this type of acquisition works in practice.

We use a source of random dirac pulses that we made up with a function generator: it plays a 20 ns wide TTL pulse in burst mode, externally triggered with a source of noise. The ratio between the burst trigger level of the function generator, and the RMS amplitude of the noise sets the average flux of pulses emitted by the source. In practice we set it up to have a flux of a few pulses per micro-second.

This source of random pulses is then connected to the second input of a QRM module, to proceed to the detection and counting.

Let’s first set up the hardware configuration for this experiment. We will set up the counting threshold of the QRM to 60% of the maximum input amplitude (so 0.6 x 0.5 V = 300 mV).

We will perform the acquisitions in a window of 15 us:

[32]:

ACQ_DURATION: float = 15e-6

[33]:

hardware_cfg_trigger_count: dict[str, Any] = {
    "config_type": "QbloxHardwareCompilationConfig",
    "version": "0.2",
    "hardware_description": {
        "cluster0": {
            "instrument_type": "Cluster",
            "modules": {
                4: {"instrument_type": "QRM"},
            },
            "ref": "internal",
        },
    },
    "hardware_options": {
        "sequencer_options": {
            "qrm:in1-digital": {
                "ttl_acq_threshold": 0.6,
            }
        },
    },
    "connectivity": {
        "graph": [
            ["cluster0.module4.complex_output_0", "qrm:out"],
            ["cluster0.module4.real_input_0", "qrm:in0"],
            ["cluster0.module4.real_input_1", "qrm:in1"],
        ]
    },
}

hardware_agent: HardwareAgent = HardwareAgent(hardware_configuration=hardware_cfg_trigger_count)
hardware_agent.connect_clusters()

/.venv/lib/python3.14/site-packages/qblox_scheduler/qblox/hardware_agent.py:603: UserWarning: cluster0: Trying to instantiate cluster with ip 'None'.Creating a dummy cluster.
  warnings.warn(

First check: scope acquisition#

We will start by simply performing a scope acquisition of the signal, to verify how it looks.

[34]:

from qblox_scheduler import Schedule, Trace

schedule: Schedule = Schedule("trace_acquisition_tutorial")

schedule.add(Trace(duration=ACQ_DURATION, acq_label="scope", port="qrm:in1", clock="cl0.baseband"))

xr_ttl_trace_acquisition: xarray.Dataset = hardware_agent.run(schedule)

Invalid input indices are connected. Scope data might be invalid. Connected input indices are (1,). Valid indices are (0, 1) and (2, 3).

[35]:

import xarray as xr

xr_ttl_trace_acquisition = xr.open_dataset(
    "./utils/data/trigger_count_scope.hdf5", engine="h5netcdf"
)

[36]:

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(10, 4))

xr_ttl_trace_acquisition["scope"].imag.plot(ax=ax)

ax.set_xlabel("Time (ns)")
ax.set_ylabel("Amplitude (a.u.)")
ax.set_title("Acquired trace")
ax.set_ylim(-0.1, 1.0)
ax.grid()

../../../../_images/products_qblox_scheduler_tutorials_any_acquisitions_66_0.png

Appending the counts#

We will repeat a TriggerCount acquisition, appending all the result until we entirely filled the acquisition memory of a QRM (currently set to a maximum of 3000000 bins).

[37]:

from qblox_scheduler import DType, Schedule, TriggerCount

REPS: int = 3_000_000  # maximum number of bins usable on QRM memory

schedule: Schedule = Schedule("trigger_count_acquisition_tutorial")

with schedule.loop(arange(0, REPS, 1, dtype=DType.NUMBER)) as rep:
    schedule.add(
        TriggerCount(
            duration=ACQ_DURATION,
            port="qrm:in1",
            clock="cl0.baseband",
            acq_label="counts",
            coords={"rep": rep},
        )
    )
xr_ttl_append_counts_acquisition: xarray.Dataset = hardware_agent.run(schedule)

[38]:

import xarray as xr

xr_ttl_append_counts_acquisition = xr.open_dataset(
    "./utils/data/simulated_3M_trigger_count_append.hdf5", engine="h5netcdf"
)

Let’s now plot the histogram of the 3 million appended counts, as well as the gaussian that we can extract from the computation of the mean value and standard deviation of this data series.

[39]:

fig, ax = plt.subplots()

avg = xr_ttl_append_counts_acquisition["counts"].mean().item()
std = xr_ttl_append_counts_acquisition["counts"].std().item()

x = np.linspace(0, 40, 100)
y = np.exp(-0.5 * ((x - avg) / std) ** 2) * REPS / (std * np.sqrt(2 * np.pi))

xr_ttl_append_counts_acquisition["counts"].plot.hist(
    bins=list(range(41)), edgecolor="black", align="left", ax=ax, label="Appended data histogram"
)
ax.plot(x, y, color="tab:red", ls="dashed", lw=2, label="Gaussian fit")


ax.legend()
ax.set_xlabel("Counts")
ax.set_ylabel("Occurrences")
ax.set_title(f"Histogram of Trigger Counts over {REPS} repetitions")
ax.text(30, 6000, f"Mean: {avg:.2f}\nStd: {std:.2f}")

[39]:

Text(30, 6000, 'Mean: 19.43\nStd: 3.72')

../../../../_images/products_qblox_scheduler_tutorials_any_acquisitions_71_1.png

We therefore measured a flux of \(1.3 \pm 0.2\) pulse per micro-second.

Distribution mode#

From what was explained before, it is clear that above histogram could have been obtained in one step (i.e. without data analysis function) using the TriggerCountDistribution class.

Not only does it spare us from doing any post-analysis of the raw data (the histogram binning is happening on the instrument side), but also – and more importantly – there will be more detection events allowed since each bin can contain the information of more than one detection event, meaning that the acquisition can be iterated much longer: let’s do it for 10 million iterations.

[40]:

from qblox_scheduler import DType, Schedule, TriggerCountDistribution

REPS: int = 10_000_000  # maximum number of bins usable on instrument memory

schedule: Schedule = Schedule("trigger_count_acquisition_tutorial")

with schedule.loop(arange(0, REPS, 1, dtype=DType.NUMBER)) as rep:
    schedule.add(
        TriggerCountDistribution(
            duration=ACQ_DURATION,
            port="qrm:in1",
            clock="cl0.baseband",
            acq_label="occurrence",
        )
    )
xr_data_distr: xarray.Dataset = hardware_agent.run(schedule)

[41]:

import xarray as xr

xr_data_distr = xr.open_dataset(
    "./utils/data/simulated_10M_trigger_count_distr.hdf5", engine="h5netcdf"
)

[42]:

fig, ax = plt.subplots()

avg = np.average(xr_data_distr["counts_occurrence"], weights=xr_data_distr["occurrence"]).item()
std = np.sqrt(
    np.average((xr_data_distr["counts_occurrence"] - avg) ** 2, weights=xr_data_distr["occurrence"])
).item()

x = np.linspace(0, 40, 100)
y = np.exp(-0.5 * ((x - avg) / std) ** 2) * REPS / (std * np.sqrt(2 * np.pi))

ax.plot(x, y, color="tab:red", ls="dashed", lw=2, label="Gaussian fit")
xr_data_distr["occurrence"].plot(
    x="counts_occurrence",
    marker="o",
    ls="None",
    color="tab:green",
    ax=ax,
    label="Distribution data points",
)


ax.legend()
ax.set_xlabel("Counts")
ax.set_ylabel("Occurrences")
ax.set_title(f"Histogram of Trigger Counts over {REPS} repetitions")
ax.text(30, 40000, f"Mean: {avg:.2f}\nStd: {std:.2f}")

[42]:

Text(30, 40000, 'Mean: 19.46\nStd: 3.71')

../../../../_images/products_qblox_scheduler_tutorials_any_acquisitions_76_1.png

Thresholded trigger count acquisition#

Generalities#

The thresholded trigger count protocol combines the functionality of the trigger count acquisition with a final comparison step. It first counts the rising edges of an input signal over a duration and then compares this total count to a specified integer threshold. The threshold comparison result (False (0), or True (1)) can be retrieved directly, and can also be used to conditionally execute other instructions. For the latter, you would use the ConditionalOperation.

We propose here to keep using our source of random pulses for illustrating this acquisition protocol. We still use 15 us long acquisition windows, within which the pulses are counted. As shown in the figure below, if the number of counts is smaller than the threshold, we trigger an event on the cluster internal network, and we count the acquisition as a 1, otherwise no event is triggered and we count it as a 0.

alt

By scanning over the value \(n_{th}\) of the threshold, the probability \(P_1(n_{th})\) of having the acquisition returning 1 should follow the erf error function, corresponding the antiderivative of the gaussian.

Schedule and conditional operation#

The source of pulses is connected to the input 1 of the QRM. An oscilloscope is connected to the output channels of the QRM to check if the conditionally triggered operation are correctly executed. We start by writing a simple schedule:

a 1 us long square pulse is played by the QRM: it is used to trigger a single acquisition with the oscilloscope;
we wait 1 us;
the acquisition starts, it lasts 15 us and an event is send on the trigger network (label “click”) if at least 1 count has been detected: regarding the typical number of pulses detected in 15 us (see above), this effectively ensures the emission of an event;
a negative square pulse is played, triggered by the event on the “click” channel;

[43]:

from qblox_scheduler import (
    ConditionalOperation,
    IdlePulse,
    Schedule,
    SquarePulse,
    ThresholdedTriggerCount,
)

schedule: Schedule = Schedule("Conditional operation")
schedule.add(SquarePulse(amplitude=1, duration=1e-6, port="qrm:out", clock="cl0.baseband"))
schedule.add(IdlePulse(duration=1e-6))
schedule.add(
    ThresholdedTriggerCount(
        port="qrm:in1",
        clock="cl0.baseband",
        duration=15e-6,
        threshold=1,  # very small threshold to ensure a trigger
        feedback_trigger_label="click",  # label of the trigger to be used in the ConditionalOperation
    )
)
schedule.add(
    ConditionalOperation(
        body=SquarePulse(amplitude=-1, duration=1e-6, port="qrm:out", clock="cl0.baseband"),
        feedback_trigger_label="click",
    ),
)
schedule.add(IdlePulse(4e-9))

[43]:

{'name': 'c65f6423-07ff-4af0-ad3c-087a1d657319', 'operation_id': '-5541197746935506874', 'timing_constraints': [TimingConstraint(ref_schedulable=None, ref_pt=None, ref_pt_new=None, rel_time=0)], 'label': 'c65f6423-07ff-4af0-ad3c-087a1d657319'}

[44]:

import numpy as np
from matplotlib import pyplot as plt

scope_data = np.genfromtxt(
    "./utils/data/conditional_playback_wf.csv",
    delimiter=",",
    skip_header=12,
)


fig, ax = plt.subplots(figsize=(12, 4))

arr_time, arr_trace = scope_data[:, 0], scope_data[:, 1]

ax.axvspan(1, 2, color="pink", alpha=0.5)
ax.axvspan(2, 17, color="tab:green", alpha=0.2)
ax.text(9.5, 0.25, "Acquisition", fontsize=12, ha="center", color="green")
ax.plot(arr_time * 1e6, arr_trace)

ax.set_xlabel("Time (us)")
ax.set_ylabel("Amplitude (V)")
ax.set_title("Acquired trace after conditional operation triggered")
ax.grid()

plt.tight_layout()
plt.savefig("./utils/images/conditional_playback_trace.png", dpi=300)
plt.close(fig)

Let’s plot the trace acquired by the scope is indeed showing two pulses of opposite polarities, and check that the duration between both pulses is indeed the expected one:

cond_playback

[45]:

threshold: float = 0.5
above_threshold: np.ndarray = arr_trace > threshold
below_threshold: np.ndarray = arr_trace < -threshold
first_pulse_timestamp: int = np.where(above_threshold)[0][0]
second_pulse_timestamp: int = np.where(below_threshold)[0][0]
delta_t: int = arr_time[second_pulse_timestamp] - arr_time[first_pulse_timestamp]
print(f"Delay time between pulses: {delta_t * 1e6:.1f} us")

Delay time between pulses: 17.0 us

Let’s now proceed to complete the experiment, where the threshold value is scanned, and for each value of the threshold we perform 100_000 iteration of the ThresholdedTriggerCount acquisition.

[46]:

from qblox_scheduler import (
    ConditionalOperation,
    IdlePulse,
    Schedule,
    SquarePulse,
    ThresholdedTriggerCount,
    TriggerCondition,
)

datasets: list[xarray.Dataset] = []
for threshold in range(40):
    schedule: Schedule = Schedule("Conditional operation")

    schedule.add(SquarePulse(amplitude=1, duration=1e-6, port="qrm:out", clock="cl0.baseband"))
    schedule.add(IdlePulse(duration=1e-6))

    with schedule.loop(arange(0, 100_000, 1, dtype=DType.NUMBER)) as rep:
        schedule.add(
            ThresholdedTriggerCount(
                port="qrm:in1",
                clock="cl0.baseband",
                duration=15e-6,
                threshold=threshold,
                feedback_trigger_label="click",
                acq_label="thresholded_count",
                feedback_trigger_condition=TriggerCondition.LESS_THAN,
            )
        )
        schedule.add(
            ConditionalOperation(
                body=SquarePulse(amplitude=-1, duration=1e-6, port="qrm:out", clock="cl0.baseband"),
                feedback_trigger_label="click",
            ),
        )
        schedule.add(IdlePulse(4e-9))

    datasets.append(hardware_agent.run(schedule))

[47]:

import pickle as pkl
from pathlib import Path

source_file = Path("./utils/data/datasets.pkl")
with source_file.open("rb") as f:
    datasets = pkl.load(f)

[48]:

cumulative_probability: list[float] = []
for dataset in datasets:
    cumulative_probability.append(dataset.thresholded_count.sum().item() / 100_000)

fig, ax = plt.subplots(figsize=(10, 5))
ax.plot(range(40), cumulative_probability, marker="o")
ax.set_xlabel("Threshold")
ax.set_ylabel("Probability")
ax.set_title("Cumulative probability to detect a trigger vs threshold")
ax.grid()

../../../../_images/products_qblox_scheduler_tutorials_any_acquisitions_86_0.png

Acquisitions#

Introduction#

Initial setup#

Pulse-level acquisitions#

Trace acquisition#

Setting up the schedule#

Compile and run the schedule, retrieving acquisition#

IQ integration acquisition#

Setting up the schedule#

Running the schedule, retrieving acquisition#

Acquisition coordinates#

General concept#

Connecting `coords` with sweeps#

Reshaping the data#

Averaging during the acquisitions#

Weighted IQ integration acquisition#

Thresholded acquisition#

Setting up the schedule#

Thresholded acquisition using ‘ThresholdedIQIntegration’#

Trigger count acquisition#

Setting up the schedule#

First check: scope acquisition#

Appending the counts#

Distribution mode#

Thresholded trigger count acquisition#

Generalities#

Schedule and conditional operation#

Acquisitions#

Introduction#

Initial setup#

Pulse-level acquisitions#

Trace acquisition#

Setting up the schedule#

Compile and run the schedule, retrieving acquisition#

IQ integration acquisition#

Setting up the schedule#

Running the schedule, retrieving acquisition#

Acquisition coordinates#

General concept#

Connecting coords with sweeps#

Reshaping the data#

Averaging during the acquisitions#

Weighted IQ integration acquisition#

Thresholded acquisition#

Setting up the schedule#

Thresholded acquisition using ‘ThresholdedIQIntegration’#

Trigger count acquisition#

Setting up the schedule#

First check: scope acquisition#

Appending the counts#

Distribution mode#

Thresholded trigger count acquisition#

Generalities#

Schedule and conditional operation#

Connecting `coords` with sweeps#