qibocal.protocols.coherence package#

Submodules#

qibocal.protocols.coherence.cpmg module#

class qibocal.protocols.coherence.cpmg.CpmgParameters(delay_between_pulses_start: int, delay_between_pulses_end: int, delay_between_pulses_step: int, single_shot: bool = False, n: int = 1)[source]#

Bases: SpinEchoParameters

Cpmg runcard inputs.

n: int = 1#: Number of pi rotations.

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

single_shot: bool = False#

delay_between_pulses_start: int#: Initial delay between pulses [ns].

delay_between_pulses_end: int#: Final delay between pulses [ns].

delay_between_pulses_step: int#: Step delay between pulses [ns].

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.coherence.cpmg.CpmgResults(t2: dict[typing.Union[int, str], typing.Union[float, list[float]]], fitted_parameters: dict[typing.Union[int, str], dict[str, float]], pcov: dict[typing.Union[int, str], list[float]], chi2: ~typing.Optional[dict[typing.Union[int, str], tuple[float, typing.Optional[float]]]] = <factory>)[source]#

Bases: SpinEchoResults

SpinEcho 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.

chi2: Optional[dict[QubitId, tuple[float, Optional[float]]]]#: Chi squared estimate mean value and error.

t2: dict[QubitId, Union[float, list[float]]]#: T2 echo for each qubit.

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

pcov: dict[QubitId, list[float]]#: Approximate covariance of fitted parameters.

class qibocal.protocols.coherence.cpmg.CpmgData(data: dict[typing.Union[int, str], numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]] = <factory>)[source]#

Bases: T1Data

SpinEcho 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]#: Raw data acquired.

qibocal.protocols.coherence.cpmg._acquisition(params: CpmgParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → CpmgData[source]#: Data acquisition for Cpmg

qibocal.protocols.coherence.cpmg._fit(data: CpmgData) → CpmgResults[source]#: Post-processing for Cpmg.

qibocal.protocols.coherence.cpmg.cpmg = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function plot>, update=<function _dummy_update>, two_qubit_gates=False)#: Cpmg Routine object.

qibocal.protocols.coherence.spin_echo module#

class qibocal.protocols.coherence.spin_echo.SpinEchoParameters(delay_between_pulses_start: int, delay_between_pulses_end: int, delay_between_pulses_step: int, single_shot: bool = False)[source]#

Bases: SpinEchoSignalParameters

SpinEcho runcard inputs.

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

single_shot: bool = False#

delay_between_pulses_start: int#: Initial delay between pulses [ns].

delay_between_pulses_end: int#: Final delay between pulses [ns].

delay_between_pulses_step: int#: Step delay between pulses [ns].

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.coherence.spin_echo.SpinEchoResults(t2: dict[typing.Union[int, str], typing.Union[float, list[float]]], fitted_parameters: dict[typing.Union[int, str], dict[str, float]], pcov: dict[typing.Union[int, str], list[float]], chi2: ~typing.Optional[dict[typing.Union[int, str], tuple[float, typing.Optional[float]]]] = <factory>)[source]#

Bases: SpinEchoSignalResults

SpinEcho outputs.

chi2: Optional[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.

t2: dict[QubitId, Union[float, list[float]]]#: T2 echo for each qubit.

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

pcov: dict[QubitId, list[float]]#: Approximate covariance of fitted parameters.

class qibocal.protocols.coherence.spin_echo.SpinEchoData(data: dict[typing.Union[int, str], numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]] = <factory>)[source]#

Bases: T1Data

SpinEcho 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]#: Raw data acquired.

qibocal.protocols.coherence.spin_echo._acquisition(params: SpinEchoParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → SpinEchoData[source]#: Data acquisition for SpinEcho

qibocal.protocols.coherence.spin_echo._fit(data: SpinEchoData) → SpinEchoResults[source]#: Post-processing for SpinEcho.

qibocal.protocols.coherence.spin_echo.spin_echo = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function plot>, update=<function _update>, two_qubit_gates=False)#: SpinEcho Routine object.

qibocal.protocols.coherence.spin_echo_signal module#

class qibocal.protocols.coherence.spin_echo_signal.SpinEchoSignalParameters(delay_between_pulses_start: int, delay_between_pulses_end: int, delay_between_pulses_step: int, single_shot: bool = False)[source]#

Bases: Parameters

SpinEcho Signal runcard inputs.

delay_between_pulses_start: int#: Initial delay between pulses [ns].

