Single NV Center Full Tuneup Notebook#

The control solution for Color Centers#

In this application example, we expand on the Pulsed ODMR application example, using our Qblox Scheduler software package for color center characterization.

Color centers are unique defects in solid state where the quantum state can be read out via an optically active transition. Well known examples are the nitrogen-vacancy (NV) centers and tin-vacancy (SnV) centers in diamond or silicon carbide. The coupling of the quantum state to a photon make color centers extremely suitable for quantum networks where quantum computing nodes are entangled over large distances.

QBLOX Cluster#

Qblox hardware integrates all control signals, photon counting and time tagging in a single quantum controller. The integrated framework takes care of synchronization of the experiment and low-latency conditional feedback operations; setting up a complete experiment has never been so seamless.

The figure below illustrates the role of individual modules of the Qblox’ portfolio in such color center experiments.

Qubit Control Module (QCM) can be used to control the acousto-optic modulator (AOM) for the laser beam.
Qubit Control Module - RF (QCM-RF II) controls the qubit state, driving th 0-1 transition.
Qubit Timetag Module (QTM) connects to photodetectors for counting and time-tagging fluorescent photons. ***

Experimental flow#

The first step in bringing up a quantum chip is to characterize a single qubit. The details of the characterization depend on the specific type of color center but it always involves a set of experiments run sequentially. Each step is upstreamed by the results of the previous one. The workflow for tuning a color center is illustrated below:

In this diagram, arrows indicate dependencies, showing that experiments are typically conducted from left to right.

Qubit spectroscopy in color centers is performed through Optically Detected Magnetic Resonance (ODMR);

Sweeping the microwave drive frequency using the QCM-RF II reveals the \(|0\rangle\)-\(|1\rangle\) qubit transition frequency through the intensity of the scattered fluorescence light.
Spin-photon conversion for photonic readout is realized by coupling the \(\left| 0 \right\rangle\) state to the \({}^3E\) excited manifold, also involved in a radiative transition cycle.
Counting/timetagging of the fluorescence photons is handled by the QTM connected to a photodector.

Specifically for Nitrogen-Vacancy (NV) centers, the optical transition does not require perfect resonance of the the laser. The system is excited into the excited state with a spin preserving transition (often referred to as “green” laser). The spin dependent decay paths result in a bright and dark response:

The \(|0\rangle\) state is the bright state, producing, in typical single NV centers in bulk diamond or nanodiamonds, 20 to 100 kcounts per second under standard confocal microscopy.
The \(|1\rangle\) state is the dark state, resulting in a reduced fluorescence rate, with the contrast typically being 20% to 30%.

Imports#

Runtime components imports#

[1]:

from __future__ import annotations  # noqa: I001
from typing import Any

from qblox_scheduler import HardwareAgent, Schedule, ClockResource, BasicElectronicNVElement

from qblox_scheduler.enums import BinMode

from qblox_scheduler.operations.expressions import DType
from qblox_scheduler.operations.loop_domains import linspace, arange
from qblox_scheduler.operations import (
    Measure,
    SetClockFrequency,
    SquarePulse,
    VoltageOffset,
    TriggerCount,
    IdlePulse,
    MarkerPulse,
    LoopStrategy,
)

import json

/.venv/lib/python3.14/site-packages/quantify_core/utilities/general.py:13: QCoDeSDeprecationWarning: The `qcodes.utils.helpers` module is deprecated. Please consult the api documentation at https://microsoft.github.io/Qcodes/api/index.html for alternatives.
  from qcodes.utils.helpers import NumpyJSONEncoder

Initializing the HardwareAgent#

Here we instantiate the HardwareAgent class using hardware (i.e. Qblox Cluster) and quantum device (i.e. qubits) parameters - see start-up guide for NV centers and Qblox Scheduler Hello World for further details.

In short, the Hardware Configuration file contains the information specific to Qblox hardware, while the Device Configuration file (QuantumDevice) contains device elements (BasicElectronicNVElement), where we save the various qubit parameters. Here we are loading a template for 1 qubit.

[2]:

## Set to True if not using real cluster
using_dummy: bool = True

## Set to True if using QTM for counting photons, if using QRM set to False
using_qtm: bool = True

# Device Config
device_path = "dependencies/configs/nv_center1q.yaml"

# Hardware config — single base file, patched per setup
with open("dependencies/configs/nv_center_hw.json") as f:
    hw_config: dict[str, Any] = json.load(f)

