T phi experiment

qiskit_experiments/database_service/db_experiment_data.py

@@ -418,7 +418,7 @@ def add_analysis_callback(self, callback: Callable, **kwargs: Any):
         """Add analysis callback for running after experiment data jobs are finished.
 
         This method adds the `callback` function to a queue to be run
-        asynchronously after complition of any running jobs, or immediately
+        asynchronously after completion of any running jobs, or immediately
         if no running jobs. If this method is called multiple times the
         callback functions will be executed in the order they were
         added.

qiskit_experiments/framework/base_experiment.py

@@ -90,7 +90,7 @@ def __init__(
             self.analysis = analysis_cls()  # pylint: disable = not-callable
 
         # Set backend
-        # This should be called last incase `_set_backend` access any of the
+        # This should be called last in case `_set_backend` access any of the
         # attributes created during initialization
         self._backend = None
         if isinstance(backend, (Backend, BaseBackend)):

qiskit_experiments/framework/composite/composite_analysis.py

@@ -34,7 +34,7 @@ class CompositeAnalysis(BaseAnalysis):
 
     .. note::
 
-        The the child :class:`ExperimentData` for each component experiment
+        If the child :class:`ExperimentData` for each component experiment
         does not already exist in the experiment data they will be initialized
         and added to the experiment data when :meth:`run` is called on the
         composite :class:`ExperimentData`.
@@ -91,7 +91,7 @@ def _component_experiment_data(self, experiment_data: ExperimentData) -> List[Ex
             )
 
         # Extract job metadata for the component experiments so it can be added
-        # to the child experiment data incase it is required by the child experiments
+        # to the child experiment data in case it is required by the child experiments
         # analysis classes
         component_metadata = experiment_data.metadata.get(
             "component_metadata", [{}] * len(component_ids)

qiskit_experiments/library/__init__.py

@@ -54,6 +54,7 @@
 
     ~characterization.T1
     ~characterization.T2Ramsey
+    ~characterization.Tphi
     ~characterization.QubitSpectroscopy
     ~characterization.EFSpectroscopy
     ~characterization.CrossResonanceHamiltonian
@@ -121,6 +122,7 @@ class instance to manage parameters and pulse schedules.
 from .characterization import (
     T1,
     T2Ramsey,
+    Tphi,
     QubitSpectroscopy,
     EFSpectroscopy,
     CrossResonanceHamiltonian,

qiskit_experiments/library/characterization/__init__.py

@@ -26,6 +26,7 @@
     T1
     T2Ramsey
     T2Hahn
+    Tphi
     QubitSpectroscopy
     CrossResonanceHamiltonian
     EchoedCrossResonanceHamiltonian
@@ -54,6 +55,7 @@
     T1Analysis
     T2RamseyAnalysis
     T2HahnAnalysis
+    TphiAnalysis
     CrossResonanceHamiltonianAnalysis
     DragCalAnalysis
     FineHalfAngleAnalysis
@@ -72,6 +74,7 @@
     T2RamseyAnalysis,
     T1Analysis,
     T2HahnAnalysis,
+    TphiAnalysis,
     CrossResonanceHamiltonianAnalysis,
     ReadoutAngleAnalysis,
 )
@@ -81,6 +84,7 @@
 from .ef_spectroscopy import EFSpectroscopy
 from .t2ramsey import T2Ramsey
 from .t2hahn import T2Hahn
+from .tphi import Tphi
 from .cr_hamiltonian import CrossResonanceHamiltonian, EchoedCrossResonanceHamiltonian
 from .rabi import Rabi, EFRabi
 from .half_angle import HalfAngle

qiskit_experiments/library/characterization/analysis/__init__.py

@@ -21,5 +21,6 @@
 from .t2ramsey_analysis import T2RamseyAnalysis
 from .t2hahn_analysis import T2HahnAnalysis
 from .t1_analysis import T1Analysis
+from .tphi_analysis import TphiAnalysis
 from .cr_hamiltonian_analysis import CrossResonanceHamiltonianAnalysis
 from .readout_angle_analysis import ReadoutAngleAnalysis

qiskit_experiments/library/characterization/analysis/t2ramsey_analysis.py

@@ -13,11 +13,8 @@
 T2Ramsey Experiment class.
 """
 from typing import Union
-
 from qiskit_experiments.data_processing import DataProcessor, Probability
 import qiskit_experiments.curve_analysis as curve
-
-
 from qiskit_experiments.framework import Options
 
 

qiskit_experiments/library/characterization/analysis/tphi_analysis.py

