def process_histomass_single(self, index):
myfile = TFile.Open(self.l_histomass[index], "recreate")
dfevtorig = pickle.load(openfile(self.l_evtorig[index], "rb"))
neventsorig = len(dfevtorig)
if self.s_trigger is not None:
dfevtorig = dfevtorig.query(self.s_trigger)
neventsaftertrigger = len(dfevtorig)
if self.runlistrigger is not None:
dfevtorig = selectdfrunlist(dfevtorig, \
self.run_param[self.runlistrigger], "run_number")
neventsafterrunsel = len(dfevtorig)
dfevtevtsel = dfevtorig.query(self.s_evtsel)
#validation plot for event selection
neventsafterevtsel = len(dfevtevtsel)
histonorm = TH1F("histonorm", "histonorm", 10, 0, 10)
histonorm.SetBinContent(1, neventsorig)
histonorm.GetXaxis().SetBinLabel(1, "tot events")
histonorm.SetBinContent(2, neventsaftertrigger)
histonorm.GetXaxis().SetBinLabel(2, "tot events after trigger")
histonorm.SetBinContent(3, neventsafterrunsel)
histonorm.GetXaxis().SetBinLabel(3, "tot events after run sel")
histonorm.SetBinContent(4, neventsafterevtsel)
histonorm.GetXaxis().SetBinLabel(4, "tot events after evt sel")
for ibin2 in range(len(self.lvar2_binmin)):
binneddf = seldf_singlevar_inclusive(dfevtevtsel, self.v_var2_binning_gen, \
self.lvar2_binmin[ibin2], self.lvar2_binmax[ibin2])
histonorm.SetBinContent(5 + ibin2, len(binneddf))
histonorm.GetXaxis().SetBinLabel(5 + ibin2, \
"tot events after mult sel %d - %d" % \
(self.lvar2_binmin[ibin2], self.lvar2_binmax[ibin2]))
histonorm.Write()
labeltrigger = "hbit%svs%s" % (self.triggerbit,
self.v_var2_binning_gen)
myfile.cd()
hsel, hnovtxmult, hvtxoutmult = \
self.gethistonormforselevt_mult(dfevtorig, dfevtevtsel, \
labeltrigger, self.v_var2_binning_gen)
if self.usetriggcorrfunc is not None and self.mcordata == "data":
hselweight, hnovtxmultweight, hvtxoutmultweight = \
self.gethistonormforselevt_mult(dfevtorig, dfevtevtsel, \
labeltrigger, self.v_var2_binning_gen, self.usetriggcorrfunc)
hselweight.Write()
hnovtxmultweight.Write()
hvtxoutmultweight.Write()
hsel.Write()
hnovtxmult.Write()
hvtxoutmult.Write()
list_df_recodtrig = []
for ipt in range(self.p_nptfinbins): # pylint: disable=too-many-nested-blocks
bin_id = self.bin_matching[ipt]
df = pickle.load(
openfile(self.mptfiles_recoskmldec[bin_id][index], "rb"))
if self.s_evtsel is not None:
df = df.query(self.s_evtsel)
if self.s_trigger is not None:
df = df.query(self.s_trigger)
if self.runlistrigger is not None:
df = selectdfrunlist(df, \
self.run_param[self.runlistrigger], "run_number")
if self.doml is True:
df = df.query(self.l_selml[bin_id])
list_df_recodtrig.append(df)
df = seldf_singlevar(df, self.v_var_binning, \
self.lpt_finbinmin[ipt], self.lpt_finbinmax[ipt])
if self.do_custom_analysis_cuts:
df = self.apply_cuts_ptbin(df, ipt)
for ibin2 in range(len(self.lvar2_binmin)):
suffix = "%s%d_%d_%.2f%s_%.2f_%.2f" % \
(self.v_var_binning, self.lpt_finbinmin[ipt],
self.lpt_finbinmax[ipt], self.lpt_probcutfin[bin_id],
self.v_var2_binning, self.lvar2_binmin[ibin2], self.lvar2_binmax[ibin2])
curr_dir = myfile.mkdir(f"bin1_{ipt}_bin2_{ibin2}")
meta_info = create_meta_info(
self.v_var_binning, self.lpt_finbinmin[ipt],
self.lpt_finbinmax[ipt], self.v_var2_binning,
self.lvar2_binmin[ibin2], self.lvar2_binmax[ibin2],
self.lpt_probcutfin[bin_id])
write_meta_info(curr_dir, meta_info)
h_invmass = TH1F("hmass" + suffix, "", self.p_num_bins,
self.p_mass_fit_lim[0],
self.p_mass_fit_lim[1])
h_invmass_weight = TH1F("h_invmass_weight" + suffix, "",
self.p_num_bins,
self.p_mass_fit_lim[0],
self.p_mass_fit_lim[1])
df_bin = seldf_singlevar_inclusive(df, self.v_var2_binning, \
self.lvar2_binmin[ibin2], self.lvar2_binmax[ibin2])
fill_hist(h_invmass, df_bin.inv_mass)
if self.usetriggcorrfunc is not None and self.mcordata == "data":
weights = self.make_weights(
df_bin[self.v_var2_binning_gen], self.weightfunc,
self.weighthist, self.usetriggcorrfunc)
weightsinv = [1. / weight for weight in weights]
fill_hist(h_invmass_weight,
df_bin.inv_mass,
weights=weightsinv)
myfile.cd()
h_invmass.Write()
h_invmass_weight.Write()
if self.mcordata == "mc":
df_bin[self.v_ismcrefl] = np.array(tag_bit_df(
df_bin, self.v_bitvar, self.b_mcrefl),
dtype=int)
df_bin_sig = df_bin[df_bin[self.v_ismcsignal] == 1]
df_bin_refl = df_bin[df_bin[self.v_ismcrefl] == 1]
h_invmass_sig = TH1F("hmass_sig" + suffix, "",
self.p_num_bins,
self.p_mass_fit_lim[0],
self.p_mass_fit_lim[1])
h_invmass_refl = TH1F("hmass_refl" + suffix, "",
self.p_num_bins,
self.p_mass_fit_lim[0],
self.p_mass_fit_lim[1])
fill_hist(h_invmass_sig, df_bin_sig.inv_mass)
fill_hist(h_invmass_refl, df_bin_refl.inv_mass)
myfile.cd()
h_invmass_sig.Write()
h_invmass_refl.Write()
if self.event_cand_validation is True:
df_recodtrig = pd.concat(list_df_recodtrig)
df_recodtrig = df_recodtrig.query("inv_mass>%f and inv_mass<%f" % \
(self.mass - 0.15, self.mass + 0.15))
dfevtwithd = pd.merge(dfevtevtsel,
df_recodtrig,
on=self.v_evtmatch)
label = "h%s" % self.v_var2_binning_gen
histomult = TH1F(label, label, self.nbinshisto, self.minvaluehisto,
self.maxvaluehisto)
fill_hist(histomult, dfevtevtsel[self.v_var2_binning_gen])
histomult.Write()
labelwithd = "h%s_withd" % self.v_var2_binning_gen
histomultwithd = TH1F(labelwithd, labelwithd, self.nbinshisto,
self.minvaluehisto, self.maxvaluehisto)
fill_hist(histomultwithd,
dfevtwithd["%s_x" % self.v_var2_binning_gen])
histomultwithd.Write()
# Validation histograms
fill_validation_vertex(dfevtorig, dfevtevtsel,
df_recodtrig).write()
fill_validation_multiplicity(dfevtorig, dfevtevtsel,
df_recodtrig).write()
fill_validation_candidates(df_recodtrig).write()
if self.mcordata == "mc":
fill_validation_candidates(
df_recodtrig[df_recodtrig[self.v_ismcsignal] == 1],
"MC").write()
def process_efficiency_single(self, index):
out_file = TFile.Open(self.l_histoeff[index], "recreate")
h_list = []
for ibin2 in range(len(self.lvar2_binmin)):
stringbin2 = "_%s_%.2f_%.2f" % (self.v_var2_binning_gen,
self.lvar2_binmin[ibin2],
self.lvar2_binmax[ibin2])
n_bins = len(self.lpt_finbinmin)
analysis_bin_lims_temp = self.lpt_finbinmin.copy()
analysis_bin_lims_temp.append(self.lpt_finbinmax[n_bins - 1])
analysis_bin_lims = array.array('f', analysis_bin_lims_temp)
def make_histo(name,
title,
name_extra=stringbin2,
bins=n_bins,
binning=analysis_bin_lims):
histo = TH1F(name + name_extra, title, bins, binning)
h_list.append(histo)
return histo
h_gen_pr = make_histo("h_gen_pr",
"Prompt Generated in acceptance |y|<0.5")
h_presel_pr = make_histo("h_presel_pr",
"Prompt Reco in acc |#eta|<0.8 and sel")
h_presel_pr_wotof = make_histo(
"h_presel_pr_wotof",
"Prompt Reco in acc woTOF |#eta|<0.8 and pre-sel")
h_presel_pr_wtof = make_histo(
"h_presel_pr_wtof",
"Prompt Reco in acc wTOF |#eta|<0.8 and pre-sel")
h_sel_pr = make_histo(
"h_sel_pr", "Prompt Reco and sel in acc |#eta|<0.8 and sel")
h_sel_pr_wotof = make_histo(
"h_sel_pr_wotof",
"Prompt Reco and sel woTOF in acc |#eta|<0.8")
h_sel_pr_wtof = make_histo(
"h_sel_pr_wtof", "Prompt Reco and sel wTOF in acc |#eta|<0.8")
h_gen_fd = make_histo("h_gen_fd",
"FD Generated in acceptance |y|<0.5")
h_presel_fd = make_histo("h_presel_fd",
"FD Reco in acc |#eta|<0.8 and sel")
h_sel_fd = make_histo("h_sel_fd",
"FD Reco and sel in acc |#eta|<0.8 and sel")
bincounter = 0
for ipt in range(self.p_nptfinbins):
bin_id = self.bin_matching[ipt]
df_mc_reco = pickle.load(
openfile(self.mptfiles_recoskmldec[bin_id][index], "rb"))
if self.s_evtsel is not None:
df_mc_reco = df_mc_reco.query(self.s_evtsel)
if self.s_trigger is not None:
df_mc_reco = df_mc_reco.query(self.s_trigger)
if self.runlistrigger is not None:
df_mc_reco = selectdfrunlist(df_mc_reco, \
self.run_param[self.runlistrigger], "run_number")
df_mc_gen = pickle.load(
openfile(self.mptfiles_gensk[bin_id][index], "rb"))
df_mc_gen = df_mc_gen.query(self.s_presel_gen_eff)
if self.runlistrigger is not None:
df_mc_gen = selectdfrunlist(df_mc_gen, \
self.run_param[self.runlistrigger], "run_number")
df_mc_reco = seldf_singlevar(df_mc_reco, self.v_var_binning, \
self.lpt_finbinmin[ipt], self.lpt_finbinmax[ipt])
df_mc_gen = seldf_singlevar(df_mc_gen, self.v_var_binning, \
self.lpt_finbinmin[ipt], self.lpt_finbinmax[ipt])
# Whether or not to cut on the 2nd binning variable
if self.mc_cut_on_binning2:
df_mc_reco = seldf_singlevar_inclusive(df_mc_reco, self.v_var2_binning_gen, \
self.lvar2_binmin[ibin2], self.lvar2_binmax[ibin2])
df_mc_gen = seldf_singlevar_inclusive(df_mc_gen, self.v_var2_binning_gen, \
self.lvar2_binmin[ibin2], self.lvar2_binmax[ibin2])
df_gen_sel_pr = df_mc_gen[df_mc_gen.ismcprompt == 1]
df_reco_presel_pr = df_mc_reco[df_mc_reco.ismcprompt == 1]
df_reco_sel_pr = None
if self.doml is True:
df_reco_sel_pr = df_reco_presel_pr.query(
self.l_selml[bin_id])
else:
df_reco_sel_pr = df_reco_presel_pr.copy()
df_gen_sel_fd = df_mc_gen[df_mc_gen.ismcfd == 1]
df_reco_presel_fd = df_mc_reco[df_mc_reco.ismcfd == 1]
df_reco_sel_fd = None
if self.doml is True:
df_reco_sel_fd = df_reco_presel_fd.query(
self.l_selml[bin_id])
else:
df_reco_sel_fd = df_reco_presel_fd.copy()
def set_content(df_to_use,
histogram,
i_b=ibin2,
b_c=bincounter):
if self.corr_eff_mult[i_b] is True:
val, err = self.get_reweighted_count(df_to_use, i_b)
else:
val = len(df_to_use)
err = math.sqrt(val)
histogram.SetBinContent(b_c + 1, val)
histogram.SetBinError(b_c + 1, err)
set_content(df_gen_sel_pr, h_gen_pr)
if "nsigTOF_Pr_0" in df_reco_presel_pr:
set_content(
df_reco_presel_pr[
df_reco_presel_pr.nsigTOF_Pr_0 < -998],
h_presel_pr_wotof)
set_content(
df_reco_presel_pr[
df_reco_presel_pr.nsigTOF_Pr_0 > -998],
h_presel_pr_wtof)
set_content(df_reco_presel_pr, h_presel_pr)
set_content(df_reco_sel_pr, h_sel_pr)
if "nsigTOF_Pr_0" in df_reco_sel_pr:
set_content(
df_reco_sel_pr[df_reco_sel_pr.nsigTOF_Pr_0 < -998],
h_sel_pr_wotof)
set_content(
df_reco_sel_pr[df_reco_sel_pr.nsigTOF_Pr_0 > -998],
h_sel_pr_wtof)
set_content(df_gen_sel_fd, h_gen_fd)
set_content(df_reco_presel_fd, h_presel_fd)
set_content(df_reco_sel_fd, h_sel_fd)
bincounter = bincounter + 1
out_file.cd()
for h in h_list:
h.Write()
h_list = []
def process_efficiency_single(self, index):
out_file = TFile.Open(self.l_histoeff[index], "recreate")
for ibin2 in range(len(self.lvar2_binmin)):
stringbin2 = "_%s_%.2f_%.2f" % (self.v_var2_binning_gen, \
self.lvar2_binmin[ibin2], \
self.lvar2_binmax[ibin2])
n_bins = len(self.lpt_finbinmin)
analysis_bin_lims_temp = self.lpt_finbinmin.copy()
analysis_bin_lims_temp.append(self.lpt_finbinmax[n_bins - 1])
analysis_bin_lims = array.array('f', analysis_bin_lims_temp)
h_gen_pr = TH1F("h_gen_pr" + stringbin2, "Prompt Generated in acceptance |y|<0.5", \
n_bins, analysis_bin_lims)
h_presel_pr = TH1F("h_presel_pr" + stringbin2, "Prompt Reco in acc |#eta|<0.8 and sel", \
n_bins, analysis_bin_lims)
h_sel_pr = TH1F("h_sel_pr" + stringbin2, "Prompt Reco and sel in acc |#eta|<0.8 and sel", \
n_bins, analysis_bin_lims)
h_gen_fd = TH1F("h_gen_fd" + stringbin2, "FD Generated in acceptance |y|<0.5", \
n_bins, analysis_bin_lims)
h_presel_fd = TH1F("h_presel_fd" + stringbin2, "FD Reco in acc |#eta|<0.8 and sel", \
n_bins, analysis_bin_lims)
h_sel_fd = TH1F("h_sel_fd" + stringbin2, "FD Reco and sel in acc |#eta|<0.8 and sel", \
n_bins, analysis_bin_lims)
bincounter = 0
for ipt in range(self.p_nptfinbins):
bin_id = self.bin_matching[ipt]
df_mc_reco = pickle.load(
openfile(self.mptfiles_recoskmldec[bin_id][index], "rb"))
if self.s_evtsel is not None:
df_mc_reco = df_mc_reco.query(self.s_evtsel)
if self.s_trigger is not None:
df_mc_reco = df_mc_reco.query(self.s_trigger)
if self.runlistrigger is not None:
df_mc_reco = selectdfrunlist(df_mc_reco, \
self.run_param[self.runlistrigger], "run_number")
df_mc_gen = pickle.load(
openfile(self.mptfiles_gensk[bin_id][index], "rb"))
df_mc_gen = df_mc_gen.query(self.s_presel_gen_eff)
if self.runlistrigger is not None:
df_mc_gen = selectdfrunlist(df_mc_gen, \
self.run_param[self.runlistrigger], "run_number")
df_mc_reco = seldf_singlevar(df_mc_reco, self.v_var_binning, \
self.lpt_finbinmin[ipt], self.lpt_finbinmax[ipt])
df_mc_gen = seldf_singlevar(df_mc_gen, self.v_var_binning, \
self.lpt_finbinmin[ipt], self.lpt_finbinmax[ipt])
df_mc_reco = seldf_singlevar_inclusive(df_mc_reco, self.v_var2_binning_gen, \
self.lvar2_binmin[ibin2], self.lvar2_binmax[ibin2])
df_mc_gen = seldf_singlevar_inclusive(df_mc_gen, self.v_var2_binning_gen, \
self.lvar2_binmin[ibin2], self.lvar2_binmax[ibin2])
df_gen_sel_pr = df_mc_gen[df_mc_gen.ismcprompt == 1]
df_reco_presel_pr = df_mc_reco[df_mc_reco.ismcprompt == 1]
df_reco_sel_pr = None
if self.doml is True:
df_reco_sel_pr = df_reco_presel_pr.query(
self.l_selml[bin_id])
else:
df_reco_sel_pr = df_reco_presel_pr.copy()
df_gen_sel_fd = df_mc_gen[df_mc_gen.ismcfd == 1]
df_reco_presel_fd = df_mc_reco[df_mc_reco.ismcfd == 1]
df_reco_sel_fd = None
if self.doml is True:
df_reco_sel_fd = df_reco_presel_fd.query(
self.l_selml[bin_id])
else:
df_reco_sel_fd = df_reco_presel_fd.copy()
if self.corr_eff_mult[ibin2] is True:
val, err = self.get_reweighted_count(df_gen_sel_pr)
h_gen_pr.SetBinContent(bincounter + 1, val)
h_gen_pr.SetBinError(bincounter + 1, err)
val, err = self.get_reweighted_count(df_reco_presel_pr)
h_presel_pr.SetBinContent(bincounter + 1, val)
h_presel_pr.SetBinError(bincounter + 1, err)
val, err = self.get_reweighted_count(df_reco_sel_pr)
h_sel_pr.SetBinContent(bincounter + 1, val)
h_sel_pr.SetBinError(bincounter + 1, err)
#print("prompt efficiency tot ptbin=", bincounter, ", value = ",
# len(df_reco_sel_pr)/len(df_gen_sel_pr))
val, err = self.get_reweighted_count(df_gen_sel_fd)
h_gen_fd.SetBinContent(bincounter + 1, val)
h_gen_fd.SetBinError(bincounter + 1, err)
val, err = self.get_reweighted_count(df_reco_presel_fd)
h_presel_fd.SetBinContent(bincounter + 1, val)
h_presel_fd.SetBinError(bincounter + 1, err)
val, err = self.get_reweighted_count(df_reco_sel_fd)
h_sel_fd.SetBinContent(bincounter + 1, val)
h_sel_fd.SetBinError(bincounter + 1, err)
#print("fd efficiency tot ptbin=", bincounter, ", value = ",
# len(df_reco_sel_fd)/len(df_gen_sel_fd))
else:
val = len(df_gen_sel_pr)
err = math.sqrt(val)
h_gen_pr.SetBinContent(bincounter + 1, val)
h_gen_pr.SetBinError(bincounter + 1, err)
val = len(df_reco_presel_pr)
err = math.sqrt(val)
h_presel_pr.SetBinContent(bincounter + 1, val)
h_presel_pr.SetBinError(bincounter + 1, err)
val = len(df_reco_sel_pr)
err = math.sqrt(val)
h_sel_pr.SetBinContent(bincounter + 1, val)
h_sel_pr.SetBinError(bincounter + 1, err)
val = len(df_gen_sel_fd)
err = math.sqrt(val)
h_gen_fd.SetBinContent(bincounter + 1, val)
h_gen_fd.SetBinError(bincounter + 1, err)
val = len(df_reco_presel_fd)
err = math.sqrt(val)
h_presel_fd.SetBinContent(bincounter + 1, val)
h_presel_fd.SetBinError(bincounter + 1, err)
val = len(df_reco_sel_fd)
err = math.sqrt(val)
h_sel_fd.SetBinContent(bincounter + 1, val)
h_sel_fd.SetBinError(bincounter + 1, err)
bincounter = bincounter + 1
out_file.cd()
h_gen_pr.Write()
h_presel_pr.Write()
h_sel_pr.Write()
h_gen_fd.Write()
h_presel_fd.Write()
h_sel_fd.Write()
