RX90 calibration implementation

doc/source/protocols/rabi/rabi.rst

@@ -29,6 +29,9 @@ Rabi rate is larger than the decay and the pure dephasing rate,
 
 where :math:`\Omega_R` is the Rabi frequency and :math:`\tau` the decay time.
 
+In qibocal we implemented also another version of the Rabi experiment which can be used to tune the amplitude (duration) of the drive pulse in order
+to excite the qubit from the ground state up to state :math:`\frac{\ket{0}+\ket{1}}{\sqrt{2}}`.
+
 Parameters
 ^^^^^^^^^^
 
@@ -103,6 +106,30 @@ It follows an example runcard and plot for the signal exepriment
 
 .. image:: rabi_signal.png
 
+In all the previous examples we run Rabi experiments for calibrating the amplitude (duration) of the drive pulse
+to excite the qubit from the ground state up to state :math:`\ket{1}`.
+All the prievious example runcard can be modified to calibrate the amplitude (duration) of the drive pulse
+to excite the qubit from the ground state up to state :math:`\frac{\ket{0}+\ket{1}}{\sqrt{2}}` by simply setting the `rx90` parameter to `True`.
+
+In the following we show an example runcard
+
+.. code-block:: yaml
+
+
+    - id: Rabi signal
+      operation: rabi_amplitude_signal
+      parameters:
+        min_amp: 0.2
+        max_amp: 1.
+        step_amp: 0.01
+        pulse_length: 40
+        nshots: 3000
+        relaxation_time: 50000
+	RX90: False
+
+..
+   _Remember image and modify runcard!
+
 Requirements
 ^^^^^^^^^^^^
 - :ref:`qubit-spectroscopy`

src/qibocal/protocols/rabi/amplitude.py

@@ -37,6 +37,8 @@ class RabiAmplitudeResults(RabiAmplitudeSignalResults):
 class RabiAmplitudeData(Data):
     """RabiAmplitude data acquisition."""
 
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
     durations: dict[QubitId, float] = field(default_factory=dict)
     """Pulse durations provided by the user."""
     data: dict[QubitId, npt.NDArray[RabiAmpType]] = field(default_factory=dict)
@@ -65,6 +67,7 @@ def _acquisition(
     )
 
     data = RabiAmplitudeData(durations=durations)