delay_between_pulses_end: int#: Final delay between pulses [ns].

delay_between_pulses_step: int#: Step delay between pulses [ns].

single_shot: bool = False#

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.coherence.spin_echo_signal.SpinEchoSignalResults(t2: dict[Union[int, str], Union[float, list[float]]], fitted_parameters: dict[Union[int, str], dict[str, float]], pcov: dict[Union[int, str], list[float]])[source]#

Bases: Results

SpinEchoSignal outputs.

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

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

pcov: dict[Union[int, str], list[float]]#: Approximate covariance of 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.

class qibocal.protocols.coherence.spin_echo_signal.SpinEchoSignalData(data: dict[typing.Union[int, str], numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]] = <factory>)[source]#

Bases: T1SignalData

SpinEcho 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.

property average#

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]#: Raw data acquired.

qibocal.protocols.coherence.spin_echo_signal._acquisition(params: SpinEchoSignalParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → SpinEchoSignalData[source]#: Data acquisition for SpinEcho

qibocal.protocols.coherence.spin_echo_signal._fit(data: SpinEchoSignalData) → SpinEchoSignalResults[source]#: Post-processing for SpinEcho.

qibocal.protocols.coherence.spin_echo_signal._plot(data: SpinEchoSignalData, target: Union[int, str], fit: SpinEchoSignalResults = None)[source]#: Plotting for SpinEcho

qibocal.protocols.coherence.spin_echo_signal._update(results: SpinEchoSignalResults, platform: CalibrationPlatform, target: Union[int, str])[source]#

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

qibocal.protocols.coherence.t1 module#

class qibocal.protocols.coherence.t1.T1Parameters(delay_before_readout_start: int, delay_before_readout_end: int, delay_before_readout_step: int, single_shot: bool = False)[source]#

Bases: T1SignalParameters

T1 runcard inputs.

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

single_shot: bool = False#: If True save single shot signal data.

delay_before_readout_start: int#: Initial delay before readout [ns].

delay_before_readout_end: int#: Final delay before readout [ns].

delay_before_readout_step: int#: Step delay before readout [ns].

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.coherence.t1.T1Results(t1: dict[typing.Union[int, str], typing.Union[float, list[float]]], fitted_parameters: dict[typing.Union[int, str], dict[str, float]], pcov: dict[typing.Union[int, str], list[float]], chi2: ~typing.Optional[dict[typing.Union[int, str], list[float]]] = <factory>)[source]#

Bases: T1SignalResults

T1 outputs.

chi2: Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], 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.

t1: dict[QubitId, Union[float, list[float]]]#: T1 for each qubit.

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

pcov: dict[QubitId, list[float]]#: Approximate covariance of fitted parameters.

qibocal.protocols.coherence.t1.CoherenceProbType = dtype([('wait', '<f8'), ('prob', '<f8'), ('error', '<f8')])#: Custom dtype for coherence routines.

class qibocal.protocols.coherence.t1.T1Data(data: dict[typing.Union[int, str], numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]] = <factory>)[source]#

Bases: Data

T1 acquisition outputs.

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

_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.

qibocal.protocols.coherence.t1._acquisition(params: T1Parameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → T1Data[source]#: Data acquisition for T1 experiment.

qibocal.protocols.coherence.t1._fit(data: T1Data) → T1Results[source]#: Fitting routine for T1 experiment. The used model is

\[y = p_0-p_1 e^{-x p_2}.\]

qibocal.protocols.coherence.t1._plot(data: T1Data, target: Union[int, str], fit: T1Results = None)[source]#: Plotting function for T1 experiment.

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

qibocal.protocols.coherence.t1_signal module#

class qibocal.protocols.coherence.t1_signal.T1SignalParameters(delay_before_readout_start: int, delay_before_readout_end: int, delay_before_readout_step: int, single_shot: bool = False)[source]#

Bases: Parameters

T1 runcard inputs.

delay_before_readout_start: int#: Initial delay before readout [ns].

delay_before_readout_end: int#: Final delay before readout [ns].

delay_before_readout_step: int#: Step delay before readout [ns].

single_shot: bool = False#: If True save single shot signal data.

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.coherence.t1_signal.T1SignalResults(t1: dict[Union[int, str], Union[float, list[float]]], fitted_parameters: dict[Union[int, str], dict[str, float]], pcov: dict[Union[int, str], list[float]])[source]#

Bases: Results

T1 Signal outputs.

t1: dict[Union[int, str], Union[float, list[float]]]#: T1 for each qubit.

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

pcov: dict[Union[int, str], list[float]]#: Approximate covariance of 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.

class qibocal.protocols.coherence.t1_signal.T1SignalData(data: dict[typing.Union[int, str], numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]] = <factory>)[source]#

