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) if self.runlistrigger is not None: dfevtorig = selectdfrunlist(dfevtorig, \ self.run_param[self.runlistrigger], "run_number") hNorm = TH1F("hEvForNorm", "hEvForNorm", 2, 0.5, 2.5) hNorm.GetXaxis().SetBinLabel(1, "normsalisation factor") hNorm.GetXaxis().SetBinLabel(2, "selected events") nselevt = 0 norm = 0 if not dfevtorig.empty: nselevt = len(dfevtorig.query("is_ev_rej==0")) norm = getnormforselevt(dfevtorig) hNorm.SetBinContent(1, norm) hNorm.SetBinContent(2, nselevt) hNorm.Write() dfevtorig = dfevtorig.query("is_ev_rej==0") 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]) suffix = "%s%d_%d" % \ (self.v_var_binning, self.lpt_finbinmin[ipt], self.lpt_finbinmax[ipt]) h_invmass = TH1F("hmass" + suffix, "", self.p_num_bins, self.p_mass_fit_lim[0], self.p_mass_fit_lim[1]) if self.runlistrigger is not None: df = selectdfrunlist(df, \ self.run_param[self.runlistrigger], "run_number") fill_hist(h_invmass, df.inv_mass) myfile.cd() h_invmass.Write() if self.mcordata == "mc": df[self.v_ismcrefl] = np.array(tag_bit_df( df, self.v_bitvar, self.b_mcrefl), dtype=int) df_sig = df[df[self.v_ismcsignal] == 1] df_refl = df[df[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_sig.inv_mass) fill_hist(h_invmass_refl, df_refl.inv_mass) myfile.cd() h_invmass_sig.Write() h_invmass_refl.Write() print("FINISHED")
def process_valevents(self, file_index): dfevt = pickle.load(openfile(self.l_evtorig[file_index], "rb")) dfevt = dfevt.query("is_ev_rej==0") triggerlist = ["HighMultV0", "HighMultSPD", "INT7"] varlist = ["v0m_corr", "n_tracklets_corr", "perc_v0m"] nbinsvar = [100, 200] minrvar = [0, 0] maxrvar = [1500, 200] fileevtroot = TFile.Open(self.l_evtvalroot[file_index], "recreate") hv0mvsperc = scatterplot(dfevt, "perc_v0m", "v0m_corr", 50000, 0, 100, 200, 0., 2000.) hv0mvsperc.SetName("hv0mvsperc") hv0mvsperc.Write() for ivar, var in enumerate(varlist): label = "hbitINT7vs%s" % (var) histoMB = TH1F(label, label, nbinsvar[ivar], minrvar[ivar], maxrvar[ivar]) fill_hist(histoMB, dfevt.query("trigger_hasbit_INT7==1")[var]) histoMB.Sumw2() histoMB.Write() for trigger in triggerlist: triggerbit = "trigger_hasbit_%s==1" % trigger labeltriggerANDMB = "hbit%sANDINT7vs%s" % (trigger, var) labeltrigger = "hbit%svs%s" % (trigger, var) histotrigANDMB = TH1F(labeltriggerANDMB, labeltriggerANDMB, nbinsvar[ivar], minrvar[ivar], maxrvar[ivar]) histotrig = TH1F(labeltrigger, labeltrigger, nbinsvar[ivar], minrvar[ivar], maxrvar[ivar]) fill_hist( histotrigANDMB, dfevt.query(triggerbit + " and trigger_hasbit_INT7==1")[var]) fill_hist(histotrig, dfevt.query(triggerbit)[var]) histotrigANDMB.Sumw2() histotrig.Sumw2() histotrigANDMB.Write() histotrig.Write() dfevtnorm = pickle.load(openfile(self.l_evtorig[file_index], "rb")) hNorm = TH1F("hEvForNorm", ";;Normalisation", 2, 0.5, 2.5) hNorm.GetXaxis().SetBinLabel(1, "normsalisation factor") hNorm.GetXaxis().SetBinLabel(2, "selected events") nselevt = 0 norm = 0 if not dfevtnorm.empty: nselevt = len(dfevtnorm.query("is_ev_rej==0")) norm = getnormforselevt(dfevtnorm) hNorm.SetBinContent(1, norm) hNorm.SetBinContent(2, nselevt) hNorm.Write() fileevtroot.Close()
import os import yaml import pandas as pd from ROOT import TFile, TH1F # pylint: disable=import-error, no-name-in-module from machine_learning_hep.selectionutils import getnormforselevt # pylint: disable=invalid-name case = "Dspp5TeV" with open("data/database_ml_parameters.yml", 'r') as param_config: data_param = yaml.load(param_config) namefile_evt = data_param[case]["files_names"]["namefile_evt_skim_tot"] folder = data_param[case]["output_folders"]["pkl_merged"]["mc"] df_evt_all = pd.read_pickle(os.path.join(folder, namefile_evt)) nselevt = len(df_evt_all.query("is_ev_rej==0")) norm = getnormforselevt(df_evt_all) hNorm = TH1F("hEvForNorm", ";;Normalisation", 2, 0.5, 2.5) hNorm.GetXaxis().SetBinLabel(1, "normsalisation factor") hNorm.GetXaxis().SetBinLabel(2, "selected events") hNorm.SetBinContent(1, norm) hNorm.SetBinContent(2, nselevt) outfile = TFile("Normalisation_%s.root" % case, "recreate") hNorm.Write() outfile.Close()
def process_valevents(self, file_index): dfevt = pickle.load(openfile(self.l_evtorig[file_index], "rb")) dfevt = dfevt.query("is_ev_rej==0") dfevtmb = pickle.load(openfile(self.l_evtorig[file_index], "rb")) dfevtmb = dfevtmb.query("is_ev_rej==0") myrunlisttrigmb = self.runlistrigger["INT7"] dfevtselmb = selectdfrunlist(dfevtmb, self.run_param[myrunlisttrigmb], "run_number") triggerlist = ["INT7", "HighMultV0", "HighMultSPD"] varlist = ["v0m_corr", "n_tracklets_corr", "perc_v0m"] nbinsvar = [100, 200, 200] minrvar = [0, 0, 0] maxrvar = [1500, 200, .5] fileevtroot = TFile.Open(self.l_evtvalroot[file_index], "recreate") hv0mvsperc = scatterplot(dfevt, "perc_v0m", "v0m_corr", 50000, 0, 100, 200, 0., 2000.) hv0mvsperc.SetName("hv0mvsperc") hv0mvsperc.Write() dfevtnorm = pickle.load(openfile(self.l_evtorig[file_index], "rb")) hntrklsperc = scatterplot(dfevt, "perc_v0m", "n_tracklets_corr", 50000, 0, 100, 200, 0., 2000.) hntrklsperc.SetName("hntrklsperc") hntrklsperc.Write() for ivar, var in enumerate(varlist): label = "hbitINT7vs%s" % (var) histoMB = TH1F(label, label, nbinsvar[ivar], minrvar[ivar], maxrvar[ivar]) fill_hist(histoMB, dfevtselmb.query("trigger_hasbit_INT7==1")[var]) histoMB.Sumw2() histoMB.Write() for trigger in triggerlist: triggerbit = "trigger_hasbit_%s==1" % trigger labeltriggerANDMB = "hbit%sANDINT7vs%s" % (trigger, var) labeltrigger = "hbit%svs%s" % (trigger, var) histotrigANDMB = TH1F(labeltriggerANDMB, labeltriggerANDMB, nbinsvar[ivar], minrvar[ivar], maxrvar[ivar]) histotrig = TH1F(labeltrigger, labeltrigger, nbinsvar[ivar], minrvar[ivar], maxrvar[ivar]) myrunlisttrig = self.runlistrigger[trigger] ev = len(dfevt) dfevtsel = selectdfrunlist(dfevt, self.run_param[myrunlisttrig], "run_number") if len(dfevtsel) < ev: print("Reduced number of events in trigger", trigger) print(ev, len(dfevtsel)) fill_hist(histotrigANDMB, dfevtsel.query(triggerbit + " and trigger_hasbit_INT7==1")[var]) fill_hist(histotrig, dfevtsel.query(triggerbit)[var]) histotrigANDMB.Sumw2() histotrig.Sumw2() histotrigANDMB.Write() histotrig.Write() hSelMult = TH1F('sel_' + labeltrigger, 'sel_' + labeltrigger, nbinsvar[ivar], minrvar[ivar], maxrvar[ivar]) hNoVtxMult = TH1F('novtx_' + labeltrigger, 'novtx_' + labeltrigger, nbinsvar[ivar], minrvar[ivar], maxrvar[ivar]) hVtxOutMult = TH1F('vtxout_' + labeltrigger, 'vtxout_' + labeltrigger, nbinsvar[ivar], minrvar[ivar], maxrvar[ivar]) # multiplicity dependent normalisation dftrg = dfevtnorm.query(triggerbit) dfsel = dftrg.query('is_ev_rej == 0') df_to_keep = filter_bit_df(dftrg, 'is_ev_rej', [[], [0, 5, 6, 10, 11]]) # events with reco vtx after previous selection tag_vtx = tag_bit_df(df_to_keep, 'is_ev_rej', [[], [1, 2, 7, 12]]) df_no_vtx = df_to_keep[~tag_vtx.values] # events with reco zvtx > 10 cm after previous selection df_bit_zvtx_gr10 = filter_bit_df(df_to_keep, 'is_ev_rej', [[3], [1, 2, 7, 12]]) fill_hist(hSelMult, dfsel[var]) fill_hist(hNoVtxMult, df_no_vtx[var]) fill_hist(hVtxOutMult, df_bit_zvtx_gr10[var]) hSelMult.Write() hNoVtxMult.Write() hVtxOutMult.Write() hNorm = TH1F("hEvForNorm", ";;Normalisation", 2, 0.5, 2.5) hNorm.GetXaxis().SetBinLabel(1, "normsalisation factor") hNorm.GetXaxis().SetBinLabel(2, "selected events") nselevt = 0 norm = 0 if not dfevtnorm.empty: nselevt = len(dfevtnorm.query("is_ev_rej==0")) norm = getnormforselevt(dfevtnorm) hNorm.SetBinContent(1, norm) hNorm.SetBinContent(2, nselevt) hNorm.Write() fileevtroot.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 unpack(self, file_index): treeevtorig = uproot.open(self.l_root[file_index])[self.n_treeevt] dfevtorig = treeevtorig.pandas.df(branches=self.v_evt) dfevtorig = selectdfrunlist(dfevtorig, self.runlist, "run_number") dfevtorig = selectdfquery(dfevtorig, self.s_cen_unp) dfevtorig = dfevtorig.reset_index(drop=True) pickle.dump(dfevtorig, openfile(self.l_evtorig[file_index], "wb"), protocol=4) dfevt = selectdfquery(dfevtorig, self.s_good_evt_unp) dfevt = dfevt.reset_index(drop=True) pickle.dump(dfevt, openfile(self.l_evt[file_index], "wb"), protocol=4) fileevtroot = TFile.Open(self.l_evtorigroot[file_index], "recreate") hNorm = TH1F("hEvForNorm", ";;Normalisation", 2, 0.5, 2.5) hNorm.GetXaxis().SetBinLabel(1, "normsalisation factor") hNorm.GetXaxis().SetBinLabel(2, "selected events") nselevt = 0 norm = 0 # Handle silent weird behaviour of Pandas if dataframe is empty # Otherwise, if it is empty it might just silently return from this frunction for some # reason and everything what follows would just be skipped. if not dfevt.empty: nselevt = len(dfevt.query("is_ev_rej==0")) norm = getnormforselevt(dfevt) hNorm.SetBinContent(1, norm) hNorm.SetBinContent(2, nselevt) hNorm.Write() fileevtroot.Close() treereco = uproot.open(self.l_root[file_index])[self.n_treereco] dfreco = treereco.pandas.df(branches=self.v_all) dfreco = selectdfrunlist(dfreco, self.runlist, "run_number") dfreco = selectdfquery(dfreco, self.s_reco_unp) dfreco = pd.merge(dfreco, dfevt, on=self.v_evtmatch) isselacc = selectfidacc(dfreco.pt_cand.values, dfreco.y_cand.values) dfreco = dfreco[np.array(isselacc, dtype=bool)] if self.b_trackcuts is not None: dfreco = filter_bit_df(dfreco, self.v_bitvar, self.b_trackcuts) dfreco[self.v_isstd] = np.array(tag_bit_df(dfreco, self.v_bitvar, self.b_std), dtype=int) dfreco = dfreco.reset_index(drop=True) if self.mcordata == "mc": dfreco[self.v_ismcsignal] = np.array(tag_bit_df(dfreco, self.v_bitvar, self.b_mcsig), dtype=int) dfreco[self.v_ismcprompt] = np.array(tag_bit_df(dfreco, self.v_bitvar, self.b_mcsigprompt), dtype=int) dfreco[self.v_ismcfd] = np.array(tag_bit_df(dfreco, self.v_bitvar, self.b_mcsigfd), dtype=int) dfreco[self.v_ismcbkg] = np.array(tag_bit_df(dfreco, self.v_bitvar, self.b_mcbkg), dtype=int) pickle.dump(dfreco, openfile(self.l_reco[file_index], "wb"), protocol=4) if self.mcordata == "mc": treegen = uproot.open(self.l_root[file_index])[self.n_treegen] dfgen = treegen.pandas.df(branches=self.v_gen) dfgen = selectdfrunlist(dfgen, self.runlist, "run_number") dfgen = pd.merge(dfgen, dfevtorig, on=self.v_evtmatch) dfgen = selectdfquery(dfgen, self.s_gen_unp) dfgen[self.v_isstd] = np.array(tag_bit_df(dfgen, self.v_bitvar, self.b_std), dtype=int) dfgen[self.v_ismcsignal] = np.array(tag_bit_df(dfgen, self.v_bitvar, self.b_mcsig), dtype=int) dfgen[self.v_ismcprompt] = np.array(tag_bit_df(dfgen, self.v_bitvar, self.b_mcsigprompt), dtype=int) dfgen[self.v_ismcfd] = np.array(tag_bit_df(dfgen, self.v_bitvar, self.b_mcsigfd), dtype=int) dfgen[self.v_ismcbkg] = np.array(tag_bit_df(dfgen, self.v_bitvar, self.b_mcbkg), dtype=int) dfgen = dfgen.reset_index(drop=True) pickle.dump(dfgen, openfile(self.l_gen[file_index], "wb"), protocol=4)
def process_valevents(self, file_index): dfevt = pickle.load(openfile(self.l_evtorig[file_index], "rb")) dfevtnorm = pickle.load(openfile(self.l_evtorig[file_index], "rb")) mbsel = "trigger_hasclass_INT7==1 and is_ev_rej==0" if self.mcordata == "mc": mbsel = "is_ev_rej==0" dfevt = dfevt.query(mbsel) sel_trigger = ["trigger_hasbit_INT7==1", "trigger_hasbit_HighMultSPD==1", "trigger_hasbit_HighMultV0==1", "trigger_hasbit_INT7==1", "trigger_hasbit_HighMultSPD==1", "trigger_hasbit_HighMultV0==1"] variable = ["v0m", "v0m", "v0m", "n_tracklets", "n_tracklets", "n_tracklets"] nbins = [100, 100, 100, 100, 100, 100] minr = [0, 0, 0, 0, 0, 0] maxr = [1500, 1500, 1500, 150, 150, 150] label = ["kINT7_vsv0m", "HighMultSPD_vsv0m", "HighMultV0_vsv0m", "kINT7_vsntracklets", "HighMultSPD_vsntracklets", "HighMultV0_vsntracklets"] fileevtroot = TFile.Open(self.l_evtvalroot[file_index], "recreate") for index, _ in enumerate(sel_trigger): hden, hnum = makeff(dfevt, sel_trigger[index], None, label[index], nbins[index], minr[index], maxr[index], variable[index]) hden.Write() hnum.Write() scatter_name1 = ["v0m"] scatter_name2 = ["n_tracklets"] nbins1 = [100] minr1 = [0] maxr1 = [1500] nbins2 = [100] minr2 = [0] maxr2 = [150] for index2, _ in enumerate(scatter_name1): hscatter = scatterplot(dfevt, scatter_name1[index2], scatter_name2[index2], \ nbins1[index2], minr1[index2], maxr1[index2], \ nbins2[index2], minr2[index2], maxr2[index2]) hscatter.Write() distrname = ["v0m", "n_tracklets"] nbinsdist = [100, 100] minrdist = [0, 0] maxrdist = [1500, 150] for index, _ in enumerate(distrname): hdistr = TH1F("hdistr" + distrname[index], "hdistr" + distrname[index], nbinsdist[index], minrdist[index], maxrdist[index]) hdistr.Sumw2() fill_hist(hdistr, dfevt[distrname[index]]) hdistr.Write() varname = "v0m" cutonspd = [20, 30, 40, 50, 60] hdenv0m = TH1F("hdenv0m", "hdenv0m", 30, 0, 1000) hdenv0m.Sumw2() fill_hist(hdenv0m, dfevt[varname]) for index, _ in enumerate(cutonspd): hnum = TH1F("hnumv0mspd%d" % cutonspd[index], "hnumv0mspd%d" % cutonspd[index], 30, 0, 1000) hnum.Sumw2() devtsel = dfevt.query("n_tracklets>=%d" % cutonspd[index]) fill_hist(hnum, devtsel[varname]) hnum.Write() hdenv0m.Write() hNorm = TH1F("hEvForNorm", ";;Normalisation", 2, 0.5, 2.5) hNorm.GetXaxis().SetBinLabel(1, "normsalisation factor") hNorm.GetXaxis().SetBinLabel(2, "selected events") nselevt = 0 norm = 0 if not dfevtnorm.empty: nselevt = len(dfevtnorm.query("is_ev_rej==0")) norm = getnormforselevt(dfevtnorm) hNorm.SetBinContent(1, norm) hNorm.SetBinContent(2, nselevt) hNorm.Write() fileevtroot.Close()