qibocal.protocols.characterization package#

class qibocal.protocols.characterization.Operation(value)[source]#

Bases: Enum

An enumeration.

resonator_spectroscopy = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

resonator_spectroscopy_attenuation = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

resonator_punchout = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

resonator_punchout_attenuation = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

resonator_flux = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

qubit_spectroscopy = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

qubit_flux = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

rabi_amplitude = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

rabi_length = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

rabi_length_sequences = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

ramsey = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

ramsey_sequences = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

t1 = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

t1_sequences = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

t2 = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

t2_sequences = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

time_of_flight_readout = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

single_shot_classification = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

spin_echo = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

allxy = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

allxy_drag_pulse_tuning = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

drag_pulse_tuning = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

flipping = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

dispersive_shift = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

chevron = Routine(acquisition=<function _aquisition>, fit=<function _fit>, report=<function _plot>)#

cz_virtualz = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

standard_rb = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

readout_characterization = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

resonator_frequency = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

fast_reset = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

zeno = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

Subpackages#

Submodules#

qibocal.protocols.characterization.classification module#

class qibocal.protocols.characterization.classification.SingleShotClassificationParameters(nshots: ~typing.Optional[int] = None, relaxation_time: ~typing.Optional[int] = None, classifiers_list: ~typing.Optional[list[str]] = <factory>, savedir: ~typing.Optional[str] = ' ')[source]#

Bases: Parameters

SingleShotClassification runcard inputs.

nshots: Optional[int] = None#: Number of shots.

relaxation_time: Optional[int] = None#: Relaxation time (ns).

classifiers_list: Optional[list[str]]#: List of models to classify the qubit states

savedir: Optional[str] = ' '#: Dumping folder of the classification results

qibocal.protocols.characterization.classification.ClassificationType = dtype([('i', '<f8'), ('q', '<f8'), ('state', '<i8')])#: Custom dtype for rabi amplitude.

class qibocal.protocols.characterization.classification.SingleShotClassificationData(nshots: int, classifiers_list: Optional[str], hpars: dict[typing.Union[str, int], dict], savedir: str, data: dict[tuple[typing.Union[str, int], int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('i', '<f8'), ('q', '<f8'), ('state', '<i8')])]]] = <factory>)[source]#

Bases: Data

nshots: int#: Number of shots.

classifiers_list: Optional[str]#: List of models to classify the qubit states

hpars: dict[Union[str, int], dict]#: Models’ hyperparameters

savedir: str#: Dumping folder of the classification results

data: dict[tuple[typing.Union[str, int], int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('i', '<f8'), ('q', '<f8'), ('state', '<i8')])]]]#: Raw data acquired.

register_qubit(qubit, state, i, q)[source]#: Store output for single qubit.

add_data(qubit, state, i, q)[source]#: Store output for single qubit.

class qibocal.protocols.characterization.classification.SingleShotClassificationResults(benchmark_table: dict[Union[str, int], pandas.core.frame.DataFrame], y_tests: dict[Union[str, int], list], x_tests: dict[Union[str, int], list], models: dict[Union[str, int], list], names: list, hpars: dict[Union[str, int], dict], threshold: dict[Union[str, int], float], rotation_angle: dict[Union[str, int], float], mean_gnd_states: dict[Union[str, int], list[float]], mean_exc_states: dict[Union[str, int], list[float]], fidelity: dict[Union[str, int], float], assignment_fidelity: dict[Union[str, int], float], savedir: str)[source]#

Bases: Results

SingleShotClassification outputs.

benchmark_table: dict[Union[str, int], pandas.core.frame.DataFrame]#: Benchmark tables.

y_tests: dict[Union[str, int], list]#: States of the testing set.

x_tests: dict[Union[str, int], list]#: I,Q couples to evaluate accuracy and test time.

models: dict[Union[str, int], list]#: List of trained classification models.

names: list#: List of models name.

