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 get_dndt_vs_occ(dat: DatHDF) -> Data1D:
data = get_avg_entropy_data(dat, lambda _: False, None)
fit = dat.NrgOcc.get_fit(name='forced_theta')
nrg = NrgUtil(NRGParams.from_lm_params(fit.params))
data.x = nrg.get_occupation_x(data.x)
data.data = data.data / np.nanmax(
U.decimate(data.data, measure_freq=dat.Logs.measure_freq, numpnts=100))
return data
def get_expected_dndt_vs_occ(dat: DatHDF) -> Data1D:
fit = dat.NrgOcc.get_fit(name='forced_theta')
nrg = NrgUtil(NRGParams.from_lm_params(fit.params))
real_data = get_avg_entropy_data(dat, lambda _: False, None)
data = nrg.data_from_params(x=real_data.x,
which_data='dndt',
which_x='occupation')
data.data = data.data / np.max(data.data)
return data
def __init__(self, dat: DatHDF):
self.dat = dat
# The averaged data which does show some signal, but quite small given the number of repeats and duration
self.avg_data = get_avg_entropy_data(self.dat, lambda _: False,
CSQ_DATNUM)
self.avg_data.x = self.avg_data.x / 100 # Convert to real mV
# Single trace of data to show how little signal for a single scan
self.data = Data1D(data=self.dat.SquareEntropy.entropy_signal[0],
x=self.dat.SquareEntropy.x)
self.data.x = self.data.x / 100 # Convert to real mV
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 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)
#############################################################################################
# Data for dN/dT
# all_dats = get_dats([2164, 2170])
all_dats = get_dats([2164, 2167])
# fit_names = ['csq_gamma_small', 'csq_forced_theta']
fit_names = ['gamma_small', 'forced_theta']
# all_dats = get_dats([2164, 2216]) # Weak, Strong coupling
# all_dats = get_dats([7334, 7356]) # Weak, Strong coupling
# all_dats = get_dats([7334, 7360]) # Weak, Strong coupling
tonly_dats = get_dats([dat.datnum + 1 for dat in all_dats])
dndt_datas, gts, nrg_fits, amps = [], [], [], []
for dat, fit_name in zip(all_dats, fit_names):
dndt = get_avg_entropy_data(dat,
center_func=_center_func,
csq_datnum=csq_datnum)
init_fit = dat.NrgOcc.get_fit(name=fit_name)
# params = NRGParams.from_lm_params(init_fit.params)
params = NRGParams.from_lm_params(
U.edit_params(init_fit.params, ['theta', 'g'],
[init_fit.best_values.theta, init_fit.best_values.g],
[False, False]))
nrg_fit = NrgUtil(inital_params=params).get_fit(x=dndt.x,
data=dndt.data,
which_data='dndt')
dndt.x = dndt.x / 100 # Convert to real mV
gt = init_fit.best_values.g / init_fit.best_values.theta
from dat_analysis.dat_object.make_dat import get_dats, get_dat
from temp import get_centered_x_at_half_occ
# csq_datnum = 2197
csq_datnum = None
# Data for weakly coupled dN/dTs
# all_dats = get_dats([2097, 2103, 2107, 2109])
all_dats = get_dats([2164])
# all_dats = get_dats([2097, 2103, 2109])
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)'])