You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
970 lines
36 KiB
970 lines
36 KiB
# flake8: noqa
|
|
|
|
"""
|
|
Script for accessing histograms of reconstructible and
|
|
reconstructed tracks for different tracking categories
|
|
and trackers.
|
|
|
|
The efficency is calculated usig TGraphAsymmErrors
|
|
and Bayesian error bars
|
|
|
|
author: Furkan Cetin
|
|
date: 10/2023
|
|
|
|
|
|
|
|
Takes data from Recent_get_resolution_and_eff_data.py and calculates efficiencies
|
|
|
|
python scripts/CompareEfficiency.py
|
|
--filename data/res_and_effs_B.root data/resolutions_and_effs_Bd2KstEE_MDmaster.root
|
|
--trackers Match --label new old --outfile data/compare_effs.root
|
|
|
|
python scripts/CompareEfficiency.py --filename data/resolutions_and_effs_D_default_weights.root data/resolutions_and_effs_D_with_electron_weights_as_residual.root --trackers BestLong Seed --label default new --outfile data_results/CompareEfficiencyDDefaultResidual.root
|
|
|
|
recreate: defaultresidual, electronresidual, residual
|
|
"""
|
|
|
|
import os, sys
|
|
import argparse
|
|
from ROOT import TMultiGraph, TLatex, TCanvas, TFile, TGaxis
|
|
from ROOT import (
|
|
kGreen,
|
|
kBlue,
|
|
kBlack,
|
|
kAzure,
|
|
kGray,
|
|
kOrange,
|
|
kMagenta,
|
|
kCyan,
|
|
kViolet,
|
|
kTeal,
|
|
kRed,
|
|
)
|
|
from ROOT import gROOT, gStyle, gPad
|
|
from ROOT import TEfficiency
|
|
from array import array
|
|
|
|
|
|
gROOT.SetBatch(True)
|
|
|
|
from utils.components import unique_name_ext_re, findRootObjByName
|
|
|
|
|
|
def getEfficiencyHistoNames():
|
|
return ["p", "pt", "phi", "eta", "nPV"]
|
|
|
|
|
|
def getTrackers(trackers):
|
|
return trackers
|
|
|
|
|
|
def getCompCuts(compare_cuts):
|
|
return compare_cuts
|
|
|
|
|
|
# data/resolutions_and_effs_Bd2KstEE_MDmaster.root:Track/...
|
|
def getOriginFolders():
|
|
basedict = {
|
|
"Velo": {},
|
|
"Upstream": {},
|
|
"Forward": {},
|
|
"Match": {},
|
|
"MergedMatch": {},
|
|
"DefaultMatch": {},
|
|
"BestLong": {},
|
|
"Seed": {},
|
|
}
|
|
# evtl anpassen wenn die folders anders heissen
|
|
basedict["Velo"]["folder"] = "VeloTrackChecker/"
|
|
basedict["Upstream"]["folder"] = "UpstreamTrackChecker/"
|
|
basedict["Forward"]["folder"] = "ForwardTrackChecker" + unique_name_ext_re() + "/"
|
|
basedict["Match"]["folder"] = "MatchTrackChecker" + unique_name_ext_re() + "/"
|
|
basedict["MergedMatch"]["folder"] = (
|
|
"MergedMatchTrackChecker" + unique_name_ext_re() + "/"
|
|
)
|
|
basedict["DefaultMatch"]["folder"] = (
|
|
"DefaultMatchTrackChecker" + unique_name_ext_re() + "/"
|
|
)
|
|
basedict["BestLong"]["folder"] = "BestLongTrackChecker" + unique_name_ext_re() + "/"
|
|
basedict["Seed"]["folder"] = "SeedTrackChecker" + unique_name_ext_re() + "/"
|
|
|
|
# basedict["Forward"]["folder"] = "ForwardTrackChecker_7a0dbfa7/"
|
|
# basedict["Match"]["folder"] = "MatchTrackChecker_29e3152a/"
|
|
# basedict["BestLong"]["folder"] = "BestLongTrackChecker_4ddacce1/"
|
|
# basedict["Seed"]["folder"] = "SeedTrackChecker_1b1d5575/"
|
|
|
|
return basedict
|
|
|
|
|
|
def getTrackNames():
|
|
basedict = {
|
|
"Velo": {},
|
|
"Upstream": {},
|
|
"Forward": {},
|
|
"Match": {},
|
|
"MergedMatch": {},
|
|
"DefaultMatch": {},
|
|
"BestLong": {},
|
|
"Seed": {},
|
|
}
|
|
|
|
basedict["Velo"] = "Velo"
|
|
basedict["Upstream"] = "VeloUT"
|
|
basedict["Forward"] = "Forward"
|
|
basedict["Match"] = "Match"
|
|
basedict["MergedMatch"] = "MergedMatch"
|
|
basedict["DefaultMatch"] = "DefaultMatch"
|
|
basedict["BestLong"] = "BestLong"
|
|
basedict["Seed"] = "Seed"
|
|
return basedict
|
|
|
|
|
|
def get_colors():
|
|
return [kBlack, kAzure, kGreen + 2, kMagenta + 2, kRed, kCyan + 2, kGray + 1]
|
|
|
|
|
|
def get_elec_colors():
|
|
return [
|
|
kGray + 2,
|
|
kBlue - 4,
|
|
kRed + 1,
|
|
kGreen + 1,
|
|
kViolet,
|
|
kOrange - 8,
|
|
kTeal - 1,
|
|
kGray + 1,
|
|
]
|
|
|
|
|
|
def get_markers():
|
|
return [20, 21, 24, 25, 22, 23, 26, 32]
|
|
|
|
|
|
def get_fillstyles():
|
|
return [1003, 3001, 3002, 3325, 3144, 3244, 3444]
|
|
|
|
|
|
def getGhostHistoNames():
|
|
basedict = {
|
|
# "Velo": {},
|
|
# "Upstream": {},
|
|
"Forward": {},
|
|
"Match": {},
|
|
"MergedMatch": {},
|
|
"DefaultMatch": {},
|
|
"BestLong": {},
|
|
"Seed": {},
|
|
}
|
|
|
|
basedict["Velo"] = ["eta", "nPV"]
|
|
basedict["Upstream"] = ["eta", "p", "pt", "nPV"]
|
|
basedict["Forward"] = ["eta", "p", "pt", "nPV"]
|
|
basedict["Match"] = ["eta", "p", "pt", "nPV"]
|
|
basedict["MergedMatch"] = basedict["Match"]
|
|
basedict["DefaultMatch"] = basedict["Match"]
|
|
basedict["BestLong"] = ["eta", "p", "pt", "nPV"]
|
|
basedict["Seed"] = ["eta", "p", "pt", "nPV"]
|
|
|
|
return basedict
|
|
|
|
|
|
def argument_parser():
|
|
parser = argparse.ArgumentParser(description="location of the tuple file")
|
|
parser.add_argument(
|
|
"--filename",
|
|
type=str,
|
|
default=["data/resolutions_and_effs_B.root"],
|
|
nargs="+",
|
|
help="input files, including path",
|
|
)
|
|
parser.add_argument(
|
|
"--outfile",
|
|
type=str,
|
|
default="data_results/compare_efficiency.root",
|
|
help="output file",
|
|
)
|
|
parser.add_argument(
|
|
"--trackers",
|
|
type=str,
|
|
nargs="+",
|
|
default=["Match", "BestLong", "Seed"], # Forward
|
|
help="Trackers to plot.",
|
|
)
|
|
parser.add_argument(
|
|
"--label",
|
|
nargs="+",
|
|
default=["Eff"],
|
|
help="label for files",
|
|
)
|
|
parser.add_argument(
|
|
"--savepdf",
|
|
action="store_true",
|
|
help="save plots in pdf format",
|
|
)
|
|
parser.add_argument(
|
|
"--compare",
|
|
default=True,
|
|
action="store_true",
|
|
help="compare efficiencies",
|
|
)
|
|
parser.add_argument(
|
|
"--compare-cuts",
|
|
type=str,
|
|
nargs="+",
|
|
default=["long", "long_fromB", "long_fromB_P>5GeV"],
|
|
help="which cuts get compared",
|
|
)
|
|
parser.add_argument(
|
|
"--plot-electrons",
|
|
default=True,
|
|
action="store_true",
|
|
help="plot electrons",
|
|
)
|
|
parser.add_argument(
|
|
"--plot-electrons-only",
|
|
action="store_true",
|
|
help="plot only electrons",
|
|
)
|
|
return parser
|
|
|
|
|
|
def get_files(tf, filename, label):
|
|
for i, f in enumerate(filename):
|
|
tf[label[i]] = TFile(f, "read")
|
|
return tf
|
|
|
|
|
|
def get_nicer_var_string(var: str):
|
|
nice_vars = dict(pt="p_{T}", eta="#eta", phi="#phi")
|
|
try:
|
|
return nice_vars[var]
|
|
except KeyError:
|
|
return var
|
|
|
|
|
|
def get_eff(eff, hist, tf, histoName, label, var):
|
|
eff = {}
|
|
hist = {}
|
|
var = get_nicer_var_string(var)
|
|
for i, lab in enumerate(label):
|
|
numeratorName = histoName + "_reconstructed"
|
|
numerator = findRootObjByName(tf[lab], numeratorName)
|
|
denominatorName = histoName + "_reconstructible"
|
|
denominator = findRootObjByName(tf[lab], denominatorName)
|
|
if numerator.GetEntries() == 0 or denominator.GetEntries() == 0:
|
|
continue
|
|
|
|
teff = TEfficiency(numerator, denominator)
|
|
teff.SetStatisticOption(7)
|
|
eff[lab] = teff.CreateGraph()
|
|
eff[lab].SetName(lab)
|
|
eff[lab].SetTitle(lab)
|
|
if histoName.find("Forward") != -1:
|
|
if histoName.find("electron") != -1:
|
|
eff[lab].SetTitle(lab + " Forward, e^{-}")
|
|
else:
|
|
eff[lab].SetTitle(lab + " Forward")
|
|
if histoName.find("Merged") != -1:
|
|
if histoName.find("electron") != -1:
|
|
eff[lab].SetTitle(lab + " MergedMatch, e^{-}")
|
|
else:
|
|
eff[lab].SetTitle(lab + " MergedMatch")
|
|
elif histoName.find("DefaultMatch") != -1:
|
|
if histoName.find("electron") != -1:
|
|
eff[lab].SetTitle(lab + " DefaultMatch, e^{-}")
|
|
else:
|
|
eff[lab].SetTitle(lab + " DefaultMatch")
|
|
elif histoName.find("Match") != -1:
|
|
if histoName.find("electron") != -1:
|
|
eff[lab].SetTitle(lab + " Match, e^{-}")
|
|
else:
|
|
eff[lab].SetTitle(lab + " Match")
|
|
if histoName.find("Seed") != -1:
|
|
if histoName.find("electron") != -1:
|
|
eff[lab].SetTitle(lab + " Seed, e^{-}")
|
|
else:
|
|
eff[lab].SetTitle(lab + " Seed")
|
|
if histoName.find("BestLong") != -1:
|
|
if histoName.find("electron") != -1:
|
|
eff[lab].SetTitle(lab + " BestLong, e^{-}")
|
|
else:
|
|
eff[lab].SetTitle(lab + " BestLong")
|
|
|
|
# eff[lab].SetTitle(lab + " not e^{-}")
|
|
# if histoName.find("strange") != -1:
|
|
# eff[lab].SetTitle(lab + " from stranges")
|
|
# if histoName.find("electron") != -1:
|
|
# eff[lab].SetTitle(lab + " e^{-}")
|
|
|
|
hist[lab] = denominator.Clone()
|
|
hist[lab].SetName("h_numerator_notElectrons")
|
|
hist[lab].SetTitle(var + " distribution, not e^{-}")
|
|
if histoName.find("strange") != -1:
|
|
hist[lab].SetTitle(var + " distribution, stranges")
|
|
if histoName.find("electron") != -1:
|
|
hist[lab].SetTitle(var + " distribution, e^{-}")
|
|
|
|
return eff, hist
|
|
|
|
|
|
def get_ghost(eff, hist, tf, histoName, label):
|
|
ghost = {}
|
|
for i, lab in enumerate(label):
|
|
numeratorName = histoName + "_Ghosts"
|
|
denominatorName = histoName + "_Total"
|
|
numerator = findRootObjByName(tf[lab], numeratorName)
|
|
denominator = findRootObjByName(tf[lab], denominatorName)
|
|
print("Numerator = " + numeratorName.replace(unique_name_ext_re(), ""))
|
|
print("Denominator = " + denominatorName.replace(unique_name_ext_re(), ""))
|
|
teff = TEfficiency(numerator, denominator)
|
|
teff.SetStatisticOption(7)
|
|
ghost[lab] = teff.CreateGraph()
|
|
print(lab)
|
|
ghost[lab].SetName(lab)
|
|
|
|
return ghost
|
|
|
|
|
|
def get_compare_ghost(eff, hist, tf, histoName, label):
|
|
ghost = {}
|
|
for i, lab in enumerate(label):
|
|
numeratorName = histoName + "_Ghosts"
|
|
denominatorName = histoName + "_Total"
|
|
numerator = findRootObjByName(tf[lab], numeratorName)
|
|
denominator = findRootObjByName(tf[lab], denominatorName)
|
|
print("Numerator = " + numeratorName.replace(unique_name_ext_re(), ""))
|
|
print("Denominator = " + denominatorName.replace(unique_name_ext_re(), ""))
|
|
teff = TEfficiency(numerator, denominator)
|
|
teff.SetStatisticOption(7)
|
|
ghost[lab] = teff.CreateGraph()
|
|
print(lab)
|
|
ghost[lab].SetName(lab)
|
|
if histoName.find("Forward") != -1:
|
|
ghost[lab].SetName(lab + " Ghosts, Forward")
|
|
if histoName.find("Merged") != -1:
|
|
ghost[lab].SetName(lab + " Ghosts, MergedMatch")
|
|
elif histoName.find("DefaultMatch") != -1:
|
|
ghost[lab].SetName(lab + " Ghosts, DefaultMatch")
|
|
elif histoName.find("Match") != -1:
|
|
ghost[lab].SetName(lab + " Ghosts, Match")
|
|
if histoName.find("Seed") != -1:
|
|
ghost[lab].SetName(lab + " Ghosts, Seed")
|
|
if histoName.find("BestLong") != -1:
|
|
ghost[lab].SetName(lab + " Ghosts, BestLong")
|
|
|
|
return ghost
|
|
|
|
|
|
def PrCheckerEfficiency(
|
|
filename,
|
|
outfile,
|
|
label,
|
|
trackers,
|
|
savepdf,
|
|
compare,
|
|
compare_cuts,
|
|
plot_electrons,
|
|
plot_electrons_only,
|
|
):
|
|
from utils.LHCbStyle import setLHCbStyle, set_style
|
|
from utils.ConfigHistos import (
|
|
efficiencyHistoDict,
|
|
ghostHistoDict,
|
|
categoriesDict,
|
|
getCuts,
|
|
)
|
|
from utils.CompareConfigHistos import getCompare, getCompColors
|
|
from utils.Legend import place_legend
|
|
|
|
setLHCbStyle()
|
|
|
|
markers = get_markers()
|
|
colors = get_colors()
|
|
elec_colors = get_elec_colors()
|
|
styles = get_fillstyles()
|
|
|
|
tf = {}
|
|
tf = get_files(tf, filename, label)
|
|
outputfile = TFile(outfile, "recreate")
|
|
|
|
latex = TLatex()
|
|
latex.SetNDC()
|
|
latex.SetTextSize(0.05)
|
|
|
|
efficiencyHistoDict = efficiencyHistoDict()
|
|
efficiencyHistos = getEfficiencyHistoNames()
|
|
ghostHistos = getGhostHistoNames()
|
|
ghostHistoDict = ghostHistoDict()
|
|
categories = categoriesDict()
|
|
cuts = getCuts()
|
|
compareDict = getCompare()
|
|
compareCuts = getCompCuts(compare_cuts)
|
|
compareColors = getCompColors()
|
|
compareGhostHisto = ["eta", "p", "pt", "nPV"]
|
|
trackers = getTrackers(trackers)
|
|
folders = getOriginFolders()
|
|
|
|
for tracker in trackers:
|
|
outputfile.cd()
|
|
trackerDir = outputfile.mkdir(tracker)
|
|
trackerDir.cd()
|
|
|
|
for cut in cuts[tracker]:
|
|
cutDir = trackerDir.mkdir(cut)
|
|
cutDir.cd()
|
|
folder = folders[tracker]["folder"]
|
|
print("folder: " + folder.replace(unique_name_ext_re(), ""))
|
|
histoBaseName = "Track/" + folder + tracker + "/" + cut + "_"
|
|
|
|
# calculate efficiency
|
|
for histo in efficiencyHistos:
|
|
canvastitle = (
|
|
"efficiency_" + histo + ", " + categories[tracker][cut]["title"]
|
|
)
|
|
# get efficiency for not electrons category
|
|
histoName = histoBaseName + "" + efficiencyHistoDict[histo]["variable"]
|
|
print("not electrons: " + histoName.replace(unique_name_ext_re(), ""))
|
|
eff = {}
|
|
hist_den = {}
|
|
eff, hist_den = get_eff(eff, hist_den, tf, histoName, label, histo)
|
|
if categories[tracker][cut]["plotElectrons"] and plot_electrons:
|
|
histoNameElec = (
|
|
"Track/"
|
|
+ folder
|
|
+ tracker
|
|
+ "/"
|
|
+ categories[tracker][cut]["Electrons"]
|
|
)
|
|
histoName_e = (
|
|
histoNameElec + "_" + efficiencyHistoDict[histo]["variable"]
|
|
)
|
|
print("electrons: " + histoName_e.replace(unique_name_ext_re(), ""))
|
|
eff_elec = {}
|
|
hist_elec = {}
|
|
eff_elec, hist_elec = get_eff(
|
|
eff_elec,
|
|
hist_elec,
|
|
tf,
|
|
histoName_e,
|
|
label,
|
|
histo,
|
|
)
|
|
name = "efficiency_" + histo
|
|
canvas = TCanvas(name, canvastitle)
|
|
canvas.SetRightMargin(0.1)
|
|
mg = TMultiGraph()
|
|
for i, lab in enumerate(label):
|
|
if not plot_electrons_only:
|
|
mg.Add(eff[lab])
|
|
set_style(eff[lab], colors[i], markers[i], styles[i])
|
|
if categories[tracker][cut]["plotElectrons"] and plot_electrons:
|
|
mg.Add(eff_elec[lab])
|
|
set_style(eff_elec[lab], elec_colors[i], markers[i], styles[i])
|
|
|
|
mg.Draw("AP")
|
|
mg.GetYaxis().SetRangeUser(0, 1.05)
|
|
xtitle = efficiencyHistoDict[histo]["xTitle"]
|
|
unit_l = xtitle.split("[")
|
|
if "]" in unit_l[-1]:
|
|
unit = unit_l[-1].replace("]", "")
|
|
else:
|
|
unit = "a.u."
|
|
print(unit)
|
|
mg.GetXaxis().SetTitle(xtitle)
|
|
mg.GetXaxis().SetTitleSize(0.06)
|
|
mg.GetYaxis().SetTitle(
|
|
"Efficiency of Long Tracks",
|
|
) # (" + str(round(hist_den[label[0]].GetBinWidth(1), 2)) + f"{unit})"+"^{-1}")
|
|
mg.GetYaxis().SetTitleSize(0.06)
|
|
mg.GetYaxis().SetTitleOffset(1.1)
|
|
mg.GetXaxis().SetRangeUser(*efficiencyHistoDict[histo]["range"])
|
|
mg.GetXaxis().SetNdivisions(10, 5, 0)
|
|
mygray = 18
|
|
myblue = kBlue - 9
|
|
for i, lab in enumerate(label):
|
|
rightmax = 1.05 * hist_den[lab].GetMaximum()
|
|
scale = gPad.GetUymax() / rightmax
|
|
hist_den[lab].Scale(scale)
|
|
if categories[tracker][cut]["plotElectrons"] and plot_electrons:
|
|
rightmax = 1.05 * hist_elec[lab].GetMaximum()
|
|
scale = gPad.GetUymax() / rightmax
|
|
hist_elec[lab].Scale(scale)
|
|
if i == 0:
|
|
if not plot_electrons_only:
|
|
set_style(hist_den[lab], mygray, markers[i], styles[i])
|
|
gStyle.SetPalette(2, array("i", [mygray - 1, myblue + 1]))
|
|
hist_den[lab].Draw("HIST PLC SAME")
|
|
if categories[tracker][cut]["plotElectrons"] and plot_electrons:
|
|
set_style(hist_elec[lab], myblue, markers[i], styles[i])
|
|
hist_elec[lab].SetFillColorAlpha(myblue, 0.35)
|
|
hist_elec[lab].Draw("HIST PLC SAME")
|
|
# else:
|
|
# print(
|
|
# "No distribution plotted for other labels.",
|
|
# "Can be added by uncommenting the code below this print statement.",
|
|
# )
|
|
# # set_style(hist_den[lab], mygray, markers[i], styles[i])
|
|
# # gStyle.SetPalette(2, array("i", [mygray - 1, myblue + 1]))
|
|
# # hist_den[lab].Draw("HIST PLC SAME")
|
|
|
|
# if histo == "p":
|
|
# pos = [0.5, 0.3, 1.0, 0.6]
|
|
# elif histo == "pt":
|
|
# pos = [0.5, 0.3, 0.99, 0.6]
|
|
# elif histo == "phi":
|
|
# pos = [0.3, 0.25, 0.8, 0.55]
|
|
# else:
|
|
# pos = [0.3, 0.25, 0.8, 0.55]
|
|
|
|
if histo == "p":
|
|
pos = [0.5, 0.3, 1.0, 0.5] # [0.53, 0.4, 1.01, 0.71]
|
|
elif histo == "pt":
|
|
pos = [0.5, 0.3, 0.99, 0.5] # [0.5, 0.4, 0.98, 0.71]
|
|
elif histo == "phi":
|
|
pos = [0.4, 0.3, 0.9, 0.5]
|
|
elif histo == "eta":
|
|
pos = [0.5, 0.25, 1.0, 0.45]
|
|
else:
|
|
pos = [0.35, 0.25, 0.85, 0.45]
|
|
|
|
legend = place_legend(
|
|
canvas, *pos, header="LHCb Simulation", option="LPE"
|
|
)
|
|
for le in legend.GetListOfPrimitives():
|
|
if "distribution" in le.GetLabel():
|
|
le.SetOption("LF")
|
|
legend.SetTextFont(132)
|
|
legend.SetTextSize(0.04)
|
|
legend.Draw()
|
|
for lab in label:
|
|
if not plot_electrons_only:
|
|
eff[lab].Draw("P SAME")
|
|
if categories[tracker][cut]["plotElectrons"] and plot_electrons:
|
|
eff_elec[lab].Draw("P SAME")
|
|
cutName = categories[tracker][cut]["title"]
|
|
latex.DrawLatex(legend.GetX1() + 0.01, legend.GetY1() - 0.05, cutName)
|
|
low = 0
|
|
high = 1.05
|
|
gPad.Update()
|
|
axis = TGaxis(
|
|
gPad.GetUxmax(),
|
|
gPad.GetUymin(),
|
|
gPad.GetUxmax(),
|
|
gPad.GetUymax(),
|
|
low,
|
|
high,
|
|
510,
|
|
"+U",
|
|
)
|
|
axis.SetTitleFont(132)
|
|
axis.SetTitleSize(0.06)
|
|
axis.SetTitleOffset(0.55)
|
|
axis.SetTitle(
|
|
"# Tracks " + get_nicer_var_string(histo) + " distribution [a.u.]",
|
|
)
|
|
axis.SetLabelSize(0)
|
|
axis.Draw()
|
|
canvas.RedrawAxis()
|
|
if savepdf:
|
|
filestypes = ["pdf"] # , "png", "eps", "C", "ps", "tex"]
|
|
for ftype in filestypes:
|
|
if not plot_electrons_only:
|
|
canvasName = tracker + "_" + cut + "_" + histo + "." + ftype
|
|
else:
|
|
canvasName = (
|
|
tracker
|
|
+ "_Electrons_"
|
|
+ cut
|
|
+ "_"
|
|
+ histo
|
|
+ "."
|
|
+ ftype
|
|
)
|
|
canvas.SaveAs("checks/" + canvasName)
|
|
# canvas.SetRightMargin(0.05)
|
|
canvas.Write()
|
|
|
|
# calculate ghost rate
|
|
print("\ncalculate ghost rate: ")
|
|
histoBaseName = "Track/" + folder + tracker + "/"
|
|
for histo in ghostHistos[tracker]:
|
|
trackerDir.cd()
|
|
title = "ghost_rate_vs_" + histo
|
|
|
|
gPad.SetTicks()
|
|
histoName = histoBaseName + ghostHistoDict[histo]["variable"]
|
|
|
|
ghost = {}
|
|
hist_den = {}
|
|
ghost = get_ghost(ghost, hist_den, tf, histoName, label)
|
|
canvas = TCanvas(title, title)
|
|
mg = TMultiGraph()
|
|
for i, lab in enumerate(label):
|
|
mg.Add(ghost[lab])
|
|
set_style(ghost[lab], colors[i], markers[2 * i], styles[i])
|
|
|
|
xtitle = ghostHistoDict[histo]["xTitle"]
|
|
mg.GetXaxis().SetTitle(xtitle)
|
|
mg.GetYaxis().SetTitle("Fraction of fake tracks")
|
|
mg.Draw("ap")
|
|
mg.GetXaxis().SetTitleSize(0.06)
|
|
mg.GetYaxis().SetTitleSize(0.06)
|
|
mg.GetYaxis().SetTitleOffset(1.1)
|
|
mg.GetXaxis().SetRangeUser(*efficiencyHistoDict[histo]["range"])
|
|
mg.GetXaxis().SetNdivisions(10, 5, 0)
|
|
# for lab in label:
|
|
# ghost[lab].Draw("P SAME")
|
|
if histo == "p":
|
|
pos = [0.53, 0.4, 1.00, 0.71]
|
|
elif histo == "pt":
|
|
pos = [0.5, 0.4, 0.98, 0.71]
|
|
elif histo == "eta":
|
|
pos = [0.35, 0.6, 0.85, 0.9]
|
|
elif histo == "phi":
|
|
pos = [0.3, 0.3, 0.9, 0.6]
|
|
else:
|
|
pos = [0.4, 0.37, 0.80, 0.68]
|
|
legend = place_legend(canvas, *pos, header="LHCb Simulation", option="LPE")
|
|
legend.SetTextFont(132)
|
|
legend.SetTextSize(0.04)
|
|
legend.Draw()
|
|
# if histo != "nPV":
|
|
# latex.DrawLatex(0.7, 0.85, "LHCb simulation")
|
|
# else:
|
|
# latex.DrawLatex(0.2, 0.85, "LHCb simulation")
|
|
# mg.GetYaxis().SetRangeUser(0, 0.4)
|
|
if histo == "eta":
|
|
mg.GetYaxis().SetRangeUser(0, 0.4)
|
|
# track_name = names[tracker] + " tracks"
|
|
# latex.DrawLatex(0.7, 0.75, track_name)
|
|
# canvas.PlaceLegend()
|
|
if savepdf:
|
|
filestypes = ["pdf"] # , "png", "eps", "C", "ps", "tex"]
|
|
for ftype in filestypes:
|
|
canvas.SaveAs(
|
|
"checks/" + tracker + "_ghost_rate_" + histo + "." + ftype,
|
|
)
|
|
canvas.Write()
|
|
|
|
#
|
|
# Compare electron efficiencies of different trackers
|
|
#
|
|
|
|
plot_electrons_only = True
|
|
if compare:
|
|
print("\nCompare Efficiencies: ")
|
|
outputfile.cd()
|
|
|
|
for jcut in compareCuts: # [long, long_fromB, long_fromB_P>5GeV]
|
|
compareDir = outputfile.mkdir("compare_" + jcut)
|
|
compareDir.cd()
|
|
for histo in efficiencyHistos: # [p, pt, phi, eta, nPV]
|
|
canvastitle = "efficiency_" + histo + "_" + jcut
|
|
name = "efficiency_" + histo + "_" + jcut
|
|
canvas = TCanvas(name, canvastitle)
|
|
canvas.SetRightMargin(0.1)
|
|
mg = TMultiGraph()
|
|
dist_eff = {}
|
|
dist_hist_den = {}
|
|
dist_eff_elec = {}
|
|
dist_hist_elec = {}
|
|
First = True
|
|
dist_tracker = ""
|
|
markeritr = 0
|
|
|
|
for tracker in trackers: # [BestLong, Forward, Match, Seed]
|
|
cut = compareDict[jcut][tracker]
|
|
folder = folders[tracker]["folder"]
|
|
print("folder: " + folder.replace(unique_name_ext_re(), ""))
|
|
|
|
jcolor = compareColors[tracker]
|
|
|
|
histoName = (
|
|
"Track/"
|
|
+ folder
|
|
+ tracker
|
|
+ "/"
|
|
+ cut
|
|
+ "_"
|
|
+ ""
|
|
+ efficiencyHistoDict[histo]["variable"]
|
|
)
|
|
print(
|
|
"not electrons: " + histoName.replace(unique_name_ext_re(), "")
|
|
)
|
|
eff = {}
|
|
hist_den = {}
|
|
eff, hist_den = get_eff(eff, hist_den, tf, histoName, label, histo)
|
|
if categories[tracker][cut]["plotElectrons"] and plot_electrons:
|
|
histoNameElec = (
|
|
"Track/"
|
|
+ folder
|
|
+ tracker
|
|
+ "/"
|
|
+ categories[tracker][cut]["Electrons"]
|
|
)
|
|
histoName_e = (
|
|
histoNameElec + "_" + efficiencyHistoDict[histo]["variable"]
|
|
)
|
|
print(
|
|
"electrons: "
|
|
+ histoName_e.replace(unique_name_ext_re(), "")
|
|
)
|
|
eff_elec = {}
|
|
hist_elec = {}
|
|
eff_elec, hist_elec = get_eff(
|
|
eff_elec,
|
|
hist_elec,
|
|
tf,
|
|
histoName_e,
|
|
label,
|
|
histo,
|
|
)
|
|
if First:
|
|
dist_eff_elec = eff_elec
|
|
dist_hist_elec = hist_elec
|
|
|
|
if First:
|
|
dist_tracker = tracker
|
|
dist_eff = eff
|
|
dist_hist_den = hist_den
|
|
First = False
|
|
|
|
seeditr = 0
|
|
for i, lab in enumerate(label):
|
|
if categories[tracker][cut]["plotElectrons"] and plot_electrons:
|
|
if (tracker == "Seed") and (seeditr != 0):
|
|
continue
|
|
if tracker == "Seed":
|
|
seeditr += 1
|
|
mg.Add(eff_elec[lab])
|
|
set_style(
|
|
eff_elec[lab],
|
|
colors[jcolor],
|
|
markers[i + markeritr],
|
|
styles[i],
|
|
)
|
|
else:
|
|
mg.Add(eff_elec[lab])
|
|
set_style(
|
|
eff_elec[lab],
|
|
elec_colors[jcolor + markeritr],
|
|
markers[i + markeritr],
|
|
styles[i],
|
|
)
|
|
markeritr = markeritr + 1
|
|
# set_style(
|
|
# eff_elec[lab], colors[jcolor], markers[i], styles[i]
|
|
# )
|
|
markeritr = 0
|
|
|
|
mg.Draw("AP")
|
|
mg.GetYaxis().SetRangeUser(0, 1.05)
|
|
xtitle = efficiencyHistoDict[histo]["xTitle"]
|
|
unit_l = xtitle.split("[")
|
|
if "]" in unit_l[-1]:
|
|
unit = unit_l[-1].replace("]", "")
|
|
else:
|
|
unit = "a.u."
|
|
print(unit)
|
|
mg.GetXaxis().SetTitle(xtitle)
|
|
mg.GetXaxis().SetTitleSize(0.06)
|
|
mg.GetYaxis().SetTitle(
|
|
"Efficiency of Long Tracks",
|
|
) # (" + str(round(hist_den[label[0]].GetBinWidth(1), 2)) + f"{unit})"+"^{-1}")
|
|
mg.GetYaxis().SetTitleSize(0.06)
|
|
mg.GetYaxis().SetTitleOffset(1.1)
|
|
mg.GetXaxis().SetRangeUser(*efficiencyHistoDict[histo]["range"])
|
|
mg.GetXaxis().SetNdivisions(10, 5, 0)
|
|
mygray = 16
|
|
myblue = kBlue - 7
|
|
|
|
dist_cut = compareDict[jcut][dist_tracker]
|
|
|
|
for i, lab in enumerate(label):
|
|
rightmax = 1.05 * dist_hist_den[lab].GetMaximum()
|
|
scale = gPad.GetUymax() / rightmax
|
|
dist_hist_den[lab].Scale(scale)
|
|
if (
|
|
categories[dist_tracker][dist_cut]["plotElectrons"]
|
|
and plot_electrons
|
|
):
|
|
rightmax = 1.05 * dist_hist_elec[lab].GetMaximum()
|
|
scale = gPad.GetUymax() / rightmax
|
|
dist_hist_elec[lab].Scale(scale)
|
|
if i == len(label) - 1:
|
|
if not plot_electrons_only:
|
|
set_style(dist_hist_den[lab], mygray, markers[i], styles[i])
|
|
# gStyle.SetPalette(2, array("i", [mygray - 1, myblue + 1]))
|
|
dist_hist_den[lab].SetFillColorAlpha(mygray, 0.5)
|
|
dist_hist_den[lab].Draw("HIST PLC SAME")
|
|
if (
|
|
categories[dist_tracker][dist_cut]["plotElectrons"]
|
|
and plot_electrons
|
|
):
|
|
set_style(
|
|
dist_hist_elec[lab], mygray, markers[i], styles[i]
|
|
)
|
|
# gStyle.SetPalette(2, array("i", [mygray - 1, myblue + 1]))
|
|
# dist_hist_elec[lab].SetFillColor(myblue)
|
|
dist_hist_elec[lab].SetFillColorAlpha(myblue, 0.5)
|
|
dist_hist_elec[lab].Draw("HIST PLC SAME")
|
|
# else:
|
|
# print(
|
|
# "No distribution plotted for other labels.",
|
|
# "Can be added by uncommenting the code below this print statement.",
|
|
# )
|
|
# set_style(dist_hist_den[lab], mygray, markers[i], styles[i])
|
|
# gStyle.SetPalette(2, array("i", [mygray - 1, myblue + 1]))
|
|
# dist_hist_den[lab].Draw("HIST PLC SAME")
|
|
|
|
if histo == "p":
|
|
pos = [0.5, 0.3, 1.0, 0.5] # [0.53, 0.4, 1.01, 0.71]
|
|
elif histo == "pt":
|
|
pos = [0.5, 0.3, 0.99, 0.5] # [0.5, 0.4, 0.98, 0.71]
|
|
elif histo == "phi":
|
|
pos = [0.4, 0.3, 0.9, 0.5]
|
|
elif histo == "eta":
|
|
pos = [0.5, 0.25, 1.0, 0.45]
|
|
else:
|
|
pos = [0.35, 0.25, 0.85, 0.45]
|
|
legend = place_legend(
|
|
canvas, *pos, header="LHCb Simulation", option="LPE"
|
|
)
|
|
for le in legend.GetListOfPrimitives():
|
|
if "distribution" in le.GetLabel():
|
|
le.SetOption("LF")
|
|
legend.SetTextFont(132)
|
|
legend.SetTextSize(0.04)
|
|
legend.Draw()
|
|
for lab in label:
|
|
if not plot_electrons_only:
|
|
dist_eff[lab].Draw("P SAME")
|
|
if categories[tracker][cut]["plotElectrons"] and plot_electrons:
|
|
dist_eff_elec[lab].Draw("P SAME")
|
|
cutName = categories[tracker][cut]["title"]
|
|
latex.DrawLatex(legend.GetX1() + 0.01, legend.GetY1() - 0.05, cutName)
|
|
low = 0
|
|
high = 1.05
|
|
gPad.Update()
|
|
axis = TGaxis(
|
|
gPad.GetUxmax(),
|
|
gPad.GetUymin(),
|
|
gPad.GetUxmax(),
|
|
gPad.GetUymax(),
|
|
low,
|
|
high,
|
|
510,
|
|
"+U",
|
|
)
|
|
axis.SetTitleFont(132)
|
|
axis.SetTitleSize(0.06)
|
|
axis.SetTitleOffset(0.55)
|
|
axis.SetTitle(
|
|
"# Tracks " + get_nicer_var_string(histo) + " distribution [a.u.]",
|
|
)
|
|
axis.SetLabelSize(0)
|
|
axis.Draw()
|
|
canvas.RedrawAxis()
|
|
if savepdf:
|
|
filestypes = ["pdf"] # , "png", "eps", "C", "ps", "tex"]
|
|
for ftype in filestypes:
|
|
if not plot_electrons_only:
|
|
canvasName = "Compare_" + cut + "_" + histo + "." + ftype
|
|
else:
|
|
canvasName = (
|
|
"Compare_Electrons_" + cut + "_" + histo + "." + ftype
|
|
)
|
|
canvas.SaveAs("checks/" + canvasName)
|
|
# canvas.SetRightMargin(0.05)
|
|
canvas.Write()
|
|
|
|
# calculate ghost rate
|
|
print("\ncalculate ghost rate: ")
|
|
for histo in compareGhostHisto: # [Match, Seed, ...]
|
|
cut = compareDict[jcut][tracker]
|
|
|
|
canvastitle = "ghost_rate_vs_" + histo + "_" + jcut
|
|
name = "ghost_rate_vs_" + histo + "_" + jcut
|
|
canvas = TCanvas(name, canvastitle)
|
|
canvas.SetRightMargin(0.1)
|
|
mg = TMultiGraph()
|
|
jitr = 0
|
|
for tracker in trackers:
|
|
if tracker == "Seed":
|
|
continue
|
|
folder = folders[tracker]["folder"]
|
|
jcolor = compareColors[tracker]
|
|
gPad.SetTicks()
|
|
histoName = (
|
|
"Track/"
|
|
+ folder
|
|
+ tracker
|
|
+ "/"
|
|
+ ghostHistoDict[histo]["variable"]
|
|
)
|
|
ghost = {}
|
|
hist_den = {}
|
|
ghost = get_compare_ghost(ghost, hist_den, tf, histoName, label)
|
|
for i, lab in enumerate(label):
|
|
mg.Add(ghost[lab])
|
|
set_style(
|
|
ghost[lab], colors[jcolor + jitr], markers[2 * i], styles[i]
|
|
)
|
|
jitr += 1
|
|
|
|
xtitle = ghostHistoDict[histo]["xTitle"]
|
|
mg.GetXaxis().SetTitle(xtitle)
|
|
mg.GetYaxis().SetTitle("Fraction of fake tracks")
|
|
mg.Draw("ap")
|
|
mg.GetXaxis().SetTitleSize(0.06)
|
|
mg.GetYaxis().SetTitleSize(0.06)
|
|
mg.GetYaxis().SetTitleOffset(1.1)
|
|
mg.GetXaxis().SetRangeUser(*efficiencyHistoDict[histo]["range"])
|
|
mg.GetXaxis().SetNdivisions(10, 5, 0)
|
|
# for lab in label:
|
|
# ghost[lab].Draw("P SAME")
|
|
if histo == "p":
|
|
pos = [0.53, 0.4, 1.00, 0.71]
|
|
elif histo == "pt":
|
|
pos = [0.5, 0.4, 0.98, 0.71]
|
|
elif histo == "eta":
|
|
pos = [0.35, 0.6, 0.85, 0.9]
|
|
elif histo == "phi":
|
|
pos = [0.3, 0.3, 0.9, 0.6]
|
|
else:
|
|
pos = [0.4, 0.37, 0.80, 0.68]
|
|
legend = place_legend(
|
|
canvas, *pos, header="LHCb Simulation", option="LPE"
|
|
)
|
|
legend.SetTextFont(132)
|
|
legend.SetTextSize(0.04)
|
|
legend.Draw()
|
|
# if histo != "nPV":
|
|
# latex.DrawLatex(0.7, 0.85, "LHCb simulation")
|
|
# else:
|
|
# latex.DrawLatex(0.2, 0.85, "LHCb simulation")
|
|
# mg.GetYaxis().SetRangeUser(0, 0.4)
|
|
if histo == "eta":
|
|
mg.GetYaxis().SetRangeUser(0, 0.4)
|
|
# track_name = names[tracker] + " tracks"
|
|
# latex.DrawLatex(0.7, 0.75, track_name)
|
|
# canvas.PlaceLegend()
|
|
if savepdf:
|
|
filestypes = ["pdf"] # , "png", "eps", "C", "ps", "tex"]
|
|
for ftype in filestypes:
|
|
canvas.SaveAs(
|
|
"checks/" + tracker + "_ghost_rate_" + histo + "." + ftype,
|
|
)
|
|
canvas.Write()
|
|
|
|
outputfile.cd()
|
|
|
|
outputfile.Write()
|
|
outputfile.Close()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = argument_parser()
|
|
args = parser.parse_args()
|
|
PrCheckerEfficiency(**vars(args))
|