hpars: dict[Union[str, int], dict]#: Classifiers hyperparameters.

threshold: dict[Union[str, int], float]#: Threshold for classification.

rotation_angle: dict[Union[str, int], float]#: Threshold for classification.

mean_gnd_states: dict[Union[str, int], list[float]]#: Centroid of the ground state blob.

mean_exc_states: dict[Union[str, int], list[float]]#: Centroid of the excited state blob.

fidelity: dict[Union[str, int], float]#: Fidelity evaluated only with the qubit_fit model

assignment_fidelity: dict[Union[str, int], float]#: Assignment fidelity evaluated only with the qubit_fit model

savedir: str#: Dumping folder of the classification results

save(path)[source]#: Store results to json.

qibocal.protocols.characterization.dispersive_shift module#

class qibocal.protocols.characterization.dispersive_shift.DispersiveShiftParameters(freq_width: int, freq_step: int, nshots: Optional[int] = None, relaxation_time: Optional[int] = None)[source]#

Bases: Parameters

Dispersive shift inputs.

freq_width: int#: Width [Hz] for frequency sweep relative to the readout frequency (Hz).

freq_step: int#: Frequency step for sweep (Hz).

nshots: Optional[int] = None#: Number of shots.

relaxation_time: Optional[int] = None#: Relaxation time (ns).

class qibocal.protocols.characterization.dispersive_shift.StateResults(frequency: dict[Union[str, int], float], fitted_parameters: dict[Union[str, int], dict[str, float]])[source]#

Bases: Results

Resonator spectroscopy outputs.

frequency: dict[Union[str, int], float]#: Readout frequency for each qubit.

fitted_parameters: dict[Union[str, int], dict[str, float]]#: Raw fitted parameters.

class qibocal.protocols.characterization.dispersive_shift.DispersiveShiftResults(results_0: StateResults, results_1: StateResults, best_freq: dict[Union[str, int], float], best_iqs: dict[Union[str, int], numpy.ndarray[Any, numpy.dtype[numpy.float64]]])[source]#

Bases: Results

Dispersive shift outputs.

results_0: StateResults#: Resonator spectroscopy outputs in the ground state.

results_1: StateResults#: Resonator spectroscopy outputs in the excited state

best_freq: dict[Union[str, int], float]#: Readout frequency that maximizes the distance of ground and excited states in iq-plane

best_iqs: dict[Union[str, int], numpy.ndarray[Any, numpy.dtype[numpy.float64]]]#: iq-couples of ground and excited states with best frequency

qibocal.protocols.characterization.dispersive_shift.DispersiveShiftType = dtype([('freq', '<f8'), ('i', '<f8'), ('q', '<f8'), ('msr', '<f8'), ('phase', '<f8')])#: Custom dtype for rabi amplitude.

class qibocal.protocols.characterization.dispersive_shift.DispersiveShiftData(resonator_type: str, data: dict[tuple[typing.Union[str, int], int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('i', '<f8'), ('q', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]] = <factory>)[source]#

Bases: Data

Dipsersive shift acquisition outputs.

resonator_type: str#: Resonator type.

data: dict[tuple[typing.Union[str, int], int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('i', '<f8'), ('q', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]]#: Data object to store arrays

register_qubit(qubit, state, freq, msr, phase, i, q)[source]#: Store output for single qubit.

qibocal.protocols.characterization.dispersive_shift.dispersive_shift = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#: Dispersive shift Routine object.

qibocal.protocols.characterization.flipping module#

class qibocal.protocols.characterization.flipping.FlippingParameters(nflips_max: int, nflips_step: int, nshots: Optional[int] = None, relaxation_time: Optional[int] = None)[source]#

Bases: Parameters

Flipping runcard inputs.

nflips_max: int#: Maximum number of flips ([RX(pi) - RX(pi)] sequences).

nflips_step: int#: Flip step.

nshots: Optional[int] = None#: Number of shots.

relaxation_time: Optional[int] = None#: Relaxation time (ns).

class qibocal.protocols.characterization.flipping.FlippingResults(amplitude: dict[Union[str, int], float], amplitude_factors: dict[Union[str, int], float], fitted_parameters: dict[Union[str, int], dict[str, float]])[source]#

Bases: Results

Flipping outputs.

amplitude: dict[Union[str, int], float]#: Drive amplitude for each qubit.

amplitude_factors: dict[Union[str, int], float]#: Drive amplitude correction factor for each qubit.

fitted_parameters: dict[Union[str, int], dict[str, float]]#: Raw fitting output.

class qibocal.protocols.characterization.flipping.FlippingData(resonator_type: str, pi_pulse_amplitudes: dict[typing.Union[str, int], float], data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('flips', '<f8'), ('msr', '<f8')])]]] = <factory>)[source]#

