Resonator spectroscopy

qiskit_experiments/data_processing/nodes.py

@@ -374,6 +374,21 @@ def _process(self, data: np.ndarray) -> np.ndarray:
         return data[..., 1] * self.scale
 
 
+class ToAbs(IQPart):
+    """IQ data post-processing. Take the absolute value of the IQ point."""
+
+    def _process(self, data: np.array) -> np.array:
+        """Take the absolute value of the IQ data.
+
+        Args:
+            data: An N-dimensional array of complex IQ point as [real, imaginary].
+
+        Returns:
+            A N-1 dimensional array, each entry is the absolute value of the given IQ data.
+        """
+        return unp.sqrt(data[..., 0] ** 2 + data[..., 1] ** 2) * self.scale
+
+
 class Probability(DataAction):
     r"""Compute the mean probability of a single measurement outcome from counts.
 

qiskit_experiments/data_processing/processor_library.py

@@ -12,39 +12,73 @@
 
 """A collection of functions that return various data processors."""
 
+from enum import Enum
+from typing import Union
+
 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 import nodes
 
 
+class ProjectorType(Enum):
+    """Types of projectors for data dimensionality reduction."""
+    SVD = nodes.SVD
+    ABS = nodes.ToAbs
+    REAL = nodes.ToReal
+    IMAG = nodes.ToImag
+
+
 def get_processor(
     meas_level: MeasLevel = MeasLevel.CLASSIFIED,
     meas_return: str = "avg",
     normalize: bool = True,
+    dimensionality_reduction: Union[str, ProjectorType] = ProjectorType.SVD,
 ) -> 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.
         normalize: Add a data normalization node to the Kerneled data processor.
+        dimensionality_reduction: An optional string or instance of :class:`ProjectorType`
+            to represent the dimensionality reduction node for Kerneled data. For the
+            supported nodes, see :class:`ProjectorType`. Typically, these nodes convert
+            complex IQ data to real data, for example by performing a singular-value
+            decomposition. This argument is only needed for Kerneled data (i.e. level 1)
+            and can thus be ignored if Classified data (the default) is used.
 
     Returns:
         An instance of DataProcessor capable of dealing with the given options.
 
     Raises:
         DataProcessorError: if the measurement level is not supported.
+        DataProcessorError: if the wrong dimensionality reduction for kerneled data
+            is specified.
     """
     if meas_level == MeasLevel.CLASSIFIED:
         return DataProcessor("counts", [nodes.Probability("1")])
 
     if meas_level == MeasLevel.KERNELED:
+
+        try:
+            if isinstance(dimensionality_reduction, ProjectorType):
+                projector_name = dimensionality_reduction.name
+            else:
+                projector_name = dimensionality_reduction
+
+            projector = ProjectorType[projector_name].value
+
+        except KeyError as error:
+            raise DataProcessorError(
+                f"Invalid dimensionality reduction: {dimensionality_reduction}."
+            ) from error
+
         if meas_return == "single":
-            processor = DataProcessor("memory", [nodes.AverageData(axis=1), nodes.SVD()])
+            processor = DataProcessor("memory", [nodes.AverageData(axis=1), projector()])
         else:
-            processor = DataProcessor("memory", [nodes.SVD()])
+            processor = DataProcessor("memory", [projector()])
 
         if normalize:
             processor.append(nodes.MinMaxNormalize())

qiskit_experiments/library/__init__.py

@@ -71,6 +71,7 @@
     ~characterization.RamseyXY
     ~characterization.FineFrequency
     ~characterization.ReadoutAngle
+    ~characterization.ResonatorSpectroscopy
 
 
 .. _calibration:
