9600507623

Committed 20 Jun 2024 02:58PM UTC coverage: 87.198% (-0.01%) from 87.208%

Build # 9600507623

Build Type

push

github

Committed by

web-flow

Commit Message

Fix v2 pulse drawer  (#12608) (#12613)

* fix error when V2 model is set

* Apply suggestions from code review

* Fix black

---------

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
Co-authored-by: Elena Peña Tapia <epenatap@gmail.com>
(cherry picked from commit 7d1731b60)

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

Run Details

1 of 36 new or added lines in 1 file covered. (2.78%)

6 existing lines in 2 files now uncovered.

74508 of 85447 relevant lines covered (87.2%)

101703.69 hits per line

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

39.71

/qiskit/visualization/pulse_v2/device_info.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.

"""A collection of backend information formatted to generate drawing data.

This instance will be provided to generator functions. The module provides an abstract
class :py:class:``DrawerBackendInfo`` with necessary methods to generate drawing objects.

Because the data structure of backend class may depend on providers, this abstract class
has an abstract factory method `create_from_backend`. Each subclass should provide
the factory method which conforms to the associated provider. By default we provide
:py:class:``OpenPulseBackendInfo`` class that has the factory method taking backends
satisfying OpenPulse specification [1].

This class can be also initialized without the factory method by manually specifying
required information. This may be convenient for visualizing a pulse program for simulator
backend that only has a device Hamiltonian information. This requires two mapping objects
for channel/qubit and channel/frequency along with the system cycle time.

If those information are not provided, this class will be initialized with a set of
empty data and the drawer illustrates a pulse program without any specific information.

Reference:
- [1] Qiskit Backend Specifications for OpenQASM and OpenPulse Experiments,
    https://arxiv.org/abs/1809.03452
"""

from abc import ABC, abstractmethod
from collections import defaultdict
from typing import Dict, List, Union, Optional

from qiskit import pulse
from qiskit.providers import BackendConfigurationError
from qiskit.providers.backend import Backend, BackendV2


class DrawerBackendInfo(ABC):
    """Backend information to be used for the drawing data generation."""

    def __init__(
        self,
        name: Optional[str] = None,
        dt: Optional[float] = None,
        channel_frequency_map: Optional[Dict[pulse.channels.Channel, float]] = None,
        qubit_channel_map: Optional[Dict[int, List[pulse.channels.Channel]]] = None,
    ):
        """Create new backend information.

        Args:
            name: Name of the backend.
            dt: System cycle time.
            channel_frequency_map: Mapping of channel and associated frequency.
            qubit_channel_map: Mapping of qubit and associated channels.
        """
        self.backend_name = name or "no-backend"
        self._dt = dt
        self._chan_freq_map = channel_frequency_map or {}
        self._qubit_channel_map = qubit_channel_map or {}

    @classmethod
    @abstractmethod
    def create_from_backend(cls, backend: Backend):
        """Initialize a class with backend information provided by provider.

        Args:
            backend: Backend object.
        """
        raise NotImplementedError

    @property
    def dt(self):
        """Return cycle time."""
        return self._dt

    def get_qubit_index(self, chan: pulse.channels.Channel) -> Union[int, None]:
        """Get associated qubit index of given channel object."""
        for qind, chans in self._qubit_channel_map.items():
            if chan in chans:
                return qind
        return chan.index

    def get_channel_frequency(self, chan: pulse.channels.Channel) -> Union[float, None]:
        """Get frequency of given channel object."""
        return self._chan_freq_map.get(chan, None)


class OpenPulseBackendInfo(DrawerBackendInfo):
    """Drawing information of backend that conforms to OpenPulse specification."""

    @classmethod
    def create_from_backend(cls, backend: Backend):
        """Initialize a class with backend information provided by provider.

        Args:
            backend: Backend object.

        Returns:
            OpenPulseBackendInfo: New configured instance.
        """
        chan_freqs = {}
        qubit_channel_map = defaultdict(list)

        if hasattr(backend, "configuration") and hasattr(backend, "defaults"):
            configuration = backend.configuration()
            defaults = backend.defaults()

            name = configuration.backend_name
            dt = configuration.dt

            # load frequencies
            chan_freqs.update(
                {
                    pulse.DriveChannel(qind): freq
                    for qind, freq in enumerate(defaults.qubit_freq_est)
                }
            )
            chan_freqs.update(
                {
                    pulse.MeasureChannel(qind): freq
                    for qind, freq in enumerate(defaults.meas_freq_est)
                }
            )
            for qind, u_lo_mappers in enumerate(configuration.u_channel_lo):
                temp_val = 0.0 + 0.0j
                for u_lo_mapper in u_lo_mappers:
                    temp_val += defaults.qubit_freq_est[u_lo_mapper.q] * u_lo_mapper.scale
                chan_freqs[pulse.ControlChannel(qind)] = temp_val.real

            # load qubit channel mapping
            for qind in range(configuration.n_qubits):
                qubit_channel_map[qind].append(configuration.drive(qubit=qind))
                qubit_channel_map[qind].append(configuration.measure(qubit=qind))
                for tind in range(configuration.n_qubits):
                    try:
                        qubit_channel_map[qind].extend(configuration.control(qubits=(qind, tind)))
                    except BackendConfigurationError:
                        pass
        elif isinstance(backend, BackendV2):
            # Pure V2 model doesn't contain channel frequency information.
            name = backend.name
            dt = backend.dt

            # load qubit channel mapping
            for qind in range(backend.num_qubits):
                # channels are NotImplemented by default so we must catch arbitrary error.
                try:
                    qubit_channel_map[qind].append(backend.drive_channel(qind))
                except Exception:  # pylint: disable=broad-except
                    pass
                try:
                    qubit_channel_map[qind].append(backend.measure_channel(qind))
                except Exception:  # pylint: disable=broad-except
                    pass
                for tind in range(backend.num_qubits):
                    try:
                        qubit_channel_map[qind].extend(backend.control_channel(qubits=(qind, tind)))
                    except Exception:  # pylint: disable=broad-except
                        pass
        else:
            raise RuntimeError("Backend object not yet supported")

        return OpenPulseBackendInfo(
            name=name, dt=dt, channel_frequency_map=chan_freqs, qubit_channel_map=qubit_channel_map
        )

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	"""A collection of backend information formatted to generate drawing data.	1✔
14
15	This instance will be provided to generator functions. The module provides an abstract
16	class :py:class:``DrawerBackendInfo`` with necessary methods to generate drawing objects.
17
18	Because the data structure of backend class may depend on providers, this abstract class
19	has an abstract factory method `create_from_backend`. Each subclass should provide
20	the factory method which conforms to the associated provider. By default we provide
21	:py:class:``OpenPulseBackendInfo`` class that has the factory method taking backends
22	satisfying OpenPulse specification [1].
23
24	This class can be also initialized without the factory method by manually specifying
25	required information. This may be convenient for visualizing a pulse program for simulator
26	backend that only has a device Hamiltonian information. This requires two mapping objects
27	for channel/qubit and channel/frequency along with the system cycle time.
28
29	If those information are not provided, this class will be initialized with a set of
30	empty data and the drawer illustrates a pulse program without any specific information.
31
32	Reference:
33	- [1] Qiskit Backend Specifications for OpenQASM and OpenPulse Experiments,
34	https://arxiv.org/abs/1809.03452
35	"""
36
37	from abc import ABC, abstractmethod	1✔
38	from collections import defaultdict	1✔
39	from typing import Dict, List, Union, Optional	1✔
40
41	from qiskit import pulse	1✔
42	from qiskit.providers import BackendConfigurationError	1✔
43	from qiskit.providers.backend import Backend, BackendV2	1✔
44
45
46	class DrawerBackendInfo(ABC):	1✔
47	"""Backend information to be used for the drawing data generation."""	1✔
48
49	def __init__(	1✔
50	self,
51	name: Optional[str] = None,
52	dt: Optional[float] = None,
53	channel_frequency_map: Optional[Dict[pulse.channels.Channel, float]] = None,
54	qubit_channel_map: Optional[Dict[int, List[pulse.channels.Channel]]] = None,
55	):
56	"""Create new backend information.
57
58	Args:
59	name: Name of the backend.
60	dt: System cycle time.
61	channel_frequency_map: Mapping of channel and associated frequency.
62	qubit_channel_map: Mapping of qubit and associated channels.
63	"""
64	self.backend_name = name or "no-backend"	1✔
65	self._dt = dt	1✔
66	self._chan_freq_map = channel_frequency_map or {}	1✔
67	self._qubit_channel_map = qubit_channel_map or {}	1✔
68
69	@classmethod
70	@abstractmethod
71	def create_from_backend(cls, backend: Backend):
72	"""Initialize a class with backend information provided by provider.
73
74	Args:
75	backend: Backend object.
76	"""
77	raise NotImplementedError
78
79	@property	1✔
80	def dt(self):	1✔
81	"""Return cycle time."""
82	return self._dt	1✔
83
84	def get_qubit_index(self, chan: pulse.channels.Channel) -> Union[int, None]:	1✔
85	"""Get associated qubit index of given channel object."""
86	for qind, chans in self._qubit_channel_map.items():	1✔
87	if chan in chans:	1✔
88	return qind	1✔
89	return chan.index	×
90
91	def get_channel_frequency(self, chan: pulse.channels.Channel) -> Union[float, None]:	1✔
92	"""Get frequency of given channel object."""
93	return self._chan_freq_map.get(chan, None)	1✔
94
95
96	class OpenPulseBackendInfo(DrawerBackendInfo):	1✔
97	"""Drawing information of backend that conforms to OpenPulse specification."""	1✔
98
99	@classmethod	1✔
100	def create_from_backend(cls, backend: Backend):	1✔
101	"""Initialize a class with backend information provided by provider.
102
103	Args:
104	backend: Backend object.
105
106	Returns:
107	OpenPulseBackendInfo: New configured instance.
108	"""
109	chan_freqs = {}	×
110	qubit_channel_map = defaultdict(list)	×
111
NEW 112	if hasattr(backend, "configuration") and hasattr(backend, "defaults"):	×
NEW 113	configuration = backend.configuration()	×
NEW 114	defaults = backend.defaults()	×
115
NEW 116	name = configuration.backend_name	×
NEW 117	dt = configuration.dt	×
118
119	# load frequencies
NEW 120	chan_freqs.update(	×
121	{
122	pulse.DriveChannel(qind): freq
123	for qind, freq in enumerate(defaults.qubit_freq_est)
124	}
125	)
NEW 126	chan_freqs.update(	×
127	{
128	pulse.MeasureChannel(qind): freq
129	for qind, freq in enumerate(defaults.meas_freq_est)
130	}
131	)
NEW 132	for qind, u_lo_mappers in enumerate(configuration.u_channel_lo):	×
NEW 133	temp_val = 0.0 + 0.0j	×
NEW 134	for u_lo_mapper in u_lo_mappers:	×
NEW 135	temp_val += defaults.qubit_freq_est[u_lo_mapper.q] * u_lo_mapper.scale	×
NEW 136	chan_freqs[pulse.ControlChannel(qind)] = temp_val.real	×
137
138	# load qubit channel mapping
NEW 139	for qind in range(configuration.n_qubits):	×
NEW 140	qubit_channel_map[qind].append(configuration.drive(qubit=qind))	×
NEW 141	qubit_channel_map[qind].append(configuration.measure(qubit=qind))	×
NEW 142	for tind in range(configuration.n_qubits):	×
NEW 143	try:	×
NEW 144	qubit_channel_map[qind].extend(configuration.control(qubits=(qind, tind)))	×
NEW 145	except BackendConfigurationError:	×
NEW 146	pass	×
NEW 147	elif isinstance(backend, BackendV2):	×
148	# Pure V2 model doesn't contain channel frequency information.
NEW 149	name = backend.name	×
NEW 150	dt = backend.dt	×
151
152	# load qubit channel mapping
NEW 153	for qind in range(backend.num_qubits):	×
154	# channels are NotImplemented by default so we must catch arbitrary error.
NEW 155	try:	×
NEW 156	qubit_channel_map[qind].append(backend.drive_channel(qind))	×
NEW 157	except Exception: # pylint: disable=broad-except	×
NEW 158	pass	×
159	try:	×
NEW 160	qubit_channel_map[qind].append(backend.measure_channel(qind))	×
NEW 161	except Exception: # pylint: disable=broad-except	×
UNCOV 162	pass	×
NEW 163	for tind in range(backend.num_qubits):	×
NEW 164	try:	×
NEW 165	qubit_channel_map[qind].extend(backend.control_channel(qubits=(qind, tind)))	×
NEW 166	except Exception: # pylint: disable=broad-except	×
NEW 167	pass	×
168	else:
169	raise RuntimeError("Backend object not yet supported")
170
171	return OpenPulseBackendInfo(	×
172	name=name, dt=dt, channel_frequency_map=chan_freqs, qubit_channel_map=qubit_channel_map
173	)

Qiskit / qiskit / 9600507623

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