qibocal.protocols package#

Subpackages#

Submodules#

qibocal.protocols.classification module#

qibocal.protocols.classification.evaluate_snr(zeros: ndarray[Any, dtype[_ScalarType_co]], ones: ndarray[Any, dtype[_ScalarType_co]]) → float[source]#: Compute snr for zeros and ones

class qibocal.protocols.classification.SingleShotClassificationParameters(unrolling: bool = False, classifiers_list: ~typing.Optional[list[str]] = <factory>, savedir: ~typing.Optional[str] = ' ')[source]#

Bases: Parameters

SingleShotClassification runcard inputs.

unrolling: bool = False#

Whether to unroll the sequences.

If True it uses sequence unrolling to deploy multiple sequences in a single instrument call.

Defaults to False.

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

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

hardware_average: bool = False#: By default hardware average will be performed.

nshots: int#: Number of executions on hardware.

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

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

class qibocal.protocols.classification.SingleShotClassificationData(nshots: int, savedir: str, qubit_frequencies: dict[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], float] = <factory>, data: dict[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]] = <factory>, classifiers_list: Optional[list[str]] = <factory>)[source]#

Bases: Data

nshots: int#: Number of shots.

savedir: str#: Dumping folder of the classification results.

qubit_frequencies: dict[Union[int, str], float]#: Qubit frequencies.

data: dict[typing.Union[int, str], numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]]#: Raw data acquired.

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

state_zero(qubit: Union[int, str]) → ndarray[Any, dtype[_ScalarType_co]][source]#: Get state zero data.

state_one(qubit: Union[int, str]) → ndarray[Any, dtype[_ScalarType_co]][source]#: Get state one data.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

class qibocal.protocols.classification.SingleShotClassificationResults(names: list, savedir: str, y_preds: dict[typing.Union[int, str], list], grid_preds: dict[typing.Union[int, str], list], threshold: dict[typing.Union[int, str], float] = <factory>, rotation_angle: dict[typing.Union[int, str], float] = <factory>, mean_gnd_states: dict[typing.Union[int, str], list[float]] = <factory>, mean_exc_states: dict[typing.Union[int, str], list[float]] = <factory>, fidelity: dict[typing.Union[int, str], float] = <factory>, assignment_fidelity: dict[typing.Union[int, str], float] = <factory>, effective_temperature: dict[typing.Union[int, str], float] = <factory>, models: dict[typing.Union[int, str], list] = <factory>, benchmark_table: ~typing.Optional[dict[typing.Union[int, str], pandas.core.frame.DataFrame]] = <factory>, classifiers_hpars: ~typing.Optional[dict[typing.Union[int, str], dict]] = <factory>, x_tests: dict[typing.Union[int, str], list] = <factory>, y_tests: dict[typing.Union[int, str], list] = <factory>, snr: dict[typing.Union[int, str], float] = <factory>)[source]#

Bases: Results

SingleShotClassification outputs.

names: list#: List of models name.

savedir: str#: Dumping folder of the classification results.

y_preds: dict[Union[int, str], list]#: Models’ predictions of the test set.

grid_preds: dict[Union[int, str], list]#: Models’ prediction of the contour grid.

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

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

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

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

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

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

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

effective_temperature: dict[Union[int, str], float]#: Qubit effective temperature from Boltzmann distribution.

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

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

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

x_tests: dict[Union[int, str], list]#: Test set.

y_tests: dict[Union[int, str], list]#: Test set.

snr: dict[Union[int, str], float]#: SNR for two clouds

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

qibocal.protocols.classification._acquisition(params: SingleShotClassificationParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → SingleShotClassificationData[source]#

Parameters:

nshots (int) – number of times the pulse sequence will be repeated.
classifiers (list) – list of classifiers, the available ones are: - qubit_fit - qblox_fit.
["qubit_fit"]. (The default value is) –
savedir (str) – Dumping folder of the classification results.
one. (If not given the dumping folder will be the report) –
relaxation_time (float) – Relaxation time.
Example –
code-block: (..) – yaml:
id (-) – single_shot_classification_1 operation: single_shot_classification parameters: nshots: 5000 savedir: “single_shot” classifiers_list: [“qubit_fit”]

qibocal.protocols.classification._fit(data: SingleShotClassificationData) → SingleShotClassificationResults[source]#

qibocal.protocols.classification._plot(data: SingleShotClassificationData, target: Union[int, str], fit: SingleShotClassificationResults)[source]#

qibocal.protocols.classification._update(results: SingleShotClassificationResults, platform: CalibrationPlatform, target: Union[int, str])[source]#

qibocal.protocols.classification.single_shot_classification = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>, update=<function _update>, two_qubit_gates=False)#: Qubit classification routine object.

qibocal.protocols.dispersive_shift module#

class qibocal.protocols.dispersive_shift.DispersiveShiftParameters(freq_width: int, freq_step: int)[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].

hardware_average: bool = False#: By default hardware average will be performed.

nshots: int#: Number of executions on hardware.

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

class qibocal.protocols.dispersive_shift.DispersiveShiftResults(frequencies: dict[Union[int, str], list[float]], fitted_parameters: dict[Union[int, str], list[list[float]]], best_freq: dict[Union[int, str], float])[source]#

Bases: Results

Dispersive shift outputs.

frequencies: dict[Union[int, str], list[float]]#: Qubit peak frequencies.

fitted_parameters: dict[Union[int, str], list[list[float]]]#: Fitted parameters. The first element is the resonator frequency when the qubit is in the ground state, the second one when the qubit is in the first excited state.

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

chi(target: Union[int, str]) → float[source]#: Evaluate the dispersive shift

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

qibocal.protocols.dispersive_shift.DispersiveShiftType = dtype([('freq', '<f8'), ('i', '<f8'), ('q', '<f8'), ('signal', '<f8'), ('phase', '<f8')])#: Custom dtype for dispersive shift.

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

Bases: Data

Dispersive shift acquisition outputs.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

resonator_type: str#: Resonator type.

data: dict[tuple[typing.Union[int, str], int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('i', '<f8'), ('q', '<f8'), ('signal', '<f8'), ('phase', '<f8')])]]]#

