qibocal.protocols.two_qubit_interaction package

Subpackages

Submodules

qibocal.protocols.two_qubit_interaction.optimize module

virtual correction experiment for two qubit gates, tune landscape.

qibocal.protocols.two_qubit_interaction.optimize.optimize_two_qubit_gate = Protocol(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>, update=<function _update>, two_qubit_gates=True)

Optimize two qubit gate protocol

qibocal.protocols.two_qubit_interaction.snz_optimize module

class qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningParamteters(amplitude_min: float, amplitude_max: float, amplitude_step: float, amp_ratio_min: float, amp_ratio_max: float, amp_ratio_step: float, theta_start: float, theta_end: float, theta_step: float, t_idling: float, tp: float, flux_time_delay: float = 0)[source]

Bases: Parameters

amplitude_min: float

Amplitude minimum.

amplitude_max: float

Amplitude maximum.

amplitude_step: float

Amplitude step.

amp_ratio_min: float

Minimum amplitude ratio of the two SNZ amplitudes

amp_ratio_max: float

Maximum amplitude ratio of the two SNZ amplitudes

amp_ratio_step: float

Amplitude ratio step of the two SNZ amplitudes

theta_start: float

Virtual phase start angle.

theta_end: float

Virtual phase end angle.

theta_step: float

Virtual phase stop angle.

t_idling: float

SNZ idling time, in number of steps.

tp: float

Gate time.

flux_time_delay: float = 0

Wait time after flux pulse.

property theta_range: ndarray
property amplitude_range: ndarray
property amplitude_ratio_range: ndarray
nshots: int

Number of executions on hardware.

relaxation_time: float

Wait time for the qubit to decohere back to the ground state.

class qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningResults(leakages: dict = <factory>, virtual_phases: dict = <factory>, fitted_parameters: dict = <factory>, angles: dict = <factory>, best_amplitude: dict = <factory>, best_leakage: dict = <factory>, best_angle: dict = <factory>, best_rel_amplitude: dict = <factory>)[source]

Bases: Results

leakages: dict

Qubit leakage.

virtual_phases: dict

Virtual Z phase correction.

fitted_parameters: dict

Fit parameters.

angles: dict

Native SNZ angle.

best_amplitude: dict
best_leakage: dict
_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, filename: str = 'results')

Store results to file.

best_angle: dict
best_rel_amplitude: dict
class qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningData(rel_amplitudes: list[float] = <factory>, _sorted_pairs: list[typing.Annotated[tuple[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], BeforeValidator(func=<function <lambda> at 0x7ff3fd586200>, json_schema_input_type=PydanticUndefined), PlainSerializer(func=<function <lambda> at 0x7ff3e0e42a20>, return_type=PydanticUndefined, when_used='always')]] = <factory>, thetas: list = <factory>, amplitudes: list = <factory>, data: dict[tuple, numpy.ndarray[tuple[typing.Any, ...], numpy.dtype[~_ScalarT]]] = <factory>)[source]

Bases: 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 from data structure.

property params: dict

Convert non-arrays attributes into dict.

property qubits: list[Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]]

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, filename: str = 'data')

Store data to file.

rel_amplitudes: list[float]
_sorted_pairs: list[~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)]]
thetas: list

Angles swept.

amplitudes: list

“Amplitudes swept.

data: dict[tuple, ndarray[tuple[Any, ...], dtype[_ScalarT]]]
property sorted_pairs
parse(i, j)[source]
qibocal.protocols.two_qubit_interaction.snz_optimize._aquisition(params: ~qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningParamteters, platform: ~qibocal.calibration.platform.CalibrationPlatform, targets: list[~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)]]) → SNZFinetuningData[source]

Acquisition for the optimization of SNZ amplitudes. The amplitude of the SNZ pulse and its amplitude ratio (B/A) are swept while the virtual phase correction experiment is performed.

