Bug fix macros.measure with backendv2

qiskit/providers/backend_compat.py

@@ -56,7 +56,11 @@ def convert_to_target(
     # Parse from properties if it exsits
     if properties is not None:
         qubit_properties = qubit_props_list_from_props(properties=properties)
-        target = Target(num_qubits=configuration.n_qubits, qubit_properties=qubit_properties)
+        target = Target(
+            num_qubits=configuration.n_qubits,
+            qubit_properties=qubit_properties,
+            meas_map=configuration.meas_map,
+        )
         # Parse instructions
         gates: Dict[str, Any] = {}
         for gate in properties.gates:
@@ -100,7 +104,7 @@ def convert_to_target(
         target.add_instruction(Measure(), measure_props)
     # Parse from configuration because properties doesn't exist
     else:
-        target = Target(num_qubits=configuration.n_qubits)
+        target = Target(num_qubits=configuration.n_qubits, meas_map=configuration.meas_map)
         for gate in configuration.gates:
             name = gate.name
             gate_props = (

qiskit/providers/fake_provider/utils/backend_converter.py

@@ -43,7 +43,7 @@ def convert_to_target(conf_dict: dict, props_dict: dict = None, defs_dict: dict
     qubit_props = None
     if props_dict:
         qubit_props = qubit_props_from_props(props_dict)
-    target = Target(qubit_properties=qubit_props)
+    target = Target(qubit_properties=qubit_props, meas_map=conf_dict.get("meas_map"))
     # Parse from properties if it exsits
     if props_dict is not None:
         # Parse instructions

qiskit/pulse/macros.py

@@ -11,14 +11,29 @@
 # that they have been altered from the originals.
 
 """Module for common pulse programming macros."""
+from __future__ import annotations
 
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, Union, TYPE_CHECKING
 
 from qiskit.pulse import channels, exceptions, instructions, utils
 from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap
 from qiskit.pulse.schedule import Schedule
+from qiskit.utils.deprecation import deprecate_arg
 
 
+if TYPE_CHECKING:
+    from qiskit.transpiler import Target
+
+
+@deprecate_arg(
+    "backend",
+    deprecation_description=(
+        "Depricating ``backendV1`` as the type of measure's `backend` argument."
+    ),
+    additional_msg=("Instead use ``backendV2``as the type of measure's `backend` argument."),
+    since="0.25.0",
+    pending=True,
+)
 def measure(
     qubits: List[int],
     backend=None,
@@ -30,6 +45,13 @@ def measure(
     """Return a schedule which measures the requested qubits according to the given
     instruction mapping and measure map, or by using the defaults provided by the backend.
 
+    If the backend has an attribute ``target``, the function uses the measurement logic,
+    "_measure_v2" that takes ``target`` of the ``backend``, ``meas_map`` and ``qubit_mem_slots``
+    assignment.
+    Otherwise, if the backend is None or ``backendV1``, the function uses the
+    measurement logic, "_measure_v1" including ``instruction_schedule_map`` and ``meas_map``
+    as inputs.
+
     By default, the measurement results for each qubit are trivially mapped to the qubit
     index. This behavior is overridden by qubit_mem_slots. For instance, to measure
     qubit 0 into MemorySlot(1), qubit_mem_slots can be provided as {0: 1}.
@@ -47,18 +69,62 @@ def measure(
 
     Returns:
         A measurement schedule corresponding to the inputs provided.
+    """
+
+    # backend is V2.
+    if hasattr(backend, "target"):
+        target = backend.target
+        return _measure_v2(
+            qubits=qubits,
+            target=target,
+            meas_map=meas_map or target.meas_map,
+            qubit_mem_slots=qubit_mem_slots or dict(zip(qubits, range(len(qubits)))),
+            measure_name=measure_name,
+        )
+    # backend is V1 or backend is None.
+    else:
+        try:
+            return _measure_v1(
+                qubits=qubits,
+                inst_map=inst_map or backend.defaults().instruction_schedule_map,
+                meas_map=meas_map or backend.configuration().meas_map,
+                qubit_mem_slots=qubit_mem_slots,
+                measure_name=measure_name,
+            )
+        except AttributeError as ex:
+            raise exceptions.PulseError(
+                "inst_map or meas_map, and backend cannot be None simultaneously"
+            ) from ex
+
 
+def _measure_v1(
+    qubits: List[int],
+    inst_map: InstructionScheduleMap,
+    meas_map: Union[List[List[int]], Dict[int, List[int]]],
+    qubit_mem_slots: Optional[Dict[int, int]] = None,
+    measure_name: str = "measure",
+) -> Schedule:
+    """Return a schedule which measures the requested qubits according to the given
+    instruction mapping and measure map, or by using the defaults provided by the backendV1.
+
+    Args:
+        qubits: List of qubits to be measured.
+        backend (Union[Backend, BaseBackend]): A backend instance, which contains
+            hardware-specific data required for scheduling.
+        inst_map: Mapping of circuit operations to pulse schedules. If None, defaults to the
+                  ``instruction_schedule_map`` of ``backend``.
+        meas_map: List of sets of qubits that must be measured together. If None, defaults to
+                  the ``meas_map`` of ``backend``.
+        qubit_mem_slots: Mapping of measured qubit index to classical bit index.
+        measure_name: Name of the measurement schedule.
+    Returns:
+        A measurement schedule corresponding to the inputs provided.
     Raises:
         PulseError: If both ``inst_map`` or ``meas_map``, and ``backend`` is None.
     """
+
     schedule = Schedule(name=f"Default measurement schedule for qubits {qubits}")
-    try:
-        inst_map = inst_map or backend.defaults().instruction_schedule_map
-        meas_map = meas_map or backend.configuration().meas_map
-    except AttributeError as ex:
-        raise exceptions.PulseError(
-            "inst_map or meas_map, and backend cannot be None simultaneously"
-        ) from ex
+
     if isinstance(meas_map, list):
         meas_map = utils.format_meas_map(meas_map)
 
@@ -92,6 +158,63 @@ def measure(
     return schedule
 
 
+def _measure_v2(
+    qubits: List[int],
+    target: Target,
+    meas_map: Union[List[List[int]], Dict[int, List[int]]],
+    qubit_mem_slots: Dict[int, int],
+    measure_name: str = "measure",
+) -> Schedule:
+    """Return a schedule which measures the requested qubits according to the given
+    target and measure map, or by using the defaults provided by the backendV2.
+
+    Args:
+        qubits: List of qubits to be measured.
+        backend (Union[Backend, BaseBackend]): A backend instance, which contains
+            hardware-specific data required for scheduling.
+        target: The :class:`~.Target` representing the target backend.
+        meas_map: List of sets of qubits that must be measured together.
+        qubit_mem_slots: Mapping of measured qubit index to classical bit index.
+        measure_name: Name of the measurement schedule.
+
+    Returns:
+        A measurement schedule corresponding to the inputs provided.
+    """
+    schedule = Schedule(name=f"Default measurement schedule for qubits {qubits}")
+
+    if isinstance(meas_map, list):
+        meas_map = utils.format_meas_map(meas_map)
+    meas_group = set()
+    for qubit in qubits:
+        meas_group |= set(meas_map[qubit])
+    meas_group = sorted(list(meas_group))
+
+    for measure_qubit in meas_group:
+        try:
+            if measure_qubit in qubits:
+                default_sched = target.get_calibration(measure_name, (measure_qubit,)).filter(
+                    channels=[
+                        channels.MeasureChannel(measure_qubit),
+                        channels.AcquireChannel(measure_qubit),
+                    ]
+                )
+            else:
+                default_sched = target.get_calibration(measure_name, (measure_qubit,)).filter(
+                    channels=[
+                        channels.AcquireChannel(measure_qubit),
+                    ]
+                )
+        except exceptions.PulseError 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
+
+
 def measure_all(backend) -> Schedule:
     """
     Return a Schedule which measures all qubits of the given backend.
@@ -104,3 +227,33 @@ def measure_all(backend) -> Schedule:
         A schedule corresponding to the inputs provided.
     """
     return measure(qubits=list(range(backend.configuration().n_qubits)), backend=backend)
+
+
+def schedule_remapping_memory_slot(schedule: Schedule, qubit_mem_slots: Dict[int, int]) -> Schedule:
+    """
+    Return a Schedule which is remapped by given qubit_mem_slots.
+
+    Args:
+        schedule: A measurement schedule.
+        qubit_mem_slots: Mapping of measured qubit index to classical bit index.
+
+    Returns:
+        A schedule remapped by qubit_mem_slots as the input provided.
+    """
+    new_schedule = Schedule()
+    for t0, inst in schedule.instructions:
+        if isinstance(inst, instructions.Acquire):
+            qubit_index = inst.channel.index
+            reg_index = qubit_mem_slots.get(qubit_index, 0)
+            new_schedule.insert(
+                t0,
+                instructions.Acquire(
+                    inst.duration,
+                    channels.AcquireChannel(qubit_index),
+                    mem_slot=channels.MemorySlot(reg_index),
+                ),
+                inplace=True,
+            )
+        else:
+            new_schedule.insert(t0, inst, inplace=True)
+    return new_schedule

qiskit/transpiler/target.py

@@ -232,6 +232,7 @@ class Target(Mapping):
         "_non_global_strict_basis",
         "qubit_properties",
         "_global_operations",
+        "_meas_map",
     )
 
     @deprecate_arguments({"aquire_alignment": "acquire_alignment"}, since="0.23.0")
@@ -245,6 +246,7 @@ def __init__(
         pulse_alignment=1,
         acquire_alignment=1,
         qubit_properties=None,
+        meas_map=None,
     ):
         """
         Create a new Target object
@@ -280,6 +282,7 @@ def __init__(
                 matches the qubit number the properties are defined for. If some
                 qubits don't have properties available you can set that entry to
                 ``None``
+            meas_map (list): List of sets of qubits that must be measured together.
         Raises:
             ValueError: If both ``num_qubits`` and ``qubit_properties`` are both
             defined and the value of ``num_qubits`` differs from the length of
@@ -315,6 +318,7 @@ def __init__(
                         "length of the input qubit_properties list"
                     )
         self.qubit_properties = qubit_properties
+        self._meas_map = meas_map
 
     def add_instruction(self, instruction, properties=None, name=None):
         """Add a new instruction to the :class:`~qiskit.transpiler.Target`
@@ -1045,6 +1049,11 @@ def build_coupling_map(self, two_q_gate=None):
         else:
             return None
 
+    @property
+    def meas_map(self):
+        """Returns the grouping of measurements which are multiplexed"""
+        return self._meas_map
+
     @property
     def physical_qubits(self):
         """Returns a sorted list of physical_qubits"""