qibocal.protocols.dispersive_shift._acquisition(params: DispersiveShiftParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → DispersiveShiftData[source]#

Data acquisition for dispersive shift experiment. Perform spectroscopy on the readout resonator, with the qubit in ground and excited state, showing the resonator shift produced by the coupling between the resonator and the qubit.

Parameters:

params (DispersiveShiftParameters) – experiment’s parameters
platform (CalibrationPlatform) – Qibolab platform object
targets (list) – list of target qubits to perform the action

qibocal.protocols.dispersive_shift._fit(data: DispersiveShiftData) → DispersiveShiftResults[source]#: Post-Processing for dispersive shift

qibocal.protocols.dispersive_shift._plot(data: DispersiveShiftData, target: Union[int, str], fit: DispersiveShiftResults)[source]#: Plotting function for dispersive shift.

qibocal.protocols.dispersive_shift._update(results: DispersiveShiftResults, platform: CalibrationPlatform, target: Union[int, str])[source]#

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

qibocal.protocols.dispersive_shift_qutrit module#

class qibocal.protocols.dispersive_shift_qutrit.DispersiveShiftQutritParameters(freq_width: int, freq_step: int)[source]#

Bases: DispersiveShiftParameters

Dispersive shift inputs.

hardware_average: bool = False#: By default hardware average will be performed.

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

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

nshots: int#: Number of executions on hardware.

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

class qibocal.protocols.dispersive_shift_qutrit.DispersiveShiftQutritResults(frequency_state_zero: dict[Union[int, str], float], frequency_state_one: dict[Union[int, str], float], frequency_state_two: dict[Union[int, str], float], fitted_parameters_state_zero: dict[Union[int, str], list[float]], fitted_parameters_state_one: dict[Union[int, str], list[float]], fitted_parameters_state_two: dict[Union[int, str], list[float]])[source]#

Bases: Results

Dispersive shift outputs.

frequency_state_zero: dict[Union[int, str], float]#: State zero frequency.

frequency_state_one: dict[Union[int, str], float]#: State one frequency.

frequency_state_two: dict[Union[int, str], float]#: State two frequency.

fitted_parameters_state_zero: dict[Union[int, str], list[float]]#: Fitted parameters state zero.

fitted_parameters_state_one: dict[Union[int, str], list[float]]#: Fitted parameters state one.

fitted_parameters_state_two: dict[Union[int, str], list[float]]#: Fitted parameters state one.

property state_zero#

property state_one#

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

property state_two#

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

Bases: DispersiveShiftData

Dipsersive shift acquisition outputs.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

resonator_type: str#: Resonator type.

data: dict[tuple[QubitId, int], npt.NDArray[DispersiveShiftType]]#

qibocal.protocols.dispersive_shift_qutrit._acquisition(params: DispersiveShiftParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → DispersiveShiftQutritData[source]#

Data acquisition for dispersive shift qutrit experiment. Perform spectroscopy on the readout resonator, with the qubit in ground, excited state and second excited state showing the resonator shift produced by the coupling between the resonator and the qubit.

Parameters:

params (DispersiveShiftParameters) – experiment’s parameters
platform (CalibrationPlatform) – Qibolab platform object
targets (list) – list of target qubits to perform the action

qibocal.protocols.dispersive_shift_qutrit._fit(data: DispersiveShiftQutritData) → DispersiveShiftQutritResults[source]#: Post-Processing for dispersive shift

qibocal.protocols.dispersive_shift_qutrit._plot(data: DispersiveShiftQutritData, target: Union[int, str], fit: DispersiveShiftQutritResults)[source]#: Plotting function for dispersive shift.

qibocal.protocols.drag module#

class qibocal.protocols.drag.DragTuningParameters(beta_start: float, beta_end: float, beta_step: float, unrolling: bool = False, nflips: int = 1)[source]#

Bases: Parameters

DragTuning runcard inputs.

beta_start: float#: DRAG pulse beta start sweep parameter.

beta_end: float#: DRAG pulse beta end sweep parameter.

beta_step: float#: DRAG pulse beta sweep step parameter.

unrolling: bool = False#: If True it uses sequence unrolling to deploy multiple sequences in a single instrument call. Defaults to False.

nflips: int = 1#: Repetitions of (Xpi - Xmpi).

hardware_average: bool = False#: By default hardware average will be performed.

nshots: int#: Number of executions on hardware.

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

class qibocal.protocols.drag.DragTuningResults(betas: dict[typing.Union[int, str], float], fitted_parameters: dict[typing.Union[int, str], dict[str, float]], chi2: dict[typing.Union[int, str], tuple[float, typing.Optional[float]]] = <factory>)[source]#

Bases: Results

DragTuning outputs.

betas: dict[Union[int, str], float]#: Optimal beta paramter for each qubit.

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

chi2: dict[Union[int, str], tuple[float, Optional[float]]]#: Chi2 calculation.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

class qibocal.protocols.drag.DragTuningData(data: dict[typing.Union[int, str], numpy.ndarray[typing.Any, numpy.dtype[dtype([('prob', '<f8'), ('error', '<f8'), ('beta', '<f8')])]]] = <factory>)[source]#

Bases: Data

DragTuning acquisition outputs.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

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

qibocal.protocols.drag._acquisition(params: DragTuningParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → DragTuningData[source]#: Data acquisition for drag pulse tuning experiment. See https://arxiv.org/pdf/1504.06597.pdf Fig. 2 (c).

qibocal.protocols.drag.drag_fit(x, offset, amplitude, period, phase)[source]#

qibocal.protocols.drag._fit(data: DragTuningData) → DragTuningResults[source]#

qibocal.protocols.drag._plot(data: DragTuningData, target: Union[int, str], fit: DragTuningResults)[source]#: Plotting function for DragTuning.

qibocal.protocols.drag._update(results: DragTuningResults, platform: CalibrationPlatform, target: Union[int, str])[source]#

qibocal.protocols.drag.drag_tuning = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>, update=<function _update>, two_qubit_gates=False)#: DragTuning Routine object.

qibocal.protocols.drag_simple module#

qibocal.protocols.drag_simple.SEQUENCES = ['YpX9', 'XpY9']#: Sequences used to fit drag parameter.

class qibocal.protocols.drag_simple.DragTuningSimpleParameters(beta_start: float, beta_end: float, beta_step: float, unrolling: bool = False, nflips: int = 1)[source]#

Bases: DragTuningParameters

DragTuningSimple runcard inputs.

hardware_average: bool = False#: By default hardware average will be performed.

nflips: int = 1#: Repetitions of (Xpi - Xmpi).

unrolling: bool = False#: If True it uses sequence unrolling to deploy multiple sequences in a single instrument call. Defaults to False.

beta_start: float#: DRAG pulse beta start sweep parameter.

beta_end: float#: DRAG pulse beta end sweep parameter.

beta_step: float#: DRAG pulse beta sweep step parameter.

nshots: int#: Number of executions on hardware.

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

class qibocal.protocols.drag_simple.DragTuningSimpleResults(betas: dict[typing.Union[int, str], float], fitted_parameters: dict[typing.Union[int, str], dict[str, float]], chi2: dict[typing.Union[int, str], tuple[float, typing.Optional[float]]] = <factory>)[source]#

Bases: DragTuningResults

DragTuningSimple outputs.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

betas: dict[QubitId, float]#: Optimal beta paramter for each qubit.

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

chi2: dict[QubitId, tuple[float, Optional[float]]]#: Chi2 calculation.

class qibocal.protocols.drag_simple.DragTuningSimpleData(data: dict[typing.Union[int, str], numpy.ndarray[typing.Any, numpy.dtype[dtype([('prob', '<f8'), ('error', '<f8'), ('beta', '<f8')])]]] = <factory>)[source]#

Bases: DragTuningData

DragTuningSimple acquisition outputs.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

data: dict[QubitId, npt.NDArray[DragTuningType]]#: Raw data acquired.

qibocal.protocols.drag_simple.add_drag(pulse: Pulse, beta: float) → Pulse[source]#: Add DRAG component to Gaussian Pulse.

qibocal.protocols.drag_simple._acquisition(params: DragTuningSimpleParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → DragTuningSimpleData[source]#

Acquisition function for DRAG experiments.

We execute two sequences YpX9 and XpY9 following https://rsl.yale.edu/sites/default/files/2024-08/2011-RSL-Thesis-Matthew-Reed.pdf for different value of the DRAG parameter.

qibocal.protocols.drag_simple._fit(data: DragTuningSimpleData) → DragTuningSimpleResults[source]#

Post-processing for DRAG protocol.

A linear fit is applied for the probability of both sequences. The optimal is determined as the point in which the two lines met.

qibocal.protocols.drag_simple._plot(data: DragTuningSimpleData, target: Union[int, str], fit: DragTuningSimpleResults)[source]#: Plotting function for DragTuning.

qibocal.protocols.drag_simple._update(results: DragTuningSimpleResults, platform: CalibrationPlatform, target: Union[int, str])[source]#

qibocal.protocols.drag_simple.drag_simple = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>, update=<function _update>, two_qubit_gates=False)#: DragTuning Routine object.

qibocal.protocols.flipping module#

qibocal.protocols.flipping.flipping_sequence(platform: CalibrationPlatform, qubit: Union[int, str], delta_amplitude: float, flips: int, rx90: bool)[source]#: Pulse sequence for flipping experiment.

class qibocal.protocols.flipping.FlippingParameters(nflips_max: int, nflips_step: int, unrolling: bool = False, delta_amplitude: float = 0, rx90: bool = False)[source]#

Bases: Parameters

Flipping runcard inputs.

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

nflips_step: int#: Flip step.

unrolling: bool = False#: If True it uses sequence unrolling to deploy multiple sequences in a single instrument call. Defaults to False.

delta_amplitude: float = 0#: Amplitude detuning.

rx90: bool = False#: Calibration of native pi pulse, if true calibrates pi/2 pulse

hardware_average: bool = False#: By default hardware average will be performed.

nshots: int#: Number of executions on hardware.

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

class qibocal.protocols.flipping.FlippingResults(amplitude: dict[typing.Union[int, str], typing.Union[float, list[float]]], delta_amplitude: dict[typing.Union[int, str], typing.Union[float, list[float]]], delta_amplitude_detuned: dict[typing.Union[int, str], typing.Union[float, list[float]]], fitted_parameters: dict[typing.Union[int, str], dict[str, float]], rx90: bool, chi2: dict[typing.Union[int, str], list[float]] = <factory>)[source]#

Bases: Results

Flipping outputs.

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

delta_amplitude: dict[Union[int, str], Union[float, list[float]]]#: Difference in amplitude between initial value and fit.

delta_amplitude_detuned: dict[Union[int, str], Union[float, list[float]]]#: Difference in amplitude between detuned value and fit.

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

rx90: bool#: Pi or Pi_half calibration

chi2: dict[Union[int, str], list[float]]#: Chi squared estimate mean value and error.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

class qibocal.protocols.flipping.FlippingData(resonator_type: str, delta_amplitude: float, pulse_amplitudes: dict[typing.Union[int, str], float], rx90: bool, data: dict[typing.Union[int, str], numpy.ndarray[typing.Any, numpy.dtype[dtype([('flips', '<f8'), ('prob', '<f8'), ('error', '<f8')])]]] = <factory>)[source]#

Bases: Data

Flipping acquisition outputs.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

resonator_type: str#: Resonator type.

delta_amplitude: float#: Amplitude detuning.

pulse_amplitudes: dict[Union[int, str], float]#: Pulse amplitudes for each qubit.

rx90: bool#: Pi or Pi_half calibration

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

qibocal.protocols.flipping._acquisition(params: FlippingParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → FlippingData[source]#

Data acquisition for flipping.

The flipping experiment correct the delta amplitude in the qubit drive pulse. We measure a qubit after applying a Rx(pi/2) and N flips (Rx(pi) rotations). After fitting we can obtain the delta amplitude to refine pi pulses. On the y axis we measure the excited state probability.

Parameters:

params (SingleShotClassificationParameters) – input parameters
platform (CalibrationPlatform) – Qibolab’s platform
qubits (dict) – dict of target Qubit objects to be characterized

Returns:

data (FlippingData)

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

qibocal.protocols.flipping._fit(data: FlippingData) → FlippingResults[source]#

Post-processing function for Flipping.

The used model is

\[y = p_0 sin\Big(\frac{2 \pi x}{p_2} + p_3\Big) + p_1.\]

qibocal.protocols.flipping._plot(data: FlippingData, target: Union[int, str], fit: FlippingResults = None)[source]#: Plotting function for Flipping.

qibocal.protocols.flipping._update(results: FlippingResults, platform: CalibrationPlatform, qubit: Union[int, str])[source]#

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

qibocal.protocols.flux_amplitude_frequency module#

Experiment to compute detuning from flux pulses.

class qibocal.protocols.flux_amplitude_frequency.FluxAmplitudeFrequencyParameters(amplitude_min: int, amplitude_max: int, amplitude_step: int, duration: float)[source]#

Bases: Parameters

FluxAmplitudeFrequency runcard inputs.

amplitude_min: int#: Minimum flux pulse amplitude.

amplitude_max: int#: Maximum flux amplitude.

amplitude_step: int#: Flux pulse amplitude step.

duration: float#: Flux pulse duration.

hardware_average: bool = False#: By default hardware average will be performed.

nshots: int#: Number of executions on hardware.

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

class qibocal.protocols.flux_amplitude_frequency.FluxAmplitudeFrequencyResults(detuning: dict[typing.Union[int, str], float] = <factory>, fitted_parameters: dict[tuple[typing.Union[int, str], str], list[float]] = <factory>)[source]#

Bases: Results

FluxAmplitudeFrequency outputs.

detuning: dict[Union[int, str], float]#: Frequency detuning.

fitted_parameters: dict[tuple[Union[int, str], str], list[float]]#: Fitted parameters for every qubit.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

qibocal.protocols.flux_amplitude_frequency.FluxAmplitudeFrequencyType = dtype([('amplitude', '<f8'), ('prob_1', '<f8')])#: Custom dtype for FluxAmplitudeFrequency.

qibocal.protocols.flux_amplitude_frequency.ramsey_flux(platform: Platform, qubit: Union[int, str], amplitude: float, duration: int, measure: str)[source]#: Compute sequences at fixed amplitude of flux pulse for <X> and <Y>

class qibocal.protocols.flux_amplitude_frequency.FluxAmplitudeFrequencyData(flux_pulse_duration: float, data: dict[tuple[typing.Union[int, str], str], numpy.ndarray[typing.Any, numpy.dtype[dtype([('amplitude', '<f8'), ('prob_1', '<f8')])]]] = <factory>)[source]#

Bases: Data

FluxAmplitudeFrequency acquisition outputs.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

flux_pulse_duration: float#: Flux pulse amplitude.

data: dict[tuple[typing.Union[int, str], str], numpy.ndarray[typing.Any, numpy.dtype[dtype([('amplitude', '<f8'), ('prob_1', '<f8')])]]]#

qibocal.protocols.flux_amplitude_frequency._acquisition(params: FluxAmplitudeFrequencyParameters, platform: Platform, targets: list[Union[int, str]]) → FluxAmplitudeFrequencyData[source]#

qibocal.protocols.flux_amplitude_frequency._fit(data: FluxAmplitudeFrequencyData) → FluxAmplitudeFrequencyResults[source]#

qibocal.protocols.flux_amplitude_frequency._plot(data: FluxAmplitudeFrequencyData, fit: FluxAmplitudeFrequencyResults, target: Union[int, str])[source]#: FluxAmplitudeFrequency plots.

qibocal.protocols.flux_amplitude_frequency._update(results: FluxAmplitudeFrequencyResults, platform: Platform, qubit: Union[int, str])[source]#

qibocal.protocols.flux_gate module#

FluxGate experiment, implementation of Z gate using flux pulse.

class qibocal.protocols.flux_gate.FluxGateParameters(duration_min: int, duration_max: int, duration_step: int, flux_pulse_amplitude: float)[source]#

Bases: Parameters

FluxGate runcard inputs.

duration_min: int#: Minimum flux pulse duration.

duration_max: int#: Maximum flux duration start.

duration_step: int#: Flux pulse duration step.

flux_pulse_amplitude: float#: Flux pulse amplitude.

hardware_average: bool = False#: By default hardware average will be performed.

nshots: int#: Number of executions on hardware.

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

class qibocal.protocols.flux_gate.FluxGateResults(detuning: dict[typing.Union[int, str], float] = <factory>, fitted_parameters: dict[typing.Union[int, str], list[float]] = <factory>)[source]#

Bases: Results

FluxGate outputs.

detuning: dict[Union[int, str], float]#: Detuning for every qubit.

fitted_parameters: dict[Union[int, str], list[float]]#: Fitted parameters for every qubit.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

qibocal.protocols.flux_gate.FluxGateType = dtype([('duration', '<i8'), ('prob_1', '<f8')])#: Custom dtype for FluxGate.

class qibocal.protocols.flux_gate.FluxGateData(flux_pulse_amplitude: float, data: dict[tuple[typing.Union[int, str], str], numpy.ndarray[typing.Any, numpy.dtype[dtype([('duration', '<i8'), ('prob_1', '<f8')])]]] = <factory>)[source]#

Bases: Data

FluxGate acquisition outputs.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

flux_pulse_amplitude: float#: Flux pulse amplitude.

data: dict[tuple[typing.Union[int, str], str], numpy.ndarray[typing.Any, numpy.dtype[dtype([('duration', '<i8'), ('prob_1', '<f8')])]]]#

qibocal.protocols.flux_gate._acquisition(params: FluxGateParameters, platform: Platform, targets: list[Union[int, str]]) → FluxGateData[source]#

qibocal.protocols.flux_gate._fit(data: FluxGateData) → FluxGateResults[source]#

qibocal.protocols.flux_gate._plot(data: FluxGateData, fit: FluxGateResults, target: Union[int, str])[source]#: FluxGate plots.

qibocal.protocols.qubit_power_spectroscopy module#

class qibocal.protocols.qubit_power_spectroscopy.QubitPowerSpectroscopyParameters(freq_width: int, freq_step: int, min_amp: float, max_amp: float, step_amp: float, duration: int)[source]#

Bases: Parameters

QubitPowerSpectroscopy runcard inputs.

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

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

min_amp: float#: Minimum amplitude.

max_amp: float#: Maximum amplitude.

step_amp: float#: Step amplitude.

hardware_average: bool = False#: By default hardware average will be performed.

duration: int#: Drive duration.

nshots: int#: Number of executions on hardware.

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

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

Bases: ResonatorPunchoutData

QubitPowerSpectroscopy data acquisition.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(qubit, freq, amp, signal, phase)#: Store output for single qubit.

save(path: Path)#: Store data to file.

resonator_type: str#: Resonator type.

amplitudes: dict[QubitId, float]#: Amplitudes provided by the user.

data: dict[QubitId, npt.NDArray[ResPunchoutType]]#: Raw data acquired.

qibocal.protocols.qubit_power_spectroscopy._acquisition(params: QubitPowerSpectroscopyParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → QubitPowerSpectroscopyData[source]#

Perform a qubit spectroscopy experiment with different amplitudes.

For high amplitude it should be possible to see more peaks: corresponding to the (0-2)/2 frequency and the 1-2. This experiment can be used also to test if a peak is a qubit: if it is, the peak will get larger while increasing the power of the drive.

qibocal.protocols.qubit_power_spectroscopy._fit(data: QubitPowerSpectroscopyData) → Results[source]#: Do not perform any fitting procedure.

qibocal.protocols.qubit_power_spectroscopy._plot(data: ResonatorPunchoutData, target: Union[int, str], fit: Optional[QubitSpectroscopyResults] = None)[source]#: Plot QubitPunchout.

qibocal.protocols.qubit_power_spectroscopy.qubit_power_spectroscopy = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>, update=<function _dummy_update>, two_qubit_gates=False)#: QubitPowerSpectroscopy Routine object.

qibocal.protocols.qubit_spectroscopy module#

class qibocal.protocols.qubit_spectroscopy.QubitSpectroscopyParameters(freq_width: int, freq_step: int, drive_duration: int, drive_amplitude: Optional[float] = None, hardware_average: bool = True)[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.

hardware_average: bool = True#: By default hardware average will be performed.

nshots: int#: Number of executions on hardware.

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

class qibocal.protocols.qubit_spectroscopy.QubitSpectroscopyResults(frequency: dict[typing.Union[int, str], dict[str, float]], amplitude: dict[typing.Union[int, str], float], fitted_parameters: dict[typing.Union[int, str], list[float]], chi2_reduced: dict[typing.Union[int, str], tuple[float, typing.Optional[float]]] = <factory>, error_fit_pars: dict[typing.Union[int, str], list] = <factory>)[source]#

Bases: Results

QubitSpectroscopy outputs.

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

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

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

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

chi2_reduced: dict[Union[int, str], tuple[float, Optional[float]]]#: Chi2 reduced.

error_fit_pars: dict[Union[int, str], list]#: Errors of the fit parameters.

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

Bases: ResonatorSpectroscopyData

QubitSpectroscopy acquisition outputs.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

fit_function: str = 'lorentzian'#: Fit function (optional) used for the resonance.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

phase_sign: bool = False#: Several instruments have their convention about the sign of the phase. If True, the routine will apply a minus to the phase data.

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

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

resonator_type: str#: Resonator type.

amplitudes: dict[QubitId, float]#: Amplitudes provided by the user.

data: dict[QubitId, npt.NDArray[ResSpecType]]#: Raw data acquired.

qibocal.protocols.qubit_spectroscopy._acquisition(params: QubitSpectroscopyParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → QubitSpectroscopyData[source]#: Data acquisition for qubit spectroscopy.

qibocal.protocols.qubit_spectroscopy._fit(data: QubitSpectroscopyData) → QubitSpectroscopyResults[source]#: Post-processing function for QubitSpectroscopy.

qibocal.protocols.qubit_spectroscopy._plot(data: QubitSpectroscopyData, target: Union[int, str], fit: QubitSpectroscopyResults)[source]#: Plotting function for QubitSpectroscopy.

qibocal.protocols.qubit_spectroscopy._update(results: QubitSpectroscopyResults, platform: CalibrationPlatform, target: Union[int, str])[source]#

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

qibocal.protocols.qubit_spectroscopy_ef module#

class qibocal.protocols.qubit_spectroscopy_ef.QubitSpectroscopyEFParameters(freq_width: int, freq_step: int, drive_duration: int, drive_amplitude: Optional[float] = None, hardware_average: bool = True)[source]#

Bases: QubitSpectroscopyParameters

QubitSpectroscopyEF runcard inputs.

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

hardware_average: bool = True#: By default hardware average will be performed.

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.

nshots: int#: Number of executions on hardware.

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

class qibocal.protocols.qubit_spectroscopy_ef.QubitSpectroscopyEFResults(frequency: dict[typing.Union[int, str], dict[str, float]], amplitude: dict[typing.Union[int, str], float], fitted_parameters: dict[typing.Union[int, str], list[float]], chi2_reduced: dict[typing.Union[int, str], tuple[float, typing.Optional[float]]] = <factory>, error_fit_pars: dict[typing.Union[int, str], list] = <factory>, anharmonicity: dict[typing.Union[int, str], float] = <factory>)[source]#

Bases: QubitSpectroscopyResults

QubitSpectroscopyEF outputs.

anharmonicity: dict[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], float]#

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

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

amplitude: dict[QubitId, float]#: Input drive amplitude. Same for all qubits.

fitted_parameters: dict[QubitId, list[float]]#: Raw fitting output.

chi2_reduced: dict[QubitId, tuple[float, Optional[float]]]#: Chi2 reduced.

error_fit_pars: dict[QubitId, list]#: Errors of the fit parameters.

class qibocal.protocols.qubit_spectroscopy_ef.QubitSpectroscopyEFData(resonator_type: str, amplitudes: dict[typing.Union[int, str], float], fit_function: str = 'lorentzian', phase_sign: bool = False, data: dict[typing.Union[int, str], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('signal', '<f8'), ('phase', '<f8'), ('error_signal', '<f8'), ('error_phase', '<f8')])]]] = <factory>, power_level: ~typing.Optional[~qibocal.protocols.utils.PowerLevel] = None, drive_frequencies: dict[typing.Union[int, str], float] = <factory>)[source]#

