qibocal.protocols.characterization.flux_dependence package#

Submodules#

qibocal.protocols.characterization.flux_dependence.qubit_flux_dependence module#

class qibocal.protocols.characterization.flux_dependence.qubit_flux_dependence.QubitFluxParameters(freq_width: int, freq_step: int, bias_width: float, bias_step: float, drive_amplitude: Optional[float] = None, flux_qubits: Optional[list[Union[str, int]]] = None, nshots: Optional[int] = None, relaxation_time: Optional[int] = None, transition: Optional[str] = '01')[source]#

Bases: Parameters

QubitFlux runcard inputs.

freq_width: int#

Width for frequency sweep relative to the qubit frequency (Hz).

freq_step: int#

Frequency step for sweep [Hz].

bias_width: float#

Width for bias sweep [V].

bias_step: float#

Bias step for sweep (V).

drive_amplitude: Optional[float] = None#

Drive amplitude (optional). If defined, same amplitude will be used in all qubits. Otherwise the default amplitude defined on the platform runcard will be used

flux_qubits: Optional[list[Union[str, int]]] = None#

IDs of the qubits that we will sweep the flux on. If None flux will be swept on all qubits that we are running the routine on in a multiplex fashion. If given flux will be swept on the given qubits in a sequential fashion (n qubits will result to n different executions). Multiple qubits may be measured in each execution as specified by the qubits option in the runcard.

nshots: Optional[int] = None#

Number of shots.

relaxation_time: Optional[int] = None#

Relaxation time (ns).

transition: Optional[str] = '01'#

Flux spectroscopy transition type (“01” or “02”). Default value is 01

class qibocal.protocols.characterization.flux_dependence.qubit_flux_dependence.QubitFluxResults(sweetspot: dict[Union[str, int], float], frequency: dict[Union[str, int], float], fitted_parameters: dict[Union[str, int], dict[str, float]])[source]#

Bases: Results

QubitFlux outputs.

sweetspot: dict[Union[str, int], float]#

Sweetspot for each qubit.

frequency: dict[Union[str, int], float]#

Drive frequency for each qubit.

fitted_parameters: dict[Union[str, int], dict[str, float]]#

Raw fitting output.

class qibocal.protocols.characterization.flux_dependence.qubit_flux_dependence.FluxCrosstalkResults[source]#

Bases: Results

Empty fitting outputs for cross talk because fitting is not implemented in this case.

qibocal.protocols.characterization.flux_dependence.qubit_flux_dependence.QubitFluxType = dtype([('freq', '<f8'), ('bias', '<f8'), ('msr', '<f8'), ('phase', '<f8')])#

Custom dtype for resonator flux dependence.

class qibocal.protocols.characterization.flux_dependence.qubit_flux_dependence.QubitFluxData(resonator_type: str, Ec: dict[typing.Union[str, int], int] = <factory>, Ej: dict[typing.Union[str, int], int] = <factory>, data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('bias', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]] = <factory>)[source]#

Bases: Data

QubitFlux acquisition outputs.

resonator_type: str#

ResonatorFlux acquisition outputs.

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

Qubit Ec provided by the user.

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

Qubit Ej provided by the user.

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

Raw data acquired.

register_qubit(qubit, flux_qubit, freq, bias, msr, phase)[source]#

Store output for single qubit.

class qibocal.protocols.characterization.flux_dependence.qubit_flux_dependence.FluxCrosstalkData(resonator_type: str, Ec: dict[typing.Union[str, int], int] = <factory>, Ej: dict[typing.Union[str, int], int] = <factory>, data: dict[typing.Union[str, int], dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('bias', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]]] = <factory>)[source]#

Bases: QubitFluxData

QubitFlux acquisition outputs when flux_qubits are given.

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

Raw data acquired for (qubit, qubit_flux) pairs saved in nested dictionaries.

register_qubit(qubit, flux_qubit, freq, bias, msr, phase)[source]#

Store output for single qubit.

qibocal.protocols.characterization.flux_dependence.qubit_flux_dependence.qubit_flux = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

QubitFlux Routine object.

qibocal.protocols.characterization.flux_dependence.resonator_flux_dependence module#

class qibocal.protocols.characterization.flux_dependence.resonator_flux_dependence.ResonatorFluxParameters(freq_width: int, freq_step: int, bias_width: float, bias_step: float, flux_qubits: Optional[list[Union[str, int]]] = None, nshots: Optional[int] = None, relaxation_time: Optional[int] = None)[source]#

Bases: Parameters

ResonatorFlux runcard inputs.

freq_width: int#

Width for frequency sweep relative to the readout frequency (Hz).

freq_step: int#

Frequency step for sweep [Hz].

bias_width: float#

Width for bias sweep [V].

bias_step: float#

Bias step for sweep (V).

flux_qubits: Optional[list[Union[str, int]]] = None#

IDs of the qubits that we will sweep the flux on. If None flux will be swept on all qubits that we are running the routine on in a multiplex fashion. If given flux will be swept on the given qubits in a sequential fashion (n qubits will result to n different executions). Multiple qubits may be measured in each execution as specified by the qubits option in the runcard.

