RX90 calibration implementation

doc/source/protocols/flipping.rst

@@ -1,16 +1,18 @@
 Flipping
 ========
 
-The flipping experiment corrects the amplitude in the qubit drive pulse. In this experiment,
-we applying an :math:`R_x(\pi/2)` rotation followed by :math:`N` flips (two :math:`R_x(\pi)` rotations)
+The flipping experiment corrects the amplitude in the qubit drive pulse for :math:`R_x(\pi)` rotations. In this experiment,
+we apply an :math:`R_x(\pi/2)` rotation followed by :math:`N` flips (two :math:`R_x(\pi)` rotations)
 and we measure the qubit state.
 The first :math:`R_x(\pi/2)` is necessary to discriminate the over rotations and under rotations of the :math:`R_x(\pi)` pulse:
 without it the difference between the two cases is just a global phase, i.e., the
 probabilities are the same. With the :math:`R_x(\pi/2)` pulse, in case of under rotations the state will be closer to :math:`\ket{0}`
 after the initial flip, in the over rotations one the final state will be closer to :math:`\ket{1}`.
 
 By fitting the resulting data with a sinusoidal function, we can determine the delta amplitude, which allows us to refine the
-:math:`\pi` pulse amplitue.
+:math:`\pi` pulse amplitude.
+
+We implemented also a version of the flipping protocol to calibrate the drive pulse amplitude of the :math:`R_x(\pi/2)` rotations, in this case each :math:`R_x(\pi)` rotation is replaced by two math:`R_x(\pi/2)` rotations.
 
 Parameters
 ^^^^^^^^^^
@@ -35,6 +37,18 @@ The expected output is the following:
 
 .. image:: flipping.png
 