Bases: QubitSpectroscopyData

QubitSpectroscopy acquisition outputs.

drive_frequencies: dict[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], float]#

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

fit_function: str = 'lorentzian'#: Fit function (optional) used for the resonance.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

phase_sign: bool = False#: Several instruments have their convention about the sign of the phase. If True, the routine will apply a minus to the phase data.

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

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

resonator_type: str#: Resonator type.

amplitudes: dict[QubitId, float]#: Amplitudes provided by the user.

data: dict[QubitId, npt.NDArray[ResSpecType]]#: Raw data acquired.

qibocal.protocols.qubit_spectroscopy_ef.fit_ef(data: QubitSpectroscopyEFData) → QubitSpectroscopyEFResults[source]#

qibocal.protocols.qubit_spectroscopy_ef._acquisition(params: QubitSpectroscopyEFParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → QubitSpectroscopyEFData[source]#

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.

qibocal.protocols.qubit_spectroscopy_ef._plot(data: QubitSpectroscopyEFData, target: Union[int, str], fit: QubitSpectroscopyEFResults)[source]#: Plotting function for QubitSpectroscopy.

qibocal.protocols.qubit_spectroscopy_ef._update(results: QubitSpectroscopyEFResults, platform: CalibrationPlatform, target: Union[int, str])[source]#: Update w12 frequency

qibocal.protocols.qubit_spectroscopy_ef.qubit_spectroscopy_ef = Routine(acquisition=<function _acquisition>, fit=<function fit_ef>, report=<function _plot>, update=<function _update>, two_qubit_gates=False)#: QubitSpectroscopyEF Routine object.

qibocal.protocols.qutrit_classification module#

class qibocal.protocols.qutrit_classification.QutritClassificationParameters(unrolling: bool = False, classifiers_list: ~typing.Optional[list[str]] = <factory>, savedir: ~typing.Optional[str] = ' ')[source]#

Bases: SingleShotClassificationParameters

SingleShotClassification runcard inputs.

hardware_average: bool = False#: By default hardware average will be performed.

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

unrolling: bool = False#

Whether to unroll the sequences.

If True it uses sequence unrolling to deploy multiple sequences in a single instrument call.

Defaults to False.

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

nshots: int#: Number of executions on hardware.

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

class qibocal.protocols.qutrit_classification.QutritClassificationData(nshots: int, savedir: str, qubit_frequencies: dict[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], float] = <factory>, data: dict[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]] = <factory>, classifiers_list: Optional[list[str]] = <factory>)[source]#

