Update calibration and mixin tests to work with BackendV2

qiskit_experiments/calibration_management/calibrations.py

@@ -275,10 +275,10 @@ def from_backend(
         )
 
         if add_parameter_defaults:
-            for qubit, freq in enumerate(backend_data.drive_freqs):
+            for qubit, freq in enumerate(getattr(backend.defaults(), "qubit_freq_est", [])):
                 cals.add_parameter_value(freq, cals.drive_freq, qubit, update_inst_map=False)
 
-            for meas, freq in enumerate(backend_data.meas_freqs):
+            for meas, freq in enumerate(getattr(backend.defaults(), "meas_freq_est", [])):
                 cals.add_parameter_value(freq, cals.meas_freq, meas, update_inst_map=False)
 
         # Update the instruction schedule map after adding all parameter values.

qiskit_experiments/framework/backend_data.py

@@ -205,29 +205,6 @@ def provider(self):
             return None
         return None
 
-    @property
-    def drive_freqs(self):
-        """Returns the backend's qubit drive frequencies"""
-        if self._v1:
-            return getattr(self._backend.defaults(), "qubit_freq_est", [])
-        elif self._v2:
-            return [property.frequency for property in self._backend.target.qubit_properties]
-        return []
-
-    @property
-    def meas_freqs(self):
-        """Returns the backend's measurement stimulus frequencies.
-
-        .. note::
-            Currently BackendV2 does not have access to this data.
-        """
-        if self._v1:
-            return getattr(self._backend.defaults(), "meas_freq_est", [])
-        elif self._v2:
-            # meas_freq_est is currently not part of the BackendV2
-            return []
-        return []
-
     @property
     def num_qubits(self):
         """Returns the backend's number of qubits"""
@@ -255,3 +232,18 @@ def is_simulator(self):
                 return True
 
         return False
+
+    def qubit_t1(self, qubit: int) -> float:
+        """Return the T1 value for a qubit from the backend properties
+
+        Args:
+            qubit: the qubit index to return T1 for
+
+        Returns:
+            The T1 value
+        """
+        if self._v1:
+            return self._backend.properties().qubit_property(qubit)["T1"][0]
+        if self._v2:
+            return self._backend.qubit_properties(0).t1
+        return float("nan")

qiskit_experiments/framework/restless_mixin.py

@@ -200,7 +200,7 @@ def _t1_check(self, rep_delay: float) -> bool:
 
         try:
             t1_values = [
-                self._backend.properties().qubit_property(physical_qubit)["T1"][0]
+                self._backend_data.qubit_t1(physical_qubit)
                 for physical_qubit in self._physical_qubits
             ]
 

qiskit_experiments/library/characterization/qubit_spectroscopy.py

@@ -60,7 +60,7 @@ def _backend_center_frequency(self) -> float:
         if self.backend is None:
             raise QiskitError("backend not set. Cannot determine the center frequency.")
 
-        return self._backend_data.drive_freqs[self.physical_qubits[0]]
+        return self.backend.defaults().qubit_freq_est[self.physical_qubits[0]]
 
     def _template_circuit(self, freq_param) -> QuantumCircuit:
         """Return the template quantum circuit."""

qiskit_experiments/library/characterization/resonator_spectroscopy.py

@@ -21,7 +21,7 @@
 from qiskit.providers import Backend
 import qiskit.pulse as pulse
 
-from qiskit_experiments.framework import Options, BackendData
+from qiskit_experiments.framework import Options
 from qiskit_experiments.library.characterization.spectroscopy import Spectroscopy
 from .analysis.resonator_spectroscopy_analysis import ResonatorSpectroscopyAnalysis
 
@@ -138,7 +138,7 @@ def __init__(
                         "Cannot automatically compute absolute frequencies without a backend."
                     )
 
-                center_freq = BackendData(backend).meas_freqs[qubit]
+                center_freq = backend.defaults().meas_freqs_est[qubit]
                 frequencies += center_freq
 
         super().__init__(qubit, frequencies, backend, absolute, analysis, **experiment_options)
@@ -156,7 +156,7 @@ def _backend_center_frequency(self) -> float:
         if self.backend is None:
             raise QiskitError("backend not set. Cannot call center_frequency.")
 
-        return self._backend_data.meas_freqs[self.physical_qubits[0]]
+        return self.backend.defaults().meas_freq_est[self.physical_qubits[0]]
 
     def _template_circuit(self) -> QuantumCircuit:
         """Return the template quantum circuit."""

qiskit_experiments/test/fake_pulse_backends.py

