Calibration of TWPA¶

In this section we show how to run an experiment aimed at calibrating the parameters of an amplifier, which in most cases is going to be a TWPA.

In this experiment the pulse sequence consists in just a single readout pulse for each qubit. We sweep the readout frequency and we acquire the signal. Firstly we acquire the signal when the ampifier is off, then we repeat the same measurement by changing the frequency and the power of the pump.

We then evaluate the gain for each frequency and power of the pump as [29]

\[G(f, p) = 10 \log_{10} \Bigg( \frac{S_{on}(f, p)}{S_{off}} \Bigg)\]

where \(S_{on}(f,p)\) is the signal acquired with the amplifier on and \(S_{off}\) the signal acquired with the amplifier off. The signal is defined as \(S\) as the average magnitude of the signal for each readout frequency value.

The best point is then selected as the one with the maximum gain. Given that different qubits often share the same amplifier, it could non trivial to select the best point.

Parameters¶

class qibocal.protocols.twpa.twpa.TwpaCalibrationParameters(freq_width: float, freq_step: float, twpa_freq_width: int, twpa_freq_step: int, twpa_pow_width: int, twpa_pow_step: int, nshots: int | None = None, relaxation_time: int | None = None)[source]

TwpaCalibration runcard inputs.

freq_width: float: Width for frequency sweep of readout pulse (Hz).

freq_step: float: Frequency step for sweep of readout pulse (Hz).

twpa_freq_width: int: Width for TPWA frequency sweep (Hz).

twpa_freq_step: int: TPWA frequency step (Hz).

twpa_pow_width: int: Width for TPWA power sweep (dBm).

twpa_pow_step: int: TPWA power step (dBm).

nshots: int | None = None: Number of shots.

relaxation_time: int | None = None: Relaxation time (ns).

Example¶

A possible runcard to launch a TWPA calibration experiment could be the following:

- id: twpa_calibration
  operation: twpa_calibration
  parameters:
    freq_step: 10000000
    freq_width: 50000000
    nshots: 300
    twpa_freq_step: 50000000
    twpa_freq_width: 300000000
    twpa_pow_step: 0.5
    twpa_pow_width: 5

The expected output is the following:

TWPA Sweeper Protocol¶

For instruments supporting hardware sweepers, the twpa_frequency_offset protocol (aliased as twpa_sweep) sweeps the TWPA pump frequency and amplitude (offset) concurrently using an on-board 2D hardware sweep. Because hardware sweepers enforce linear steps, the amplitude/power sweep is replaced by a linear offset sweep. Offset values must lie in the inclusive interval [-1, 1].

Before sweeping the pump parameters, a reference scan measures the readout signal with the TWPA pump off (its power set to zero). The reference uses the same probe frequencies, pulse duration, amplitude, and acquisition settings as the subsequent pump sweep: one reference measurement per target at its calibrated readout frequency by default, or one per target for each frequency listed in probes. The acquired I/Q magnitudes are averaged over the evaluated probe frequencies, separately for the reference and for each pump working point. The gain displayed in the heatmap is then

\[G(f, o) = 20 \log_{10} \left( \frac{\langle |IQ_{\mathrm{on}}(f, o)| \rangle_{\mathrm{probes}}} {\langle |IQ_{\mathrm{off}}| \rangle_{\mathrm{probes}}} \right),\]

where \(f\) and \(o\) are the pump frequency and offset. This reference normalizes the amplified signal to the unamplified readout signal.

By default, when the probes parameter is omitted, the protocol performs only a single acquisition run (a single execution for the reference scan, and a further individual one for the 2D pump sweep). In this run, each target qubit is updated and interrogated exclusively at its own calibrated readout resonator frequency, rather than scanning across the readout frequencies of the other targets. This provides a fast, multiplexed characterization at the operational frequencies of all selected targets.

When a discrete list of probe frequencies is provided in probes, the protocol instead evaluates each probe frequency in a loop, applying each frequency across all target probe lines and averaging the resulting gain over the evaluated probes to find the pump parameters that maximize average gain. Gain computation raises an error if a target’s mean TWPA-off reference magnitude is non-finite or close to zero, since it cannot provide a reliable normalization.

Note

When defined, the probe frequencies are specified as a discrete list (probes) rather than a swept range, and evaluated via a software loop. The reason not to sweep the probe frequency continuously is that the TWPA gain oscillates rapidly with the probe frequency. Instead of obtaining the best gain on average across an arbitrary continuous range, the calibration is targeted specifically at the frequencies of the expected readout resonators. Because not all control electronics support sweeping an arbitrary non-equispaced list of values on-board, this is implemented as a loop over the probe frequencies, while the primary speed-up is achieved via the 2D hardware sweep over the pump signal parameters (amplitude and frequency).

Parameters¶

class qibocal.protocols.twpa.frequency_offset.TwpaFrequencyOffsetParameters(amplitude: tuple[float, float, float] | tuple[Literal['linspace'], float, float, int] | tuple[Literal['window'], float, float, float] | tuple[Literal['linwindow'], float, float, int] | tuple[Literal['center'], float, float] | tuple[Literal['lincenter'], float, int] | tuple[Literal['asym'], tuple[float, float], float] | tuple[Literal['linasym'], tuple[float, float], int], frequency: tuple[float, float, float] | tuple[Literal['linspace'], float, float, int] | tuple[Literal['window'], float, float, float] | tuple[Literal['linwindow'], float, float, int] | tuple[Literal['center'], float, float] | tuple[Literal['lincenter'], float, int] | tuple[Literal['asym'], tuple[float, float], float] | tuple[Literal['linasym'], tuple[float, float], int], probes: list[float] | None = None, probe_duration: float = 4000.0, probe_amplitude: float = 1.0)[source]

amplitude: tuple[float, float, float] | tuple[Literal['linspace'], float, float, int] | tuple[Literal['window'], float, float, float] | tuple[Literal['linwindow'], float, float, int] | tuple[Literal['center'], float, float] | tuple[Literal['lincenter'], float, int] | tuple[Literal['asym'], tuple[float, float], float] | tuple[Literal['linasym'], tuple[float, float], int]: Range of amplitude (offset) values for TWPA sweep.

frequency: tuple[float, float, float] | tuple[Literal['linspace'], float, float, int] | tuple[Literal['window'], float, float, float] | tuple[Literal['linwindow'], float, float, int] | tuple[Literal['center'], float, float] | tuple[Literal['lincenter'], float, int] | tuple[Literal['asym'], tuple[float, float], float] | tuple[Literal['linasym'], tuple[float, float], int]: Range of TWPA frequency values for sweep.

probes: list[float] | None = None

List of probe frequencies to evaluate (Hz).

If omitted, a single acquisition run is performed where each target is probed exclusively at its own calibrated readout frequency.

probe_duration: float = 4000.0: Probe wave duration.

probe_amplitude: float = 1.0: Probe wave amplitude.

nshots: int: Number of executions on hardware.

relaxation_time: float: Wait time for the qubit to decohere back to the ground state.

Example¶

- id: twpa_frequency_offset
  operation: twpa_frequency_offset
  parameters:
    probes: [7000000000, 7200000000]
    frequency: ["center", 300000000, 50000000]
    amplitude: [0.1, 0.5, 0.05]
    nshots: 300