Bases: SingleShotClassificationData

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

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

state_one(qubit: Union[int, str]) → ndarray[Any, dtype[_ScalarType_co]]#: Get state one data.

state_zero(qubit: Union[int, str]) → ndarray[Any, dtype[_ScalarType_co]]#: Get state zero data.

nshots: int#: Number of shots.

savedir: str#: Dumping folder of the classification results.

qubit_frequencies: dict[QubitId, float]#: Qubit frequencies.

data: dict[QubitId, npt.NDArray]#: Raw data acquired.

class qibocal.protocols.qutrit_classification.QutritClassificationResults[source]#

Bases: Results

Qutrit classification results

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

qibocal.protocols.qutrit_classification._acquisition(params: QutritClassificationParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → QutritClassificationData[source]#

This Routine prepares the qubits in 0,1 and 2 states and measures their respective I, Q values.

Parameters:

nshots (int) – number of times the pulse sequence will be repeated.
classifiers (list) – list of classifiers, the available ones are: - naive_bayes - nn - random_forest - decision_tree
["naive_bayes"]. (The default value is) –
savedir (str) – Dumping folder of the classification results.
given (If not) –
one. (the dumping folder will be the report) –
relaxation_time (float) – Relaxation time.

qibocal.protocols.qutrit_classification._fit(data: QutritClassificationData) → QutritClassificationResults[source]#

qibocal.protocols.qutrit_classification._plot(data: QutritClassificationData, target: Union[int, str], fit: QutritClassificationResults)[source]#

qibocal.protocols.qutrit_classification.qutrit_classification = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>, update=<function _dummy_update>, two_qubit_gates=False)#: Qutrit classification Routine object.

qibocal.protocols.readout_characterization module#

class qibocal.protocols.readout_characterization.ReadoutCharacterizationParameters(delay: float = 0)[source]#

Bases: Parameters

ReadoutCharacterization runcard inputs.

delay: float = 0#: Delay between readouts, could account for resonator deplation or not [ns].

hardware_average: bool = False#: By default hardware average will be performed.

nshots: int#: Number of executions on hardware.

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

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

Bases: Results

ReadoutCharacterization outputs.

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

assignment_fidelity: dict[Union[int, str], float]#: Assignment fidelity.

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

effective_temperature: dict[Union[int, str], list[float]]#: Effective qubit temperature.

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

Lambda_M2: dict[Union[int, str], float]#: Mapping between the outcome after the measurement and it still being that outcame after another measurement

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

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

class qibocal.protocols.readout_characterization.ReadoutCharacterizationData(qubit_frequencies: dict[typing.Union[int, str], float] = <factory>, delay: float = 0, data: dict[tuple, numpy.ndarray[typing.Any, numpy.dtype[dtype([('i', '<f8'), ('q', '<f8')])]]] = <factory>, samples: dict[tuple, numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]] = <factory>)[source]#

Bases: Data

ReadoutCharacterization acquisition outputs.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

qubit_frequencies: dict[Union[int, str], float]#: Qubit frequencies.

delay: float = 0#: Delay between readouts [ns].

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

samples: dict[tuple, numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]]#: Raw data acquired.

qibocal.protocols.readout_characterization._acquisition(params: ReadoutCharacterizationParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → ReadoutCharacterizationData[source]#: Data acquisition for resonator spectroscopy.

qibocal.protocols.readout_characterization._fit(data: ReadoutCharacterizationData) → ReadoutCharacterizationResults[source]#: Post-processing function for ReadoutCharacterization.

qibocal.protocols.readout_characterization._plot(data: ReadoutCharacterizationData, fit: ReadoutCharacterizationResults, target: Union[int, str])[source]#: Plotting function for ReadoutCharacterization.

qibocal.protocols.readout_characterization._update(results: ReadoutCharacterizationResults, platform: CalibrationPlatform, target: Union[int, str])[source]#

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

qibocal.protocols.readout_mitigation_matrix module#

class qibocal.protocols.readout_mitigation_matrix.ReadoutMitigationMatrixParameters(nshots: Optional[int] = None, relaxation_time: Optional[int] = None)[source]#

Bases: Parameters

ReadoutMitigationMatrix matrix inputs.

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

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

hardware_average: bool = False#: By default hardware average will be performed.

class qibocal.protocols.readout_mitigation_matrix.ReadoutMitigationMatrixResults(readout_mitigation_matrix: dict[tuple[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ...], numpy.ndarray[typing.Any, numpy.dtype[numpy.float64]]] = <factory>)[source]#

Bases: Results

readout_mitigation_matrix: dict[tuple[Union[int, str], ...], numpy.ndarray[Any, numpy.dtype[numpy.float64]]]#: Readout mitigation matrices (inverse of measurement matrix).

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

qibocal.protocols.readout_mitigation_matrix.ReadoutMitigationMatrixId#

Data identifier for single list of qubits.

Tuple[QubitId, …] is the qubits which have been passed on as parameters. The two strings represents the expected state and the measured state.

alias of tuple[Tuple[Union[int, str][Union[int, str]], …], str, str]

class qibocal.protocols.readout_mitigation_matrix.ReadoutMitigationMatrixData(qubit_list: list[typing.Union[int, str]], nshots: int, data: dict[tuple[typing.Tuple[typing.Union[int, str], ...], str, str], float] = <factory>)[source]#

Bases: Data

ReadoutMitigationMatrix acquisition outputs.

qubit_list: list[Union[int, str]]#: List of qubit ids

nshots: int#: Number of shots

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

data: dict[tuple[Tuple[Union[int, str], ...], str, str], float]#: Raw data acquited.

qibocal.protocols.readout_mitigation_matrix._acquisition(params: ReadoutMitigationMatrixParameters, platform: CalibrationPlatform, targets: list[list[Union[int, str]]]) → ReadoutMitigationMatrixData[source]#

qibocal.protocols.readout_mitigation_matrix._fit(data: ReadoutMitigationMatrixData) → ReadoutMitigationMatrixResults[source]#: Post processing for readout mitigation matrix protocol.

qibocal.protocols.readout_mitigation_matrix._plot(data: ReadoutMitigationMatrixData, fit: ReadoutMitigationMatrixResults, target: list[Union[int, str]])[source]#: Plotting function for readout mitigation matrix.

qibocal.protocols.readout_mitigation_matrix._update(results: ReadoutMitigationMatrixData, platform: CalibrationPlatform, target: list[Union[int, str]])[source]#

qibocal.protocols.readout_mitigation_matrix.readout_mitigation_matrix = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>, update=<function _update>, two_qubit_gates=False)#: Readout mitigation matrix protocol.

qibocal.protocols.resonator_punchout module#

