Adding CPMG protocol

doc/source/protocols/cpmg/cpmg.rst

@@ -0,0 +1,50 @@
+CPMG sequence
+=============
+
+In this section we show how to run the dynamical decoupling sequence CPMG.
+
+The CPMG sequence consists in applying N equally spaced :math:`\pi` pulses
+within two :math:`\pi` pulses. By increasing the number of :math:`\pi` pulses :math:`T_2`
+should increase until reaching the :math:`2 T_1` limit.
+
+
+The fit is again a dumped exponential of the following form:
+
+.. math::
+
+    p_e(t) = A + B  e^{ - t / T_2}
+
+
+Parameters
+^^^^^^^^^^
+
+.. autoclass:: qibocal.protocols.coherence.cpmg.CpmgParameters
+  :noindex:
+
+Example
+^^^^^^^
+
+A possible runcard to launch a CPMG experiment could be the following:
+
+.. code-block:: yaml
+
+    - id: CPMG
+      operation: cpmg
+      parameters:
+        delay_between_pulses_end: 100000
+        delay_between_pulses_start: 4
+        delay_between_pulses_step: 1000
+        n: 10
+        nshots: 1000
+
+The expected output is the following:
+
+.. image:: cpmg.png
+
+:math:`T_2` is determined by fitting the output signal using
+the formula presented above.
+
+Requirements
+^^^^^^^^^^^^
+
+- :ref:`single-shot`

doc/source/protocols/index.rst