Bases: Data

Flipping acquisition outputs.

resonator_type: str#: Resonator type.

pi_pulse_amplitudes: dict[Union[str, int], float]#: Pi pulse amplitudes for each qubit.

data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('flips', '<f8'), ('msr', '<f8')])]]]#: Raw data acquired.

register_qubit(qubit, flips, msr)[source]#: Store output for single qubit.

qibocal.protocols.characterization.flipping.flipping_fit(x, offset, amplitude, omega, phase, gamma)[source]#

qibocal.protocols.characterization.flipping.flipping = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#: Flipping Routine object.

qibocal.protocols.characterization.qubit_spectroscopy module#

class qibocal.protocols.characterization.qubit_spectroscopy.QubitSpectroscopyParameters(freq_width: int, freq_step: int, drive_duration: int, drive_amplitude: Optional[float] = None, nshots: Optional[int] = None, relaxation_time: Optional[int] = None)[source]#

Bases: Parameters

QubitSpectroscopy runcard inputs.

freq_width: int#: Width [Hz] for frequency sweep relative to the qubit frequency.

freq_step: int#: Frequency [Hz] step for sweep.

drive_duration: int#: Drive pulse duration [ns]. Same for all qubits.

drive_amplitude: Optional[float] = None#: Drive pulse amplitude (optional). Same for all qubits.

nshots: Optional[int] = None#: Number of shots.

relaxation_time: Optional[int] = None#: Relaxation time (ns).

class qibocal.protocols.characterization.qubit_spectroscopy.QubitSpectroscopyResults(frequency: dict[Union[str, int], dict[str, float]], amplitude: dict[Union[str, int], float], fitted_parameters: dict[Union[str, int], dict[str, float]])[source]#

Bases: Results

QubitSpectroscopy outputs.

frequency: dict[Union[str, int], dict[str, float]]#: Drive frequecy [GHz] for each qubit.

amplitude: dict[Union[str, int], float]#: Input drive amplitude. Same for all qubits.

fitted_parameters: dict[Union[str, int], dict[str, float]]#: Raw fitting output.

class qibocal.protocols.characterization.qubit_spectroscopy.QubitSpectroscopyData(resonator_type: str, amplitudes: dict[typing.Union[str, int], float], data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]] = <factory>, power_level: ~typing.Optional[~qibocal.protocols.characterization.utils.PowerLevel] = None)[source]#

Bases: ResonatorSpectroscopyData

QubitSpectroscopy acquisition outputs.

qibocal.protocols.characterization.qubit_spectroscopy.qubit_spectroscopy = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#: QubitSpectroscopy Routine object.

qibocal.protocols.characterization.ramsey module#

class qibocal.protocols.characterization.ramsey.RamseyParameters(delay_between_pulses_start: int, delay_between_pulses_end: int, delay_between_pulses_step: int, n_osc: Optional[int] = 0, nshots: Optional[int] = None, relaxation_time: Optional[int] = None)[source]#

Bases: Parameters

Ramsey runcard inputs.

delay_between_pulses_start: int#: Initial delay between RX(pi/2) pulses in ns.