class qibocal.protocols.resonator_punchout.ResonatorPunchoutParameters(freq_width: int, freq_step: int, min_amp: float, max_amp: float, step_amp: float)[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: float#: Minimum amplitude multiplicative factor.

max_amp: float#: Maximum amplitude multiplicative factor.

step_amp: float#: Step amplitude multiplicative factor.

hardware_average: bool = False#: By default hardware average will be performed.

nshots: int#: Number of executions on hardware.

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

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

Bases: Results

ResonatorPunchout outputs.

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

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

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

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

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

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

Bases: Data

ResonatorPunchout data acquisition.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

save(path: Path)#: Store data to file.

resonator_type: str#: Resonator type.

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

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

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

qibocal.protocols.resonator_punchout._acquisition(params: ResonatorPunchoutParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → ResonatorPunchoutData[source]#: Data acquisition for Punchout over amplitude.

qibocal.protocols.resonator_punchout._fit(data: ResonatorPunchoutData, fit_type='amp') → ResonatorPunchoutResults[source]#: Fit frequency and attenuation at high and low power for a given resonator.

qibocal.protocols.resonator_punchout._plot(data: ResonatorPunchoutData, target: Union[int, str], fit: ResonatorPunchoutResults = None)[source]#: Plotting function for ResonatorPunchout.

qibocal.protocols.resonator_punchout._update(results: ResonatorPunchoutResults, platform: CalibrationPlatform, target: Union[int, str])[source]#

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

qibocal.protocols.resonator_spectroscopy module#

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

class qibocal.protocols.resonator_spectroscopy.ResonatorSpectroscopyFit(function: Callable, fit: Callable, chi2: Callable, values: Callable, errors: Callable, plot: Callable)[source]#

Bases: object

ResonatorSpectroscopy fit.

function: Callable#: Routine function to fit data with a model.

fit: Callable#: Fit function used for the resonance.

chi2: Callable#: Chi2 reduced.

values: Callable#: Extract values from data.

errors: Callable#: Extract errors from data.

plot: Callable#: Plotting function for ResonatorSpectroscopy.

qibocal.protocols.resonator_spectroscopy.FITS = {'lorentzian': ResonatorSpectroscopyFit(function=<function lorentzian>, fit=<function lorentzian_fit>, chi2=<function chi2_reduced>, values=<function <lambda>>, errors=<function <lambda>>, plot=<function spectroscopy_plot>), 's21': ResonatorSpectroscopyFit(function=<function s21>, fit=<function s21_fit>, chi2=<function chi2_reduced_complex>, values=<function <lambda>>, errors=<function <lambda>>, plot=<function s21_spectroscopy_plot>)}#: Dictionary of available fitting routines for ResonatorSpectroscopy.

class qibocal.protocols.resonator_spectroscopy.ResonatorSpectroscopyParameters(freq_width: int, freq_step: int, power_level: Union[PowerLevel, str], fit_function: str = 'lorentzian', phase_sign: bool = True, amplitude: Optional[float] = None, hardware_average: bool = True)[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: Union[PowerLevel, str]#: 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.

fit_function: str = 'lorentzian'#: Routine function (lorentzian or s21) to fit data with a model.

phase_sign: bool = True#: Several instruments have their convention about the sign of the phase. If True, the routine will apply a minus to the phase data.

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

hardware_average: bool = True#: By default hardware average will be performed.

nshots: int#: Number of executions on hardware.

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

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

Bases: Results

ResonatorSpectroscopy outputs.

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

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

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

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

error_fit_pars: dict[Union[int, str], list]#: Errors of the fit parameters.

chi2_reduced: dict[Union[int, str], tuple[float, Optional[float]]]#: Chi2 reduced.

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

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

Bases: Data

Data structure for resonator spectroscopy with attenuation.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

save(path: Path)#: Store data to file.

resonator_type: str#: Resonator type.

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

fit_function: str = 'lorentzian'#: Fit function (optional) used for the resonance.

phase_sign: bool = False#: Several instruments have their convention about the sign of the phase. If True, the routine will apply a minus to the phase data.

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

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

qibocal.protocols.resonator_spectroscopy._acquisition(params: ResonatorSpectroscopyParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → ResonatorSpectroscopyData[source]#: Data acquisition for resonator spectroscopy.

qibocal.protocols.resonator_spectroscopy._fit(data: ResonatorSpectroscopyData) → ResonatorSpectroscopyResults[source]#: Post-processing function for ResonatorSpectroscopy.

qibocal.protocols.resonator_spectroscopy._plot(data: ResonatorSpectroscopyData, target: Union[int, str], fit: ResonatorSpectroscopyResults)[source]#: Plotting function for ResonatorSpectroscopy.

qibocal.protocols.resonator_spectroscopy._update(results: ResonatorSpectroscopyResults, platform: CalibrationPlatform, target: Union[int, str])[source]#

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

qibocal.protocols.resonator_utils module#

qibocal.protocols.resonator_utils.PHASES_THRESHOLD_PERCENTAGE = 80#

pi circle.

Type:: Threshold percentage to ensure the phase data covers a significant portion of the full 2
Type:: math

qibocal.protocols.resonator_utils.STD_DEV_GAUSSIAN_KERNEL = 30#: Standard deviation for the Gaussian kernel.

qibocal.protocols.resonator_utils.PHASE_ELEMENTS = 5#: Number of values to better guess :math:` heta` (in rad) in the phase fit function.

qibocal.protocols.resonator_utils.cable_delay(frequencies: ndarray[Any, dtype[_ScalarType_co]], phases: ndarray[Any, dtype[_ScalarType_co]], num_points: int) → float[source]#

Evaluates the cable delay :math:` au` (in s).

The cable delay :math:` au` (in s) is caused by the length of the cable and the finite speed of light. This is estimated fitting a first-grade polynomial fit of the phases (in rad) as a function of the frequencies (in Hz), and extracting the angular coefficient, which is then expressed in seconds.

The num_points is used to select how many points should be fitted, from both the start and the end of the frequency range.

qibocal.protocols.resonator_utils.remove_cable_delay(frequencies: ndarray[Any, dtype[_ScalarType_co]], z: ndarray[Any, dtype[_ScalarType_co]], tau: float) → ndarray[Any, dtype[_ScalarType_co]][source]#

Corrects the cable delay :math:` au` (in s).

The cable delay :math:` au` (in s) is removed from the scattering matrix element array z by performing an exponential product which also depends from the frequencies (in Hz).

qibocal.protocols.resonator_utils.circle_fit(z: ndarray[Any, dtype[_ScalarType_co]]) → tuple[complex, float][source]#

Fits the circle of a scattering matrix element array.

The circle fit exploits the algebraic fit described in “Efficient and robust analysis of complex scattering data under noise in microwave resonators” (https://doi.org/10.1063/1.4907935) by S. Probst et al and “The physics of superconducting microwave resonators” (https://doi.org/10.7907/RAT0-VM75) by J. Gao.

The function, from the scattering matrix element array, evaluates the center coordinates x_c and y_c and the radius of the circle r_0.

qibocal.protocols.resonator_utils.phase_fit(frequencies: ndarray[Any, dtype[_ScalarType_co]], phases: ndarray[Any, dtype[_ScalarType_co]]) → ndarray[Any, dtype[_ScalarType_co]][source]#

Fits the phase response of a resonator.

The phase fit firstly ensure the phase data (in rad) covers a significant portion of the full 2 $\pi$ circle evaluating a roll_off. If the data do not cover a full circle it is possible to increase the frequency span around the resonance. Data are smoothed using a Gaussian filter and the derivative is evaluated while initial guesses for the parameters (resonance_guess (in Hz)), q_loaded_guess, tau_guess (in s) and theta_guess (in rad) are computed with frequencies (in Hz).

The parameter estimation is done through an iterative least squares process to optimize the model parameters. The defined functions: residuals_q_loaded, residuals_resonance_theta residuals_resonance_theta, residuals_tau, residuals_resonance_q_loaded, residuals_full take the parameters to be fitted and return the residuals calculated by subtracting the phase centered model from the phase data (in rad).

qibocal.protocols.resonator_utils.phase_dist(phases: ndarray[Any, dtype[_ScalarType_co]]) → ndarray[Any, dtype[_ScalarType_co]][source]#: Maps phases (in rad) [-2pi, 2pi] to phase distance on circle [0, pi].

qibocal.protocols.resonator_utils.phase_centered(frequencies: ndarray[Any, dtype[_ScalarType_co]], resonance: float, q_loaded: float, theta: float, tau: float = 0.0) → ndarray[Any, dtype[_ScalarType_co]][source]#

Evaluates the phase (in rad) response of a resonator.

The phase centered evaluates the phase angle (in rad) of a circle centered around the origin accounting for a phase offset :math:` heta` (in rad), a linear background slope :math: 2pi ` au` (in s) (frequencies (in Hz) - resonance (in Hz)) (if needed) and a dependency on the q_loaded.

qibocal.protocols.resonator_utils.periodic_boundary(angle: float) → float[source]#: Maps arbitrary angle (in rad) to interval [-np.pi, np.pi).

qibocal.protocols.state_tomography module#

qibocal.protocols.state_tomography.BASIS = ['X', 'Y', 'Z']#: Single qubit measurement basis.

qibocal.protocols.state_tomography.CIRCUIT_PATH = 'circuit.json'#: Path where circuit is stored.

class qibocal.protocols.state_tomography.StateTomographyParameters(circuit: Optional[Union[str, Circuit]] = None)[source]#

Bases: Parameters

Tomography input parameters

circuit: Optional[Union[str, Circuit]] = None#

Circuit to prepare initial state.

It can also be provided the path to a json file containing a serialized circuit.

hardware_average: bool = False#: By default hardware average will be performed.

nshots: int#: Number of executions on hardware.

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

qibocal.protocols.state_tomography.TomographyType = dtype([('samples', '<i8')])#: Custom dtype for tomography.

class qibocal.protocols.state_tomography.StateTomographyData(targets: dict[typing.Union[int, str], int], circuit: ~qibo.models.circuit.Circuit, data: dict[tuple[typing.Union[int, str], str], numpy.int64] = <factory>)[source]#

Bases: Data

Tomography data

targets: dict[Union[int, str], int]#: Store targets order.

circuit: Circuit#: Circuit where tomography will be executed.

data: dict[tuple[Union[int, str], str], numpy.int64]#: Hardware measurements.

property params: dict#: Convert non-arrays attributes into dict.

save(path)[source]#: Store data to file.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

class qibocal.protocols.state_tomography.StateTomographyResults(measured_density_matrix_real: dict[Union[int, str], list], measured_density_matrix_imag: dict[Union[int, str], list], target_density_matrix_real: dict[Union[int, str], list], target_density_matrix_imag: dict[Union[int, str], list], fidelity: dict[Union[int, str], float])[source]#

Bases: Results

Tomography results

measured_density_matrix_real: dict[Union[int, str], list]#: Real part of measured density matrix.

measured_density_matrix_imag: dict[Union[int, str], list]#: Imaginary part of measured density matrix.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

target_density_matrix_real: dict[Union[int, str], list]#: Real part of exact density matrix.

target_density_matrix_imag: dict[Union[int, str], list]#: Imaginary part of exact density matrix.

fidelity: dict[Union[int, str], float]#: State fidelity.

qibocal.protocols.state_tomography._acquisition(params: StateTomographyParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → StateTomographyData[source]#: Acquisition protocol for single qubit state tomography experiment.

qibocal.protocols.state_tomography._fit(data: StateTomographyData) → StateTomographyResults[source]#: Post-processing for State tomography.

qibocal.protocols.state_tomography.plot_parallelogram(a, e, pos_x, pos_y, **options)[source]#: Plotting single histogram in 3d plot.

qibocal.protocols.state_tomography.plot_rho(fig, zz, trace_options, figure_options, showlegend=None)[source]#: Plot density matrix

qibocal.protocols.state_tomography.plot_reconstruction(ideal, measured)[source]#: Plot 3D plot with reconstruction of ideal and measured density matrix.

qibocal.protocols.state_tomography._plot(data: StateTomographyData, fit: StateTomographyResults, target: Union[int, str])[source]#: Plotting for state tomography

qibocal.protocols.two_qubit_state_tomography module#

qibocal.protocols.two_qubit_state_tomography.SIMULATED_DENSITY_MATRIX = 'ideal'#: Filename for simulated density matrix.

qibocal.protocols.two_qubit_state_tomography.TomographyType = dtype([('frequencies', '<i8'), ('simulation_probabilities', '<f8')])#: Custom dtype for tomography.

class qibocal.protocols.two_qubit_state_tomography.StateTomographyData(data: dict[tuple[typing.Union[int, str], typing.Union[int, str], str, str], numpy.int64] = <factory>, ideal: dict[tuple[typing.Union[int, str], typing.Union[int, str]], numpy.ndarray] = <factory>, simulated: ~typing.Optional[~qibo.result.QuantumState] = None)[source]#

Bases: Data

Tomography data.

data: dict[tuple[Union[int, str], Union[int, str], str, str], numpy.int64]#

ideal: dict[tuple[Union[int, str], Union[int, str]], numpy.ndarray]#

simulated: Optional[QuantumState] = None#

save(path)[source]#: Store data to file.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property pairs#: Access qubit pairs ordered alphanumerically from data structure.

property params: dict#: Convert non-arrays attributes into dict.

property qubits#: Access qubits from data structure.

register_qubit(dtype, data_keys, data_dict)#

Store output for single qubit.

Parameters:

data_keys (tuple) – Keys of Data.data.
data_dict (dict) – The keys are the fields of dtype and
arrays. (the values are the related) –

class qibocal.protocols.two_qubit_state_tomography.StateTomographyResults(measured_raw_density_matrix_real: dict[tuple[typing.Union[int, str], typing.Union[int, str]], list] = <factory>, measured_raw_density_matrix_imag: dict[tuple[typing.Union[int, str], typing.Union[int, str]], list] = <factory>, measured_density_matrix_real: dict[tuple[typing.Union[int, str], typing.Union[int, str]], list] = <factory>, measured_density_matrix_imag: dict[tuple[typing.Union[int, str], typing.Union[int, str]], list] = <factory>, fidelity: dict[typing.Union[int, str], float] = <factory>)[source]#

Bases: Results

Tomography results.

measured_raw_density_matrix_real: dict[tuple[Union[int, str], Union[int, str]], list]#: Real part of measured density matrix before projecting.

measured_raw_density_matrix_imag: dict[tuple[Union[int, str], Union[int, str]], list]#: Imaginary part of measured density matrix before projecting.

measured_density_matrix_real: dict[tuple[Union[int, str], Union[int, str]], list]#: Real part of measured density matrix after projecting.

measured_density_matrix_imag: dict[tuple[Union[int, str], Union[int, str]], list]#: Imaginary part of measured density matrix after projecting.

fidelity: dict[Union[int, str], float]#: State fidelity.

_to_json(path: Path, filename: str)#: Helper function to dump to json.

_to_npz(path: Path, filename: str)#: Helper function to use np.savez while converting keys into strings.

static load_data(path: Path, filename: str)#: Load data stored in a npz file.

static load_params(path: Path, filename: str)#: Load parameters stored in a json file.

property params: dict#: Convert non-arrays attributes into dict.

save(path: Path)#: Store results to file.

qibocal.protocols.two_qubit_state_tomography._acquisition(params: StateTomographyParameters, platform: CalibrationPlatform, targets: list[tuple[Union[int, str], Union[int, str]]]) → StateTomographyData[source]#: Acquisition protocol for two qubit state tomography experiment.

qibocal.protocols.two_qubit_state_tomography.rotation_matrix(basis)[source]#

Matrix of the gate implementing the rotation to the given basis.

Parameters:: basis (str) – One of Pauli basis: X, Y or Z.

qibocal.protocols.two_qubit_state_tomography.project_psd(matrix)[source]#: Project matrix to the space of positive semidefinite matrices.

qibocal.protocols.two_qubit_state_tomography._fit(data: StateTomographyData) → StateTomographyResults[source]#

Post-processing for two qubit state tomography.

Uses a linear inversion algorithm to reconstruct the density matrix from measurements, with the following steps: 1. Construct a linear transformation M, from density matrix to Born-probabilities in the space of all two-qubit measurement bases (in our case XX, XY, XZ, YX, YY, YZ, ZX, ZY, ZZ). 2. Invert M to get the transformation from Born-probabilities to density matrices. 3. Calculate vector of Born-probabilities from experimental measurements (frequencies). 4. Map this vector to a density matrix (measured_raw_density_matrix) using the inverse of M from step 2. 5. Project the calculated density matrix to the space of positive semidefinite matrices (measured_density_matrix) using the function project_psd.

qibocal.protocols.two_qubit_state_tomography.plot_measurements(data: StateTomographyData, target: tuple[Union[int, str], Union[int, str]])[source]#: Plot histogram of measurements in the 9 different basis.

qibocal.protocols.two_qubit_state_tomography._plot(data: StateTomographyData, fit: StateTomographyResults, target: tuple[Union[int, str], Union[int, str]])[source]#: Plotting for two qubit state tomography.

qibocal.protocols.utils module#

qibocal.protocols.utils.HBAR = 1.0545718176461565e-34#: Chi2 output when errors list contains zero elements

qibocal.protocols.utils.CONFIDENCE_INTERVAL_FIRST_MASK = 99#: Confidence interval used to mask flux data.

qibocal.protocols.utils.CONFIDENCE_INTERVAL_SECOND_MASK = 70#: Confidence interval used to clean outliers.

qibocal.protocols.utils.DELAY_FIT_PERCENTAGE = 10#: Percentage of the first and last points used to fit the cable delay.

class qibocal.protocols.utils.DcFilteredConfig(*, kind: Literal['dc-filter'] = 'dc-filter', offset: float, filter: list)[source]#

Bases: Config

Dummy config for dc with filters.

Required by cryoscope protocol.

kind: Literal['dc-filter']#

offset: float#

filter: list#

_abc_impl = <_abc._abc_data object>#

_calculate_keys(*args: Any, **kwargs: Any) → Any#

_check_frozen(name: str, value: Any) → None#

_copy_and_set_values(*args: Any, **kwargs: Any) → Any#

classmethod _get_value(*args: Any, **kwargs: Any) → Any#

_iter(*args: Any, **kwargs: Any) → Any#

classmethod construct(_fields_set: set[str] | None = None, **values: Any) → Self#

Returns a copy of the model.

!!! warning “Deprecated”: This method is now deprecated; use model_copy instead.

If you need include or exclude, use:

`python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) `

Parameters:

include – Optional set or mapping specifying which fields to include in the copied model.
exclude – Optional set or mapping specifying which fields to exclude in the copied model.
update – Optional dictionary of field-value pairs to override field values in the copied model.
deep – If True, the values of fields that are Pydantic models will be deep-copied.

Returns:

A copy of the model with included, excluded and updated fields as specified.

dict(*, include: Optional[Union[Set[int], Set[str], Mapping[int, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]], Mapping[str, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]]]] = None, exclude: Optional[Union[Set[int], Set[str], Mapping[int, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]], Mapping[str, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]]]] = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False) → Dict[str, Any]#

classmethod from_orm(obj: Any) → Self#

json(*, include: Optional[Union[Set[int], Set[str], Mapping[int, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]], Mapping[str, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]]]] = None, exclude: Optional[Union[Set[int], Set[str], Mapping[int, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]], Mapping[str, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]]]] = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, encoder: Optional[Callable[[Any], Any]] = PydanticUndefined, models_as_dict: bool = PydanticUndefined, **dumps_kwargs: Any) → str#

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}#

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'frozen': True}#: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self#

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed.

