Spectroscopy

qiskit_experiments/characterization/__init__.py

@@ -24,6 +24,7 @@
 
     T1Experiment
     T2StarExperiment
+    QubitSpectroscopy
 
 
 Analysis
@@ -34,6 +35,8 @@
 
     T1Analysis
     T2StarAnalysis
+    SpectroscopyAnalysis
 """
 from .t1_experiment import T1Experiment, T1Analysis
+from .qubit_spectroscopy import QubitSpectroscopy, SpectroscopyAnalysis
 from .t2star_experiment import T2StarExperiment, T2StarAnalysis

qiskit_experiments/data_processing/nodes.py

@@ -186,9 +186,18 @@ def _process(
                 error_value = np.sqrt(
                     (error[idx][0] * np.cos(angle)) ** 2 + (error[idx][1] * np.sin(angle)) ** 2
                 )
-                processed_error.append(error_value)
+                processed_error.append(error_value / self.scales[idx])
 
-        return np.array(processed_data), processed_error
+        if len(processed_data) == 1:
+            if error is None:
+                return processed_data[0], None
+            else:
+                return processed_data[0], processed_error[0]
+
+        if error is None:
+            return np.array(processed_data), None
+        else:
+            return np.array(processed_data), np.array(processed_error)
 
     def train(self, data: List[Any]):
         """Train the SVD on the given data.
@@ -396,11 +405,11 @@ def _process(self, datum: Dict[str, Any], error: Optional[Dict] = None) -> Tuple
                 adding the corresponding probabilities.
 
         Returns:
