Dispatch a builder with backendV1 and backendV2

qiskit/pulse/builder.py

@@ -495,9 +495,11 @@
     library,
     transforms,
 )
+from qiskit.providers.backend import BackendV2
 from qiskit.pulse.instructions import directives
 from qiskit.pulse.schedule import Schedule, ScheduleBlock
 from qiskit.pulse.transforms.alignments import AlignmentKind
+from qiskit.pulse.utils import get_qubit_channels
 
 
 #: contextvars.ContextVar[BuilderContext]: active builder
@@ -677,6 +679,9 @@ def get_context(self) -> ScheduleBlock:
     @_requires_backend
     def num_qubits(self):
         """Get the number of qubits in the backend."""
+        # backendV2
+        if isinstance(self.backend, BackendV2):
+            return self.backend.num_qubits
         return self.backend.configuration().n_qubits
 
     @property
@@ -1105,6 +1110,8 @@ def num_qubits() -> int:
 
     .. note:: Requires the active builder context to have a backend set.
     """
+    if isinstance(active_backend(), BackendV2):
+        return active_backend().num_qubits
     return active_backend().configuration().n_qubits
 
 
@@ -1120,6 +1127,12 @@ def seconds_to_samples(seconds: Union[float, np.ndarray]) -> Union[int, np.ndarr
     Returns:
         The number of samples for the time to elapse
     """
+    # backendV2
+    if isinstance(active_backend(), BackendV2):
+        if isinstance(seconds, np.ndarray):
+            return (seconds / active_backend().dt).astype(int)
+        else:
+            return int(seconds / active_backend().dt)
     if isinstance(seconds, np.ndarray):
         return (seconds / active_backend().configuration().dt).astype(int)
     return int(seconds / active_backend().configuration().dt)