!!! note: model_construct() generally respects the model_config.extra setting on the provided model. That is, if model_config.extra == ‘allow’, then all extra passed values are added to the model instance’s __dict__ and __pydantic_extra__ fields. If model_config.extra == ‘ignore’ (the default), then all extra passed values are ignored. Because no validation is performed with a call to model_construct(), having model_config.extra == ‘forbid’ does not result in an error if extra values are passed, but they will be ignored.

Parameters:

_fields_set – A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute. Otherwise, the field names from the values argument will be used.
values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

model_copy(*, update: Optional[Mapping[str, Any]] = None, deep: bool = False) → Self#

Usage docs: https://docs.pydantic.dev/2.10/concepts/serialization/#model_copy

Returns a copy of the model.

Parameters:

update – Values to change/add in the new model. Note: the data is not validated before creating the new model. You should trust this data.
deep – Set to True to make a deep copy of the model.

Returns:

New model instance.

model_dump(*, mode: Union[Literal['json', 'python'], str] = 'python', include: Optional[Union[Set[int], Set[str], Mapping[int, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]], Mapping[str, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]]]] = None, exclude: Optional[Union[Set[int], Set[str], Mapping[int, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]], Mapping[str, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]]]] = None, context: Any | None = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, round_trip: bool = False, warnings: Union[bool, Literal['none', 'warn', 'error']] = True, serialize_as_any: bool = False) → dict[str, Any]#

Usage docs: https://docs.pydantic.dev/2.10/concepts/serialization/#modelmodel_dump

Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.

Parameters:

mode – The mode in which to_python should run. If mode is ‘json’, the output will only contain JSON serializable types. If mode is ‘python’, the output may contain non-JSON-serializable Python objects.
include – A set of fields to include in the output.
exclude – A set of fields to exclude from the output.
context – Additional context to pass to the serializer.
by_alias – Whether to use the field’s alias in the dictionary key if defined.
exclude_unset – Whether to exclude fields that have not been explicitly set.
exclude_defaults – Whether to exclude fields that are set to their default value.
exclude_none – Whether to exclude fields that have a value of None.
round_trip – If True, dumped values should be valid as input for non-idempotent types such as Json[T].
warnings – How to handle serialization errors. False/”none” ignores them, True/”warn” logs errors, “error” raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
serialize_as_any – Whether to serialize fields with duck-typing serialization behavior.

Returns:

A dictionary representation of the model.

model_dump_json(*, indent: int | None = None, include: Optional[Union[Set[int], Set[str], Mapping[int, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]], Mapping[str, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]]]] = None, exclude: Optional[Union[Set[int], Set[str], Mapping[int, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]], Mapping[str, Union[Set[int], Set[str], Mapping[int, Union[IncEx, bool]], Mapping[str, Union[IncEx, bool]], bool]]]] = None, context: Any | None = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, round_trip: bool = False, warnings: Union[bool, Literal['none', 'warn', 'error']] = True, serialize_as_any: bool = False) → str#