nshots: Optional[int] = None#

Number of shots.

relaxation_time: Optional[int] = None#

Relaxation time (ns).

class qibocal.protocols.characterization.flux_dependence.resonator_flux_dependence.ResonatorFluxResults(sweetspot: dict[Union[str, int], float], frequency: dict[Union[str, int], float], fitted_parameters: dict[Union[str, int], dict[str, float]])[source]#

Bases: Results

ResonatoFlux outputs.

sweetspot: dict[Union[str, int], float]#

Sweetspot for each qubit.

frequency: dict[Union[str, int], float]#

Readout frequency for each qubit.

fitted_parameters: dict[Union[str, int], dict[str, float]]#

Raw fitting output.

class qibocal.protocols.characterization.flux_dependence.resonator_flux_dependence.FluxCrosstalkResults[source]#

Bases: Results

Empty fitting outputs for cross talk because fitting is not implemented in this case.

qibocal.protocols.characterization.flux_dependence.resonator_flux_dependence.ResFluxType = dtype([('freq', '<f8'), ('bias', '<f8'), ('msr', '<f8'), ('phase', '<f8')])#

Custom dtype for resonator flux dependence.

class qibocal.protocols.characterization.flux_dependence.resonator_flux_dependence.ResonatorFluxData(resonator_type: str, Ec: dict[typing.Union[str, int], int] = <factory>, Ej: dict[typing.Union[str, int], int] = <factory>, g: dict[typing.Union[str, int], int] = <factory>, bare_resonator_frequency: dict[typing.Union[str, int], int] = <factory>, data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('bias', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]] = <factory>)[source]#

Bases: Data

Resonator type.

resonator_type: str#

ResonatorFlux acquisition outputs.

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

Qubit Ec provided by the user.

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

Qubit Ej provided by the user.

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

Qubit g provided by the user.

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

Qubit bare resonator frequency power provided by the user.

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

Raw data acquired.

register_qubit(qubit, flux_qubit, freq, bias, msr, phase)[source]#

Store output for single qubit.

class qibocal.protocols.characterization.flux_dependence.resonator_flux_dependence.FluxCrosstalkData(resonator_type: str, Ec: dict[typing.Union[str, int], int] = <factory>, Ej: dict[typing.Union[str, int], int] = <factory>, g: dict[typing.Union[str, int], int] = <factory>, bare_resonator_frequency: dict[typing.Union[str, int], int] = <factory>, data: dict[typing.Union[str, int], dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('freq', '<f8'), ('bias', '<f8'), ('msr', '<f8'), ('phase', '<f8')])]]]] = <factory>)[source]#

Bases: ResonatorFluxData

QubitFlux acquisition outputs when flux_qubits are given.

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

Raw data acquired for (qubit, qubit_flux) pairs saved in nested dictionaries.

register_qubit(qubit, flux_qubit, freq, bias, msr, phase)[source]#

Store output for single qubit.

qibocal.protocols.characterization.flux_dependence.resonator_flux_dependence.resonator_flux = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>)#

ResonatorFlux Routine object.

qibocal.protocols.characterization.flux_dependence.utils module#

qibocal.protocols.characterization.flux_dependence.utils.create_data_array(freq, bias, msr, phase, dtype)[source]#

Create custom dtype array for acquired data.

qibocal.protocols.characterization.flux_dependence.utils.flux_dependence_plot(data, fit, qubit)[source]#
qibocal.protocols.characterization.flux_dependence.utils.flux_crosstalk_plot(data, fit, qubit)[source]#
qibocal.protocols.characterization.flux_dependence.utils.G_f_d(x, p0, p1, p2)[source]#

Auxiliary function to calculate the qubit frequency as a function of bias for the qubit flux spectroscopy. It also determines the flux dependence of \(E_J\), \(E_J(\phi)=E_J(0)G_f_d^2\).

Parameters

  • p[0] (float) – bias offset.

  • p[1] (float) – constant to convert flux (\(\phi_0\)) to bias (\(v_0\)). Typically denoted as \(\Xi\). \(v_0 = \Xi \phi_0\).

  • p[2] (float) – asymmetry between the two junctions of the transmon. Typically denoted as \(d\). \(d = (E_J^1 - E_J^2) / (E_J^1 + E_J^2)\).

Returns

(float)

qibocal.protocols.characterization.flux_dependence.utils.freq_q_transmon(x, p0, p1, p2, p3)[source]#

