Update calibration and mixin tests to work with BackendV2

qiskit_experiments/framework/backend_data.py

@@ -224,14 +224,14 @@ def meas_freqs(self):
         """Returns the backend's measurement stimulus frequencies.
 
         .. note::
-            Currently BackendV2 does not have access to this data.
+
+            The qiskit-terra base classes do not provide this information as a
+            standard backend property, but it is available from some providers
+            in the data returned by the ``Backend.defaults()`` method.
         """
-        if self._v1:
-            return getattr(self._backend.defaults(), "meas_freq_est", [])
-        elif self._v2:
-            # meas_freq_est is currently not part of the BackendV2
+        if not hasattr(self._backend, "defaults"):
             return []
-        return []
+        return getattr(self._backend.defaults(), "meas_freq_est", [])
 
     @property
     def num_qubits(self):
@@ -262,3 +262,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(qubit).t1
+        return float("nan")

qiskit_experiments/framework/restless_mixin.py

@@ -201,7 +201,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/resonator_spectroscopy.py

@@ -175,26 +175,38 @@ def __init__(
 
         Raises:
             QiskitError: If no frequencies are given and absolute frequencies are desired and
-                no backend is given.
+                no backend is given or the backend does not have default measurement frequencies.
         """
         analysis = ResonatorSpectroscopyAnalysis()
 
         if frequencies is None:
             frequencies = np.linspace(-20.0e6, 20.0e6, 51)
 
             if absolute:
-                if backend is None:
-                    raise QiskitError(
-                        "Cannot automatically compute absolute frequencies without a backend."
-                    )
-
-                center_freq = BackendData(backend).meas_freqs[physical_qubits[0]]
-                frequencies += center_freq
+                frequencies += self._get_backend_meas_freq(
+                    BackendData(backend) if backend is not None else None,
+                    physical_qubits[0],
+                )
 
         super().__init__(
             physical_qubits, frequencies, backend, absolute, analysis, **experiment_options
         )
 
+    @staticmethod
+    def _get_backend_meas_freq(backend_data: Optional[BackendData], qubit: int) -> float:
+        """Get backend meas_freq with error checking"""
+        if backend_data is None:
+            raise QiskitError(
+                "Cannot automatically compute absolute frequencies without a backend."
+            )
+
+        if len(backend_data.meas_freqs) < qubit + 1:
+            raise QiskitError(
+                "Cannot retrieve default measurement frequencies from backend. "
+                "Please set frequencies explicitly or set `absolute` to `False`."
+            )
+        return backend_data.meas_freqs[qubit]
+
     @property
     def _backend_center_frequency(self) -> float:
         """Returns the center frequency of the experiment.
@@ -205,10 +217,7 @@ def _backend_center_frequency(self) -> float:
         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_data.meas_freqs[self.physical_qubits[0]]
+        return self._get_backend_meas_freq(self._backend_data, self.physical_qubits[0])
 
     def _template_circuit(self) -> QuantumCircuit:
         """Return the template quantum circuit."""

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,49 @@
 )
 
 