@@ -103,21 +104,7 @@ class instance to manage parameters and pulse schedules.
     ~calibration.EFRoughXSXAmplitudeCal
 
 """
-from .calibration import (
-    RoughDragCal,
-    FineDragCal,
-    FineXDragCal,
-    FineSXDragCal,
-    RoughAmplitudeCal,
-    RoughXSXAmplitudeCal,
-    EFRoughXSXAmplitudeCal,
-    FineAmplitudeCal,
-    FineXAmplitudeCal,
-    FineSXAmplitudeCal,
-    RoughFrequencyCal,
-    FrequencyCal,
-    FineFrequencyCal,
-)
+
 from .characterization import (
     T1,
     T2Ramsey,
@@ -138,7 +125,25 @@ class instance to manage parameters and pulse schedules.
     RamseyXY,
     FineFrequency,
     ReadoutAngle,
+    ResonatorSpectroscopy,
 )
+
+from .calibration import (
+    RoughDragCal,
+    FineDragCal,
+    FineXDragCal,
+    FineSXDragCal,
+    RoughAmplitudeCal,
+    RoughXSXAmplitudeCal,
+    EFRoughXSXAmplitudeCal,
+    FineAmplitudeCal,
+    FineXAmplitudeCal,
+    FineSXAmplitudeCal,
+    RoughFrequencyCal,
+    FrequencyCal,
+    FineFrequencyCal,
+)
+
 from .randomized_benchmarking import StandardRB, InterleavedRB
 from .tomography import StateTomography, ProcessTomography
 from .quantum_volume import QuantumVolume

qiskit_experiments/library/characterization/__init__.py

@@ -41,6 +41,7 @@
     FineDrag
     FineXDrag
     FineSXDrag
+    ResonatorSpectroscopy
 
 
 Analysis
@@ -59,6 +60,7 @@
     FineAmplitudeAnalysis
     RamseyXYAnalysis
     ReadoutAngleAnalysis
+    ResonatorSpectroscopyAnalysis
 """
 
 from .analysis import (
@@ -71,6 +73,7 @@
     T1Analysis,
     CrossResonanceHamiltonianAnalysis,
     ReadoutAngleAnalysis,
+    ResonatorSpectroscopyAnalysis,
 )
 
 from .t1 import T1
@@ -86,3 +89,4 @@
 from .drag import RoughDrag
 from .readout_angle import ReadoutAngle
 from .fine_drag import FineDrag, FineXDrag, FineSXDrag
+from .resonator_spectroscopy import ResonatorSpectroscopy

qiskit_experiments/library/characterization/analysis/__init__.py

@@ -22,3 +22,4 @@
 from .t1_analysis import T1Analysis
 from .cr_hamiltonian_analysis import CrossResonanceHamiltonianAnalysis
 from .readout_angle_analysis import ReadoutAngleAnalysis
+from .resonator_spectroscopy_analysis import ResonatorSpectroscopyAnalysis

qiskit_experiments/library/characterization/analysis/resonator_spectroscopy_analysis.py

@@ -0,0 +1,65 @@
+# 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 analysis class for resonators."""
+
+from typing import List, Tuple
+import numpy as np
+
+import qiskit_experiments.curve_analysis as curve
+from qiskit_experiments.curve_analysis import ResonanceAnalysis
+from qiskit_experiments.framework import AnalysisResultData, ExperimentData
+from qiskit_experiments.framework.matplotlib import get_non_gui_ax
+
+
+class ResonatorSpectroscopyAnalysis(ResonanceAnalysis):
+    """Class to analysis resonator spectroscopy."""
+
+    @classmethod
+    def _default_options(cls):
+        options = super()._default_options()
+        options.dimensionality_reduction = "ToAbs"
+        options.result_parameters = [curve.ParameterRepr("freq", "meas_freq", "Hz")]
+        options.plot_iq_data = True
+        return options
+
+    def _run_analysis(
+        self, experiment_data: ExperimentData
+    ) -> Tuple[List[AnalysisResultData], List["pyplot.Figure"]]:
+        """Wrap the analysis to optionally plot the IQ data."""
+        analysis_results, figures = super()._run_analysis(experiment_data)
+
+        if self.options.plot_iq_data:
+            axis = get_non_gui_ax()
+            figure = axis.get_figure()
+            figure.set_size_inches(*self.options.style.figsize)
+
+            iqs = []
+
+            for datum in experiment_data.data():
+                if "memory" in datum:
+                    mem = np.array(datum["memory"])
+
+                    # Average single-shot data.
+                    if len(mem.shape) == 3:
+                        iqs.append(np.average(mem.reshape(mem.shape[0], mem.shape[2]), axis=0))
+
+            iqs = np.array(iqs)
+            axis.scatter(iqs[:, 0], iqs[:, 1], color="b")
+            axis.set_xlabel("In phase [arb. units]", fontsize=self.options.style.axis_label_size)
+            axis.set_ylabel("Quadrature [arb. units]", fontsize=self.options.style.axis_label_size)
+            axis.tick_params(labelsize=self.options.style.tick_label_size)
+            axis.grid(True)
+
+            figures.append(figure)
+
+        return analysis_results, figures