Qubit frequency in the boson description. Close to the half-flux quantum (:math:’phi=0.5`), \(E_J/E_C = E_J(\phi=0)*d/E_C\) can be too small for a quasi-symmetric split-transmon to apply this expression. We assume that the qubit frequencty \(\gg E_C\).

Parameters

  • p[0] (float) – bias offset.

  • p[1] (float) – constant to convert flux (\(\phi_0\)) to bias (\(v_0\)). Typically denoted as \(\Xi\). \(v_0 = \Xi \phi_0\).

  • p[2] (float) – asymmetry between the two junctions of the transmon. Typically denoted as \(d\). \(d = (E_J^1 - E_J^2) / (E_J^1 + E_J^2)\).

  • p[3] (float) – qubit frequency at the sweetspot.

Returns

(float)

qibocal.protocols.characterization.flux_dependence.utils.freq_r_transmon(x, p0, p1, p2, p3, p4, p5)[source]#

Flux dependent resonator frequency in the transmon limit.

Parameters

  • p[0] (float) – bias offset.

  • p[1] (float) – constant to convert flux (\(\phi_0\)) to bias (\(v_0\)). Typically denoted as \(\Xi\). \(v_0 = \Xi \phi_0\).

  • p[2] (float) – asymmetry between the two junctions of the transmon. Typically denoted as \(d\). \(d = (E_J^1 - E_J^2) / (E_J^1 + E_J^2)\).

  • p[3] (float) – qubit frequency at the sweetspot / high power resonator frequency,

  • p[4] (float) – readout coupling at the sweetspot. Typically denoted as \(g\).

  • p[5] (float) – high power resonator frequency.

Returns

(float)

qibocal.protocols.characterization.flux_dependence.utils.kordering(m, ng=0.4999)[source]#

Auxilliary function to compute the qubit frequency in the CPB model (useful when the boson description fails). It sorts the eigenvalues \(|m,ng\rangle\) for the Schrodinger equation for the Cooper pair box circuit in the phase basis.

Parameters

  • m (integer) – index denoting the m eigenvector.

  • ng (float) – effective offset charge. The sorting does not work for ng integer or half-integer. To study the sweet spot at \(ng = 0.5\) for instance, one should insert an approximation like \(ng = 0.4999\).

Returns

(float)

qibocal.protocols.characterization.flux_dependence.utils.mathieu(index, x)[source]#

Mathieu’s characteristic value. Auxilliary function to compute the qubit frequency in the CPB model.

Parameters

index (integer) – index to specify the Mathieu’s characteristic value.

Returns

(float)

qibocal.protocols.characterization.flux_dependence.utils.freq_q_mathieu(x, p0, p1, p2, p3, p4, p5=0.499)[source]#

Qubit frequency in the CPB model. It is useful when the boson description fails and to determine \(E_C\) and \(E_J\).

Parameters

  • p[0] (float) – bias offset.

  • p[1] (float) – constant to convert flux (\(\phi_0\)) to bias (\(v_0\)). Typically denoted as \(\Xi\). \(v_0 = \Xi \phi_0\).

  • p[2] (float) – asymmetry between the two junctions of the transmon. Typically denoted as \(d\). \(d = (E_J^1 - E_J^2) / (E_J^1 + E_J^2)\).

  • p[3] (float) – charge energy at the sweetspot, \(E_C\).

  • p[4] (float) – Josephson energy, \(E_J\).

  • p[5] (float) – effective offset charge, \(ng\).

Returns

(float)

qibocal.protocols.characterization.flux_dependence.utils.freq_r_mathieu(x, p0, p1, p2, p3, p4, p5, p6, p7=0.499)[source]#

Resonator frequency in the CPB model.

Parameters

  • p[0] (float) – high power resonator frequency.

  • p[1] (float) – readout coupling at the sweetspot.

  • p[2] (float) – bias offset.

  • p[3] (float) – constant to convert flux (\(\phi_0\)) to bias (\(v_0\)). Typically denoted as \(\Xi\). \(v_0 = \Xi \phi_0\).

  • p[4] (float) – asymmetry between the two junctions of the transmon. Typically denoted as \(d\). \(d = (E_J^1 - E_J^2) / (E_J^1 + E_J^2)\).

  • p[5] (float) – charge energy at the sweetspot, \(E_C\).

  • p[6] (float) – Josephson energy, \(E_J\).

  • p[7] (float) – effective offset charge, \(ng\).

Returns

(float)

qibocal.protocols.characterization.flux_dependence.utils.line(x, p0, p1)[source]#

Linear fit.

Parameters

  • p[0] (float) – slope.

  • p[1] (float) – intercept.

Returns

(float)

qibocal.protocols.characterization.flux_dependence.utils.feature(x, order=3)[source]#

Auxilliary function for the function image_to_curve(). It generates a polynomial feature of the form [1, x, x^2, …, x^order].

Parameters

x (ndarray) –

Returns

(ndarray)

qibocal.protocols.characterization.flux_dependence.utils.image_to_curve(x, y, z, msr_mask=0.5, alpha=1e-05, order=50)[source]#

Extracts a feature characterized by min(z(x, y)). It considers all the data and applies Ridge regression on a polynomial ansatz in x. This allows obtaining a set of points describing the feature as y vs x.

Parameters

  • x (ndarray) –

  • y (ndarray) –

  • z (ndarray) –

Returns

y_pred (ndarray) frequencies x_pred (ndarray) bias