delay_between_pulses_end: int#: Final delay between RX(pi/2) pulses in ns.

delay_between_pulses_step: int#: Step delay between RX(pi/2) pulses in ns.

n_osc: Optional[int] = 0#: Number of oscillations to induce detuning (optional). If 0 standard Ramsey experiment is performed.

nshots: Optional[int] = None#: Number of shots.

relaxation_time: Optional[int] = None#: Relaxation time (ns).

class qibocal.protocols.characterization.ramsey.RamseyResults(frequency: dict[Union[str, int], float], t2: dict[Union[str, int], float], delta_phys: dict[Union[str, int], float], fitted_parameters: dict[Union[str, int], dict[str, float]])[source]#

Bases: Results

Ramsey outputs.

frequency: dict[Union[str, int], float]#: Drive frequency [GHz] for each qubit.

t2: dict[Union[str, int], float]#: T2 for each qubit [ns].

delta_phys: dict[Union[str, int], float]#: Drive frequency [Hz] correction for each qubit.

fitted_parameters: dict[Union[str, int], dict[str, float]]#: Raw fitting output.

qibocal.protocols.characterization.ramsey.RamseyType = dtype([('wait', '<f8'), ('msr', '<f8'), ('phase', '<f8')])#: Custom dtype for coherence routines.

class qibocal.protocols.characterization.ramsey.RamseyData(n_osc: int, t_max: int, detuning_sign: int, qubit_freqs: dict[typing.Union[str, int], float] = <factory>, data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('wait', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]] = <factory>)[source]#

Bases: Data

Ramsey acquisition outputs.

n_osc: int#: Number of oscillations for detuning.

t_max: int#: Final delay between RX(pi/2) pulses in ns.

detuning_sign: int#: Sign for induced detuning.

qubit_freqs: dict[Union[str, int], float]#: Qubit freqs for each qubit.

data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('wait', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]]#: Raw data acquired.

register_qubit(qubit, wait, msr, phase)[source]#: Store output for single qubit.

qibocal.protocols.characterization.ramsey.ramsey_fit(x, p0, p1, p2, p3, p4)[source]#

qibocal.protocols.characterization.ramsey.ramsey = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#: Ramsey Routine object.

qibocal.protocols.characterization.ramsey_sequences module#

qibocal.protocols.characterization.ramsey_sequences.ramsey_sequences = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#: Ramsey Routine object.

qibocal.protocols.characterization.readout_characterization module#

class qibocal.protocols.characterization.readout_characterization.ReadoutCharacterizationParameters(nshots: Optional[int] = None, relaxation_time: Optional[int] = None)[source]#

Bases: Parameters

ReadoutCharacterization runcard inputs.

nshots: Optional[int] = None#: Number of shots.

relaxation_time: Optional[int] = None#: Relaxation time (ns).

class qibocal.protocols.characterization.readout_characterization.ReadoutCharacterizationResults(fidelity: dict[Union[str, int], float], qnd: dict[Union[str, int], float], Lambda_M: dict[Union[str, int], float])[source]#

Bases: Results

ReadoutCharacterization outputs.

fidelity: dict[Union[str, int], float]#: Fidelity of the measurement

qnd: dict[Union[str, int], float]#: QND-ness of the measurement

Lambda_M: dict[Union[str, int], float]#: Mapping between a given initial state to an outcome adter the measurement

qibocal.protocols.characterization.readout_characterization.ReadoutCharacterizationType = dtype([('probability', '<f8')])#: Custom dtype for ReadoutCharacterization.

class qibocal.protocols.characterization.readout_characterization.ReadoutCharacterizationData(data: dict[tuple[typing.Union[str, int], int, bool], numpy.ndarray[typing.Any, numpy.dtype[dtype([('probability', '<f8')])]]] = <factory>)[source]#

Bases: Data

ReadoutCharacterization acquisition outputs.

