From 3181ff1efc22d598400bf865d9357dd123126025 Mon Sep 17 00:00:00 2001 From: Andrea Date: Thu, 29 Feb 2024 17:26:42 +0400 Subject: [PATCH] refactor: Remove unused protocol --- .../resonator_spectroscopy_attenuation.py | 206 ------------------ 1 file changed, 206 deletions(-) delete mode 100644 src/qibocal/protocols/characterization/resonator_spectroscopy_attenuation.py diff --git a/src/qibocal/protocols/characterization/resonator_spectroscopy_attenuation.py b/src/qibocal/protocols/characterization/resonator_spectroscopy_attenuation.py deleted file mode 100644 index a5580f5fd..000000000 --- a/src/qibocal/protocols/characterization/resonator_spectroscopy_attenuation.py +++ /dev/null @@ -1,206 +0,0 @@ -from dataclasses import dataclass, field -from typing import Optional - -import numpy as np -from qibolab import AcquisitionType, AveragingMode, ExecutionParameters -from qibolab.platform import Platform -from qibolab.pulses import PulseSequence -from qibolab.qubits import QubitId -from qibolab.sweeper import Parameter, Sweeper, SweeperType - -from qibocal import update -from qibocal.auto.operation import Parameters, Results, Routine - -from .resonator_spectroscopy import ResonatorSpectroscopyData, ResSpecType -from .utils import PowerLevel, lorentzian_fit, spectroscopy_plot - - -@dataclass -class ResonatorSpectroscopyAttenuationParameters(Parameters): - """ResonatorSpectroscopy runcard inputs.""" - - freq_width: int - """Width for frequency sweep relative to the readout frequency [Hz].""" - freq_step: int - """Frequency step for sweep [Hz].""" - power_level: PowerLevel - """Power regime (low or high). If low the readout frequency will be updated. - If high both the readout frequency and the bare resonator frequency will be updated.""" - amplitude: Optional[float] = None - """Readout amplitude (optional). If defined, same amplitude will be used in all qubits. - Otherwise the default amplitude defined on the platform runcard will be used""" - attenuation: Optional[int] = None - """Readout attenuation (optional). If defined, same attenuation will be used in all qubits. - Otherwise the default attenuation defined on the platform runcard will be used""" - - def __post_init__(self): - # TODO: ask Alessandro if there is a proper way to pass Enum to class - self.power_level = PowerLevel(self.power_level) - - -@dataclass -class ResonatorSpectroscopyAttenuationResults(Results): - """ResonatorSpectroscopy outputs.""" - - frequency: dict[QubitId, float] - """Readout frequency [GHz] for each qubit.""" - fitted_parameters: dict[QubitId, list[float]] - """Raw fitted parameters.""" - bare_frequency: Optional[dict[QubitId, float]] = field( - default_factory=dict, - ) - """Bare resonator frequency [GHz] for each qubit.""" - amplitude: Optional[dict[QubitId, float]] = field( - default_factory=dict, - ) - """Readout amplitude for each qubit.""" - attenuation: Optional[dict[QubitId, int]] = field( - default_factory=dict, - ) - """Readout attenuation [dB] for each qubit.""" - - -@dataclass -class ResonatorSpectroscopyAttenuationData(ResonatorSpectroscopyData): - """Data structure for resonator spectroscopy with attenuation.""" - - attenuations: dict[QubitId, int] = field(default_factory=dict) - - -def _acquisition( - params: ResonatorSpectroscopyAttenuationParameters, - platform: Platform, - targets: list[QubitId], -) -> ResonatorSpectroscopyAttenuationData: - """Data acquisition for resonator spectroscopy attenuation.""" - # create a sequence of pulses for the experiment: - # MZ - - # taking advantage of multiplexing, apply the same set of gates to all qubits in parallel - sequence = PulseSequence() - ro_pulses = {} - amplitudes = {} - attenuations = {} - - for qubit in targets: - ro_pulses[qubit] = platform.create_qubit_readout_pulse(qubit, start=0) - if params.amplitude is not None: - ro_pulses[qubit].amplitude = params.amplitude - - amplitudes[qubit] = ro_pulses[qubit].amplitude - - if params.attenuation is not None: - platform.qubits[qubit].readout.attenuation = params.attenuation - - attenuations[qubit] = platform.qubits[qubit].readout.attenuation - - sequence.add(ro_pulses[qubit]) - - # define the parameter to sweep and its range: - delta_frequency_range = np.arange( - -params.freq_width // 2, params.freq_width // 2, params.freq_step - ) - sweeper = Sweeper( - Parameter.frequency, - delta_frequency_range, - pulses=[ro_pulses[qubit] for qubit in targets], - type=SweeperType.OFFSET, - ) - data = ResonatorSpectroscopyAttenuationData( - resonator_type=platform.resonator_type, - power_level=params.power_level, - amplitudes=amplitudes, - attenuations=attenuations, - ) - - results = platform.sweep( - sequence, - ExecutionParameters( - nshots=params.nshots, - relaxation_time=params.relaxation_time, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ), - sweeper, - ) - - # retrieve the results for every qubit - for qubit in targets: - result = results[ro_pulses[qubit].serial] - # store the results - data.register_qubit( - ResSpecType, - (qubit), - dict( - signal=result.magnitude, - phase=result.phase, - freq=delta_frequency_range + ro_pulses[qubit].frequency, - ), - ) - # finally, save the remaining data - return data - - -def _fit( - data: ResonatorSpectroscopyAttenuationData, -) -> ResonatorSpectroscopyAttenuationResults: - """Post-processing function for ResonatorSpectroscopy.""" - qubits = data.qubits - bare_frequency = {} - frequency = {} - fitted_parameters = {} - for qubit in qubits: - fit_result = lorentzian_fit( - data[qubit], resonator_type=data.resonator_type, fit="resonator" - ) - if fit_result is not None: - frequency[qubit], fitted_parameters[qubit] = fit_result - if data.power_level is PowerLevel.high: - bare_frequency[qubit] = frequency[qubit] - - if data.power_level is PowerLevel.high: - return ResonatorSpectroscopyAttenuationResults( - frequency=frequency, - fitted_parameters=fitted_parameters, - bare_frequency=bare_frequency, - amplitude=data.amplitudes, - attenuation=data.attenuations, - ) - else: - return ResonatorSpectroscopyAttenuationResults( - frequency=frequency, - fitted_parameters=fitted_parameters, - amplitude=data.amplitudes, - attenuation=data.attenuations, - ) - - -def _plot( - data: ResonatorSpectroscopyAttenuationData, - target: QubitId, - fit: ResonatorSpectroscopyAttenuationResults, -): - """Plotting function for ResonatorSpectroscopyAttenuation.""" - return spectroscopy_plot(data, target, fit) - - -def _update( - results: ResonatorSpectroscopyAttenuationResults, - platform: Platform, - target: QubitId, -): - update.readout_frequency(results.frequency[target], platform, target) - - # if this condition is satisfied means that we are in the low power regime - # therefore we update also the readout amplitude - if len(results.bare_frequency) == 0: - update.readout_amplitude(results.amplitude[target], platform, target) - update.readout_attenuation(results.attenuation[target], platform, target) - else: - update.bare_resonator_frequency( - results.bare_frequency[target], platform, target - ) - - -resonator_spectroscopy_attenuation = Routine(_acquisition, _fit, _plot, _update) -"""ResonatorSpectroscopyAttenuation Routine object."""