06a : PSB Readout#

Tutorial Objective#

The objective of this tutorial is to demonstrate how to perform the Pauli Spin Blockade (PSB) readout on a double quantum dot system. For further information on this readout method, see Barthel.2009.

Imports

[1]:

from __future__ import annotations

import rich  # noqa:F401
from dependencies.psb import OperatingPoints, PsbEdge

from qblox_scheduler import (
    HardwareAgent,
    Schedule,
)
from qblox_scheduler.operations import (
    Measure,
    PulseCompensation,
    RampPulse,
    SquarePulse,
)

Hardware/Device Configuration Files#

We use JSON files in order to set the configurations for different parts of the whole system.

Using the information specified in these files, we set the hardware and device configurations which determines the connectivity of our system.

[2]:

hw_config_path = "dependencies/configs/tuning_spin_coupled_pair_hardware_config.json"
device_path = "dependencies/configs/spin_with_psb_device_config_2q.yaml"

Experimental Setup#

To run the tutorial, you will need a quantum device consists of a double quantum dot array (q0 and q1), with a charge sensor (cs0) connected to reflectometry readout. The DC voltages of the quantum device also need to be properly tuned. For example, reservoir gates need to be ramped up for the accumulation devices. The charge sensor can be a quantum dot, quantum point contact (QPC), or single electron transistor (SET).

The HardwareAgent() is the main object for Qblox experiments. It provides an interface to define the quantum device, set up hardware connectivity, run experiments, and receive results.

[3]:

hw_agent = HardwareAgent(hw_config_path, device_path)
hw_agent.connect_clusters()

# Device name string should be defined as specified in the hardware configuration file
sensor_0 = hw_agent.quantum_device.get_element("cs0")
qubit_0 = hw_agent.quantum_device.get_element("q0")
qubit_1 = hw_agent.quantum_device.get_element("q1")
hw_opts = hw_agent.hardware_configuration.hardware_options
cluster = hw_agent._clusters["cluster0"].cluster

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

As can be observed from the defined quantum devices and the hardware connectivies of these elements, the relevant modules and connections for this tutorial are:

QCM (Module 2):

\(\text{O}^{1}\): Gate connection line for qubit 0 (q0).
\(\text{O}^{2}\): Gate connection line for qubit 1 (q1).

QRM (Module 4):

\(\text{O}^{1}\) and \(\text{I}^{1}\): Charge sensor (cs0) resonator probe and readout connection.
\(\text{O}^{2}\) : Charge sensor (cs0) plunger gate connection.

PSB Readout#

In order to apply PSB Readout in a concise and readable manner, we implement a custom defined ‘’’Edge’’’ that is configured for this purpose. For details on how to configure such a custom device element or edge, see the Make Your Own Device Elements tutorial.

[4]:

q0_q1 = PsbEdge(qubit_0, qubit_1)

q0_q1.control.parent_voltage = 0.1
q0_q1.control.child_voltage = -0.2
q0_q1.control.barrier_voltage = 0.3

q0_q1.readout.parent_voltage = 0.0
q0_q1.readout.child_voltage = 0.0
q0_q1.readout.barrier_voltage = 0.0

hw_agent.quantum_device.add_edge(q0_q1)

We further introduce two helper functions to be able to move along or hold at certain points of the charge stability diagram:

``ramps`` Creates a schedule that smoothly ramps the voltages from one operating point to another using RampPulse. The duration of the ramp is determined by the RampingTimes submodule of the PSBEdge.
``hold`` Creates a schedule that holds the system at a given operating point for a fixed duration using SquarePulse. This is useful when you want to keep the system stable at a specific bias point (e.g., during readout).

Both functions loop over the parameters defined in the operating points (e.g. control and readout points and both for qubits and barrier gates), fetch the corresponding hardware ports, and then generate the appropriate pulses. This further helps with readability and streamlining of the generated schedules, which are expected to include PSB Readout quite frequently.

[5]:

def ramps(op_start: OperatingPoints, op_end: OperatingPoints) -> Schedule:
    """Generate a schedule to ramp gate voltages between two PSB operating points."""
    parent = op_start.parent
    port_dict = parent.port_dict
    ramp_time = parent.ramps.to_dict()[f"{op_start.name}_to_{op_end.name}"]

    ops = op_start.to_dict()
    ope = op_end.to_dict()

    sched = Schedule("")
    ref_op = None
    for key in op_start.parameters:
        amplitude = ope[key] - ops[key]
        offset = ops[key]
        ref_op = sched.add(
            RampPulse(amp=amplitude, offset=offset, duration=ramp_time, port=port_dict[key]),
            ref_pt="start",
            ref_op=ref_op,
        )
    return sched


def hold(op_point: OperatingPoints, duration: float) -> Schedule:
    """Generate a schedule to hold gate voltages at a given PSB operating point."""
    parent = op_point.parent
    port_dict = parent.port_dict

    sched = Schedule("")
    ref_op = None
    for key in op_point.parameters:
        ref_op = sched.add(
            SquarePulse(amp=op_point.to_dict()[key], duration=duration, port=port_dict[key]),
            ref_pt="start",
            ref_op=ref_op,
        )
    return sched