RX90 calibration implementation

src/qibocal/protocols/rabi/amplitude.py

@@ -41,6 +41,8 @@ class RabiAmplitudeData(Data):
     """Pulse durations provided by the user."""
     data: dict[QubitId, npt.NDArray[RabiAmpType]] = field(default_factory=dict)
     """Raw data acquired."""
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
 
 
 def _acquisition(
@@ -65,6 +67,7 @@ def _acquisition(
     )
 
     data = RabiAmplitudeData(durations=durations)
+    data.pihalf_pulse = params.pihalf_pulse
 
     # 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,7 +144,9 @@ 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_amplitude(
+        results.amplitude[target], results.pihalf_pulse, platform, target
+    )
     update.drive_duration(results.length[target], platform, target)
 
 

src/qibocal/protocols/rabi/amplitude_frequency.py

@@ -60,6 +60,9 @@ class RabiAmplitudeFreqData(RabiAmplitudeFreqSignalData):
     data: dict[QubitId, npt.NDArray[RabiAmpFreqType]] = field(default_factory=dict)
     """Raw data acquired."""
 
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
+
     def register_qubit(self, qubit, freq, amp, prob, error):
         """Store output for single qubit."""
         size = len(freq) * len(amp)
@@ -102,6 +105,7 @@ def _acquisition(
     )
 
     data = RabiAmplitudeFreqData(durations=durations)
+    data.pihalf_pulse = params.pihalf_pulse
 
     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

@@ -44,6 +44,8 @@ class RabiAmplitudeFrequencySignalParameters(Parameters):
     """Frequency to use as step for the scan."""
     pulse_length: Optional[float] = None
     """RX pulse duration [ns]."""
+    pihalf_pulse: Optional[bool] = True
+    """Calibration of native pihalf pulse, if false calibrates pi pulse"""
 
 
 @dataclass
@@ -75,6 +77,8 @@ class RabiAmplitudeFreqSignalData(Data):
         default_factory=dict
     )
     """Raw data acquired."""
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
 
     def register_qubit(self, qubit, freq, amp, signal, phase):
         """Store output for single qubit."""
@@ -127,6 +131,7 @@ def _acquisition(
     )
 
     data = RabiAmplitudeFreqSignalData(durations=durations)
+    data.pihalf_pulse = params.pihalf_pulse
 
     results = platform.execute(
         [sequence],
@@ -198,6 +203,7 @@ def _fit(data: RabiAmplitudeFreqSignalData) -> RabiAmplitudeFrequencySignalResul
         length=data.durations,
         fitted_parameters=fitted_parameters,
         frequency=fitted_frequencies,
+        pihalf_pulse=data.pihalf_pulse,
     )
 
 
@@ -296,7 +302,9 @@ def _update(
     target: QubitId,
 ):
     update.drive_duration(results.length[target], platform, target)