Usage docs: https://docs.pydantic.dev/2.10/concepts/serialization/#modelmodel_dump_json

Generates a JSON representation of the model using Pydantic’s to_json method.

Parameters:

indent – Indentation to use in the JSON output. If None is passed, the output will be compact.
include – Field(s) to include in the JSON output.
exclude – Field(s) to exclude from the JSON output.
context – Additional context to pass to the serializer.
by_alias – Whether to serialize using field aliases.
exclude_unset – Whether to exclude fields that have not been explicitly set.
exclude_defaults – Whether to exclude fields that are set to their default value.
exclude_none – Whether to exclude fields that have a value of None.
round_trip – If True, dumped values should be valid as input for non-idempotent types such as Json[T].
warnings – How to handle serialization errors. False/”none” ignores them, True/”warn” logs errors, “error” raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
serialize_as_any – Whether to serialize fields with duck-typing serialization behavior.

Returns:

A JSON string representation of the model.

property model_extra: dict[str, Any] | None#

Get extra fields set during validation.

Returns:: A dictionary of extra fields, or None if config.extra is not set to “allow”.

model_fields: ClassVar[dict[str, FieldInfo]] = {'filter': FieldInfo(annotation=list, required=True), 'kind': FieldInfo(annotation=Literal['dc-filter'], required=False, default='dc-filter'), 'offset': FieldInfo(annotation=float, required=True)}#

property model_fields_set: set[str]#

Returns the set of fields that have been explicitly set on this model instance.

Returns:

A set of strings representing the fields that have been set,: i.e. that were not filled from defaults.

classmethod model_json_schema(by_alias: bool = True, ref_template: str = '#/$defs/{model}', schema_generator: type[pydantic.json_schema.GenerateJsonSchema] = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: ~typing.Literal['validation', 'serialization'] = 'validation') → dict[str, Any]#

Generates a JSON schema for a model class.

Parameters:

by_alias – Whether to use attribute aliases or not.
ref_template – The reference template.
schema_generator – To override the logic used to generate the JSON schema, as a subclass of GenerateJsonSchema with your desired modifications
mode – The mode in which to generate the schema.

Returns:

The JSON schema for the given model class.

classmethod model_parametrized_name(params: tuple[type[Any], ...]) → str#

Compute the class name for parametrizations of generic classes.

This method can be overridden to achieve a custom naming scheme for generic BaseModels.

Parameters:: params – Tuple of types of the class. Given a generic class Model with 2 type variables and a concrete model Model[str, int], the value (str, int) would be passed to params.
Returns:: String representing the new class where params are passed to cls as type variables.
Raises:: TypeError – Raised when trying to generate concrete names for non-generic models.

model_post_init(_BaseModel__context: Any) → None#: Override this method to perform additional initialization after __init__ and model_construct. This is useful if you want to do some validation that requires the entire model to be initialized.

classmethod model_rebuild(*, force: bool = False, raise_errors: bool = True, _parent_namespace_depth: int = 2, _types_namespace: MappingNamespace | None = None) → bool | None#

Try to rebuild the pydantic-core schema for the model.

This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.

Parameters:

force – Whether to force the rebuilding of the model schema, defaults to False.
raise_errors – Whether to raise errors, defaults to True.
_parent_namespace_depth – The depth level of the parent namespace, defaults to 2.
_types_namespace – The types namespace, defaults to None.

Returns:

Returns None if the schema is already “complete” and rebuilding was not required. If rebuilding _was_ required, returns True if rebuilding was successful, otherwise False.

classmethod model_validate(obj: Any, *, strict: bool | None = None, from_attributes: bool | None = None, context: Any | None = None) → Self#

Validate a pydantic model instance.

Parameters:

obj – The object to validate.
strict – Whether to enforce types strictly.
from_attributes – Whether to extract data from object attributes.
context – Additional context to pass to the validator.

Raises:

ValidationError – If the object could not be validated.

Returns:

The validated model instance.

classmethod model_validate_json(json_data: str | bytes | bytearray, *, strict: bool | None = None, context: Any | None = None) → Self#

Usage docs: https://docs.pydantic.dev/2.10/concepts/json/#json-parsing

Validate the given JSON data against the Pydantic model.

Parameters:

json_data – The JSON data to validate.
strict – Whether to enforce types strictly.
context – Extra variables to pass to the validator.

Returns:

The validated Pydantic model.

Raises:

ValidationError – If json_data is not a JSON string or the object could not be validated.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None) → Self#

Validate the given object with string data against the Pydantic model.

Parameters:

obj – The object containing string data to validate.
strict – Whether to enforce types strictly.
context – Extra variables to pass to the validator.

Returns:

The validated Pydantic model.

classmethod parse_file(path: str | Path, *, content_type: str | None = None, encoding: str = 'utf8', proto: DeprecatedParseProtocol | None = None, allow_pickle: bool = False) → Self#

classmethod parse_obj(obj: Any) → Self#

classmethod parse_raw(b: str | bytes, *, content_type: str | None = None, encoding: str = 'utf8', proto: DeprecatedParseProtocol | None = None, allow_pickle: bool = False) → Self#

classmethod schema(by_alias: bool = True, ref_template: str = '#/$defs/{model}') → Dict[str, Any]#

classmethod schema_json(*, by_alias: bool = True, ref_template: str = '#/$defs/{model}', **dumps_kwargs: Any) → str#

classmethod update_forward_refs(**localns: Any) → None#

classmethod validate(value: Any) → Self#

qibocal.protocols.utils.effective_qubit_temperature(prob_0: ndarray[Any, dtype[_ScalarType_co]], prob_1: ndarray[Any, dtype[_ScalarType_co]], qubit_frequency: float, nshots: int)[source]#

Calculates the qubit effective temperature.

The formula used is the following one:

kB Teff = - hbar qubit_freq / ln(prob_1/prob_0)

Parameters:

prob_0 (NDArray) – population 0 samples
prob_1 (NDArray) – population 1 samples
qubit_frequency (float) – frequency of qubit
nshots (int) – number of shots

Returns:

effective temperature error (float): error on effective temperature

Return type:

temp (float)

qibocal.protocols.utils.calculate_frequencies(results, ro_pulses)[source]#

Calculates outcome frequencies from individual shots. :param results: return of execute_pulse_sequence :type results: dict :param qubit_list: list of qubit ids executed in pulse sequence. :type qubit_list: list

Returns:: dictionary containing frequencies.

class qibocal.protocols.utils.PowerLevel(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]#

Bases: str, Enum

Power Regime for Resonator Spectroscopy

high = 'high'#

low = 'low'#

_generate_next_value_(start, count, last_values)#

Generate the next value when not given.

name: the name of the member start: the initial start value or None count: the number of existing members last_values: the list of values assigned

_new_member_(**kwargs)#: Create and return a new object. See help(type) for accurate signature.

_use_args_ = True#

_member_names_ = ['high', 'low']#

_member_map_ = {'high': PowerLevel.high, 'low': PowerLevel.low}#

_value2member_map_ = {'high': PowerLevel.high, 'low': PowerLevel.low}#

_unhashable_values_ = []#

_member_type_#: alias of str

_value_repr_()#: Return repr(self).

capitalize()#

Return a capitalized version of the string.

More specifically, make the first character have upper case and the rest lower case.

casefold()#: Return a version of the string suitable for caseless comparisons.

center(width, fillchar=' ', /)#

Return a centered string of length width.

Padding is done using the specified fill character (default is a space).

count(sub[, start[, end]]) → int#: Return the number of non-overlapping occurrences of substring sub in string S[start:end]. Optional arguments start and end are interpreted as in slice notation.

encode(encoding='utf-8', errors='strict')#

Encode the string using the codec registered for encoding.

encoding: The encoding in which to encode the string.
errors: The error handling scheme to use for encoding errors. The default is ‘strict’ meaning that encoding errors raise a UnicodeEncodeError. Other possible values are ‘ignore’, ‘replace’ and ‘xmlcharrefreplace’ as well as any other name registered with codecs.register_error that can handle UnicodeEncodeErrors.

endswith(suffix[, start[, end]]) → bool#: Return True if S ends with the specified suffix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. suffix can also be a tuple of strings to try.

expandtabs(tabsize=8)#

Return a copy where all tab characters are expanded using spaces.

If tabsize is not given, a tab size of 8 characters is assumed.

find(sub[, start[, end]]) → int#

Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation.

Return -1 on failure.

format(*args, **kwargs) → str#: Return a formatted version of S, using substitutions from args and kwargs. The substitutions are identified by braces (‘{’ and ‘}’).

format_map(mapping) → str#: Return a formatted version of S, using substitutions from mapping. The substitutions are identified by braces (‘{’ and ‘}’).

index(sub[, start[, end]]) → int#

Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation.

Raises ValueError when the substring is not found.

isalnum()#

Return True if the string is an alpha-numeric string, False otherwise.

A string is alpha-numeric if all characters in the string are alpha-numeric and there is at least one character in the string.

isalpha()#

Return True if the string is an alphabetic string, False otherwise.

A string is alphabetic if all characters in the string are alphabetic and there is at least one character in the string.

isascii()#

Return True if all characters in the string are ASCII, False otherwise.

ASCII characters have code points in the range U+0000-U+007F. Empty string is ASCII too.

isdecimal()#

Return True if the string is a decimal string, False otherwise.

A string is a decimal string if all characters in the string are decimal and there is at least one character in the string.

isdigit()#

Return True if the string is a digit string, False otherwise.

A string is a digit string if all characters in the string are digits and there is at least one character in the string.

isidentifier()#

Return True if the string is a valid Python identifier, False otherwise.

Call keyword.iskeyword(s) to test whether string s is a reserved identifier, such as “def” or “class”.

islower()#

Return True if the string is a lowercase string, False otherwise.

A string is lowercase if all cased characters in the string are lowercase and there is at least one cased character in the string.

isnumeric()#

Return True if the string is a numeric string, False otherwise.

A string is numeric if all characters in the string are numeric and there is at least one character in the string.

isprintable()#

Return True if the string is printable, False otherwise.

A string is printable if all of its characters are considered printable in repr() or if it is empty.

isspace()#

Return True if the string is a whitespace string, False otherwise.

A string is whitespace if all characters in the string are whitespace and there is at least one character in the string.

istitle()#

Return True if the string is a title-cased string, False otherwise.

In a title-cased string, upper- and title-case characters may only follow uncased characters and lowercase characters only cased ones.