-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
+
+    # This method is not defined in the base class as we would like to avoid
+    # relying on it as much as necessary. Individual tests should add it when
+    # necessary.
+    # 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):
@@ -145,7 +189,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
@@ -171,7 +216,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__(

releasenotes/notes/calibration-backendv2-e564f466eb1c9999.yaml

@@ -0,0 +1,10 @@
+---
+fixes:
+  - |
+    Updated querying of :class:`~qiskit.providers.Backend` metadata to support
+    the look up of qubit T1 and measurement drive frequency, in order to
+    support :class:`~qiskit.providers.BackendV2` backends. The look up of the
+    latter is ``qiskit-ibm-provider`` specific. This change fixes errors
+    failing to find these properties when using :class:`.ResonatorSpectroscopy`
+    (issue `#1099 <https://github.com/Qiskit/qiskit-experiments/issues/1099>_`)
+    and when using restless measurements with ``BackendV2`` backends.

test/calibration/test_update_library.py

@@ -14,44 +14,17 @@
 from test.base import QiskitExperimentsTestCase
 import numpy as np
 
-from qiskit import pulse
-from qiskit.circuit import Parameter
-from qiskit.qobj.utils import MeasLevel
 from qiskit.providers.fake_provider import FakeAthensV2
+from qiskit.qobj.utils import MeasLevel
 
+from qiskit_experiments.framework import BackendData
 from qiskit_experiments.library import QubitSpectroscopy
 from qiskit_experiments.calibration_management.calibrations import Calibrations
 from qiskit_experiments.calibration_management.update_library import Frequency
 from qiskit_experiments.test.mock_iq_backend import MockIQBackend
 from qiskit_experiments.test.mock_iq_helpers import MockIQSpectroscopyHelper as SpectroscopyHelper
 
 
-class TestAmplitudeUpdate(QiskitExperimentsTestCase):
-    """Test the update functions in the update library."""
-
-    def setUp(self):
-        """Setup amplitude values."""
-        super().setUp()
-        self.cals = Calibrations(coupling_map=[])
-        self.qubit = 1
-
-        axp = Parameter("amp")
-        chan = Parameter("ch0")
-        with pulse.build(name="xp") as xp:
-            pulse.play(pulse.Gaussian(duration=160, amp=axp, sigma=40), pulse.DriveChannel(chan))
-
-        ax90p = Parameter("amp")
-        with pulse.build(name="x90p") as x90p:
-            pulse.play(pulse.Gaussian(duration=160, amp=ax90p, sigma=40), pulse.DriveChannel(chan))
-
-        self.x90p = x90p
-
-        self.cals.add_schedule(xp, num_qubits=1)
-        self.cals.add_schedule(x90p, num_qubits=1)
-        self.cals.add_parameter_value(0.2, "amp", self.qubit, "xp")
-        self.cals.add_parameter_value(0.1, "amp", self.qubit, "x90p")
-
-
 class TestFrequencyUpdate(QiskitExperimentsTestCase):
     """Test the frequency update function in the update library."""
 
@@ -67,10 +40,8 @@ def test_frequency(self):
                 iq_cluster_width=[0.2],
             ),
         )
-        backend._configuration.basis_gates = ["x"]
-        backend._configuration.timing_constraints = {"granularity": 16}
 
-        freq01 = backend.defaults().qubit_freq_est[qubit]
+        freq01 = BackendData(backend).drive_freqs[qubit]
         frequencies = np.linspace(freq01 - 10.0e6, freq01 + 10.0e6, 21)
 
         spec = QubitSpectroscopy([qubit], frequencies)

test/library/calibration/test_fine_amplitude.py

@@ -16,6 +16,7 @@
 from ddt import ddt, data
 
 from qiskit import pulse, transpile
+from qiskit.circuit import Gate
 from qiskit.circuit.library import XGate, SXGate
 from qiskit.pulse import DriveChannel, Drag
 
@@ -41,10 +42,11 @@ def test_end_to_end_under_rotation(self, pi_ratio):
         """Test the experiment end to end."""
 
         amp_exp = FineXAmplitude([0])
-        amp_exp.set_transpile_options(basis_gates=["x", "sx"])
 
         error = -np.pi * pi_ratio
         backend = MockIQBackend(FineAmpHelper(error, np.pi, "x"))
+        backend.target.add_instruction(XGate(), properties={(0,): None})
+        backend.target.add_instruction(SXGate(), properties={(0,): None})
 
         expdata = amp_exp.run(backend)
         self.assertExperimentDone(expdata)
@@ -61,10 +63,11 @@ def test_end_to_end_over_rotation(self, pi_ratio):
         """Test the experiment end to end."""
 
         amp_exp = FineXAmplitude([0])
-        amp_exp.set_transpile_options(basis_gates=["x", "sx"])
 
         error = np.pi * pi_ratio
         backend = MockIQBackend(FineAmpHelper(error, np.pi, "x"))
