Source code for qibocal.protocols.qubit_spectroscopy_ef

from dataclasses import asdict, dataclass, field

import numpy as np
from qibolab import Delay, Parameter, PulseSequence, Sweeper

from qibocal.auto.operation import QubitId, Routine
from qibocal.calibration import CalibrationPlatform
from qibocal.update import replace

from .. import update
from ..result import magnitude, phase
from .qubit_spectroscopy import (
    QubitSpectroscopyData,
    QubitSpectroscopyParameters,
    QubitSpectroscopyResults,
    _fit,
)
from .resonator_spectroscopy import ResSpecType
from .utils import readout_frequency, spectroscopy_plot, table_dict, table_html


[docs]@dataclass class QubitSpectroscopyEFParameters(QubitSpectroscopyParameters): """QubitSpectroscopyEF runcard inputs."""
[docs]@dataclass class QubitSpectroscopyEFResults(QubitSpectroscopyResults): """QubitSpectroscopyEF outputs.""" anharmonicity: dict[QubitId, float] = field(default_factory=dict)
[docs]@dataclass class QubitSpectroscopyEFData(QubitSpectroscopyData): """QubitSpectroscopy acquisition outputs.""" drive_frequencies: dict[QubitId, float] = field(default_factory=dict)
[docs]def fit_ef(data: QubitSpectroscopyEFData) -> QubitSpectroscopyEFResults: results = _fit(data) anharmoncities = { qubit: results.frequency[qubit] - data.drive_frequencies[qubit] for qubit in data.qubits if qubit in results } params = asdict(results) return QubitSpectroscopyEFResults(anharmonicity=anharmoncities, **params)
[docs]def _acquisition( params: QubitSpectroscopyEFParameters, platform: CalibrationPlatform, targets: list[QubitId], ) -> QubitSpectroscopyEFData: """Data acquisition for qubit spectroscopy ef protocol. Similar to a qubit spectroscopy with the difference that the qubit is first excited to the state 1. This protocols aims at finding the transition frequency between state 1 and the state 2. The anharmonicity is also computed. If the RX12 frequency is not present in the runcard the sweep is performed around the qubit drive frequency shifted by DEFAULT_ANHARMONICITY, an hardcoded parameter editable in this file. """ # create a sequence of pulses for the experiment: # long drive probing pulse - MZ # taking advantage of multiplexing, apply the same set of gates to all qubits in parallel sequence = PulseSequence() ro_pulses = {} amplitudes = {} sweepers = [] drive_frequencies = {} delta_frequency_range = np.arange( -params.freq_width, params.freq_width, params.freq_step ) for qubit in targets: natives = platform.natives.single_qubit[qubit] qd_channel, qd_pulse = natives.RX()[0] qd12_channel, qd12_pulse = natives.RX12()[0] ro_channel, ro_pulse = natives.MZ()[0] qd12_pulse = replace(qd12_pulse, duration=params.drive_duration) if params.drive_amplitude is not None: qd12_pulse = replace(qd12_pulse, amplitude=params.drive_amplitude) amplitudes[qubit] = qd12_pulse.amplitude ro_pulses[qubit] = ro_pulse sequence.append((qd_channel, qd_pulse)) sequence.append((qd12_channel, Delay(duration=qd_pulse.duration))) sequence.append((qd12_channel, qd12_pulse)) sequence.append( (ro_channel, Delay(duration=qd_pulse.duration + qd12_pulse.duration)) ) sequence.append((ro_channel, ro_pulse)) drive_frequencies[qubit] = platform.calibration.single_qubits[ qubit ].qubit.frequency_01 sweepers.append( Sweeper( parameter=Parameter.frequency, values=platform.config(qd12_channel).frequency + delta_frequency_range, channels=[qd12_channel], ) ) data = QubitSpectroscopyEFData( resonator_type=platform.resonator_type, amplitudes=amplitudes, drive_frequencies=drive_frequencies, ) results = platform.execute( [sequence], [sweepers], updates=[ { platform.qubits[q].probe: { "frequency": readout_frequency(q, platform, state=1) } } for q in targets ], **params.execution_parameters, ) # retrieve the results for every qubit for qubit, ro_pulse in ro_pulses.items(): result = results[ro_pulse.id] f0 = platform.config(platform.qubits[qubit].drive_qudits[1, 2]).frequency signal = magnitude(result) _phase = phase(result) if len(signal.shape) > 1: error_signal = np.std(signal, axis=0, ddof=1) / np.sqrt(signal.shape[0]) signal = np.mean(signal, axis=0) error_phase = np.std(_phase, axis=0, ddof=1) / np.sqrt(_phase.shape[0]) _phase = np.mean(_phase, axis=0) else: error_signal, error_phase = None, None data.register_qubit( ResSpecType, (qubit), dict( signal=signal, phase=_phase, freq=delta_frequency_range + f0, error_signal=error_signal, error_phase=error_phase, ), ) return data
[docs]def _plot( data: QubitSpectroscopyEFData, target: QubitId, fit: QubitSpectroscopyEFResults ): """Plotting function for QubitSpectroscopy.""" figures, report = spectroscopy_plot(data, target, fit) show_error_bars = not np.isnan(data[target].error_signal).any() if fit is not None: if show_error_bars: report = table_html( table_dict( target, [ "Frequency 1->2 [Hz]", "Amplitude [a.u.]", "Anharmonicity [Hz]", "Chi2", ], [ (fit.frequency[target], fit.error_fit_pars[target][1]), (fit.amplitude[target], fit.error_fit_pars[target][0]), (fit.anharmonicity[target], fit.error_fit_pars[target][2]), fit.chi2_reduced[target], ], display_error=True, ) ) else: report = table_html( table_dict( target, [ "Frequency 1->2 [Hz]", "Amplitude [a.u.]", "Anharmonicity [Hz]", ], [ fit.frequency[target], fit.amplitude[target], fit.anharmonicity[target], ], display_error=False, ) ) return figures, report
[docs]def _update( results: QubitSpectroscopyEFResults, platform: CalibrationPlatform, target: QubitId ): """Update w12 frequency""" update.frequency_12_transition(results.frequency[target], platform, target) platform.calibration.single_qubits[target].qubit.frequency_12 = results.frequency[ target ]
qubit_spectroscopy_ef = Routine(_acquisition, fit_ef, _plot, _update) """QubitSpectroscopyEF Routine object."""