def process_histomass(self):
myfile = TFile.Open(self.n_filemass, "recreate")
for ipt in range(self.p_nptfinbins):
bin_id = self.bin_matching[ipt]
df = pickle.load(openfile(self.lpt_recodecmerged[bin_id], "rb"))
df = df.query(self.l_selml[bin_id])
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)
df = seldf_singlevar(df, self.v_var_binning, \
self.lpt_finbinmin[ipt], self.lpt_finbinmax[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])
h_invmass = TH1F("hmass" + suffix, "", self.p_num_bins,
self.p_mass_fit_lim[0], self.p_mass_fit_lim[1])
df_bin = seldf_singlevar(df, self.v_var2_binning,
self.lvar2_binmin[ibin2], self.lvar2_binmax[ibin2])
fill_hist(h_invmass, df_bin.inv_mass)
myfile.cd()
h_invmass.Write()
if "pt_jet" in df_bin.columns:
zarray = z_calc(df_bin.pt_jet, df_bin.phi_jet, df_bin.eta_jet,
df_bin.pt_cand, df_bin.phi_cand, df_bin.eta_cand)
h_zvsinvmass = TH2F("hzvsmass" + suffix, "", 5000, 1.00, 6.00, 2000, -0.5, 1.5)
zvsinvmass = np.vstack((df_bin.inv_mass, zarray)).T
fill_hist(h_zvsinvmass, zvsinvmass)
h_zvsinvmass.Write()
def process_histomass(self):
myfile = TFile.Open(self.n_filemass, "recreate")
for ipt in range(self.p_nptfinbins):
bin_id = self.bin_matching[ipt]
df = pickle.load(openfile(self.lpt_recodecmerged[bin_id], "rb"))
df = df.query(self.l_selml[bin_id])
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)
df = seldf_singlevar(df, self.v_var_binning, \
self.lpt_finbinmin[ipt], self.lpt_finbinmax[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])
h_invmass = TH1F("hmass" + suffix, "", self.p_num_bins,
self.p_mass_fit_lim[0],
self.p_mass_fit_lim[1])
df_bin = seldf_singlevar(df, self.v_var2_binning,
self.lvar2_binmin[ibin2],
self.lvar2_binmax[ibin2])
weights = None
#apply_weights = self.datap["analysis"][self.typean]["triggersel"]["weights"]
#if apply_weights is not None:
# filenorm = TFile.Open("norm.root", "read")
# hnorm = filenorm.Get("hnorm_" + apply_weights[0] + "_" + apply_weights[1])
# weights = [hnorm.GetBinContent(hnorm.FindBin(_bin)) \
# for _bin in df_bin[apply_weights[0]]]
fill_hist(h_invmass, df_bin.inv_mass, weights=weights)
myfile.cd()
h_invmass.Write()
if "pt_jet" in df_bin.columns:
zarray = z_calc(df_bin.pt_jet, df_bin.phi_jet,
df_bin.eta_jet, df_bin.pt_cand,
df_bin.phi_cand, df_bin.eta_cand)
h_zvsinvmass = TH2F("hzvsmass" + suffix, "", 5000, 1.00,
6.00, 2000, -0.5, 1.5)
zvsinvmass = np.vstack((df_bin.inv_mass, zarray)).T
fill_hist(h_zvsinvmass, zvsinvmass)
h_zvsinvmass.Write()
def process_response(self):
"""
First of all, we load all the mc gen and reco files that are skimmed
in bins of HF candidate ptand we apply the standard selection to all
of them. After this, we merged them all to create a single file of gen
and reco monte carlo sample with all the HF candidate pt. In particular
gen jets are selected according to run trigger, runlist, and gen jet
zbin_recoand pseudorapidity. Reco candidates according to evt selection, eta
jets, trigger and ml probability of the HF hadron
"""
zbin_reco = []
nzbin_reco = self.p_nbinshape_reco
zbin_reco = self.varshaperanges_reco
zbinarray_reco = array.array('d', zbin_reco)
zbin_gen = []
nzbin_gen = self.p_nbinshape_gen
zbin_gen = self.varshaperanges_gen
zbinarray_gen = array.array('d', zbin_gen)
jetptbin_reco = []
njetptbin_reco = self.p_nbin2_reco
jetptbin_reco = self.var2ranges_reco
jetptbinarray_reco = array.array('d', jetptbin_reco)
jetptbin_gen = []
njetptbin_gen = self.p_nbin2_gen
jetptbin_gen = self.var2ranges_gen
jetptbinarray_gen = array.array('d', jetptbin_gen)
candptbin = []
candptbin = self.lpt_finbinmin.copy()
candptbin.append(self.lpt_finbinmax[-1])
candptbinarray = array.array('d', candptbin)
out_file = TFile.Open(self.n_fileeff, "update")
list_df_mc_reco = []
list_df_mc_gen = []
for iptskim, _ in enumerate(self.lpt_anbinmin):
df_mc_gen = pickle.load(openfile(self.lpt_gendecmerged[iptskim], "rb"))
df_mc_gen = selectdfrunlist(df_mc_gen, \
self.run_param[self.runlistrigger[self.triggerbit]], "run_number")
df_mc_gen = df_mc_gen.query(self.s_jetsel_gen)
list_df_mc_gen.append(df_mc_gen)
df_mc_reco = pickle.load(openfile(self.lpt_recodecmerged[iptskim], "rb"))
if self.s_evtsel is not None:
df_mc_reco = df_mc_reco.query(self.s_evtsel)
if self.s_jetsel_reco is not None:
df_mc_reco = df_mc_reco.query(self.s_jetsel_reco)
if self.s_trigger is not None:
df_mc_reco = df_mc_reco.query(self.s_trigger)
if self.doml is True:
df_mc_reco = df_mc_reco.query(self.l_selml[iptskim])
list_df_mc_reco.append(df_mc_reco)
# Here we can merge the dataframes corresponding to different HF pt in a
# single one. In addition we are here selecting only non prompt HF
df_gen = pd.concat(list_df_mc_gen)
df_mc_reco = pd.concat(list_df_mc_reco)
# add the z columns
df_gen["z"] = z_calc(df_gen.pt_jet, df_gen.phi_jet, df_gen.eta_jet,
df_gen.pt_cand, df_gen.phi_cand, df_gen.eta_cand)
df_mc_reco["z"] = z_calc(df_mc_reco.pt_jet, df_mc_reco.phi_jet, df_mc_reco.eta_jet,
df_mc_reco.pt_cand, df_mc_reco.phi_cand, df_mc_reco.eta_cand)
df_mc_reco["z_gen"] = z_gen_calc(df_mc_reco.pt_gen_jet, df_mc_reco.phi_gen_jet,
df_mc_reco.eta_gen_jet, df_mc_reco.pt_gen_cand,
df_mc_reco.delta_phi_gen_jet, df_mc_reco.delta_eta_gen_jet)
df_gen_nonprompt = df_gen[df_gen.ismcfd == 1]
df_gen_prompt = df_gen[df_gen.ismcprompt == 1]
df_mc_reco_merged_nonprompt = df_mc_reco[df_mc_reco.ismcfd == 1]
df_mc_reco_merged_prompt = df_mc_reco[df_mc_reco.ismcprompt == 1]
# The following plots are 3d plots all at generated level of z,
# pt_jet and pt_cand. This was used in the first version of the feeddown
# subtraction, currently is obsolete
hzvsjetpt_gen_unmatched = TH2F("hzvsjetpt_gen_unmatched", "hzvsjetpt_gen_unmatched", \
nzbin_gen, zbinarray_gen, njetptbin_gen, jetptbinarray_gen)
df_zvsjetpt_gen_unmatched = df_gen_prompt.loc[:, [self.v_varshape_binning, "pt_jet"]]
fill_hist(hzvsjetpt_gen_unmatched, df_zvsjetpt_gen_unmatched)
hzvsjetpt_gen_unmatched.Write()
titlehist = "hzvsjetptvscandpt_gen_nonprompt"
hzvsjetptvscandpt_gen_nonprompt = makefill3dhist(df_gen_nonprompt, titlehist, \
zbinarray_gen, jetptbinarray_gen, candptbinarray, self.v_varshape_binning, "pt_jet", "pt_cand")
hzvsjetptvscandpt_gen_nonprompt.Write()
# hz_gen_nocuts is the distribution of generated z values in b in
# bins of gen_jet pt before the reco z and jetpt selection. hz_gen_cuts
# also includes cut on z reco and jet pt reco. These are used for overall
# efficiency correction to estimate the fraction of candidates that are
# in the reco range but outside the gen range and viceversa
for ibin2 in range(self.p_nbin2_gen):
suffix = "%s_%.2f_%.2f" % \
(self.v_var2_binning, self.lvar2_binmin_gen[ibin2], self.lvar2_binmax_gen[ibin2])
hz_gen_nocuts = TH1F("hz_gen_nocuts_nonprompt" + suffix, \
"hz_gen_nocuts_nonprompt" + suffix, nzbin_gen, zbinarray_gen)
hz_gen_nocuts.Sumw2()
hz_gen_cuts = TH1F("hz_gen_cuts_nonprompt" + suffix,
"hz_gen_cuts_nonprompt" + suffix, nzbin_gen, zbinarray_gen)
hz_gen_cuts.Sumw2()
df_tmp = seldf_singlevar(df_mc_reco_merged_nonprompt, "pt_gen_jet", \
self.lvar2_binmin_gen[ibin2], self.lvar2_binmax_gen[ibin2])
df_tmp = seldf_singlevar(df_tmp, self.v_varshape_binning_gen, \
self.lvarshape_binmin_gen[0], self.lvarshape_binmax_gen[-1])
fill_hist(hz_gen_nocuts, df_tmp[self.v_varshape_binning_gen])
df_tmp = seldf_singlevar(df_tmp, "pt_jet",
self.lvar2_binmin_reco[0], self.lvar2_binmax_reco[-1])
df_tmp = seldf_singlevar(df_tmp, self.v_varshape_binning,
self.lvarshape_binmin_reco[0], self.lvarshape_binmax_reco[-1])
fill_hist(hz_gen_cuts, df_tmp[self.v_varshape_binning_gen])
hz_gen_cuts.Write()
hz_gen_nocuts.Write()
# Addendum for unfolding
hz_gen_nocuts_pr = TH1F("hz_gen_nocuts" + suffix, \
"hz_gen_nocuts" + suffix, nzbin_gen, zbinarray_gen)
hz_gen_nocuts_pr.Sumw2()
hz_gen_cuts_pr = TH1F("hz_gen_cuts" + suffix,
"hz_gen_cuts" + suffix, nzbin_gen, zbinarray_gen)
hz_gen_cuts_pr.Sumw2()
df_tmp_pr = seldf_singlevar(df_mc_reco_merged_prompt, "pt_gen_jet", \
self.lvar2_binmin_gen[ibin2], self.lvar2_binmax_gen[ibin2])
df_tmp_pr = seldf_singlevar(df_tmp_pr, self.v_varshape_binning_gen, \
self.lvarshape_binmin_gen[0], self.lvarshape_binmax_gen[-1])
fill_hist(hz_gen_nocuts_pr, df_tmp_pr[self.v_varshape_binning_gen])
df_tmp_pr = seldf_singlevar(df_tmp_pr, "pt_jet",
self.lvar2_binmin_reco[0], self.lvar2_binmax_reco[-1])
df_tmp_pr = seldf_singlevar(df_tmp_pr, self.v_varshape_binning,
self.lvarshape_binmin_reco[0], self.lvarshape_binmax_reco[-1])
fill_hist(hz_gen_cuts_pr, df_tmp_pr[self.v_varshape_binning_gen])
hz_gen_cuts_pr.Write()
hz_gen_nocuts_pr.Write()
# End addendum for unfolding
df_tmp_selgen, df_tmp_selreco, df_tmp_selrecogen = \
self.create_df_closure(df_mc_reco_merged_nonprompt)
df_tmp_selgen_pr, df_tmp_selreco_pr, df_tmp_selrecogen_pr = \
self.create_df_closure(df_mc_reco_merged_prompt)
# histograms for response of feeddown
hzvsjetpt_reco_nocuts = \
build2dhisto("hzvsjetpt_reco_nocuts_nonprompt", zbinarray_reco, jetptbinarray_reco)
hzvsjetpt_reco_cuts = \
build2dhisto("hzvsjetpt_reco_cuts_nonprompt", zbinarray_reco, jetptbinarray_reco)
hzvsjetpt_gen_nocuts = \
build2dhisto("hzvsjetpt_gen_nocuts_nonprompt", zbinarray_gen, jetptbinarray_gen)
hzvsjetpt_gen_cuts = \
build2dhisto("hzvsjetpt_gen_cuts_nonprompt", zbinarray_gen, jetptbinarray_gen)
hzvsjetpt_reco = hzvsjetpt_reco_nocuts.Clone("hzvsjetpt_reco_nonprompt")
hzvsjetpt_gen = hzvsjetpt_gen_nocuts.Clone("hzvsjetpt_genv")
response_matrix = RooUnfoldResponse(hzvsjetpt_reco, hzvsjetpt_gen)
fill2dhist(df_tmp_selreco, hzvsjetpt_reco_nocuts, self.v_varshape_binning, "pt_jet")
fill2dhist(df_tmp_selgen, hzvsjetpt_gen_nocuts, self.v_varshape_binning_gen, "pt_gen_jet")
fill2dhist(df_tmp_selrecogen, hzvsjetpt_reco_cuts, self.v_varshape_binning, "pt_jet")
fill2dhist(df_tmp_selrecogen, hzvsjetpt_gen_cuts, self.v_varshape_binning_gen, "pt_gen_jet")
hzvsjetpt_reco_nocuts.Write()
hzvsjetpt_gen_nocuts.Write()
hzvsjetpt_reco_cuts.Write()
hzvsjetpt_gen_cuts.Write()
# histograms for unfolding
hzvsjetpt_reco_nocuts_pr = \
build2dhisto("hzvsjetpt_reco_nocuts", zbinarray_reco, jetptbinarray_reco)
hzvsjetpt_reco_cuts_pr = \
build2dhisto("hzvsjetpt_reco_cuts", zbinarray_reco, jetptbinarray_reco)
hzvsjetpt_gen_nocuts_pr = \
build2dhisto("hzvsjetpt_gen_nocuts", zbinarray_gen, jetptbinarray_gen)
hzvsjetpt_gen_cuts_pr = \
build2dhisto("hzvsjetpt_gen_cuts", zbinarray_gen, jetptbinarray_gen)
fill2dhist(df_tmp_selreco_pr, hzvsjetpt_reco_nocuts_pr, self.v_varshape_binning, "pt_jet")
fill2dhist(df_tmp_selgen_pr, hzvsjetpt_gen_nocuts_pr, self.v_varshape_binning_gen, "pt_gen_jet")
fill2dhist(df_tmp_selrecogen_pr, hzvsjetpt_reco_cuts_pr, self.v_varshape_binning, "pt_jet")
fill2dhist(df_tmp_selrecogen_pr, hzvsjetpt_gen_cuts_pr, self.v_varshape_binning_gen, "pt_gen_jet")
hzvsjetpt_reco_nocuts_pr.Write()
hzvsjetpt_gen_nocuts_pr.Write()
hzvsjetpt_reco_cuts_pr.Write()
hzvsjetpt_gen_cuts_pr.Write()
hzvsjetpt_reco_closure_pr = \
build2dhisto("hzvsjetpt_reco_closure", zbinarray_reco, jetptbinarray_reco)
hzvsjetpt_gen_closure_pr = \
build2dhisto("hzvsjetpt_gen_closure", zbinarray_reco, jetptbinarray_reco)
hzvsjetpt_reco_pr = \
build2dhisto("hzvsjetpt_reco", zbinarray_reco, jetptbinarray_reco)
hzvsjetpt_gen_pr = \
build2dhisto("hzvsjetpt_gen", zbinarray_gen, jetptbinarray_gen)
response_matrix_pr = RooUnfoldResponse(hzvsjetpt_reco_pr, hzvsjetpt_gen_pr)
response_matrix_closure_pr = RooUnfoldResponse(hzvsjetpt_reco_pr, hzvsjetpt_gen_pr)
fill2dhist(df_tmp_selreco_pr, hzvsjetpt_reco_pr, self.v_varshape_binning, "pt_jet")
fill2dhist(df_tmp_selgen_pr, hzvsjetpt_gen_pr, self.v_varshape_binning_gen, "pt_gen_jet")
hzvsjetpt_reco_pr.Write()
hzvsjetpt_gen_pr.Write()
hjetpt_gen_nocuts_pr = TH1F("hjetpt_gen_nocuts", \
"hjetpt_gen_nocuts", njetptbin_gen, jetptbinarray_gen)
hjetpt_gen_cuts_pr = TH1F("hjetpt_gen_cuts", \
"hjetpt_gen_cuts", njetptbin_gen, jetptbinarray_gen)
hjetpt_gen_nocuts_closure = TH1F("hjetpt_gen_nocuts_closure", \
"hjetpt_gen_nocuts_closure", njetptbin_gen, jetptbinarray_gen)
hjetpt_gen_cuts_closure = TH1F("hjetpt_gen_cuts_closure", \
"hjetpt_gen_cuts_closure", njetptbin_gen, jetptbinarray_gen)
hjetpt_gen_nocuts_pr.Sumw2()
hjetpt_gen_cuts_pr.Sumw2()
hjetpt_gen_nocuts_closure.Sumw2()
hjetpt_gen_nocuts_closure.Sumw2()
fill_hist(hjetpt_gen_nocuts_pr, df_tmp_selgen_pr["pt_gen_jet"])
fill_hist(hjetpt_gen_cuts_pr, df_tmp_selrecogen_pr["pt_gen_jet"])
hjetpt_gen_nocuts_pr.Write()
hjetpt_gen_cuts_pr.Write()
# end of histograms for unfolding
hjetpt_genvsreco_full = \
TH2F("hjetpt_genvsreco_full_nonprompt", "hjetpt_genvsreco_full_nonprompt", \
njetptbin_gen * 100, self.lvar2_binmin_gen[0], self.lvar2_binmax_gen[-1], \
njetptbin_reco * 100, self.lvar2_binmin_reco[0], self.lvar2_binmax_reco[-1])
hz_genvsreco_full = \
TH2F("hz_genvsreco_full_nonprompt", "hz_genvsreco_full_nonprompt", \
nzbin_gen * 100, self.lvarshape_binmin_gen[0], self.lvarshape_binmax_gen[-1],
nzbin_reco * 100, self.lvarshape_binmin_reco[0], self.lvarshape_binmax_reco[-1])
fill2dhist(df_tmp_selrecogen, hjetpt_genvsreco_full, "pt_gen_jet", "pt_jet")
hjetpt_genvsreco_full.Scale(1.0 / hjetpt_genvsreco_full.Integral(1, -1, 1, -1))
hjetpt_genvsreco_full.Write()
fill2dhist(df_tmp_selrecogen, hz_genvsreco_full, self.v_varshape_binning_gen, self.v_varshape_binning)
hz_genvsreco_full.Scale(1.0 / hz_genvsreco_full.Integral(1, -1, 1, -1))
hz_genvsreco_full.Write()
for row in df_tmp_selrecogen.itertuples():
response_matrix.Fill(getattr(row, self.v_varshape_binning), row.pt_jet, getattr(row, self.v_varshape_binning_gen), row.pt_gen_jet)
response_matrix.Write("response_matrix_nonprompt")
# histograms for unfolding
hjetpt_genvsreco_full_pr = \
TH2F("hjetpt_genvsreco_full", "hjetpt_genvsreco_full", \
njetptbin_gen * 100, self.lvar2_binmin_gen[0], self.lvar2_binmax_gen[-1], \
njetptbin_reco * 100, self.lvar2_binmin_reco[0], self.lvar2_binmax_reco[-1])
hz_genvsreco_full_pr = \
TH2F("hz_genvsreco_full", "hz_genvsreco_full", \
nzbin_gen * 100, self.lvarshape_binmin_gen[0], self.lvarshape_binmax_gen[-1],
nzbin_reco * 100, self.lvarshape_binmin_reco[0], self.lvarshape_binmax_reco[-1])
fill2dhist(df_tmp_selrecogen_pr, hjetpt_genvsreco_full_pr, "pt_gen_jet", "pt_jet")
hjetpt_genvsreco_full_pr.Scale(1.0 / hjetpt_genvsreco_full_pr.Integral(1, -1, 1, -1))
hjetpt_genvsreco_full_pr.Write()
fill2dhist(df_tmp_selrecogen_pr, hz_genvsreco_full_pr, self.v_varshape_binning_gen, self.v_varshape_binning)
hz_genvsreco_full_pr.Scale(1.0 / hz_genvsreco_full_pr.Integral(1, -1, 1, -1))
hz_genvsreco_full_pr.Write()
hzvsjetpt_prior_weights = build2dhisto("hzvsjetpt_prior_weights", \
zbinarray_gen, jetptbinarray_gen)
fill2dhist(df_tmp_selrecogen_pr, hzvsjetpt_prior_weights, self.v_varshape_binning_gen, "pt_gen_jet")
# end of histograms for unfolding
for ibin2 in range(self.p_nbin2_reco):
df_tmp_selrecogen_jetbin = seldf_singlevar(df_tmp_selrecogen, "pt_jet", \
self.lvar2_binmin_reco[ibin2], self.lvar2_binmax_reco[ibin2])
suffix = "%s_%.2f_%.2f" % (self.v_var2_binning, \
self.lvar2_binmin_reco[ibin2], self.lvar2_binmax_reco[ibin2])
hz_genvsreco = TH2F("hz_genvsreco_nonprompt" + suffix, "hz_genvsreco_nonprompt" + suffix, \
nzbin_gen * 100, self.lvarshape_binmin_gen[0], self.lvarshape_binmax_gen[-1], \
nzbin_reco*100, self.lvarshape_binmin_reco[0], self.lvarshape_binmax_reco[-1])
fill2dhist(df_tmp_selrecogen_jetbin, hz_genvsreco, self.v_varshape_binning_gen, self.v_varshape_binning)
norm = hz_genvsreco.Integral(1, -1, 1, -1)
if norm > 0:
hz_genvsreco.Scale(1.0/norm)
hz_genvsreco.Write()
df_tmp_selrecogen_pr_jetbin = seldf_singlevar(df_tmp_selrecogen_pr, "pt_jet", \
self.lvar2_binmin_reco[ibin2], self.lvar2_binmax_reco[ibin2])
suffix = "%s_%.2f_%.2f" % (self.v_var2_binning, \
self.lvar2_binmin_reco[ibin2], self.lvar2_binmax_reco[ibin2])
hz_genvsreco_pr = TH2F("hz_genvsreco" + suffix, "hz_genvsreco" + suffix, \
nzbin_gen * 100, self.lvarshape_binmin_gen[0], self.lvarshape_binmax_gen[-1], \
nzbin_reco*100, self.lvarshape_binmin_reco[0], self.lvarshape_binmax_reco[-1])
fill2dhist(df_tmp_selrecogen_pr_jetbin, hz_genvsreco_pr, self.v_varshape_binning_gen, self.v_varshape_binning)
norm_pr = hz_genvsreco_pr.Integral(1, -1, 1, -1)
if norm_pr > 0:
hz_genvsreco_pr.Scale(1.0/norm_pr)
hz_genvsreco_pr.Write()
for ibinshape in range(len(self.lvarshape_binmin_reco)):
df_tmp_selrecogen_zbin = seldf_singlevar(df_tmp_selrecogen, self.v_varshape_binning, \
self.lvarshape_binmin_reco[ibinshape], self.lvarshape_binmax_reco[ibinshape])
suffix = "%s_%.2f_%.2f" % \
(self.v_varshape_binning, self.lvarshape_binmin_reco[ibinshape], self.lvarshape_binmax_reco[ibinshape])
hjetpt_genvsreco = TH2F("hjetpt_genvsreco_nonprompt" + suffix, \
"hjetpt_genvsreco_nonprompt" + suffix, njetptbin_gen * 100, self.lvar2_binmin_gen[0], \
self.lvar2_binmax_gen[-1], njetptbin_reco * 100, self.lvar2_binmin_reco[0], \
self.lvar2_binmax_reco[-1])
fill2dhist(df_tmp_selrecogen_zbin, hjetpt_genvsreco, "pt_gen_jet", "pt_jet")
norm = hjetpt_genvsreco.Integral(1, -1, 1, -1)
if norm > 0:
hjetpt_genvsreco.Scale(1.0/norm)
hjetpt_genvsreco.Write()
df_tmp_selrecogen_pr_zbin = seldf_singlevar(df_tmp_selrecogen_pr, self.v_varshape_binning, \
self.lvarshape_binmin_reco[ibinshape], self.lvarshape_binmax_reco[ibinshape])
suffix = "%s_%.2f_%.2f" % \
(self.v_varshape_binning, self.lvarshape_binmin_reco[ibinshape], self.lvarshape_binmax_reco[ibinshape])
hjetpt_genvsreco_pr = TH2F("hjetpt_genvsreco" + suffix, \
"hjetpt_genvsreco" + suffix, njetptbin_gen * 100, self.lvar2_binmin_gen[0], \
self.lvar2_binmax_gen[-1], njetptbin_reco * 100, self.lvar2_binmin_reco[0], \
self.lvar2_binmax_reco[-1])
fill2dhist(df_tmp_selrecogen_pr_zbin, hjetpt_genvsreco_pr, "pt_gen_jet", "pt_jet")
norm_pr = hjetpt_genvsreco_pr.Integral(1, -1, 1, -1)
if norm_pr > 0:
hjetpt_genvsreco_pr.Scale(1.0/norm_pr)
hjetpt_genvsreco_pr.Write()
for ibinshape in range(len(self.lvarshape_binmin_gen)):
dtmp_nonprompt_zgen = seldf_singlevar(df_mc_reco_merged_nonprompt, \
self.v_varshape_binning_gen, self.lvarshape_binmin_gen[ibinshape], self.lvarshape_binmax_gen[ibinshape])
suffix = "%s_%.2f_%.2f" % \
(self.v_varshape_binning, self.lvarshape_binmin_gen[ibinshape], self.lvarshape_binmax_gen[ibinshape])
hz_fracdiff = TH1F("hz_fracdiff_nonprompt" + suffix,
"hz_fracdiff_nonprompt" + suffix, 100, -2, 2)
fill_hist(hz_fracdiff, (dtmp_nonprompt_zgen[self.v_varshape_binning] - \
dtmp_nonprompt_zgen[self.v_varshape_binning_gen])/dtmp_nonprompt_zgen[self.v_varshape_binning_gen])
norm = hz_fracdiff.Integral(1, -1)
if norm:
hz_fracdiff.Scale(1.0 / norm)
hz_fracdiff.Write()
dtmp_prompt_zgen = seldf_singlevar(df_mc_reco_merged_prompt, \
self.v_varshape_binning_gen, self.lvarshape_binmin_gen[ibinshape], self.lvarshape_binmax_gen[ibinshape])
suffix = "%s_%.2f_%.2f" % \
(self.v_varshape_binning, self.lvarshape_binmin_gen[ibinshape], self.lvarshape_binmax_gen[ibinshape])
hz_fracdiff_pr = TH1F("hz_fracdiff_prompt" + suffix,
"hz_fracdiff_prompt" + suffix, 100, -2, 2)
fill_hist(hz_fracdiff_pr, (dtmp_prompt_zgen[self.v_varshape_binning] - \
dtmp_prompt_zgen[self.v_varshape_binning_gen])/dtmp_prompt_zgen[self.v_varshape_binning_gen])
norm_pr = hz_fracdiff_pr.Integral(1, -1)
if norm_pr:
hz_fracdiff_pr.Scale(1.0 / norm_pr)
hz_fracdiff_pr.Write()
for ibin2 in range(self.p_nbin2_gen):
dtmp_nonprompt_jetptgen = seldf_singlevar(df_mc_reco_merged_nonprompt, \
"pt_gen_jet", self.lvar2_binmin_gen[ibin2], self.lvar2_binmax_gen[ibin2])
suffix = "%s_%.2f_%.2f" % (self.v_var2_binning,
self.lvar2_binmin_gen[ibin2], self.lvar2_binmax_gen[ibin2])
hjetpt_fracdiff = TH1F("hjetpt_fracdiff_nonprompt" + suffix,
"hjetpt_fracdiff_nonprompt" + suffix, 100, -2, 2)
fill_hist(hjetpt_fracdiff, (dtmp_nonprompt_jetptgen["pt_jet"] - \
dtmp_nonprompt_jetptgen["pt_gen_jet"])/dtmp_nonprompt_jetptgen["pt_gen_jet"])
norm = hjetpt_fracdiff.Integral(1, -1)
if norm:
hjetpt_fracdiff.Scale(1.0 / norm)
hjetpt_fracdiff.Write()
dtmp_prompt_jetptgen = seldf_singlevar(df_mc_reco_merged_prompt, \
"pt_gen_jet", self.lvar2_binmin_gen[ibin2], self.lvar2_binmax_gen[ibin2])
suffix = "%s_%.2f_%.2f" % (self.v_var2_binning,
self.lvar2_binmin_gen[ibin2], self.lvar2_binmax_gen[ibin2])
hjetpt_fracdiff_pr = TH1F("hjetpt_fracdiff_prompt" + suffix,
"hjetpt_fracdiff_prompt" + suffix, 100, -2, 2)
fill_hist(hjetpt_fracdiff_pr, (dtmp_prompt_jetptgen["pt_jet"] - \
dtmp_prompt_jetptgen["pt_gen_jet"])/dtmp_prompt_jetptgen["pt_gen_jet"])
norm_pr = hjetpt_fracdiff_pr.Integral(1, -1)
if norm_pr:
hjetpt_fracdiff_pr.Scale(1.0 / norm_pr)
hjetpt_fracdiff_pr.Write()
df_mc_reco_merged_prompt_train, df_mc_reco_merged_prompt_test = \
train_test_split(df_mc_reco_merged_prompt, test_size=self.closure_frac)
df_tmp_selgen_pr_test, df_tmp_selreco_pr_test, df_tmp_selrecogen_pr_test = \
self.create_df_closure(df_mc_reco_merged_prompt_test)
_, _, df_tmp_selrecogen_pr_train = \
self.create_df_closure(df_mc_reco_merged_prompt_train)
fill2dhist(df_tmp_selreco_pr_test, hzvsjetpt_reco_closure_pr, self.v_varshape_binning, "pt_jet")
fill2dhist(df_tmp_selgen_pr_test, hzvsjetpt_gen_closure_pr, self.v_varshape_binning_gen, "pt_gen_jet")
hzvsjetpt_reco_closure_pr.Write("input_closure_reco")
hzvsjetpt_gen_closure_pr.Write("input_closure_gen")
for ibin2 in range(self.p_nbin2_gen):
suffix = "%s_%.2f_%.2f" % \
(self.v_var2_binning, self.lvar2_binmin_gen[ibin2], self.lvar2_binmax_gen[ibin2])
hz_gen_nocuts_closure = TH1F("hz_gen_nocuts_closure" + suffix,
"hz_gen_nocuts_closure" + suffix,
nzbin_gen, zbinarray_gen)
hz_gen_nocuts_closure.Sumw2()
hz_gen_cuts_closure = TH1F("hz_gen_cuts_closure" + suffix,
"hz_gen_cuts_closure" + suffix,
nzbin_gen, zbinarray_gen)
hz_gen_cuts_closure.Sumw2()
df_tmp_selgen_pr_test_bin = seldf_singlevar(df_tmp_selgen_pr_test, \
"pt_gen_jet", self.lvar2_binmin_gen[ibin2], self.lvar2_binmax_gen[ibin2])
df_tmp_selrecogen_pr_test_bin = seldf_singlevar(df_tmp_selrecogen_pr_test, \
"pt_gen_jet", self.lvar2_binmin_gen[ibin2], self.lvar2_binmax_gen[ibin2])
fill_hist(hz_gen_nocuts_closure, df_tmp_selgen_pr_test_bin[self.v_varshape_binning_gen])
fill_hist(hz_gen_cuts_closure, df_tmp_selrecogen_pr_test_bin[self.v_varshape_binning_gen])
hz_gen_cuts_closure.Write()
hz_gen_nocuts_closure.Write()
fill_hist(hjetpt_gen_nocuts_closure, df_tmp_selgen_pr_test["pt_gen_jet"])
fill_hist(hjetpt_gen_cuts_closure, df_tmp_selrecogen_pr_test["pt_gen_jet"])
hjetpt_gen_nocuts_closure.Write()
hjetpt_gen_cuts_closure.Write()
hzvsjetpt_reco_nocuts_closure = TH2F("hzvsjetpt_reco_nocuts_closure",
"hzvsjetpt_reco_nocuts_closure",
nzbin_reco, zbinarray_reco,
njetptbin_reco, jetptbinarray_reco)
hzvsjetpt_reco_nocuts_closure.Sumw2()
hzvsjetpt_reco_cuts_closure = TH2F("hzvsjetpt_reco_cuts_closure",
"hzvsjetpt_reco_cuts_closure",
nzbin_reco, zbinarray_reco,
njetptbin_reco, jetptbinarray_reco)
hzvsjetpt_reco_cuts_closure.Sumw2()
fill2dhist(df_tmp_selreco_pr_test, hzvsjetpt_reco_nocuts_closure, self.v_varshape_binning, "pt_jet")
fill2dhist(df_tmp_selrecogen_pr_test, hzvsjetpt_reco_cuts_closure, self.v_varshape_binning, "pt_jet")
hzvsjetpt_reco_nocuts_closure.Write()
hzvsjetpt_reco_cuts_closure.Write()
for row in df_tmp_selrecogen_pr.itertuples():
response_matrix_weight = 1.0
if self.doprior is True:
binx = hzvsjetpt_prior_weights.GetXaxis().FindBin(getattr(row, self.v_varshape_binning_gen))
biny = hzvsjetpt_prior_weights.GetYaxis().FindBin(row.pt_gen_jet)
weight = hzvsjetpt_prior_weights.GetBinContent(binx, biny)
if weight > 0.0:
response_matrix_weight = 1.0/weight
response_matrix_pr.Fill(getattr(row, self.v_varshape_binning), row.pt_jet,\
getattr(row, self.v_varshape_binning_gen), row.pt_gen_jet, response_matrix_weight)
for row in df_tmp_selrecogen_pr_train.itertuples():
response_matrix_weight = 1.0
if self.doprior is True:
binx = hzvsjetpt_prior_weights.GetXaxis().FindBin(getattr(row, self.v_varshape_binning_gen))
biny = hzvsjetpt_prior_weights.GetYaxis().FindBin(row.pt_gen_jet)
weight = hzvsjetpt_prior_weights.GetBinContent(binx, biny)
if weight > 0.0:
response_matrix_weight = 1.0/weight
response_matrix_closure_pr.Fill(getattr(row, self.v_varshape_binning), row.pt_jet,\
getattr(row, self.v_varshape_binning_gen), row.pt_gen_jet, response_matrix_weight)
response_matrix_pr.Write("response_matrix")
response_matrix_closure_pr.Write("response_matrix_closure")
out_file.Close()
def process_histomass_single(self, index):
myfile = TFile.Open(self.l_histomass[index], "recreate")
for ipt in range(self.p_nptfinbins):
bin_id = self.bin_matching[ipt]
df = pickle.load(openfile(self.mptfiles_recoskmldec[bin_id][index], "rb"))
if self.doml is True:
df = df.query(self.l_selml[bin_id])
if self.s_evtsel is not None:
df = df.query(self.s_evtsel)
if self.s_jetsel_reco is not None:
df = df.query(self.s_jetsel_reco)
if self.s_trigger is not None:
df = df.query(self.s_trigger)
h_invmass_all = TH1F("hmass_%d" % ipt, "", self.p_num_bins,
self.p_mass_fit_lim[0], self.p_mass_fit_lim[1])
fill_hist(h_invmass_all, df.inv_mass)
myfile.cd()
h_invmass_all.Write()
df = seldf_singlevar(df, self.v_var_binning, \
self.lpt_finbinmin[ipt], self.lpt_finbinmax[ipt])
for ibin2 in range(self.p_nbin2_reco):
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_reco[ibin2],
self.lvar2_binmax_reco[ibin2])
df_bin = seldf_singlevar(df, self.v_var2_binning,
self.lvar2_binmin_reco[ibin2],
self.lvar2_binmax_reco[ibin2])
df_bin = selectdfrunlist(df_bin, \
self.run_param[self.runlistrigger[self.triggerbit]], "run_number")
# add the z column
df_bin["z"] = z_calc(df_bin.pt_jet, df_bin.phi_jet, df_bin.eta_jet,
df_bin.pt_cand, df_bin.phi_cand, df_bin.eta_cand)
h_invmass = TH1F("hmass" + suffix, "", self.p_num_bins,
self.p_mass_fit_lim[0], self.p_mass_fit_lim[1])
fill_hist(h_invmass, df_bin.inv_mass)
myfile.cd()
h_invmass.Write()
massarray = [1.0 + i * (5.0 / 5000.0) for i in range(5001)] # 5000 bins in range 1.0-6.0
massarray_reco = array.array('d', massarray)
zarray_reco = array.array('d', self.varshaperanges_reco)
h_zvsinvmass = TH2F("hzvsmass" + suffix, "", \
5000, massarray_reco, self.p_nbinshape_reco, zarray_reco)
h_zvsinvmass.Sumw2()
fill2dhist(df_bin, h_zvsinvmass, "inv_mass", self.v_varshape_binning)
h_zvsinvmass.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()
def process_response(self):
list_df_mc_reco = []
list_df_mc_gen = []
for iptskim, _ in enumerate(self.lpt_anbinmin):
df_mc_reco = pickle.load(openfile(self.lpt_recodecmerged[iptskim], "rb"))
if "pt_jet" not in df_mc_reco.columns:
print("Jet variables not found in the dataframe. Skipping process_response.")
return
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)
df_mc_reco = selectdfrunlist(df_mc_reco, \
self.run_param[self.runlistrigger[self.triggerbit]], "run_number")
if self.doml is True:
df_mc_reco = df_mc_reco.query(self.l_selml[iptskim])
else:
print("Doing std analysis")
list_df_mc_reco.append(df_mc_reco)
df_mc_gen = pickle.load(openfile(self.lpt_gendecmerged[iptskim], "rb"))
df_mc_gen = selectdfrunlist(df_mc_gen, \
self.run_param[self.runlistrigger[self.triggerbit]], "run_number")
df_mc_gen = df_mc_gen.query(self.s_presel_gen_eff)
list_df_mc_gen.append(df_mc_gen)
df_rec = pd.concat(list_df_mc_reco)
df_gen = pd.concat(list_df_mc_gen)
his_njets = TH1F("his_njets_gen", "Number of MC jets", 1, 0, 1)
his_njets.SetBinContent(1, len(df_gen.index)) # total number of generated & selected jets for normalisation
df_rec = df_rec[df_rec.ismcfd == 1] # reconstructed & selected non-prompt jets
df_gen = df_gen[df_gen.ismcfd == 1] # generated & selected non-prompt jets
out_file = TFile.Open(self.n_fileeff, "update")
# Bin arrays
# pt_cand
n_bins_ptc = len(self.lpt_finbinmin)
bins_ptc_temp = self.lpt_finbinmin.copy()
bins_ptc_temp.append(self.lpt_finbinmax[n_bins_ptc - 1])
bins_ptc = array.array('d', bins_ptc_temp)
# pt_jet
n_bins_ptjet = len(self.lvar2_binmin)
bins_ptjet_temp = self.lvar2_binmin.copy()
bins_ptjet_temp.append(self.lvar2_binmax[n_bins_ptjet - 1])
bins_ptjet = array.array('d', bins_ptjet_temp)
# z
bins_z_temp = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1]
n_bins_z = len(bins_z_temp) - 1
bins_z = array.array('d', bins_z_temp)
# Detector response matrix of pt_jet of non-prompt jets
df_resp_jet_fd = df_rec.loc[:, ["pt_gen_jet", "pt_jet"]]
his_resp_jet_fd = TH2F("his_resp_jet_fd", \
"Response matrix of #it{p}_{T}^{jet, ch} of non-prompt jets;#it{p}_{T}^{jet, ch, gen.} (GeV/#it{c});#it{p}_{T}^{jet, ch, rec.} (GeV/#it{c})", \
100, 0, 100, 100, 0, 100)
fill_hist(his_resp_jet_fd, df_resp_jet_fd)
# Simulated pt_cand vs. pt_jet of non-prompt jets
df_ptc_ptjet_fd = df_gen.loc[:, ["pt_cand", "pt_jet"]]
his_ptc_ptjet_fd = TH2F("his_ptc_ptjet_fd", \
"Simulated #it{p}_{T}^{cand.} vs. #it{p}_{T}^{jet} of non-prompt jets;#it{p}_{T}^{cand., gen.} (GeV/#it{c});#it{p}_{T}^{jet, ch, gen.} (GeV/#it{c})", \
n_bins_ptc, bins_ptc, 100, 0, 100)
fill_hist(his_ptc_ptjet_fd, df_ptc_ptjet_fd)
# z_gen of reconstructed feed-down jets (for response)
arr_z_gen_resp = z_gen_calc(df_rec.pt_gen_jet, df_rec.phi_gen_jet, df_rec.eta_gen_jet,
df_rec.pt_gen_cand, df_rec.delta_phi_gen_jet, df_rec.delta_eta_gen_jet)
# z_rec of reconstructed feed-down jets (for response)
arr_z_rec_resp = z_calc(df_rec.pt_jet, df_rec.phi_jet, df_rec.eta_jet,
df_rec.pt_cand, df_rec.phi_cand, df_rec.eta_cand)
# z_gen of simulated feed-down jets
arr_z_gen_sim = z_calc(df_gen.pt_jet, df_gen.phi_jet, df_gen.eta_jet,
df_gen.pt_cand, df_gen.phi_cand, df_gen.eta_cand)
df_rec["z_gen"] = arr_z_gen_resp
df_rec["z"] = arr_z_rec_resp
df_gen["z"] = arr_z_gen_sim
# Simulated pt_cand vs. pt_jet vs z of non-prompt jets
df_ptc_ptjet_z_fd = df_gen.loc[:, ["pt_cand", "pt_jet", "z"]]
his_ptc_ptjet_z_fd = TH3F("his_ptc_ptjet_z_fd", \
"Simulated #it{p}_{T}^{cand.} vs. #it{p}_{T}^{jet} vs. #it{z} of non-prompt jets;"
"#it{p}_{T}^{cand., gen.} (GeV/#it{c});"
"#it{p}_{T}^{jet, ch, gen.} (GeV/#it{c});"
"#it{z}", \
n_bins_ptc, bins_ptc, n_bins_ptjet, bins_ptjet, n_bins_z, bins_z)
fill_hist(his_ptc_ptjet_z_fd, df_ptc_ptjet_z_fd)
# Create response matrix for feed-down smearing
# x axis = z, y axis = pt_jet
his_resp_rec = TH2F("his_resp_rec", "his_resp_rec", n_bins_z, bins_z, n_bins_ptjet, bins_ptjet)
his_resp_gen = TH2F("his_resp_gen", "his_resp_gen", n_bins_z, bins_z, n_bins_ptjet, bins_ptjet)
resp_z = RooUnfoldResponse(his_resp_rec, his_resp_gen)
for row in df_rec.itertuples():
resp_z.Fill(row.z, row.pt_jet, row.z_gen, row.pt_gen_jet)
out_file.cd()
his_resp_jet_fd.Write()
his_ptc_ptjet_fd.Write()
his_ptc_ptjet_z_fd.Write()
his_njets.Write()
resp_z.Write("resp_z")
out_file.Close()
def process_histomass_single(self, index):
myfile = TFile.Open(self.l_histomass[index], "recreate")
dfevtorig = pickle.load(openfile(self.l_evtorig[index], "rb"))
if self.s_trigger is not None:
dfevtorig = dfevtorig.query(self.s_trigger)
dfevtorig = selectdfrunlist(dfevtorig, \
self.run_param[self.runlistrigger[self.triggerbit]], "run_number")
for ibin2 in range(len(self.lvar2_binmin)):
mybindfevtorig = seldf_singlevar(dfevtorig, self.v_var2_binning_gen, \
self.lvar2_binmin[ibin2], self.lvar2_binmax[ibin2])
hNorm = TH1F("hEvForNorm_mult%d" % ibin2, "hEvForNorm_mult%d" % ibin2, 2, 0.5, 2.5)
hNorm.GetXaxis().SetBinLabel(1, "normsalisation factor")
hNorm.GetXaxis().SetBinLabel(2, "selected events")
nselevt = 0
norm = 0
if not mybindfevtorig.empty:
nselevt = len(mybindfevtorig.query("is_ev_rej==0"))
norm = getnormforselevt(mybindfevtorig)
hNorm.SetBinContent(1, norm)
hNorm.SetBinContent(2, nselevt)
hNorm.Write()
# histmultevt = TH1F("hmultevtmult%d" % ibin2,
# "hmultevtmult%d" % ibin2, 100, 0, 100)
mybindfevtorig = mybindfevtorig.query("is_ev_rej==0")
# fill_hist(histmultevt, mybindfevtorig.n_tracklets_corr)
# histmultevt.Write()
# h_v0m_ntracklets = TH2F("h_v0m_ntracklets%d" % ibin2,
# "h_v0m_ntracklets%d" % ibin2,
# 200, 0, 200, 200, -0.5, 1999.5)
# v_v0m_ntracklets = np.vstack((mybindfevtorig.n_tracklets_corr,
# mybindfevtorig.v0m_corr)).T
# fill_hist(h_v0m_ntracklets, v_v0m_ntracklets)
# h_v0m_ntracklets.Write()
for ipt in range(self.p_nptfinbins):
bin_id = self.bin_matching[ipt]
df = pickle.load(openfile(self.mptfiles_recoskmldec[bin_id][index], "rb"))
if self.doml is True:
df = df.query(self.l_selml[bin_id])
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)
df = seldf_singlevar(df, self.v_var_binning, \
self.lpt_finbinmin[ipt], self.lpt_finbinmax[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])
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(df, self.v_var2_binning,
self.lvar2_binmin[ibin2], self.lvar2_binmax[ibin2])
df_bin = selectdfrunlist(df_bin, \
self.run_param[self.runlistrigger[self.triggerbit]], "run_number")
fill_hist(h_invmass, df_bin.inv_mass)
if "INT7" not in self.triggerbit and self.mcordata == "data":
fileweight_name = "%s/correctionsweights.root" % self.d_val
fileweight = TFile.Open(fileweight_name, "read")
namefunction = "funcnorm_%s_%s" % (self.triggerbit, self.v_var2_binning_gen)
funcweighttrig = fileweight.Get(namefunction)
if funcweighttrig:
weights = evaluate(funcweighttrig, df_bin[self.v_var2_binning])
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()
histmult = TH1F("hmultpt%dmult%d" % (ipt, ibin2),
"hmultpt%dmult%d" % (ipt, ibin2), 1000, 0, 1000)
fill_hist(histmult, df_bin.n_tracklets_corr)
histmult.Write()
h_v0m_ntrackletsD = TH2F("h_v0m_ntrackletsD%d%d" % (ibin2, ipt),
"h_v0m_ntrackletsD%d%d" % (ibin2, ipt),
200, 0, 200, 200, -0.5, 1999.5)
v_v0m_ntrackletsD = np.vstack((df_bin.n_tracklets_corr,
df_bin.v0m_corr)).T
fill_hist(h_v0m_ntrackletsD, v_v0m_ntrackletsD)
h_v0m_ntrackletsD.Write()
if "pt_jet" in df_bin.columns:
zarray = z_calc(df_bin.pt_jet, df_bin.phi_jet, df_bin.eta_jet,
df_bin.pt_cand, df_bin.phi_cand, df_bin.eta_cand)
h_zvsinvmass = TH2F("hzvsmass" + suffix, "", 5000, 1.00, 6.00, 2000, -0.5, 1.5)
zvsinvmass = np.vstack((df_bin.inv_mass, zarray)).T
fill_hist(h_zvsinvmass, zvsinvmass)
h_zvsinvmass.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()
def process_histomass(self):
myfile = TFile.Open(self.n_filemass, "recreate")
for ipt in range(self.p_nptfinbins):
bin_id = self.bin_matching[ipt]
df = pickle.load(openfile(self.lpt_recodecmerged[bin_id], "rb"))
df = df.query(self.l_selml[bin_id])
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)
df = seldf_singlevar(df, self.v_var_binning, \
self.lpt_finbinmin[ipt], self.lpt_finbinmax[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])
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(df, self.v_var2_binning,
self.lvar2_binmin[ibin2],
self.lvar2_binmax[ibin2])
fill_hist(h_invmass, df_bin.inv_mass)
triggerbit = self.datap["analysis"][self.typean]["triggerbit"]
if "INT7" not in triggerbit and self.mcordata == "data":
fileweight_name = "%s/correctionsweights.root" % self.d_val
fileweight = TFile.Open(fileweight_name, "read")
namefunction = "funcnorm_%s" % self.triggerbit
funcweighttrig = fileweight.Get(namefunction)
weights = evaluate(funcweighttrig,
df_bin[self.v_var2_binning])
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 "pt_jet" in df_bin.columns:
zarray = z_calc(df_bin.pt_jet, df_bin.phi_jet,
df_bin.eta_jet, df_bin.pt_cand,
df_bin.phi_cand, df_bin.eta_cand)
h_zvsinvmass = TH2F("hzvsmass" + suffix, "", 5000, 1.00,
6.00, 2000, -0.5, 1.5)
zvsinvmass = np.vstack((df_bin.inv_mass, zarray)).T
fill_hist(h_zvsinvmass, zvsinvmass)
h_zvsinvmass.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()