qibocal.protocols.two_qubit_interaction.snz_optimize._fit(data: SNZFinetuningData) → SNZFinetuningResults[source]

Repetition of correct virtual phase fit for all configurations.

qibocal.protocols.two_qubit_interaction.snz_optimize._plot(data: ~qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningData, fit: ~qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningResults, target: ~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)])[source]

Plot routine for SNZ optimization.

qibocal.protocols.two_qubit_interaction.snz_optimize._update(results: ~qibocal.protocols.two_qubit_interaction.snz_optimize.SNZFinetuningResults, platform: ~qibocal.calibration.platform.CalibrationPlatform, target: ~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)])[source]

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle module

class qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingParameters(amplitude_min: float, amplitude_max: float, amplitude_step: float, t_idle_min: float, t_idle_max: float, t_idle_step: float, tp: float, theta_start: float, theta_end: float, theta_step: float, b_amplitude: float)[source]

Bases: Parameters

amplitude_min: float

Amplitude minimum.

amplitude_max: float

Amplitude maximum.

amplitude_step: float

Amplitude step.

t_idle_min: float

Amplitude minimum.

t_idle_max: float

Amplitude maximum.

t_idle_step: float

Amplitude step.

tp: float

Gate time.

theta_start: float

Virtual phase start angle.

theta_end: float

Virtual phase end angle.

theta_step: float

Virtual phase stop angle.

b_amplitude: float

SNZ B amplitude.

property theta_range: ndarray
property amplitude_range: ndarray
property t_idle_range: ndarray
nshots: int

Number of executions on hardware.

relaxation_time: float

Wait time for the qubit to decohere back to the ground state.

class qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingResults(leakages: dict = <factory>, virtual_phases: dict = <factory>, fitted_parameters: dict = <factory>, angles: dict = <factory>, best_amplitude: dict = <factory>, best_leakage: dict = <factory>, best_angle: dict = <factory>, best_rel_amplitude: dict = <factory>, best_t_idle: dict = <factory>)[source]

Bases: SNZFinetuningResults

best_t_idle: dict
_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, filename: str = 'results')

Store results to file.

leakages: dict

Qubit leakage.

virtual_phases: dict

Virtual Z phase correction.

fitted_parameters: dict

Fit parameters.

angles: dict

Native SNZ angle.

best_amplitude: dict
best_leakage: dict
best_angle: dict
best_rel_amplitude: dict
class qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingData(sampling_rate: float = 1, _sorted_pairs: list[typing.Annotated[tuple[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], BeforeValidator(func=<function <lambda> at 0x7ff3fd586200>, json_schema_input_type=PydanticUndefined), PlainSerializer(func=<function <lambda> at 0x7ff3e0e42a20>, return_type=PydanticUndefined, when_used='always')]] = <factory>, thetas: list = <factory>, amplitudes: list = <factory>, t_idles: list = <factory>, data: dict[tuple, numpy.ndarray[tuple[typing.Any, ...], numpy.dtype[~_ScalarT]]] = <factory>)[source]

Bases: Data

sampling_rate: float = 1

Sampling rate of devices.

_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 from data structure.

property params: dict

Convert non-arrays attributes into dict.

property qubits: list[Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]]

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, filename: str = 'data')

Store data to file.

_sorted_pairs: list[~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)]]

List of sorted pairs.

thetas: list

Angles swept.

amplitudes: list

“Amplitudes swept.

t_idles: list

Durations swept.

data: dict[tuple, ndarray[tuple[Any, ...], dtype[_ScalarT]]]
property sorted_pairs: list
parse(i, j) → dict[source]
qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle._aquisition(params: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingParameters, platform: ~qibocal.calibration.platform.CalibrationPlatform, targets: list[~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)]]) → SNZIdlingData[source]

Acquisition for the optimization of SNZ amplitudes. The amplitude of the SNZ pulse and its idling time are swept while the virtual phase correction experiment is performed.

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle._fit(data: SNZIdlingData) → SNZIdlingResults[source]

