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_N_vs_sweepgate(dat: DatHDF, fit_name: str = 'gamma_small') -> Data1D:
"""Quick fn for Josh, to get Occupation vs sweep to see that peak is at 2/3"""
fit = dat.NrgOcc.get_fit(name=fit_name)
nrg = NrgUtil(NRGParams.from_lm_params(fit.params))
x = dat.NrgOcc.avg_x
occ = nrg.data_from_params(x=x, which_data='occupation')
occ.x = occ.x / 100 # Convert to real mV
return occ
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 _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_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 nrg_data(self,
params: NRGParams,
x: np.ndarray,
which_data: str = 'dndt',
which_x: str = 'occupation',
real_data: Optional[np.ndarray] = None,
which_fit_data: str = 'i_sense') -> Data1D:
"""For NRG data only"""
nrg_generator = NrgUtil(inital_params=params)
if real_data is not None:
fit = nrg_generator.get_fit(x=x,
data=real_data,
which_data=which_fit_data)
params = NRGParams.from_lm_params(fit.params)
return nrg_generator.data_from_params(params,
x=x,
which_data=which_data,
which_x=which_x)
def get_nrg_integrated(dat: DatHDF) -> Data1D:
from temp import get_avg_i_sense_data, get_centered_x_at_half_occ, get_centers, get_2d_data
from dat_analysis.analysis_tools.nrg import NrgUtil, NRGParams
# i_data = get_avg_i_sense_data(dat, None, _center_func, overwrite=False, hot_or_cold='hot')
data2d = get_2d_data(dat, hot_or_cold='cold', csq_datnum=None)
if _center_func(dat):
centers = get_centers(dat, data2d, name=None, overwrite=False)
else:
centers = [0] * data2d.data.shape[0]
hot_data2d = get_2d_data(dat, hot_or_cold='hot', csq_datnum=None)
avg_data, avg_x = dat.NrgOcc.get_avg_data(x=data2d.x,
data=hot_data2d.data,
centers=centers,
return_x=True,
name='hot_cold_centers',
check_exists=False,
overwrite=False)
i_data = Data1D(avg_x, avg_data)
i_data.x = get_centered_x_at_half_occ(dat,
None,
fit_name='csq_forced_theta')
init_fit = dat.NrgOcc.get_fit(name='csq_forced_theta')
new_pars = U.edit_params(init_fit.params, ['theta', 'g'], [None, None],
vary=[True, False])
nrg = NrgUtil(None)
new_fit = nrg.get_fit(i_data.x,
i_data.data,
initial_params=new_pars,
which_data='i_sense')
expected_data = nrg.data_from_params(NRGParams.from_lm_params(
new_fit.params),
x=i_data.x,
which_data='dndt')
expected_data.data = np.cumsum(expected_data.data)
expected_data.data = expected_data.data / expected_data.data[-1] * np.log(
2)
expected_data.x = expected_data.x / 100 # Convert to real mV
return expected_data
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
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
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] +
datas=[data.data for data in datas],
labels=[f'{gt:.1f}' for gt in gts])
for data in fit_datas:
ax.plot(data.x, data.data, label='fit')
ax.set_xlim(-5, 5)
plt.tight_layout()
fig.show()
################################################################
# Data for occupation data
from temp import get_avg_i_sense_data, get_centered_x_at_half_occ
from dat_analysis.analysis_tools.nrg import NrgUtil, NRGParams
nrg_fit_name = nrg_fit_name # Use same as above
entropy_dats = entropy_dats # Use same as above
nrg = NrgUtil()
# which = 'occupation' # i_sense or occupation
which = 'i_sense' # i_sense or occupation
datas = []
nrg_datas = []
fits = []
for dat in entropy_dats:
data = get_avg_i_sense_data(dat, csq_datnum, None, hot_or_cold='hot')
data.x = get_centered_x_at_half_occ(dat,
csq_datnum=csq_datnum,
fit_name=nrg_fit_name)
data.data = U.decimate(data.data,
measure_freq=dat.Logs.measure_freq,
numpnts=200)
data.x = U.get_matching_x(data.x, data.data)