@@ -0,0 +1,67 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Tphi Analysis class.
+"""
+
+from typing import List, Tuple
+from uncertainties import ufloat
+
+from qiskit_experiments.framework import (
+    ExperimentData,
+    AnalysisResultData,
+    FitVal,
+)
+from qiskit_experiments.framework.composite.composite_analysis import CompositeAnalysis
+
+
+class TphiAnalysis(CompositeAnalysis):
+
+    r"""
+    Tphi result analysis class.
+    A class to analyze :math:`T_\phi` experiments.
+    """
+
+    def _run_analysis(
+        self, experiment_data: ExperimentData, **options
+    ) -> Tuple[List[AnalysisResultData], List["matplotlib.figure.Figure"]]:
+        r"""Run analysis for :math:`T_\phi` experiment.
+        It invokes CompositeAnalysis._run_analysis that will invoke
+        _run_analysis for the two sub-experiments.
+        Based on the results, it computes the result for :math:`T_phi`.
+        """
+        _, _ = super()._run_analysis(experiment_data, **options)
+
+        t1_result = experiment_data.child_data(0).analysis_results("T1")
+        t2star_result = experiment_data.child_data(1).analysis_results("T2star")
+        # we use the 'ucert' prefix to denote values that include
+        # uncertainty using the `uncertainties` package
+        uncert_t1_res = ufloat(t1_result.value.value, t1_result.value.stderr)
+        uncert_t2star_res = ufloat(t2star_result.value.value, t2star_result.value.stderr)
+        uncert_reciprocal = (1 / uncert_t2star_res) - (1 / (2 * uncert_t1_res))
+        uncert_tphi = 1 / uncert_reciprocal
+
+        quality_tphi = (
+            "good" if (t1_result.quality == "good" and t2star_result.quality == "good") else "bad"
+        )
+
+        analysis_results = []
+        analysis_results.append(
+            AnalysisResultData(
+                name="T_phi",
+                value=FitVal(uncert_tphi.nominal_value, uncert_tphi.std_dev),
+                chisq=None,
+                quality=quality_tphi,
+                extra={},
+            )
+        )
+        return analysis_results, []

qiskit_experiments/library/characterization/tphi.py

@@ -0,0 +1,119 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Tphi Experiment class.
+"""
+
+from typing import List, Optional, Union
+import numpy as np
+
+from qiskit import QiskitError
+from qiskit.providers import Backend
+from qiskit.test.mock import FakeBackend
+from qiskit_experiments.framework.composite.batch_experiment import BatchExperiment
+from qiskit_experiments.library.characterization import (
+    T1,
+    T2Ramsey,
+    TphiAnalysis,
+    T1Analysis,
+    T2RamseyAnalysis,
+)
+
+
+class Tphi(BatchExperiment):
+    r"""Tphi Experiment Class
+
+    # section: overview
+
+        :math:`\Gamma_\varphi` is defined as the rate of pure dephasing
+        or depolarization in the :math:`x - y` plane.
+        We compute :math:`\Gamma_\varphi` by computing :math:`\Gamma_2*`, the transverse relaxation rate,
+        and subtracting :math:`\Gamma_1`, the longitudinal relaxation rate. The pure dephasing time
+        is defined by :math:`T_\varphi = 1/\Gamma_\varphi`. Or more precisely,
+
+        :math:`1/T_\varphi = 1/T_{2*} - 1/2T_1`.
+
+        For more details, see :py:class:`T1` and :py:class:`T2Ramsey`
+
+    # section: analysis_ref
+        :py:class:`TphiAnalysis`
+
+    # section: reference
+        .. ref_arxiv:: 1 1904.06560v5
+
+    # section: tutorial
+        :doc:`/tutorials/tphi_characterization`
+    """
+
+    def set_experiment_options(self, **fields):
+        """Set the experiment options.
+        Args:
+            fields: The fields defining the options
+
+        Raises:
+             QiskitError : Error for invalid input option.
+        """
+        # propagate options to the sub-experiments.
+        for key in fields:
+            if key == "delays_t1":
+                self.component_experiment(0).set_experiment_options(delays=fields["delays_t1"])
+            elif key == "delays_t2":
+                self.component_experiment(1).set_experiment_options(delays=fields["delays_t2"])
+            else:
+                raise QiskitError(f"Tphi experiment does not support option {key}")
+
+    def __init__(
+        self,
+        qubit: int,
+        delays_t1: List[Union[List[float], np.array]],
+        delays_t2: List[Union[List[float], np.array]],
+        osc_freq: float = 0.0,
+        backend: Optional[Backend] = None,
+    ):
+        """Initialize the experiment object.
+
+        Args:
+            qubit: the qubit under test
+            delays_t1: delay times of the T1 experiment
+            delays_t2: delay times of the T2* experiment
+            osc_freq: the oscillation frequency induced using by the user for T2Ramsey
+            backend: Optional, the backend on which to run the experiment
+        """
+
+        exp_t1 = T1(qubit=qubit, delays=delays_t1, backend=backend)
+        exp_t2 = T2Ramsey(
+            qubit=qubit,
+            delays=delays_t2,
+            backend=backend,
+            osc_freq=osc_freq,
+        )
+        self.exps = [exp_t1, exp_t2]
+
+        # Create batch experiment
+        super().__init__(experiments=self.exps, backend=backend)
+
+        self.set_experiment_options(delays_t1=delays_t1, delays_t2=delays_t2)
+        # CompositeAnalysis accept the component analysis classes in its constructor
+        self.analysis = TphiAnalysis(analyses=[T1Analysis(), T2RamseyAnalysis()])
+
+    def _set_backend(self, backend: Backend):
+        super()._set_backend(backend)
+
+        # Scheduling parameters
+        if not self._backend.configuration().simulator and not isinstance(backend, FakeBackend):
+            timing_constraints = getattr(self.transpile_options, "timing_constraints", {})
+            if "acquire_alignment" not in timing_constraints:
+                timing_constraints["acquire_alignment"] = 16
+            scheduling_method = getattr(self.transpile_options, "scheduling_method", "alap")
+            self.set_transpile_options(
+                timing_constraints=timing_constraints, scheduling_method=scheduling_method
+            )

qiskit_experiments/test/t1_backend.py

@@ -129,5 +129,4 @@ def run(self, run_input, **options):
                     "data": {"counts": counts},
                 }
             )
-
         return FakeJob(backend=self, result=Result.from_dict(result))