+        backend.target.add_instruction(XGate(), properties={(0,): None})
+        backend.target.add_instruction(SXGate(), properties={(0,): None})
         expdata = amp_exp.run(backend)
         self.assertExperimentDone(expdata)
         result = expdata.analysis_results(1)
@@ -87,6 +90,7 @@ def test_end_to_end(self, pi_ratio):
         error = -np.pi * pi_ratio
         amp_exp = FineZXAmplitude((0, 1))
         backend = MockIQBackend(FineAmpHelper(error, np.pi / 2, "szx"))
+        backend.target.add_instruction(Gate("szx", 2, []), properties={(0, 1): None})
 
         expdata = amp_exp.run(backend)
         self.assertExperimentDone(expdata)
@@ -207,8 +211,8 @@ def setUp(self):
         library = FixedFrequencyTransmon()
 
         self.backend = MockIQBackend(FineAmpHelper(-np.pi * 0.07, np.pi, "xp"))
-        self.backend.configuration().basis_gates.append("sx")
-        self.backend.configuration().basis_gates.append("x")
+        self.backend.target.add_instruction(SXGate(), properties={(0,): None})
+        self.backend.target.add_instruction(XGate(), properties={(0,): None})
         self.cals = Calibrations.from_backend(self.backend, libraries=[library])
 
     def test_cal_options(self):

test/library/calibration/test_fine_frequency.py

@@ -23,9 +23,9 @@
     FineFrequency,
     FineFrequencyCal,
 )
-from qiskit_experiments.framework import BackendData
 from qiskit_experiments.calibration_management.basis_gate_library import FixedFrequencyTransmon
 from qiskit_experiments.calibration_management import Calibrations
+from qiskit_experiments.framework import BackendData
 from qiskit_experiments.test.mock_iq_backend import MockIQBackend
 from qiskit_experiments.test.mock_iq_helpers import MockIQFineFreqHelper as FineFreqHelper
 
@@ -53,7 +53,7 @@ def test_end_to_end(self, freq_shift):
         """Test the experiment end to end."""
         exp_helper = FineFreqHelper(sx_duration=self.sx_duration, freq_shift=freq_shift)
         backend = MockIQBackend(exp_helper)
-        exp_helper.dt = backend.configuration().dt
+        exp_helper.dt = BackendData(backend).dt
 
         freq_exp = FineFrequency([0], 160, backend)
         freq_exp.set_transpile_options(inst_map=self.inst_map)
@@ -62,7 +62,7 @@ def test_end_to_end(self, freq_shift):
         self.assertExperimentDone(expdata)
         result = expdata.analysis_results(1)
         d_theta = result.value.n
-        dt = backend.configuration().dt
+        dt = BackendData(backend).dt
         d_freq = d_theta / (2 * np.pi * self.sx_duration * dt)
 
         tol = 0.01e6
@@ -75,7 +75,7 @@ def test_calibration_version(self):
 
         exp_helper = FineFreqHelper(sx_duration=self.sx_duration, freq_shift=0.1e6)
         backend = MockIQBackend(exp_helper)
-        exp_helper.dt = backend.configuration().dt
+        exp_helper.dt = BackendData(backend).dt
 
         fine_freq = FineFrequencyCal([0], self.cals, backend)
         armonk_freq = BackendData(FakeArmonkV2()).drive_freqs[0]

test/library/calibration/test_ramsey_xy.py

@@ -21,7 +21,7 @@
 
 from qiskit_experiments.calibration_management.calibrations import Calibrations
 from qiskit_experiments.calibration_management.basis_gate_library import FixedFrequencyTransmon
-from qiskit_experiments.framework import BaseAnalysis, AnalysisStatus, BackendData
+from qiskit_experiments.framework import AnalysisStatus, BackendData, BaseAnalysis
 from qiskit_experiments.library import RamseyXY, FrequencyCal
 from qiskit_experiments.test.mock_iq_backend import MockIQBackend
 from qiskit_experiments.test.mock_iq_helpers import MockIQRamseyXYHelper as RamseyXYHelper