Repetition of correct virtual phase fit for all configurations.

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle._plot(data: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingData, fit: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingResults, target: ~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)])[source]

Plot routine for OptimizeTwoQubitGate.

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle._update(results: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle.SNZIdlingResults, platform: ~qibocal.calibration.platform.CalibrationPlatform, target: ~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)])[source]

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot module

class qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationParamteters(duration_min: float, duration_max: float, duration_step: float, t_idle_min: float, t_idle_max: float, t_idle_step: float, theta_start: float, theta_end: float, theta_step: float, b_amplitude: float)[source]

Bases: Parameters

duration_min: float

Duration minimum.

duration_max: float

Duration maximum.

duration_step: float

Duration step.

t_idle_min: float

t_idle minimum.

t_idle_max: float

t_idle maximum.

t_idle_step: float

t_idle step.

theta_start: float

Virtual phase start angle.

theta_end: float

Virtual phase end angle.

theta_step: float

Virtual phase stop angle.

b_amplitude: float

SNZ B amplitude.

property theta_range: ndarray
property duration_range: ndarray
property t_idle_range: ndarray
nshots: int

Number of executions on hardware.

relaxation_time: float

Wait time for the qubit to decohere back to the ground state.

class qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationResults(leakages: dict = <factory>, virtual_phases: dict = <factory>, fitted_parameters: dict = <factory>, angles: dict = <factory>, best_amplitude: dict = <factory>, best_leakage: dict = <factory>, best_angle: dict = <factory>, best_rel_amplitude: dict = <factory>, best_t_idle: dict = <factory>, best_duration: dict = <factory>)[source]

Bases: SNZIdlingResults

best_duration: dict
_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, filename: str = 'results')

Store results to file.

best_t_idle: dict
leakages: dict

Qubit leakage.

virtual_phases: dict

Virtual Z phase correction.

fitted_parameters: dict

Fit parameters.

angles: dict

Native SNZ angle.

best_amplitude: dict
best_leakage: dict
best_angle: dict
best_rel_amplitude: dict
class qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationData(sampling_rate: float = 1, _sorted_pairs: list[typing.Annotated[tuple[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], BeforeValidator(func=<function <lambda> at 0x7ff3fd586200>, json_schema_input_type=PydanticUndefined), PlainSerializer(func=<function <lambda> at 0x7ff3e0e42a20>, return_type=PydanticUndefined, when_used='always')]] = <factory>, thetas: list = <factory>, durations: list = <factory>, t_idles: list = <factory>, data: dict[tuple, numpy.ndarray[tuple[typing.Any, ...], numpy.dtype[~_ScalarT]]] = <factory>)[source]

Bases: Data

sampling_rate: float = 1
_sorted_pairs: list[~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)]]
_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 from data structure.

property params: dict

Convert non-arrays attributes into dict.

property qubits: list[Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]]

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, filename: str = 'data')

Store data to file.

thetas: list

Angles swept.

durations: list

“Amplitudes swept.

t_idles: list

Durations swept.

data: dict[tuple, ndarray[tuple[Any, ...], dtype[_ScalarT]]]
property sorted_pairs
parse(i, j)[source]
qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot._aquisition(params: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationParamteters, platform: ~qibocal.calibration.platform.CalibrationPlatform, targets: list[~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)]]) → SNZDurationData[source]
qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot._fit(data: SNZDurationData) → SNZDurationResults[source]

Repetition of correct virtual phase fit for all configurations.

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot._plot(data: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationData, fit: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationResults, target: ~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)])[source]

Plot routine for OptimizeTwoQubitGate.

qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot._update(results: ~qibocal.protocols.two_qubit_interaction.snz_optimize_t_idle_vs_t_tot.SNZDurationResults, platform: ~qibocal.calibration.platform.CalibrationPlatform, target: ~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)])[source]