+If the same experiment is run setting the `rx90: True` the flipping is performed to calibrate the amplitude of the :math:`R_x(\pi/2)` rotation
+
+.. code-block:: yaml
+
+	- id: flipping
+	  operation: flipping
+	  parameters:
+	    delta_amplitude: 0.05
+	    nflips_max: 30
+	    nflips_step: 1
+	    rx90: True
+
 Requirements
 ^^^^^^^^^^^^
 

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}-i\ket{1}}{\sqrt{2}}`.
+
 Parameters
 ^^^^^^^^^^
 
@@ -103,6 +106,29 @@ 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 these example runcards 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}-i\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.01
+        max_amp: 0.16
+        step_amp: 0.002
+        pulse_length: 40
+        nshots: 1024
+        relaxation_time: 50000
+	rx90: True
+
+.. image:: rabi_amplitude_rx90
+
 Requirements
 ^^^^^^^^^^^^
 - :ref:`qubit-spectroscopy`

pyproject.toml

@@ -17,8 +17,8 @@ classifiers = [
 
 [tool.poetry.dependencies]
 python = ">=3.9,<3.12"
-qibolab = { git = "https://github.com/qiboteam/qibolab.git" }
-qibo = "^0.2.12"
+qibolab = { git = "https://github.com/qiboteam/qibolab.git", branch = "pi_half" }
+qibo = "0.2.12"
 numpy = "^1.26.4"
 scipy = "^1.10.1"
 pandas = { version = "^2.2.2", extras = ["html"] }

src/qibocal/protocols/flipping.py

@@ -23,25 +23,45 @@
 
 
 def flipping_sequence(
-    platform: CalibrationPlatform, qubit: QubitId, delta_amplitude: float, flips: int
+    platform: CalibrationPlatform,
+    qubit: QubitId,
+    delta_amplitude: float,
+    flips: int,
+    rx90: bool,
 ):
     """Pulse sequence for flipping experiment."""
 
     sequence = PulseSequence()
     natives = platform.natives.single_qubit[qubit]
-    sequence |= natives.R(theta=np.pi / 2)
 
-    for _ in range(flips):
+    if rx90:
+        sequence |= natives.RX90()
 
-        qd_channel, rx_pulse = natives.RX()[0]
+        for _ in range(flips):
+            qd_channel, qd_pulse = natives.RX90()[0]
 
-        rx_detuned = update.replace(
-            rx_pulse, amplitude=rx_pulse.amplitude + delta_amplitude
-        )
-        sequence.append((qd_channel, rx_detuned))
-        sequence.append((qd_channel, rx_detuned))
+            qd_detuned = update.replace(
+                qd_pulse, delta_amplitude=qd_pulse.amplitude + delta_amplitude
+            )
 
-    sequence |= natives.MZ()
+            sequence.append((qd_channel, qd_detuned))
+            sequence.append((qd_channel, qd_detuned))
+            sequence.append((qd_channel, qd_detuned))
+            sequence.append((qd_channel, qd_detuned))
+
+    else:
+        sequence |= natives.R(theta=np.pi / 2)
+
+        for _ in range(flips):
+            qd_channel, qd_pulse = natives.RX()[0]
+
+            qd_detuned = update.replace(
+                qd_pulse, amplitude=qd_pulse.amplitude + delta_amplitude
+            )
+            sequence.append((qd_channel, qd_detuned))
+            sequence.append((qd_channel, qd_detuned))
+
+        sequence |= natives.MZ()
 
     return sequence
 
@@ -59,6 +79,8 @@ class FlippingParameters(Parameters):
     Defaults to ``False``."""
     delta_amplitude: float = 0
     """Amplitude detuning."""
+    rx90: bool = False
+    """Calibration of native pi pulse, if true calibrates pi/2 pulse"""
 
 
 @dataclass
@@ -73,6 +95,8 @@ class FlippingResults(Results):
     """Difference in amplitude between detuned value and fit."""
     fitted_parameters: dict[QubitId, dict[str, float]]
     """Raw fitting output."""
+    rx90: bool
+    """Pi or Pi_half calibration"""
     chi2: dict[QubitId, list[float]] = field(default_factory=dict)
     """Chi squared estimate mean value and error. """
 
@@ -90,8 +114,10 @@ class FlippingData(Data):
     """Resonator type."""
     delta_amplitude: float
     """Amplitude detuning."""
-    pi_pulse_amplitudes: dict[QubitId, float]
-    """Pi pulse amplitudes for each qubit."""
+    pulse_amplitudes: dict[QubitId, float]
+    """Pulse amplitudes for each qubit."""
+    rx90: bool
+    """Pi or Pi_half calibration"""
     data: dict[QubitId, npt.NDArray[FlippingType]] = field(default_factory=dict)
     """Raw data acquired."""
 
@@ -120,10 +146,15 @@ def _acquisition(
     data = FlippingData(
         resonator_type=platform.resonator_type,
         delta_amplitude=params.delta_amplitude,
-        pi_pulse_amplitudes={
-            qubit: platform.natives.single_qubit[qubit].RX[0][1].amplitude
+        pulse_amplitudes={
+            qubit: (
+                platform.natives.single_qubit[qubit].RX90[0][1].amplitude
+                if params.rx90
+                else platform.natives.single_qubit[qubit].RX[0][1].amplitude
+            )
             for qubit in targets
         },
+        rx90=params.rx90,
     )
 
     options = {
@@ -144,6 +175,7 @@ def _acquisition(
                 qubit=qubit,
                 delta_amplitude=params.delta_amplitude,
                 flips=flips,
+                rx90=params.rx90,
             )
 
         sequences.append(sequence)
@@ -197,9 +229,7 @@ def _fit(data: FlippingData) -> FlippingResults:
     chi2 = {}
     for qubit in qubits:
         qubit_data = data[qubit]
-        detuned_pi_pulse_amplitude = (
-            data.pi_pulse_amplitudes[qubit] + data.delta_amplitude
-        )
+        detuned_pulse_amplitude = data.pulse_amplitudes[qubit] + data.delta_amplitude
         y = qubit_data.prob
         x = qubit_data.flips
 
@@ -222,10 +252,14 @@ def _fit(data: FlippingData) -> FlippingResults:
             perr = np.sqrt(np.diag(perr)).tolist()
             popt = popt.tolist()
             correction = popt[2] / 2
+
+            if data.rx90:
+                correction = correction / 2
+
             corrected_amplitudes[qubit] = [
-                float(detuned_pi_pulse_amplitude * np.pi / (np.pi + correction)),
+                float(detuned_pulse_amplitude * np.pi / (np.pi + correction)),
                 float(
-                    detuned_pi_pulse_amplitude
+                    detuned_pulse_amplitude
                     * np.pi
                     * 1
                     / (np.pi + correction) ** 2
@@ -237,11 +271,9 @@ def _fit(data: FlippingData) -> FlippingResults:
             fitted_parameters[qubit] = popt
 
             delta_amplitude_detuned[qubit] = [
-                -correction * detuned_pi_pulse_amplitude / (np.pi + correction),
+                -correction * detuned_pulse_amplitude / (np.pi + correction),
                 np.abs(
-                    np.pi
-                    * detuned_pi_pulse_amplitude
-                    * np.power(np.pi + correction, -2)
+                    np.pi * detuned_pulse_amplitude * np.power(np.pi + correction, -2)
                 )
                 * perr[2]
                 / 2,
@@ -267,6 +299,7 @@ def _fit(data: FlippingData) -> FlippingResults:
         delta_amplitude,
         delta_amplitude_detuned,
         fitted_parameters,
+        data.rx90,
         chi2,
     )
 
@@ -358,7 +391,7 @@ def _plot(data: FlippingData, target: QubitId, fit: FlippingResults = None):
 
 
 def _update(results: FlippingResults, platform: CalibrationPlatform, qubit: QubitId):
-    update.drive_amplitude(results.amplitude[qubit], platform, qubit)
+    update.drive_amplitude(results.amplitude[qubit], results.rx90, platform, qubit)
 
 
 flipping = Routine(_acquisition, _fit, _plot, _update)

src/qibocal/protocols/rabi/amplitude.py

@@ -37,6 +37,8 @@ class RabiAmplitudeResults(RabiAmplitudeSignalResults):
 class RabiAmplitudeData(Data):
     """RabiAmplitude data acquisition."""
 
+    rx90: 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)
@@ -55,7 +57,7 @@ def _acquisition(
     """
 
     sequence, qd_pulses, ro_pulses, durations = utils.sequence_amplitude(
-        targets, params, platform
+        targets, params, platform, params.rx90
     )
 
     sweeper = Sweeper(
@@ -64,7 +66,7 @@ def _acquisition(
         pulses=[qd_pulses[qubit] for qubit in targets],
     )
 
-    data = RabiAmplitudeData(durations=durations)
+    data = RabiAmplitudeData(durations=durations, rx90=params.rx90)
 
     # sweep the parameter
     results = platform.execute(
@@ -128,19 +130,21 @@ 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.rx90, chi2
+    )
 
 
 def _plot(data: RabiAmplitudeData, target: QubitId, fit: RabiAmplitudeResults = None):
     """Plotting function for RabiAmplitude."""
-    return utils.plot_probabilities(data, target, fit)
+    return utils.plot_probabilities(data, target, fit, data.rx90)
 
 
 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.rx90, platform, target)
+    update.drive_duration(results.length[target], results.rx90, platform, target)
 
 
 rabi_amplitude = Routine(_acquisition, _fit, _plot, _update)

src/qibocal/protocols/rabi/amplitude_frequency.py

@@ -80,7 +80,7 @@ def _acquisition(
     """Data acquisition for Rabi experiment sweeping amplitude."""
 
     sequence, qd_pulses, ro_pulses, durations = sequence_amplitude(
-        targets, params, platform
+        targets, params, platform, params.rx90
     )
     frequency_range = np.arange(
         params.min_freq,
@@ -101,7 +101,7 @@ def _acquisition(
         pulses=[qd_pulses[qubit] for qubit in targets],
     )
 
-    data = RabiAmplitudeFreqData(durations=durations)
+    data = RabiAmplitudeFreqData(durations=durations, rx90=params.rx90)
 
     results = platform.execute(
         [sequence],
@@ -186,6 +186,7 @@ def _fit(data: RabiAmplitudeFreqData) -> RabiAmplitudeFrequencyResults:
         fitted_parameters=fitted_parameters,
         frequency=fitted_frequencies,
         chi2=chi2,
+        rx90=data.rx90,
     )
 
 
@@ -234,10 +235,16 @@ def _plot(
             row=1,
             col=1,
         )
+
+        if data.rx90:
+            pulse_name = "Pi-half pulse"
+        else:
+            pulse_name = "Pi pulse"
+
         fitting_report = table_html(
             table_dict(
                 target,
-                ["Optimal rabi frequency", "Pi-pulse amplitude"],
+                ["Optimal rabi frequency", f"{pulse_name} amplitude"],
                 [
                     fit.frequency[target],
                     f"{fit.amplitude[target][0]:.6f} +- {fit.amplitude[target][1]:.6f} [a.u.]",