Quantum Instrumentation Control Kit (QICK)

The Quantum Instrumentation Control Kit (QICK) is an AMD RFSoC-based qubit controller designed for the direct synthesis of control and readout pulses in quantum computing experiments. It is a vertically integrated system consisting of:

• Hardware: AMD RFSoC boards (ZCU111, ZCU216, or RFSoC4x2) often with custom analog front-ends.
• Firmware: Custom FPGA logic including the tProcessor, DDS generators, and readout systems.
• Software: A Python library used for pulse programming, data acquisition, and real-time feedback.

All components (schematics, firmware, and software) are open-source.

The Signal Generator v6 (SG-v6) is the latest QICK on-chip waveform engine. It is designed to replace SG-v5, offering a richer feature set and lower latency while maintaining full compatibility with QICK-compatible boards like ZCU216 and ZCU111.

In Python, the SG-v6 is accessed via the qick.drivers.generator class. It functions by combining a dual-port memory (BRAM) for envelope samples, a FIFO for 160-bit waveform descriptors, and a central signal generation block that drives N parallel DDS channels.

The axis_kidsim_v3 is a per-lane RF resonator simulator used to test KID (Kinetic Inductance Detector) or qubit readout firmware and software. It allows for testing against a physically-realistic resonator response without requiring a real cryostat.

How it works: Each lane demodulates its input with a DDS (Direct Digital Synthesis) carrier, applies a 1-pole/1-zero IIR filter at baseband (simulating the resonator response), and then remodulates the signal back to RF.

Key characteristics:

• It is not a readout itself, but a simulator for the resonator.
• It wraps L parallel lanes (default L=8) behind a single AXI4-Lite register block.
• Each lane processes one 32-bit {Q, I} sub-word of the packed AXI-Stream input.
• It is exposed in Python via the AxisKidsimV3 class.

QICK programs can perform arithmetic and memory management directly on the hardware via tProc. Capabilities include:

• Memory Access: Writing data to and reading data from tProc memory addresses, which are accessible by tProc registers.
• Arithmetic Operations: Addition, subtraction, multiplication, and bit shifting.

For a basic implementation, refer to 04_Reading_Math_Writing.ipynb.

The axis_kidsim_v3 emulator simulates a single-mode resonator in a notch/hanger geometry (reflection measurement). It works by demodulating an incoming stream with a DDS carrier, filtering the complex baseband with a first-order (1-pole/1-zero) IIR, and then remodulating back to RF.

Core Logic:

• Demodulation: Multiplies input by $e^{-j ext{phase}}$ using a DDS carrier.
• Filtering: An IIR (iir_1p1z) runs on the demodulated baseband signal. The pole ($C_1$) sets the linewidth, the zero ($C_0$) sets the coupling, and the gain ($G$) sets the scale.
• Remodulation: Shifts the passband back up to the carrier frequency $f_c$.

Key takeaway: The resonant frequency is determined by the carrier (DDS_FREQ_REG), not the IIR pole. The IIR pole sets the linewidth/decay characteristics.

Instead of using a slow Python loop to iterate over multiple QICK programs, you can use the update function to modify parameters (such as pulse gain) within a single QICK program. This allows for high-speed parameter sweeping directly on the hardware.

For a basic implementation, refer to 02_Sweeping_variables.ipynb.

QICK provides two primary readout modes that differ in what they return and how they process data:

• Accumulated (acquire): Use this mode when you need the full accumulated signal.
• Decimated (acquire_decimated): Use this mode for decimated readout.

Both modes share a common setup process. Consult the readout_modes documentation to determine which mode is appropriate for your specific measurement requirements.