match (using_dummy, using_qtm):
    case (True, _):
        pass  # Base config is ready for dummy use

    case (False, True):
        hw_config["hardware_description"]["cluster0"]["ip"] = "10.10.200.42"
        del hw_config["hardware_description"]["cluster0"]["modules"]
        # Adjust QTM input to match physical wiring
        hw_config["connectivity"]["graph"] = [
            ["cluster0.module10.digital_input_5", "qe0:optical_readout"]
            if edge[1] == "qe0:optical_readout"
            else edge
            for edge in hw_config["connectivity"]["graph"]
        ]

    case (False, False):
        hw_config["hardware_description"]["cluster0"]["ip"] = "10.10.200.42"
        del hw_config["hardware_description"]["cluster0"]["modules"]
        # QRM handles optical readout instead of QTM
        hw_config["connectivity"]["graph"] = [
            ["cluster0.module4.real_input_0", "qe0:optical_readout"]
            if edge[1] == "qe0:optical_readout"
            else edge
            for edge in hw_config["connectivity"]["graph"]
        ]
        hw_config["hardware_options"]["sequencer_options"] = {
            "qe0:optical_readout-qe0.ge0": {"ttl_acq_threshold": 0.5}
        }
        hw_config["hardware_options"]["digitization_thresholds"] = {
            "qtm0:in-digital": {"analog_threshold": 0.8},
            "qtm1:in-digital": {"analog_threshold": 0.8},
        }

[3]:

# Create a new hardware agent based on the configuration files discussed above
hw_agent: HardwareAgent = HardwareAgent(
    hardware_configuration=hw_config, quantum_device_configuration=device_path
)

hw_agent.connect_clusters()

# Create an alias for a specific element of the DUT to conveniently interact with its properties
qubit: BasicElectronicNVElement = hw_agent.quantum_device.get_element("qe0")

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

Continuous Wave ODMR#

A Continuous Wave (CW) Optically Detected Magnetic Resonance (ODMR) experiment is performed to determine roughly the \(|0\rangle\)-\(|1\rangle\) qubit transition frequency. With that technique, the resolution is limited by the linewidth of the laser in use. With typical setups, it is not possible to distinguish the hyperfine splitting. The CW ODMR schedule continuously stimulates the optical transition for readout, while at the same time sweeping the microwave drive frequency. The continuous stimulation of the optical transition results in higher photon counts, making it a good experiment to start with and verify the proper tuning of the confocal optical setup. It also eliminates dependencies on the timing of the laser with respect to the acquisition window (the laser is not pulsed) and – in case of direct laser control – the laser stability.

The CW ODMR schedule consists for following steps:

Laser activation
- The laser beam is turned on continuously for the entire duration of the experiment. This is done by setting a VoltageOffset to the optical control port with clock ge0.
- This serves the purpose of both qubit ground state initialization as well as readout.
Microwave Frequency Sweep
- The microwave signal frequency is set using SetClockFrequency at the qubit’s microwave port.
- A SquarePulse applies the microwave tone, sweeping through frequencies to probe the \(|0\rangle\)-\(|1\rangle\) transition.
Readout
- Since the laser beam is always turned on, we only need to accumulate the photon counts via a TriggerCount operation, which is done at the same time as when the microwave pulse is played.
- We accumulate photon counts over many repetitions, grouping results as per the specified acquisition coordinates (frequency), across multiple repetitions.

Parametrization of the schedule#

Generate a range of frequencies with the defined steps, for the CW ODMR spectroscopy.

[4]:

# Number of repetitions for the whole schedule
repetitions: int = 2

# Frequency settings
frequency_center: float = qubit.clock_freqs.spec  # Hz
frequency_width: float = 20e6  # Hz
frequency_npoints: int = 4

## In this schedule, we want to mix some pulse-level and gate-level operations.
## For this, we fetch the qubit parameters from the central data structure containing all the qubit
## information, the Device Config file, initialized as `qubit` above.

# Define control parameters for the laser beam used for readout
clock_laser: str = f"{qubit.name}.ge0"
port_laser: str = qubit.ports.optical_control
amp_laser: float = qubit.measure.pulse_amplitude
duration_laser: float = qubit.measure.pulse_duration

# Acquisition parameters
clock_meas: str = f"{qubit.name}.ge0"
port_meas: str = qubit.ports.optical_readout
duration_meas: float = qubit.measure.acq_duration

#  Microwave drive pulse parameters
clock_drive: str = f"{qubit.name}.spec"
port_drive: str = f"{qubit.name}:mw"
amp_drive: float = qubit.rxy.amp180
duration_drive: float = (
    duration_meas  # We keep the microwave pulse on for as long as we count the photonss
)

[5]:

