def plot_dT_comparison(dats: List[DatHDF], plot=True):
plotter = OneD(dats=dats)
fig = plotter.figure(xlabel='Fridge Temp /mK',
ylabel='% Difference between calculated dTs',
title=f'Dats{dats[0].datnum}-{dats[-1].datnum}: Difference between DC bias calculated dT and '
f'Square Entropy Calculated dT')
hover_infos = [
HoverInfo(name='Dat', func=lambda dat: dat.datnum, precision='.d', units=''),
HoverInfo(name='Temperature', func=lambda dat: dat.Logs.temps.mc * 1000, precision='.1f', units='mK'),
HoverInfo(name='Bias', func=lambda dat: dat.AWG.max(0) / 10, precision='.1f', units='nA'),
]
funcs, template = _additional_data_dict_converter(hover_infos)
for bias in sorted(list(set([dat.AWG.max(0) for dat in dats]))):
ds = [dat for dat in dats if dat.AWG.max(0) == bias]
diffs = [compare_dTs(dat, verbose=False) for dat in ds]
hover_data = [[func(dat) for func in funcs] for dat in ds]
fig.add_trace(plotter.trace(data=diffs, x=[dat.Logs.temps.mc * 1000 for dat in ds],
name=f'Bias={bias / 10:.0f}nA',
mode='markers+lines',
trace_kwargs={'customdata': hover_data, 'hovertemplate': template}))
if plot:
fig.show(renderer='browser')
return fig
def plot_entropy_vs_temp(dats: List[DatHDF], integrated=False, plot=True):
fit_name = 'SPS.0045'
plotter = OneD(dats=dats)
_tname = 'Integrated' if integrated else 'Fit'
fig = plotter.figure(
title=f'Dats{dats[0].datnum}-{dats[-1].datnum}: {_tname} Entropy',
xlabel='Heating Bias /nA',
ylabel='Entropy /kB')
temps = list(range(0, 300, 10))
hover_infos = [
HoverInfo(name='Dat', func=lambda dat: dat.datnum, precision='.d', units=''),
HoverInfo(name='Temperature', func=lambda dat: dat.Logs.temps.mc * 1000, precision='.1f', units='mK'),
HoverInfo(name='Bias', func=lambda dat: dat.AWG.max(0) / 10, precision='.1f', units='nA'),
]
funcs, template = _additional_data_dict_converter(hover_infos)
for temp in temps:
ds = [dat for dat in dats if np.isclose(dat.Logs.temps.mc * 1000, temp, atol=5)]
if len(ds) > 0:
x = [dat.AWG.max(0) / 10 for dat in ds]
hover_data = [[func(dat) for func in funcs] for dat in ds]
if integrated is False:
entropies = [dat.Entropy.get_fit(name=fit_name).best_values.dS for dat in ds]
entropy_errs = [np.nanstd([
f.best_values.dS if f.best_values.dS is not None else np.nan
for f in dat.Entropy.get_row_fits(name=fit_name) for dat in ds
]) / np.sqrt(dat.Data.y_array.shape[0]) for dat in ds]
fig.add_trace(plotter.trace(
data=entropies, data_err=entropy_errs, x=x, name=f'{temp:.0f}mK',
mode='markers+lines',
trace_kwargs={'customdata': hover_data, 'hovertemplate': template})
)
else:
integrated_entropies = [np.nanmean(dat.Entropy.integrated_entropy[-10:]) for dat in ds]
fig.add_trace(plotter.trace(
data=integrated_entropies, x=x, name=f'{temp:.0f}mK',
mode='markers+lines',
trace_kwargs={'customdata': hover_data, 'hovertemplate': template})
)
if plot:
fig.show(renderer='browser')
return fig
def dcbias_multi_dat(dats: List[DatHDF]):
plotter = OneD(dats=dats)
fig = plotter.figure(
xlabel='Heater Current Bias /nA',
ylabel='Theta /mV',
title=f'Dats{dats[0].datnum}-{dats[-1].datnum}: DCbias')
thetas = []
biases = []
for dat in dats:
fit = dat.Transition.get_fit(which='avg',
name='default',
check_exists=False)
theta = fit.best_values.theta
thetas.append(theta)
biases.append(dat.Logs.fds['HO1/10M'] / 10)
hover_infos = common_dat_hover_infos(datnum=True)
hover_infos.append(
HoverInfo(name='Bias',
func=lambda dat: dat.Logs.dacs['HO1/10M'] / 10,
precision='.2f',
units='nA'))
hover_infos.append(
HoverInfo(name='Theta',
func=lambda dat: dat.Transition.get_fit().best_values.theta,
precision='.2f',
units='mV'))
hover_group = HoverInfoGroup(hover_infos=hover_infos)
fig.add_trace(
plotter.trace(x=biases,
data=thetas,
mode='markers+lines',
hover_template=hover_group.template,
hover_data=hover_group.customdata(dats)))
return fig
def entropy_vs_gate_trace(dats: List[DatHDF], x_gate, y_gate=None):
fit_name = "SPS.0045"
plotter = OneD(dats=dats)
entropy = [dat.Entropy.get_fit(which='avg', name=fit_name).best_values.dS for dat in dats]
entropy_errs = [np.nanstd([f.best_values.dS if f.best_values.dS is not None else np.nan
for f in dat.Entropy.get_row_fits(name=fit_name)]) for dat in dats]
x = [dat.Logs.fds[x_gate] for dat in dats]
trace = plotter.trace(data=entropy, data_err=entropy_errs, x=x, mode='markers+lines',
name=f'Dats{dats[0].datnum}->{dats[-1].datnum}')
hover_infos = [
HoverInfo(name='Dat', func=lambda dat: dat.datnum, precision='.d', units=''),
HoverInfo(name=x_gate, func=lambda dat: dat.Logs.fds[x_gate], precision='.1f', units='mV'),
# HoverInfo(name='Time', func=lambda dat: dat.Logs.time_completed.strftime('%H:%M'), precision='', units=''),
]
if y_gate:
hover_infos.append(HoverInfo(name=y_gate, func=lambda dat: dat.Logs.fds[y_gate], precision='.2f', units='mV'))
funcs, hover_template = _additional_data_dict_converter(info=hover_infos)
hover_data = [[f(dat) for f in funcs] for dat in dats]
trace.update(hovertemplate=hover_template,
customdata=hover_data)
return trace
def plot_stacked_square_heated(datnums: List[int], save_name: str, plot=True):
dats = get_dats(datnums)
# Plot Integrated
integrated_plot_info = PlotInfo(
title_append='Integrated Entropy',
ylabel='Entropy /kB',
data_func=lambda dat: dat.Entropy.get_integrated_entropy(
name=save_name,
data=dat.SquareEntropy.get_Outputs(
name=save_name, check_exists=True).average_entropy_signal),
x_func=lambda dat: dat.SquareEntropy.get_Outputs(name=save_name,
check_exists=True).x,
trace_name=lambda dat: f'Dat{dat.datnum}')
fit_plot_info = PlotInfo(
title_append='Fit Entropy',
ylabel='Entropy /kB',
data_func=lambda dat: dat.SquareEntropy.get_Outputs(
name=save_name, check_exists=True).average_entropy_signal,
x_func=lambda dat: dat.SquareEntropy.get_Outputs(name=save_name,
check_exists=True).x,
trace_name=lambda dat: f'Dat{dat.datnum}')
figs = []
for plot_info in [integrated_plot_info]:
plotter = OneD(dats=dats)
dat = dats[0]
fig = plotter.figure(
xlabel=dat.Logs.xlabel,
ylabel=plot_info.ylabel,
title=
f'Dats{dats[0].datnum}-{dats[-1].datnum}: {plot_info.title_append}'
)
for dat in dats:
data = plot_info.data_func(dat)
x = plot_info.x_func(dat)
hover_infos = [
HoverInfo(name='Datnum',
func=lambda dat: dat.datnum,
precision='d',
units=''),
HoverInfo(name=dat.Logs.xlabel,
func=lambda dat: plot_info.x_func(dat),
precision='.2f',
units='/mV'),
HoverInfo(name=plot_info.ylabel,
func=lambda dat: dat.datnum,
precision='d',
units=''),
]
hover_funcs, template = _additional_data_dict_converter(
hover_infos)
hover_data = []
for func in hover_funcs:
v = func(dat)
if not hasattr(v, '__len__') or len(
v) == 1: # Make sure a hover info for each x_coord
v = [v] * len(x)
hover_data.append(v)
fig.add_trace(
plotter.trace(x=x,
data=data,
name=plot_info.trace_name(dat),
hover_data=hover_data,
hover_template=template,
mode='lines'))
if plot:
fig.show()
figs.append(fig)
return figs
def get_integrated_trace(
dats: List[DatHDF],
x_func: Callable,
x_label: str,
trace_name: str,
save_name: str,
int_info_name: Optional[str] = None,
SE_output_name: Optional[str] = None,
sub_linear: bool = False,
signal_width: Optional[Union[float, Callable]] = None) -> go.Scatter:
"""
Returns a trace Integrated Entropy vs x_func
Args:
dats ():
x_func ():
x_label ():
trace_name ():
save_name ():
int_info_name ():
SE_output_name ():
sub_linear (): Whether to subtract linear entropy term from both integrated trace (note: requires signal_width)
signal_width (): How wide the actual entropy signal is so that a slope can be fit to the sides around it,
Can be a callable which takes 'dat' as the argument
Returns:
go.Scatter: The trace
"""
if int_info_name is None:
int_info_name = save_name
if SE_output_name is None:
SE_output_name = save_name
plotter = OneD(dats=dats)
dats = U.order_list(dats, [x_func(dat) for dat in dats])
standard_hover_infos = common_dat_hover_infos(
datnum=True,
heater_bias=True,
fit_entropy_name=save_name,
fit_entropy=True,
int_info_name=int_info_name,
output_name=SE_output_name,
integrated_entropy=True,
sub_lin=sub_linear,
sub_lin_width=signal_width,
int_info=True,
)
standard_hover_infos.append(
HoverInfo(name=x_label,
func=lambda dat: x_func(dat),
precision='.1f',
units='mV',
position=1))
hover_infos = HoverInfoGroup(standard_hover_infos)
x = [x_func(dat) for dat in dats]
if not sub_linear:
integrated_entropies = [
np.nanmean(
dat.Entropy.get_integrated_entropy(
name=int_info_name,
data=dat.SquareEntropy.get_Outputs(
name=SE_output_name,
check_exists=True).average_entropy_signal)[-10:])
for dat in dats
]
else:
integrated_entropies = [
np.nanmean(
dat_integrated_sub_lin(dat,
signal_width=signal_width(dat),
int_info_name=int_info_name,
output_name=SE_output_name)[-10:])
for dat in dats
]
trace = plotter.trace(data=integrated_entropies,
x=x,
name=trace_name,
mode='markers+lines',
trace_kwargs=dict(
customdata=hover_infos.customdata(dats),
hovertemplate=hover_infos.template))
return trace
def plot_fit_integrated_comparison(dats: List[DatHDF],
x_func: Callable,
x_label: str,
title_append: Optional[str] = '',
int_info_name: Optional[str] = None,
fit_name: str = 'SPS.0045',
plot=True) -> go.Figure():
if int_info_name is None:
int_info_name = 'default'
plotter = OneD(dats=dats)
fig = plotter.figure(
title=
f'Dats{dats[0].datnum}-{dats[-1].datnum}: Fit and Integrated (\'{int_info_name}\') Entropy{title_append}',
xlabel=x_label,
ylabel='Entropy /kB')
hover_infos = [
HoverInfo(name='Dat',
func=lambda dat: dat.datnum,
precision='.d',
units=''),
HoverInfo(name='Temperature',
func=lambda dat: dat.Logs.temps.mc * 1000,
precision='.1f',
units='mK'),
HoverInfo(name='Bias',
func=lambda dat: dat.AWG.max(0) / 10,
precision='.1f',
units='nA'),
# HoverInfo(name='Fit Entropy', func=lambda dat: dat.SquareEntropy.get_fit(which_fit='entropy', fit_name=fit_name).best_values.dS,
# precision='.2f', units='kB'),
HoverInfo(
name='Integrated Entropy',
func=lambda dat: np.nanmean(
dat.Entropy.get_integrated_entropy(
name=int_info_name,
data=dat.SquareEntropy.get_Outputs(
name=fit_name).average_entropy_signal)[-10:]),
# TODO: Change to using proper output (with setpoints)
precision='.2f',
units='kB'),
]
funcs, template = _additional_data_dict_converter(hover_infos)
x = [x_func(dat) for dat in dats]
hover_data = [[func(dat) for func in funcs] for dat in dats]
entropies = [
dat.Entropy.get_fit(name=fit_name).best_values.dS for dat in dats
]
# entropy_errs = [np.nanstd([
# f.best_values.dS if f.best_values.dS is not None else np.nan
# for f in dat.Entropy.get_row_fits(name=fit_name) for dat in dats
# ]) / np.sqrt(dat.Data.y_array.shape[0]) for dat in dats]
entropy_errs = None
fig.add_trace(
plotter.trace(data=entropies,
data_err=entropy_errs,
x=x,
name=f'Fit Entropy',
mode='markers',
trace_kwargs={
'customdata': hover_data,
'hovertemplate': template
}))
integrated_entropies = [
np.nanmean(
dat.Entropy.get_integrated_entropy(
name=int_info_name,
data=dat.SquareEntropy.get_Outputs(
name=fit_name).average_entropy_signal)[-10:])
for dat in dats
]
### For plotting the impurity dot scans (i.e. isolate only the integrated entropy due to the main dot transition)
# integrated_entropies = []
# for dat in dats:
# out = dat.SquareEntropy.get_Outputs(name=fit_name)
# x1, x2 = U.get_data_index(out.x, [-40, 40], is_sorted=True)
# integrated = dat.Entropy.get_integrated_entropy(name=int_info_name,
# data=out.average_entropy_signal)
# integrated_entropies.append(integrated[x2]-integrated[x1])
fig.add_trace(
plotter.trace(data=integrated_entropies,
x=x,
name=f'Integrated',
mode='markers+lines',
trace_kwargs={
'customdata': hover_data,
'hovertemplate': template
}))
if plot:
fig.show(renderer='browser')
return fig
def common_dat_hover_infos(datnum=True,
heater_bias=False,
fit_entropy_name: Optional[str] = None,
fit_entropy=False,
int_info_name: Optional[str] = None,
output_name: Optional[str] = None,
integrated_entropy=False,
sub_lin: bool = False,
sub_lin_width: Optional[Union[float, Callable]] = None,
int_info=False,
amplitude=False,
theta=False,
gamma=False,
) -> List[HoverInfo]:
"""
Returns a list of HoverInfos for the specified parameters. To do more complex things, append specific
HoverInfos before/after this.
Examples:
hover_infos = common_dat_hover_infos(datnum=True, amplitude=True, theta=True)
hover_group = HoverInfoGroup(hover_infos)
Args:
datnum ():
heater_bias ():
fit_entropy_name (): Name of saved fit_entropy if wanting fit_entropy
fit_entropy ():
int_info_name (): Name of int_info if wanting int_info or integrated_entropy
output_name (): Name of SE output to integrate (defaults to int_info_name)
integrated_entropy ():
sub_lin (): Whether to subtract linear term from integrated_info first
sub_lin_width (): Width of transition to avoid in determining linear terms
int_info (): amp/dT/sf from int_info
Returns:
List[HoverInfo]:
"""
hover_infos = []
if datnum:
hover_infos.append(HoverInfo(name='Dat', func=lambda dat: dat.datnum, precision='.d', units=''))
if heater_bias:
hover_infos.append(HoverInfo(name='Bias', func=lambda dat: dat.AWG.max(0) / 10, precision='.1f', units='nA'))
if fit_entropy:
hover_infos.append(HoverInfo(name='Fit Entropy',
func=lambda dat: dat.Entropy.get_fit(name=fit_entropy_name,
check_exists=True).best_values.dS,
precision='.2f', units='kB'), )
if integrated_entropy:
if output_name is None:
output_name = int_info_name
if sub_lin:
if sub_lin_width is None:
raise ValueError(f'Must specify sub_lin_width if subtrating linear term from integrated entropy')
elif not isinstance(sub_lin_width, Callable):
sub_lin_width = lambda _: sub_lin_width # make a value into a function so so that can assume function
data = lambda dat: dat_integrated_sub_lin(dat, signal_width=sub_lin_width(dat), int_info_name=int_info_name,
output_name=output_name)
hover_infos.append(HoverInfo(name='Sub lin width', func=sub_lin_width, precision='.1f', units='mV'))
else:
data = lambda dat: dat.Entropy.get_integrated_entropy(
name=int_info_name,
data=dat.SquareEntropy.get_Outputs(
name=output_name).average_entropy_signal)
hover_infos.append(HoverInfo(name='Integrated Entropy',
func=lambda dat: np.nanmean(data(dat)[-10:]),
precision='.2f', units='kB'))
if int_info:
info = lambda dat: dat.Entropy.get_integration_info(name=int_info_name)
hover_infos.append(HoverInfo(name='SF amp',
func=lambda dat: info(dat).amp,
precision='.3f',
units='nA'))
hover_infos.append(HoverInfo(name='SF dT',
func=lambda dat: info(dat).dT,
precision='.3f',
units='mV'))
hover_infos.append(HoverInfo(name='SF',
func=lambda dat: info(dat).sf,
precision='.3f',
units=''))
return hover_infos