Bases: Data

T1 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[+_ScalarType_co]]]#: Raw data acquired.

property average#

qibocal.protocols.coherence.t1_signal.t1_sequence(platform: CalibrationPlatform, targets: list[Union[int, str]])[source]#: Create sequence for T1 experiment with a given optional delay.

qibocal.protocols.coherence.t1_signal._acquisition(params: T1SignalParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → T1SignalData[source]#

Data acquisition for T1 experiment.

In this protocol the y axis is the magnitude of signal in the IQ plane.

qibocal.protocols.coherence.t1_signal._fit(data: T1SignalData) → T1SignalResults[source]#: Fitting routine for T1 experiment. The used model is

\[y = p_0-p_1 e^{-x p_2}.\]

qibocal.protocols.coherence.t1_signal._plot(data: T1SignalData, target: Union[int, str], fit: T1SignalResults = None)[source]#: Plotting function for T1 experiment.

qibocal.protocols.coherence.t1_signal._update(results: T1SignalResults, platform: CalibrationPlatform, target: Union[int, str])[source]#

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

qibocal.protocols.coherence.t2 module#

class qibocal.protocols.coherence.t2.T2Parameters(delay_between_pulses_start: int, delay_between_pulses_end: int, delay_between_pulses_step: int, single_shot: bool = False)[source]#

Bases: T2SignalParameters

T2 runcard inputs.

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

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

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

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

single_shot: bool = False#: If True save single shot signal data.

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.coherence.t2.T2Results(t2: dict[typing.Union[int, str], typing.Union[float, list[float]]], fitted_parameters: dict[typing.Union[int, str], dict[str, float]], pcov: dict[typing.Union[int, str], list[float]], chi2: ~typing.Optional[dict[typing.Union[int, str], tuple[float, typing.Optional[float]]]] = <factory>)[source]#

Bases: T2SignalResults

T2 outputs.

chi2: Optional[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.

t2: dict[QubitId, Union[float, list[float]]]#: T2 for each qubit [ns].

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

pcov: dict[QubitId, list[float]]#: Approximate covariance of fitted parameters.

class qibocal.protocols.coherence.t2.T2Data(data: dict[typing.Union[int, str], numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]] = <factory>)[source]#

Bases: T1Data

T2 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]#: Raw data acquired.

qibocal.protocols.coherence.t2._acquisition(params: T2Parameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → T2Data[source]#: Data acquisition for T2 experiment.

qibocal.protocols.coherence.t2._fit(data: T2Data) → T2Results[source]#: The used model is

\[y = p_0 - p_1 e^{-x p_2}.\]

qibocal.protocols.coherence.t2.t2 = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function plot>, update=<function _update>, two_qubit_gates=False)#: T2 Routine object.

qibocal.protocols.coherence.t2_signal module#

class qibocal.protocols.coherence.t2_signal.T2SignalParameters(delay_between_pulses_start: int, delay_between_pulses_end: int, delay_between_pulses_step: int, single_shot: bool = False)[source]#

Bases: Parameters

T2Signal runcard inputs.

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

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

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

single_shot: bool = False#: If True save single shot signal data.

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.coherence.t2_signal.T2SignalResults(t2: dict[Union[int, str], Union[float, list[float]]], fitted_parameters: dict[Union[int, str], dict[str, float]], pcov: dict[Union[int, str], list[float]])[source]#

Bases: Results

T2Signal outputs.

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

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

pcov: dict[Union[int, str], list[float]]#: Approximate covariance of 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.

class qibocal.protocols.coherence.t2_signal.T2SignalData(data: dict[typing.Union[int, str], numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]]] = <factory>)[source]#

Bases: T1SignalData

T2Signal 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.

property average#

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]#: Raw data acquired.

t2: dict[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], float]#: T2 for each qubit [ns].

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