qiskit_experiments/library/characterization/qubit_spectroscopy.py

@@ -123,6 +123,21 @@ def __init__(
 
         self.analysis.set_options(ylabel="Signal [arb. unit]")
 
+    @property
+    def center_frequency(self) -> float:
+        """Returns the center frequency of the experiment.
+
+        Returns:
+            The center frequency of the experiment.
+
+        Raises:
+            QiskitError: If the experiment does not have a backend set.
+        """
+        if self.backend is None:
+            raise QiskitError("backend not set. Cannot call center_frequency.")
+
+        return self.backend.defaults().qubit_freq_est[self.physical_qubits[0]]
+
     def _spec_gate_schedule(
         self, backend: Optional[Backend] = None
     ) -> Tuple[pulse.ScheduleBlock, Parameter]:
@@ -151,6 +166,20 @@ def _template_circuit(self, freq_param) -> QuantumCircuit:
 
         return circuit
 
+    def _add_metadata(self, circuit: QuantumCircuit, freq: float, sched: pulse.ScheduleBlock):
+        """Helper method to add the metadata to avoid code duplication with subclasses."""
+        circuit.metadata = {
+            "experiment_type": self._type,
+            "qubits": (self.physical_qubits[0],),
+            "xval": np.round(freq, decimals=3),
+            "unit": "Hz",
+            "amplitude": self.experiment_options.amp,
+            "duration": self.experiment_options.duration,
+            "sigma": self.experiment_options.sigma,
+            "width": self.experiment_options.width,
+            "schedule": str(sched),
+        }
+
     def circuits(self):
         """Create the circuit for the spectroscopy experiment.
 
@@ -161,52 +190,30 @@ def circuits(self):
             circuits: The circuits that will run the spectroscopy experiment.
 
         Raises:
-            QiskitError:
-                - If absolute frequencies are used but no backend is given.
-                - If the backend configuration does not define dt.
+            QiskitError: If absolute frequencies are used but no backend is given.
+            QiskitError: If the backend configuration does not define dt.
             AttributeError: If backend to run on does not contain 'dt' configuration.
         """
         if self.backend is None and self._absolute:
-            raise QiskitError("Cannot run spectroscopy absolute to qubit without a backend.")
+            raise QiskitError("Cannot run spectroscopy in absolute without a backend.")
 
         # Create a template circuit
         sched, freq_param = self._spec_gate_schedule(self.backend)
         circuit = self._template_circuit(freq_param)
-        circuit.add_calibration("Spec", (self.physical_qubits[0],), sched, params=[freq_param])
-
-        # Get dt
-        try:
-            dt_factor = getattr(self.backend.configuration(), "dt")
-        except AttributeError as no_dt:
-            raise AttributeError("dt parameter is missing in backend configuration") from no_dt
-
-        # Get center frequency from backend
-        if self._absolute:
-            center_freq = self.backend.defaults().qubit_freq_est[self.physical_qubits[0]]
-        else:
-            center_freq = None
+        circuit.add_calibration(
+            self.__spec_gate_name__, self.physical_qubits, sched, params=[freq_param]
+        )
 
         # Create the circuits to run
         circs = []
         for freq in self._frequencies:
             freq_shift = freq
             if self._absolute:
-                freq_shift -= center_freq
+                freq_shift -= self.center_frequency
             freq_shift = np.round(freq_shift, decimals=3)
 
             assigned_circ = circuit.assign_parameters({freq_param: freq_shift}, inplace=False)
-            assigned_circ.metadata = {
-                "experiment_type": self._type,
-                "qubits": (self.physical_qubits[0],),
-                "xval": np.round(freq, decimals=3),
-                "unit": "Hz",
-                "amplitude": self.experiment_options.amp,
-                "duration": self.experiment_options.duration,
-                "sigma": self.experiment_options.sigma,
-                "width": self.experiment_options.width,
-                "schedule": str(sched),
-                "dt": dt_factor,
-            }
+            self._add_metadata(assigned_circ, freq, sched)
 
             circs.append(assigned_circ)