@@ -0,0 +1,55 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Fake backend class for tests."""
+
+from qiskit.exceptions import QiskitError
+from qiskit.providers.fake_provider import FakeArmonkV2, FakeAthensV2, FakeBelemV2
+from qiskit.providers.models import PulseDefaults
+from qiskit.providers.fake_provider.utils.json_decoder import decode_pulse_defaults
+
+
+class PulseDefaultsMixin:
+    """Mixin class to add defaults() to a fake backend
+
+    In particular, this class works with
+    ``qiskit.providers.fake_provider.fake_backend.FakeBackendV2`` classes that
+    have a ``defs_filename`` attribute with the path to a pulse defaults json
+    file.
+    """
+
+    _defaults = None
+
+    def defaults(self):
+        """Returns a snapshot of device defaults"""
+        if not self._defaults:
+            self._set_defaults_from_json()
+        return self._defaults
+
+    def _set_defaults_from_json(self):
+        if not self.props_filename:
+            raise QiskitError("No properties file has been defined")
+        defs = self._load_json(self.defs_filename)
+        decode_pulse_defaults(defs)
+        self._defaults = PulseDefaults.from_dict(defs)
+
+
+class FakeArmonkV2Pulse(FakeArmonkV2, PulseDefaultsMixin):
+    """FakeArmonkV2 with pulse defaults"""
+
+
+class FakeAthensV2Pulse(FakeAthensV2, PulseDefaultsMixin):
+    """FakeAthensV2 with pulse defaults"""
+
+
+class FakeBelemV2Pulse(FakeBelemV2, PulseDefaultsMixin):
+    """FakeBelemV2 with pulse defaults"""

qiskit_experiments/test/mock_iq_backend.py

@@ -16,8 +16,10 @@
 import numpy as np
 
 from qiskit import QuantumCircuit
+from qiskit.circuit.library import XGate, SXGate
 from qiskit.result import Result
 from qiskit.providers.fake_provider import FakeOpenPulse2Q
+from qiskit.providers.fake_provider.fake_backend import FakeBackendV2
 
 from qiskit.qobj.utils import MeasLevel
 from qiskit_experiments.exceptions import QiskitError
@@ -31,7 +33,46 @@
 )
 
 
-class MockRestlessBackend(FakeOpenPulse2Q):
+class FakeOpenPulse2QV2(FakeBackendV2):
+    """BackendV2 version of FakeOpenPulse2Q"""
+
+    def __init__(self):
+        # FakeOpenPulse2Q has its data hard-coded rather than in json files. We
+        # prepopulate the dicts so that FakeBackendV2 does not try to load them
+        # from files.
+        #
+        # We have to use a hack to populate _conf_dict
+        backend_v1 = FakeOpenPulse2Q()
+        self._conf_dict_real = backend_v1._configuration.to_dict()
+        super().__init__()
+        self._props_dict = backend_v1._properties.to_dict()
+        self._defs_dict = backend_v1._defaults.to_dict()
+        self._defaults = backend_v1._defaults
+
+        # Workaround a bug in FakeOpenPulse2Q. It defines u1 on qubit 1 in the
+        # cmd_def in the defaults json file but not in the gates in the
+        # properties json. The code FakeBackendV2 uses to build the Target
+        # assumes these two are consistent.
+        u1_0 = next(g for g in self._props_dict["gates"] if g["gate"] == "u1")
+        self._props_dict["gates"].append(u1_0.copy())
+        self._props_dict["gates"][-1]["qubits"] = [1]
+
+    @property
+    def _conf_dict(self):
+        # FakeBackendV2 sets this in __init__. As a hack, we use this property
+        # to prevent it from overriding our values.
+        return self._conf_dict_real
+
+    @_conf_dict.setter
+    def _conf_dict(self, value):
+        pass
+
+    def defaults(self):
+        """Pulse defaults"""
+        return self._defaults
+
+
+class MockRestlessBackend(FakeOpenPulse2QV2):
     """An abstract backend for testing that can mock restless data."""
 
     def __init__(self, rng_seed: int = 0):
@@ -144,7 +185,8 @@ def __init__(
         self._angle_per_gate = angle_per_gate
         super().__init__(rng_seed=rng_seed)
 
-        self.configuration().basis_gates.extend(["sx", "x"])
+        self.target.add_instruction(SXGate(), properties={(0,): None})
+        self.target.add_instruction(XGate(), properties={(0,): None})
 
     def _compute_outcome_probabilities(self, circuits: List[QuantumCircuit]):
         """Compute the probabilities of being in the excited state or
@@ -170,7 +212,7 @@ def _compute_outcome_probabilities(self, circuits: List[QuantumCircuit]):
             self._precomputed_probabilities[(idx, "01")] = [prob_1, prob_0, 0, 0]
 
 