qibocal.protocols.coherence.t2_signal._acquisition(params: T2SignalParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → T2SignalData[source]#

Data acquisition for T2 experiment.

In this protocol the y axis is the magnitude of signal in the IQ plane.

qibocal.protocols.coherence.t2_signal._fit(data: T2SignalData) → T2SignalResults[source]#: The used model is

\[y = p_0 - p_1 e^{-x p_2}.\]

qibocal.protocols.coherence.t2_signal._plot(data: T2SignalData, target: Union[int, str], fit: T2SignalResults = None)[source]#: Plotting function for Ramsey Experiment.

qibocal.protocols.coherence.t2_signal._update(results: T2SignalResults, platform: CalibrationPlatform, target: Union[int, str])[source]#

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

qibocal.protocols.coherence.utils module#

qibocal.protocols.coherence.utils.CoherenceType = dtype([('wait', '<f8'), ('signal', '<f8'), ('phase', '<f8')])#: Custom dtype for coherence routines.

qibocal.protocols.coherence.utils.average_single_shots(data_type, single_shots)[source]#

Convert single shot acquisition results of signal routines to averaged.

Parameters:

data_type – Type of produced data object (eg. T1SignalData, T2SignalData etc.).
single_shots (dict) – Dictionary containing acquired single shot data.

qibocal.protocols.coherence.utils.dynamical_decoupling_sequence(platform: Platform, targets: list[Union[int, str]], wait: int = 0, n: int = 1, kind: str = 'CPMG') → tuple[qibolab._core.sequence.PulseSequence, list[qibolab._core.pulses.pulse.Delay]][source]#

Create dynamical decoupling sequence.

Two sequences are available: - CP: RX90 (wait RX wait )^N RX90 - CPMG: RX90 (wait RY wait )^N RX90

qibocal.protocols.coherence.utils.exp_decay(x, *p)[source]#

qibocal.protocols.coherence.utils.exponential_fit(data, zeno=False)[source]#

qibocal.protocols.coherence.utils.exponential_fit_probability(data, zeno=False)[source]#

qibocal.protocols.coherence.utils.plot(data, target: Union[int, str], fit=None) → tuple[list[plotly.graph_objs._figure.Figure], str][source]#: Plotting function for spin-echo or CPMG protocol.

qibocal.protocols.coherence.zeno module#

class qibocal.protocols.coherence.zeno.ZenoParameters(readouts: int)[source]#

Bases: Parameters

Zeno runcard inputs.

readouts: int#: Number of readout pulses

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.coherence.zeno.ZenoResults(zeno_t1: dict[Union[int, str], int], fitted_parameters: dict[Union[int, str], dict[str, float]], pcov: dict[Union[int, str], list[float]], chi2: dict[Union[int, str], tuple[float, Optional[float]]])[source]#

Bases: Results

Zeno outputs.

zeno_t1: dict[Union[int, str], int]#: T1 for each qubit.

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

pcov: dict[Union[int, str], list[float]]#: Approximate covariance of fitted parameters.

chi2: dict[Union[int, str], tuple[float, Optional[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.

qibocal.protocols.coherence.zeno.zeno_sequence(platform: CalibrationPlatform, targets: list[Union[int, str]], readouts: int) → tuple[qibolab._core.sequence.PulseSequence, dict[Union[int, str], int]][source]#: Generating sequence for Zeno experiment.

class qibocal.protocols.coherence.zeno.ZenoData(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>, readout_duration: dict[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], float] = <factory>)[source]#

Bases: T1Data

_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.

readout_duration: dict[typing.Annotated[typing.Union[int, str], FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(union_mode='left_to_right')])], float]#: Readout durations for each qubit

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

qibocal.protocols.coherence.zeno._acquisition(params: ZenoParameters, platform: CalibrationPlatform, targets: list[Union[int, str]]) → ZenoData[source]#: In a T1_Zeno experiment, we measure an excited qubit repeatedly. Due to decoherence processes, it is possible that, at the time of measurement, the qubit will not be excited anymore. The quantum zeno effect consists of measuring allowing a particle’s time evolution to be slowed down by measuring it frequently enough. However, in the experiments we see that due the QND-ness of the readout pulse that the qubit decoheres faster. Reference: https://link.aps.org/accepted/10.1103/PhysRevLett.118.240401.

qibocal.protocols.coherence.zeno._fit(data: ZenoData) → ZenoResults[source]#: Fitting routine for T1 experiment. The used model is

\[y = p_0-p_1 e^{-x p_2}.\]

qibocal.protocols.coherence.zeno._plot(data: ZenoData, fit: ZenoResults, target: Union[int, str])[source]#: Plotting function for T1 experiment.

qibocal.protocols.coherence.zeno._update(results: ZenoResults, platform: CalibrationPlatform, qubit: Union[int, str])[source]#