def process_single(pars: GammaAnalysisParams,
overwrite_transition=False,
overwrite_entropy=False):
"""Does all the processing necessary for a single GammaAnalysisParams (i.e. csq mapping, transition fitting,
entropy fitting and setting integration info"""
if pars.csq_mapped:
calculate_csq_map(pars.entropy_datnum,
csq_datnum=pars.csq_datnum,
overwrite=overwrite_entropy)
if pars.transition_only_datnum:
calculate_csq_map(pars.transition_only_datnum,
csq_datnum=pars.csq_datnum,
overwrite=overwrite_transition)
if pars.transition_only_datnum is not None:
print(f'Dat{pars.transition_only_datnum}')
if pars.save_name + '_cold' not in get_dat(pars.transition_only_datnum).Transition.fit_names \
or overwrite_transition:
do_transition_only_calc(
datnum=pars.transition_only_datnum,
save_name=pars.save_name,
theta=pars.force_theta,
gamma=pars.force_gamma,
center_func=pars.transition_center_func_name,
width=pars.transition_fit_width,
t_func_name=pars.transition_func_name,
csq_mapped=pars.csq_mapped,
data_rows=pars.transition_data_rows,
overwrite=overwrite_transition)
if pars.save_name not in get_dat(
pars.entropy_datnum).Entropy.fit_names or overwrite_entropy:
print(f'Dat{pars.entropy_datnum}')
do_entropy_calc(pars.entropy_datnum,
save_name=pars.save_name,
setpoint_start=pars.setpoint_start,
t_func_name=pars.entropy_transition_func_name,
csq_mapped=pars.csq_mapped,
theta=pars.force_theta,
gamma=pars.force_gamma,
width=pars.entropy_fit_width,
data_rows=pars.transition_data_rows,
overwrite=overwrite_entropy)
calculate_new_sf_only(
pars.entropy_datnum,
pars.save_name,
dt=pars.force_dt,
amp=pars.force_amp,
from_square_transition=pars.sf_from_square_transition,
transition_datnum=pars.transition_only_datnum,
fit_name=pars.save_name)
# Save to HDF
d = get_dat(pars.entropy_datnum)
save_gamma_analysis_params_to_dat(d,
analysis_params=pars,
name=pars.save_name)
return None
def check_nrg_fit(datnum, exisiting_fit='forced_theta_linear'):
"""
Args:
datnum ():
exisiting_fit (): To get the Theta value from
Returns:
"""
dat = get_dat(datnum)
x = dat.Data.x
data = dat.Data.get_data('csq_mapped_avg')
theta = dat.Transition.get_fit(name=exisiting_fit).best_values.theta
nrg_fitter = NrgUtil(
NRGParams(gamma=1,
theta=theta,
center=0,
amp=1.5,
lin=0.003,
const=0,
lin_occ=0))
fit = nrg_fitter.get_fit(x=x, data=data)
fig = p1d.plot(data=data, x=x, trace_name='data')
fig.add_trace(p1d.trace(x=x, data=fit.eval_fit(x=x), name='fit'))
fig.add_trace(p1d.trace(x=x, data=fit.eval_init(x=x), name='init'))
fig.show()
print(
f'Dat{dat.datnum}: G/T = {fit.best_values.g / fit.best_values.theta:.2f}'
)
def plot_multiple_dndt(params: List[Params]) -> go.Figure:
fig = p1d.figure(xlabel='Sweep Gate/max(Gamma, T)',
ylabel=f'{DELTA}I*max(Gamma, T)',
title=f'{DELTA}I vs Sweep gate for various Gamma/T')
for param in params:
dat = get_dat(param.datnum)
out = dat.SquareEntropy.get_Outputs(name='forced_theta_linear_non_csq')
sweep_x = out.x / 100 # /100 to convert to real mV
data_dndt = out.average_entropy_signal
# transition_fit = tdat.Transition.get_fit(name='forced_theta_linear_non_csq')
# gamma_over_t = transition_fit.best_values.g/transition_fit.best_values.theta
gamma_over_t = param.gamma / param.theta
rescale = max(param.gamma, param.theta)
fig.add_trace(
p1d.trace(x=sweep_x / rescale,
data=data_dndt * rescale,
mode='lines',
name=f'{gamma_over_t:.2f}'))
fig.update_layout(legend_title='Gamma/Theta')
fig.update_xaxes(range=[-0.2, 0.2])
fig.update_layout(template='simple_white')
return fig
def _get_params_from_dat(self,
datnum,
fit_which: str = 'i_sense',
hot_or_cold: str = 'cold') -> NRGParams:
dat = get_dat(datnum)
orig_fit = dat.NrgOcc.get_fit(name=NRG_OCC_FIT_NAME)
if fit_which == 'i_sense':
data = get_avg_i_sense_data(dat,
CSQ_DATNUM,
center_func=_center_func,
hot_or_cold=hot_or_cold)
if hot_or_cold == 'hot': # Then allow theta to vary, but hold gamma const
params = U.edit_params(orig_fit.params, ['g', 'theta'],
[None, None],
vary=[False, True])
else:
params = orig_fit.params
new_fit = dat.NrgOcc.get_fit(calculate_only=True,
x=data.x,
data=data.data,
initial_params=params)
elif fit_which == 'entropy':
data = get_avg_entropy_data(dat,
center_func=_center_func,
csq_datnum=CSQ_DATNUM)
new_fit = NrgUtil(inital_params=orig_fit).get_fit(
data.x, data.data, which_data='dndt')
else:
raise NotImplementedError
params = NRGParams.from_lm_params(new_fit.params)
return params
def run_weakly_coupled_nrg_fit(
datnum: int,
csq_datnum: Optional[int],
center_func: Optional[Callable[[DatHDF], bool]] = None,
overwrite: bool = False,
) -> FitInfo:
"""
Runs
Args:
datnum (): Dat to calculate for
csq_datnum (): Num of dat to use for CSQ mapping (will only calculate if necessary)
center_func: Whether data should be centered first for dat
(e.g. lambda dat: True if dat.Logs.dacs['ESC'] > -250 else False)
overwrite (): NOTE: Only overwrites final Avg fit.
Returns:
"""
fit_name = 'csq_gamma_small' if csq_datnum is not None else 'gamma_small'
dat = get_dat(datnum)
avg_data = get_avg_i_sense_data(dat, csq_datnum, center_func=center_func)
pars = get_initial_params(avg_data, which='nrg')
pars['g'].value = 0.005
pars['g'].vary = False
pars['occ_lin'].vary = False
fit = dat.NrgOcc.get_fit(which='avg',
name=fit_name,
initial_params=pars,
data=avg_data.data,
x=avg_data.x,
calculate_only=False,
check_exists=False,
overwrite=overwrite)
return fit
def figure_1_add_NRG_fit_to_gamma_dndt() -> go.Figure:
fit_name = 'forced_theta_linear_non_csq'
dat = get_dat(2170)
init_params = NRGParams(
gamma=23.4352,
theta=4.396,
center=78.4,
amp=0.675,
lin=0.00121,
const=7.367,
lin_occ=0.0001453,
)
out = dat.SquareEntropy.get_Outputs(name=fit_name)
x = out.x
z = out.average_entropy_signal
fig = p1d.figure(xlabel='V_P', ylabel=f'{DELTA}I (nA)')
fig.add_trace(p1d.trace(x=x, data=z, name='Data', mode='lines'))
dndt_init_params = copy.copy(init_params)
dndt_init_params.amp = 0.0001 # To rescale the arbitrary NRG dndt scale
dndt_init_params.theta = dat.SquareEntropy.get_fit(
fit_name=fit_name).best_values.theta
nrg_fitter = NrgUtil(inital_params=dndt_init_params)
fit = nrg_fitter.get_fit(x=x, data=z, which_data='dndt')
fig.add_trace(
p1d.trace(x=x, data=fit.eval_fit(x=x), mode='lines', name='Fit'))
fig.add_trace(
p1d.trace(x=x, data=fit.eval_init(x=x), mode='lines', name='Init'))
fig.show()
return fig
def __init__(
self,
run,
run_centers,
datnum,
overwrite_centers,
sp_start,
se_transition_func,
se_fit_width,
se_rows,
use_tonly,
tonly_datnum,
tonly_func,
tonly_width,
tonly_rows,
center_func,
force_theta,
force_gamma,
force_dt,
force_amp,
int_from_se,
use_csq,
csq_datnum,
):
self.run = triggered_by(
self.components.but_run.id) # i.e. True if run was the trigger
self.run_centers = triggered_by(
self.components.but_run_generate_centers.id)
self.overwrite_centers = True if overwrite_centers else False
self.datnum = datnum
# SE fitting
self.sp_start = sp_start if sp_start else 0.0
self.ent_transition_func = se_transition_func
self.ent_width = se_fit_width
self.ent_rows = se_rows if se_rows else (None, None)
# Tonly fitting
self.use_tonly = use_tonly
self.tonly_datnum = tonly_datnum
self.tonly_func = tonly_func
self.tonly_width = tonly_width
self.tonly_rows = tonly_rows
self.center_func = center_func
self.force_theta = force_theta
self.force_gamma = force_gamma
# Integration info
self.force_dt = force_dt
self.force_amp = force_amp
self.int_from_se = int_from_se
# CSQ mapping
self.csq_map = use_csq
self.csq_datnum = csq_datnum
# ## Post init
self.dat = get_dat(self.datnum) if self.datnum else None
def calc_transition(datnum: int, exp2hdf=FebMar21Exp2HDF) -> FitInfo:
dat = get_dat(datnum, exp2hdf=exp2hdf, overwrite=False)
try:
tfit = dat.Transition.avg_fit
except Exception as e:
print(f'Dat{datnum} raised {e}')
tfit = None
return tfit
def __init__(self, datnum: int, se_name, e_names, t_names, int_names):
self.datnum: Optional[int] = datnum
self.se_name: str = se_name
self.e_names: List[str] = listify_dash_input(e_names)
self.t_names: List[str] = listify_dash_input(t_names)
self.int_names: List[str] = listify_dash_input(int_names)
# Generated
self.dat = get_dat(datnum) if self.datnum is not None else None
def get_real_data(self, occupation=False) -> Data1D:
if self.which_plot == 'weak':
dat = get_dat(2164)
elif self.which_plot == 'strong':
dat = get_dat(2170)
# dat = get_dat(2213)
else:
raise NotImplementedError
if occupation:
data = get_avg_i_sense_data(dat,
CSQ_DATNUM,
center_func=_center_func,
hot_or_cold='cold')
else:
data = get_avg_entropy_data(dat,
center_func=_center_func,
csq_datnum=CSQ_DATNUM)
return Data1D(x=data.x, data=data.data)
def compare_nrg_with_i_sense_for_single_dat(
datnum: int,
csq_map_datnum: Optional[int] = None,
show_2d_centering_comparsion=False,
show_1d_fit_comparison=True):
"""
Runs and can plot the comparsion of 2D centering, and 1D fitting of averaged data for NRG vs regular I_sense, either
csq mapped or not
Args:
datnum ():
csq_map_datnum (): Optional CSQ datnum for csq mapping
show_2d_centering_comparsion (): Whether to show the 2D plot with centers
show_1d_fit_comparison (): Whether to show the 1D fit and fit info
Returns:
"""
dat = get_dat(datnum)
if csq_map_datnum is not None:
csq_dat = get_dat(csq_map_datnum)
data = get_2d_i_sense_csq_mapped(dat, csq_dat)
using_csq = True
else:
data = get_2d_data(dat)
using_csq = False
if show_2d_centering_comparsion:
fig = plot_2d_i_sense(data,
title_prepend=f'Dat{dat.datnum}: ',
trace_type='heatmap',
using_csq=using_csq)
run_and_plot_center_comparsion(fig, data).show()
fits = fit_2d_transition_data(data,
fit_with='i_sense',
initial_params=None)
centers = [f.best_values.mid for f in fits]
avg_data = average_data(data, centers)
if show_1d_fit_comparison:
fig = plot_single_transition(avg_data,
title_prepend=f'Dat{dat.datnum}: ',
using_csq=using_csq)
run_and_plot_single_fit_comparison(fig, avg_data).show()
def transition_2d(self) -> go.Figure:
if not self._correct_call_args():
logger.warning(f'Bad call args to GraphCallback')
return go.Figure()
if not self.calculated_triggered or self.calculated.analysis_params.transition_only_datnum is None:
dat = self.dat
plotter = TwoD(dat=dat)
out = dat.SquareEntropy.get_row_only_output(name='default',
calculate_only=True)
x = out.x
y = dat.Data.get_data('y')
data = np.nanmean(out.cycled[:, (
0,
2,
), :], axis=1)
fig = plotter.plot(data=data,
x=x,
y=y,
title=f'Dat{dat.datnum}: 2D Cold Transition')
if self.calculated_triggered:
out = self.calculated.calculated_entropy_fit.output
x = out.x
data = np.nanmean(out.cycled[:, (
0,
2,
), :], axis=1)
ys = y_from_rows(
self.calculated.analysis_params.entropy_data_rows,
y,
mode='values')
fig.add_trace(
plotter.trace(data=data,
x=x,
y=np.linspace(ys[0], ys[1],
out.entropy_signal.shape[0])))
for h in ys:
plotter.add_line(fig, h, mode='horizontal', color='black')
else:
dat = get_dat(
self.calculated.analysis_params.transition_only_datnum)
plotter = TwoD(dat=dat)
x = dat.Transition.x
y = dat.Data.get_data('y')
data = dat.Transition.data
ys = y_from_rows(
self.calculated.analysis_params.transition_data_rows,
y,
mode='values')
fig = plotter.plot(data=data,
x=x,
y=y,
title=f'Dat{dat.datnum}: 2D Transition only')
for h in ys:
plotter.add_line(fig, h, mode='horizontal', color='black')
return fig
def plot_integrated(
datnum: int,
params: Params,
) -> go.Figure:
"""
Args:
datnum (): To get the integration info/dndt from
Returns:
"""
dat = get_dat(datnum)
out = dat.SquareEntropy.get_Outputs(name='forced_theta_linear_non_csq')
sweep_x = out.x
data_dndt = out.average_entropy_signal
int_info = dat.Entropy.get_integration_info(
name='forced_theta_linear_non_csq')
data_int = int_info.integrate(data_dndt)
data_isense_cold = np.nanmean(out.averaged[(0, 2), :], axis=0)
fit = nrg_fit(sweep_x, data_isense_cold, init_params=params)
params = Params(
gamma=fit.best_values.g,
theta=fit.best_values.theta,
center=fit.best_values.mid,
amp=fit.best_values.amp,
lin=fit.best_values.lin,
const=fit.best_values.const,
lin_occ=fit.best_values.occ_lin,
)
nrg = NRG_func_generator('int_dndt')
nrg_integrated = nrg(sweep_x, params.center, params.gamma,
params.theta) # , amp=1, lin=0, const=0, occ_lin=0)
fig = p1d.figure(xlabel='Sweep Gate (mV)', ylabel='Entropy (kB)')
for data, label in zip([data_int, nrg_integrated], ['Data', 'NRG']):
fig.add_trace(
p1d.trace(x=sweep_x / 100, data=data, mode='lines',
name=label)) # /100 to convert to real mV
for v in [np.log(2), np.log(3)]:
p1d.add_line(fig,
v,
mode='horizontal',
color='black',
linewidth=1,
linetype='dash')
fig.update_layout(template='simple_white')
return fig
def set_sf_from_transition(entropy_datnums,
transition_datnums,
fit_name,
integration_info_name,
dt_from_self=False,
fixed_dt=None,
fixed_amp=None,
experiment_name: Optional[str] = None):
for enum, tnum in progressbar(zip(entropy_datnums, transition_datnums)):
edat = get_dat(enum, exp2hdf=experiment_name)
tdat = get_dat(tnum, exp2hdf=experiment_name)
try:
_set_amplitude_from_transition_only(edat,
tdat,
fit_name,
integration_info_name,
dt_from_self=dt_from_self,
fixed_dt=fixed_dt,
fixed_amp=fixed_amp)
except (TypeError, U.NotFoundInHdfError):
print(
f'Failed to set scaling factor for dat{enum} using dat{tnum}')
def calculate_centers(self) -> str:
"""Calculates center fits for dats with option to overwrite and DOES write to HDF. Can be extremely slow!
Note: Currently only uses csq_mapped/force_theta/force_gamma... Does not use setpoint or width.
Note: Saves center fits under same name regardless of whether from CSQ mapping or not.. (should be very similar)
"""
def get_x_data(dat: DatHDF) -> Tuple[np.ndarray, np.ndarray]:
x = dat.Data.get_data('x')
data = dat.Data.get_data(
'i_sense') if not self.csq_map else e_dat.Data.get_data(
'csq_mapped')
if data.ndim == 2:
data = data[0]
return x, data
if not self.run_centers:
raise PreventUpdate
e_dat = self.dat
if e_dat is None:
raise PreventUpdate
init_x, init_data = get_x_data(e_dat)
calc_params = TransitionCalcParams(initial_x=init_x,
initial_data=init_data,
force_theta=self.force_theta,
force_gamma=self.force_gamma,
csq_mapped=self.csq_map)
# Do Center calculations
set_centers(e_dat,
self.center_func,
calc_params=calc_params,
se_data=True,
csq_mapped=self.csq_map)
if self.use_tonly:
t_dat = get_dat(self.tonly_datnum)
init_x, init_data = get_x_data(t_dat)
calc_params = TransitionCalcParams(initial_x=init_x,
initial_data=init_data,
force_theta=self.force_theta,
force_gamma=self.force_gamma,
csq_mapped=self.csq_map)
set_centers(t_dat,
self.center_func,
se_data=False,
calc_params=calc_params,
csq_mapped=self.csq_map)
return f'Done'
def _get_datas(self) -> Tuple[List[Data1D], List[float], List[float]]:
datas = []
if self.which_plot == 'data':
gammas = []
thetas = []
for k in PARAM_DATNUM_DICT:
dat = get_dat(k)
data = get_avg_entropy_data(dat,
center_func=_center_func,
csq_datnum=CSQ_DATNUM)
occ_data = get_avg_i_sense_data(dat,
CSQ_DATNUM,
center_func=_center_func)
data.x = occ_data.x
data.x -= dat.NrgOcc.get_x_of_half_occ(
fit_name=NRG_OCC_FIT_NAME)
fit = dat.NrgOcc.get_fit(name=NRG_OCC_FIT_NAME)
# data.x = data.x/fit.best_values.theta*kb*0.1 # So that difference in lever arm is taken into account
gammas.append(fit.best_values.g)
thetas.append(fit.best_values.theta)
rescale = max(fit.best_values.g, fit.best_values.theta)
datas.append(
Data1D(x=data.x / rescale, data=data.data * rescale))
elif self.which_plot == 'nrg':
gts = [0.1, 1, 5, 10, 25]
theta = 1
thetas = [theta] * len(gts)
gammas = list(np.array(gts) * theta)
for gamma in gammas:
x_width = max([gamma, theta]) * 15
pars = NRGParams(gamma=gamma, theta=theta)
data = NrgUtil().data_from_params(params=pars,
x=np.linspace(
-x_width, x_width, 501),
which_data='dndt',
which_x='sweepgate')
data.x -= get_x_of_half_occ(params=pars.to_lm_params())
data.x *= 0.0001 # Convert back to NRG units
data.data = data.data / np.sum(data.data) / np.mean(
np.diff(data.x)) * np.log(2) # Convert to real entropy
rescale = max(gamma, theta)
data.x = data.x / rescale
data.data = data.data * rescale
datas.append(data)
else:
raise NotImplementedError
return datas, gammas, thetas
def __init__(self, se_name, e_names, t_names, int_names, calculated,
datnum):
super().__init__() # Shutting up PyCharm
self.se_name: str = se_name
self.e_names: List[str] = listify_dash_input(e_names)
self.t_names: List[str] = listify_dash_input(t_names)
self.int_names: List[str] = listify_dash_input(int_names)
self.datnum: Optional[int] = datnum
self.calculated: StoreData = calculated
self.calculated_triggered = triggered_by(
self.components.store_calculated.id)
# Generated
self.dat = get_dat(datnum) if self.datnum is not None else None
def __init__(
self,
datnum,
t_fit_names, # plotting existing
calculated,
):
self.datnum: int = datnum
# plotting existing
self.t_fit_names: List[str] = listify_dash_input(t_fit_names)
self.calculated: StoreData = calculated
self.calculated_triggered = triggered_by(
self.components.store_calculated.id)
# ################# Post calculations
self.dat = get_dat(self.datnum) if self.datnum is not None else None
def do_calc(datnum):
dat = get_dat(datnum)
fit = dat.Transition.avg_fit
mid = fit.best_values.mid
width = fit.best_values.theta * 15
x1, x2 = U.get_data_index(dat.Transition.avg_x, [mid - width, mid + width],
is_sorted=True)
x = dat.Transition.avg_x[x1:x2]
data = dat.Transition.avg_data[x1:x2]
new_fit = dat.Transition.get_fit(which='avg',
name='narrow_centered',
overwrite=True,
x=x,
data=data)
print(f'Fitting Dat{dat.datnum} from {x[0]:.2f} -> {x[-1]:.2f}mV')
return new_fit
def _temp_calculate_from_non_csq():
"""Used this to recalculate the csq mapped output (used same centers because they are not really going to change
for gamma broadened anyway)"""
dat = get_dat(2170)
from dat_analysis.analysis_tools.csq_mapping import calculate_csq_map
calculate_csq_map(2170, None, 2172)
inps = dat.SquareEntropy.get_Inputs(
x_array=dat.Data.get_data('x'),
i_sense=dat.Data.get_data('csq_mapped'),
save_name='forced_theta_linear')
pp = dat.SquareEntropy.get_ProcessParams(
name='forced_theta_linear_non_csq', save_name='forced_theta_linear')
out = dat.SquareEntropy.get_Outputs(name='forced_theta_linear',
inputs=inps,
process_params=pp)
def one_d_data_subtract_fit(self):
if self.datnum:
dat = get_dat(self.datnum, exp2hdf=self.experiment_name)
plotter = OneD(dat=dat)
xlabel = 'Sweepgate /mV'
fig = plotter.figure(xlabel=xlabel, ylabel='Current /nA', title=f'Data Subtract Fit: G={self.g:.2f}mV, '
f'{THETA}={self.theta:.2f}mV, '
f'{THETA}/G={self.theta / self.g:.2f}')
for i, which in enumerate(self.which):
if 'i_sense' in which:
x, data = _get_x_and_data(self.datnum, self.experiment_name, which)
nrg_func = NRG_func_generator(which='i_sense')
nrg_data = nrg_func(x, self.mid, self.g, self.theta, self.amp, self.lin, self.const, self.occ_lin)
data_sub_nrg = data - nrg_data
fig.add_trace(plotter.trace(x=x, data=data_sub_nrg, name=f'{which} subtract NRG', mode='lines'))
return fig
return go.Figure()
def run_forced_theta_nrg_fit(
datnum: int,
csq_datnum: Optional[int],
center_func: Optional[Callable[[DatHDF], bool]] = None,
which_linear_theta_params: str = 'normal',
overwrite: bool = False,
) -> FitInfo:
"""
Runs
Args:
datnum (): Dat to calculate for
csq_datnum (): Num of dat to use for CSQ mapping (will only calculate if necessary)
center_func: Whether data should be centered first for dat
(e.g. lambda dat: True if dat.Logs.dacs['ESC'] > -250 else False)
which_linear_theta_params: str =
overwrite (): NOTE: Only overwrites final Avg fit.
Returns:
"""
if csq_datnum is not None:
fit_name = 'csq_forced_theta'
else:
fit_name = 'forced_theta'
if center_func is None:
center_func = lambda dat: False # Default to no centering for gamma broadened
dat = get_dat(datnum)
avg_data = get_avg_i_sense_data(dat, csq_datnum, center_func=center_func)
pars = get_initial_params(avg_data, which='nrg')
theta = get_linear_theta(dat, which_params=which_linear_theta_params)
pars['theta'].value = theta
pars['theta'].vary = False
pars['g'].value = 5
pars['g'].max = theta * 50 # limit of NRG data
pars['g'].min = theta / 10000 # limit of NRG data
pars['occ_lin'].vary = True
if abs((x := avg_data.x)[-1] -
x[0]) > 1500: # If it's a wider scan, only fit over middle 1500
cond = np.where(np.logical_and(x > -750, x < 750))
avg_data.x, avg_data.data = x[cond], avg_data.data[cond]
def __init__(self, datnum: int, current_value):
dat = get_dat(datnum) if datnum is not None else None
min_ = 0
max_ = 1
step = 1
marks = {}
value = (0, 1)
if dat is not None:
yshape = dat.Data.get_data('y').shape[0]
max_ = yshape - 1
marks = {int(v): str(int(v)) for v in np.linspace(min_, max_, 5)}
if current_value and all([min_ < v < max_ for v in current_value]):
value = current_value
else:
value = (min_, max_)
super().__init__(min=min_,
max=max_,
step=step,
marks=marks,
value=value)
def do_calc(datnum):
"""Just a function which can be passed to a process pool for faster calculation"""
save_name = 'SPS.0045'
dat = get_dat(datnum)
setpoints = [0.0045, None]
# Get other inputs
setpoint_times = square_wave_time_array(dat.SquareEntropy.square_awg)
sp_start, sp_fin = [U.get_data_index(setpoint_times, sp) for sp in setpoints]
logger.debug(f'Setpoint times: {setpoints}, Setpoint indexs: {sp_start, sp_fin}')
# Run Fits
pp = dat.SquareEntropy.get_ProcessParams(name=None, # Start from default and modify from there
setpoint_start=sp_start, setpoint_fin=sp_fin,
transition_fit_func=i_sense,
save_name=save_name)
out = dat.SquareEntropy.get_Outputs(name=save_name, inputs=None, process_params=pp, overwrite=False)
dat.Entropy.get_fit(which='avg', name=save_name, data=out.average_entropy_signal, x=out.x, check_exists=False)
[dat.Entropy.get_fit(which='row', row=i, name=save_name,
data=row, x=out.x, check_exists=False) for i, row in enumerate(out.entropy_signal)]
def _get_x_and_data(datnum, experiment_name, which: str) -> Tuple[np.ndarray, np.ndarray]:
if datnum:
dat = get_dat(datnum, exp2hdf=experiment_name)
try:
awg = dat.Logs.awg
se = True
except NotFoundInHdfError:
se = False
if se:
out = _get_output(datnum, experiment_name)
x = out.x
data = data_from_output(out, which)
else:
if 'i_sense' not in which:
raise NotFoundInHdfError(f'Dat{datnum} is a Transition only dat and has no {which} data.')
x = dat.Transition.x
if dat.Logs.dacs['ESC'] >= ESC_GAMMA_LIMIT:
data = np.nanmean(dat.Transition.data, axis=0)
else:
data = dat.Transition.avg_data
return x, data
else:
raise RuntimeError(f'No datnum found to load data from')
def _get_output(datnum, experiment_name) -> Output:
def calculate_se_output(dat: DatHDF):
if dat.Logs.dacs['ESC'] >= ESC_GAMMA_LIMIT: # Gamma broadened so no centering
logger.info(f'Dat{dat.datnum}: Calculating {OUTPUT_NAME} without centering')
do_entropy_calc(dat.datnum, save_name=OUTPUT_NAME, setpoint_start=OUTPUT_SETPOINT, csq_mapped=False,
experiment_name=experiment_name,
center_for_avg=False)
else: # Not gamma broadened so needs centering
logger.info(f'Dat{dat.datnum}: Calculating {OUTPUT_NAME} with centering')
do_entropy_calc(dat.datnum, save_name=OUTPUT_NAME, setpoint_start=OUTPUT_SETPOINT, csq_mapped=False,
center_for_avg=True,
experiment_name=experiment_name,
t_func_name='i_sense')
if datnum:
dat = get_dat(datnum, exp2hdf=experiment_name)
if OUTPUT_NAME not in dat.SquareEntropy.Output_names():
with thread_lock:
if OUTPUT_NAME not in dat.SquareEntropy.Output_names(): # check again in case a previous thread did this
calculate_se_output(dat)
out = dat.SquareEntropy.get_Outputs(name=OUTPUT_NAME)
else:
raise RuntimeError(f'No datnum found to load data from')
return out
# base_dt = 1.149
# ######### 100mK
# line_pars['slope'].value = 0.08866821
# line_pars['intercept'].value = 64.3754
# theta_for_dt = line.eval(x=-265, params=line_pars) # Dat2101 is the setting where DCbias was done and dT is defined
# base_dt = 0.0127 * 1000
#####
######## 50mK
# line_pars['slope'].value = 1.086e-4*1000
# line_pars['intercept'].value = 0.05184*1000
# theta_for_dt = line.eval(x=-270, params=line_pars) # dT is calculated at -270mV ESC
# base_dt = 22.8
for par in all_params:
dat = get_dat(par.transition_only_datnum)
theta = line.eval(params=line_pars, x=dat.Logs.fds['ESC'])
par.force_theta = theta
par.force_dt = base_dt * theta / theta_for_dt # Scale dT with same proportion as theta
# par.force_dt = base_dt
# if par.transition_only_datnum == 2136:
# par.force_amp = 0.52
# Do processing
general = AnalysisGeneral(params_list=all_params,
calculate=True,
overwrite_entropy=True,
overwrite_transition=True)
run_processing(general, multiprocessed=True)
for par in all_params:
# dndt_, freq = U.decimate(dndts[1], measure_freq=all_dats[1].Logs.measure_freq, numpnts=200, return_freq=True)
x_ = U.get_matching_x(dndt_datas[1].x, dndt_)
# dndt_signal(ax, xs=xs[1], datas=dndts[1])
dndt_signal(ax, xs=x_, datas=dndt_, amp_sensitivity=amps[1])
ax.set_xlim(-3, 3)
# ax.set_title('dN/dT for gamma broadened')
ax.plot(x_, nrg_fits[1].eval_fit(x=x_ * 100), label='NRG Fit')
for ax in strong_fig.axes:
ax.set_ylabel(ax.get_ylabel(), labelpad=5)
plt.tight_layout()
strong_fig.show()
# Data for single hot/cold plot
dat = get_dat(2164)
# dat = get_dat(7334)
_, avg_x = dat.NrgOcc.get_avg_data(check_exists=True, return_x=True)
sweep_x = avg_x / 100 # Convert to real mV
cold_data = get_avg_i_sense_data(dat,
None,
_center_func,
False,
hot_or_cold='cold')
hot_data = get_avg_i_sense_data(dat,
None,
_center_func,
False,
hot_or_cold='hot')
plot_transition_fitting = False
plot_transition_values = True
plot_entropy_vs_gamma = True
plot_entropy_vs_time = False
plot_amp_comparison = False
plot_csq_map_check = False
plot_stacked_square_heated = False
plot_stacked_transition = False
plot_dot_tune = False
print_info = False
# For resetting dats if something goes badly wrong
reset_dats = False
if reset_dats:
for datnum in transition_datnums + entropy_datnums + csq_datnums:
get_dat(datnum, overwrite=True)
# Calculations
gamma_scans = True
if gamma_scans:
csq_map = False
calculate = True
overwrite = False
theta = None
gamma = 0
width = None
dt_from_self = True
# dt = 1.111
dt = 1.45 * 9.423
amp = None
x_func = lambda dat: dat.Logs.fds['ESC']
data=real_data.data,
name=igor_name,
x_label='Occupation',
y_label=f'Scaled {DELTA}I (a.u.)'))
save_infos.append(
U.IgorSaveInfo(x=real_data.x,
data=fit_data.data,
name=f'{igor_name}_fit',
x_label='Occupation',
y_label=f'Scaled {DELTA}I (a.u.)'))
U.save_multiple_save_info_to_itx(filename, save_infos)
############################# Weak signal in Gamma broadened
save_infos = []
dat = get_dat(2213)
data2d = get_2d_data(dat, 'entropy')
data2d.x = data2d.x / 100 # Convert to real mV
data = Data1D(data=np.nanmean(data2d.data, axis=0), x=data2d.x)
data_single = Data1D(data=data2d.data[0], x=data2d.x)
fig = p1d.plot(data.data,
x=data.x,
xlabel='V_D (mV)',
ylabel='Delta I (nA)',
mode='lines',
trace_name='Avg Data')
fig.add_trace(
p1d.trace(data_single.data,
x=data_single.x,
