def chi01(param_name: Union[str, None], yval: float,
**kwargs) -> Dict[str, Any]:
"""Plot defaults for sweep_plotting.chi01"""
kwargs['xlabel'] = kwargs.get('xlabel') or recast_name(param_name)
kwargs['ylabel'] = kwargs.get('ylabel') or r'$\chi_{{01}}$ [{}]'.format(
units.get_units())
kwargs['title'] = kwargs.get('title') or r'$\chi_{{01}}=${:.4f} {}'.format(
yval, units.get_units())
return kwargs
def chi01(param_name: Union[str, None], yval: float,
**kwargs) -> Dict[str, Any]:
"""Plot defaults for sweep_plotting.chi01"""
kwargs["xlabel"] = kwargs.get("xlabel") or recast_name(param_name)
kwargs["ylabel"] = kwargs.get("ylabel") or r"$\chi_{{01}}$ [{}]".format(
units.get_units())
kwargs["title"] = kwargs.get("title") or r"$\chi_{{01}}=${:.4f} {}".format(
yval, units.get_units())
return kwargs
def create_widget(callback_func: Callable,
init_params: Dict[str, Any],
image_filename: str = None) -> None:
"""
Displays ipywidgets for initialization of a QuantumSystem object.
Parameters
----------
callback_func:
callback_function depends on all the parameters provided as keys (str) in the
parameter_dict, and is called upon changes of values inside the widgets
init_params:
names and values of initialization parameters
image_filename:
file name for circuit image to be displayed alongside the qubit
"""
widgets = {}
box_list = []
for name, value in init_params.items():
label_str = name
# NOTE: This will break if names of energy parameters in future qubits do not
# start with 'E'
if name[0] == "E":
label_str += " [" + units.get_units() + "]"
elif name == "flux":
label_str += r" [$\Phi_0$]"
label = ipywidgets.Label(value=label_str)
if isinstance(value, float):
enter_widget = ipywidgets.FloatText
else:
enter_widget = ipywidgets.IntText
widgets[name] = enter_widget(
value=value,
description="",
disabled=False,
layout=ipywidgets.Layout(width="150px"),
)
box_list.append(
ipywidgets.HBox(
[label, widgets[name]],
layout=ipywidgets.Layout(justify_content="flex-end"),
))
if image_filename:
file = open(image_filename, "rb")
image = file.read()
image_widget = ipywidgets.Image(
value=image, format="jpg", layout=ipywidgets.Layout(width="700px"))
ui_widget = ipywidgets.HBox(
[ipywidgets.VBox(box_list),
ipywidgets.VBox([image_widget])])
else:
ui_widget = ipywidgets.VBox(box_list)
out = ipywidgets.interactive_output(callback_func, widgets)
display(ui_widget, out)
def dressed_spectrum(sweep: 'ParameterSweep', **kwargs) -> Dict[str, Any]:
"""Plot defaults for sweep_plotting.dressed_spectrum"""
if 'ylim' not in kwargs:
kwargs['ymax'] = kwargs.get('ymax') or min(
15, (np.max(sweep.dressed_specdata.energy_table) -
np.min(sweep.dressed_specdata.energy_table)))
kwargs['xlabel'] = kwargs.get('xlabel') or recast_name(sweep.param_name)
kwargs['ylabel'] = kwargs.get('ylabel') or r'energy [{}]'.format(
units.get_units())
return kwargs
def create_widget(callback_func, init_params, image_filename=None):
"""
Displays ipywidgets for initialization of a QuantumSystem object.
Parameters
----------
callback_func: function
callback_function depends on all the parameters provided as keys (str) in the parameter_dict, and is called upon
changes of values inside the widgets
init_params: {str: value, str: value, ...}
names and values of initialization parameters
image_filename: str, optional
file name for circuit image to be displayed alongside the qubit
Returns
-------
"""
widgets = {}
box_list = []
for name, value in init_params.items():
label_str = name
# NOTE: This will break if names of energy parameters in future qubits do not start with 'E'
if name[0] == 'E':
label_str += ' [' + units.get_units() + ']'
elif name == 'flux':
label_str += r' [$\Phi_0$]'
label = ipywidgets.Label(value=label_str)
if isinstance(value, float):
enter_widget = ipywidgets.FloatText
else:
enter_widget = ipywidgets.IntText
widgets[name] = enter_widget(value=value,
description='',
disabled=False,
layout=ipywidgets.Layout(width='150px'))
box_list.append(
ipywidgets.HBox(
[label, widgets[name]],
layout=ipywidgets.Layout(justify_content='flex-end')))
if image_filename:
file = open(image_filename, "rb")
image = file.read()
image_widget = ipywidgets.Image(
value=image, format='jpg', layout=ipywidgets.Layout(width='700px'))
ui_widget = ipywidgets.HBox(
[ipywidgets.VBox(box_list),
ipywidgets.VBox([image_widget])])
else:
ui_widget = ipywidgets.VBox(box_list)
out = ipywidgets.interactive_output(callback_func, widgets)
display(ui_widget, out)
def dressed_spectrum(sweep: "ParameterSweep", **kwargs) -> Dict[str, Any]:
"""Plot defaults for sweep_plotting.dressed_spectrum"""
if "ylim" not in kwargs:
kwargs["ymax"] = kwargs.get("ymax") or min(
15,
(np.max(sweep.dressed_specdata.energy_table) -
np.min(sweep.dressed_specdata.energy_table)),
)
kwargs["xlabel"] = kwargs.get("xlabel") or recast_name(sweep.param_name)
kwargs["ylabel"] = kwargs.get("ylabel") or r"energy [{}]".format(
units.get_units())
return kwargs
def display_dressed_spectrum(sweep, initial_bare, final_bare, energy_initial,
energy_final, param_val, fig_ax):
energy_difference = energy_final - energy_initial
title = r"{} $\rightarrow$ {}: {:.4f} {}".format(initial_bare, final_bare,
energy_difference,
units.get_units())
__ = splot.dressed_spectrum(sweep, title=title, fig_ax=fig_ax)
_, axes = fig_ax
axes.axvline(param_val, color="gray", linestyle=":")
axes.scatter([param_val] * 2, [energy_initial, energy_final],
s=40,
c="gray")
def wavefunction1d_defaults(self, mode: str, evals: ndarray,
wavefunc_count: int) -> Dict[str, Any]:
"""Plot defaults for plotting.wavefunction1d.
Parameters
----------
mode:
amplitude modifier, needed to give the correct default y label
evals:
eigenvalues to include in plot
wavefunc_count:
number of wave functions to be plotted
"""
ylabel = r"$\psi_j(\varphi)$"
ylabel = constants.MODE_STR_DICT[mode](ylabel)
ylabel += ", energy [{}]".format(units.get_units())
options = {"xlabel": r"$\varphi$", "ylabel": ylabel}
return options
def chi(param_name: Union[str, None], **kwargs) -> Dict[str, Any]:
"""Plot defaults for sweep_plotting.chi"""
kwargs["xlabel"] = kwargs.get("xlabel") or recast_name(param_name)
kwargs["ylabel"] = kwargs.get("ylabel") or r"$\chi_j$ [{}]".format(
units.get_units())
return kwargs
def evals_vs_paramvals(specdata: "SpectrumData", **kwargs) -> Dict[str, Any]:
"""Plot defaults for plotting.evals_vs_paramvals"""
kwargs["xlabel"] = kwargs.get("xlabel") or recast_name(specdata.param_name)
kwargs["ylabel"] = kwargs.get("ylabel") or "energy [{}]".format(
units.get_units())
return kwargs
def plot_dispersion_vs_paramvals(
self,
dispersion_name: str,
param_name: str,
param_vals: ndarray,
ref_param: Optional[str] = None,
transitions: Union[Tuple[int], Tuple[Tuple[int], ...]] = (0, 1),
levels: Optional[Union[int, Tuple[int]]] = None,
point_count: int = 50,
num_cpus: Optional[int] = None,
**kwargs,
) -> Tuple[Figure, Axes]:
"""Generates a simple plot of a set of curves representing the charge or flux
dispersion of transition energies.
Parameters
----------
dispersion_name:
parameter inducing the dispersion, typically 'ng' or 'flux' (will be
scanned over range from 0 to 1)
param_name:
name of parameter to be varied
param_vals:
parameter values to be plugged in
ref_param:
optional, name of parameter to use as reference for the parameter value;
e.g., to compute charge dispersion vs. EJ/EC, use EJ as param_name and
EC as ref_param
transitions:
integer tuple or tuples specifying for which transitions dispersion is to
be calculated
(default: = (0,1))
levels:
int or tuple specifying level(s) (rather than transitions) for which
dispersion should be plotted; overrides transitions parameter when given
point_count:
number of points scanned for the dispersion parameter for determining min
and max values of transition energies (default: 50)
num_cpus:
number of cores to be used for computation
(default value: settings.NUM_CPUS)
**kwargs:
standard plotting option (see separate documentation)
"""
specdata = self.get_dispersion_vs_paramvals(
dispersion_name,
param_name,
param_vals,
ref_param=ref_param,
transitions=transitions,
levels=levels,
point_count=point_count,
num_cpus=num_cpus,
)
if levels is not None:
if isinstance(levels, int):
levels = (levels,)
label_list = [str(j) for j in levels]
else:
if isinstance(transitions[0], int):
transitions = (transitions,)
label_list = ["{}{}".format(i, j) for i, j in transitions]
return plot.data_vs_paramvals(
xdata=specdata.param_vals,
ydata=specdata.dispersion,
label_list=label_list,
xlabel=specdata.param_name,
ylabel="energy dispersion [{}]".format(units.get_units()),
yscale="log",
**kwargs,
)
def evals_vs_paramvals(specdata: 'SpectrumData', **kwargs) -> Dict[str, Any]:
"""Plot defaults for plotting.evals_vs_paramvals"""
kwargs['xlabel'] = kwargs.get('xlabel') or recast_name(specdata.param_name)
kwargs['ylabel'] = kwargs.get('ylabel') or 'energy [{}]'.format(
units.get_units())
return kwargs