isupper()#

Return True if the string is an uppercase string, False otherwise.

A string is uppercase if all cased characters in the string are uppercase and there is at least one cased character in the string.

join(iterable, /)#

Concatenate any number of strings.

The string whose method is called is inserted in between each given string. The result is returned as a new string.

Example: ‘.’.join([‘ab’, ‘pq’, ‘rs’]) -> ‘ab.pq.rs’

ljust(width, fillchar=' ', /)#

Return a left-justified string of length width.

Padding is done using the specified fill character (default is a space).

lower()#: Return a copy of the string converted to lowercase.

lstrip(chars=None, /)#

Return a copy of the string with leading whitespace removed.

If chars is given and not None, remove characters in chars instead.

static maketrans()#

Return a translation table usable for str.translate().

If there is only one argument, it must be a dictionary mapping Unicode ordinals (integers) or characters to Unicode ordinals, strings or None. Character keys will be then converted to ordinals. If there are two arguments, they must be strings of equal length, and in the resulting dictionary, each character in x will be mapped to the character at the same position in y. If there is a third argument, it must be a string, whose characters will be mapped to None in the result.

partition(sep, /)#

Partition the string into three parts using the given separator.

This will search for the separator in the string. If the separator is found, returns a 3-tuple containing the part before the separator, the separator itself, and the part after it.

If the separator is not found, returns a 3-tuple containing the original string and two empty strings.

removeprefix(prefix, /)#

Return a str with the given prefix string removed if present.

If the string starts with the prefix string, return string[len(prefix):]. Otherwise, return a copy of the original string.

removesuffix(suffix, /)#

Return a str with the given suffix string removed if present.

If the string ends with the suffix string and that suffix is not empty, return string[:-len(suffix)]. Otherwise, return a copy of the original string.

replace(old, new, count=-1, /)#

Return a copy with all occurrences of substring old replaced by new.

count
Maximum number of occurrences to replace. -1 (the default value) means replace all occurrences.

If the optional argument count is given, only the first count occurrences are replaced.

rfind(sub[, start[, end]]) → int#

Return the highest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation.

Return -1 on failure.

rindex(sub[, start[, end]]) → int#

Return the highest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation.

Raises ValueError when the substring is not found.

rjust(width, fillchar=' ', /)#

Return a right-justified string of length width.

Padding is done using the specified fill character (default is a space).

rpartition(sep, /)#

Partition the string into three parts using the given separator.

This will search for the separator in the string, starting at the end. If the separator is found, returns a 3-tuple containing the part before the separator, the separator itself, and the part after it.

If the separator is not found, returns a 3-tuple containing two empty strings and the original string.

rsplit(sep=None, maxsplit=-1)#

Return a list of the substrings in the string, using sep as the separator string.

sep
The separator used to split the string.

When set to None (the default value), will split on any whitespace character (including n r t f and spaces) and will discard empty strings from the result.

maxsplit
Maximum number of splits. -1 (the default value) means no limit.

Splitting starts at the end of the string and works to the front.

rstrip(chars=None, /)#

Return a copy of the string with trailing whitespace removed.

If chars is given and not None, remove characters in chars instead.

split(sep=None, maxsplit=-1)#

Return a list of the substrings in the string, using sep as the separator string.

sep
The separator used to split the string.

When set to None (the default value), will split on any whitespace character (including n r t f and spaces) and will discard empty strings from the result.

maxsplit
Maximum number of splits. -1 (the default value) means no limit.

Splitting starts at the front of the string and works to the end.

Note, str.split() is mainly useful for data that has been intentionally delimited. With natural text that includes punctuation, consider using the regular expression module.

splitlines(keepends=False)#

Return a list of the lines in the string, breaking at line boundaries.

Line breaks are not included in the resulting list unless keepends is given and true.

startswith(prefix[, start[, end]]) → bool#: Return True if S starts with the specified prefix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. prefix can also be a tuple of strings to try.

strip(chars=None, /)#

Return a copy of the string with leading and trailing whitespace removed.

If chars is given and not None, remove characters in chars instead.

swapcase()#: Convert uppercase characters to lowercase and lowercase characters to uppercase.

title()#

Return a version of the string where each word is titlecased.

More specifically, words start with uppercased characters and all remaining cased characters have lower case.

translate(table, /)#

Replace each character in the string using the given translation table.

table
Translation table, which must be a mapping of Unicode ordinals to Unicode ordinals, strings, or None.

The table must implement lookup/indexing via __getitem__, for instance a dictionary or list. If this operation raises LookupError, the character is left untouched. Characters mapped to None are deleted.

upper()#: Return a copy of the string converted to uppercase.

zfill(width, /)#

Pad a numeric string with zeros on the left, to fill a field of the given width.

The string is never truncated.

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

qibocal.protocols.utils.readout_frequency(target: Union[int, str], platform: CalibrationPlatform, power_level: PowerLevel = PowerLevel.low, state=0) → float[source]#: Returns readout frequency depending on power level.

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

qibocal.protocols.utils.s21(frequencies: ndarray[Any, dtype[_ScalarType_co]], resonance: float, q_loaded: float, q_coupling: float, phi: float = 0.0, amplitude: float = 1.0, alpha: float = 0.0, tau: float = 0.0) → ndarray[Any, dtype[_ScalarType_co]][source]#

Full model of the S21 notch resonator based on eq. (1) described in: “Efficient and robust analysis of complex scattering data under noise in microwave resonators” (https://doi.org/10.1063/1.4907935) by S. Probst et al and on eq. (E.1) described in: “The Physics of Superconducting Microwave Resonators” (https://doi.org/10.7907/RAT0-VM75) by J. Gao.

The equation is split into two parts describing the ideal resonator and the environment.

Parameters:

frequencies (NDArray[float]) – frequencies (Hz) at which the measurement was taken.
resonance (float) – resonance frequency (Hz).
q_loaded (float) – loaded quality factor.
q_coupling (float) – coupling quality factor.
phi (float) – quantifies the impedance mismatch (Fano interference).
amplitude (float) – accounts for additional attenuation/amplification present in the setup.
alpha (float) – accounts for a additional phase shift.
tau (float) – cable delay caused by the length of the cable and finite speed of light.

Returns:

S21 resonance profile array (NDArray) of a notch resonator.

qibocal.protocols.utils.s21_fit(data: ndarray[Any, dtype[_ScalarType_co]], resonator_type=None, fit=None) → tuple[float, list[float], list[float]][source]#

Calibrates the S21 profile of a notch resonator, based on https://github.com/qkitgroup/qkit.

Args:
data (NDArray[complex]): S21 scattering matrix element.

Returns:
Model parameters

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

qibocal.protocols.utils.s21_spectroscopy_plot(data, qubit, fit: Results = None)[source]#

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

qibocal.protocols.utils.cumulative(input_data, points)[source]#: Evaluates in data the cumulative distribution function of points.

qibocal.protocols.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.utils.eval_magnitude(value)[source]#: number of non decimal digits in value

qibocal.protocols.utils.round_report(measure: list) → tuple[list, list][source]#

Rounds the measured values and their errors according to their significant digits.

Parameters:: measure (list) – Variable-Errors couples.
Returns:: A tuple with the lists of values and errors in the correct string format.

qibocal.protocols.utils.format_error_single_cell(measure: tuple)[source]#: Helper function to print mean value and error in one line.

qibocal.protocols.utils.chi2_reduced(observed: ndarray[Any, dtype[_ScalarType_co]], estimated: ndarray[Any, dtype[_ScalarType_co]], errors: ndarray[Any, dtype[_ScalarType_co]], dof: Optional[float] = None)[source]#

qibocal.protocols.utils.chi2_reduced_complex(observed: tuple[numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]], numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]], estimated: ndarray[Any, dtype[_ScalarType_co]], errors: tuple[numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]], numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]], dof: Optional[float] = None)[source]#

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

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

qibocal.protocols.utils.significant_digit(number: float)[source]#

Computes the position of the first significant digit of a given number.

Parameters:

number (Number) – number for which the significant digit is computed. Can be complex.

Returns:

position of the first significant digit. Returns -1 if the given number: is >= 1, = 0 or inf.

Return type:

int

qibocal.protocols.utils.evaluate_grid(data: ndarray[Any, dtype[_ScalarType_co]])[source]#: This function returns a matrix grid evaluated from the datapoints data.

qibocal.protocols.utils.plot_results(data: Data, qubit: Union[int, str], qubit_states: list, fit: Results)[source]#

Plots for the qubit and qutrit classification.

Parameters:

data (Data) – acquisition data
qubit (QubitID) – qubit
qubit_states (list) – list of qubit states available.
fit (Results) – fit results

qibocal.protocols.utils.table_dict(qubit: Union[list[Union[int, str]], int, str], names: list[str], values: list, display_error=False) → dict[source]#

Build a dictionary to generate HTML table with table_html.

Parameters:

qubit (Union[list[QubitId], QubitId]) – If qubit is a scalar value,
repeated. (the "Qubit" entries will have only this value) –
names (list[str]) – List of the names of the parameters.
values (list) – List of the values of the parameters.
display_errors (bool) – if True, it means that values is a list of value-error couples,
False. (so an Errors key will be displayed in the dictionary. The function will round the couples according to their significant digits. Default) –

Returns:

A dictionary with keys Qubit, Parameters, Values (Errors).

qibocal.protocols.utils.table_html(data: dict) → str[source]#

This function converts a dictionary into an HTML table.

Parameters:

data (dict) – the keys will be converted into table entries and the
table. (values will be the columns of the) –
strings. (Values must be valid HTML) –

Returns:

str

qibocal.protocols.utils.extract_feature(x: ndarray, y: ndarray, z: ndarray, feat: str, ci_first_mask: float = 99, ci_second_mask: float = 70)[source]#

Extract feature using confidence intervals.

Given a dataset of the form (x, y, z) where a spike or a valley is expected, this function discriminate the points (x, y) with a signal, from the pure noise and return the first ones.

A first mask is construct by looking at ci_first_mask confidence interval for each y bin. A second mask is applied by looking at ci_second_mask confidence interval to remove outliers. feat could be min or max, in the first case the function will look for valleys, otherwise for peaks.

qibocal.protocols.utils.guess_period(x, y)[source]#: Return fft period estimation given a sinusoidal plot.

qibocal.protocols.utils.fallback_period(period)[source]#: Function to estimate period if guess_period fails.