-            processed data: A dict with the populations.
+            processed data: A dict with the populations and standard deviation.
         """
 
         shots = sum(datum.values())
         p_mean = datum.get(self._outcome, 0.0) / shots
         p_var = p_mean * (1 - p_mean) / shots
 
-        return p_mean, p_var
+        return p_mean, np.sqrt(p_var)

qiskit_experiments/data_processing/processor_library.py

@@ -0,0 +1,46 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+"""A collection of functions that return various data processors."""
+
+from qiskit.qobj.utils import MeasLevel
+
+from qiskit_experiments.data_processing.exceptions import DataProcessorError
+from qiskit_experiments.data_processing.data_processor import DataProcessor
+from qiskit_experiments.data_processing.nodes import AverageData, Probability, SVD
+
+
+def get_to_signal_processor(
+    meas_level: MeasLevel = MeasLevel.CLASSIFIED, meas_return: str = "avg"
+) -> DataProcessor:
+    """Get a DataProcessor that produces a continuous signal given the options.
+
+    Args:
+        meas_level: The measurement level of the data to process.
+        meas_return: The measurement return (single or avg) of the data to process.
+
+    Returns:
+        An instance of DataProcessor capable of dealing with the given options.
+
+    Raises:
+        DataProcessorError: if the measurement level is not supported.
+    """
+    if meas_level == MeasLevel.CLASSIFIED:
+        return DataProcessor("counts", [Probability("1")])
+
+    if meas_level == MeasLevel.KERNELED:
+        if meas_return == "single":
+            return DataProcessor("memory", [AverageData(), SVD()])
+        else:
+            return DataProcessor("memory", [SVD()])
+
+    raise DataProcessorError(f"Unsupported measurement level {meas_level}.")

qiskit_experiments/test/__init__.py

@@ -0,0 +1,15 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+"""
+Test tools for experiment.
+"""

qiskit_experiments/test/mock_iq_backend.py

@@ -0,0 +1,95 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+"""An mock IQ backend for testing."""
+
+from typing import Dict, List, Tuple
+import numpy as np
+
+from qiskit.providers.backend import BackendV1 as Backend
+from qiskit.providers import JobV1
+from qiskit.providers.models import QasmBackendConfiguration
+from qiskit.result import Result
+
+
+class TestJob(JobV1):
+    """Job for testing."""
+
+    def __init__(self, backend: Backend, result: Dict):
+        """Setup a job for testing."""
+        super().__init__(backend, "test-id")
+        self._result = result
+
+    def result(self) -> Result:
+        """Return a result."""
+        return Result.from_dict(self._result)
+
+    def submit(self):
+        pass
+
+    def status(self):
+        pass
+
+    def cancel(self):
+        pass
+
+
+class IQTestBackend(Backend):
+    """An abstract backend for testing that can mock IQ data."""
+
+    __configuration__ = {
+        "backend_name": "simulator",
+        "backend_version": "0",
+        "n_qubits": int(1),
+        "basis_gates": [],
+        "gates": [],
+        "local": True,
+        "simulator": True,
+        "conditional": False,
+        "open_pulse": False,
+        "memory": True,
+        "max_shots": int(1e6),
+        "coupling_map": [],
+        "dt": 0.1,
+    }
+
+    def __init__(
+        self,
+        iq_cluster_centers: Tuple[float, float, float, float] = (1.0, 1.0, -1.0, -1.0),
+        iq_cluster_width: float = 1.0,
+    ):
+        """
+        Initialize the backend.
+        """
+        self._iq_cluster_centers = iq_cluster_centers
+        self._iq_cluster_width = iq_cluster_width
+
+        self._rng = np.random.default_rng(0)
+
+        super().__init__(QasmBackendConfiguration(**self.__configuration__))
+
+    def _default_options(self):
+        """Default options of the test backend."""
+
+    def _draw_iq_shot(self, prob) -> List[List[float]]:
+        """Produce an IQ shot."""
+
+        rand_i = self._rng.normal(0, self._iq_cluster_width)
+        rand_q = self._rng.normal(0, self._iq_cluster_width)
+
+        if self._rng.binomial(1, prob) > 0.5:
+            return [[self._iq_cluster_centers[0] + rand_i, self._iq_cluster_centers[1] + rand_q]]
+        else:
+            return [[self._iq_cluster_centers[2] + rand_i, self._iq_cluster_centers[3] + rand_q]]
+
+    def run(self, run_input, **options) -> TestJob:
+        """Subclasses will need to override this."""

test/data_processing/test_data_processing.py

@@ -158,7 +158,7 @@ def test_populations(self):
         new_data, error = processor(self.exp_data_lvl2.data(0))
 
         self.assertEqual(new_data, 0.4)
-        self.assertEqual(error, 0.4 * (1 - 0.4) / 10)
+        self.assertEqual(error, np.sqrt(0.4 * (1 - 0.4) / 10))
 
     def test_validation(self):
         """Test the validation mechanism."""
@@ -377,10 +377,10 @@ def test_averaging_and_svd(self):
         # Test the x90p rotation
         processed, error = processor(self.data.data(2))
         self.assertTrue(np.allclose(processed, np.array([0, 0])))
-        self.assertTrue(np.allclose(error, np.array([0.5, 0.5])))
+        self.assertTrue(np.allclose(error, np.array([0.25, 0.25])))
 
         # Test the x45p rotation
         processed, error = processor(self.data.data(3))
-        expected_std = np.array([np.std([1, 1, 1, -1, 1, 1, 1, -1]) / np.sqrt(8.0)] * 2)
+        expected_std = np.array([np.std([1, 1, 1, -1, 1, 1, 1, -1]) / np.sqrt(8.0) / 2] * 2)
         self.assertTrue(np.allclose(processed, np.array([0.5, -0.5]) / np.sqrt(2.0)))
         self.assertTrue(np.allclose(error, expected_std))

test/test_qubit_spectroscopy.py

@@ -0,0 +1,149 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+"""Spectroscopy tests."""
+
+from typing import Tuple
+
+import numpy as np
+from qiskit.qobj.utils import MeasLevel
+from qiskit.test import QiskitTestCase
+
+from qiskit_experiments.characterization.qubit_spectroscopy import QubitSpectroscopy
+from qiskit_experiments.test.mock_iq_backend import TestJob, IQTestBackend
+
+
+class SpectroscopyBackend(IQTestBackend):
+    """
+    A simple and primitive backend to test spectroscopy experiments.
+    """
+
+    def __init__(
+        self,
+        line_width: float = 2e6,
+        freq_offset: float = 0.0,
+        iq_cluster_centers: Tuple[float, float, float, float] = (1.0, 1.0, -1.0, -1.0),
+        iq_cluster_width: float = 0.2,
+    ):
+        """Initialize the spectroscopy backend."""
+
+        self.__configuration__["basis_gates"] = ["spec"]
+
+        self._linewidth = line_width
+        self._freq_offset = freq_offset
+
+        super().__init__(iq_cluster_centers, iq_cluster_width)
+
+    # pylint: disable = arguments-differ
+    def run(
+        self, circuits, shots=1024, meas_level=MeasLevel.KERNELED, meas_return="single", **options
+    ):
+        """Run the spectroscopy backend."""
+
+        result = {
+            "backend_name": "spectroscopy backend",
+            "backend_version": "0",
+            "qobj_id": 0,
+            "job_id": 0,
+            "success": True,
+            "results": [],
+        }
+
+        for circ in circuits:
+
+            run_result = {
+                "shots": shots,
+                "success": True,
+                "header": {"metadata": circ.metadata},
+            }
+
+            set_freq = float(circ.data[0][0].params[0])
+            delta_freq = set_freq - self._freq_offset
+            prob = np.exp(-(delta_freq ** 2) / (2 * self._linewidth ** 2))
+
+            if meas_level == MeasLevel.CLASSIFIED:
+                counts = {"1": 0, "0": 0}
+
+                for _ in range(shots):
+                    counts[str(self._rng.binomial(1, prob))] += 1
+
+                run_result["data"] = {"counts": counts}
+            else:
+                memory = [self._draw_iq_shot(prob) for _ in range(shots)]
+
+                if meas_return == "avg":
+                    memory = np.average(np.array(memory), axis=0).tolist()
+
+                run_result["data"] = {"memory": memory}
+
+            result["results"].append(run_result)
+
+        return TestJob(self, result)
+
+
+class TestQubitSpectroscopy(QiskitTestCase):
+    """Test spectroscopy experiment."""
+
+    def test_spectroscopy_end2end_classified(self):
+        """End to end test of the spectroscopy experiment."""
+
+        backend = SpectroscopyBackend(line_width=2e6)
+
+        spec = QubitSpectroscopy(3, np.linspace(-10.0, 10.0, 21), unit="MHz")
+        spec.set_run_options(meas_level=MeasLevel.CLASSIFIED)
+        result = spec.run(backend).analysis_result(0)
+
+        self.assertTrue(abs(result["value"]) < 1e6)
+        self.assertTrue(result["success"])
+        self.assertEqual(result["quality"], "computer_good")
+
+        # Test if we find still find the peak when it is shifted by 5 MHz.
+        backend = SpectroscopyBackend(line_width=2e6, freq_offset=5.0e6)
+
+        spec = QubitSpectroscopy(3, np.linspace(-10.0, 10.0, 21), unit="MHz")
+        spec.set_run_options(meas_level=MeasLevel.CLASSIFIED)
+        result = spec.run(backend).analysis_result(0)
+
+        self.assertTrue(result["value"] < 5.1e6)
+        self.assertTrue(result["value"] > 4.9e6)
+        self.assertEqual(result["quality"], "computer_good")
+
+    def test_spectroscopy_end2end_kerneled(self):
+        """End to end test of the spectroscopy experiment on IQ data."""
+
+        backend = SpectroscopyBackend(line_width=2e6)
+
+        spec = QubitSpectroscopy(3, np.linspace(-10.0, 10.0, 21), unit="MHz")
+        result = spec.run(backend).analysis_result(0)
+
+        self.assertTrue(abs(result["value"]) < 1e6)
+        self.assertTrue(result["success"])
+        self.assertEqual(result["quality"], "computer_good")
+
+        # Test if we find still find the peak when it is shifted by 5 MHz.
+        backend = SpectroscopyBackend(line_width=2e6, freq_offset=5.0e6)
+
+        spec = QubitSpectroscopy(3, np.linspace(-10.0, 10.0, 21), unit="MHz")
+        result = spec.run(backend).analysis_result(0)
+
+        self.assertTrue(result["value"] < 5.1e6)
+        self.assertTrue(result["value"] > 4.9e6)
+        self.assertEqual(result["quality"], "computer_good")
+        self.assertTrue(result["ydata_err"] is not None)
+
+        spec.set_run_options(meas_return="avg")
+        result = spec.run(backend).analysis_result(0)
+
+        self.assertTrue(result["value"] < 5.1e6)
+        self.assertTrue(result["value"] > 4.9e6)
+        self.assertEqual(result["quality"], "computer_good")
+        self.assertTrue(result["ydata_err"] is None)