data: dict[tuple[typing.Union[str, int], int, bool], numpy.ndarray[typing.Any, numpy.dtype[dtype([('probability', '<f8')])]]]#: Raw data acquired.

register_qubit(qubit, probability, state, readout_number)[source]#: Store output for single qubit.

qibocal.protocols.characterization.readout_characterization.readout_characterization = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#: ReadoutCharacterization Routine object.

qibocal.protocols.characterization.resonator_punchout module#

class qibocal.protocols.characterization.resonator_punchout.ResonatorPunchoutParameters(freq_width: int, freq_step: int, min_amp_factor: float, max_amp_factor: float, step_amp_factor: float, amplitude: Optional[float] = None, nshots: Optional[int] = None, relaxation_time: Optional[int] = None)[source]#

Bases: Parameters

“ResonatorPunchout runcard inputs.

freq_width: int#: Width for frequency sweep relative to the readout frequency (Hz).

freq_step: int#: Frequency step for sweep (Hz).

min_amp_factor: float#: Minimum amplitude multiplicative factor.

max_amp_factor: float#: Maximum amplitude multiplicative factor.

step_amp_factor: float#: Step amplitude multiplicative factor.

amplitude: float = None#: Initial readout amplitude.

nshots: Optional[int] = None#: Number of shots.

relaxation_time: Optional[int] = None#: Relaxation time (ns).

class qibocal.protocols.characterization.resonator_punchout.ResonatorPunchoutResults(readout_frequency: dict[Union[str, int], float], bare_frequency: Optional[dict[Union[str, int], float]], readout_amplitude: dict[Union[str, int], float])[source]#

Bases: Results

ResonatorPunchout outputs.

readout_frequency: dict[Union[str, int], float]#: Readout frequency [GHz] for each qubit.

bare_frequency: Optional[dict[Union[str, int], float]]#: Bare resonator frequency [GHz] for each qubit.

readout_amplitude: dict[Union[str, int], float]#: Readout amplitude for each qubit.

qibocal.protocols.characterization.resonator_punchout.ResPunchoutType = dtype([('freq', '<f8'), ('amp', '<f8'), ('msr', '<f8'), ('phase', '<f8')])#: Custom dtype for resonator punchout.

class qibocal.protocols.characterization.resonator_punchout.ResonatorPunchoutData(resonator_type: str, amplitudes: dict[typing.Union[str, int], float], data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('amp', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]] = <factory>)[source]#

Bases: Data

ResonatorPunchout data acquisition.

resonator_type: str#: Resonator type.

amplitudes: dict[Union[str, int], float]#: Amplitudes provided by the user.

data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('amp', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]]#: Raw data acquired.

register_qubit(qubit, freq, amp, msr, phase)[source]#: Store output for single qubit.

qibocal.protocols.characterization.resonator_punchout.resonator_punchout = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#: ResonatorPunchout Routine object.

qibocal.protocols.characterization.resonator_punchout_attenuation module#

class qibocal.protocols.characterization.resonator_punchout_attenuation.ResonatorPunchoutAttenuationParameters(freq_width: int, freq_step: int, min_att: int, max_att: int, step_att: int, nshots: Optional[int] = None, relaxation_time: Optional[int] = None)[source]#

Bases: Parameters

ResonatorPunchoutAttenuation runcard inputs.

freq_width: int#: Width for frequency sweep relative to the readout frequency (Hz).

freq_step: int#: Frequency step for sweep (Hz).

min_att: int#: Attenuation minimum value (dB).

max_att: int#: Attenuation maximum value (dB).

step_att: int#: Attenuation step (dB).

nshots: Optional[int] = None#: Number of shots.

relaxation_time: Optional[int] = None#: Relaxation time (ns).

class qibocal.protocols.characterization.resonator_punchout_attenuation.ResonatorPunchoutAttenuationResults(readout_frequency: dict[Union[str, int], float], bare_frequency: Optional[dict[Union[str, int], float]], readout_attenuation: dict[Union[str, int], int])[source]#

