7993544242

Committed 21 Feb 2024 06:05PM UTC coverage: 89.268% (-0.02%) from 89.292%

Build # 7993544242

Build Type

push

github

Committed by

web-flow

Commit Message

Deduplicate SliceOrInt (#11844) (#11853)

* Deduplicate SliceOrInt

After doing some post-merge analysis on the impact of #11842 it turns
out the enum being modified in that PR was duplicated in the rust code
unnecessarily. The same enum was already defined in the
euler_one_qubit_decomposer module for it's custom 1 qubit gate sequence
return type. This commit updates the code so it just use the one
defined in the circuit data module that has the fix from #11842 applied
already.

* Move enum to common location

(cherry picked from commit 802ac5133)

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

Run Details

58890 of 65970 relevant lines covered (89.27%)

183047.45 hits per line

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

0.0

/qiskit/visualization/timeline/plotters/matplotlib.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.

# pylint: disable=invalid-name

"""Matplotlib plotter API."""

from typing import Optional, Tuple

import matplotlib
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.collections import PatchCollection
from matplotlib.patches import Rectangle

from qiskit.visualization.exceptions import VisualizationError
from qiskit.visualization.timeline import core, types, drawings
from qiskit.visualization.timeline.plotters.base_plotter import BasePlotter
from qiskit.visualization.utils import matplotlib_close_if_inline


class MplPlotter(BasePlotter):
    """Matplotlib API for pulse drawer.

    This plotter arranges bits along y axis of 2D canvas with vertical offset.
    """

    def __init__(self, canvas: core.DrawerCanvas, axis: Optional[plt.Axes] = None):
        """Create new plotter.

        Args:
            canvas: Configured drawer canvas object. Canvas object should be updated
                with `.update` method before initializing the plotter.
            axis: Matplotlib axis object. When `axis` is provided, the plotter updates
                given axis instead of creating and returning new matplotlib figure.
        """
        super().__init__(canvas=canvas)

        if axis is None:
            fig_height = self.canvas.vmax - self.canvas.vmin
            fig_h = self.canvas.formatter["general.fig_unit_height"] * fig_height
            fig_w = self.canvas.formatter["general.fig_width"]

            self.figure = plt.figure(figsize=(fig_w, fig_h))
            self.ax = self.figure.add_subplot(1, 1, 1)
        else:
            self.figure = axis.figure
            self.ax = axis

        self.initialize_canvas()

    def initialize_canvas(self):
        """Format appearance of matplotlib canvas."""
        self.ax.set_facecolor(self.canvas.formatter["color.background"])

        # axis lines
        self.ax.spines["right"].set_color("none")
        self.ax.spines["left"].set_color("none")
        self.ax.spines["top"].set_color("none")

        # axis labels
        self.ax.set_yticks([])
        axis_config = self.canvas.layout["time_axis_map"](time_window=self.canvas.time_range)

        self.ax.set_xticks(list(axis_config.axis_map.keys()))
        self.ax.set_xticklabels(
            list(axis_config.axis_map.values()),
            fontsize=self.canvas.formatter["text_size.axis_label"],
        )
        self.ax.set_xlabel(
            axis_config.label, fontsize=self.canvas.formatter["text_size.axis_label"]
        )

        # boundary
        self.ax.set_xlim(*self.canvas.time_range)
        self.ax.set_ylim(self.canvas.vmin, self.canvas.vmax)

    def draw(self):
        """Output drawings stored in canvas object."""

        for _, data in self.canvas.collections:
            xvals = np.asarray(data.xvals, dtype=float)
            yvals = np.asarray(data.yvals, dtype=float)
            offsets = [self.canvas.assigned_coordinates[bit] for bit in data.bits]

            if isinstance(data, drawings.BoxData):
                # box data
                if data.data_type in [
                    str(types.BoxType.SCHED_GATE.value),
                    str(types.BoxType.DELAY.value),
                ]:
                    # draw a smoothly rounded rectangle
                    xs, ys1, ys2 = self._time_bucket_outline(xvals, yvals)
                    self.ax.fill_between(
                        x=xs, y1=ys1 + offsets[0], y2=ys2 + offsets[0], **data.styles
                    )

                else:
                    # draw a rectangle
                    x0, x1 = xvals
                    y0, y1 = yvals + offsets[0]

                    rect = Rectangle(xy=(x0, y0), width=x1 - x0, height=y1 - y0)
                    pc = PatchCollection([rect], **data.styles)
                    self.ax.add_collection(pc)

            elif isinstance(data, drawings.LineData):
                # line data
                self.ax.plot(xvals, yvals + offsets[0], **data.styles)

            elif isinstance(data, drawings.TextData):
                # text data
                if data.latex is not None:
                    s = rf"${data.latex}$"
                else:
                    s = data.text

                self.ax.text(x=xvals[0], y=yvals[0] + offsets[0], s=s, **data.styles)

            elif isinstance(data, drawings.GateLinkData):
                # gate link data
                self.ax.plot(xvals.repeat(len(offsets)), offsets, **data.styles)

            else:
                raise VisualizationError(
                    "Data {name} is not supported by {plotter}"
                    "".format(name=data, plotter=self.__class__.__name__)
                )

    def _time_bucket_outline(
        self, xvals: np.ndarray, yvals: np.ndarray
    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
        """Generate outline of time bucket. Edges are smoothly faded.

        Args:
            xvals: Left and right point coordinates.
            yvals: Bottom and top point coordinates.

        Returns:
            Coordinate vectors of time bucket fringe.
        """
        x0, x1 = xvals
        y0, y1 = yvals

        width = x1 - x0
        y_mid = 0.5 * (y0 + y1)

        risefall = int(min(self.canvas.formatter["time_bucket.edge_dt"], max(width / 2 - 2, 0)))
        edge = np.sin(np.pi / 2 * np.arange(0, risefall) / risefall)

        xs = np.concatenate(
            [
                np.arange(x0, x0 + risefall),
                [x0 + risefall, x1 - risefall],
                np.arange(x1 - risefall + 1, x1 + 1),
            ]
        )

        l1 = (y1 - y_mid) * np.concatenate([edge, [1, 1], edge[::-1]])
        l2 = (y0 - y_mid) * np.concatenate([edge, [1, 1], edge[::-1]])

        return xs, l1, l2

    def save_file(self, filename: str):
        """Save image to file.
        Args:
            filename: File path to output image data.
        """
        plt.savefig(filename, bbox_inches="tight", dpi=self.canvas.formatter["general.dpi"])

    def get_image(self, interactive: bool = False) -> matplotlib.pyplot.Figure:
        """Get image data to return.
        Args:
            interactive: When set `True` show the circuit in a new window.
                This depends on the matplotlib backend being used supporting this.
        Returns:
            Matplotlib figure data.
        """
        matplotlib_close_if_inline(self.figure)

        if self.figure and interactive:
            self.figure.show()

        return self.figure

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	# pylint: disable=invalid-name
14
15	"""Matplotlib plotter API."""	×
16
17	from typing import Optional, Tuple	×
18
19	import matplotlib	×
20	import matplotlib.pyplot as plt	×
21	import numpy as np	×
22	from matplotlib.collections import PatchCollection	×
23	from matplotlib.patches import Rectangle	×
24
25	from qiskit.visualization.exceptions import VisualizationError	×
26	from qiskit.visualization.timeline import core, types, drawings	×
27	from qiskit.visualization.timeline.plotters.base_plotter import BasePlotter	×
28	from qiskit.visualization.utils import matplotlib_close_if_inline	×
29
30
31	class MplPlotter(BasePlotter):	×
32	"""Matplotlib API for pulse drawer.
33
34	This plotter arranges bits along y axis of 2D canvas with vertical offset.
35	"""
36
37	def __init__(self, canvas: core.DrawerCanvas, axis: Optional[plt.Axes] = None):	×
38	"""Create new plotter.
39
40	Args:
41	canvas: Configured drawer canvas object. Canvas object should be updated
42	with `.update` method before initializing the plotter.
43	axis: Matplotlib axis object. When `axis` is provided, the plotter updates
44	given axis instead of creating and returning new matplotlib figure.
45	"""
46	super().__init__(canvas=canvas)	×
47
48	if axis is None:	×
49	fig_height = self.canvas.vmax - self.canvas.vmin	×
50	fig_h = self.canvas.formatter["general.fig_unit_height"] * fig_height	×
51	fig_w = self.canvas.formatter["general.fig_width"]	×
52
53	self.figure = plt.figure(figsize=(fig_w, fig_h))	×
54	self.ax = self.figure.add_subplot(1, 1, 1)	×
55	else:
56	self.figure = axis.figure	×
57	self.ax = axis	×
58
59	self.initialize_canvas()	×
60
61	def initialize_canvas(self):	×
62	"""Format appearance of matplotlib canvas."""
63	self.ax.set_facecolor(self.canvas.formatter["color.background"])	×
64
65	# axis lines
66	self.ax.spines["right"].set_color("none")	×
67	self.ax.spines["left"].set_color("none")	×
68	self.ax.spines["top"].set_color("none")	×
69
70	# axis labels
71	self.ax.set_yticks([])	×
72	axis_config = self.canvas.layout["time_axis_map"](time_window=self.canvas.time_range)	×
73
74	self.ax.set_xticks(list(axis_config.axis_map.keys()))	×
75	self.ax.set_xticklabels(	×
76	list(axis_config.axis_map.values()),
77	fontsize=self.canvas.formatter["text_size.axis_label"],
78	)
79	self.ax.set_xlabel(	×
80	axis_config.label, fontsize=self.canvas.formatter["text_size.axis_label"]
81	)
82
83	# boundary
84	self.ax.set_xlim(*self.canvas.time_range)	×
85	self.ax.set_ylim(self.canvas.vmin, self.canvas.vmax)	×
86
87	def draw(self):	×
88	"""Output drawings stored in canvas object."""
89
90	for _, data in self.canvas.collections:	×
91	xvals = np.asarray(data.xvals, dtype=float)	×
92	yvals = np.asarray(data.yvals, dtype=float)	×
93	offsets = [self.canvas.assigned_coordinates[bit] for bit in data.bits]	×
94
95	if isinstance(data, drawings.BoxData):	×
96	# box data
97	if data.data_type in [	×
98	str(types.BoxType.SCHED_GATE.value),
99	str(types.BoxType.DELAY.value),
100	]:
101	# draw a smoothly rounded rectangle
102	xs, ys1, ys2 = self._time_bucket_outline(xvals, yvals)	×
103	self.ax.fill_between(	×
104	x=xs, y1=ys1 + offsets[0], y2=ys2 + offsets[0], **data.styles
105	)
106
107	else:
108	# draw a rectangle
109	x0, x1 = xvals	×
110	y0, y1 = yvals + offsets[0]	×
111
112	rect = Rectangle(xy=(x0, y0), width=x1 - x0, height=y1 - y0)	×
113	pc = PatchCollection([rect], **data.styles)	×
114	self.ax.add_collection(pc)	×
115
116	elif isinstance(data, drawings.LineData):	×
117	# line data
118	self.ax.plot(xvals, yvals + offsets[0], **data.styles)	×
119
120	elif isinstance(data, drawings.TextData):	×
121	# text data
122	if data.latex is not None:	×
123	s = rf"${data.latex}$"	×
124	else:
125	s = data.text	×
126
127	self.ax.text(x=xvals[0], y=yvals[0] + offsets[0], s=s, **data.styles)	×
128
129	elif isinstance(data, drawings.GateLinkData):	×
130	# gate link data
131	self.ax.plot(xvals.repeat(len(offsets)), offsets, **data.styles)	×
132
133	else:
134	raise VisualizationError(	×
135	"Data {name} is not supported by {plotter}"
136	"".format(name=data, plotter=self.__class__.__name__)
137	)
138
139	def _time_bucket_outline(	×
140	self, xvals: np.ndarray, yvals: np.ndarray
141	) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
142	"""Generate outline of time bucket. Edges are smoothly faded.
143
144	Args:
145	xvals: Left and right point coordinates.
146	yvals: Bottom and top point coordinates.
147
148	Returns:
149	Coordinate vectors of time bucket fringe.
150	"""
151	x0, x1 = xvals	×
152	y0, y1 = yvals	×
153
154	width = x1 - x0	×
155	y_mid = 0.5 * (y0 + y1)	×
156
157	risefall = int(min(self.canvas.formatter["time_bucket.edge_dt"], max(width / 2 - 2, 0)))	×
158	edge = np.sin(np.pi / 2 * np.arange(0, risefall) / risefall)	×
159
160	xs = np.concatenate(	×
161	[
162	np.arange(x0, x0 + risefall),
163	[x0 + risefall, x1 - risefall],
164	np.arange(x1 - risefall + 1, x1 + 1),
165	]
166	)
167
168	l1 = (y1 - y_mid) * np.concatenate([edge, [1, 1], edge[::-1]])	×
169	l2 = (y0 - y_mid) * np.concatenate([edge, [1, 1], edge[::-1]])	×
170
171	return xs, l1, l2	×
172
173	def save_file(self, filename: str):	×
174	"""Save image to file.
175	Args:
176	filename: File path to output image data.
177	"""
178	plt.savefig(filename, bbox_inches="tight", dpi=self.canvas.formatter["general.dpi"])	×
179
180	def get_image(self, interactive: bool = False) -> matplotlib.pyplot.Figure:	×
181	"""Get image data to return.
182	Args:
183	interactive: When set `True` show the circuit in a new window.
184	This depends on the matplotlib backend being used supporting this.
185	Returns:
186	Matplotlib figure data.
187	"""
188	matplotlib_close_if_inline(self.figure)	×
189
190	if self.figure and interactive:	×
191	self.figure.show()	×
192
193	return self.figure	×

Qiskit / qiskit / 7993544242

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