def window_ds():
"""
Take a single DataSet and window it so that the file only contains events
near an expected peak location.
Create some temporary in/out files s/t the originals aren't overwritten.
"""
# run = 42
# ds = DataSet(run=run, md="runDB.json")
ds_num = 3
ds = DataSet(ds_num, md="runDB.json")
# specify temporary I/O locations
p_tmp = "~/Data/cage"
f_tier1 = "~/Data/cage/cage_ds3_t1.h5"
f_tier2 = "~/Data/cage/cage_ds3_t2.h5"
# figure out the uncalibrated energy range of the K40 peak
# xlo, xhi, xpb = 0, 2e6, 2000 # show phys. spectrum (top feature is 2615 pk)
xlo, xhi, xpb = 990000, 1030000, 250 # k40 peak, ds 3
t2df = ds.get_t2df()
hE, xE = ph.get_hist(t2df["energy"], range=(xlo, xhi), dx=xpb)
plt.semilogy(xE, hE, ls='steps', lw=1, c='r')
import matplotlib.ticker as ticker
plt.gca().xaxis.set_major_formatter(ticker.FormatStrFormatter('%0.4e'))
plt.locator_params(axis='x', nbins=5)
plt.xlabel("Energy (uncal.)", ha='right', x=1)
plt.ylabel("Counts", ha='right', y=1)
plt.savefig(f"./plots/cage_ds{ds_num}_winK40.pdf")
# exit()
# write a windowed tier 1 file containing only waveforms near the peak
t1df = pd.DataFrame()
for run in ds.paths:
ft1 = ds.paths[run]["t1_path"]
print(f"Scanning ds {ds_num}, run {run}\n file: {ft1}")
for chunk in pd.read_hdf(ft1, 'ORSIS3302DecoderForEnergy', chunksize=5e4):
t1df_win = chunk.loc[(chunk.energy > xlo) & (chunk.energy < xhi)]
print(t1df_win.shape)
t1df = pd.concat([t1df, t1df_win], ignore_index=True)
# -- save to HDF5 output file --
h5_opts = {
"mode":"w", # overwrite existing
"append":False,
"format":"table",
"complib":"blosc:zlib",
"complevel":1,
"data_columns":["ievt"]
}
t1df.reset_index(inplace=True)
t1df.to_hdf(f_tier1, key="df_windowed", **h5_opts)
print("wrote file:", f_tier1)
def get_spectra():
ds = DataSet(runlist=[143, 144, 145], md='./runDB.json', tier_dir=tier_dir)
t2df = ds.get_t2df()
xlo, xhi, xpb = 0, 10000, 10
xP, hP = get_hist(t2df["trap_max"], xlo, xhi, xpb)
plt.plot(xP,
hP,
ls='steps',
lw=1.5,
c='m',
label="pygama trap_max, {} cts".format(sum(hP)))
plt.xlabel("Energy (uncal)", ha='right', x=1)
plt.ylabel("Counts", ha='right', y=1)
plt.legend()
plt.tight_layout()
plt.show()
def tier2_AoverE():
"""
show the A/E distribution.
"""
run = 42
ds = DataSet(run=run, md="runDB.json")
t2df = ds.get_t2df()
aoe = t2df["current_max"] / t2df["e_ftp"]
# # 1d
# xlo, xhi, xpb = -2000, 2000, 10
# h, x = ph.get_hist(aoe, range=(xlo, xhi), dx=xpb)
# plt.semilogy(x, h, ls='steps', lw=1, c='r', label=f'run {run}')
# plt.xlabel("A/E (uncal.)", ha='right', x=1)
# plt.ylabel("Counts", ha='right', y=1)
# plt.grid(linestyle=':')
# plt.legend()
# # plt.show()
# plt.cla()
# 2d vs E
xlo, xhi, xpb = 0, 6000, 5
# ylo, yhi, ypb = 0.6, 1.2, 0.001
ylo, yhi, ypb = 0, 0.1, 0.001
nbx, nby = int((xhi - xlo) / xpb), int((yhi - ylo) / ypb)
from matplotlib.colors import LogNorm
plt.hist2d(t2df["e_ftp"],
aoe,
bins=(nbx, nby),
range=((xlo, xhi), (ylo, yhi)),
norm=LogNorm(),
cmap='jet')
# cb = plt.colorbar()
# cb.set_label("Counts", ha='right', y=1)
plt.xlabel("e_ftp (uncal.)", ha='right', x=1)
plt.ylabel("A/E", ha='right', y=1)
# plt.grid(which='both', linestyle=':')
plt.grid()
plt.savefig(f"./plots/cage_run{run}_AE.png", dpi=200)
def tier2_spec():
"""
show a few examples of energy spectra (onboard E and offline E)
"""
run = 42
ds = DataSet(run=run, md="runDB.json")
t2df = ds.get_t2df()
# print(t2df.columns)
# onboard E
ene = "energy"
# xlo, xhi, xpb = 0, 20e6, 5000 # show muon peak (full dyn. range)
xlo, xhi, xpb = 0, 2e6, 2000 # show phys. spectrum (top feature is 2615 pk)
# # trap_max E
# ene = "etrap_max"
# xlo, xhi, xpb = 0, 50000, 100 # muon peak
# xlo, xhi, xpb = 0, 6000, 10 # gamma spectrum
# # fixed time pickoff E
# ene = "e_ftp"
# # xlo, xhi, xpb = 0, 50000, 100 # muon peak
# xlo, xhi, xpb = 0, 6000, 10 # gamma spectrum
# get histogram
hE, xE = ph.get_hist(t2df[ene], range=(xlo, xhi), dx=xpb)
# make the plot
plt.semilogy(xE, hE, ls='steps', lw=1, c='r', label=f'run {run}')
plt.xlabel("Energy (uncal.)", ha='right', x=1)
plt.ylabel("Counts", ha='right', y=1)
# show a couple formatting tricks
import matplotlib.ticker as ticker
plt.gca().xaxis.set_major_formatter(ticker.FormatStrFormatter('%0.1e'))
plt.locator_params(axis='x', nbins=5)
plt.grid(linestyle=':')
plt.legend()
# plt.show()
plt.savefig(f"./plots/cage_run{run}_{ene}.pdf")
def main():
"""
perform automatic calibration of pygama DataSets.
command line options to specify the DataSet are the same as in processing.py
save results in a JSON database for access by other routines.
"""
par = argparse.ArgumentParser(description="calibration suite for tumbsi")
arg, st, sf = par.add_argument, "store_true", "store_false"
arg("-ds", nargs='*', action="store", help="load runs for a DS")
arg("-r", "--run", nargs=1, help="load a single run")
arg("-s", "--spec", action=st, help="print simple spectrum")
arg("-sc", "--cal", action=st, help="print calibrated spectrum")
arg("-p0",
"--pass0",
action=st,
help="run pass0 (single peak) calibration")
arg("-p1", "--pass1", action=st, help="run pass-1 (linear) calibration")
arg("-p2", "--pass2", action=st, help="run pass-2 (peakfit) calibration")
arg("-e",
"--etype",
nargs=1,
help="custom energy param (default is e_ftp)")
arg("-t", "--test", action=st, help="set verbose (testing) output")
arg("-w", "--writeDB", action=st, help="store results in DB")
arg("-pr", "--printDB", action=st, help="print calibration results in DB")
arg("-pa", "--path", nargs=1, help="Set Path to runDB.json file")
arg("-db", "--db", nargs=1, help="Path to runDB.json and calDB.json")
arg("-sub", "--sub", nargs=1, help="Number of Subfiles")
args = vars(par.parse_args())
etype = args["etype"][0] if args["etype"] else "e_ftp"
if args["db"]:
path_to_files = args["db"][0]
run_db, cal_db = path_to_files + "/runDB.json", path_to_files + "/calDB.json"
# -- declare the DataSet --
if args["ds"]:
ds_lo = int(args["ds"][0])
try:
ds_hi = int(args["ds"][1])
except:
ds_hi = None
ds = DataSet(ds_lo, ds_hi, 1, md=run_db, cal=cal_db, v=args["test"])
if args["run"]:
run = int(args["run"][0])
ds = DataSet(1, run, md=run_db, cal=cal_db, v=args["test"])
fp = ds.paths[run]["t2_path"].split("t2")[0]
t2_file = ds.get_t2df()
if args["sub"]:
subNumber = int(args["sub"][0])
counter = 0
for p, d, files in os.walk(ds.tier2_dir):
for f in files:
if any("{}-".format(r) in f for r in [run]):
if counter < subNumber:
t2_file = t2_file.append(pd.read_hdf(fp + f))
counter += 1
print("Whaat")
if args["spec"]:
his = t2_file.hist("e_ftp", bins=2000)
plt.yscale('log')
plt.savefig(path_to_files + 'plots/Raw.png',
bbox_inches='tight',
transperent=True)
plt.show()
if args["pass0"]:
calibrate_pass0(ds, t2_file, etype, args["writeDB"])
if args["pass1"]:
calibrate_pass1(ds, t2_file, etype, args["writeDB"], args["test"])
if args["pass2"]:
calibrate_pass2(ds, t2_file, run, cal_db, run_db, args["writeDB"])
if args["printDB"]:
show_calDB(cal_db)
if args["cal"]:
show_calspectrum(ds, t2_file, cal_db, etype, run, args["pass1"],
args["pass2"])
def resolution():
"""
fit the 208Tl 2615 keV peak and give me the resolution
test out pygama's peak fitting routines
"""
ds_num = 11
ds = DataSet(ds_num, md='./runDB.json', tier_dir=tier_dir)
t2df = ds.get_t2df()
ene = t2df["energy"].values
rt = ds.get_runtime() / 3600 # hrs
# apply calibration
cal = runDB["cal_onboard"][str(ds_num)]
m, b = cal[0], cal[1]
ene = m * ene + b
# zoom in to the area around the 2615 peak
xlo, xhi, xpb = 2565, 2665, 0.5
ene2 = ene[np.where((ene > xlo) & (ene < xhi))]
xE, hE = get_hist(ene, xlo, xhi, xpb)
# set peak bounds
guess_ene = 2615
guess_sig = 5
idxpk = np.where((xE > guess_ene - guess_sig)
& (xE > guess_ene + guess_sig))
guess_area = np.sum(hE[idxpk])
# radford_peak function pars: mu, sigma, hstep, htail, tau, bg0, a
p0 = [guess_ene, guess_sig, 1E-3, 0.7, 5, 0, guess_area]
bnd = [[0.9 * guess_ene, 0.5 * guess_sig, 0, 0, 0, 0, 0],
[1.1 * guess_ene, 2 * guess_sig, 0.1, 0.75, 10, 10, 5 * guess_area]]
pars = fit_binned(radford_peak, hE, xE, p0) #, bounds=bnd)
print("mu:", pars[0], "\n", "sig", pars[1], "\n", "hstep:", pars[2], "\n",
"htail:", pars[3], "\n", "tau:", pars[4], "\n", "bg0:", pars[5],
"\n", "a:", pars[6])
plt.plot(xE,
hE,
c='b',
ls='steps',
lw=1,
label="MJ60 data, {:.2f} hrs".format(rt))
plt.plot(xE,
radford_peak(xE, *pars),
color="r",
alpha=0.7,
label=r"Radford peak, $\sigma$={:.2f} keV".format(pars[1]))
plt.axvline(2614.511,
color='r',
alpha=0.6,
lw=1,
label=r"$E_{lit}$=2614.511")
plt.axvline(pars[0],
color='g',
alpha=0.6,
lw=1,
label=r"$E_{fit}$=%.3f" % (pars[0]))
plt.xlabel("Energy (keV)", ha='right', x=1)
plt.ylabel("Counts / {:.2f} keV".format(xpb), ha='right', y=1)
plt.legend()
plt.tight_layout()
# plt.show()
plt.savefig("./plots/kr83_resolution.pdf")
def calibrate():
"""
do a rough energy calibration
"automatic": based on finding ratios
"""
from scipy.signal import medfilt, find_peaks_cwt
from scipy.stats import linregress
pks_lit = [239, 911, 1460.820, 1764, 2614.511]
# ds = DataSet(11, md='./runDB.json', tier_dir=tier_dir)
ds = DataSet(run=204, md='./runDB.json', tier_dir=tier_dir)
t2df = ds.get_t2df()
rt = ds.get_runtime() / 3600 # hrs
ene = t2df["e_ftp"]
xlo, xhi, xpb = 0, 10000, 10 # damn, need to remove the overflow peak
nbins = int((xhi - xlo) / xpb)
hE, xE, _ = get_hist(ene, nbins, (xlo, xhi))
# xE, hE = get_hist(ene, xlo, xhi, xpb)
# -- pygama's cal routine needs some work ... --
# need to manually remove the overflow peak?
# data_peaks = get_most_prominent_peaks(ene, xlo, xhi, xpb, test=True)
# ene_peaks = get_calibration_energies("uwmjlab")
# ene_peaks = get_calibration_energies("th228")
# best_m, best_b = match_peaks(data_peaks, ene_peaks)
# ecal = best_m * t2df["trap_max"] + best_b
# -- test out a rough automatic calibration here --
npks = 15
hE_med = medfilt(hE, 21)
hE_filt = hE - hE_med
pk_width = np.arange(1, 10, 0.1)
pk_idxs = find_peaks_cwt(hE_filt, pk_width, min_snr=5)
pks_data = xE[pk_idxs]
pk_counts = hE[pk_idxs]
idx_sorted = np.argsort(pk_counts)
pk_idx_max = pk_idxs[idx_sorted[-npks:]]
pks_data = np.sort(xE[pk_idx_max])
r0 = pks_lit[4] / pks_lit[2]
# this is pretty ad hoc, should use more of the match_peaks function
found_match = False
for pk1 in pks_data:
for pk2 in pks_data:
r = pk1 / pk2
if np.fabs(r - r0) < 0.005:
print("found match to peak list:\n "
"r0 {:.3f} r {:.3f} pk1 {:.0f} pk2 {:.0f}".format(
r0, r, pk1, pk2))
found_match = True # be careful, there might be more than one
break
if found_match:
break
# # check uncalibrated spectrum
# plt.plot(xE, hE, ls='steps', lw=1, c='b')
# # plt.plot(xE, hE_filt, ls='steps', lw=1, c='b')
# # for pk in pks_data:
# # plt.axvline(pk, color='r', lw=1, alpha=0.6)
# plt.axvline(pk1, color='r', lw=1)
# plt.axvline(pk2, color='r', lw=1)
# plt.show()
# exit()
# two-point calibration
data = np.array(sorted([pk1, pk2]))
lit = np.array([pks_lit[2], pks_lit[4]])
m, b, _, _, _ = linregress(data, y=lit)
print("Paste this into runDB.json:\n ", m, b)
# err = np.sum((lit - (m * data + b))**2)
# plt.plot(data, lit, '.b', label="E = {:.2e} x + {:.2e}".format(m, b))
# xf = np.arange(data[0], data[1], 1)
# plt.plot(xf, m * xf + b, "-r")
# plt.legend()
# plt.show()
# apply calibration
ecal = m * ene + b
# # check calibrated spectrum
xlo, xhi, xpb = 0, 3000, 1
hC, xC, _ = get_hist(ecal, int((xhi - xlo) / xpb), (xlo, xhi))
hC = np.concatenate(
(hC, [0])) # FIXME: annoying - have to add an extra zero
plt.semilogy(xC,
hC / rt,
c='b',
ls='steps',
lw=1,
label="MJ60 data, {:.2f} hrs".format(rt))
plt.axvline(pks_lit[2], c='r', lw=3, alpha=0.7, label="40K, 1460.820 keV")
plt.axvline(pks_lit[4],
c='m',
lw=3,
alpha=0.7,
label="208Tl, 2614.511 keV")
plt.xlabel("Energy (keV)", ha='right', x=1)
plt.ylabel("Counts / hr / {:.2f} keV".format(xpb), ha='right', y=1)
plt.legend()
plt.tight_layout()
# plt.show()
plt.savefig("./plots/surface_spec.pdf")
# exit()
# check low-e spectrum
plt.figure()
xlo, xhi, xpb = 0, 50, 0.1
hC, xC, _ = get_hist(ecal, int((xhi - xlo) / xpb), (xlo, xhi))
hC = np.concatenate(
(hC, [0])) # FIXME: annoying - have to add an extra zero
plt.plot(xC, hC, c='b', ls='steps', lw=1, label="Kr83 data")
plt.axvline(9.4057, color='r', lw=1.5, alpha=0.6,
label="9.4057 keV") # kr83 lines
plt.axvline(12.651, color='g', lw=1.5, alpha=0.6,
label="12.651 keV") # kr83 lines
plt.xlabel("Energy (keV)", ha='right', x=1)
plt.ylabel("Counts / {:.2f} keV".format(xpb), ha='right', y=1)
plt.legend()
plt.tight_layout()
# plt.show()
plt.savefig("./plots/test_kr83_cal.pdf")
def get_multiple_spectra():
# energy (onboard)
# xlo, xhi, xpb = 0, 2000000, 1000
# xlo, xhi, xpb = 0, 500000, 1000
# xlo, xhi, xpb = 0, 50000, 100
# energy (onboard, calibrated)
xlo, xhi, xpb = 0, 40, 0.1
# trap_max
# xlo, xhi, xpb = 0, 10000, 10
# xlo, xhi, xpb = 0, 300, 0.3
# xlo, xhi, xpb = 0, 80, 0.2
# xlo, xhi, xpb = 0, 40, 0.1
# ds = DataSet(run=147, md='./runDB.json', tier_dir=tier_dir)
# get calibration
cal = runDB["cal_onboard"]["11"]
m, b = cal[0], cal[1]
ds = DataSet(10, md='./runDB.json', tier_dir=tier_dir)
rt1 = ds.get_runtime() / 3600
t2df = ds.get_t2df()
ene1 = m * t2df["energy"] + b
x, h1 = get_hist(ene1, xlo, xhi, xpb)
# x, h1 = get_hist(t2df["trap_max"], xlo, xhi, xpb)
h1 = np.divide(h1, rt1)
ds2 = DataSet(11, md='./runDB.json', tier_dir=tier_dir)
t2df2 = ds2.get_t2df()
rt2 = ds2.get_runtime() / 3600
ene2 = m * t2df2["energy"] + b
x, h2 = get_hist(ene2, xlo, xhi, xpb)
# x, h2 = get_hist(t2df2["trap_max"], xlo, xhi, xpb)
h2 = np.divide(h2, rt2)
plt.figure(figsize=(7, 5))
plt.plot(x,
h1,
ls='steps',
lw=1,
c='b',
label="bkg, {:.2f} hrs".format(rt1))
plt.plot(x,
h2,
ls='steps',
lw=1,
c='r',
label="Kr83, {:.2f} hrs".format(rt2))
plt.axvline(9.4057, color='m', lw=2, alpha=0.4,
label="9.4057 keV") # kr83 lines
plt.axvline(12.651, color='g', lw=2, alpha=0.4,
label="12.651 keV") # kr83 lines
plt.xlabel("Energy (keV)", ha='right', x=1)
plt.ylabel("Counts / hr / {:.2f} keV".format(xpb), ha='right', y=1)
plt.legend()
plt.tight_layout()
# plt.show()
# plt.savefig("./plots/krSpec_{:.0f}_{:.0f}_onboard.pdf".format(xlo,xhi))
# plt.savefig("./plots/krSpec_{:.0f}_{:.0f}_uncal.pdf".format(xlo,xhi))
plt.savefig("./plots/krSpec_{:.0f}_{:.0f}_cal.pdf".format(xlo, xhi))
def get_spectra():
with open("runDB.json") as f:
runDB = json.load(f)
tier_dir = runDB["tier_dir"]
ds = DataSet(runlist=[555], md='./runDB.json', tier_dir=tier_dir)
t2df = ds.get_t2df()
t2df = t2df.loc[t2df.e_ftp > 500] # Low energy cut
#print(t2df.columns)
# print(t2df)
# exit()
# 4 to 36 pF variable cap
rise_time = t2df["tp90"] - t2df["tp10"]
ds2 = DataSet(runlist=[556], md='./runDB.json', tier_dir=tier_dir)
t2df_2 = ds2.get_t2df()
t2df_2 = t2df_2.loc[t2df_2.e_ftp > 500]
rise_time2 = t2df_2["tp90"] - t2df_2["tp10"]
ds3 = DataSet(runlist=[554], md='./runDB.json', tier_dir=tier_dir)
t2df_3 = ds3.get_t2df()
t2df_3 = t2df_3.loc[t2df_3.e_ftp > 500]
rise_time3 = t2df_3["tp90"] - t2df_3["tp10"]
xlo, xhi, xpb = 0., 500., 1
hP, xP, _ = get_hist(rise_time, range=(xlo, xhi), dx=xpb)
hP2, xP2, _ = get_hist(rise_time2, range=(xlo, xhi), dx=xpb)
hP3, xP3, _ = get_hist(rise_time3, range=(xlo, xhi), dx=xpb)
#Note to self: for risetime histograms, use similar to above, but replace
#first parameter with rise_time!
plt.semilogy(xP[:-1] * 0.423,
hP,
ls='steps',
lw=1.5,
c='k',
label="Rise Time, Preamp 1".format(sum(hP)))
# hist = plt.hist(rise_time, bins = 1000)
plt.semilogy(xP2[:-1] * 0.423,
hP2,
ls='steps',
lw=1.5,
c='c',
label="Rise Time, Preamp 2".format(sum(hP)))
plt.semilogy(xP3[:-1] * 0.423,
hP3,
ls='steps',
lw=1.5,
c='0.5',
label="Rise Time, Preamp 0".format(sum(hP)))
plt.xlabel("Rise Time", ha='right', x=1)
plt.ylabel("Counts", ha='right', y=1)
plt.legend()
plt.tight_layout()
plt.show()
plt.savefig("Rise Time Comparison")
def psa(run, dataset, ecal, eres, peaks_of_interest):
# ds = DataSet(runlist=[191], md='./runDB.json', tier_dir=tier_dir)
ds = DataSet(ds_lo=0, md='./runDB.json', tier_dir=tier_dir)
t2 = ds.get_t2df()
# t2df = os.path.expandvars('{}/Spectrum_{}.hdf5'.format(meta_dir,run))
# t2df = pd.read_hdf(t2df, key="df")
# t2df = t2df.reset_index(drop=True)
t2 = t2.reset_index(drop=True)
print(" Energy calibration:")
cal = ecal[0] * np.asarray(t2["e_ftp"])
print(" -> 1st pass linear energy calibration done")
if (cal[1]):
cal = cal / ecal[1] - ecal[2]
print(" -> 2nd pass linear energy calibration done")
n = "current_max"
e = "e_cal"
e_over_unc = cal / np.asarray(t2["e_ftp"])
aoe0 = np.asarray(t2[n])
print(" Apply quality cuts")
Nall = len(cal)
bl0 = np.asarray(t2["bl0"])
bl1 = np.asarray(t2["bl1"])
e_over_unc = e_over_unc[(bl1 - bl0) < 2]
cal = cal[(bl1 - bl0) < 2]
aoe0 = aoe0[(bl1 - bl0) < 2]
Nqc_acc = len(cal)
print(" -> Total number of events: ", Nall)
print(" -> After quality cuts : ", Nqc_acc)
print(" -> Quality cuts rejection: ", 100 * float(Nqc_acc) / float(Nall),
"%")
aoe = aoe0 * e_over_unc / cal
print(" Compute AoE normalization curve")
aoe_norm = AoEcorrection(cal, aoe)
print(" -> parameteres (a x E + b):", aoe_norm[0], aoe_norm[1])
aoe = aoe / (aoe_norm[0] * cal + aoe_norm[1])
print(" Find the low-side A/E cut for ", 100 * dep_acc,
"% 208Tl DEP acceptance")
cut = get_aoe_cut(cal, aoe, dep_line, eres)
print(" -> cut: ", '{:1.3f}'.format(cut))
if cut == 0:
print(" -> cut not found. Exit.")
sys.exit()
print(" Compute energy spectrum after A/E cut")
cal_cut = cal[aoe >= cut]
print(" Compute survival fractions: ")
sf = np.zeros(len(peaks_of_interest))
sferr = np.zeros(len(peaks_of_interest))
for i, peak in enumerate(peaks_of_interest):
sf[i], sferr[i] = get_sf(cal, aoe, cut, peak, eres)
print(" -> ", peak, '{:2.1f}'.format(100. * sf[i]), " +/- ",
'{:2.1f}'.format(100. * sferr[i]), "%")
print(" Display hitograms")
plt.figure(2)
plt.hist2d(cal,
aoe,
bins=[2000, 400],
range=[[0, 3000], [0, 1.5]],
norm=LogNorm(),
cmap='jet')
cbar = plt.colorbar()
plt.title("Dataset {}".format(dataset))
plt.xlabel("Energy (keV)", ha='right', x=1)
plt.ylabel("A/E (a.u.)", ha='right', y=1)
cbar.ax.set_ylabel('Counts')
plt.tight_layout()
plt.savefig('./plots/aoe_versus_energy.pdf',
bbox_inches='tight',
transparent=True)
plt.show()
plt.figure(3)
hist, bins = np.histogram(cal, bins=3000, range=[0, 3000])
hist1, bins1 = np.histogram(cal_cut, bins=3000, range=[0, 3000])
plt.clf()
plt.plot(bins[1:],
hist,
color='black',
ls="steps",
linewidth=1.5,
label='all events')
plt.plot(bins1[1:],
hist1,
'-r',
ls="steps",
linewidth=1.5,
label='after A/E cut')
plt.ylabel('Counts', ha='right', y=1)
plt.xlabel('Energy (keV)', ha='right', x=1)
plt.legend(title='Calibrated Energy')
plt.yscale('log')
plt.savefig('./plots/calEnergy_spectrum_after_psa.pdf',
bbox_inches='tight',
transparent=True)
plt.show()
print("")
print(" Normal termination")
print("")
import json
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from scipy.optimize import curve_fit
from pygama import DataSet
with open("runDB.json") as f:
runDB = json.load(f)
tier_dir = runDB["tier_dir"]
ds0 = DataSet(runlist=[554], md='./runDB.json', tier_dir=tier_dir)
t2df_0 = ds0.get_t2df()
ds1 = DataSet(runlist=[555], md='./runDB.json', tier_dir=tier_dir)
t2df_1 = ds1.get_t2df()
ds2 = DataSet(runlist=[556], md='./runDB.json', tier_dir=tier_dir)
t2df_2 = ds2.get_t2df()
e_0 = t2df_0["energy"]
e_1 = t2df_1["energy"]
e_2 = t2df_2["energy"]
e_full = [0, 3.3e6]
e_pks = [1.2e6, 2.6e6]
e_K = [1.3e6, 1.36e6]
e_T = [2.35e6, 2.42e6]
h_0, edg_0 = np.histogram(e_0, bins=5000, range=e_full)
x_0 = (edg_0[:-1] + edg_0[1:]) / 2
# h_0_K,edg_0_K = np.histogram(e_0, bin=500, range=e_K)
def histograms(run):
ds = DataSet(runlist=[run], md='./runDB.json', tier_dir=tier_dir)
t2 = ds.get_t2df()
t2df = os.path.expandvars('{}/Spectrum_{}.hdf5'.format(meta_dir, run))
t2df = pd.read_hdf(t2df, key="df")
# n = "tslope_savgol"
# n = "current_max"
# n = "tslope_pz"
n = "tail_tau"
# n = "tail_amp"
e = "e_cal"
x = t2df[e]
# y = t2df[n]
y = t2df[n] / x
plt.clf()
# H, xedges, yedges = np.histogram2d(t2df["tail_tau"], t2df["e_ftp"], bins=[2000,200], range=[[0, 6600], [0, 5]])
plt.hist2d(x,
y,
bins=[1000, 200],
range=[[0, 200], [0, .001]],
norm=LogNorm(),
cmap='jet')
# plt.hist2d(x, y, bins=[1000,1000], norm=LogNorm())
# plt.scatter(H[0],H[1])
# f = plt.figure(figsize=(20,5))
# p1 = f.add_subplot(111, title='Test', xlabel='Energy (keV)', ylabel=n)
# h1,xedg1,yedg1 = np.histogram2d(x, y, bins=[1000,200], range=[[0,2000],[0,100]])
# h1 = h1.T
# # hMin, hMax = np.amin(h1), np.amax(h1)
# # im1 = p1.imshow(h1,cmap='jet',vmin=hMin,vmax=hMax, aspect='auto') #norm=LogNorm())
# im1 = p1.imshow(h1,cmap='jet', origin='lower', aspect='auto', norm=LogNorm(), extent=[xedg1[0], xedg1[-1], yedg1[0], yedg1[-1]])
# cb1 = f.colorbar(im1, ax=p1)#, fraction=0.037, pad=0.04)
cbar = plt.colorbar()
# plt.xscale('symlog')
# plt.yscale('symlog')
plt.title("Run {}".format(run))
plt.xlabel("Energy (keV)", ha='right', x=1)
plt.ylabel(n, ha='right', y=1)
# cbar.ax.set_ylabel('Counts')
# plt.ylabel("tslope_savgol", ha='right', y=1)
# plt.ylabel("A/E_ftp", ha='right', y=1)
# plt.tight_layout()
# # plt.savefig('./plots/meeting_plots/run{}_{}_vs_{}.png'.format(run, n, e))
# plt.show()
# xlo, xhi, xpb = 0, 10000, 10
# xP, hP = get_hist(t2df["trap_max"], xlo, xhi, xpb)
#
# plt.plot(xP, hP, ls='steps', lw=1.5, c='m',
# label="pygama trap_max, {} cts".format(sum(hP)))
# plt.xlabel("Energy (uncal)", ha='right', x=1)
# plt.ylabel("Counts", ha='right', y=1)
# plt.legend()
plt.tight_layout()
plt.show()