Bases: Results

ResonatorPunchoutAttenation outputs.

readout_frequency: dict[Union[str, int], float]#: Readout frequency [GHz] for each qubit.

bare_frequency: Optional[dict[Union[str, int], float]]#

readout_attenuation: dict[Union[str, int], int]#: Readout attenuation [dB] for each qubit.

qibocal.protocols.characterization.resonator_punchout_attenuation.ResPunchoutAttType = dtype([('freq', '<f8'), ('att', '<f8'), ('msr', '<f8'), ('phase', '<f8')])#: Custom dtype for resonator punchout.

class qibocal.protocols.characterization.resonator_punchout_attenuation.ResonatorPunchoutAttenuationData(resonator_type: str, data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('att', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]] = <factory>)[source]#

Bases: Data

ResonatorPunchoutAttenuation data acquisition.

resonator_type: str#: Resonator type.

data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('att', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]]#: Raw data acquired.

register_qubit(qubit, freq, att, msr, phase)[source]#: Store output for single qubit.

qibocal.protocols.characterization.resonator_punchout_attenuation.resonator_punchout_attenuation = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#: ResonatorPunchoutAttenuation Routine object.

qibocal.protocols.characterization.resonator_spectroscopy module#

class qibocal.protocols.characterization.resonator_spectroscopy.ResonatorSpectroscopyParameters(freq_width: int, freq_step: int, power_level: PowerLevel, amplitude: Optional[float] = None, nshots: Optional[int] = None, relaxation_time: Optional[int] = None)[source]#

Bases: 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

nshots: Optional[int] = None#: Number of shots.

relaxation_time: Optional[int] = None#: Relaxation time (ns).

class qibocal.protocols.characterization.resonator_spectroscopy.ResonatorSpectroscopyResults(frequency: dict[typing.Union[str, int], float], fitted_parameters: dict[typing.Union[str, int], dict[str, float]], bare_frequency: ~typing.Optional[dict[typing.Union[str, int], float]] = <factory>, amplitude: ~typing.Optional[dict[typing.Union[str, int], float]] = <factory>, attenuation: ~typing.Optional[dict[typing.Union[str, int], int]] = <factory>)[source]#

Bases: Results

ResonatorSpectroscopy outputs.

frequency: dict[Union[str, int], float]#: Readout frequency [GHz] for each qubit.

fitted_parameters: dict[Union[str, int], dict[str, float]]#: Raw fitted parameters.

bare_frequency: Optional[dict[Union[str, int], float]]#: Bare resonator frequency [GHz] for each qubit.

amplitude: Optional[dict[Union[str, int], float]]#: Readout amplitude for each qubit.

attenuation: Optional[dict[Union[str, int], int]]#: Readout attenuation [dB] for each qubit.

property update#: Method overwritten from Results to not update amplitude when running resonator spectroscopy at high power.

qibocal.protocols.characterization.resonator_spectroscopy.ResSpecType = dtype([('freq', '<f8'), ('msr', '<f8'), ('phase', '<f8')])#: Custom dtype for resonator spectroscopy.

class qibocal.protocols.characterization.resonator_spectroscopy.ResonatorSpectroscopyData(resonator_type: str, amplitudes: dict[typing.Union[str, int], float], data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]] = <factory>, power_level: ~typing.Optional[~qibocal.protocols.characterization.utils.PowerLevel] = None)[source]#

Bases: Data

Data structure for resonator spectroscopy.

resonator_type: str#: Resonator type.

amplitudes: dict[Union[str, int], float]#: Amplitudes provided by the user.

data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]]#: Raw data acquired.

power_level: Optional[PowerLevel] = None#: Power regime of the resonator.

register_qubit(qubit, freq, msr, phase)[source]#: Store output for single qubit.

qibocal.protocols.characterization.resonator_spectroscopy.resonator_spectroscopy = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#: ResonatorSpectroscopy Routine object.