-class MockIQBackend(FakeOpenPulse2Q):
+class MockIQBackend(FakeOpenPulse2QV2):
     """A mock backend for testing with IQ data."""
 
     def __init__(

test/calibration/test_calibrations.py

@@ -31,12 +31,12 @@
 from qiskit import transpile, QuantumCircuit
 from qiskit.pulse.transforms import inline_subroutines, block_to_schedule
 import qiskit.pulse as pulse
-from qiskit.providers.fake_provider import FakeArmonkV2, FakeBelemV2
 from qiskit_experiments.framework import BackendData
 from qiskit_experiments.calibration_management.calibrations import Calibrations, ParameterKey
 from qiskit_experiments.calibration_management.parameter_value import ParameterValue
 from qiskit_experiments.calibration_management.basis_gate_library import FixedFrequencyTransmon
 from qiskit_experiments.exceptions import CalibrationError
+from qiskit_experiments.test.fake_pulse_backends import FakeArmonkV2Pulse, FakeBelemV2Pulse
 
 
 class TestCalibrationsBasic(QiskitExperimentsTestCase):
@@ -274,7 +274,7 @@ def test_qubit_input(self):
     def test_from_backend(self):
         """Test that when generating calibrations from backend
         the data is passed correctly"""
-        backend = FakeBelemV2()
+        backend = FakeBelemV2Pulse()
         cals = Calibrations.from_backend(backend)
         config_args = cals.config()["kwargs"]
         control_channel_map_size = len(config_args["control_channel_map"].chan_map)
@@ -1446,7 +1446,7 @@ def test_save_load_library(self):
         """
 
         library = FixedFrequencyTransmon()
-        backend = FakeArmonkV2()
+        backend = FakeArmonkV2Pulse()
         cals = Calibrations.from_backend(backend, libraries=[library])
 
         cals.parameters_table()
@@ -1459,7 +1459,7 @@ def test_save_load_library(self):
         self.assertEqual(cals.get_parameter_value("amp", (0,), "x"), 0.5)
         self.assertEqual(
             cals.get_parameter_value("drive_freq", (0,)),
-            BackendData(backend).drive_freqs[0],
+            backend.defaults().qubit_freq_est[0],
         )
 
 
@@ -1470,7 +1470,7 @@ def test_setup_withLibrary(self):
         """Test that we can setup with a library."""
 
         cals = Calibrations.from_backend(
-            FakeArmonkV2(),
+            FakeArmonkV2Pulse(),
             libraries=[
                 FixedFrequencyTransmon(basis_gates=["x", "sx"], default_values={"duration": 320})
             ],
@@ -1491,7 +1491,7 @@ def test_setup_withLibrary(self):
     def test_instruction_schedule_map_export(self):
         """Test that exporting the inst map works as planned."""
 
-        backend = FakeBelemV2()
+        backend = FakeBelemV2Pulse()
 
         cals = Calibrations.from_backend(
             backend,
@@ -1520,7 +1520,7 @@ def test_inst_map_transpilation(self):
         """Test that we can use the inst_map to inject the cals into the circuit."""
 
         cals = Calibrations.from_backend(
-            FakeArmonkV2(),
+            FakeArmonkV2Pulse(),
             libraries=[FixedFrequencyTransmon(basis_gates=["x"])],
         )
 
@@ -1570,7 +1570,7 @@ def test_inst_map_updates(self):
         """Test that updating a parameter will force an inst map update."""
 
         cals = Calibrations.from_backend(
-            FakeBelemV2(),
+            FakeBelemV2Pulse(),
             libraries=[FixedFrequencyTransmon(basis_gates=["sx", "x"])],
         )
 
@@ -1619,7 +1619,7 @@ def test_cx_cz_case(self):
         a CX on qubits 0, 1 in the inst. map and a CZ on qubits 1, 2.
         """
 
-        cals = Calibrations.from_backend(FakeBelemV2())
+        cals = Calibrations.from_backend(FakeBelemV2Pulse())
 
         sig = Parameter("σ")
         dur = Parameter("duration")
@@ -1666,7 +1666,7 @@ def test_cx_cz_case(self):
     def test_alternate_initialization(self):
         """Test that we can initialize without a backend object."""
 
-        backend = FakeBelemV2()
+        backend = FakeBelemV2Pulse()
         library = FixedFrequencyTransmon(basis_gates=["sx", "x"])
 
         backend_data = BackendData(backend)
@@ -1690,7 +1690,7 @@ class TestSerialization(QiskitExperimentsTestCase):
     def test_serialization(self):
         """Test the serialization."""
 
-        backend = FakeBelemV2()
+        backend = FakeBelemV2Pulse()
         library = FixedFrequencyTransmon(basis_gates=["sx", "x"])
 
         cals = Calibrations.from_backend(backend, libraries=[library])
@@ -1700,7 +1700,7 @@ def test_serialization(self):
 
     def test_equality(self):
         """Test the equal method on calibrations."""
-        backend = FakeBelemV2()
+        backend = FakeBelemV2Pulse()
         library = FixedFrequencyTransmon(basis_gates=["sx", "x"])
 
         cals1 = Calibrations.from_backend(