# creation of the LinearDomain objects used in the Schedule loops
reps_loop = arange(repetitions, dtype=DType.NUMBER)
freqs_loop = linspace(
    start=frequency_center - frequency_width / 2,
    stop=frequency_center + frequency_width / 2,
    num=frequency_npoints,
    dtype=DType.FREQUENCY,
)

[6]:

# Initialize the schedule with the specified number of repetitions
sched: Schedule = Schedule("CW ODMR")

## Turn on the laser beam for the entire experiment duration.
sched.add(
    VoltageOffset(
        offset_path_I=amp_laser,
        offset_path_Q=amp_laser,
        port=port_laser,
        clock=clock_laser,
    )
)

## Creating a sweep for repetitions and to scan frequency
with (
    sched.loop(reps_loop),
    sched.loop(freqs_loop) as freq,
):
    ## Microwave drive pulse

    ### Sweeping through the 0-1 transition frequencies
    sched.add(SetClockFrequency(clock=clock_drive, clock_freq_new=freq))

    ## Choose Square or Hermite Pulse for driving
    drive_pulse = sched.add(
        SquarePulse(amp=amp_drive, duration=duration_meas, port=port_drive, clock=clock_drive)
    )

    # Trigger scope
    sched.add(
        MarkerPulse(duration=duration_meas - 4e-9, port="qe0:marker"),
        ref_op=drive_pulse,
        ref_pt="start",
        rel_time=0,
    )

    # Counting the photons
    sched.add(
        TriggerCount(
            port=port_meas,
            clock=clock_meas,
            duration=duration_meas,
            acq_channel="counts",
            coords={"freq": freq},
            bin_mode=BinMode.AVERAGE_APPEND,
        ),
        rel_time=0,
        ref_op=drive_pulse,
        ref_pt="start",
    )

# Turn off the reaodut laser
sched.add(VoltageOffset(offset_path_I=0.0, offset_path_Q=0.0, port=port_laser, clock=clock_laser))

# `VoltageOffset` requires a Q1ASM upd_param call which has minimum duration 4 ns
sched.add(IdlePulse(duration=4e-9))

# Execute the experiment
cw_odmr_dataset = hw_agent.run(sched)

/tmp/ipykernel_9284/3906357044.py:22: FutureWarning: clock_freq_new is deprecated as an argument to SetClockFrequency and will be removed in qblox-scheduler >= 2.0; use frequency instead.
  sched.add(SetClockFrequency(clock=clock_drive, clock_freq_new=freq))
/tmp/ipykernel_9284/3906357044.py:26: FutureWarning: amp is deprecated as an argument to SquarePulse and will be removed in qblox-scheduler >= 2.0; use amplitude instead.
  SquarePulse(amp=amp_drive, duration=duration_meas, port=port_drive, clock=clock_drive)

Let us observe the dataset

[7]:

cw_odmr_dataset

[8]:

# Compiling the schedule to see the compiled instructions and pulse diagram

comp_sched = hw_agent.compile(sched)

Let us view the compiled Q1ASM instructions

[9]:

# Uncomment to display the compiled Q1ASM instructions and QCoDeS setting for each module

# hw_agent.latest_compiled_schedule.compiled_instructions

Looking at the Pulse Diagram

[10]:

# Uncomment to see the pulse diagram
comp_sched.plot_pulse_diagram(plot_backend="plotly")

[11]:

# Update the transition frequency
# This can be done directly in the device config file (dependencies/configs/nv_center1q) or in the following manner
# qubit.clock_freqs.spec = ## INSERT UPDATED VALUE

Time Domain Measurements#

From this point on we will be using set frequencies, obtained from the preceding experiments, and trying to optimize the performance on manipulating the quantum state. For optimal performance, the mixer in the QCM-RF module should be calibrated. Enabling automated mixer calibration can be done in the hardware config (["hardware_options"]["mixer_corrections"][port-clock combination]["auto_lo_cal"/"auto_sideband_cal"]), as shown in the hardware config file for this experiment. For more details, please see the Qblox Scheduler User Guide - Hardware Config page. For the most optimal performance, the mixer can also be calibrated manually. More information on this can be found in the Manual mixer calibration tutorial.

Single NV Center Full Tuneup Notebook#

The control solution for Color Centers#

QBLOX Cluster#

Experimental flow#

Imports#

Runtime components imports#

Initializing the HardwareAgent#

Continuous Wave ODMR#

Parametrization of the schedule#

Pulsed ODMR Schedule#

Pulsed ODMR versus Power Schedule#

Multiplexed Pulsed ODMR Schedule#

Time Domain Measurements#

Rabi Oscillations - Power and Time#

T1 relaxation time (bit-flip time)#

Ramsey (T2*) experiment#

Hahn Echo (T2) Schedule#