def save_to_itx(self):
U.save_to_igor_itx('sup_fig1_strong_gamma_noise.itx',
xs=[self.data.x],
datas=[self.data.data],
names=['single_strong_dndt'],
x_labels=['Sweepgate (mV)'],
y_labels=['Delta I (nA)'])
def save_data1ds_to_igor_itx(filepath: str, datas: List[Data1D],
names: List[str]):
U.save_to_igor_itx(file_path=filepath,
xs=[d.x for d in datas],
datas=[d.data for d in datas],
names=[n for n in names],
x_labels='V_D (mV)',
y_labels='Occupation')
def save_to_itx(self, filepath='fig3_heater_power.itx'):
save_infos = []
for t in self.temp_dat_dict.keys():
save_infos.append(
self.get_dats_closest_to_temp(t)._get_IgorSaveInfo(
trace_name=f'{t}mK_theta_vs_bias'))
U.save_to_igor_itx(
file_path=filepath,
xs=[s.x for s in save_infos],
datas=[s.data for s in save_infos],
names=[s.name for s in save_infos],
x_labels=[s.x_label for s in save_infos],
y_labels=[s.y_label for s in save_infos],
)
def run(self,
save_name: Optional[str] = None,
name_prefix: Optional[str] = None,
occupation_x_axis: bool = False,
fit_hot: bool = False) -> go.Figure:
params = self.get_params(fit_hot=fit_hot)
real_dndt = self.get_real_data()
occ_data = self.get_real_data(occupation=True)
real_dndt.x = occ_data.x
if occupation_x_axis:
real_dndt.x = NrgUtil().get_occupation_x(real_dndt.x,
params=params)
x_short = 'occ'
x_label = 'Occupation'
which_x = 'occupation'
else:
x_short = 'sweepgate'
x_label = 'Sweepgate (mV)'
which_x = 'sweepgate'
nrg_data = self.nrg_data(params=params,
x=real_dndt.x,
which_data='dndt',
which_x=which_x)
if not occupation_x_axis:
real_dndt.x = real_dndt.x / 100 # Convert to real mV
nrg_data.x = nrg_data.x / 100
# Switch to occupation as x axis
fig = self.plot(real_data=real_dndt,
nrg_data=nrg_data,
x_label=x_label)
if save_name:
assert name_prefix is not None
U.save_to_igor_itx(
f'{save_name}.itx',
xs=[data.x for data in [real_dndt, nrg_data]],
datas=[data.data for data in [real_dndt, nrg_data]],
names=[
f'{name_prefix}_data_vs_{x_short}',
f'{name_prefix}_nrg_vs_{x_short}'
],
x_labels=[x_label] * 2,
y_labels=[f'{DELTA}I (nA)'] * 2)
return fig
def run(self,
save_name: Optional[str] = None,
name_prefix: Optional[str] = None) -> go.Figure:
datas, gammas, thetas = self._get_datas()
fig = self.plot(datas, gammas, thetas)
if save_name:
U.save_to_igor_itx(f'{save_name}.itx',
xs=[data.x for data in datas],
datas=[data.data for data in datas],
names=[
f'{name_prefix}_scaled_dndt_g{g / t:.2f}'
for g, t in zip(gammas, thetas)
],
x_labels=[r'$V_D$/max(Gamma, T)'] * len(datas),
y_labels=[f'{DELTA}I*max(Gamma, T)'] *
len(datas))
return fig
def run(self,
save_name: Optional[str] = None,
name_prefix: Optional[str] = None) -> go.Figure:
data2d = self._data()
fig = self.plot(data2d)
if save_name:
assert name_prefix is not None
U.save_to_igor_itx(f'{save_name}.itx',
xs=[data2d.x],
ys=[data2d.y],
datas=[data2d.data],
names=[f'{name_prefix}_data_2d'],
x_labels=['$V_D$ (mV)'],
y_labels=['Gamma/T'])
U.save_to_txt(datas=[data2d.data, data2d.x, data2d.y],
names=['dndt', 'x', 'y'],
file_path='temp.txt')
return fig
def save_to_itx(self,
file_name: str = 'fig3_single_heater_power.itx',
trace_name: str = 'theta_vs_bias',
bias_max: Optional[float] = None):
"""
Save to .itx file
Args:
file_name ():
trace_name ():
bias_max (): Max bias to include in saved data (i.e. 3 will save only data with bias < 3nA)
Returns:
"""
save_info = self._get_IgorSaveInfo(trace_name, bias_max)
U.save_to_igor_itx(file_name,
xs=[save_info.x],
datas=[save_info.data],
names=[save_info.name],
x_labels=save_info.x_label,
y_labels=save_info.y_label)
which_data='dndt')
dndt.x = dndt.x / 100 # Convert to real mV
gt = init_fit.best_values.g / init_fit.best_values.theta
dndt_datas.append(dndt)
gts.append(gt)
nrg_fits.append(nrg_fit)
amps.append(init_fit.best_values.amp)
U.save_to_igor_itx(
file_path=f'fig1_dndt.itx',
xs=[data.x for data in dndt_datas] + [np.linspace(-3, 3, 1000)] +
[np.arange(4)],
datas=[data.data for data in dndt_datas] +
[nrg_fits[1].eval_fit(x=np.linspace(-3, 3, 1000) * 100)] +
[np.array(gts)],
names=[f'dndt_{i}' for i in range(len(dndt_datas))] +
['dndt_1_nrg_fit'] + ['gts_for_dndts'],
x_labels=['Sweep Gate (mV)'] * (len(dndt_datas) + 1) + ['index'],
y_labels=['dN/dT (nA)'] * (len(dndt_datas) + 1) + ['G/T'])
# dNdT Plots (one for weakly coupled only, one for strongly coupled only)
weak_fig, ax = plt.subplots(1, 1)
ax = dndt_signal(ax,
xs=dndt_datas[0].x,
datas=dndt_datas[0].data,
amp_sensitivity=amps[0])
ax.set_xlim(-0.6, 0.6)
ax.set_title('')
plt.tight_layout()
save_infos.append(
U.IgorSaveInfo(x=data2d.x,
data=data2d.data,
name='sup_weak_signal_2d',
x_label='V_D (mV)',
y_label='Repeats',
y=data2d.y))
for d, name_append in zip([data, data_single], ['avg', 'single']):
save_infos.append(
U.IgorSaveInfo(x=d.x,
data=d.data,
name=f'sup_weak_signal_{name_append}',
x_label='V_D (mV)',
y_label='Delta I (nA)'))
U.save_multiple_save_info_to_itx(file_path='Sup_weak_signal.itx',
save_infos=save_infos)
################ CSQ Map
dat = get_dat(2197)
data = plot_csq_trace(dat, cutoff=-165)
U.save_to_igor_itx(
file_path='Sup_csq_map.itx',
xs=[data.x],
datas=[data.data],
names=['csq_map'],
x_labels=['V_C (mV)'],
y_labels=['I_{CS}'],
)
gt = fit.best_values.g / \
fit.best_values.theta
data.x = data.x / 100 # Convert to real mV
datas.append(data)
gts.append(gt)
fit_datas.append(get_nrg_integrated(dat))
save_to_igor_itx(
file_path=f'fig3_integrated_entropy.itx',
xs=[data.x for data in datas] + [data.x for data in fit_datas] +
[np.arange(len(gts))],
datas=[data.data
for data in datas] + [data.data
for data in fit_datas] + [np.array(gts)],
names=[
f'int_entropy_{k}' for k in ['weak', 'similar', 'med', 'strong']
] +
[f'int_entropy_{k}_fit'
for k in ['weak', 'similar', 'med', 'strong']] +
['gts_for_int_vary_g'],
x_labels=['Sweep Gate (mV)'] * len(datas) * 2 + ['index'],
y_labels=['Entropy (kB)'] * len(datas) * 2 + ['G/T'])
# Plot Integrated Entropy
fig, ax = plt.subplots(1, 1)
integrated_entropy(ax,
xs=[data.x for data in datas],
datas=[data.data for data in datas],
labels=[f'{gt:.1f}' for gt in gts])
for data in fit_datas:
all_dats = U.order_list(all_dats,
[dat.Logs.fds['ESC'] for dat in all_dats])
datas = [
get_avg_entropy_data(dat,
center_func=_center_func,
csq_datnum=csq_datnum) for dat in all_dats
]
xs = [data.x / 100 for data in datas] # /100 to convert to real mV
dndts = [data.data for data in datas]
U.save_to_igor_itx(
file_path=f'fig2_dndt.itx',
xs=xs + [np.array([dat.datnum for dat in all_dats])],
datas=dndts + [np.array([dat.Logs.dacs['ESC'] for dat in all_dats])],
names=[f'dndt_stacked_{i}'
for i in range(len(dndts))] + ['stacked_coupling_gates'],
x_labels=['Sweep Gate (mV)'] * len(dndts) + ['Datnum'],
y_labels=['dN/dT (nA)'] * len(dndts) + ['ESC (mV)'])
# plotting dNdT for several weakly coupled
fig, ax = plt.subplots(1, 1)
ax = dndt_signal(ax,
xs=xs,
datas=dndts,
labels=[f'{dat.Logs.fds["ESC"]:.1f}' for dat in all_dats],
single=False)
for line in ax.lines:
line.set_marker('')
ax.get_legend().set_title('Coupling Gate (mV)')
ax.set_xlim(-1, 1)