-    update.drive_amplitude(results.amplitude[target], 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]."""
+    pihalf_pulse: Optional[bool] = True
+    """Calibration of native pihalf pulse, if false calibrates pi 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(
@@ -55,6 +59,8 @@ class RabiAmplitudeSignalData(Data):
     """Pulse durations provided by the user."""
     data: dict[QubitId, npt.NDArray[RabiAmpSignalType]] = field(default_factory=dict)
     """Raw data acquired."""
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
 
 
 def _acquisition(
@@ -80,6 +86,7 @@ def _acquisition(
     )
 
     data = RabiAmplitudeSignalData(durations=durations)
+    data.pihalf_pulse = params.pihalf_pulse
 
     # 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,7 +165,9 @@ def _plot(
 def _update(
     results: RabiAmplitudeSignalResults, platform: CalibrationPlatform, target: QubitId
 ):
-    update.drive_amplitude(results.amplitude[target], platform, target)
+    update.drive_amplitude(
+        results.amplitude[target], results.pihalf_pulse, platform, target
+    )
     update.drive_duration(results.length[target], platform, target)
 
 

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: Optional[bool] = True
+    """Calibration of native pihalf pulse, if false calibrates pi pulse"""
     interpolated_sweeper: bool = False
     """Use real-time interpolation if supported by instruments."""
 
@@ -87,6 +89,7 @@ def _acquisition(
         )
 
     data = RabiLengthData(amplitudes=amplitudes)
+    data.pihalf_pulse = params.pihalf_pulse
 
     # execute the sweep
     results = platform.execute(
@@ -155,11 +158,15 @@ 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_duration(
+        results.length[target], results.pihalf_pulse, platform, target
+    )
     update.drive_amplitude(results.amplitude[target], platform, target)
 
 

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."""
+    pihalf_pulse: Optional[bool] = True
+    """Calibration of native pihalf pulse, if false calibrates pi pulse"""
     interpolated_sweeper: bool = False
     """Use real-time interpolation if supported by instruments."""
 
@@ -72,6 +74,8 @@ class RabiLengthFreqSignalData(Data):
         default_factory=dict
     )
     """Raw data acquired."""
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
 
     def register_qubit(self, qubit, freq, lens, signal, phase):
         """Store output for single qubit."""
@@ -137,6 +141,7 @@ def _acquisition(
         )
 
     data = RabiLengthFreqSignalData(amplitudes=amplitudes)
+    data.pihalf_pulse = params.pihalf_pulse
 
     results = platform.execute(
         [sequence],
@@ -207,6 +212,7 @@ def _fit(data: RabiLengthFreqSignalData) -> RabiLengthFrequencySignalResults:
         amplitude=data.amplitudes,
         fitted_parameters=fitted_parameters,
         frequency=fitted_frequencies,
+        pihalf_pulse=data.pihalf_pulse,
     )
 
 
@@ -305,7 +311,9 @@ def _update(
     platform: CalibrationPlatform,
     target: QubitId,
 ):
-    update.drive_amplitude(results.amplitude[target], platform, target)
+    update.drive_amplitude(
+        results.amplitude[target], results.pihalf_pulse, platform, target
+    )
     update.drive_duration(results.length[target], platform, target)
     update.drive_frequency(results.frequency[target], platform, target)
 

src/qibocal/protocols/rabi/length_signal.py

@@ -27,6 +27,8 @@ class RabiLengthSignalParameters(Parameters):
     """Step pi pulse duration [ns]."""
     pulse_amplitude: Optional[float] = None
     """Pi pulse amplitude. Same for all qubits."""
+    pihalf_pulse: Optional[bool] = True
+    """Calibration of native pihalf pulse, if false calibrates pi pulse"""
     interpolated_sweeper: bool = False
     """Use real-time interpolation if supported by instruments."""
 
@@ -41,6 +43,8 @@ class RabiLengthSignalResults(Results):
     """Pi pulse amplitude. Same for all qubits."""
     fitted_parameters: dict[QubitId, dict[str, float]]
     """Raw fitting output."""
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
 
 
 RabiLenSignalType = np.dtype(
@@ -57,6 +61,8 @@ class RabiLengthSignalData(Data):
     """Pulse durations provided by the user."""
     data: dict[QubitId, npt.NDArray[RabiLenSignalType]] = field(default_factory=dict)
     """Raw data acquired."""
+    pihalf_pulse: bool
+    """Pi or Pi_half calibration"""
 
 
 def _acquisition(
@@ -92,6 +98,7 @@ def _acquisition(
         )
 
     data = RabiLengthSignalData(amplitudes=amplitudes)
+    data.pihalf_pulse = params.pihalf_pulse
 
     # execute the sweep
     results = platform.execute(
@@ -153,13 +160,17 @@ def _fit(data: RabiLengthSignalData) -> RabiLengthSignalResults:
         except Exception as e:
             log.warning(f"Rabi fit failed for qubit {qubit} due to {e}.")
 
-    return RabiLengthSignalResults(durations, data.amplitudes, fitted_parameters)
+    return RabiLengthSignalResults(
+        durations, data.amplitudes, fitted_parameters, data.pihalf_pulse
+    )
 
 
 def _update(
     results: RabiLengthSignalResults, platform: CalibrationPlatform, target: QubitId
 ):
-    update.drive_duration(results.length[target], platform, target)
+    update.drive_duration(
+        results.length[target], results.pihalf_pulse, platform, target
+    )
     update.drive_amplitude(results.amplitude[target], platform, target)
 
 

src/qibocal/protocols/rabi/utils.py

@@ -223,9 +223,13 @@ def period_correction_factor(phase: float):
 
 
 def sequence_amplitude(
-    targets: list[QubitId], params: Parameters, platform: Platform
+    targets: list[QubitId],
+    params: Parameters,
+    platform: Platform,
+    pulse: bool,  # if true calibrate pi_half pulse
 ) -> tuple[PulseSequence, dict, dict, dict]:
     """Return sequence for rabi amplitude."""
+
     sequence = PulseSequence()
     qd_pulses = {}
     ro_pulses = {}
@@ -242,6 +246,9 @@ def sequence_amplitude(
         qd_pulses[q] = qd_pulse
         ro_pulses[q] = ro_pulse
 
+        if pulse:
+            sequence.append((qd_channel, qd_pulses[q]))
+
         sequence.append((qd_channel, qd_pulses[q]))
         sequence.append((ro_channel, Delay(duration=durations[q])))
         sequence.append((ro_channel, ro_pulse))
@@ -252,9 +259,11 @@ def sequence_length(
     targets: list[QubitId],
     params: Parameters,
     platform: Platform,
+    pulse: bool,  # if true calibrate pi_half pulse
     use_align: bool = False,
 ) -> tuple[PulseSequence, dict, dict, dict]:
     """Return sequence for rabi length."""
+
     sequence = PulseSequence()
     qd_pulses = {}
     delays = {}
@@ -272,6 +281,9 @@ def sequence_length(
         qd_pulses[q] = qd_pulse
         ro_pulses[q] = ro_pulse
 
+        if pulse:
+            sequence.append((qd_channel, qd_pulse))
+
         sequence.append((qd_channel, qd_pulse))
         if use_align:
             sequence.align([qd_channel, ro_channel])

src/qibocal/update.py

@@ -54,11 +54,16 @@ def drive_frequency(
     platform.update({f"configs.{drive_channel}.frequency": freq})
 
 
-def drive_amplitude(amp: Union[float, tuple, list], platform: Platform, qubit: QubitId):
+def drive_amplitude(
+    amp: Union[float, tuple, list], pi_half: bool, platform: Platform, qubit: QubitId
+):
     """Update drive frequency value in platform for specific qubit."""
     if isinstance(amp, Iterable):
         amp = amp[0]
-    platform.update({f"native_gates.single_qubit.{qubit}.RX.0.1.amplitude": amp})
+    if pi_half:
+        platform.update({f"native_gates.single_qubit.{qubit}.RX90.0.1.amplitude": amp})
+    else:
+        platform.update({f"native_gates.single_qubit.{qubit}.RX.0.1.amplitude": amp})
 
 
 def drive_duration(