@@ -22,6 +22,7 @@ In this section we introduce the basics of all protocols supported by ``qibocal`
     t1/t1
     t2/t2
     t2_echo/t2_echo
+    cpmg/cpmg
     flux/single
     flux/crosstalk
     singleshot

src/qibocal/protocols/__init__.py

@@ -1,6 +1,7 @@
 from .allxy.allxy import allxy
 from .allxy.allxy_resonator_depletion_tuning import allxy_resonator_depletion_tuning
 from .classification import single_shot_classification
+from .coherence.cpmg import cpmg
 from .coherence.spin_echo import spin_echo
 from .coherence.spin_echo_signal import spin_echo_signal
 from .coherence.t1 import t1
@@ -104,4 +105,5 @@
     "standard_rb_2q_inter",
     "optimize_two_qubit_gate",
     "ramsey_zz",
+    "cpmg",
 ]

src/qibocal/protocols/coherence/cpmg.py

@@ -0,0 +1,172 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+import numpy as np
+import plotly.graph_objects as go
+from qibolab import AcquisitionType, AveragingMode, Parameter, Sweeper
+
+from qibocal.auto.operation import QubitId, Routine
+from qibocal.calibration import CalibrationPlatform
+from qibocal.result import probability
+
+from ..utils import table_dict, table_html
+from . import t1
+from .spin_echo import SpinEchoParameters, SpinEchoResults, _update
+from .utils import dynamical_decoupling_sequence, exp_decay, exponential_fit_probability
+
+
+@dataclass
+class CpmgParameters(SpinEchoParameters):
+    """Cpmg runcard inputs."""
+
+    n: int = 1
+    """Number of pi rotations."""
+
+
+@dataclass
+class CpmgResults(SpinEchoResults):
+    """SpinEcho outputs."""
+
+    chi2: Optional[dict[QubitId, tuple[float, Optional[float]]]] = field(
+        default_factory=dict
+    )
+    """Chi squared estimate mean value and error."""
+
+
+class CpmgData(t1.T1Data):
+    """SpinEcho acquisition outputs."""
+
+
+def _acquisition(
+    params: CpmgParameters,
+    platform: CalibrationPlatform,
+    targets: list[QubitId],
+) -> CpmgData:
+    """Data acquisition for Cpmg"""
+    # create a sequence of pulses for the experiment:
+    sequence, delays = dynamical_decoupling_sequence(
+        platform, targets, n=params.n, kind="CPMG"
+    )
+
+    # define the parameter to sweep and its range:
+    # delay between pulses
+    wait_range = np.arange(
+        params.delay_between_pulses_start,
+        params.delay_between_pulses_end,
+        params.delay_between_pulses_step,
+    )
+
+    sweeper = Sweeper(
+        parameter=Parameter.duration,
+        values=wait_range / 2 / params.n,
+        pulses=delays,
+    )
+
+    results = platform.execute(
+        [sequence],
+        [[sweeper]],
+        nshots=params.nshots,
+        relaxation_time=params.relaxation_time,
+        acquisition_type=AcquisitionType.DISCRIMINATION,
+        averaging_mode=AveragingMode.SINGLESHOT,
+    )
+
+    data = CpmgData()
+    for qubit in targets:
+        ro_pulse = list(sequence.channel(platform.qubits[qubit].acquisition))[-1]
+        result = results[ro_pulse.id]
+        prob = probability(result, state=1)
+        error = np.sqrt(prob * (1 - prob) / params.nshots)
+        data.register_qubit(
+            t1.CoherenceProbType,
+            (qubit),
+            dict(
+                wait=wait_range,
+                prob=prob,
+                error=error,
+            ),
+        )
+
+    return data
+
+
+def _fit(data: CpmgData) -> CpmgResults:
+    """Post-processing for Cpmg."""
+    t2Echos, fitted_parameters, pcovs, chi2 = exponential_fit_probability(data)
+    return CpmgResults(t2Echos, fitted_parameters, pcovs, chi2)
+
+
+def _plot(data: CpmgData, target: QubitId, fit: CpmgResults = None):
+    """Plotting for Cpmg"""
+
+    figures = []
+    # iterate over multiple data folders
+    fitting_report = ""
+
+    qubit_data = data[target]
+    waits = qubit_data.wait
+    probs = qubit_data.prob
+    error_bars = qubit_data.error
+
+    fig = go.Figure(
+        [
+            go.Scatter(
+                x=waits,
+                y=probs,
+                opacity=1,
+                name="Probability of 1",
+                showlegend=True,
+                legendgroup="Probability of 1",
+                mode="lines",
+            ),
+            go.Scatter(
+                x=np.concatenate((waits, waits[::-1])),
+                y=np.concatenate((probs + error_bars, (probs - error_bars)[::-1])),
+                fill="toself",
+                fillcolor=t1.COLORBAND,
+                line=dict(color=t1.COLORBAND_LINE),
+                showlegend=True,
+                name="Errors",
+            ),
+        ]
+    )
+
+    if fit is not None:
+        # add fitting trace
+        waitrange = np.linspace(
+            min(waits),
+            max(waits),
+            2 * len(qubit_data),
+        )
+        params = fit.fitted_parameters[target]
+
+        fig.add_trace(
+            go.Scatter(
+                x=waitrange,
+                y=exp_decay(waitrange, *params),
+                name="Fit",
+                line=go.scatter.Line(dash="dot"),
+            ),
+        )
+        fitting_report = table_html(
+            table_dict(
+                target,
+                ["T2", "chi2 reduced"],
+                [fit.t2_spin_echo[target], fit.chi2[target]],
+                display_error=True,
+            )
+        )
+
+    fig.update_layout(
+        showlegend=True,
+        xaxis_title="Time [ns]",
+        yaxis_title="Probability of State 1",
+    )
+
+    figures.append(fig)
+
+    return figures, fitting_report
+
+
+cpmg = Routine(_acquisition, _fit, _plot, _update)
+"""Cpmg Routine object."""

src/qibocal/protocols/coherence/spin_echo.py

 sequence, delays = dynamical_decoupling_sequence(platform, targets, kind="CP") 
 sequence, delays = dynamical_decoupling_sequence(platform, targets, kind="CP") 
@@ -12,7 +12,7 @@
 from ..utils import table_dict, table_html
 from . import t1
 from .spin_echo_signal import SpinEchoSignalParameters, SpinEchoSignalResults, _update
-from .utils import exp_decay, exponential_fit_probability, spin_echo_sequence
+from .utils import dynamical_decoupling_sequence, exp_decay, exponential_fit_probability
 
 
 @dataclass
@@ -41,19 +41,19 @@ def _acquisition(
 ) -> SpinEchoData:
     """Data acquisition for SpinEcho"""
     # create a sequence of pulses for the experiment:
-    sequence, delays = spin_echo_sequence(platform, targets)
+    sequence, delays = dynamical_decoupling_sequence(platform, targets, kind="CP")
 
     # define the parameter to sweep and its range:
     # delay between pulses
-    ro_wait_range = np.arange(
+    wait_range = np.arange(
         params.delay_between_pulses_start,
         params.delay_between_pulses_end,
         params.delay_between_pulses_step,
     )
 
     sweeper = Sweeper(
         parameter=Parameter.duration,
-        values=ro_wait_range,
+        values=wait_range / 2,
         pulses=delays,
     )
 
@@ -70,13 +70,13 @@ def _acquisition(
     for qubit in targets:
         ro_pulse = list(sequence.channel(platform.qubits[qubit].acquisition))[-1]
         result = results[ro_pulse.id]
-        prob = probability(result, state=0)
+        prob = probability(result, state=1)
         error = np.sqrt(prob * (1 - prob) / params.nshots)
         data.register_qubit(
             t1.CoherenceProbType,
             (qubit),
             dict(
-                wait=ro_wait_range,
+                wait=wait_range,
                 prob=prob,
                 error=error,
             ),
@@ -109,9 +109,9 @@ def _plot(data: SpinEchoData, target: QubitId, fit: SpinEchoResults = None):
                 x=waits,
                 y=probs,
                 opacity=1,
-                name="Probability of 0",
+                name="Probability of 1",
                 showlegend=True,
-                legendgroup="Probability of 0",
+                legendgroup="Probability of 1",
                 mode="lines",
             ),
             go.Scatter(
@@ -155,7 +155,7 @@ def _plot(data: SpinEchoData, target: QubitId, fit: SpinEchoResults = None):
     fig.update_layout(
         showlegend=True,
         xaxis_title="Time [ns]",
-        yaxis_title="Probability of State 0",
+        yaxis_title="Probability of State 1",
     )
 
     figures.append(fig)

src/qibocal/protocols/coherence/spin_echo_signal.py

@@ -12,7 +12,12 @@
 from ... import update
 from ..utils import table_dict, table_html
 from .t1_signal import T1SignalData
-from .utils import CoherenceType, exp_decay, exponential_fit, spin_echo_sequence
+from .utils import (
+    CoherenceType,
+    dynamical_decoupling_sequence,
+    exp_decay,
+    exponential_fit,
+)
 
 
 @dataclass
@@ -26,8 +31,6 @@ class SpinEchoSignalParameters(Parameters):
     delay_between_pulses_step: int
     """Step delay between pulses [ns]."""
     single_shot: bool = False
-    """If ``True`` save single shot signal data."""
-    unrolling: bool = False
 
 
 @dataclass
@@ -53,19 +56,19 @@ def _acquisition(
 ) -> SpinEchoSignalData:
     """Data acquisition for SpinEcho"""
     # create a sequence of pulses for the experiment:
-    sequence, delays = spin_echo_sequence(platform, targets)
+    sequence, delays = dynamical_decoupling_sequence(platform, targets, kind="CP")
 
     # define the parameter to sweep and its range:
     # delay between pulses
-    ro_wait_range = np.arange(
+    wait_range = np.arange(
         params.delay_between_pulses_start,
         params.delay_between_pulses_end,
         params.delay_between_pulses_step,
     )
 
     sweeper = Sweeper(
         parameter=Parameter.duration,
-        values=ro_wait_range,
+        values=wait_range / 2,
         pulses=delays,
     )
 
@@ -86,9 +89,9 @@ def _acquisition(
         result = results[ro_pulse.id]
         signal = magnitude(result)
         if params.single_shot:
-            _wait = np.array(len(signal) * [ro_wait_range])
+            _wait = np.array(len(signal) * [wait_range])
         else:
-            _wait = ro_wait_range
+            _wait = wait_range
         data.register_qubit(
             CoherenceType,
             (qubit),