qibocal.protocols.two_qubit_interaction.utils module

qibocal.protocols.two_qubit_interaction.utils.order_pair(pair: ~typing.Annotated[tuple[~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ~typing.Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], ~pydantic.functional_validators.BeforeValidator(func=~qibocal.calibration.calibration.<lambda>, json_schema_input_type=PydanticUndefined), ~pydantic.functional_serializers.PlainSerializer(func=~qibocal.calibration.calibration.<lambda>, return_type=PydanticUndefined, when_used=always)], platform: ~qibolab._core.platform.platform.Platform) → tuple[Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]][source]

Order a pair of qubits by drive frequency.

qibocal.protocols.two_qubit_interaction.utils.sinusoid(x, gate_repetition, amplitude, offset, phase)[source]

Sinusoidal fit function.

qibocal.protocols.two_qubit_interaction.utils.fit_flux_amplitude(matrix, amps, times)[source]

Estimate amplitude for CZ gate.

Given the pattern of a chevron plot (see for example Fig. 2 here https://arxiv.org/pdf/1907.04818.pdf). This function estimates the CZ amplitude by finding the amplitude which gives the standard deviation, indicating that there are oscillation along the z axis.

Parameters:

  • matrix (np.ndarray) – signal matrix

  • amps (np.ndarray) – amplitudes swept

  • times (np.ndarray) – duration swept

Returns:

estimated amplitude index (int): amplitude index delta (float): omega for estimated amplitude

Return type:

amplitude (float)

qibocal.protocols.two_qubit_interaction.utils.phase_diff(phase_1, phase_2)[source]

Return the phase difference of two sinusoids, normalized in the range [0, 2*pi].

qibocal.protocols.two_qubit_interaction.utils.fit_sinusoid(thetas, data, gate_repetition)[source]

Fit sinusoid to the given data.

qibocal.protocols.two_qubit_interaction.utils.fit_virtualz(data: dict, pair: list, thetas: list, gate_repetition: int, key=None)[source]

qibocal.protocols.two_qubit_interaction.virtual_z_phases module

CZ virtual correction experiment for two qubit gates, tune landscape.

qibocal.protocols.two_qubit_interaction.virtual_z_phases.correct_virtual_z_phases = Protocol(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>, update=<function _update>, two_qubit_gates=True)

Virtual phases correction protocol.

qibocal.protocols.two_qubit_interaction.virtual_z_phases.create_sequence(platform: CalibrationPlatform, setup: Literal['I', 'X'], target_qubit: Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], control_qubit: Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], ordered_pair: list[Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], Annotated[int | str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])]], native: Literal['CZ', 'iSWAP'], dt: float, flux_pulse_max_duration: float = None, gate_repetition: int = 1, flux_pulse: list | None = None) → tuple[PulseSequence, Pulse, Pulse, list[Pulse]][source]

Create the pulse sequence for the calibration of two-qubit gate virtual phases.

This function constructs a pulse sequence for a given two-qubit native gate native (CZ or iSWAP) on the specified qubits. The sequence includes: - A preliminary RX90 pulse on the target_qubit. - An optional X pulse on the control_qubit based on the setup type. - A flux pulse implementing the two-qubit native gate. - A delay of duration dt before the final X90 pulse on the target qubit. - Measurement pulses. It is possible to specify the maximum duration for the flux pulses with the flux_pulse_max_duration parameter.

The function returns:

  • The full experiment pulse sequence.

  • The applied flux pulse.

  • The final VirtualZPhase pulses to be used for phase sweeping.

qibocal.protocols.two_qubit_interaction.virtual_z_phases.fit_sinusoid(thetas, data, gate_repetition)[source]

Fit sinusoid to the given data.

qibocal.protocols.two_qubit_interaction.virtual_z_phases.phase_diff(phase_1, phase_2)[source]

Return the phase difference of two sinusoids, normalized in the range [0, 2*pi].