def _format_plot(centers: List[complex], ax: Optional["matplotlib.pyplot.AxesSubplot"] = None): """Format the readout_angle plot Args: centers: the two centers of the level 1 measurements for 0 and for 1. ax: matplotlib axis to add plot to. Returns: AxesSubPlot: the matplotlib axes containing the plot. """ largest_extent = (np.max([ np.max(np.abs(np.real(centers))), np.max(np.abs(np.imag(centers))) ]) * 1.1) ax = get_non_gui_ax() ax.plot(np.real(centers[0]), np.imag(centers[0]), "ro", markersize=24) ax.plot(np.real(centers[1]), np.imag(centers[1]), "bo", markersize=24) ax.set_xlim([-largest_extent, largest_extent]) ax.set_ylim([-largest_extent, largest_extent]) ax.set_xlabel("I [arb.]") ax.set_ylabel("Q [arb.]") ax.set_title("Centroid Positions") ax.legend(["0", "1"]) return ax
def _plot_calibration(self, matrix, labels, ax=None) -> "matplotlib.figure.Figure": """ Plot the calibration matrix (2D color grid plot). Args: matrix: calibration matrix to plot ax (matplotlib.axes): settings for the graph Returns: The generated plot of the calibration matrix Raises: QiskitError: if _cal_matrices was not set. ImportError: if matplotlib was not installed. """ if ax is None: ax = get_non_gui_ax() figure = ax.get_figure() ax.matshow(matrix, cmap=plt.cm.binary, clim=[0, 1]) ax.set_xlabel("Prepared State") ax.xaxis.set_label_position("top") ax.set_ylabel("Measured State") ax.set_xticks(np.arange(len(labels))) ax.set_yticks(np.arange(len(labels))) ax.set_xticklabels(labels) ax.set_yticklabels(labels) return figure
def callback1(exp_data): """Callback function that call add_analysis_callback""" exp_data.add_analysis_callback(callback2) result = DbAnalysisResult("result_name", 0, [Qubit(0)], "experiment_id") exp_data.add_analysis_results(result) figure = get_non_gui_ax().get_figure() exp_data.add_figures(figure, "figure.svg") exp_data.add_data({"key": 1.2}) exp_data.data()
def assignment_matrix_visualization(assignment_matrix, ax=None): """Displays a visualization of the assignment matrix compared to the identity""" if ax is None: ax = get_non_gui_ax() figure = ax.get_figure() n = len(assignment_matrix) diff = np.abs(assignment_matrix - np.eye(n)) im2 = ax.matshow(diff, cmap=plt.cm.Reds, vmin=0, vmax=0.2) ax.set_yticks(np.arange(n)) ax.set_xticks(np.arange(n)) ax.set_yticklabels(n * [""]) ax.set_xticklabels(n * [""]) ax.set_xlabel(r"$|A - I|$", fontsize=16) figure.colorbar(im2, ax=ax) return figure
def plot_errorbar( xdata: np.ndarray, ydata: np.ndarray, sigma: Optional[np.ndarray] = None, ax=None, labelsize: int = 14, grid: bool = True, **kwargs, ): """Generate an errorbar plot of xy data. Wraps :func:`matplotlib.pyplot.errorbar` Args: xdata: xdata used for fitting ydata: ydata used for fitting sigma: Optional, standard deviation of ydata ax (matplotlib.axes.Axes): Optional, a matplotlib axes to add the plot to. labelsize: label size for plot grid: Show grid on plot. **kwargs: Additional options for :func:`matplotlib.pyplot.errorbar` Returns: matplotlib.axes.Axes: the matplotlib axes containing the plot. """ if ax is None: ax = get_non_gui_ax() # Default plot options plot_opts = kwargs.copy() if "color" not in plot_opts: plot_opts["color"] = "red" if "marker" not in plot_opts: plot_opts["marker"] = "." if "markersize" not in plot_opts: plot_opts["markersize"] = 9 if "linestyle" not in plot_opts: plot_opts["linestyle"] = "None" # Plot data ax.errorbar(xdata, ydata, yerr=sigma, **plot_opts) # Formatting ax.tick_params(labelsize=labelsize) ax.grid(grid) return ax
def plot_scatter( xdata: np.ndarray, ydata: np.ndarray, ax=None, labelsize: int = 14, grid: bool = True, **kwargs, ): """Generate a scatter plot of xy data. Wraps :func:`matplotlib.pyplot.scatter`. Args: xdata: xdata used for fitting ydata: ydata used for fitting ax (matplotlib.axes.Axes): Optional, a matplotlib axes to add the plot to. labelsize: label size for plot grid: Show grid on plot. **kwargs: Additional options for :func:`matplotlib.pyplot.scatter` Returns: matplotlib.axes.Axes: the matplotlib axes containing the plot. """ if ax is None: ax = get_non_gui_ax() # Default plot options plot_opts = kwargs.copy() if "c" not in plot_opts: plot_opts["c"] = "grey" if "marker" not in plot_opts: plot_opts["marker"] = "x" if "alpha" not in plot_opts: plot_opts["alpha"] = 0.8 # Plot data ax.scatter(xdata, ydata, **plot_opts) # Formatting ax.tick_params(labelsize=labelsize) ax.grid(grid) return ax
def _run_analysis( self, experiment_data: ExperimentData ) -> Tuple[List[AnalysisResultData], List["pyplot.Figure"]]: """Wrap the analysis to optionally plot the IQ data.""" analysis_results, figures = super()._run_analysis(experiment_data) if self.options.plot_iq_data: axis = get_non_gui_ax() figure = axis.get_figure() figure.set_size_inches(*self.options.style.figsize) iqs = [] for datum in experiment_data.data(): if "memory" in datum: mem = np.array(datum["memory"]) # Average single-shot data. if len(mem.shape) == 3: for idx in range(mem.shape[1]): iqs.append(np.average(mem[:, idx, :], axis=0)) else: iqs.append(mem) if len(iqs) > 0: iqs = np.vstack(iqs) axis.scatter(iqs[:, 0], iqs[:, 1], color="b") axis.set_xlabel("In phase [arb. units]", fontsize=self.options.style.axis_label_size) axis.set_ylabel("Quadrature [arb. units]", fontsize=self.options.style.axis_label_size) axis.tick_params(labelsize=self.options.style.tick_label_size) axis.grid(True) figures.append(figure) return analysis_results, figures
def draw( cls, series_defs: List[SeriesDef], raw_samples: List[CurveData], fit_samples: List[CurveData], tick_labels: Dict[str, str], fit_data: FitData, result_entries: List[AnalysisResultData], style: Optional[PlotterStyle] = None, axis: Optional["matplotlib.axes.Axes"] = None, ) -> "pyplot.Figure": """Create a fit result of all curves in the single canvas. Args: series_defs: List of definition for each curve. raw_samples: List of raw sample data for each curve. fit_samples: List of formatted sample data for each curve. tick_labels: Dictionary of axis label information. Axis units and label for x and y value should be explained. fit_data: fit data generated by the analysis. result_entries: List of analysis result data entries. style: Optional. A configuration object to modify the appearance of the figure. axis: Optional. A matplotlib Axis object. Returns: A matplotlib figure of the curve fit result. """ if axis is None: axis = get_non_gui_ax() # update image size to experiment default figure = axis.get_figure() figure.set_size_inches(*style.figsize) else: figure = axis.get_figure() # draw all curves on the same canvas for series_def, raw_samp, fit_samp in zip(series_defs, raw_samples, fit_samples): draw_single_curve_mpl( axis=axis, series_def=series_def, raw_sample=raw_samp, fit_sample=fit_samp, fit_data=fit_data, style=style, ) # add legend if len(series_defs) > 1: axis.legend(loc=style.legend_loc) # get axis scaling factor for this_axis in ("x", "y"): sub_axis = getattr(axis, this_axis + "axis") unit = tick_labels[this_axis + "val_unit"] label = tick_labels[this_axis + "label"] if unit: maxv = np.max(np.abs(sub_axis.get_data_interval())) scaled_maxv, prefix = detach_prefix(maxv, decimal=3) prefactor = scaled_maxv / maxv # pylint: disable=cell-var-from-loop sub_axis.set_major_formatter( FuncFormatter(lambda x, p: f"{x * prefactor: .3g}")) sub_axis.set_label_text(f"{label} [{prefix}{unit}]", fontsize=style.axis_label_size) else: sub_axis.set_label_text(label, fontsize=style.axis_label_size) axis.ticklabel_format(axis=this_axis, style="sci", scilimits=(-3, 3)) if tick_labels["xlim"]: axis.set_xlim(tick_labels["xlim"]) if tick_labels["ylim"]: axis.set_ylim(tick_labels["ylim"]) # write analysis report if fit_data: report_str = write_fit_report(result_entries) report_str += r"Fit $\chi^2$ = " + f"{fit_data.reduced_chisq: .4g}" report_handler = axis.text( *style.fit_report_rpos, report_str, ha="center", va="top", size=style.fit_report_text_size, transform=axis.transAxes, ) bbox_props = dict(boxstyle="square, pad=0.3", fc="white", ec="black", lw=1, alpha=0.8) report_handler.set_bbox(bbox_props) axis.tick_params(labelsize=style.tick_label_size) axis.grid(True) return figure
def draw( cls, series_defs: List[SeriesDef], raw_samples: List[CurveData], fit_samples: List[CurveData], tick_labels: Dict[str, str], fit_data: FitData, result_entries: List[AnalysisResultData], style: Optional[PlotterStyle] = None, axis: Optional["matplotlib.axes.Axes"] = None, ) -> "pyplot.Figure": """Create a fit result of all curves in the single canvas. Args: series_defs: List of definition for each curve. raw_samples: List of raw sample data for each curve. fit_samples: List of formatted sample data for each curve. tick_labels: Dictionary of axis label information. Axis units and label for x and y value should be explained. fit_data: fit data generated by the analysis. result_entries: List of analysis result data entries. style: Optional. A configuration object to modify the appearance of the figure. axis: Optional. A matplotlib Axis object. Returns: A matplotlib figure of the curve fit result. """ if axis is None: axis = get_non_gui_ax() # update image size to experiment default figure = axis.get_figure() figure.set_size_inches(*style.figsize) else: figure = axis.get_figure() # get canvas number n_subplots = max(series_def.canvas for series_def in series_defs) + 1 # use inset axis. this allows us to draw multiple canvases on a given single axis object inset_ax_h = (1 - (0.05 * (n_subplots - 1))) / n_subplots inset_axes = [ axis.inset_axes( [ 0, 1 - (inset_ax_h + 0.05) * n_axis - inset_ax_h, 1, inset_ax_h ], transform=axis.transAxes, zorder=1, ) for n_axis in range(n_subplots) ] # show x label only in the bottom canvas for inset_axis in inset_axes[:-1]: inset_axis.set_xticklabels([]) inset_axes[-1].get_shared_x_axes().join(*inset_axes) # remove original axis frames axis.spines.right.set_visible(False) axis.spines.left.set_visible(False) axis.spines.top.set_visible(False) axis.spines.bottom.set_visible(False) axis.set_xticks([]) axis.set_yticks([]) # collect data source per canvas plot_map = defaultdict(list) for curve_ind, series_def in enumerate(series_defs): plot_map[series_def.canvas].append(curve_ind) y_labels = tick_labels["ylabel"].split(",") if len(y_labels) == 1: y_labels = y_labels * n_subplots for ax_ind, curve_inds in plot_map.items(): inset_axis = inset_axes[ax_ind] for curve_ind in curve_inds: draw_single_curve_mpl( axis=inset_axis, series_def=series_defs[curve_ind], raw_sample=raw_samples[curve_ind], fit_sample=fit_samples[curve_ind], fit_data=fit_data, style=style, ) # add legend to each inset axis if len(curve_inds) > 1: inset_axis.legend(loc=style.legend_loc) # format y axis tick value of each inset axis yaxis = getattr(inset_axis, "yaxis") unit = tick_labels["yval_unit"] label = y_labels[ax_ind] if unit: maxv = np.max(np.abs(yaxis.get_data_interval())) scaled_maxv, prefix = detach_prefix(maxv, decimal=3) prefactor = scaled_maxv / maxv # pylint: disable=cell-var-from-loop yaxis.set_major_formatter( FuncFormatter(lambda x, p: f"{x * prefactor: .3g}")) yaxis.set_label_text(f"{label} [{prefix}{unit}]", fontsize=style.axis_label_size) else: inset_axis.ticklabel_format(axis="y", style="sci", scilimits=(-3, 3)) yaxis.set_label_text(label, fontsize=style.axis_label_size) if tick_labels["ylim"]: inset_axis.set_ylim(tick_labels["ylim"]) # format x axis xaxis = getattr(inset_axes[-1], "xaxis") unit = tick_labels["xval_unit"] label = tick_labels["xlabel"] if unit: maxv = np.max(np.abs(xaxis.get_data_interval())) scaled_maxv, prefix = detach_prefix(maxv, decimal=3) prefactor = scaled_maxv / maxv # pylint: disable=cell-var-from-loop xaxis.set_major_formatter( FuncFormatter(lambda x, p: f"{x * prefactor: .3g}")) xaxis.set_label_text(f"{label} [{prefix}{unit}]", fontsize=style.axis_label_size) else: axis.ticklabel_format(axis="x", style="sci", scilimits=(-3, 3)) xaxis.set_label_text(label, fontsize=style.axis_label_size) if tick_labels["xlim"]: inset_axes[-1].set_xlim(tick_labels["xlim"]) # write analysis report if fit_data: report_str = write_fit_report(result_entries) report_str += r"Fit $\chi^2$ = " + f"{fit_data.reduced_chisq: .4g}" report_handler = axis.text( *style.fit_report_rpos, report_str, ha="center", va="top", size=style.fit_report_text_size, transform=axis.transAxes, ) bbox_props = dict(boxstyle="square, pad=0.3", fc="white", ec="black", lw=1, alpha=0.8) report_handler.set_bbox(bbox_props) axis.tick_params(labelsize=style.tick_label_size) axis.grid(True) return figure
def plot_curve_fit( func: Callable, result: FitData, fit_uncertainty: bool = False, ax=None, num_fit_points: int = 100, labelsize: int = 14, grid: bool = True, **kwargs, ): """Generate plot of a curve fit analysis result. Wraps :func:`matplotlib.pyplot.plot`. Args: func: the fit function for curve_fit. result: a fitting data set. fit_uncertainty: if True plot the fit uncertainty from popt_err. ax (matplotlib.axes.Axes): Optional, a matplotlib axes to add the plot to. num_fit_points: the number of points to plot for xrange. labelsize: label size for plot grid: Show grid on plot. **kwargs: Additional options for matplotlib.pyplot.plot Returns: matplotlib.axes.Axes: the matplotlib axes containing the plot. Raises: ImportError: if matplotlib is not installed. """ if ax is None: ax = get_non_gui_ax() # Default plot options plot_opts = kwargs.copy() if "color" not in plot_opts: plot_opts["color"] = "blue" if "linestyle" not in plot_opts: plot_opts["linestyle"] = "-" if "linewidth" not in plot_opts: plot_opts["linewidth"] = 2 # Result data fit_params = result.popt param_keys = result.popt_keys fit_errors = result.popt_err xmin, xmax = result.x_range # Plot fit data xs = np.linspace(xmin, xmax, num_fit_points) if param_keys: ys_fit = func(xs, **dict(zip(param_keys, fit_params))) else: ys_fit = func(xs, *fit_params) ax.plot(xs, ys_fit, **plot_opts) # Plot standard error interval if fit_uncertainty and fit_errors is not None: if param_keys: params_upper = {} params_lower = {} for key, param, error in zip(param_keys, fit_params, fit_errors): params_upper[key] = param + error params_lower[key] = param - error ys_upper = func(xs, **params_upper) ys_lower = func(xs, **params_lower) else: params_upper = [ param + error for param, error in zip(fit_params, fit_errors) ] params_lower = [ param - error for param, error in zip(fit_params, fit_errors) ] ys_upper = func(xs, *params_upper) ys_lower = func(xs, *params_lower) ax.fill_between(xs, ys_lower, ys_upper, alpha=0.1, color=plot_opts["color"]) # Formatting ax.tick_params(labelsize=labelsize) ax.grid(grid) return ax
def plot_curve_fit( func: Callable, result: FitData, ax=None, num_fit_points: int = 100, labelsize: int = 14, grid: bool = True, fit_uncertainty: List[Tuple[float, float]] = None, **kwargs, ): """Generate plot of a curve fit analysis result. Wraps :func:`matplotlib.pyplot.plot`. Args: func: the fit function for curve_fit. result: a fitting data set. ax (matplotlib.axes.Axes): Optional, a matplotlib axes to add the plot to. num_fit_points: the number of points to plot for xrange. labelsize: label size for plot grid: Show grid on plot. fit_uncertainty: a list of sigma values to plot confidence interval of fit line. **kwargs: Additional options for matplotlib.pyplot.plot Returns: matplotlib.axes.Axes: the matplotlib axes containing the plot. Raises: ImportError: if matplotlib is not installed. """ if ax is None: ax = get_non_gui_ax() if fit_uncertainty is None: fit_uncertainty = list() elif isinstance(fit_uncertainty, tuple): fit_uncertainty = [fit_uncertainty] # Default plot options plot_opts = kwargs.copy() if "color" not in plot_opts: plot_opts["color"] = "blue" if "linestyle" not in plot_opts: plot_opts["linestyle"] = "-" if "linewidth" not in plot_opts: plot_opts["linewidth"] = 2 xmin, xmax = result.x_range # Plot fit data xs = np.linspace(xmin, xmax, num_fit_points) ys_fit_with_error = func(xs, **dict(zip(result.popt_keys, result.popt))) # Line ax.plot(xs, unp.nominal_values(ys_fit_with_error), **plot_opts) # Confidence interval of N sigma values stdev_arr = unp.std_devs(ys_fit_with_error) if np.isfinite(stdev_arr).all(): for sigma, alpha in fit_uncertainty: ax.fill_between( xs, y1=unp.nominal_values(ys_fit_with_error) - sigma * stdev_arr, y2=unp.nominal_values(ys_fit_with_error) + sigma * stdev_arr, alpha=alpha, color=plot_opts["color"], ) # Formatting ax.tick_params(labelsize=labelsize) ax.grid(grid) return ax
def initialize_canvas(self): # Create axis if empty if not self.options.axis: axis = get_non_gui_ax() figure = axis.get_figure() figure.set_size_inches(*self.options.figsize) else: axis = self.options.axis n_rows, n_cols = self.options.subplots n_subplots = n_cols * n_rows if n_subplots > 1: # Add inset axis. User may provide a single axis object via the analysis option, # while this analysis tries to draw its result in multiple canvases, # especially when the analysis consists of multiple curves. # Inset axis is experimental implementation of matplotlib 3.0 so maybe unstable API. # This draws inset axes with shared x and y axis. inset_ax_h = 1 / n_rows inset_ax_w = 1 / n_cols for i in range(n_rows): for j in range(n_cols): # x0, y0, width, height bounds = [ inset_ax_w * j, 1 - inset_ax_h * (i + 1), inset_ax_w, inset_ax_h, ] sub_ax = axis.inset_axes(bounds, transform=axis.transAxes, zorder=1) if j != 0: # remove y axis except for most-left plot sub_ax.set_yticklabels([]) else: # this axis locates at left, write y-label if self.options.ylabel: label = self.options.ylabel if isinstance(label, list): # Y label can be given as a list for each sub axis label = label[i] sub_ax.set_ylabel( label, fontsize=self.options.axis_label_size) if i != n_rows - 1: # remove x axis except for most-bottom plot sub_ax.set_xticklabels([]) else: # this axis locates at bottom, write x-label if self.options.xlabel: label = self.options.xlabel if isinstance(label, list): # X label can be given as a list for each sub axis label = label[j] sub_ax.set_xlabel( label, fontsize=self.options.axis_label_size) if j == 0 or i == n_rows - 1: # Set label size for outer axes where labels are drawn sub_ax.tick_params( labelsize=self.options.tick_label_size) sub_ax.grid() # Remove original axis frames axis.axis("off") else: axis.set_xlabel(self.options.xlabel, fontsize=self.options.axis_label_size) axis.set_ylabel(self.options.ylabel, fontsize=self.options.axis_label_size) axis.tick_params(labelsize=self.options.tick_label_size) axis.grid() self._axis = axis