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()
