Calibration routines#
Introduction#
The calibration routines are techniques used to reduce execution errors in quantum circuits. To perform calibrations, the expected theoretical results of an experiment are compared with readouts obtained by running that same experiment using quantum devices. There are at least two objectives in calibration:
To derive the exact values of the signals to be supplied to the hardware in order to obtain the best possible implementation of a theoretical operation;
Derive the system relaxation time, which is the threshold time interval beyond which executions of operations on the hardware are no longer reliable due to machine overload.
Current and future qibocal
routines are listed in the following table:
Methods |
Code |
Tested on device |
Automated |
---|---|---|---|
Resonator Punchout |
Yes |
Yes |
In progress |
Resonator-Flux |
Yes |
Yes |
In progress |
Qubit spectroscopy |
Yes |
Yes |
In progress |
Qubit Flux |
Yes |
Yes |
In progress |
Rabi (T1) |
Yes |
Yes |
No |
Ramsey (T2) |
Yes |
Yes |
No |
Single shot readouts |
Yes |
Yes |
No |
All-XY (drag) |
Yes |
Yes |
No |
RB & co (1 qubit) |
Yes |
No |
No |
Cryoscope |
In progress |
In progress |
No |
CZ gate |
No |
No |
No |
RB & co (multi qubits) |
No |
No |
No |
Circuit transpilation |
Yes |
No |
No |
Resonator#
- qibocal.calibrations.characterization.resonator_spectroscopy.resonator_spectroscopy(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, fast_width, fast_step, precision_width, precision_step, software_averages=1, points=10)#
Perform spectroscopies on the qubits’ readout resonators. This routine executes an initial scan around the expected resonator frequency indicated in the platform runcard. After that, a final sweep with more precision is executed centered in the new resonator frequency found.
- Parameters
platform (AbstractPlatform) – Qibolab platform object
qubits (dict) – List of target qubits to perform the action
fast_width (int) – Width frequency in HZ to perform the high resolution sweep
fast_step (int) – Step frequency in HZ for the high resolution sweep
precision_width (int) – Width frequency in HZ to perform the precision resolution sweep
precision_step (int) – Step frequency in HZ for the precission resolution sweep
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
Two DataUnits objects with the raw data obtained for the fast and precision sweeps with the following keys
MSR[V]: Resonator signal voltage mesurement in volts
i[V]: Resonator signal voltage mesurement for the component I in volts
q[V]: Resonator signal voltage mesurement for the component Q in volts
phase[rad]: Resonator signal phase mesurement in radians
frequency[Hz]: Resonator frequency value in Hz
qubit: The qubit being tested
iteration: The iteration number of the many determined by software_averages
A DataUnits object with the fitted data obtained with the following keys
readout_frequency: frequency
peak_voltage: peak voltage
popt0: Lorentzian’s amplitude
popt1: Lorentzian’s center
popt2: Lorentzian’s sigma
popt3: Lorentzian’s offset
qubit: The qubit being tested
- qibocal.calibrations.characterization.resonator_spectroscopy.resonator_punchout(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, freq_width, freq_step, min_att, max_att, step_att, software_averages=1, points=10)#
Perform spectroscopies on the qubits’ readout resonators, decreasing the attenuation applied to the read-out pulse, producing an increment of the power sent to the resonator. That shows the two regimes of a given resonator, low and high-power regimes.
- Parameters
platform (AbstractPlatform) – Qibolab platform object
qubits (dict) – List of target qubits to perform the action
freq_width (int) – Width frequency in HZ to perform the spectroscopy sweep
freq_step (int) – Step frequency in HZ for the spectroscopy sweep
min_att (int) – Minimum value in db for the attenuation sweep
max_att (int) – Minimum value in db for the attenuation sweep
step_att (int) – Step attenuation in db for the attenuation sweep
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
A DataUnits object with the raw data obtained with the following keys
MSR[V]: Resonator signal voltage mesurement in volts
i[V]: Resonator signal voltage mesurement for the component I in volts
q[V]: Resonator signal voltage mesurement for the component Q in volts
phase[rad]: Resonator signal phase mesurement in radians
frequency[Hz]: Resonator frequency value in Hz
attenuation[dB]: attenuation value in db applied to the flux line
qubit: The qubit being tested
iteration: The iteration number of the many determined by software_averages
- qibocal.calibrations.characterization.resonator_spectroscopy.resonator_spectroscopy_flux(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, freq_width, freq_step, bias_width, bias_step, fluxlines, software_averages=1, points=10)#
Perform spectroscopy on the readout resonator modifying the bias applied in the flux control line. This routine works for quantum devices flux controlled.
- Parameters
platform (AbstractPlatform) – Qibolab platform object
qubits (dict) – List of target qubits to perform the action
freq_width (int) – Width frequency in HZ to perform the spectroscopy sweep
freq_step (int) – Step frequency in HZ for the spectroscopy sweep
bias_width (float) – Width bias in A for the flux bias sweep
bias_step (float) – Step bias in A for the flux bias sweep
fluxlines (list) – List of flux lines to use to perform the experiment. If it is set to “qubits”, it uses each of flux lines associated with the target qubits.
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
A DataUnits object with the raw data obtained with the following keys
MSR[V]: Resonator signal voltage mesurement in volts
i[V]: Resonator signal voltage mesurement for the component I in volts
q[V]: Resonator signal voltage mesurement for the component Q in volts
phase[rad]: Resonator signal phase mesurement in radians
frequency[Hz]: Resonator frequency value in Hz
bias[V]: Current value in A applied to the flux line
qubit: The qubit being tested
fluxline: The fluxline being tested
iteration: The iteration number of the many determined by software_averages
- qibocal.calibrations.characterization.resonator_spectroscopy.dispersive_shift(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, freq_width, freq_step, software_averages=1, points=10)#
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
platform (AbstractPlatform) – Qibolab platform object
qubits (dict) – List of target qubits to perform the action
freq_width (int) – Width frequency in HZ to perform the spectroscopy sweep
freq_step (int) – Step frequency in HZ for the spectroscopy sweep
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
A DataUnits object with the raw data obtained for the normal and shifted sweeps with the following keys
MSR[V]: Resonator signal voltage mesurement in volts
i[V]: Resonator signal voltage mesurement for the component I in volts
q[V]: Resonator signal voltage mesurement for the component Q in volts
phase[rad]: Resonator signal phase mesurement in radians
frequency[Hz]: Resonator frequency value in Hz
qubit: The qubit being tested
iteration: The iteration number of the many determined by software_averages
Single Qubit#
Qubit spectroscopy#
- qibocal.calibrations.characterization.qubit_spectroscopy.qubit_spectroscopy(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, fast_width, fast_step, precision_width, precision_step, software_averages=1, points=10)#
Perform spectroscopy on the qubit. This routine executes a fast scan around the expected qubit frequency indicated in the platform runcard. Afterthat, a final sweep with more precision is executed centered in the new qubit frequency found.
- Parameters
platform (AbstractPlatform) – Qibolab platform object
qubits (dict) – Dict of target Qubit objects to perform the action
fast_start (int) – Initial frequency in HZ to perform the qubit fast sweep
fast_width (int) – Width frequency in HZ to perform the high resolution sweep
fast_step (int) – Step frequency in HZ for the high resolution sweep
precision_width (int) – Width frequency in HZ to perform the precision resolution sweep
precision_step (int) – Step frequency in HZ for the precission resolution sweep
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
Two DataUnits objects with the raw data obtained for the fast and precision sweeps with the following keys
MSR[V]: Resonator signal voltage mesurement in volts
i[V]: Resonator signal voltage mesurement for the component I in volts
q[V]: Resonator signal voltage mesurement for the component Q in volts
phase[rad]: Resonator signal phase mesurement in radians
frequency[Hz]: Qubit drive frequency value in Hz
qubit: The qubit being tested
iteration: The iteration number of the many determined by software_averages
A DataUnits object with the fitted data obtained with the following keys
qubit: The qubit being tested
drive_frequency: frequency
peak_voltage: peak voltage
popt0: Lorentzian’s amplitude
popt1: Lorentzian’s center
popt2: Lorentzian’s sigma
popt3: Lorentzian’s offset
- qibocal.calibrations.characterization.qubit_spectroscopy.qubit_spectroscopy_flux(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, freq_width, freq_step, bias_width, bias_step, fluxlines, software_averages=1, points=10)#
Perform spectroscopy on the qubit modifying the bias applied in the flux control line. This routine works for multiqubit devices flux controlled.
- Parameters
platform (AbstractPlatform) – Qibolab platform object
qubits (dict) – Dict of target Qubit objects to perform the action
freq_width (int) – Width frequency in HZ to perform the spectroscopy sweep
freq_step (int) – Step frequency in HZ for the spectroscopy sweep
bias_width (float) – Width bias in A for the flux bias sweep
bias_step (float) – Step bias in A for the flux bias sweep
fluxlines (list) – List of flux lines to use to perform the experiment. If it is set to “qubits”, it uses each of flux lines associated with the target qubits.
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
A DataUnits object with the raw data obtained for the fast and precision sweeps with the following keys
MSR[V]: Resonator signal voltage mesurement in volts
i[V]: Resonator signal voltage mesurement for the component I in volts
q[V]: Resonator signal voltage mesurement for the component Q in volts
phase[rad]: Resonator signal phase mesurement in radians
frequency[Hz]: Qubit drive frequency value in Hz
bias[V]: Current value in A applied to the flux line
qubit: The qubit being tested
fluxline: The fluxline being tested
iteration: The iteration number of the many determined by software_averages
A DataUnits object with the fitted data obtained with the following keys
drive_frequency: frequency
peak_voltage: peak voltage
popt0: Lorentzian’s amplitude
popt1: Lorentzian’s center
popt2: Lorentzian’s sigma
popt3: Lorentzian’s offset
qubit: The qubit being tested
Rabi oscillations#
Ramsey#
- qibocal.calibrations.characterization.ramsey.ramsey_frequency_detuned(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, delay_between_pulses_start, delay_between_pulses_end, delay_between_pulses_step, n_osc, software_averages=1, points=10)#
We introduce an artificial detune over the drive pulse frequency to be off-resonance and, after fitting, determine two of the qubit’s properties: Ramsey or detuning frequency and T2. If our drive pulse is well calibrated, the Ramsey experiment without artificial detuning results in an exponential that describes T2, but we can not refine the detuning frequency.
In this method we iterate over diferent maximum time delays between the drive pulses of the ramsey sequence in order to refine the fitted detuning frequency and T2.
Ramsey sequence: Rx(pi/2) - wait time - Rx(pi/2) - ReadOut
- Parameters
platform (AbstractPlatform) – Qibolab platform object
qubits (dict) – Dict of target Qubit objects to perform the action
delay_between_pulses_start (int) – Initial time delay between drive pulses in the Ramsey sequence
delay_between_pulses_end (list) – List of maximum time delays between drive pulses in the Ramsey sequence
delay_between_pulses_step (int) – Scan range step for the time delay between drive pulses in the Ramsey sequence
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
A DataUnits object with the raw data obtained for the fast and precision sweeps with the following keys
MSR[V]: Resonator signal voltage mesurement in volts
i[V]: Resonator signal voltage mesurement for the component I in volts
q[V]: Resonator signal voltage mesurement for the component Q in volts
phase[rad]: Resonator signal phase mesurement in radians
wait[ns]: Wait time used in the current Ramsey execution
t_max[ns]: Maximum time delay between drive pulses in the Ramsey sequence
qubit: The qubit being tested
iteration: The iteration number of the many determined by software_averages
A DataUnits object with the fitted data obtained with the following keys
delta_frequency: Physical detunning of the actual qubit frequency
drive_frequency:
T2: New qubit frequency after correcting the actual qubit frequency with the detunning calculated
popt0: offset
popt1: oscillation amplitude
popt2: frequency
popt3: phase
popt4: T2
qubit: The qubit being tested
- qibocal.calibrations.characterization.ramsey.ramsey(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, delay_between_pulses_start, delay_between_pulses_end, delay_between_pulses_step, software_averages=1, points=10)#
The purpose of the Ramsey experiment is to determine two of the qubit’s properties: Ramsey or detuning frequency and T2.
Ramsey sequence: Rx(pi/2) - wait time - Rx(pi/2) - ReadOut
- Parameters
platform (AbstractPlatform) – Qibolab platform object
qubits (dict) – Dict of target Qubit objects to perform the action
delay_between_pulses_start (int) – Initial time delay between drive pulses in the Ramsey sequence
delay_between_pulses_end (list) – Maximum time delay between drive pulses in the Ramsey sequence
delay_between_pulses_step (int) – Scan range step for the time delay between drive pulses in the Ramsey sequence
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
A DataUnits object with the raw data obtained for the fast and precision sweeps with the following keys
MSR[V]: Resonator signal voltage mesurement in volts
i[V]: Resonator signal voltage mesurement for the component I in volts
q[V]: Resonator signal voltage mesurement for the component Q in volts
phase[rad]: Resonator signal phase mesurement in radians
wait[ns]: Wait time used in the current Ramsey execution
t_max[ns]: Maximum time delay between drive pulses in the Ramsey sequence
qubit: The qubit being tested
iteration: The iteration number of the many determined by software_averages
A DataUnits object with the fitted data obtained with the following keys
delta_frequency: Physical detunning of the actual qubit frequency
drive_frequency:
T2: New qubit frequency after correcting the actual qubit frequency with the detunning calculated
popt0: offset
popt1: oscillation amplitude
popt2: frequency
popt3: phase
popt4: T2
qubit: The qubit being tested
T1#
- qibocal.calibrations.characterization.t1.t1(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: list, delay_before_readout_start, delay_before_readout_end, delay_before_readout_step, software_averages=1, points=10)#
In a T1 experiment, we measure an excited qubit after a delay. Due to decoherence processes (e.g. amplitude damping channel), it is possible that, at the time of measurement, after the delay, the qubit will not be excited anymore. The larger the delay time is, the more likely is the qubit to fall to the ground state. The goal of the experiment is to characterize the decay rate of the qubit towards the ground state.
- Parameters
platform (AbstractPlatform) – Qibolab platform object
qubits (list) – List of target qubits to perform the action
delay_before_readout_start (int) – Initial time delay before ReadOut
delay_before_readout_end (list) – Maximum time delay before ReadOut
delay_before_readout_step (int) – Scan range step for the delay before ReadOut
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
A DataUnits object with the raw data obtained for the fast and precision sweeps with the following keys
MSR[V]: Resonator signal voltage mesurement in volts
i[V]: Resonator signal voltage mesurement for the component I in volts
q[V]: Resonator signal voltage mesurement for the component Q in volts
phase[rad]: Resonator signal phase mesurement in radians
wait[ns]: Delay before ReadOut used in the current execution
qubit: The qubit being tested
iteration: The iteration number of the many determined by software_averages
A DataUnits object with the fitted data obtained with the following keys
labels[0]: T1
popt0: p0
popt1: p1
popt2: p2
qubit: The qubit being tested
Flipping#
- qibocal.calibrations.characterization.flipping.flipping(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, nflips_max, nflips_step, software_averages=1, points=10)#
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.
- Parameters
platform (AbstractPlatform) – Qibolab platform object
qubits (dict) – Dict of target Qubit objects to perform the action
nflips_max (int) – Maximum number of flips introduced in each sequence
nflips_step (int) – Scan range step for the number of flippings
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
A DataUnits object with the raw data obtained for the fast and precision sweeps with the following keys
MSR[V]: Resonator signal voltage mesurement in volts
i[V]: Resonator signal voltage mesurement for the component I in volts
q[V]: Resonator signal voltage mesurement for the component Q in volts
phase[rad]: Resonator signal phase mesurement in radians
flips[dimensionless]: Number of flips applied in the current execution
qubit: The qubit being tested
iteration: The iteration number of the many determined by software_averages
A DataUnits object with the fitted data obtained with the following keys
amplitude_correction_factor: Pi pulse correction factor
corrected_amplitude: Corrected pi pulse amplitude
popt0: p0
popt1: p1
popt2: p2
popt3: p3
qubit: The qubit being tested
All-XY#
- qibocal.calibrations.characterization.allXY.allXY(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, beta_param=None, software_averages=1, points=10)#
The AllXY experiment is a simple test of the calibration of single qubit gatesThe qubit (initialized in the |0> state) is subjected to two back-to-back single-qubit gates and measured. In each round, we run 21 different gate pairs: ideally, the first 5 return the qubit to |0>, the next 12 drive it to superposition state, and the last 4 put the qubit in |1> state.
- Parameters
platform (AbstractPlatform) – Qibolab platform object
qubits (dict) – Dict of target Qubit objects to perform the action
beta_param (float) – Drag pi pulse coefficient. If none, teh default shape defined in the runcard will be used.
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
A DataUnits object with the raw data obtained for the fast and precision sweeps with the following keys
MSR[V]: Difference between resonator signal voltage mesurement in volts from sequence 1 and 2
i[V]: Difference between resonator signal voltage mesurement for the component I in volts from sequence 1 and 2
q[V]: Difference between resonator signal voltage mesurement for the component Q in volts from sequence 1 and 2
phase[rad]: Difference between resonator signal phase mesurement in radians from sequence 1 and 2
probability[dimensionless]: Probability of being in |0> state
gateNumber[dimensionless]: Gate number applied from the list of gates
qubit: The qubit being tested
iteration: The iteration number of the many determined by software_averages
- qibocal.calibrations.characterization.allXY.allXY_drag_pulse_tuning(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, beta_start, beta_end, beta_step, software_averages=1, points=10)#
The AllXY experiment is a simple test of the calibration of single qubit gatesThe qubit (initialized in the |0> state) is subjected to two back-to-back single-qubit gates and measured. In each round, we run 21 different gate pairs: ideally, the first 5 return the qubit to |0>, the next 12 drive it to superposition state, and the last 4 put the qubit in |1> state.
The AllXY iteration method allows the user to execute iteratively the list of gates playing with the drag pulse shape in order to find the optimal drag pulse coefficient for pi pulses.
- Parameters
platform (AbstractPlatform) – Qibolab platform object
qubits (dict) – Dict of target Qubit objects to perform the action
beta_start (float) – Initial drag pulse beta parameter
beta_end (float) – Maximum drag pulse beta parameter
beta_step (float) – Scan range step for the drag pulse beta parameter
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
A DataUnits object with the raw data obtained for the fast and precision sweeps with the following keys
MSR[V]: Difference between resonator signal voltage mesurement in volts from sequence 1 and 2
i[V]: Difference between resonator signal voltage mesurement for the component I in volts from sequence 1 and 2
q[V]: Difference between resonator signal voltage mesurement for the component Q in volts from sequence 1 and 2
phase[rad]: Difference between resonator signal phase mesurement in radians from sequence 1 and 2
probability[dimensionless]: Probability of being in |0> state
gateNumber[dimensionless]: Gate number applied from the list of gates
beta_param[dimensionless]: Beta paramter applied in the current execution
qubit: The qubit being tested
iteration: The iteration number of the many determined by software_averages
- qibocal.calibrations.characterization.allXY.drag_pulse_tuning(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, beta_start, beta_end, beta_step, software_averages=1, points=10)#
In this experiment, we apply two sequences in a given qubit: Rx(pi/2) - Ry(pi) and Ry(pi) - Rx(pi/2) for a range of different beta parameter values. After fitting, we obtain the best coefficient value for a pi pulse with drag shape.
- Parameters
platform (AbstractPlatform) – Qibolab platform object
qubits (dict) – Dict of target Qubit objects to perform the action
beta_start (float) – Initial drag pulse beta parameter
beta_end (float) – Maximum drag pulse beta parameter
beta_step (float) – Scan range step for the drag pulse beta parameter
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
A DataUnits object with the raw data obtained for the fast and precision sweeps with the following keys
MSR[V]: Difference between resonator signal voltage mesurement in volts from sequence 1 and 2
i[V]: Difference between resonator signal voltage mesurement for the component I in volts from sequence 1 and 2
q[V]: Difference between resonator signal voltage mesurement for the component Q in volts from sequence 1 and 2
phase[rad]: Difference between resonator signal phase mesurement in radians from sequence 1 and 2
beta_param[dimensionless]: Optimal drag coefficient
qubit: The qubit being tested
iteration: The iteration number of the many determined by software_averages
A DataUnits object with the fitted data obtained with the following keys
optimal_beta_param: Best drag pulse coefficent
popt0: offset
popt1: oscillation amplitude
popt2: period
popt3: phase
qubit: The qubit being tested
State calibration#
- qibocal.calibrations.characterization.calibrate_qubit_states.calibrate_qubit_states(platform: qibolab.platforms.abstract.AbstractPlatform, qubits: dict, nshots, points=10)#
Method which implements the state’s calibration of a chosen qubit. Two analogous tests are performed for calibrate the ground state and the excited state of the oscillator. The subscripts exc and gnd will represent the excited state |1> and the ground state |0>.
- Parameters
platform (
qibolab.platforms.abstract.AbstractPlatform
) – custom abstract platform on which we perform the calibration.qubits (dict) – Dict of target Qubit objects to perform the action
nshots (int) – number of times the pulse sequence will be repeated.
software_averages (int) – Number of executions of the routine for averaging results
points (int) – Save data results in a file every number of points
- Returns
A DataUnits object with the raw data obtained for the fast and precision sweeps with the following keys
MSR[V]: Resonator signal voltage mesurement in volts
i[V]: Resonator signal voltage mesurement for the component I in volts
q[V]: Resonator signal voltage mesurement for the component Q in volts
phase[rad]: Resonator signal phase mesurement in radians
iteration[dimensionless]: Execution number
qubit: The qubit being tested
iteration: The iteration number of the many determined by software_averages
Data structure#
In qibocal
there are two different objects to manipulate data: qibocal.data.DataUnits
and qibocal.data.Data
.
qibocal.data.DataUnits
is used to store physical related quantities, such as voltages and frequencies. It is a wrapper to a
pandas.DataFrame where the units of measure for each quantity
are implemented using pint.
qibocal.data.Data
can be used manipulate non-physical quantities.
They provide different formats for storing data including pickle and csv.
- class qibocal.data.DataUnits(name=None, quantities=None, options=None)#
Class to store the data measured during the calibration routines. It is a wrapper to a pandas DataFrame with units of measure from the Pint library.
- Parameters
- property df#
Dataframe attribute.
- load_data_from_dict(data: dict)#
Load dataframe from dictionary.
- Parameters
data (dict) – dictionary containing the data to be loaded. Every key should have the following form:
<name>[<unit>]
.
- add_data_from_dict(data: dict)#
Add the contents of a dictionary to the data of the dataframe. :param df: dictionary containing the data to be added. :type df: dict
- add(data)#
Add a row to DataUnits.
- Parameters
data (dict) – dictionary containing the data to be added. Every key should have the following form:
<name>[<unit>]
.
- get_values(key, unit=None)#
Get values of a quantity in specified units.
- classmethod load_data(folder, subfolder, routine, data_format, name)#
Load data from specific format.
- Parameters
- Returns
dataset object with the loaded data.
- Return type
data (
DataUnits
)
Example
see the method
load_data
in classData
- to_csv(path)#
Save data in csv file.
- Parameters
path (str) – Path containing output folder.
Example
import os from qibocal.data import DataUnits import numpy as np data = DataUnits() length = 3 folder = "foo" # create directory if not os.path.isdir(folder): os.mkdir(folder) # generate random dataset for l in range(length): msr, i, q, phase = np.random.rand(4) pulse_sequence_result = { "MSR[V]": msr, "i[V]": i, "q[V]": q, "phase[rad]]": phase, } data.add({**pulse_sequence_result}) data.to_csv(folder)
- class qibocal.data.Data(name=None, quantities=None)#
Class to store the data obtained from calibration routines. It is a wrapper to a pandas DataFrame.
- Parameters
quantities (list) – list of quantities to be saved.
- property df#
Dataframe attribute.
- load_data_from_dict(data: dict)#
Set df attribute.
- Parameters
df (dict) – dictionary containing the data to be added.
Example
from qibocal.data import Data data = Data() test = { "int": [1, 2, 3], "float": [3.0, 4.0, 5.0], "string": ["one", "two", "three"], "bool": [True, False, True], } data.load_data_from_dict(test) print(data.df)
int float string bool 0 1 3.0 one True 1 2 4.0 two False 2 3 5.0 three True
- add(data)#
Add a row to data.
- Parameters
data (dict) – dictionary containing the data to be added. Every key should have the following form:
<name>[<unit>]
.
- get_values(quantity)#
Get values of a quantity.
- Parameters
quantity (str) – Quantity to get the values of.
- Returns
pd.Series
with the quantity values in the given units.
- classmethod load_data(folder, subfolder, routine, data_format, name)#
Load data from specific format.
- Parameters
- Returns
data object with the loaded data.
- Return type
data (
Data
)
Example
from qibocal.data import Data import os folder = "test_folder/test_subfolder/test_routine" length = 3 if not os.path.isdir(folder): os.makedirs(folder) # create a dataset data = Data() for i in range(length): data.add( { "int": int(i), "float": float(i), "string": str(f"hello{i}"), "bool": bool(i), } ) # save the dataset in csv format data.to_csv(folder) # upload the dataset data_upload = Data().load_data("test_folder", "test_subfolder", "test_routine", "csv", "data")
- to_csv(path)#
Save data in csv file.
- Parameters
path (str) – Path containing output folder.
Example
import shutil from qibocal.data import Data import numpy as np import os data = Data() length = 3 folder = "foo" # create directory if not os.path.isdir(folder): os.mkdir(folder) # generate a dataset data = Data() for i in range(length): data.add( { "int": int(i), "float": float(i), "string": str(f"hello{i}"), "bool": bool(i), } ) data.to_csv(folder)
Fitting functions#
Qibocal
offers routine-specific method for post-processing analysis of the data generated by the different Calibration routines.
Routine-specific method for post-processing data acquired.
- qibocal.fitting.methods.lorentzian_fit(data, x, y, qubits, resonator_type, labels, fit_file_name=None)#
Fitting routine for resonator/qubit spectroscopy. The used model is
\[y = \frac{A}{\pi} \Big[ \frac{\sigma}{(f-f_0)^2 + \sigma^2} \Big] + y_0.\]Args:
- Parameters
data (DataUnits) – dataset for the fit
x (str) – name of the input values for the Lorentzian model
y (str) – name of the output values for the Lorentzian model
qubits (list) – A list with the IDs of the qubits
resonator_type (str) – the type of readout resonator [‘3D’, ‘2D’]
labels (list of str) –
list containing the lables of the quantities computed by this fitting method.
When using
resonator_spectroscopy
the expected labels are [readout_frequency, peak voltage], where readout_frequency is the estimated frequency of the resonator, and peak_voltage the peak of the Lorentzianwhen using
qubit_spectroscopy
the expected labels are [drive_frequency, peak voltage], where drive_frequency is the estimated frequency of the qubit
fit_file_name (str) – file name,
None
is the default value.
- Returns
A
Data
object with the following keyslabels[0]: peak voltage
labels[1]: frequency
popt0: Lorentzian’s amplitude
popt1: Lorentzian’s center
popt2: Lorentzian’s sigma
popt3: Lorentzian’s offset
qubit: The qubit being tested
Example
In the code below, a noisy Lorentzian dataset is implemented and then the
lorentzian_fit
method is applied.import numpy as np from qibocal.data import DataUnits from qibocal.fitting.methods import lorentzian_fit from qibocal.fitting.utils import lorenzian import matplotlib.pyplot as plt name = "test" nqubits = 1 label = "drive_frequency" amplitude = -1 center = 2 sigma = 3 offset = 4 # generate noisy Lorentzian x = np.linspace(center - 10, center + 10, 100) noisy_lorentzian = ( lorenzian(x, amplitude, center, sigma, offset) + amplitude * np.random.randn(100) * 0.5e-2 ) # Initialize data and evaluate the fit data = DataUnits(quantities={"frequency": "Hz"}, options=["qubit", "iteration"]) mydict = {"frequency[Hz]": x, "MSR[V]": noisy_lorentzian, "qubit": 0, "iteration" : 0} data.load_data_from_dict(mydict) fit = lorentzian_fit( data, "frequency[Hz]", "MSR[V]", qubits = [0], resonator_type='3D', labels=[label, "peak_voltage", "intermediate_freq"], fit_file_name=name, ) fit_params = [fit.get_values(f"popt{i}") for i in range(4)] fit_data = lorenzian(x,*fit_params) # Plot #fig = plt.figure(figsize = (10,5)) #plt.scatter(x,noisy_lorentzian,label="data",s=10,color = 'darkblue',alpha = 0.9) #plt.plot(x,fit_data, label = "fit", color = 'violet', linewidth = 3, alpha = 0.4) #plt.xlabel('frequency (Hz)') #plt.ylabel('MSR (Volt)') #plt.legend() #plt.title("Data fit") #plt.grid() #plt.show()
The following plot shows the resulting output:
- qibocal.fitting.methods.rabi_fit(data, x, y, qubits, resonator_type, labels)#
Fitting routine for Rabi experiment. The used model is
\[y = p_0 + p_1 sin(2 \pi p_2 x + p_3) e^{-x p_4}.\]- Parameters
data (DataUnits) – dataset for the fit
x (str) – name of the input values for the Rabi model
y (str) – name of the output values for the Rabi model
qubits (list) – A list with the IDs of the qubits
resonator_type (str) – the type of readout resonator [‘3D’, ‘2D’]
labels (list of str) – list containing the lables of the quantities computed by this fitting method.
- Returns
A
Data
object with the following keyspopt0: offset
popt1: oscillation amplitude
popt2: frequency
popt3: phase
popt4: T2
labels[0]: pulse parameter
labels[1]: pulse’s maximum voltage
qubit: The qubit being tested
- qibocal.fitting.methods.ramsey_fit(data, x, y, qubits, resonator_type, qubit_freqs, sampling_rate, offset_freq, labels)#
Fitting routine for Ramsey experiment. The used model is
\[y = p_0 + p_1 sin \Big(p_2 x + p_3 \Big) e^{-x p_4}.\]- Parameters
data (DataUnits) – dataset for the fit
x (str) – name of the input values for the Ramsey model
y (str) – name of the output values for the Ramsey model
qubits (list) – A list with the IDs of the qubits
qubits_freq (float) – frequency of the qubit
sampling_rate (float) – Platform sampling rate
offset_freq (float) – Total qubit frequency offset. It contains the artificial detunning applied by the experimentalist + the inherent offset in the actual qubit frequency stored in the runcard.
labels (list of str) – list containing the lables of the quantities computed by this fitting method.
- Returns
A
Data
object with the following keyspopt0: offset
popt1: oscillation amplitude
popt2: frequency
popt3: phase
popt4: T2
labels[0]: Physical detunning of the actual qubit frequency
labels[1]: New qubit frequency after correcting the actual qubit frequency with the detunning calculated (labels[0])
labels[2]: T2
qubit: The qubit being tested
- qibocal.fitting.methods.t1_fit(data, x, y, qubits, resonator_type, labels)#
Fitting routine for T1 experiment. The used model is
\[y = p_0-p_1 e^{-x p_2}.\]- Parameters
data (DataUnits) – dataset for the fit
x (str) – name of the input values for the T1 model
y (str) – name of the output values for the T1 model
qubit (int) – ID qubit number
nqubits (int) – total number of qubits
labels (list of str) – list containing the lables of the quantities computed by this fitting method.
- Returns
A
Data
object with the following keyspopt0: p0
popt1: p1
popt2: p2
labels[0]: T1.
- qibocal.fitting.methods.flipping_fit(data, x, y, qubits, resonator_type, pi_pulse_amplitudes, labels)#
Fitting routine for T1 experiment. The used model is
\[y = p_0 sin\Big(\frac{2 \pi x}{p_2} + p_3\Big).\]- Parameters
data (DataUnits) – dataset for the fit
x (str) – name of the input values for the flipping model
y (str) – name of the output values for the flipping model
qubit (int) – ID qubit number
nqubits (int) – total number of qubits
niter (int) – Number of times of the flipping sequence applied to the qubit
pi_pulse_amplitudes (list) – list of corrected pi pulse amplitude
labels (list of str) – list containing the lables of the quantities computed by this fitting method.
- Returns
A
Data
object with the following keyspopt0: p0
popt1: p1
popt2: p2
popt3: p3
labels[0]: delta amplitude
labels[1]: corrected amplitude
- qibocal.fitting.methods.drag_tuning_fit(data: qibocal.data.Data, x, y, qubits, labels)#
Fitting routine for drag tunning. The used model is
\[y = p_1 cos \Big(\frac{2 \pi x}{p_2} + p_3 \Big) + p_0.\]- Parameters
- Returns
A
Data
object with the following keyspopt0: offset
popt1: oscillation amplitude
popt2: period
popt3: phase
labels[0]: optimal beta.
- qibocal.fitting.methods.res_spectroscopy_flux_fit(data, x, y, qubit, fluxline, params_fit)#
- Fit frequency as a function of current for the flux resonator spectroscopy
Args: data (DataUnits): Data file with information on the feature response at each current point. x (str): Column of the data file associated to x-axis. y (str): Column of the data file associated to y-axis. qubit (int): qubit coupled to the resonator that we are probing. fluxline (int): id of the current line used for the experiment. params_fit (list): List of parameters for the fit. [freq_rh, g, Ec, Ej].
freq_rh is the resonator frequency at high power and g in the readout coupling. If Ec and Ej are missing, the fit is valid in the transmon limit and if they are indicated, contains the next-order correction.
- Returns
Data file with labels and fit parameters.
- Return type
data_fit (Data)
- qibocal.fitting.methods.res_spectroscopy_flux_matrix(folder, fluxlines)#
- Calculation of the resonator flux matrix, Mf.
curr = Mf*freq + offset_c. Mf = Mc^-1, offset_c = -Mc^-1 * offset_f freq = Mc*curr + offset_f
Args: folder (str): Folder where the data files with the experimental and fit data are. fluxlines (list): ids of the current line used for the experiment.
- Returns
- Data file with len(fluxlines)+1 columns that contains the flux matrix (Mf) and
offset (offset_c) in the last column.
- Return type
data (Data)
- qibocal.fitting.methods.spin_echo_fit(data, x, y, qubits, resonator_type, labels)#
- qibocal.fitting.methods.calibrate_qubit_states_fit(data, x, y, nshots, qubits)#
Gate set characterization#
Abstract and Basic methods#
- class qibocal.calibrations.niGSC.basics.experiment.Experiment(circuitfactory: Iterable | None, data: Iterable | None = None, nshots: int | None = 128, noise_model: NoiseModel | None = None)#
Bases:
object
Experiment objects which holds an iterable circuit factory along with a simple data structure associated to each circuit.
- Parameters
circuitfactory (Iterable) – Gives a certain amount of circuits when iterated over.
nshots (int) – For execution of circuit, indicates how many shots.
data (list) – If filled,
data
can be used to specifying parameters while executing a circuit or deciding how to process results. It is used to store all relevant data.
- property noise_model#
- property dataframe: pandas.core.frame.DataFrame#
- classmethod load(path: str) qibocal.calibrations.niGSC.basics.experiment.Experiment #
Creates an experiment object with data and if possible with circuits.
- Parameters
path (str) – The directory from where the object should be restored.
- Returns
The object with data (and circuitfactory).
- Return type
- save(path: str | None = None) str #
Creates a path if None given and pickles relevant data from
self.data
and ifself.circuitfactory
is a list that one too.- Returns
The path of stored experiment.
- Return type
(str)
- extract(output_key: str, groupby_key: str = '', agg_type: str | Callable = '') np.ndarray | tuple[np.ndarray, np.ndarray] #
Return wanted values from
self.data
via the dataframe property.If
groupby_key
given, aggregate the dataframe, extract the data by which the frame was grouped, what was calculated given theagg_type
parameter. Two arrays are returned then, the group values and the grouped (aggregated) data. If noagg_type
given use a linear function. Ifgroupby_key
not given, only return the extracted data from given key.- Parameters
- Returns
Either one or two np.ndarrays. If no grouping wanted, just the data. If grouping wanted, the values after which where grouped and the grouped data.
- prebuild() None #
Converts the attribute
circuitfactory
which is in general an iterable into a list.
- perform(sequential_task: Callable[[qibo.models.circuit.Circuit, dict], dict]) None #
Takes a given function, checks the status of attribute
circuitfactory
anddata
and executes the sequential function row by row altering theself.data
attribute.Either
self.circuitfactory
orself.data
cannot beNone
and if notNone
they have to have the right length.
- execute(circuit: qibo.models.circuit.Circuit, datarow: dict) dict #
Executes a circuit, returns the single shot results in a dict.
- Parameters
circuit (Circuit) – Will be executed, has to return samples.
datarow (dict) – Dictionary with parameters for execution and immediate postprocessing information.
In this python script the fitting methods for the gate set protocols are defined. They consist mostly of exponential decay fitting.
- qibocal.calibrations.niGSC.basics.fitting.exp1_func(x: numpy.ndarray, A: float, f: float) numpy.ndarray #
Return \(A\cdot f^x\) where
x
is annp.ndarray
andA
,f
are floats
- qibocal.calibrations.niGSC.basics.fitting.exp1B_func(x: numpy.ndarray, A: float, f: float, B: float) numpy.ndarray #
Return \(A\cdot f^x+B\) where
x
is annp.ndarray
andA
,f
,B
are floats
- qibocal.calibrations.niGSC.basics.fitting.exp2_func(x: numpy.ndarray, A1: float, A2: float, f1: float, f2: float) numpy.ndarray #
Return \(A_1\cdot f_1^x+A_2\cdot f_2^x\) where
x
is annp.ndarray
andA1
,f1
,A2
,f2
are floats. There is no linear offsett B.
- qibocal.calibrations.niGSC.basics.fitting.esprit(xdata: numpy.ndarray, ydata: numpy.ndarray, num_decays: int, hankel_dim: Optional[int] = None) numpy.ndarray #
Implements the ESPRIT algorithm for peak detection.
- Parameters
- Returns
The decay parameters.
- Return type
np.ndarray
- Raises
ValueError – When the x-labels are not equally spaced the algorithm does not work.
- qibocal.calibrations.niGSC.basics.fitting.fit_exp1B_func(xdata: Union[numpy.ndarray, list], ydata: Union[numpy.ndarray, list], **kwargs) Tuple[tuple, tuple] #
Calculate an single exponential A*p^m+B fit to the given ydata.
- qibocal.calibrations.niGSC.basics.fitting.fit_exp1_func(xdata: Union[numpy.ndarray, list], ydata: Union[numpy.ndarray, list], **kwargs) Tuple[tuple, tuple] #
Calculate an single exponential A*p^m fit to the given ydata, no linear offset.
- qibocal.calibrations.niGSC.basics.fitting.fit_exp2_func(xdata: Union[numpy.ndarray, list], ydata: Union[numpy.ndarray, list], **kwargs) Tuple[tuple, tuple] #
Calculate 2 exponentials on top of each other, fit to the given ydata.
No linear offset, the ESPRIT algorithm is used to identify the two exponential decays.
- class qibocal.calibrations.niGSC.basics.plot.Report#
Bases:
object
Once initialized with the correct parameters an Report object can build reports to display results of a gate set characterization experiment.
- build()#
- qibocal.calibrations.niGSC.basics.plot.scatter_fit_fig(experiment: qibocal.calibrations.niGSC.basics.experiment.Experiment, df_aggr: pandas.core.frame.DataFrame, xlabel: str, index: str)#
- qibocal.calibrations.niGSC.basics.utils.experiment_directory(name: str)#
Make the directory where the experiment will be stored.
- qibocal.calibrations.niGSC.basics.utils.effective_depol(error_channel, **kwargs)#
- qibocal.calibrations.niGSC.basics.utils.probabilities(allsamples: Union[list, numpy.ndarray]) numpy.ndarray #
Takes the given list/array (3-dimensional) of samples and returns probabilities for each possible state to occure.
The states for 4 qubits are order as follows: [(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 1, 0), (0, 0, 1, 1), (0, 1, 0, 0), (0, 1, 0, 1), (0, 1, 1, 0), (0, 1, 1, 1), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 1, 0), (1, 0, 1, 1), (1, 1, 0, 0), (1, 1, 0, 1), (1, 1, 1, 0), (1, 1, 1, 1)]
- Parameters
allsamples (Union[list, np.ndarray]) – The single shot samples, 3-dimensional.
- Returns
Probability array of 2 dimension.
- Return type
np.ndarray
- qibocal.calibrations.niGSC.basics.utils.copy_circuit(circuit: qibo.models.circuit.Circuit)#
- qibocal.calibrations.niGSC.basics.utils.gate_fidelity(eff_depol: float, primitive=False) float #
Returns the average gate fidelity given the effective depolarizing parameter for single qubits.
If primitive is True, divide by additional 1.875 as convetion in RB reporting. (The original reasoning was that Clifford gates are typically compiled with an average number of 1.875 Pi half pulses.)
Costum error models are build here for making it possible to pass strings describing the error model via runcards in qibocal. They inherit from the qibo noise NoiseModel module and are prebuild.
- class qibocal.calibrations.niGSC.basics.noisemodels.PauliErrorOnUnitary(*args)#
Bases:
qibo.noise.NoiseModel
Builds a noise model with pauli flips acting on unitaries.
If no initial parameters for px, py, pz are given, random values are drawn (in sum not bigger than 1).
- build(*params)#
- class qibocal.calibrations.niGSC.basics.noisemodels.PauliErrorOnX(*args)#
Bases:
qibocal.calibrations.niGSC.basics.noisemodels.PauliErrorOnUnitary
Builds a noise model with pauli flips acting on X gates.
Inherited from
PauliErrorOnUnitary
but thebuild
method is overwritten to act on X gates. If no initial parameters for px, py, pz are given, random values are drawn (in sum not bigger than 1).- build(*params)#
Standard RB#
Here the standard randomized benchmarking is implemented using the niGSC (non-interactive gate set characterization) architecture.
- class qibocal.calibrations.niGSC.standardrb.ModuleFactory(nqubits: int, depths: list, qubits: list = [])#
Bases:
qibocal.calibrations.niGSC.basics.circuitfactory.SingleCliffordsFactory
- build_circuit(depth: int) qibo.models.circuit.Circuit #
Overwrites parent method. Add an inverse gate before the measurement.
- Parameters
depth (int) – How many gate layers.
- Returns
A circuit with single qubit Clifford gates with
depth
many layers and an inverse gate before the measurement gate.- Return type
(Circuit)
- class qibocal.calibrations.niGSC.standardrb.ModuleExperiment(circuitfactory: Iterable, data: Iterable | None = None, nshots: int | None = None, noise_model: NoiseModel = None)#
Bases:
qibocal.calibrations.niGSC.basics.experiment.Experiment
- class qibocal.calibrations.niGSC.standardrb.moduleReport#
- qibocal.calibrations.niGSC.standardrb.groundstate_probabilities(circuit: qibo.models.circuit.Circuit, datarow: dict) dict #
Calculates the ground state probability with data from single shot measurements.
- qibocal.calibrations.niGSC.standardrb.post_processing_sequential(experiment: qibocal.calibrations.niGSC.basics.experiment.Experiment)#
Perform sequential tasks needed to analyze the experiment results.
The data is added/changed in the experiment, nothing has to be returned.
- Parameters
experiment (Experiment) – Experiment object after execution of the experiment itself.
- qibocal.calibrations.niGSC.standardrb.get_aggregational_data(experiment: qibocal.calibrations.niGSC.basics.experiment.Experiment) pandas.core.frame.DataFrame #
Computes aggregational tasks, fits data and stores the results in a data frame.
No data is manipulated in the
experiment
object.- Parameters
experiment (Experiment) – After sequential postprocessing of the experiment data.
- Returns
The summarized data.
- Return type
pd.DataFrame
- qibocal.calibrations.niGSC.standardrb.build_report(experiment: qibocal.calibrations.niGSC.basics.experiment.Experiment, df_aggr: pandas.core.frame.DataFrame) plotly.graph_objs._figure.Figure #
Use data and information from
experiment
and the aggregated data data frame to build a report as plotly figure.- Parameters
experiment (Experiment) – After sequential postprocessing of the experiment data.
df_aggr (pd.DataFrame) – Normally build with
get_aggregational_data
function.
- Returns
A plotly.graphical_object.Figure object.
- Return type
(Figure)
Simultaneous Filtered RB#
- class qibocal.calibrations.niGSC.simulfilteredrb.ModuleFactory(nqubits: int, depths: list, qubits: list = [])#
Bases:
qibocal.calibrations.niGSC.basics.circuitfactory.SingleCliffordsFactory
- class qibocal.calibrations.niGSC.simulfilteredrb.ModuleExperiment(circuitfactory: Iterable, data: Iterable | None = None, nshots: int | None = None, noise_model: NoiseModel = None)#
Bases:
qibocal.calibrations.niGSC.basics.experiment.Experiment
Inherits from abstract
Experiment
class.- execute(circuit: qibo.models.circuit.Circuit, datarow: dict) dict #
Overwrited parents method. Executes a circuit, returns the single shot results and depth.
- Parameters
circuit (Circuit) – Will be executed, has to return samples.
datarow (dict) – Dictionary with parameters for execution and immediate postprocessing information.
- class qibocal.calibrations.niGSC.simulfilteredrb.moduleReport#
- qibocal.calibrations.niGSC.simulfilteredrb.filter_function(circuit: qibo.models.circuit.Circuit, datarow: dict) dict #
Calculates the filtered signal for every crosstalk irrep.
Every irrep has a projector charactarized with a bit string \(\boldsymbol{\lambda}\in\mathbb{F}_2^N\) where \(N\) is the number of qubits. The experimental outcome for each qubit is denoted as \(\ket{i_k}\) with \(i_k=0, 1\) with \(d=2\).
\[f_{\boldsymbol{\lambda}}(i,g) = \frac{1}{2^{N-|\boldsymbol{\lambda}|}} \sum_{\mathbf b\in\mathbb F_2^N} (-1)^{|\boldsymbol{\lambda}\wedge\mathbf b|} \frac{1}{d^N}\left(\prod_{k=1}^N(d|\bra{i_k} U_{g_{(k)}} \ket{0}|^2)^{\lambda_k-\lambda_kb_k}\right)\]
- qibocal.calibrations.niGSC.simulfilteredrb.post_processing_sequential(experiment: qibocal.calibrations.niGSC.basics.experiment.Experiment)#
Perform sequential tasks needed to analyze the experiment results.
The data is added/changed in the experiment, nothign has to be returned.
- Parameters
experiment (Experiment) – Experiment object after execution of the experiment itself.
- qibocal.calibrations.niGSC.simulfilteredrb.get_aggregational_data(experiment: qibocal.calibrations.niGSC.basics.experiment.Experiment) pandas.core.frame.DataFrame #
Computes aggregational tasks, fits data and stores the results in a data frame.
No data is manipulated in the
experiment
object.- Parameters
experiment (Experiment) – After sequential postprocessing of the experiment data.
- Returns
The summarized data.
- Return type
pd.DataFrame
- qibocal.calibrations.niGSC.simulfilteredrb.build_report(experiment: qibocal.calibrations.niGSC.basics.experiment.Experiment, df_aggr: pandas.core.frame.DataFrame) plotly.graph_objs._figure.Figure #
Use data and information from
experiment
and the aggregated data dataframe to build a reprot as plotly figure.- Parameters
experiment (Experiment) – After sequential postprocessing of the experiment data.
df_aggr (pd.DataFrame) – Normally build with
get_aggregational_data
function.
- Returns
A plotly.graphical_object.Figure object.
- Return type
(Figure)
X-ID RB#
This script implements an easy 1-qubit protocol with only X-gates and identities. It is a great example on how to write an own niGSC protocol. The single functions above have little descriptions for the purpose of that function and what is important to include.
Step:
Define the two module specific classes which are used in defining and executing an experiment, the circuit factory and experiment class. They can also just inherit everything from another module.
Step:
Write the sequential post processing functions.
Step:
Write the aggregational post processing function.
Step:
Write the function to build a report. When using the qq module, a plotly figure has to be returned.
- class qibocal.calibrations.niGSC.XIdrb.ModuleFactory(nqubits: int, depths: list, qubits: list = [])#
Bases:
qibocal.calibrations.niGSC.basics.circuitfactory.CircuitFactory
- build_circuit(depth: int)#
Initiate a
qibo.models.Circuit
object and fill it with the wanted gates.Which gates are wanted is encoded in
self.gates_layer()
. Add a measurement gate for every qubit.- Parameters
depth (int) – How many layers there are in the circuit.
- Returns
the circuit with
depth
many layers.- Return type
Circuit
- class qibocal.calibrations.niGSC.XIdrb.ModuleExperiment(circuitfactory: Iterable, data: Iterable | None = None, nshots: int | None = None, noise_model: NoiseModel = None)#
Bases:
qibocal.calibrations.niGSC.basics.experiment.Experiment
- execute(circuit: qibo.models.circuit.Circuit, datarow: dict) dict #
Executes a circuit, returns the single shot results in a dict.
- Parameters
circuit (Circuit) – Will be executed, has to return samples.
datarow (dict) – Dictionary with parameters for execution and immediate postprocessing information.
- class qibocal.calibrations.niGSC.XIdrb.moduleReport#
- qibocal.calibrations.niGSC.XIdrb.filter_sign(circuit: qibo.models.circuit.Circuit, datarow: dict) dict #
Calculates the filtered signal for the XId.
\(n_X\) denotes the amount of \(X\) gates in the circuit with gates \(g\) and :math`i` the outcome which is either ground state \(0\) or exited state \(1\).
\[f_{\text{sign}}(i,g) = (-1)^{n_X\%2 + i}/2\]
- qibocal.calibrations.niGSC.XIdrb.post_processing_sequential(experiment: qibocal.calibrations.niGSC.basics.experiment.Experiment)#
Perform sequential tasks needed to analyze the experiment results.
The data is added/changed in the experiment, nothing has to be returned.
- Parameters
experiment (Experiment) – Experiment object after execution of the experiment itself.
- qibocal.calibrations.niGSC.XIdrb.get_aggregational_data(experiment: qibocal.calibrations.niGSC.basics.experiment.Experiment) pandas.core.frame.DataFrame #
Computes aggregational tasks, fits data and stores the results in a data frame.
No data is manipulated in the
experiment
object.- Parameters
experiment (Experiment) – After sequential postprocessing of the experiment data.
- Returns
The summarized data.
- Return type
pd.DataFrame
- qibocal.calibrations.niGSC.XIdrb.build_report(experiment: qibocal.calibrations.niGSC.basics.experiment.Experiment, df_aggr: pandas.core.frame.DataFrame) plotly.graph_objs._figure.Figure #
Use data and information from
experiment
and the aggregated data data frame to build a report as plotly figure.- Parameters
experiment (Experiment) – After sequential postprocessing of the experiment data.
df_aggr (pd.DataFrame) – Normally build with
get_aggregational_data
function.
- Returns
A plotly.graphical_object.Figure object.
- Return type
(Figure)