+    data.pihalf_pulse = params.rx90
 
     # sweep the parameter
     results = platform.execute(
@@ -128,7 +131,9 @@ def _fit(data: RabiAmplitudeData) -> RabiAmplitudeResults:
 
         except Exception as e:
             log.warning(f"Rabi fit failed for qubit {qubit} due to {e}.")
-    return RabiAmplitudeResults(pi_pulse_amplitudes, durations, fitted_parameters, chi2)
+    return RabiAmplitudeResults(
+        pi_pulse_amplitudes, durations, fitted_parameters, data.pihalf_pulse, chi2
+    )
 
 
 def _plot(data: RabiAmplitudeData, target: QubitId, fit: RabiAmplitudeResults = None):
@@ -139,8 +144,12 @@ def _plot(data: RabiAmplitudeData, target: QubitId, fit: RabiAmplitudeResults =
 def _update(
     results: RabiAmplitudeResults, platform: CalibrationPlatform, target: QubitId
 ):
-    update.drive_amplitude(results.amplitude[target], platform, target)
-    update.drive_duration(results.length[target], platform, target)
+    update.drive_amplitude(
+        results.amplitude[target], results.pihalf_pulse, platform, target
+    )
+    update.drive_duration(
+        results.length[target], results.pihalf_pulse, platform, target
+    )
 
 
 rabi_amplitude = Routine(_acquisition, _fit, _plot, _update)

src/qibocal/protocols/rabi/amplitude_frequency.py

@@ -57,6 +57,9 @@ class RabiAmplitudeFrequencyResults(RabiAmplitudeFrequencySignalResults):
 class RabiAmplitudeFreqData(RabiAmplitudeFreqSignalData):
     """RabiAmplitudeFreq data acquisition."""
 
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
+
     data: dict[QubitId, npt.NDArray[RabiAmpFreqType]] = field(default_factory=dict)
     """Raw data acquired."""
 
@@ -102,6 +105,7 @@ def _acquisition(
     )
 
     data = RabiAmplitudeFreqData(durations=durations)
+    data.pihalf_pulse = params.rx90
 
     results = platform.execute(
         [sequence],
@@ -186,6 +190,7 @@ def _fit(data: RabiAmplitudeFreqData) -> RabiAmplitudeFrequencyResults:
         fitted_parameters=fitted_parameters,
         frequency=fitted_frequencies,
         chi2=chi2,
+        pihalf_pulse=data.pihalf_pulse,
     )
 
 

src/qibocal/protocols/rabi/amplitude_frequency_signal.py

@@ -42,6 +42,8 @@ class RabiAmplitudeFrequencySignalParameters(Parameters):
     """Maximum frequency as an offset."""
     step_freq: int
     """Frequency to use as step for the scan."""
+    rx90: bool = False
+    """Calibration of native pi pulse, if true calibrates pi/2 pulse"""
     pulse_length: Optional[float] = None
     """RX pulse duration [ns]."""
 
@@ -52,6 +54,8 @@ class RabiAmplitudeFrequencySignalResults(RabiAmplitudeSignalResults):
 
     frequency: dict[QubitId, Union[float, list[float]]]
     """Drive frequency for each qubit."""
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
 
 
 RabiAmpFreqSignalType = np.dtype(
@@ -69,6 +73,8 @@ class RabiAmplitudeFrequencySignalResults(RabiAmplitudeSignalResults):
 class RabiAmplitudeFreqSignalData(Data):
     """RabiAmplitudeFreqSignal data acquisition."""
 
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
     durations: dict[QubitId, float] = field(default_factory=dict)
     """Pulse durations provided by the user."""
     data: dict[QubitId, npt.NDArray[RabiAmpFreqSignalType]] = field(
@@ -127,6 +133,7 @@ def _acquisition(
     )
 
     data = RabiAmplitudeFreqSignalData(durations=durations)
+    data.pihalf_pulse = params.rx90
 
     results = platform.execute(
         [sequence],
@@ -198,6 +205,7 @@ def _fit(data: RabiAmplitudeFreqSignalData) -> RabiAmplitudeFrequencySignalResul
         length=data.durations,
         fitted_parameters=fitted_parameters,
         frequency=fitted_frequencies,
+        pihalf_pulse=data.pihalf_pulse,
     )
 
 
@@ -295,8 +303,12 @@ def _update(
     platform: CalibrationPlatform,
     target: QubitId,
 ):
-    update.drive_duration(results.length[target], platform, target)
-    update.drive_amplitude(results.amplitude[target], platform, target)
+    update.drive_duration(
+        results.length[target], results.pihalf_pulse, platform, target
+    )
+    update.drive_amplitude(
+        results.amplitude[target], results.pihalf_pulse, platform, target
+    )
     update.drive_frequency(results.frequency[target], platform, target)
 
 

src/qibocal/protocols/rabi/amplitude_signal.py

@@ -27,6 +27,8 @@ class RabiAmplitudeSignalParameters(Parameters):
     """Step amplitude."""
     pulse_length: Optional[float] = None
     """RX pulse duration [ns]."""
+    rx90: bool = False
+    """Calibration of native pi pulse, if true calibrates pi/2 pulse"""
 
 
 @dataclass
@@ -39,6 +41,8 @@ class RabiAmplitudeSignalResults(Results):
     """Drive pulse duration. Same for all qubits."""
     fitted_parameters: dict[QubitId, dict[str, float]]
     """Raw fitted parameters."""
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
 
 
 RabiAmpSignalType = np.dtype(
@@ -51,6 +55,8 @@ class RabiAmplitudeSignalResults(Results):
 class RabiAmplitudeSignalData(Data):
     """RabiAmplitudeSignal data acquisition."""
 
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
     durations: dict[QubitId, float] = field(default_factory=dict)
     """Pulse durations provided by the user."""
     data: dict[QubitId, npt.NDArray[RabiAmpSignalType]] = field(default_factory=dict)
@@ -80,6 +86,7 @@ def _acquisition(
     )
 
     data = RabiAmplitudeSignalData(durations=durations)
+    data.pihalf_pulse = params.rx90
 
     # sweep the parameter
     results = platform.execute(
@@ -142,7 +149,7 @@ def _fit(data: RabiAmplitudeSignalData) -> RabiAmplitudeSignalResults:
             log.warning(f"Rabi fit failed for qubit {qubit} due to {e}.")
 
     return RabiAmplitudeSignalResults(
-        pi_pulse_amplitudes, data.durations, fitted_parameters
+        pi_pulse_amplitudes, data.durations, fitted_parameters, data.pihalf_pulse
     )
 
 
@@ -158,8 +165,12 @@ def _plot(
 def _update(
     results: RabiAmplitudeSignalResults, platform: CalibrationPlatform, target: QubitId
 ):
-    update.drive_amplitude(results.amplitude[target], platform, target)
-    update.drive_duration(results.length[target], platform, target)
+    update.drive_amplitude(
+        results.amplitude[target], results.pihalf_pulse, platform, target
+    )
+    update.drive_duration(
+        results.length[target], results.pihalf_pulse, platform, target
+    )
 
 
 rabi_amplitude_signal = Routine(_acquisition, _fit, _plot, _update)

src/qibocal/protocols/rabi/ef.py

@@ -85,8 +85,8 @@ def _acquisition(
     )
 
     data = RabiAmplitudeEFData(durations=durations)
+    data.pihalf_pulse = params.pihalf_pulse
 
-    # sweep the parameter
     # sweep the parameter
     results = platform.execute(
         [sequence],
@@ -124,8 +124,12 @@ def _update(
     results: RabiAmplitudeEFResults, platform: CalibrationPlatform, target: QubitId
 ):
     """Update RX2 amplitude_signal"""
-    update.drive_12_amplitude(results.amplitude[target], platform, target)
-    update.drive_12_duration(results.length[target], platform, target)
+    update.drive_12_amplitude(
+        results.amplitude[target], results.pihalf_pulse, platform, target
+    )
+    update.drive_12_duration(
+        results.length[target], results.pihalf_pulse, platform, target
+    )
 
 
 rabi_amplitude_ef = Routine(_acquisition, amplitude_signal._fit, _plot, _update)

src/qibocal/protocols/rabi/length.py

@@ -31,6 +31,8 @@ class RabiLengthParameters(Parameters):
     """Step pi pulse duration [ns]."""
     pulse_amplitude: Optional[float] = None
     """Pi pulse amplitude. Same for all qubits."""
+    pihalf_pulse: bool = False
+    """Calibration of native pi pulse, if true calibrates pi/2 pulse"""
     interpolated_sweeper: bool = False
     """Use real-time interpolation if supported by instruments."""
 
@@ -39,6 +41,8 @@ class RabiLengthParameters(Parameters):
 class RabiLengthResults(RabiLengthSignalResults):
     """RabiLength outputs."""
 
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
     chi2: dict[QubitId, list[float]] = field(default_factory=dict)
 
 
@@ -87,6 +91,7 @@ def _acquisition(
         )
 
     data = RabiLengthData(amplitudes=amplitudes)
+    data.pihalf_pulse = params.rx90
 
     # execute the sweep
     results = platform.execute(
@@ -155,12 +160,18 @@ def _fit(data: RabiLengthData) -> RabiLengthResults:
         except Exception as e:
             log.warning(f"Rabi fit failed for qubit {qubit} due to {e}.")
 
-    return RabiLengthResults(durations, amplitudes, fitted_parameters, chi2)
+    return RabiLengthResults(
+        durations, amplitudes, fitted_parameters, data.pihalf_pulse, chi2
+    )
 
 
 def _update(results: RabiLengthResults, platform: CalibrationPlatform, target: QubitId):
-    update.drive_duration(results.length[target], platform, target)
-    update.drive_amplitude(results.amplitude[target], platform, target)
+    update.drive_duration(
+        results.length[target], results.pihalf_pulse, platform, target
+    )
+    update.drive_amplitude(
+        results.amplitude[target], results.pihalf_pulse, platform, target
+    )
 
 
 def _plot(data: RabiLengthData, fit: RabiLengthResults, target: QubitId):

src/qibocal/protocols/rabi/length_frequency.py

@@ -33,6 +33,8 @@ class RabiLengthFrequencyParameters(RabiLengthFrequencySignalParameters):
 class RabiLengthFrequencyResults(RabiLengthFrequencySignalResults):
     """RabiLengthFrequency outputs."""
 
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
     chi2: dict[QubitId, list[float]] = field(default_factory=dict)
 
 
@@ -51,6 +53,9 @@ class RabiLengthFrequencyResults(RabiLengthFrequencySignalResults):
 class RabiLengthFreqData(RabiLengthFreqSignalData):
     """RabiLengthFreq data acquisition."""
 
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
+
     data: dict[QubitId, npt.NDArray[RabiLenFreqType]] = field(default_factory=dict)
     """Raw data acquired."""
 
@@ -110,6 +115,7 @@ def _acquisition(
         )
 
     data = RabiLengthFreqData(amplitudes=amplitudes)
+    data.pihalf_pulse = params.rx90
 
     results = platform.execute(
         [sequence],

src/qibocal/protocols/rabi/length_frequency_signal.py

@@ -39,6 +39,8 @@ class RabiLengthFrequencySignalParameters(Parameters):
     """Frequency to use as step for the scan."""
     pulse_amplitude: Optional[float] = None
     """Pi pulse amplitude. Same for all qubits."""
+    rx90: bool = False
+    """Calibration of native pi pulse, if true calibrates pi/2 pulse"""
     interpolated_sweeper: bool = False
     """Use real-time interpolation if supported by instruments."""
 
@@ -47,6 +49,8 @@ class RabiLengthFrequencySignalParameters(Parameters):
 class RabiLengthFrequencySignalResults(RabiLengthSignalResults):
     """RabiLengthFrequency outputs."""
 
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
     frequency: dict[QubitId, Union[float, list[float]]]
     """Drive frequency for each qubit."""
 
@@ -66,6 +70,8 @@ class RabiLengthFrequencySignalResults(RabiLengthSignalResults):
 class RabiLengthFreqSignalData(Data):
     """RabiLengthFreqSignal data acquisition."""
 
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
     amplitudes: dict[QubitId, float] = field(default_factory=dict)
     """Pulse amplitudes provided by the user."""
     data: dict[QubitId, npt.NDArray[RabiLenFreqSignalType]] = field(
@@ -137,6 +143,7 @@ def _acquisition(
         )
 
     data = RabiLengthFreqSignalData(amplitudes=amplitudes)
+    data.pihalf_pulse = params.rx90
 
     results = platform.execute(
         [sequence],
@@ -207,6 +214,7 @@ def _fit(data: RabiLengthFreqSignalData) -> RabiLengthFrequencySignalResults:
         amplitude=data.amplitudes,
         fitted_parameters=fitted_parameters,
         frequency=fitted_frequencies,
+        pihalf_pulse=data.pihalf_pulse,
     )
 
 
@@ -305,8 +313,12 @@ def _update(
     platform: CalibrationPlatform,
     target: QubitId,
 ):
-    update.drive_amplitude(results.amplitude[target], platform, target)
-    update.drive_duration(results.length[target], platform, target)
+    update.drive_amplitude(
+        results.amplitude[target], results.pihalf_pulse, platform, target
+    )
+    update.drive_duration(
+        results.length[target], results.pihalf_pulse, platform, target
+    )
     update.drive_frequency(results.frequency[target], platform, target)