qibocal.protocols.ramsey package#

Submodules#

qibocal.protocols.ramsey.ramsey module#

class qibocal.protocols.ramsey.ramsey.RamseyParameters(delay_between_pulses_start: int, delay_between_pulses_end: int, delay_between_pulses_step: int, detuning: Optional[int] = 0, unrolling: bool = False)[source]#

Bases: RamseySignalParameters

Ramsey runcard inputs.

class qibocal.protocols.ramsey.ramsey.RamseyResults(frequency: dict[Union[str, int], tuple[float, Optional[float]]], t2: dict[Union[str, int], tuple[float, Optional[float]]], delta_phys: dict[Union[str, int], tuple[float, Optional[float]]], delta_fitting: dict[Union[str, int], tuple[float, Optional[float]]], fitted_parameters: dict[Union[str, int], list[float]], chi2: dict[Union[str, int], tuple[float, Optional[float]]])[source]#

Bases: RamseySignalResults

Ramsey outputs.

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

Chi squared estimate mean value and error.

qibocal.protocols.ramsey.ramsey.RamseyType = dtype([('wait', '<f8'), ('prob', '<f8'), ('errors', '<f8')])#

Custom dtype for coherence routines.

class qibocal.protocols.ramsey.ramsey.RamseyData(detuning: int, qubit_freqs: dict[typing.Union[str, int], float] = <factory>, data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('wait', '<f8'), ('prob', '<f8'), ('errors', '<f8')])]]] = <factory>)[source]#

Bases: RamseySignalData

Ramsey acquisition outputs.

data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('wait', '<f8'), ('prob', '<f8'), ('errors', '<f8')])]]]#

Raw data acquired.

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

Ramsey Routine object.

qibocal.protocols.ramsey.ramsey_signal module#

class qibocal.protocols.ramsey.ramsey_signal.RamseySignalParameters(delay_between_pulses_start: int, delay_between_pulses_end: int, delay_between_pulses_step: int, detuning: Optional[int] = 0, unrolling: bool = False)[source]#

Bases: Parameters

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

detuning: Optional[int] = 0#

Frequency detuning [Hz] (optional). If 0 standard Ramsey experiment is performed.

unrolling: bool = False#

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

class qibocal.protocols.ramsey.ramsey_signal.RamseySignalResults(frequency: dict[Union[str, int], tuple[float, Optional[float]]], t2: dict[Union[str, int], tuple[float, Optional[float]]], delta_phys: dict[Union[str, int], tuple[float, Optional[float]]], delta_fitting: dict[Union[str, int], tuple[float, Optional[float]]], fitted_parameters: dict[Union[str, int], list[float]])[source]#

Bases: Results

Ramsey outputs.

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

Drive frequency [GHz] for each qubit.

t2: dict[Union[str, int], tuple[float, Optional[float]]]#

T2 for each qubit [ns].

delta_phys: dict[Union[str, int], tuple[float, Optional[float]]]#

Drive frequency [Hz] correction for each qubit.

delta_fitting: dict[Union[str, int], tuple[float, Optional[float]]]#

Raw drive frequency [Hz] correction for each qubit. including the detuning.

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

Raw fitting output.

qibocal.protocols.ramsey.ramsey_signal.RamseySignalType = dtype([('wait', '<f8'), ('signal', '<f8')])#

Custom dtype for coherence routines.

class qibocal.protocols.ramsey.ramsey_signal.RamseySignalData(detuning: int, qubit_freqs: dict[typing.Union[str, int], float] = <factory>, data: dict[typing.Union[str, int], numpy.ndarray[typing.Any, numpy.dtype[dtype([('wait', '<f8'), ('signal', '<f8')])]]] = <factory>)[source]#

Bases: Data

Ramsey acquisition outputs.

detuning: int#

Frequency detuning [Hz].

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

Qubit freqs for each qubit.

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

Raw data acquired.

property waits#

Return a list with the waiting times without repetitions.

qibocal.protocols.ramsey.ramsey_signal.ramsey_signal = Routine(acquisition=<function _acquisition>, fit=<function _fit>, report=<function _plot>, update=<function _update>, two_qubit_gates=False)#

Ramsey Routine object.

qibocal.protocols.ramsey.utils module#

qibocal.protocols.ramsey.utils.POPT_EXCEPTION = [0, 0, 0, 0, 1]#

Fit parameters output to handle exceptions

qibocal.protocols.ramsey.utils.PERR_EXCEPTION = [1, 1, 1, 1, 1]#

Fit errors to handle exceptions; their choice has no physical meaning and is meant to avoid breaking the code.

qibocal.protocols.ramsey.utils.THRESHOLD = 0.5#

Threshold parameters for find_peaks to guess frequency for sinusoidal fit.

qibocal.protocols.ramsey.utils.ramsey_sequence(platform: Platform, qubit: Union[str, int], wait: Optional[int] = 0, detuning: Optional[int] = 0)[source]#

Pulse sequence used in Ramsey (detuned) experiments.

The pulse sequence is the following:

RX90 – wait – RX90 – MZ

If detuning is specified the RX90 pulses will be sent to frequency = drive_frequency + detuning

qibocal.protocols.ramsey.utils.ramsey_fit(x, offset, amplitude, delta, phase, decay)[source]#

Dumped sinusoidal fit.

qibocal.protocols.ramsey.utils.fitting(x: list, y: list, errors: Optional[list] = None) list[source]#

Given the inputs list x and outputs one y, this function fits the ramsey_fit function and returns a list with the fit parameters.