qibocal.protocols.characterization.resonator_spectroscopy_attenuation module#

class qibocal.protocols.characterization.resonator_spectroscopy_attenuation.ResonatorSpectroscopyAttenuationParameters(freq_width: int, freq_step: int, power_level: PowerLevel, nshots: Optional[int] = None, relaxation_time: Optional[int] = None, amplitude: Optional[float] = None, attenuation: Optional[int] = None)[source]#

Bases: 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.

nshots: Optional[int] = None#: Number of shots.

relaxation_time: Optional[int] = None#: Relaxation time (ns).

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

class qibocal.protocols.characterization.resonator_spectroscopy_attenuation.ResonatorSpectroscopyAttenuationResults(frequency: dict[typing.Union[str, int], float], fitted_parameters: dict[typing.Union[str, int], dict[str, float]], bare_frequency: ~typing.Optional[dict[typing.Union[str, int], float]] = <factory>, amplitude: ~typing.Optional[dict[typing.Union[str, int], float]] = <factory>, attenuation: ~typing.Optional[dict[typing.Union[str, int], int]] = <factory>)[source]#

Bases: Results

ResonatorSpectroscopy outputs.

frequency: dict[Union[str, int], float]#: Readout frequency [GHz] for each qubit.

fitted_parameters: dict[Union[str, int], dict[str, float]]#: Raw fitted parameters.

bare_frequency: Optional[dict[Union[str, int], float]]#: Bare resonator frequency [GHz] for each qubit.

amplitude: Optional[dict[Union[str, int], float]]#: Readout amplitude for each qubit.

attenuation: Optional[dict[Union[str, int], int]]#: Readout attenuation [dB] for each qubit.

class qibocal.protocols.characterization.resonator_spectroscopy_attenuation.ResonatorSpectroscopyAttenuationData(resonator_type: str, amplitudes: dict[typing.Union[str, int], float], data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]] = <factory>, power_level: ~typing.Optional[~qibocal.protocols.characterization.utils.PowerLevel] = None, attenuations: dict[typing.Union[str, int], int] = <factory>)[source]#

Bases: ResonatorSpectroscopyData

Data structure for resonator spectroscopy with attenuation.

attenuations: dict[Union[str, int], int]#

qibocal.protocols.characterization.resonator_spectroscopy_attenuation.resonator_spectroscopy_attenuation = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#: ResonatorSpectroscopyAttenuation Routine object.

qibocal.protocols.characterization.test module#

qibocal.protocols.characterization.two module#

qibocal.protocols.characterization.utils module#

class qibocal.protocols.characterization.utils.PowerLevel(value)[source]#

Bases: str, Enum

Power Regime for Resonator Spectroscopy

high = 'high'#

low = 'low'#

qibocal.protocols.characterization.utils.lorentzian(frequency, amplitude, center, sigma, offset)[source]#

qibocal.protocols.characterization.utils.lorentzian_fit(data, resonator_type=None, fit=None)[source]#

qibocal.protocols.characterization.utils.spectroscopy_plot(data, fit: Results, qubit)[source]#

qibocal.protocols.characterization.utils.norm(x_mags)[source]#

qibocal.protocols.characterization.utils.cumulative(input_data, points)[source]#: Evaluates in data the cumulative distribution function of points. WARNING: input_data and points should be sorted data.

qibocal.protocols.characterization.utils.fit_punchout(data: Data, fit_type: str)[source]#

Punchout fitting function.

Args:

data (Data): Punchout acquisition data. fit_type (str): Punchout type, it could be amp (amplitude) or att (attenuation).

Return:

List of dictionaries containing the low, high amplitude (attenuation) frequencies and the readout amplitude (attenuation) for each qubit.

qibocal.protocols.characterization.utils.get_color_state0(number)[source]#

qibocal.protocols.characterization.utils.get_color_state1(number)[source]#