def main():
#for i in range(5000):
# m_nonl3 = samplePar_new(kA3, kB3, kC3, es3, kAerr3, kBerr3, kCerr3, eserr3)
# #m_nonl2 = samplePar(kA2, kC2, es2, kAerr2, kCerr2, eserr2)
# plt.plot(Etrue, m_nonl3, "-", color="lightskyblue", alpha=1)
# #plt.plot(Etrue, m_nonl2, "-", color="pink", alpha=0.01)
#plt.plot(Etrue, nominal_new(es3), "-", color="coral", label="nominal")
#plt.plot(Etrue, bestfit_new(kA3, kB3, kC3, es3), "--", color="blueviolet", label="best fit")
##plt.plot(Etrue, bestfit(kA2, kC2, es2), "--", color="deeppink", label="best fit: gamma+B12")
#plt.legend()
#plt.xlabel(r"$E_{true}$/MeV")
#plt.ylabel(r"$E_{vis}/E_{true}$")
##plt.semilogy()
##plt.savefig("nonlCurve_fit_B12+gam.pdf")
#plt.show()
sigma1 = sample_corelation("../output/params/covar1_nonlres_gamB12.txt")
#sigma2 = sample_corelation("../covar1.txt")
for i in range(5000):
kA = kA6 + sigma1[0, i]
kB = kB6 + sigma1[1, i]
A2 = A26 + sigma1[2, i]
A3 = A36 + sigma1[3, i]
A4 = A46 + sigma1[4, i]
es = es6 + sigma1[5, i]
m_nonl = []
for i in Etrue:
m_nonl.append( (kA * eloader.getQPE(i, kB, es) + cerpe_func(i, A2, A3, A4) ) )
plt.plot(Etrue, m_nonl, "-", color="lightskyblue", alpha=0.1)
m_nonl_bestfit1 = []
for i in Etrue:
m_nonl_bestfit1.append( kA6 * eloader.getQPE(i, kB6, es6) + cerpe_func(i, A26, A36, A46) )
print(m_nonl_bestfit1[-1], m_nonl_bestfit2[-1])
plt.plot(Etrue, m_nonl_bestfit1, "--", color="coral", label="best fit: simulation cerenkov")
#plt.plot(Etrue, nominal_new(es3), "-", color="coral", label="nominal")
plt.legend()
plt.xlabel(r"$E_{true}$/MeV")
plt.ylabel(r"$E_{vis}/E_{true}$")
plt.grid(True)
plt.title("Electron Nonlinearity")
#plt.semilogx()
plt.savefig("nonlCurve_fit_B12+gam_kBfit.pdf")
plt.show()
"""
def nominal_new(es):
m_kA = 1
m_kC = 1
m_kB = 0.0065
m_es = es
m_nonl = []
for i in Etrue:
m_nonl.append( (m_kA * eloader.getQPE(i, m_kB, m_es) + m_kC * eloader.getCerNPE(i)) / i / m_es )
m_nonl = np.array(m_nonl)
return m_nonl
def bestfit_new(kA, kB, kC, es):
m_kA = kA
m_kB = kB
m_kC = kC
m_es = es
m_nonl = []
for i in Etrue:
#m_nonl.append( (m_kA * eloader.getQPE(i, m_kB, m_es) + m_kC * eloader.getCerNPE(i)) / i / m_es )
m_nonl.append( (m_kA * eloader.getQPE(i, m_kB, m_es) + m_kC * eloader.getCerNPE(i)) )
m_nonl = np.array(m_nonl)
return m_nonl
def sctpe_sim(E, kB, scale):
return eloader.getQPE(E, kB, scale)
def main():
path = []
path.append(
"/junofs/users/miaoyu/energy_model/production/J19v1r0-Pre4/positron/e+1MeV/"
)
path.append(
"/junofs/users/miaoyu/energy_model/production/J19v1r0-Pre4/positron/e+2MeV/"
)
path.append(
"/junofs/users/miaoyu/energy_model/production/J19v1r0-Pre4/positron/e+3MeV/"
)
path.append(
"/junofs/users/miaoyu/energy_model/production/J19v1r0-Pre4/positron/e+5MeV/"
)
path.append(
"/junofs/users/miaoyu/energy_model/production/J19v1r0-Pre4/positron/e+8MeV/"
)
KE = [1, 2, 3, 5, 8]
totE = [2.022, 3.022, 4.022, 6.022, 9.022]
low = [2000, 3500, 5000, 8000, 12000]
high = [4000, 5500, 7000, 9000, 14000]
gam_mu, gam_sigma = 1321.197, 38.484
evis = []
nonl_sim, nonlerr_sim, nonl_calc, nonlerr_calc, nonlmaxerr_calc = [], [], [], [[], []], []
res_sim, reserr_sim, res_calc, reserr_calc, resmaxerr_calc = [], [], [], [
[], []
], []
nonldiff, nonldiff_err = [], []
resdiff, resdiff_err = [], []
nonlmin_calc = [
1431.8381389757549 + gam_mu, 2913.0388007609768 + gam_mu,
4401.233268426745 + gam_mu, 7371.814214576139 + gam_mu,
11823.149593869492 + gam_mu
]
nonlmax_calc = [
1437.8121664943255 + gam_mu, 2925.5246537477137 + gam_mu,
4420.31365383517 + gam_mu, 7404.033416866311 + gam_mu,
11875.027720320764 + gam_mu
]
nonlmin_calc = np.array(nonlmin_calc)
nonlmax_calc = np.array(nonlmax_calc)
resmin_calc = [
1498.913928982478, 3235.138681521096, 5155.421562764596,
9495.534628055557, 16740.93191173247
]
resmax_calc = [
1681.2479261177136, 3604.857079158652, 5855.433378370916,
11364.529454522733, 22447.7253381445
]
resmin_calc = np.array(resmin_calc)
resmax_calc = np.array(resmax_calc)
resmin_calc = np.sqrt(resmin_calc + gam_sigma**2)
resmax_calc = np.sqrt(resmax_calc + gam_sigma**2)
global_es = 3134.078 / 2.223
for i in range(5):
#for i in range(len(path)):
# root data loading
############################################################
filename = path[i] + "user.root"
totpe = loadTotalPE(filename)
npe, npe_err, sigma, sigma_err = gaussFit(totpe, low[i], high[i])
#print(npe, npe_err, sigma ,sigma_err)
nonl_sim.append(npe / (KE[i] + 1.022) / global_es)
nonlerr_sim.append(npe_err / (KE[i] + 1.022) / global_es)
res_sim.append(sigma / npe)
reserr_sim.append(
np.sqrt(sigma_err**2 / npe**2 + npe_err**2 * sigma**2 / npe**4))
#plt.hist(totpe, bins=100, density=True, label=str(KE[i])+" MeV")
# model prediction
############################################################
sctpe_elec = el.getQPE(KE[i], kB, A)
cerpe_elec = kC * el.getCerNPE(KE[i])
pesigma_elec = PESigma(sctpe_elec + cerpe_elec, 0, p1, p2)
ntotpe = sctpe_elec + cerpe_elec + gam_mu
evis.append(ntotpe / es)
totsigma = np.sqrt(pesigma_elec**2 + gam_sigma**2)
nonl_calc.append(ntotpe / (KE[i] + 1.022) / global_es)
res_calc.append(totsigma / ntotpe)
nonlerr_calc[0].append(nonl_calc[-1] - nonlmin_calc[i] /
(KE[i] + 1.022) / global_es)
nonlerr_calc[1].append(nonlmax_calc[i] / (KE[i] + 1.022) / global_es -
nonl_calc[-1])
if nonlerr_calc[0][-1] < nonlerr_calc[1][-1]:
nonlmaxerr_calc.append(nonlerr_calc[1][-1])
else:
nonlmaxerr_calc.append(nonlerr_calc[0][-1])
nonldiff.append((nonl_calc[-1] - nonl_sim[-1]) / nonl_sim[-1])
nonldiff_err.append(
np.sqrt(nonlerr_sim[-1]**2 * nonl_calc[-1]**2 / nonl_sim[-1]**4))
#nonldiff_err.append( np.sqrt(nonlerr_sim[-1]**2 * nonl_calc[-1]**2 / nonl_sim[-1]**4 + nonlmaxerr_calc[-1]**2/nonl_sim[-1]**2 ) )
reserr_calc[0].append(res_calc[-1] - resmin_calc[i] / ntotpe)
reserr_calc[1].append(resmax_calc[i] / ntotpe - res_calc[-1])
if reserr_calc[0][-1] < reserr_calc[1][-1]:
resmaxerr_calc.append(reserr_calc[1][-1])
else:
resmaxerr_calc.append(reserr_calc[0][-1])
resdiff.append((res_calc[-1] - res_sim[-1]) / res_sim[-1])
resdiff_err.append(
np.sqrt(reserr_sim[-1]**2 * res_calc[-1]**2 / res_sim[-1]**4))
#resdiff_err.append( np.sqrt(reserr_sim[-1]**2 * res_calc[-1]**2 / res_sim[-1]**4 + resmaxerr_calc[-1]**2/res_sim[-1]**2 ) )
#plotx = np.arange(totpe-10*totsigma, totpe+10*totsigma, 1)
#ploty = []
#for k in plotx:
# ploty.append(gauss(k, totpe, totsigma))
#plt.plot(plotx, ploty, "-")
fig = plt.figure(figsize=(12, 6))
spec = gridspec.GridSpec(ncols=2, nrows=2, height_ratios=[1, 2])
ax0 = fig.add_subplot(spec[0])
ax1 = fig.add_subplot(spec[1])
ax2 = fig.add_subplot(spec[2])
ax3 = fig.add_subplot(spec[3])
ax2.plot(totE, nonl_calc, "-", color='royalblue', label="Calculation")
ax2.errorbar(totE,
nonl_sim,
yerr=nonlerr_sim,
fmt="o",
ms=5,
color='magenta',
label="Simulation")
ax2.grid(True)
ax2.set_xlabel(r"$E_{dep}$/MeV", fontsize=15)
ax2.set_ylabel(r"$E_{vis}/E_{dep}$", fontsize=15)
ax0.errorbar(totE, nonldiff, yerr=nonldiff_err, fmt="o", color="peru")
ax0.set_ylabel("relative bias", fontsize=15)
ax0.fill_between([0, 10], [-0.001, -0.001], [0.001, 0.001],
color="royalblue",
alpha=0.3)
ax0.hlines(0, 0, 10, linestyle="--", color="red")
ax0.text(2.5,
0.002,
"0.1% uncertainty band",
color="darkviolet",
fontsize=13)
ax0.set_ylim(-0.004, 0.004)
ax3.plot(evis, res_calc, "-", color="royalblue", label="Best fit")
ax3.errorbar(evis,
res_sim,
yerr=reserr_sim,
fmt="o",
ms=5,
color='magenta',
label="Simulation")
ax3.grid(True)
ax3.set_xlabel(r"$E_{vis}$/MeV", fontsize=15)
ax3.set_ylabel(r"$\sigma/N_{tot}$", fontsize=15)
ax1.errorbar(evis, resdiff, yerr=resdiff_err, fmt="o", color="peru")
ax1.set_ylabel("relative bias", fontsize=15)
ax1.fill_between([0, 10], [-0.04, -0.04], [0.04, 0.04],
color="royalblue",
alpha=0.3)
ax1.hlines(0, 0, 10, linestyle="--", color="red")
ax1.text(2.5,
0.05,
"4.0% uncertainty band",
color="darkviolet",
fontsize=13)
ax1.set_ylim(-0.1, 0.1)
plt.savefig("posiModel.pdf")
plt.show()
def main():
#########################################
###### Truth
# Electrons:
Etrue_elec, tot_elec, sct_elec, cer_elec, npe_elec, ncer_elec = [], [], [], [], [], []
for i in [100, 200, 320, 400, 501, 583, 702, 789]:
filename = "/junofs/users/miaoyu/energy_model/production/J19v1r0-Pre4/electron/user-" + str(
i) + ".root"
stdSct, stdCer, stdTot, edep, totpe, cerpe = fileDealing(filename)
Etrue_elec.append(edep)
tot_elec.append(stdTot)
sct_elec.append(stdSct)
cer_elec.append(stdCer)
npe_elec.append(totpe)
ncer_elec.append(cerpe)
Etrue_elec = np.array(Etrue_elec)
tot_elec = np.array(tot_elec)
sct_elec = np.array(sct_elec)
cer_elec = np.array(cer_elec)
npe_elec = np.array(npe_elec)
ncer_elec = np.array(ncer_elec)
# Positron :
Etrue_posi, tot_posi, sct_posi, cer_posi, npe_posi, ncer_posi = [], [], [], [], [], []
for i in range(1, 80, 10):
filename = "/junofs/users/miaoyu/energy_model/production/J19v1r0-Pre4/positron/user-" + str(
i) + ".root"
stdSct, stdCer, stdTot, edep, totpe, cerpe = fileDealing(filename)
Etrue_posi.append(edep)
tot_posi.append(stdTot)
sct_posi.append(stdSct)
cer_posi.append(stdCer)
npe_posi.append(totpe)
ncer_posi.append(cerpe)
Etrue_posi = np.array(Etrue_posi)
tot_posi = np.array(tot_posi)
sct_posi = np.array(sct_posi)
cer_posi = np.array(cer_posi)
npe_posi = np.array(npe_posi)
ncer_posi = np.array(ncer_posi)
# Gamma :
# From gamma_decomp.py outputs:
sigma1_gam = [
135.75754411290345, 214.08054787476925, 701.0206474514603,
1465.5137067971593, 3233.109245421706, 4032.931805211035
]
sigma2_gam = [
856.3847286529768, 1100.8440713142763, 2069.100274912067,
3385.8515058172984, 7797.8901612275795, 11827.917014913259
]
Etrue_gam, tot_gam, sct_gam, cer_gam, npe_gam, ncer_gam = [], [], [], [], [], []
names = ['Cs137', "Mn54", "K40", 'nH', 'AmBe', 'AmC']
for j in range(6):
Sct, Cer, Tot, edep, npe = [], [], [], [], []
for i in range(10):
filename = "/junofs/users/miaoyu/energy_model/production/J19v1r0-Pre4/gamma/" + names[
j] + "/user-" + str(i) + ".root"
tmpSct, tmpCer, tmpTot, tmpedep = fileLoading(filename)
for i in range(len(tmpSct)):
Sct.append(tmpSct[i])
Cer.append(tmpCer[i])
Tot.append(tmpTot[i])
edep.append(tmpedep[i])
Etrue_gam.append(np.mean(edep))
tot_gam.append(np.std(Tot))
sct_gam.append(np.std(Sct))
cer_gam.append(np.std(Cer))
npe_gam.append(np.mean(Tot))
ncer_gam.append(np.mean(Cer))
Etrue_gam = np.array(Etrue_gam)
tot_gam = np.array(tot_gam)
sct_gam = np.array(sct_gam)
cer_gam = np.array(cer_gam)
npe_gam = np.array(npe_gam)
ncer_gam = np.array(ncer_gam)
global_es = 3134.078 / 2.223
fig, ax0 = plt.subplots()
ax0.plot(Etrue_elec,
ncer_elec / npe_elec,
"^-",
lw=2,
ms=8,
color="coral",
label=r"$e^-$")
ax0.plot(Etrue_posi,
ncer_posi / npe_posi,
"^-.",
lw=2,
ms=8,
color="blue",
label=r"$e^+$")
ax0.plot(Etrue_gam,
ncer_gam / npe_gam,
"^--",
lw=2,
ms=8,
color="seagreen",
label=r"Single $\gamma$")
######################## Fitting
kB, Asct, kC = 6.26e-3, 1408, 0.996
# electron
elecFitNPE, elecFitCNPE = [], []
for i in npe_elec:
E = i / global_es
elecFitNPE.append(el.getCerNPE(E) * kC + el.getQPE(E, kB, Asct))
print(i, elecFitNPE[-1])
elecFitCNPE.append(el.getCerNPE(E) * kC)
elecFitNPE = np.array(elecFitNPE)
elecFitCNPE = np.array(elecFitCNPE)
ax0.plot(Etrue_elec,
elecFitCNPE / elecFitNPE,
"o",
lw=2,
mfc="w",
ms=6,
color="coral")
# gamma
name = ["Cs137", "Mn54", "K40", "nH", "AmBe", "AmC"]
Etrue = [0.662, 0.835, 1.461, 2.223, 4.43, 6.13]
gamFitNPE, gamFitCNPE = [], []
sGamArr = []
Cs137 = singleGamma("Cs137")
sGamArr.append(Cs137)
Mn54 = singleGamma("Mn54")
sGamArr.append(Mn54)
K40 = singleGamma("K40")
sGamArr.append(K40)
nH = singleGamma("nH")
sGamArr.append(nH)
AmBe = singleGamma("AmBe")
sGamArr.append(AmBe)
AmC = singleGamma("AmC")
sGamArr.append(AmC)
sigmaTot2, sigmaPart12, sigmaPart22 = [], [], []
for i in sGamArr:
i.ModelPrediction()
#sigmaTot2.append(i.getSPE()**2)
#sigmaPart12.append(i.getSigmaPart1())
#sigmaPart22.append(i.getSigmaPart2())
#print(sigmaTot2[-1], sigmaPart12[-1], sigmaPart22[-1])
gamFitNPE.append(i.getNPE())
gamFitCNPE.append(i.getCNPE())
print(i.getName(), gamFitCNPE[-1], gamFitNPE[-1])
gamFitNPE = np.array(gamFitNPE)
gamFitCNPE = np.array(gamFitCNPE)
ax0.plot(Etrue_gam,
gamFitCNPE / gamFitNPE,
"o",
mfc="w",
lw=2,
ms=6,
color="seagreen")
# positron
posiFitNPE, posiFitCNPE = [], []
for E in Etrue_posi:
E -= 2 * 0.511
posiFitNPE.append(
el.getCerNPE(E) * kC + el.getQPE(E, kB, Asct) + 2 * 660.8)
print(i, posiFitNPE[-1])
posiFitCNPE.append(el.getCerNPE(E) * kC + 2.49)
posiFitNPE = np.array(posiFitNPE)
posiFitCNPE = np.array(posiFitCNPE)
ax0.plot(Etrue_posi,
posiFitCNPE / posiFitNPE,
"o",
lw=2,
mfc="w",
ms=6,
color="blue")
ax0.tick_params(axis='both', which='major', labelsize=13)
ax0.set_xlabel(r"$E_{dep}$[MeV]", fontsize=16)
ax0.set_ylabel(r"$E_{Cer}/E_{dep}$", fontsize=16)
#axmin = npe_gam.min()-100
#axmax = npe_posi.max()+100
#ax0.set_xlim(axmin, axmax)
ax0.grid(True)
ax0.set_xlim(0, 9)
ax0.set_ylim(0., 0.07)
p1, = ax0.plot(12, 1, "o", mfc="w", ms=6, color="dimgray")
p2, = ax0.plot(12, 1, "^", ms=8, color="dimgray")
legend1 = ax0.legend([p1, p2], ["Model", "Simulation truth"],
loc="center right",
prop={"size": 14},
ncol=1)
ax0.add_artist(legend1)
ax0.legend(loc="lower right", prop={"size": 14})
plt.tight_layout()
plt.savefig("CerRatioThreePar.pdf")
npeSim = []
speSim = []
for i in Edep:
npeSim.append(el.getNPE(i))
speSim.append(el.getSPE(i))
npeSim = np.array(npeSim)
speSim = np.array(speSim)
nonlSim = npeSim / Edep / globalES
resSim = speSim/npeSim
# fitting results
npeCalc = []
npeCalc1 = []
speCalc = []
for i in Edep:
sctpe = el.getQPE(i, kB, A)
cerpe = kC * el.getCerNPE(i)
npeCalc.append((sctpe+cerpe))
speCalc.append(np.sqrt(p1*(sctpe+cerpe) + p2*(sctpe+cerpe)**2))
for i in Edep1:
sctpe = el.getQPE(i, kB, A)
cerpe = kC * el.getCerNPE(i)
npeCalc1.append((sctpe+cerpe))
npeCalc = np.array(npeCalc)
npeCalc1 = np.array(npeCalc1)
speCalc = np.array(speCalc)
nonlCalc = npeCalc / Edep / globalES
nonlCalc1 = npeCalc1 / Edep1 / globalES
resCalc = speCalc/npeCalc
import numpy as np
import elecLoader as el
import matplotlib.pyplot as plt
kB1, es1, kC1 = 6.29e-3, 1408.45, 0.991
kB2, es2, kC2 = 6.03479e-3, 1404.65, 1.02747
Etrue = np.arange(0.1, 15, 0.1)
npe_sim = []
cerpe_sim, sctpe_sim = [], []
npe1, npe2 = [], []
for i in Etrue:
npe1.append(el.getQPE(i, kB1, es1) + kC1 * el.getCerNPE(i))
npe2.append(el.getQPE(i, kB2, es2) + kC2 * el.getCerNPE(i))
npe_sim.append(el.getNPE(i))
cerpe_sim.append(el.getCerNPE(i))
sctpe_sim.append(el.getSctNPE(i))
sctpe_sim = np.array(sctpe_sim)
cerpe_sim = np.array(cerpe_sim)
npe1 = np.array(npe1)
npe2 = np.array(npe2)
npe_sim = np.array(npe_sim)
scale = 1400
plt.plot(Etrue, npe1 / Etrue / scale, label="previous")
#plt.plot(Etrue, npe2/Etrue/scale, "--", label="w/15MeV gamma")
plt.plot(Etrue, npe_sim / Etrue / scale, label="sim")
plt.semilogx()
#plt.semilogy()
plt.legend()
def getFitSNPE(self, Etrue):
NPE = eloader.getQPE(Etrue, self.kB, self.Asct)
return NPE
def getFitNPE(self, Etrue):
NPE = eloader.getQPE(Etrue, self.kB,
self.Asct) + self.kC * eloader.getCerNPE(Etrue)
return NPE