@@ -1135,6 +1148,9 @@ def samples_to_seconds(samples: Union[int, np.ndarray]) -> Union[float, np.ndarr
     Returns:
         The time that elapses in ``samples``.
     """
+    # backendV2
+    if isinstance(active_backend(), BackendV2):
+        return samples * active_backend().dt
     return samples * active_backend().configuration().dt
 
 
@@ -1163,6 +1179,9 @@ def qubit_channels(qubit: int) -> Set[chans.Channel]:
         such as in the case where significant crosstalk exists.
 
     """
+    # backendV2
+    if isinstance(active_backend(), BackendV2):
+        return set(get_qubit_channels(active_backend(), qubit))
     return set(active_backend().configuration().get_qubit_channels(qubit))
 
 
@@ -1648,7 +1667,11 @@ def frequency_offset(
     finally:
         if compensate_phase:
             duration = builder.get_context().duration - t0
-            dt = active_backend().configuration().dt
+            # backendV2
+            if isinstance(active_backend(), BackendV2):
+                dt = active_backend().dt
+            else:
+                dt = active_backend().configuration().dt
             accumulated_phase = 2 * np.pi * ((duration * dt * frequency) % 1)
             for channel in channels:
                 shift_phase(-accumulated_phase, channel)
@@ -1675,6 +1698,9 @@ def drive_channel(qubit: int) -> chans.DriveChannel:
 
     .. note:: Requires the active builder context to have a backend set.
     """
+    # backendV2
+    if isinstance(active_backend(), BackendV2):
+        return active_backend().drive_channel(qubit)
     return active_backend().configuration().drive(qubit)
 
 
@@ -1695,6 +1721,9 @@ def measure_channel(qubit: int) -> chans.MeasureChannel:
 
     .. note:: Requires the active builder context to have a backend set.
     """
+    # backendV2
+    if isinstance(active_backend(), BackendV2):
+        return active_backend().measure_channel(qubit)
     return active_backend().configuration().measure(qubit)
 
 
@@ -1715,6 +1744,9 @@ def acquire_channel(qubit: int) -> chans.AcquireChannel:
 
     .. note:: Requires the active builder context to have a backend set.
     """
+    # backendV2
+    if isinstance(active_backend(), BackendV2):
+        return active_backend().acquire_channel(qubit)
     return active_backend().configuration().acquire(qubit)
 
 
@@ -1745,6 +1777,9 @@ def control_channels(*qubits: Iterable[int]) -> List[chans.ControlChannel]:
         List of control channels associated with the supplied ordered list
         of qubits.
     """
+    # backendV2
+    if isinstance(active_backend(), BackendV2):
+        return active_backend().control_channel(qubits)
     return active_backend().configuration().control(qubits=qubits)
 
 
@@ -2428,11 +2463,9 @@ def measure(
             registers = list(registers)
         except TypeError:
             registers = [registers]
-
     measure_sched = macros.measure(
         qubits=qubits,
-        inst_map=backend.defaults().instruction_schedule_map,
-        meas_map=backend.configuration().meas_map,
+        backend=backend,
         qubit_mem_slots={qubit: register.index for qubit, register in zip(qubits, registers)},
     )
 
@@ -2478,10 +2511,10 @@ def measure_all() -> List[chans.MemorySlot]:
     backend = active_backend()
     qubits = range(num_qubits())
     registers = [chans.MemorySlot(qubit) for qubit in qubits]
+
     measure_sched = macros.measure(
         qubits=qubits,
-        inst_map=backend.defaults().instruction_schedule_map,
-        meas_map=backend.configuration().meas_map,
+        backend=backend,
         qubit_mem_slots={qubit: qubit for qubit in qubits},
     )
 

qiskit/pulse/macros.py

@@ -18,6 +18,7 @@
 from qiskit.pulse import channels, exceptions, instructions, utils
 from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap
 from qiskit.pulse.schedule import Schedule
+from qiskit.providers.backend import BackendV2
 
 
 if TYPE_CHECKING:
@@ -62,17 +63,12 @@ def measure(
     """
 
     # backend is V2.
-    if hasattr(backend, "target"):
-        try:
-            meas_map = backend.configuration().meas_map
-        except AttributeError:
-            # TODO add meas_map to Target in 0.25
-            meas_map = [list(range(backend.num_qubits))]
+    if isinstance(backend, BackendV2):
 
         return _measure_v2(
             qubits=qubits,
             target=backend.target,
-            meas_map=meas_map,
+            meas_map=meas_map or backend.meas_map,
             qubit_mem_slots=qubit_mem_slots or dict(zip(qubits, range(len(qubits)))),
             measure_name=measure_name,
         )
@@ -198,20 +194,14 @@ def _measure_v2(
                         channels.AcquireChannel(measure_qubit),
                     ]
                 )
-            else:
-                default_sched = target.get_calibration(measure_name, (measure_qubit,)).filter(
-                    channels=[
-                        channels.AcquireChannel(measure_qubit),
-                    ]
-                )
+                schedule += _schedule_remapping_memory_slot(default_sched, qubit_mem_slots)
         except KeyError as ex:
             raise exceptions.PulseError(
                 "We could not find a default measurement schedule called '{}'. "
                 "Please provide another name using the 'measure_name' keyword "
                 "argument. For assistance, the instructions which are defined are: "
                 "{}".format(measure_name, target.instructions)
             ) from ex
-        schedule += _schedule_remapping_memory_slot(default_sched, qubit_mem_slots)
     return schedule
 
 
@@ -226,7 +216,12 @@ def measure_all(backend) -> Schedule:
     Returns:
         A schedule corresponding to the inputs provided.
     """
-    return measure(qubits=list(range(backend.configuration().n_qubits)), backend=backend)
+    # backend is V2.
+    if isinstance(backend, BackendV2):
+        qubits = list(range(backend.num_qubits))
+    else:
+        qubits = list(range(backend.configuration().n_qubits))
+    return measure(qubits=qubits, backend=backend)
 
 
 def _schedule_remapping_memory_slot(

qiskit/pulse/utils.py

@@ -11,7 +11,9 @@
 # that they have been altered from the originals.
 
 """Module for common pulse programming utilities."""
-from typing import List, Dict, Union
+from __future__ import annotations
+
+from typing import List, Dict, Union, TYPE_CHECKING
 import warnings
 
 import numpy as np
@@ -20,6 +22,9 @@
 from qiskit.pulse.exceptions import UnassignedDurationError, QiskitError
 from qiskit.utils.deprecation import deprecate_func, deprecate_function
 
+if TYPE_CHECKING:
+    from qiskit.providers.backend import BackendV2
+
 
 def format_meas_map(meas_map: List[List[int]]) -> Dict[int, List[int]]:
     """
@@ -125,3 +130,24 @@ def deprecated_functionality(func):
         stacklevel=2,
         since="0.22.0",
     )(func)
+
+
+def get_qubit_channels(backend: BackendV2, qubit: int):
+    r"""Return a list of channels which operate on the given ``qubit``.
+    Returns:
+        List of ``Channel``\s operated on my the given ``qubit``.
+    """
+    channels = []
+
+    # add multi-qubit channels
+    for node_qubits in backend.coupling_map:
+        if qubit in node_qubits:
+            control_channels = backend.control_channel(node_qubits)
+            if control_channels:
+                channels.extend(control_channels)
+
+    # add single qubit channels
+    channels.append(backend.drive_channel(qubit))
+    channels.append(backend.measure_channel(qubit))
+    channels.append(backend.acquire_channel(qubit))
+    return channels

releasenotes/notes/fix-dispatching-backends-28aff96f726ca9c5.yaml

@@ -0,0 +1,5 @@
+---
+fixes:
+  - |
+    Fixed an failure that attributes of :class:`.BackendV2` backends cannot be used
+    by introducing dispatching with backends in a builder.

test/python/pulse/test_builder.py

@@ -258,7 +258,6 @@ def test_phase_compensated_frequency_offset(self):
         """Test that the phase offset context properly compensates for phase
         accumulation."""
         d0 = pulse.DriveChannel(0)
-
         with pulse.build(self.backend) as schedule:
             with pulse.frequency_offset(1e9, d0, compensate_phase=True):
                 pulse.delay(10, d0)
@@ -270,7 +269,6 @@ def test_phase_compensated_frequency_offset(self):
             -2 * np.pi * ((1e9 * 10 * self.configuration.dt) % 1), d0
         )
         reference += instructions.ShiftFrequency(-1e9, d0)
-
         self.assertScheduleEqual(schedule, reference)
 
 
@@ -535,7 +533,6 @@ def test_barrier_on_qubits(self):
         """Test barrier directive on qubits."""
         with pulse.build(self.backend) as schedule:
             pulse.barrier(0, 1)
-
         reference = pulse.ScheduleBlock()
         reference += directives.RelativeBarrier(
             pulse.DriveChannel(0),