8110771392

Committed 01 Mar 2024 11:37AM UTC coverage: 89.298% (+0.008%) from 89.29%

Build # 8110771392

Build Type

push

github

Committed by

web-flow

Commit Message

Bug Fix for missing qubit property (#11880) (#11927)

(cherry picked from commit c566b3ffa)

Co-authored-by: Naoki Kanazawa <nkanazawa1989@gmail.com>

Run Details

5 of 7 new or added lines in 1 file covered. (71.43%)

4 existing lines in 2 files now uncovered.

58918 of 65979 relevant lines covered (89.3%)

183736.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.71

/qiskit/providers/backend_compat.py

# This code is part of Qiskit.
#
# (C) Copyright IBM 2020.
#
# 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.

"""Backend abstract interface for providers."""

from __future__ import annotations
import logging
import warnings
from typing import List, Iterable, Any, Dict, Optional

from qiskit.providers.backend import BackendV1, BackendV2
from qiskit.providers.backend import QubitProperties
from qiskit.providers.models.backendconfiguration import BackendConfiguration
from qiskit.providers.models.backendproperties import BackendProperties
from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
from qiskit.providers.models.pulsedefaults import PulseDefaults
from qiskit.providers.options import Options
from qiskit.providers.exceptions import BackendPropertyError

logger = logging.getLogger(__name__)


def convert_to_target(
    configuration: BackendConfiguration,
    properties: BackendProperties = None,
    defaults: PulseDefaults = None,
    custom_name_mapping: Optional[Dict[str, Any]] = None,
    add_delay: bool = True,
    filter_faulty: bool = True,
):
    """Decode transpiler target from backend data set.

    This function generates :class:`.Target`` instance from intermediate
    legacy objects such as :class:`.BackendProperties` and :class:`.PulseDefaults`.
    These objects are usually components of the legacy :class:`.BackendV1` model.

    Args:
        configuration: Backend configuration as ``BackendConfiguration``
        properties: Backend property dictionary or ``BackendProperties``
        defaults: Backend pulse defaults dictionary or ``PulseDefaults``
        custom_name_mapping: A name mapping must be supplied for the operation
            not included in Qiskit Standard Gate name mapping, otherwise the operation
            will be dropped in the resulting ``Target`` object.
        add_delay: If True, adds delay to the instruction set.
        filter_faulty: If True, this filters the non-operational qubits.

    Returns:
        A ``Target`` instance.
    """

    # importing pacakges where they are needed, to avoid cyclic-import.
    # pylint: disable=cyclic-import
    from qiskit.transpiler.target import (
        Target,
        InstructionProperties,
    )
    from qiskit.circuit.controlflow import ForLoopOp, IfElseOp, SwitchCaseOp, WhileLoopOp
    from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping
    from qiskit.circuit.parameter import Parameter
    from qiskit.circuit.gate import Gate

    required = ["measure", "delay"]

    # Load Qiskit object representation
    qiskit_inst_mapping = get_standard_gate_name_mapping()
    if custom_name_mapping:
        qiskit_inst_mapping.update(custom_name_mapping)

    qiskit_control_flow_mapping = {
        "if_else": IfElseOp,
        "while_loop": WhileLoopOp,
        "for_loop": ForLoopOp,
        "switch_case": SwitchCaseOp,
    }

    in_data = {"num_qubits": configuration.n_qubits}

    # Parse global configuration properties
    if hasattr(configuration, "dt"):
        in_data["dt"] = configuration.dt
    if hasattr(configuration, "timing_constraints"):
        in_data.update(configuration.timing_constraints)

    # Create instruction property placeholder from backend configuration
    basis_gates = set(getattr(configuration, "basis_gates", []))
    supported_instructions = set(getattr(configuration, "supported_instructions", []))
    gate_configs = {gate.name: gate for gate in configuration.gates}
    all_instructions = set.union(
        basis_gates, set(required), supported_instructions.intersection(CONTROL_FLOW_OP_NAMES)
    )

    inst_name_map = {}  # type: Dict[str, Instruction]

    faulty_ops = set()
    faulty_qubits = set()
    unsupported_instructions = []

    # Create name to Qiskit instruction object repr mapping
    for name in all_instructions:
        if name in qiskit_control_flow_mapping:
            continue
        if name in qiskit_inst_mapping:
            inst_name_map[name] = qiskit_inst_mapping[name]
        elif name in gate_configs:
            # GateConfig model is a translator of QASM opcode.
            # This doesn't have quantum definition, so Qiskit transpiler doesn't perform
            # any optimization in quantum domain.
            # Usually GateConfig counterpart should exist in Qiskit namespace so this is rarely called.
            this_config = gate_configs[name]
            params = list(map(Parameter, getattr(this_config, "parameters", [])))
            coupling_map = getattr(this_config, "coupling_map", [])
            inst_name_map[name] = Gate(
                name=name,
                num_qubits=len(coupling_map[0]) if coupling_map else 0,
                params=params,
            )
        else:
            warnings.warn(
                f"No gate definition for {name} can be found and is being excluded "
                "from the generated target. You can use `custom_name_mapping` to provide "
                "a definition for this operation.",
                RuntimeWarning,
            )
            unsupported_instructions.append(name)

    for name in unsupported_instructions:
        all_instructions.remove(name)

    # Create inst properties placeholder
    # Without any assignment, properties value is None,
    # which defines a global instruction that can be applied to any qubit(s).
    # The None value behaves differently from an empty dictionary.
    # See API doc of Target.add_instruction for details.
    prop_name_map = dict.fromkeys(all_instructions)
    for name in all_instructions:
        if name in gate_configs:
            if coupling_map := getattr(gate_configs[name], "coupling_map", None):
                # Respect operational qubits that gate configuration defines
                # This ties instruction to particular qubits even without properties information.
                # Note that each instruction is considered to be ideal unless
                # its spec (e.g. error, duration) is bound by the properties object.
                prop_name_map[name] = dict.fromkeys(map(tuple, coupling_map))

    # Populate instruction properties
    if properties:

        def _get_value(prop_dict, prop_name):
            if ndval := prop_dict.get(prop_name, None):
                return ndval[0]
            return None

        # is_qubit_operational is a bit of expensive operation so precache the value
        faulty_qubits = {
            q for q in range(configuration.num_qubits) if not properties.is_qubit_operational(q)
        }

        qubit_properties = []
        for qi in range(0, configuration.num_qubits):
            # TODO faulty qubit handling might be needed since
            #  faulty qubit reporting qubit properties doesn't make sense.
            try:
                prop_dict = properties.qubit_property(qubit=qi)
            except KeyError:
                continue
            qubit_properties.append(
                QubitProperties(
                    t1=prop_dict.get("T1", (None, None))[0],
                    t2=prop_dict.get("T2", (None, None))[0],
                    frequency=prop_dict.get("frequency", (None, None))[0],
                )
            )
        in_data["qubit_properties"] = qubit_properties

        for name in all_instructions:
            try:
                for qubits, params in properties.gate_property(name).items():
                    if filter_faulty and (
                        set.intersection(faulty_qubits, qubits)
                        or not properties.is_gate_operational(name, qubits)
                    ):
                        try:
                            # Qubits might be pre-defined by the gate config
                            # However properties objects says the qubits is non-operational
                            del prop_name_map[name][qubits]
                        except KeyError:
                            pass
                        faulty_ops.add((name, qubits))
                        continue
                    if prop_name_map[name] is None:
                        # This instruction is tied to particular qubits
                        # i.e. gate config is not provided, and instruction has been globally defined.
                        prop_name_map[name] = {}
                    prop_name_map[name][qubits] = InstructionProperties(
                        error=_get_value(params, "gate_error"),
                        duration=_get_value(params, "gate_length"),
                    )
                if isinstance(prop_name_map[name], dict) and any(
                    v is None for v in prop_name_map[name].values()
                ):
                    # Properties provides gate properties only for subset of qubits
                    # Associated qubit set might be defined by the gate config here
                    logger.info(
                        "Gate properties of instruction %s are not provided for every qubits. "
                        "This gate is ideal for some qubits and the rest is with finite error. "
                        "Created backend target may confuse error-aware circuit optimization.",
                        name,
                    )
            except BackendPropertyError:
                # This gate doesn't report any property
                continue

        # Measure instruction property is stored in qubit property
        prop_name_map["measure"] = {}

        for qubit_idx in range(configuration.num_qubits):
            if filter_faulty and (qubit_idx in faulty_qubits):
                continue
            qubit_prop = properties.qubit_property(qubit_idx)
            prop_name_map["measure"][(qubit_idx,)] = InstructionProperties(
                error=_get_value(qubit_prop, "readout_error"),
                duration=_get_value(qubit_prop, "readout_length"),
            )

    for op in required:
        # Map required ops to each operational qubit
        if prop_name_map[op] is None:
            prop_name_map[op] = {
                (q,): None
                for q in range(configuration.num_qubits)
                if not filter_faulty or (q not in faulty_qubits)
            }

    if defaults:
        inst_sched_map = defaults.instruction_schedule_map

        for name in inst_sched_map.instructions:
            for qubits in inst_sched_map.qubits_with_instruction(name):

                if not isinstance(qubits, tuple):
                    qubits = (qubits,)

                if (
                    name not in all_instructions
                    or name not in prop_name_map
                    or prop_name_map[name] is None
                    or qubits not in prop_name_map[name]
                ):
                    logger.info(
                        "Gate calibration for instruction %s on qubits %s is found "
                        "in the PulseDefaults payload. However, this entry is not defined in "
                        "the gate mapping of Target. This calibration is ignored.",
                        name,
                        qubits,
                    )
                    continue

                if (name, qubits) in faulty_ops:
                    continue

                entry = inst_sched_map._get_calibration_entry(name, qubits)

                try:
                    prop_name_map[name][qubits].calibration = entry
                except AttributeError:
                    logger.info(
                        "The PulseDefaults payload received contains an instruction %s on "
                        "qubits %s which is not present in the configuration or properties payload.",
                        name,
                        qubits,
                    )

    # Add parsed properties to target
    target = Target(**in_data)
    for inst_name in all_instructions:
        if inst_name == "delay" and not add_delay:
            continue
        if inst_name in qiskit_control_flow_mapping:
            # Control flow operator doesn't have gate property.
            target.add_instruction(
                instruction=qiskit_control_flow_mapping[inst_name],
                name=inst_name,
            )
        else:
            target.add_instruction(
                instruction=inst_name_map[inst_name],
                properties=prop_name_map.get(inst_name, None),
                name=inst_name,
            )

    return target


def qubit_props_list_from_props(
    properties: BackendProperties,
) -> List[QubitProperties]:
    """Uses BackendProperties to construct
    and return a list of QubitProperties.
    """
    qubit_props: List[QubitProperties] = []
    for qubit, _ in enumerate(properties.qubits):
        try:
            t_1 = properties.t1(qubit)
        except BackendPropertyError:
            t_1 = None
        try:
            t_2 = properties.t2(qubit)
        except BackendPropertyError:
            t_2 = None
        try:
            frequency = properties.frequency(qubit)
        except BackendPropertyError:
            frequency = None
        qubit_props.append(
            QubitProperties(  # type: ignore[no-untyped-call]
                t1=t_1,
                t2=t_2,
                frequency=frequency,
            )
        )
    return qubit_props


class BackendV2Converter(BackendV2):
    """A converter class that takes a :class:`~.BackendV1` instance and wraps it in a
    :class:`~.BackendV2` interface.

    This class implements the :class:`~.BackendV2` interface and is used to enable
    common access patterns between :class:`~.BackendV1` and :class:`~.BackendV2`. This
    class should only be used if you need a :class:`~.BackendV2` and still need
    compatibility with :class:`~.BackendV1`.

    When using custom calibrations (or other custom workflows) it is **not** recommended
    to mutate the ``BackendV1`` object before applying this converter. For example, in order to
    convert a ``BackendV1`` object with a customized ``defaults().instruction_schedule_map``,
    which has a custom calibration for an operation, the operation name must be in
    ``configuration().basis_gates`` and ``name_mapping`` must be supplied for the operation.
    Otherwise, the operation will be dropped in the resulting ``BackendV2`` object.

    Instead it is typically better to add custom calibrations **after** applying this converter
    instead of updating ``BackendV1.defaults()`` in advance. For example::

        backend_v2 = BackendV2Converter(backend_v1)
        backend_v2.target.add_instruction(
            custom_gate, {(0, 1): InstructionProperties(calibration=custom_sched)}
        )
    """

    def __init__(
        self,
        backend: BackendV1,
        name_mapping: Optional[Dict[str, Any]] = None,
        add_delay: bool = True,
        filter_faulty: bool = True,
    ):
        """Initialize a BackendV2 converter instance based on a BackendV1 instance.

        Args:
            backend: The input :class:`~.BackendV1` based backend to wrap in a
                :class:`~.BackendV2` interface
            name_mapping: An optional dictionary that maps custom gate/operation names in
                ``backend`` to an :class:`~.Operation` object representing that
                gate/operation. By default most standard gates names are mapped to the
                standard gate object from :mod:`qiskit.circuit.library` this only needs
                to be specified if the input ``backend`` defines gates in names outside
                that set.
            add_delay: If set to true a :class:`~qiskit.circuit.Delay` operation
                will be added to the target as a supported operation for all
                qubits
            filter_faulty: If the :class:`~.BackendProperties` object (if present) for
                ``backend`` has any qubits or gates flagged as non-operational filter
                those from the output target.
        """
        self._backend = backend
        self._config = self._backend.configuration()
        super().__init__(
            provider=backend.provider,
            name=backend.name(),
            description=self._config.description,
            online_date=getattr(self._config, "online_date", None),
            backend_version=self._config.backend_version,
        )
        self._options = self._backend._options
        self._properties = None
        self._defaults = None

        if hasattr(self._backend, "properties"):
            self._properties = self._backend.properties()
        if hasattr(self._backend, "defaults"):
            self._defaults = self._backend.defaults()

        self._target = None
        self._name_mapping = name_mapping
        self._add_delay = add_delay
        self._filter_faulty = filter_faulty

    @property
    def target(self):
        """A :class:`qiskit.transpiler.Target` object for the backend.

        :rtype: Target
        """
        if self._target is None:
            self._target = convert_to_target(
                configuration=self._config,
                properties=self._properties,
                defaults=self._defaults,
                custom_name_mapping=self._name_mapping,
                add_delay=self._add_delay,
                filter_faulty=self._filter_faulty,
            )
        return self._target

    @property
    def max_circuits(self):
        return self._config.max_experiments

    @classmethod
    def _default_options(cls):
        return Options()

    @property
    def dtm(self) -> float:
        return self._config.dtm

    @property
    def meas_map(self) -> List[List[int]]:
        return self._config.meas_map

    def drive_channel(self, qubit: int):
        return self._config.drive(qubit)

    def measure_channel(self, qubit: int):
        return self._config.measure(qubit)

    def acquire_channel(self, qubit: int):
        return self._config.acquire(qubit)

    def control_channel(self, qubits: Iterable[int]):
        return self._config.control(qubits)

    def run(self, run_input, **options):
        return self._backend.run(run_input, **options)

1	# This code is part of Qiskit.
2	#
3	# (C) Copyright IBM 2020.
4	#
5	# This code is licensed under the Apache License, Version 2.0. You may
6	# obtain a copy of this license in the LICENSE.txt file in the root directory
7	# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
8	#
9	# Any modifications or derivative works of this code must retain this
10	# copyright notice, and modified files need to carry a notice indicating
11	# that they have been altered from the originals.
12
13	"""Backend abstract interface for providers."""	1✔
14
15	from __future__ import annotations	1✔
16	import logging	1✔
17	import warnings	1✔
18	from typing import List, Iterable, Any, Dict, Optional	1✔
19
20	from qiskit.providers.backend import BackendV1, BackendV2	1✔
21	from qiskit.providers.backend import QubitProperties	1✔
22	from qiskit.providers.models.backendconfiguration import BackendConfiguration	1✔
23	from qiskit.providers.models.backendproperties import BackendProperties	1✔
24	from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES	1✔
25	from qiskit.providers.models.pulsedefaults import PulseDefaults	1✔
26	from qiskit.providers.options import Options	1✔
27	from qiskit.providers.exceptions import BackendPropertyError	1✔
28
29	logger = logging.getLogger(__name__)	1✔
30
31
32	def convert_to_target(	1✔
33	configuration: BackendConfiguration,
34	properties: BackendProperties = None,
35	defaults: PulseDefaults = None,
36	custom_name_mapping: Optional[Dict[str, Any]] = None,
37	add_delay: bool = True,
38	filter_faulty: bool = True,
39	):
40	"""Decode transpiler target from backend data set.
41
42	This function generates :class:`.Target`` instance from intermediate
43	legacy objects such as :class:`.BackendProperties` and :class:`.PulseDefaults`.
44	These objects are usually components of the legacy :class:`.BackendV1` model.
45
46	Args:
47	configuration: Backend configuration as ``BackendConfiguration``
48	properties: Backend property dictionary or ``BackendProperties``
49	defaults: Backend pulse defaults dictionary or ``PulseDefaults``
50	custom_name_mapping: A name mapping must be supplied for the operation
51	not included in Qiskit Standard Gate name mapping, otherwise the operation
52	will be dropped in the resulting ``Target`` object.
53	add_delay: If True, adds delay to the instruction set.
54	filter_faulty: If True, this filters the non-operational qubits.
55
56	Returns:
57	A ``Target`` instance.
58	"""
59
60	# importing pacakges where they are needed, to avoid cyclic-import.
61	# pylint: disable=cyclic-import
62	from qiskit.transpiler.target import (	1✔
63	Target,
64	InstructionProperties,
65	)
66	from qiskit.circuit.controlflow import ForLoopOp, IfElseOp, SwitchCaseOp, WhileLoopOp	1✔
67	from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping	1✔
68	from qiskit.circuit.parameter import Parameter	1✔
69	from qiskit.circuit.gate import Gate	1✔
70
71	required = ["measure", "delay"]	1✔
72
73	# Load Qiskit object representation
74	qiskit_inst_mapping = get_standard_gate_name_mapping()	1✔
75	if custom_name_mapping:	1✔
76	qiskit_inst_mapping.update(custom_name_mapping)	1✔
77
78	qiskit_control_flow_mapping = {	1✔
79	"if_else": IfElseOp,
80	"while_loop": WhileLoopOp,
81	"for_loop": ForLoopOp,
82	"switch_case": SwitchCaseOp,
83	}
84
85	in_data = {"num_qubits": configuration.n_qubits}	1✔
86
87	# Parse global configuration properties
88	if hasattr(configuration, "dt"):	1✔
89	in_data["dt"] = configuration.dt	1✔
90	if hasattr(configuration, "timing_constraints"):	1✔
91	in_data.update(configuration.timing_constraints)	1✔
92
93	# Create instruction property placeholder from backend configuration
94	basis_gates = set(getattr(configuration, "basis_gates", []))	1✔
95	supported_instructions = set(getattr(configuration, "supported_instructions", []))	1✔
96	gate_configs = {gate.name: gate for gate in configuration.gates}	1✔
97	all_instructions = set.union(	1✔
98	basis_gates, set(required), supported_instructions.intersection(CONTROL_FLOW_OP_NAMES)
99	)
100
101	inst_name_map = {} # type: Dict[str, Instruction]	1✔
102
103	faulty_ops = set()	1✔
104	faulty_qubits = set()	1✔
105	unsupported_instructions = []	1✔
106
107	# Create name to Qiskit instruction object repr mapping
108	for name in all_instructions:	1✔
109	if name in qiskit_control_flow_mapping:	1✔
110	continue	1✔
111	if name in qiskit_inst_mapping:	1✔
112	inst_name_map[name] = qiskit_inst_mapping[name]	1✔
113	elif name in gate_configs:	×
114	# GateConfig model is a translator of QASM opcode.
115	# This doesn't have quantum definition, so Qiskit transpiler doesn't perform
116	# any optimization in quantum domain.
117	# Usually GateConfig counterpart should exist in Qiskit namespace so this is rarely called.
118	this_config = gate_configs[name]	×
119	params = list(map(Parameter, getattr(this_config, "parameters", [])))	×
120	coupling_map = getattr(this_config, "coupling_map", [])	×
121	inst_name_map[name] = Gate(	×
122	name=name,
123	num_qubits=len(coupling_map[0]) if coupling_map else 0,
124	params=params,
125	)
126	else:
127	warnings.warn(	×
128	f"No gate definition for {name} can be found and is being excluded "
129	"from the generated target. You can use `custom_name_mapping` to provide "
130	"a definition for this operation.",
131	RuntimeWarning,
132	)
133	unsupported_instructions.append(name)	×
134
135	for name in unsupported_instructions:	1✔
136	all_instructions.remove(name)	×
137
138	# Create inst properties placeholder
139	# Without any assignment, properties value is None,
140	# which defines a global instruction that can be applied to any qubit(s).
141	# The None value behaves differently from an empty dictionary.
142	# See API doc of Target.add_instruction for details.
143	prop_name_map = dict.fromkeys(all_instructions)	1✔
144	for name in all_instructions:	1✔
145	if name in gate_configs:	1✔
146	if coupling_map := getattr(gate_configs[name], "coupling_map", None):	1✔
147	# Respect operational qubits that gate configuration defines
148	# This ties instruction to particular qubits even without properties information.
149	# Note that each instruction is considered to be ideal unless
150	# its spec (e.g. error, duration) is bound by the properties object.
151	prop_name_map[name] = dict.fromkeys(map(tuple, coupling_map))	1✔
152
153	# Populate instruction properties
154	if properties:	1✔
155
156	def _get_value(prop_dict, prop_name):	1✔
157	if ndval := prop_dict.get(prop_name, None):	1✔
158	return ndval[0]	1✔
159	return None	1✔
160
161	# is_qubit_operational is a bit of expensive operation so precache the value
162	faulty_qubits = {	1✔
163	q for q in range(configuration.num_qubits) if not properties.is_qubit_operational(q)
164	}
165
166	qubit_properties = []	1✔
167	for qi in range(0, configuration.num_qubits):	1✔
168	# TODO faulty qubit handling might be needed since
169	# faulty qubit reporting qubit properties doesn't make sense.
170	try:	1✔
171	prop_dict = properties.qubit_property(qubit=qi)	1✔
NEW 172	except KeyError:	×
NEW 173	continue	×
174	qubit_properties.append(	1✔
175	QubitProperties(
176	t1=prop_dict.get("T1", (None, None))[0],
177	t2=prop_dict.get("T2", (None, None))[0],
178	frequency=prop_dict.get("frequency", (None, None))[0],
179	)
180	)
181	in_data["qubit_properties"] = qubit_properties	1✔
182
183	for name in all_instructions:	1✔
184	try:	1✔
185	for qubits, params in properties.gate_property(name).items():	1✔
186	if filter_faulty and (	1✔
187	set.intersection(faulty_qubits, qubits)
188	or not properties.is_gate_operational(name, qubits)
189	):
190	try:	1✔
191	# Qubits might be pre-defined by the gate config
192	# However properties objects says the qubits is non-operational
193	del prop_name_map[name][qubits]	1✔
194	except KeyError:	1✔
195	pass	1✔
196	faulty_ops.add((name, qubits))	1✔
197	continue	1✔
198	if prop_name_map[name] is None:	1✔
199	# This instruction is tied to particular qubits
200	# i.e. gate config is not provided, and instruction has been globally defined.
201	prop_name_map[name] = {}	1✔
202	prop_name_map[name][qubits] = InstructionProperties(	1✔
203	error=_get_value(params, "gate_error"),
204	duration=_get_value(params, "gate_length"),
205	)
206	if isinstance(prop_name_map[name], dict) and any(	1✔
207	v is None for v in prop_name_map[name].values()
208	):
209	# Properties provides gate properties only for subset of qubits
210	# Associated qubit set might be defined by the gate config here
211	logger.info(	×
212	"Gate properties of instruction %s are not provided for every qubits. "
213	"This gate is ideal for some qubits and the rest is with finite error. "
214	"Created backend target may confuse error-aware circuit optimization.",
215	name,
216	)
217	except BackendPropertyError:	1✔
218	# This gate doesn't report any property
219	continue	1✔
220
221	# Measure instruction property is stored in qubit property
222	prop_name_map["measure"] = {}	1✔
223
224	for qubit_idx in range(configuration.num_qubits):	1✔
225	if filter_faulty and (qubit_idx in faulty_qubits):	1✔
226	continue	1✔
227	qubit_prop = properties.qubit_property(qubit_idx)	1✔
228	prop_name_map["measure"][(qubit_idx,)] = InstructionProperties(	1✔
229	error=_get_value(qubit_prop, "readout_error"),
230	duration=_get_value(qubit_prop, "readout_length"),
231	)
232
233	for op in required:	1✔
234	# Map required ops to each operational qubit
235	if prop_name_map[op] is None:	1✔
236	prop_name_map[op] = {	1✔
237	(q,): None
238	for q in range(configuration.num_qubits)
239	if not filter_faulty or (q not in faulty_qubits)
240	}
241
242	if defaults:	1✔
243	inst_sched_map = defaults.instruction_schedule_map	1✔
244
245	for name in inst_sched_map.instructions:	1✔
246	for qubits in inst_sched_map.qubits_with_instruction(name):	1✔
247
248	if not isinstance(qubits, tuple):	1✔
249	qubits = (qubits,)	1✔
250
251	if (	1✔
252	name not in all_instructions
253	or name not in prop_name_map
254	or prop_name_map[name] is None
255	or qubits not in prop_name_map[name]
256	):
257	logger.info(	1✔
258	"Gate calibration for instruction %s on qubits %s is found "
259	"in the PulseDefaults payload. However, this entry is not defined in "
260	"the gate mapping of Target. This calibration is ignored.",
261	name,
262	qubits,
263	)
264	continue	1✔
265
266	if (name, qubits) in faulty_ops:	1✔
267	continue	×
268
269	entry = inst_sched_map._get_calibration_entry(name, qubits)	1✔
270
271	try:	1✔
272	prop_name_map[name][qubits].calibration = entry	1✔
273	except AttributeError:	×
274	logger.info(	×
275	"The PulseDefaults payload received contains an instruction %s on "
276	"qubits %s which is not present in the configuration or properties payload.",
277	name,
278	qubits,
279	)
280
281	# Add parsed properties to target
282	target = Target(**in_data)	1✔
283	for inst_name in all_instructions:	1✔
284	if inst_name == "delay" and not add_delay:	1✔
285	continue	1✔
286	if inst_name in qiskit_control_flow_mapping:	1✔
287	# Control flow operator doesn't have gate property.
288	target.add_instruction(	1✔
289	instruction=qiskit_control_flow_mapping[inst_name],
290	name=inst_name,
291	)
292	else:
293	target.add_instruction(	1✔
294	instruction=inst_name_map[inst_name],
295	properties=prop_name_map.get(inst_name, None),
296	name=inst_name,
297	)
298
299	return target	1✔
300
301
302	def qubit_props_list_from_props(	1✔
303	properties: BackendProperties,
304	) -> List[QubitProperties]:
305	"""Uses BackendProperties to construct
306	and return a list of QubitProperties.
307	"""
308	qubit_props: List[QubitProperties] = []	1✔
309	for qubit, _ in enumerate(properties.qubits):	1✔
310	try:	1✔
311	t_1 = properties.t1(qubit)	1✔
312	except BackendPropertyError:	×
313	t_1 = None	×
314	try:	1✔
315	t_2 = properties.t2(qubit)	1✔
316	except BackendPropertyError:	×
317	t_2 = None	×
318	try:	1✔
319	frequency = properties.frequency(qubit)	1✔
320	except BackendPropertyError:	×
321	frequency = None	×
322	qubit_props.append(	1✔
323	QubitProperties( # type: ignore[no-untyped-call]
324	t1=t_1,
325	t2=t_2,
326	frequency=frequency,
327	)
328	)
329	return qubit_props	1✔
330
331
332	class BackendV2Converter(BackendV2):	1✔
333	"""A converter class that takes a :class:`~.BackendV1` instance and wraps it in a	1✔
334	:class:`~.BackendV2` interface.
335
336	This class implements the :class:`~.BackendV2` interface and is used to enable
337	common access patterns between :class:`~.BackendV1` and :class:`~.BackendV2`. This
338	class should only be used if you need a :class:`~.BackendV2` and still need
339	compatibility with :class:`~.BackendV1`.
340
341	When using custom calibrations (or other custom workflows) it is not recommended
342	to mutate the ``BackendV1`` object before applying this converter. For example, in order to
343	convert a ``BackendV1`` object with a customized ``defaults().instruction_schedule_map``,
344	which has a custom calibration for an operation, the operation name must be in
345	``configuration().basis_gates`` and ``name_mapping`` must be supplied for the operation.
346	Otherwise, the operation will be dropped in the resulting ``BackendV2`` object.
347
348	Instead it is typically better to add custom calibrations after applying this converter
349	instead of updating ``BackendV1.defaults()`` in advance. For example::
350
351	backend_v2 = BackendV2Converter(backend_v1)
352	backend_v2.target.add_instruction(
353	custom_gate, {(0, 1): InstructionProperties(calibration=custom_sched)}
354	)
355	"""
356
357	def __init__(	1✔
358	self,
359	backend: BackendV1,
360	name_mapping: Optional[Dict[str, Any]] = None,
361	add_delay: bool = True,
362	filter_faulty: bool = True,
363	):
364	"""Initialize a BackendV2 converter instance based on a BackendV1 instance.
365
366	Args:
367	backend: The input :class:`~.BackendV1` based backend to wrap in a
368	:class:`~.BackendV2` interface
369	name_mapping: An optional dictionary that maps custom gate/operation names in
370	``backend`` to an :class:`~.Operation` object representing that
371	gate/operation. By default most standard gates names are mapped to the
372	standard gate object from :mod:`qiskit.circuit.library` this only needs
373	to be specified if the input ``backend`` defines gates in names outside
374	that set.
375	add_delay: If set to true a :class:`~qiskit.circuit.Delay` operation
376	will be added to the target as a supported operation for all
377	qubits
378	filter_faulty: If the :class:`~.BackendProperties` object (if present) for
379	``backend`` has any qubits or gates flagged as non-operational filter
380	those from the output target.
381	"""
382	self._backend = backend	1✔
383	self._config = self._backend.configuration()	1✔
384	super().__init__(	1✔
385	provider=backend.provider,
386	name=backend.name(),
387	description=self._config.description,
388	online_date=getattr(self._config, "online_date", None),
389	backend_version=self._config.backend_version,
390	)
391	self._options = self._backend._options	1✔
392	self._properties = None	1✔
393	self._defaults = None	1✔
394
395	if hasattr(self._backend, "properties"):	1✔
396	self._properties = self._backend.properties()	1✔
397	if hasattr(self._backend, "defaults"):	1✔
398	self._defaults = self._backend.defaults()	1✔
399
400	self._target = None	1✔
401	self._name_mapping = name_mapping	1✔
402	self._add_delay = add_delay	1✔
403	self._filter_faulty = filter_faulty	1✔
404
405	@property	1✔
406	def target(self):	1✔
407	"""A :class:`qiskit.transpiler.Target` object for the backend.
408
409	:rtype: Target
410	"""
411	if self._target is None:	1✔
412	self._target = convert_to_target(	1✔
413	configuration=self._config,
414	properties=self._properties,
415	defaults=self._defaults,
416	custom_name_mapping=self._name_mapping,
417	add_delay=self._add_delay,
418	filter_faulty=self._filter_faulty,
419	)
420	return self._target	1✔
421
422	@property	1✔
423	def max_circuits(self):	1✔
424	return self._config.max_experiments	1✔
425
426	@classmethod	1✔
427	def _default_options(cls):	1✔
428	return Options()	1✔
429
430	@property	1✔
431	def dtm(self) -> float:	1✔
432	return self._config.dtm	×
433
434	@property	1✔
435	def meas_map(self) -> List[List[int]]:	1✔
436	return self._config.meas_map	×
437
438	def drive_channel(self, qubit: int):	1✔
439	return self._config.drive(qubit)	×
440
441	def measure_channel(self, qubit: int):	1✔
442	return self._config.measure(qubit)	×
443
444	def acquire_channel(self, qubit: int):	1✔
445	return self._config.acquire(qubit)	×
446
447	def control_channel(self, qubits: Iterable[int]):	1✔
448	return self._config.control(qubits)	×
449
450	def run(self, run_input, **options):	1✔
451	return self._backend.run(run_input, **options)	1✔

Qiskit / qiskit / 8110771392

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous