def doPlot(legList, graphList, saveName, **kwargs):
# Definitions
hgList = []
lList = {}
# For-loop: All TGraphs
for i, g in enumerate(graphList, 0):
if opts.boldText:
gName = legList[i]
else:
gName = "#font[42]{%s}" % legList[i]
hg = histograms.HistoGraph(graphList[i],
gName,
drawStyle="L",
legendStyle="l")
hgList.append(hg)
# Create a plot-base object
Verbose("Creating the plot-base object", True)
# plot = plots.PlotBase(hgList, saveFormats=[])
hgList.insert(0, hgList.pop(opts.refIndex))
plot = plots.ComparisonManyPlot(hgList[0], hgList[1:], saveFormats=[])
#plot = plots.ComparisonManyPlot(hgList[-1], hgList[:-1], saveFormats=[])
# Apply histo style
Verbose("Applying the histogram styles (generator)", True)
plot.histoMgr.forEachHisto(styles.generator())
# plot.histoMgr.forEachHisto(lambda h: h.getRootHisto().SetMarkerSize(1.2))
# plot.histoMgr.forEachHisto(lambda h: h.getRootHisto().SetLineWidth(3))
def sty(h):
r = h.getRootHisto()
r.SetLineWidth(3)
r.SetMarkerSize(1.2)
return
# Apply style and set label
Verbose("Applying the histogram styles (forEachHisto)", True)
plot.histoMgr.forEachHisto(sty)
if opts.plotType != "var":
plot.setLegendHeader("Sequential Model (Keras)")
# Draw the plot
Verbose("Drawing the plot", True)
plots.drawPlot(plot, saveName, **kwargs)
if opts.removeLegend:
plot.removeLegend()
# Save plots and return
Verbose("Saving the plot as %s" % (saveName), True)
SavePlot(plot, opts.saveDir, saveName, opts.saveFormats)
Verbose(
"Plots saved under directory %s" %
(sh_s + aux.convertToURL(opts.saveDir, opts.url) + sh_n), True)
return
def doSystematicsPlots(self):
if self._mySystObject == None:
return
# Make sure results have been obtained
if self._hSystematicsUp == None:
self.doSystematicsForMetShapeDifference()
# Create output directory
if os.path.exists("%s/Systematics_%s"%(self._myDir, self._systName)):
shutils.rmtree("%s/Systematics_%s"%(self._myDir, self._systName))
os.mkdir("%s/Systematics_%s"%(self._myDir, self._systName))
# Make plot for systematics (phase-space bins integrated)
if self._hFinalShape != None:
self._hFinalShape.SetLineColor(ROOT.kBlack)
self._hSystematicsUp.SetLineColor(ROOT.kBlue)
self._hSystematicsDown.SetLineColor(ROOT.kRed)
myYmax = 15
if "2012" in self._moduleInfoString:
myYmax = 30
plot = plots.ComparisonManyPlot(histograms.Histo(self._hFinalShape, "Nominal", drawStyle="E"),
[histograms.Histo(self._hSystematicsUp, "Up", drawStyle="E"), histograms.Histo(self._hSystematicsDown, "Down", drawStyle="E")])
plot.createFrame("%s/Systematics_%s/QCDInvertedShapeWithMetSyst_final_%s"%(self._myDir, self._systName, self._moduleInfoString), createRatio=True, opts2={"ymin": 0, "ymax": 2}, opts={"addMCUncertainty": True, "ymin": -5, "ymax": myYmax})
plot.frame.GetXaxis().SetTitle(self._histoSpecs["xtitle"])
plot.frame.GetYaxis().SetTitle(self._histoSpecs["ytitle"])
plot.setLegend(histograms.createLegend(0.59, 0.70, 0.87, 0.90))
plot.legend.SetFillColor(0)
plot.legend.SetFillStyle(1001)
styles.mcStyle(plot.histoMgr.getHisto("Up"))
#plot.histoMgr.getHisto("Up").getRootHisto().SetMarkerSize(0)
styles.mcStyle2(plot.histoMgr.getHisto("Down"))
styles.dataStyle(plot.histoMgr.getHisto("Nominal"))
self._drawPlot(plot)
# Make plots for systematics (for each phase-space bin separately)
nSplitBins = self._myCtrlRegion.getNumberOfPhaseSpaceSplitBins()
myCtrlHistograms = self._mySystObject.getHistogramsForCtrlRegion()
mySignalHistograms = self._mySystObject.getHistogramsForSignalRegion()
myMinIndex = 0
if myCtrlHistograms[0] == None:
myMinIndex = 1 # Skip empty first bin
for i in range(myMinIndex, nSplitBins):
plot = plots.ComparisonPlot(histograms.Histo(mySignalHistograms[i].Clone(), "Signal region", drawStyle="E"),
histograms.Histo(myCtrlHistograms[i].Clone(), "Ctrl. region", drawStyle="E"))
plot.createFrame("%s/Systematics_%s/QCDInvertedShapeWithMetSyst_%s_%s"%(self._myDir, self._systName, self._myCtrlRegion.getPhaseSpaceBinFileFriendlyTitle(i), self._moduleInfoString), createRatio=True, opts2={"ymin": 0, "ymax": 2}, opts={"addMCUncertainty": True, "ymin": -0.05, "ymax": 0.3})
plot.frame.GetXaxis().SetTitle(self._histoSpecs["xtitle"])
plot.frame.GetYaxis().SetTitle("Arb. units. (Normalised to 1)")
styles.mcStyle(plot.histoMgr.getHisto("Ctrl. region"))
styles.dataStyle(plot.histoMgr.getHisto("Signal region"))
plot.setLegend(histograms.createLegend(0.59, 0.77, 0.87, 0.90))
plot.legend.SetFillColor(0)
plot.legend.SetFillStyle(1001)
#plot.histoMgr.getHisto("Up").getRootHisto().SetMarkerSize(0)
self._drawPlot(plot)
print "Saved MET shape systematics plot for bin %s"%self._myCtrlRegion.getPhaseSpaceBinFileFriendlyTitle(i)
def createPlot(histo, myLumi, legendLabel, sLegStyle, sDrawStyle, **kwargs):
style = tdrstyle.TDRStyle()
if isinstance(histo, ROOT.TH1):
args = {"legendStyle": sLegStyle, "drawStyle": sDrawStyle}
args.update(kwargs)
histo.GetZaxis().SetTitle("")
#p = plots.PlotBase([histograms.Histo(histo, legendLabel, **args)])
p = plots.ComparisonManyPlot(histograms.Histo(histo, legendLabel, **args), [])
p.setLuminosity(myLumi)
return p
else:
print "*** ERROR: Histogram \"%s\" is not a valid instance of a ROOT.TH1" % (histo)
sys.exit()
def PlotTFsCompare(pName, sKeys, gList, isRatio=False):
# Finally do a all-in=one plot
plot = plots.ComparisonManyPlot(gList[0], gList[1:])
for k in sKeys:
plot.histoMgr.setHistoLegendLabelMany({
k: k,
})
# For-loop: All graphs
for i, s in enumerate(sKeys, 1):
# Reference histo is exception (draw just a line)
if s == opts.refHisto:
# plot.histoMgr.setHistoDrawStyle(s, "L")
# plot.histoMgr.setHistoLegendStyle(s, "L")
# plot.histoMgr.setHistoDrawStyle(s, "C3") # curve && filled area is drawn through end points of errors
# plot.histoMgr.setHistoLegendStyle(s, "F")
# plot.histoMgr.setHistoDrawStyle(s, "P2")
# plot.histoMgr.setHistoLegendStyle(s, "LP")
plot.histoMgr.setHistoDrawStyle(
s, "C4"
) # curve && smoothed filled area is drawn through end points of errors
plot.histoMgr.setHistoLegendStyle(s, "LF")
else:
plot.histoMgr.setHistoDrawStyle(s, "P")
plot.histoMgr.setHistoLegendStyle(s, "LP")
#
#plot.histoMgr.setHistoDrawStyle(s, "4") # curve && smoothed filled area is drawn through end points of errors
#plot.histoMgr.setHistoLegendStyle(s, "F")
plot.setLegend(getLegend(opts, dx=+0.0, dy=-0.15))
plot.createFrame(pName, saveFormats=[])
plot.frame.GetXaxis().SetTitle("")
plot.frame.GetYaxis().SetTitle("transfer factor")
plot.draw()
plot.setLuminosity(opts.intLumi)
plot.addStandardTexts(addLuminosityText=False, cmsTextPosition="outframe")
SavePlot(plot, pName, os.path.join(opts.saveDir, ""))
return
def plotClosure(mt_nom, mts_var, name, optMode):
#for mt_var in mts_var:
# printSummedDifference(mt_nom, mt_var)
style = tdrstyle.TDRStyle()
plot = plots.ComparisonManyPlot(mt_nom, mts_var)
plot.createFrame(optMode.replace("Opt", "mT_Closure_" + name + "_"),
createRatio=True)
moveLegend = {"dx": -0.325, "dy": 0.02, "dw": -0.14, "dh": -0.12}
plot.setLegend(
histograms.moveLegend(histograms.createLegend(), **moveLegend))
histograms.addText(
0.65, 0.3,
optMode.replace("OptQCDTailKiller", "R_{BB} ").replace("Plus", ""), 25)
histograms.addStandardTexts()
plot.draw()
plot.save()
def main(argv):
multicrabDir = sys.argv[1]
if not os.path.exists(multicrabDir) or not os.path.isdir(multicrabDir):
usage()
# Apply TDR style
style = tdrstyle.TDRStyle()
# Construct datasets as stated in the multicrab.cfg of the execution
# directory. The returned object is of type DatasetManager.
datasets = dataset.getDatasetsFromMulticrabCfg(directory = multicrabDir)
datasetlist = datasets.getMCDatasets()
qlist_particle = ["Pt","Phi","Eta"]
qlist_met = ["Et","Phi"]
qlist_b = ["Pt","Eta"]
if mass < 175:
objects = {
"Hplus/associatedB" : qlist_particle,
"Hplus/hplus" : qlist_particle,
"Hplus/associatedT" : qlist_particle,
"Hplus/associatedSecondaryT" : qlist_particle,
"Hplus/associatedTau" : qlist_particle,
"Hplus/associatedOneProngTau" : qlist_particle,
"met" : qlist_met
}
else:
objects = {
"Hplus/associatedB" : qlist_particle,
"Hplus/associatedSecondaryB" : qlist_b,
"Hplus/hplus" : qlist_particle,
"Hplus/associatedT" : qlist_particle,
"Hplus/associatedTau" : qlist_particle,
"Hplus/associatedOneProngTau" : qlist_particle,
"met" : qlist_met
}
colorlist = [1,2,4,5]
print "These objects are considered: ", objects.keys()
object_dict={
"met" : "Gen MET",
"associatedB" : "associated b",
"associatedT" : "associated t",
"associatedSecondaryB" : "b (from associated t decay)",
"associatedSecondaryT" : "t (from t#bar{t}, t#rightarrow bW)",
"hplus" : "H^{#pm}",
"associatedTau" : "associated #tau",
"associatedOneProngTau" : "associated 1-prong #tau"
}
quantity_dict={
'Et' : '(GeV)',
"Pt" : "p_{T} (GeV)",
"Phi" : "#phi",
"Eta" : "#eta"
}
gen_dict = {
'PYTHIA6' : 'Pythia 6 (LO)',
'PYTHIA8' : 'Pythia 8',
'2HDMII' : 'MG 2HDM type II',
'2HDMtypeII' : 'MG 2HDM type II',
'MSSM' :'MG5_aMC@NLO MSSM',
'LowTanb' : 'Low tan#beta',
'2HDMtypeII_LO' : 'MG5_aMC@NLO (LO)',
'2HDMtypeII_NLO' : 'MG5_aMC@NLO (NLO)'
}
for obj in objects.keys():
for quantity in objects[obj]:
HISTONAME = obj + quantity
histos = []
for i in range(0,len(datasetlist)):
name = datasetlist[i].getName()
histotuple = datasetlist[i].getRootHisto(HISTONAME)
histo = histotuple[0].Clone()
if histo.Integral() == 0:
print "Warning, histogram",histo.GetName(),"is empty"
continue
if len(datasetlist) > 1:
histo.Scale(1/histo.Integral())
histo.SetLineColor(colorlist[i])
histo.SetName(gen_dict[name])
histos.append(histo)
myParams = {}
if len(obj.split("/")) > 1:
obj_name = obj.split("/")[1]
else:
obj_name = obj
xmin = None
xmax = None
if quantity == "Phi":
myParams["moveLegend"] = {"dx": -0.25, "dy": -0.2, "dh": -0.1}
ymin = 0
ymax = 0.012
elif quantity == "Eta":
myParams["moveLegend"] = {"dx": -0.25, "dy": 0.0, "dh": -0.1}
myParams["log"] = True
xmin = -2.5
xmax = 2.5
ymin = 0.005
ymax = 0.05
if mass > 175:
if "associatedB" in obj_name:
xmin = -4.0
xmax = 4.0
ymax = 0.02
else:
myParams["moveLegend"] = {"dx": -0.25, "dy": 0.0, "dh": -0.1}
myParams["log"] = True
ymin = 0.00005
ymax = 0.5
if obj_name == "associatedB":
ymin = ymin/5
if mass > 175:
ymin = ymin*10
if len(histos) > 1:
myParams["ratio"] = True
myParams["opts2"] = {"ymin": 0.0, "ymax":2.0}
myParams["ylabel"] = "#LT Events / bin #GT, normalized"
if xmin and xmax:
myParams["opts"] = {"xmin": xmin, "xmax": xmax, "ymin": ymin, "ymax": ymax}
else:
myParams["opts"] = {"ymin": ymin, "ymax": ymax}
else:
myParams["ylabel"] = "#LT Events / bin #GT"
myParams["xlabel"] = object_dict[obj_name]+" "+quantity_dict[quantity]
if len(histos) <= 1:
plot = plots.PlotBase(histos)
else:
default = histos[0]
compared = histos[1:]
plot = plots.ComparisonManyPlot(default, compared)
plot.saveFormats=formats
tb = histograms.PlotTextBox(xmin=0.75, ymin=None, xmax=0.85, ymax=0.1, size=25, lineheight=0.035)
tb.addText("m_{H^+} = %s GeV"%mass)
plot.appendPlotObject(tb)
histograms.createLegend.setDefaults(textSize = 0.045)
def customYTitleOffset(p):
if quantity != "Pt":
scale = 1.2
else:
scale = 1
yaxis = p.getFrame().GetYaxis()
yaxis.SetTitleOffset(scale*yaxis.GetTitleOffset())
if len(histos) > 1:
myParams["customise"] = customYTitleOffset
if not os.path.exists(plotDir):
os.mkdir(plotDir)
plots.drawPlot(plot, os.path.join(plotDir,obj_name+quantity), **myParams)
def DoPlots(datasetsMgr, histoName):
analysisType = "Inverted"
# Get the Inclusive (Data, EWK)
p1 = plots.ComparisonPlot(*getHistos(datasetsMgr, histoName, analysisType))
p1.histoMgr.normalizeMCToLuminosity(
datasetsMgr.getDataset("Data").getLuminosity())
# Get histos
inverted_Data = p1.histoMgr.getHisto("Data").getRootHisto().Clone(
"Inverted-Data")
inverted_EWK = p1.histoMgr.getHisto("EWK").getRootHisto().Clone(
"Inverted-EWK")
inverted_QCD = p1.histoMgr.getHisto("Data").getRootHisto().Clone(
"Inverted-QCD")
# Normalize histograms to unit area
inverted_Data.Scale(1.0 / inverted_QCD.Integral())
inverted_QCD.Scale(1.0 / inverted_QCD.Integral())
inverted_EWK.Scale(1.0 / inverted_EWK.Integral())
# Create the final plot object (Cannot subtract EWK from Data since the trigger in the MC samples is NOT prescaled. In data it is)
p = plots.ComparisonManyPlot(inverted_Data, [inverted_EWK], saveFormats=[])
#p = plots.PlotBase([inverted_Data], saveFormats=[])
# Apply styles
p.histoMgr.forHisto("Inverted-Data", styles.getDataStyle())
#p.histoMgr.forHisto("Inverted-QCD" , styles.getInvertedLineStyle() )
p.histoMgr.forHisto("Inverted-EWK", styles.getAltEWKStyle())
# Set draw style
p.histoMgr.setHistoDrawStyle("Inverted-Data", "AP")
#p.histoMgr.setHistoDrawStyle("Inverted-QCD" , "HIST")
p.histoMgr.setHistoDrawStyle("Inverted-EWK", "AP")
# Set legend style
p.histoMgr.setHistoLegendStyle("Inverted-Data", "P")
#p.histoMgr.setHistoLegendStyle("Inverted-QCD" , "L")
p.histoMgr.setHistoLegendStyle("Inverted-EWK", "P")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Inverted-Data": "Data",
"Inverted-EWK": "EWK",
#"Inverted-QCD" : "QCD=Data-EWK",
})
# Draw the histograms
_cutBox = None
_rebinX = 1
#_opts = {"ymin": 1e-4, "ymaxfactor": 2.0}
_opts = {"ymin": 1e-4, "ymax": 1e-1}
_xlabel = None
_units = "GeV/c^{2}"
_xlabel = "m_{jjb} (%s)" % _units
_ylabel = "Arbitrary Units / %0.0f %s " % (inverted_QCD.GetBinWidth(0),
_units)
_cutBox = {
"cutValue": 173.21,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
_opts["xmax"] = 1500.0
# Complains (SysError in <TFile::TFile>: file ...)
if 0:
plots.drawPlot(p,
histoName,
xlabel=_xlabel,
ylabel=_ylabel,
log=True,
rebinX=_rebinX,
cmsExtraText="Preliminary",
createLegend={
"x1": 0.62,
"y1": 0.78,
"x2": 0.92,
"y2": 0.92
},
opts=_opts)
if 1:
plots.drawPlot(
p,
histoName,
xlabel=_xlabel,
ylabel=_ylabel,
log=True,
rebinX=_rebinX,
cmsExtraText="Preliminary",
createLegend={
"x1": 0.62,
"y1": 0.78,
"x2": 0.92,
"y2": 0.92
},
opts=_opts,
opts2={
"ymin": 0.0,
"ymax": 2.0
},
ratio=True,
ratioInvert=False,
ratioYlabel="Ratio",
cutBox=_cutBox,
)
# Save to ROOT file
inverted_QCD.SaveAs("Inverted_QCD.root")
# Save plot in all formats
SavePlot(p, histoName, os.path.join(opts.saveDir, "Test", opts.optMode))
return
def analyze(analysis=None):
paths = [sys.argv[1]]
if not analysis == None:
datasets = dataset.getDatasetsFromMulticrabDirs(
paths,
analysisName=analysis,
excludeTasks="Silver|GluGluHToTauTau_M125")
else:
datasets = dataset.getDatasetsFromMulticrabDirs(
paths, excludeTasks="Silver|GluGluHToTauTau_M125")
analysis = datasets.getAllDatasets()[0].getAnalysisName()
# datasetsDY = None
datasetsDY = dataset.getDatasetsFromMulticrabDirs(
paths, analysisName=analysis, includeOnlyTasks="DYJetsToLL")
# datasets = dataset.getDatasetsFromMulticrabDirs(paths,analysisName=analysis,excludeTasks="GluGluHToTauTau_M125|TTJets")
datasetsH125 = None
# datasetsH125 = dataset.getDatasetsFromMulticrabDirs(paths,analysisName=analysis,includeOnlyTasks="GluGluHToTauTau_M125",emptyDatasetsAsNone=True)
# datasetsH125 = dataset.getDatasetsFromMulticrabDirs(paths,analysisName=analysis,includeOnlyTasks="GluGluHToTauTau_M125")
datasets.loadLuminosities()
style = tdrstyle.TDRStyle()
dataset1 = datasets.getDataDatasets()
dataset2 = dataset1
# dataset2 = datasets.getMCDatasets()
if not datasetsDY == None:
dataset2 = datasetsDY.getMCDatasets()
eff1 = getEfficiency(dataset1)
eff2 = getEfficiency(dataset2)
if isinstance(datasetsH125, dataset.DatasetManager):
eff3 = getEfficiency(datasetsH125.getMCDatasets())
styles.dataStyle.apply(eff1)
styles.mcStyle.apply(eff2)
eff1.SetMarkerSize(1)
# eff2.SetMarkerSize(1.5)
if isinstance(datasetsH125, dataset.DatasetManager):
styles.mcStyle.apply(eff3)
eff3.SetMarkerSize(1.5)
eff3.SetMarkerColor(4)
eff3.SetLineColor(4)
# p = plots.ComparisonPlot(histograms.HistoGraph(eff1, "eff1", "p", "P"),
# histograms.HistoGraph(eff2, "eff2", "p", "P"))
if isinstance(datasetsH125, dataset.DatasetManager):
p = plots.ComparisonManyPlot(
histograms.HistoGraph(eff1, "eff1", "p", "P"), [
histograms.HistoGraph(eff2, "eff2", "p", "P"),
histograms.HistoGraph(eff3, "eff3", "p", "P")
])
elif isinstance(datasetsDY, dataset.DatasetManager):
p = plots.ComparisonPlot(histograms.HistoGraph(eff1, "eff1", "p", "P"),
histograms.HistoGraph(eff2, "eff2", "p", "P"))
else:
p = plots.PlotBase([histograms.HistoGraph(eff1, "eff1", "p", "P")])
fit("Data", p, eff1, 20, 200)
fit("MC", p, eff2, 20, 200)
if isinstance(datasetsH125, dataset.DatasetManager):
fit("H125", p, eff3, 20, 200)
opts = {"ymin": 0, "ymax": 1.1}
opts2 = {"ymin": 0.5, "ymax": 1.5}
# moveLegend = {"dx": -0.55, "dy": -0.15, "dh": -0.1}
moveLegend = {"dx": -0.2, "dy": -0.5, "dh": -0.1}
name = "TauMET_" + analysis + "_DataVsMC_PFTauPt"
legend1 = "Data"
# legend2 = "MC (DY)"
legend2 = "Simulation"
legend3 = "MC (H125)"
createRatio = False
p.histoMgr.setHistoLegendLabelMany({"eff1": legend1})
if isinstance(datasetsDY, dataset.DatasetManager):
p.histoMgr.setHistoLegendLabelMany({"eff1": legend1, "eff2": legend2})
createRatio = True
if isinstance(datasetsH125, dataset.DatasetManager):
p.histoMgr.setHistoLegendLabelMany({
"eff1": legend1,
"eff2": legend2,
"eff3": legend3
})
if createRatio:
p.createFrame(os.path.join(plotDir, name),
createRatio=createRatio,
opts=opts,
opts2=opts2)
else:
p.createFrame(os.path.join(plotDir, name), opts=opts, opts2=opts2)
p.setLegend(histograms.moveLegend(histograms.createLegend(), **moveLegend))
p.getFrame().GetYaxis().SetTitle("HLT tau efficiency")
# p.getFrame().GetXaxis().SetTitle("#tau-jet p_{T} (GeV/c)")
p.getFrame().GetXaxis().SetTitle("#tau_{h} p_{T} (GeV/c)")
if createRatio:
p.getFrame2().GetYaxis().SetTitle("Ratio")
p.getFrame2().GetYaxis().SetTitleOffset(1.6)
histograms.addText(0.5, 0.6, "LooseIsoPFTau50_Trk30_eta2p1", 17)
# label = analysis.split("_")[len(analysis.split("_")) -1]
label = "2016"
histograms.addText(0.5, 0.53, label, 17)
runRange = datasets.loadRunRange()
histograms.addText(0.5, 0.46, "Runs " + runRange, 17)
p.draw()
lumi = 0.0
for d in datasets.getDataDatasets():
print "luminosity", d.getName(), d.getLuminosity()
lumi += d.getLuminosity()
print "luminosity, sum", lumi
histograms.addStandardTexts(lumi=lumi)
if not os.path.exists(plotDir):
os.mkdir(plotDir)
p.save(formats)
pythonWriter.addParameters(plotDir, label, runRange, lumi, eff1)
pythonWriter.addMCParameters(label, eff2)
pythonWriter.writeJSON(
os.path.join(plotDir, "tauLegTriggerEfficiency_" + label + ".json"))
# if not createRatio:
# sys.exit()
#########################################################################
eff1eta = getEfficiency(dataset1, "NumeratorEta", "DenominatorEta")
eff2eta = getEfficiency(dataset2, "NumeratorEta", "DenominatorEta")
if isinstance(datasetsH125, dataset.DatasetManager):
eff3eta = getEfficiency(datasetsH125.getMCDatasets(), "NumeratorEta",
"DenominatorEta")
styles.dataStyle.apply(eff1eta)
styles.mcStyle.apply(eff2eta)
eff1eta.SetMarkerSize(1)
if isinstance(datasetsH125, dataset.DatasetManager):
styles.mcStyle.apply(eff3eta)
eff3eta.SetMarkerSize(1.5)
eff3eta.SetMarkerColor(4)
eff3eta.SetLineColor(4)
if isinstance(datasetsH125, dataset.DatasetManager):
p_eta = plots.ComparisonManyPlot(
histograms.HistoGraph(eff1eta, "eff1eta", "p", "P"), [
histograms.HistoGraph(eff2eta, "eff2eta", "p", "P"),
histograms.HistoGraph(eff3eta, "eff3eta", "p", "P")
])
elif isinstance(datasetsDY, dataset.DatasetManager):
p_eta = plots.ComparisonPlot(
histograms.HistoGraph(eff1eta, "eff1eta", "p", "P"),
histograms.HistoGraph(eff2eta, "eff2eta", "p", "P"))
else:
p_eta = plots.PlotBase(
[histograms.HistoGraph(eff1eta, "eff1eta", "p", "P")])
p_eta.histoMgr.setHistoLegendLabelMany({"eff1eta": legend1})
if isinstance(datasetsDY, dataset.DatasetManager):
p_eta.histoMgr.setHistoLegendLabelMany({
"eff1eta": legend1,
"eff2eta": legend2
})
if isinstance(datasetsH125, dataset.DatasetManager):
p_eta.histoMgr.setHistoLegendLabelMany({
"eff1eta": legend1,
"eff2eta": legend2,
"eff3eta": legend3
})
name = "TauMET_" + analysis + "_DataVsMC_PFTauEta"
if createRatio:
p_eta.createFrame(os.path.join(plotDir, name),
createRatio=createRatio,
opts=opts,
opts2=opts2)
else:
p_eta.createFrame(os.path.join(plotDir, name), opts=opts, opts2=opts2)
moveLegendEta = {"dx": -0.5, "dy": -0.65, "dh": -0.1}
p_eta.setLegend(
histograms.moveLegend(histograms.createLegend(), **moveLegendEta))
p_eta.getFrame().GetYaxis().SetTitle("HLT tau efficiency")
p_eta.getFrame().GetXaxis().SetTitle("#tau-jet #eta")
if createRatio:
p_eta.getFrame2().GetYaxis().SetTitle("Ratio")
p_eta.getFrame2().GetYaxis().SetTitleOffset(1.6)
histograms.addText(0.2, 0.46, "LooseIsoPFTau50_Trk30_eta2p1", 17)
histograms.addText(0.2, 0.38, label, 17)
histograms.addText(0.2, 0.31, "Runs " + datasets.loadRunRange(), 17)
p_eta.draw()
histograms.addStandardTexts(lumi=lumi)
p_eta.save(formats)
#########################################################################
eff1phi = getEfficiency(dataset1, "NumeratorPhi", "DenominatorPhi")
eff2phi = getEfficiency(dataset2, "NumeratorPhi", "DenominatorPhi")
if isinstance(datasetsH125, dataset.DatasetManager):
eff3phi = getEfficiency(datasetsH125.getMCDatasets(), "NumeratorPhi",
"DenominatorPhi")
styles.dataStyle.apply(eff1phi)
styles.mcStyle.apply(eff2phi)
eff1phi.SetMarkerSize(1)
if isinstance(datasetsH125, dataset.DatasetManager):
styles.mcStyle.apply(eff3phi)
eff3phi.SetMarkerSize(1.5)
eff3phi.SetMarkerColor(4)
eff3phi.SetLineColor(4)
if isinstance(datasetsH125, dataset.DatasetManager):
p_phi = plots.ComparisonManyPlot(
histograms.HistoGraph(eff1phi, "eff1phi", "p", "P"), [
histograms.HistoGraph(eff2phi, "eff2phi", "p", "P"),
histograms.HistoGraph(eff3phi, "eff3phi", "p", "P")
])
elif isinstance(datasetsDY, dataset.DatasetManager):
p_phi = plots.ComparisonPlot(
histograms.HistoGraph(eff1phi, "eff1phi", "p", "P"),
histograms.HistoGraph(eff2phi, "eff2phi", "p", "P"))
else:
p_phi = plots.PlotBase(
[histograms.HistoGraph(eff1phi, "eff1phi", "p", "P")])
p_phi.histoMgr.setHistoLegendLabelMany({"eff1phi": legend1})
if isinstance(datasetsDY, dataset.DatasetManager):
p_phi.histoMgr.setHistoLegendLabelMany({
"eff1phi": legend1,
"eff2phi": legend2
})
if isinstance(datasetsH125, dataset.DatasetManager):
p_phi.histoMgr.setHistoLegendLabelMany({
"eff1phi": legend1,
"eff2phi": legend2,
"eff3phi": legend3
})
name = "TauMET_" + analysis + "_DataVsMC_PFTauPhi"
if createRatio:
p_phi.createFrame(os.path.join(plotDir, name),
createRatio=createRatio,
opts=opts,
opts2=opts2)
else:
p_phi.createFrame(os.path.join(plotDir, name), opts=opts, opts2=opts2)
moveLegendPhi = {"dx": -0.5, "dy": -0.65, "dh": -0.1}
p_phi.setLegend(
histograms.moveLegend(histograms.createLegend(), **moveLegendPhi))
p_phi.getFrame().GetYaxis().SetTitle("HLT tau efficiency")
p_phi.getFrame().GetXaxis().SetTitle("#tau-jet #phi")
if createRatio:
p_phi.getFrame2().GetYaxis().SetTitle("Ratio")
p_phi.getFrame2().GetYaxis().SetTitleOffset(1.6)
histograms.addText(0.2, 0.46, "LooseIsoPFTau50_Trk30_eta2p1", 17)
histograms.addText(0.2, 0.38, label, 17)
histograms.addText(0.2, 0.31, "Runs " + datasets.loadRunRange(), 17)
p_phi.draw()
histograms.addStandardTexts(lumi=lumi)
p_phi.save(formats)
#########################################################################
namePU = "TauMET_" + analysis + "_DataVsMC_nVtx"
eff1PU = getEfficiency(dataset1, "NumeratorPU", "DenominatorPU")
eff2PU = getEfficiency(dataset2, "NumeratorPU", "DenominatorPU")
styles.dataStyle.apply(eff1PU)
styles.mcStyle.apply(eff2PU)
eff1PU.SetMarkerSize(1)
eff2PU.SetMarkerSize(1.5)
if isinstance(datasetsDY, dataset.DatasetManager):
pPU = plots.ComparisonManyPlot(
histograms.HistoGraph(eff1PU, "eff1", "p", "P"),
[histograms.HistoGraph(eff2PU, "eff2", "p", "P")])
pPU.histoMgr.setHistoLegendLabelMany({
"eff1": legend1,
"eff2": legend2
})
else:
pPU = plots.PlotBase([histograms.HistoGraph(eff1PU, "eff1", "p", "P")])
pPU.histoMgr.setHistoLegendLabelMany({"eff1": legend1})
optsPU = {"ymin": 0.01, "ymax": 1.0}
createRatio = False
if createRatio:
pPU.createFrame(os.path.join(plotDir, namePU),
createRatio=True,
opts=optsPU,
opts2=opts2)
else:
pPU.createFrame(os.path.join(plotDir, namePU),
opts=optsPU,
opts2=opts2)
moveLegend = {"dx": -0.5, "dy": -0.5, "dh": -0.1}
pPU.setLegend(
histograms.moveLegend(histograms.createLegend(), **moveLegend))
# if createRatio:
# pPU.getPad1().SetLogy(True)
# else:
# pPU.getPad().SetLogy(True)
pPU.getFrame().GetYaxis().SetTitle("HLT tau efficiency")
pPU.getFrame().GetXaxis().SetTitle("Number of reco vertices")
if createRatio:
pPU.getFrame2().GetYaxis().SetTitle("Ratio")
pPU.getFrame2().GetYaxis().SetTitleOffset(1.6)
histograms.addText(0.2, 0.6, "LooseIsoPFTau50_Trk30_eta2p1", 17)
histograms.addText(0.2, 0.53, label, 17)
histograms.addText(0.2, 0.46, "Runs " + datasets.loadRunRange(), 17)
pPU.draw()
histograms.addStandardTexts(lumi=lumi)
pPU.save(formats)
#########################################################################
"""
hName = "Pull"
# hName = "Sub"
namePull = "TauMET_"+analysis+"_DataVsMC_"+hName+"s"
plots.mergeRenameReorderForDataMC(datasets)
datasets.merge("MC", ["TT","WJets","DYJetsToLL","SingleTop","QCD"], keepSources=True)
drh1 = datasets.getDataset("Data").getDatasetRootHisto(hName)
drh2 = datasets.getDataset("MC").getDatasetRootHisto(hName)
drh1.normalizeToOne()
drh2.normalizeToOne()
pull1 = drh1.getHistogram()
pull2 = drh2.getHistogram()
if isinstance(datasetsH125,dataset.DatasetManager):
plots.mergeRenameReorderForDataMC(datasetsH125)
drh3 = datasetsH125.getMCDatasets()[0].getDatasetRootHisto(hName)
drh3.normalizeToOne()
pull3 = drh3.getHistogram()
styles.dataStyle.apply(pull1)
styles.mcStyle.apply(pull2)
pull1.SetMarkerSize(1)
if isinstance(datasetsH125,dataset.DatasetManager):
styles.mcStyle.apply(pull3)
pull3.SetMarkerSize(1.5)
pull3.SetMarkerColor(4)
pull3.SetLineColor(4)
if isinstance(datasetsH125,dataset.DatasetManager):
p_pull = plots.ComparisonManyPlot(histograms.Histo(pull1, "pull1", "p", "P"),
[histograms.Histo(pull2, "pull2", "p", "P"),
histograms.Histo(pull3, "pull3", "p", "P")])
else:
p_pull = plots.ComparisonPlot(histograms.Histo(pull1, "pull1", "p", "P"),
histograms.Histo(pull2, "pull2", "p", "P"))
p_pull.histoMgr.setHistoLegendLabelMany({"pull1": legend1, "pull2": legend2})
if isinstance(datasetsH125,dataset.DatasetManager):
p_pull.histoMgr.setHistoLegendLabelMany({"pull1": legend1, "pull2": legend2, "pull3": legend3})
p_pull.createFrame(os.path.join(plotDir, namePull), createRatio=True, opts=opts, opts2=opts2)
moveLegendPull = {"dx": -0.5, "dy": -0.35, "dh": -0.1}
p_pull.setLegend(histograms.moveLegend(histograms.createLegend(), **moveLegendPull))
p_pull.getFrame().GetYaxis().SetTitle("Arbitrary units")
# p_pull.getFrame().GetXaxis().SetTitle("HLT #tau p_{T} - #tau-jet p_{T} (GeV/c)")
p_pull.getFrame().GetXaxis().SetTitle("HLT #tau p_{T}/ #tau-jet p_{T} - 1")
p_pull.getFrame2().GetYaxis().SetTitle("Ratio")
p_pull.getFrame2().GetYaxis().SetTitleOffset(1.6)
histograms.addText(0.2, 0.75, "LooseIsoPFTau50_Trk30_eta2p1", 17)
histograms.addText(0.2, 0.68, analysis.split("_")[len(analysis.split("_")) -1], 17)
histograms.addText(0.2, 0.61, "Runs "+runRange, 17)
p_pull.draw()
histograms.addStandardTexts(lumi=lumi)
p_pull.save(formats)
"""
#########################################################################
print "Output written in", plotDir
def PlotPurity(datasetsMgr, histoName):
'''
Create plots with "FakeB=Data-EWKGenuineB"
'''
Verbose("Plotting histogram %s for Data, EWK, QCD " % (histoName), True)
# Which folder to use (redundant)
defaultFolder = "FakeBPurity"
genuineBFolder = defaultFolder + "EWKGenuineB"
fakeBFolder = defaultFolder + "EWKFakeB"
# Customize the histograms (BEFORE calculating purity obviously otherwise numbers are nonsense)
_cutBox = None
_rebinX = 1
_opts = {"ymin": 1e-3, "ymax": 1.0} #"ymaxfactor": 1.2}
_format = "%0.0f"
#_opts["xmax"] = xMax
_xlabel = None
_ylabel = "Purity / "
_format = "/ %.0f "
h = histoName.split("/")[-1]
if "dijetm" in h.lower():
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jj} (%s)" % (_units)
_cutBox = {
"cutValue": 80.399,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
if "trijetm" in h.lower():
_rebinX = 2
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jjb} (%s)" % _units
_cutBox = {
"cutValue": 173.21,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
_opts["xmax"] = 1000.0
if "pt" in h.lower():
_format = "%0.0f GeV/c"
if "chisqr" in h.lower():
_opts["xmax"] = 100.0
if "allselections" in h.lower():
_opts["xmax"] = 10.0
#if histo.lower().endswith("met_et"):
if h.lower().startswith("ht_"):
_rebinX = 5
_units = "GeV/c"
_format = "%0.0f " + _units
_xlabel = "H_{T} (%s)" % _units
_cutBox = {
"cutValue": 500.0,
"fillColor": 16,
"box": False,
"line": False,
"greaterThan": True
}
_opts["xmin"] = 500.0
_opts["xmax"] = 3500.0
if "eta" in h.lower():
_rebinX = 1
_format = "%0.2f"
_cutBox = {
"cutValue": 0.,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
_opts["xmin"] = -3.0
_opts["xmax"] = +3.0
if "deltaeta" in h.lower():
_format = "%0.2f"
_opts["xmin"] = 0.0
_opts["xmax"] = 6.0
if "bdisc" in h.lower():
_format = "%0.2f"
if "tetrajetm" in h.lower():
_rebinX = 4
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jjbb} (%s)" % (_units)
_opts["xmax"] = 2500.0
if "pt_" in h.lower():
_rebinX = 2
_ylabel += _format
# Get histos (Data, EWK) for Inclusive
p1 = plots.ComparisonPlot(*getHistos(datasetsMgr, histoName))
p1.histoMgr.normalizeMCToLuminosity(
datasetsMgr.getDataset("Data").getLuminosity())
# Clone histograms
Data = p1.histoMgr.getHisto("Data").getRootHisto().Clone("Data")
EWK = p1.histoMgr.getHisto("EWK").getRootHisto().Clone("EWK")
QCD = p1.histoMgr.getHisto("Data").getRootHisto().Clone("QCD")
# Rebin histograms (Before calculating Purity)
Data.Rebin(_rebinX)
EWK.Rebin(_rebinX)
QCD.Rebin(_rebinX)
# Get QCD = Data-EWK
QCD.Add(EWK, -1)
# Comparison plot. The first argument is the reference histo. All other histograms are compared with respect to that.
QCD_Purity, xMin, xMax, binList, valueDict, upDict, downDict = getPurityHisto(
QCD, Data, inclusiveBins=False, printValues=False)
EWK_Purity, xMin, xMax, binList, valueDict, upDict, downDict = getPurityHisto(
EWK, Data, inclusiveBins=False, printValues=False)
# Create TGraphs
if 0:
gQCD_Purity = MakeGraph(ROOT.kFullTriangleUp, ROOT.kOrange, binList,
valueDict, upDict, downDict)
gEWK_Purity = MakeGraph(ROOT.kFullTriangleDown, ROOT.kPurple, binList,
valueDict, upDict, downDict)
# Make the plots
if opts.plotEWK:
p = plots.ComparisonManyPlot(QCD_Purity, [EWK_Purity], saveFormats=[])
else:
p = plots.PlotBase([QCD_Purity], saveFormats=[])
# Apply histo styles
p.histoMgr.forHisto("QCD", styles.getQCDLineStyle())
if opts.plotEWK:
p.histoMgr.forHisto("EWK", styles.getAltEWKLineStyle())
# Set draw style
p.histoMgr.setHistoDrawStyle("QCD", "P")
if opts.plotEWK:
p.histoMgr.setHistoDrawStyle("EWK", "HIST")
# Set legend style
p.histoMgr.setHistoLegendStyle("QCD", "P")
if opts.plotEWK:
p.histoMgr.setHistoLegendStyle("EWK", "F")
# Set legend labels
if opts.plotEWK:
p.histoMgr.setHistoLegendLabelMany({
"QCD": "QCD",
"EWK": "EWK",
})
else:
p.histoMgr.setHistoLegendLabelMany({
"QCD": "QCD",
})
# Do the plot
plots.drawPlot(
p,
histoName,
xlabel=_xlabel,
ylabel=_ylabel,
log=False,
rebinX=1, # must be done BEFORE calculating purity
cmsExtraText="Preliminary",
createLegend={
"x1": 0.76,
"y1": 0.80,
"x2": 0.92,
"y2": 0.92
},
opts=_opts,
opts2={
"ymin": 1e-5,
"ymax": 1e0
},
ratio=False,
ratioInvert=False,
ratioYlabel="Ratio",
cutBox=_cutBox,
)
# Save plot in all formats
SavePlot(p, histoName,
os.path.join(opts.saveDir, "Purity",
opts.optMode)) #, saveFormats = [".png"] )
return
def BaselineVsInvertedComparison(datasetsMgr, histoName):
p1 = plots.ComparisonPlot(*getHistos(datasetsMgr, "Data", "topSelection_Baseline/%s" % histoName, "topSelection_Inverted/%s" % histoName))
p1.histoMgr.normalizeMCToLuminosity(datasetsMgr.getDataset("Data").getLuminosity())
p2 = plots.ComparisonPlot(*getHistos(datasetsMgr, "EWK", "topSelection_Baseline/%s" % histoName, "topSelection_Inverted/%s" % histoName) )
p2.histoMgr.normalizeMCToLuminosity(datasetsMgr.getDataset("Data").getLuminosity())
# Get Data histos
baseline_Data = p1.histoMgr.getHisto("Baseline-Data").getRootHisto().Clone("Baseline-Data")
inverted_Data = p1.histoMgr.getHisto("Inverted-Data").getRootHisto().Clone("Inverted-Data")
# Get EWK histos
baseline_EWK = p2.histoMgr.getHisto("Baseline-EWK").getRootHisto().Clone("Baseline-EWK")
inverted_EWK = p2.histoMgr.getHisto("Inverted-EWK").getRootHisto().Clone("Inverted-EWK")
# Create QCD histos: QCD = Data-EWK
baseline_QCD = p1.histoMgr.getHisto("Baseline-Data").getRootHisto().Clone("Baseline-QCD")
baseline_QCD.Add(baseline_EWK, -1)
inverted_QCD = p1.histoMgr.getHisto("Inverted-Data").getRootHisto().Clone("Inverted-QCD")
inverted_QCD.Add(inverted_EWK, -1)
# Normalize histograms to unit area
baseline_QCD.Scale(1.0/baseline_QCD.Integral())
inverted_QCD.Scale(1.0/inverted_QCD.Integral())
# Create the final plot object
p = plots.ComparisonManyPlot(baseline_QCD, [inverted_QCD], saveFormats=[]) #[".C", ".png", ".pdf"])
p.setLuminosity(GetLumi(datasetsMgr))
# Apply styles
p.histoMgr.forHisto("Baseline-QCD" , styles.getBaselineStyle() )
p.histoMgr.forHisto("Inverted-QCD" , styles.getInvertedStyle() )
# Set draw style
p.histoMgr.setHistoDrawStyle("Baseline-QCD", "AP")
p.histoMgr.setHistoLegendStyle("Baseline-QCD", "LP")
p.histoMgr.setHistoDrawStyle("Inverted-QCD", "HIST")
p.histoMgr.setHistoLegendStyle("Inverted-QCD", "F")
# p.histoMgr.setHistoLegendStyleAll("LP")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Baseline-QCD" : "Baseline (QCD)",
"Inverted-QCD" : "Inverted (QCD)",
})
# Draw the histograms
_rebinX = 1
_cutBox = None
_opts = {"ymin": 8e-5, "ymaxfactor": 2.0}
if "Pt_" in histoName:
_format = "%0.f GeV/c"
if "tetrajet" in histoName.lower():
_rebinX = 2
if "ChiSqr" in histoName:
_format = "%0.1f"
_rebinX = 10
if "After" in histoName:
_rebinX = 1
_opts["xmax"] = 20.0
if "Mass" in histoName:
_format = "%0.0f GeV/c^{2}"
_rebinX = 2
if "tetrajet" in histoName.lower():
_rebinX = 5
_opts["xmax"] = 3000.0
if "BDisc" in histoName:
_format = "%0.2f"
_rebinX = 2
_opts["xmax"] = 1.01
if "Eta" in histoName:
_format = "%0.2f"
if "trijet" in histoName.lower():
_cutBox = {"cutValue": 173.21, "fillColor": 16, "box": False, "line": True, "greaterThan": True}
if "dijet" in histoName.lower():
_cutBox = {"cutValue": 80.399, "fillColor": 16, "box": False, "line": True, "greaterThan": True}
if "TetrajetMass" in histoName:
_opts = {"ymin": 8e-5, "ymaxfactor": 2.0, "xmax": 3000.0}
plots.drawPlot(p, histoName,
ylabel = "Arbitrary Units / %s" % (_format),
log = True,
rebinX = _rebinX, cmsExtraText = "Preliminary",
createLegend = {"x1": 0.62, "y1": 0.78, "x2": 0.92, "y2": 0.92},
opts = _opts,
opts2 = {"ymin": 0.6, "ymax": 1.4},
ratio = True,
ratioInvert = False,
ratioYlabel = "Ratio",
cutBox = _cutBox,
)
# Save plot in all formats
SavePlot(p, histoName, os.path.join(opts.saveDir, "BaselineVsInverted") )
return
def main(argv):
dirs = []
if len(sys.argv) < 2:
usage()
dirs.append(sys.argv[1])
dirs_signal = ["../../SignalAnalysis_140605_143702/"]
QCDInvertedNormalization = sort(
QCDInvertedNormalizationFactors.QCDInvertedNormalization)
labels, QCDInvertedNormalizationFilteredEWKFakeTaus = getSortedLabelsAndFactors(
QCDInvertedNormalizationFactorsFilteredEWKFakeTaus.
QCDInvertedNormalization)
analysis_inverted = "signalAnalysisInvertedTau"
analysis = "signalAnalysis"
optModes = []
#optModes.append("OptQCDTailKillerZeroPlus")
optModes.append("OptQCDTailKillerLoosePlus")
optModes.append("OptQCDTailKillerMediumPlus")
optModes.append("OptQCDTailKillerTightPlus")
varHistoName = "shapeEWKGenuineTausTransverseMass"
nomHistoName = "shapeTransverseMass"
signalHistoName = "shapeEWKFakeTausTransverseMass"
#Optimal: 0.8, 0.82, 0.9
###w_list = [0.65, 0.7, 0.76] #old baseline ft
w_list = [0.66, 0.67, 0.75]
#w_list = [0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 1]
#defaultBinning = systematics.getBinningForPlot("shapeTransverseMass")
defaultBinning = [0, 20, 40, 60, 80, 100, 120, 140, 160, 200, 400]
defaultBinning_array = array.array("d", defaultBinning)
diff_opt = []
for optMode in optModes:
diff_list = []
for w in w_list:
var_values = []
nom_values = []
# baseline fake taus
mt_baseline_faketaus_data = getDataSets(dirs_signal, dataEra,
searchMode, analysis,
optMode)
mtplot_signalfaketaus = plots.DataMCPlot(mt_baseline_faketaus_data,
signalHistoName)
mt_signalfaketaus = mtplot_signalfaketaus.histoMgr.getHisto(
"EWK").getRootHisto().Clone(signalHistoName)
# inverted fake taus
mt_inverted_faketaus_data = getDataSets(dirs, dataEra, searchMode,
analysis_inverted, optMode)
histonames_var = mt_inverted_faketaus_data.getDataset(
"Data").getDirectoryContent(varHistoName)
histonames_nom = mt_inverted_faketaus_data.getDataset(
"Data").getDirectoryContent(nomHistoName)
bins_var = getBins(histonames_var, varHistoName)
bins_nom = getBins(histonames_nom, nomHistoName)
normalization_var_qg = getNormalization(
bins_var, w, QCDInvertedNormalizationFilteredEWKFakeTaus, True,
True)
normalization_var = getNormalization(
bins_var, w, QCDInvertedNormalizationFilteredEWKFakeTaus, True,
False)
normalization_nom = getNormalization(bins_nom, w,
QCDInvertedNormalization,
False, False)
mt_var_qg = getMt(mt_inverted_faketaus_data, bins_var,
varHistoName, normalization_var_qg)
mt_var = getMt(mt_inverted_faketaus_data, bins_var, varHistoName,
normalization_var)
mt_nom = getMt(mt_inverted_faketaus_data, bins_nom, nomHistoName,
normalization_nom)
mt_nom.Add(mt_signalfaketaus)
mt_var_qg.SetName(
"QCD(Data)+EWK+t#bar{t}(Data, mis-ID. #tau), q-g bal.")
mt_var.SetName("QCD(Data)+EWK+t#bar{t}(Data, mis-ID. #tau)")
mt_nom.SetName("QCD(Data)+EWK+t#bar{t}(MC, mis-ID. #tau)")
mt_var_qg.SetLineWidth(4)
mt_var.SetLineColor(14)
mt_nom.SetLineColor(2)
mt_var_qg = mt_var_qg.Rebin(
len(defaultBinning) - 1, "", defaultBinning_array)
mt_var = mt_var.Rebin(
len(defaultBinning) - 1, "", defaultBinning_array)
mt_nom = mt_nom.Rebin(
len(defaultBinning) - 1, "", defaultBinning_array)
for i in range(0, mt_nom.GetSize()):
var_values.append(mt_var_qg.GetBinContent(i))
nom_values.append(mt_nom.GetBinContent(i))
style = tdrstyle.TDRStyle()
varPlots = [mt_var, mt_var_qg]
plot = plots.ComparisonManyPlot(mt_nom, varPlots)
plot.createFrame(optMode.replace(
"Opt", "Mt_DataDrivenVsMC_" + "w=" + str(w) + "_"),
createRatio=True)
moveLegend = {"dx": -0.35, "dy": 0.05}
plot.setLegend(
histograms.moveLegend(histograms.createLegend(), **moveLegend))
histograms.addText(
0.65, 0.3,
optMode.replace("OptQCDTailKiller",
"R_{BB} ").replace("Plus", ""), 25)
histograms.addCmsPreliminaryText()
histograms.addEnergyText()
lumi = mt_inverted_faketaus_data.getDataset("Data").getLuminosity()
histograms.addLuminosityText(x=None, y=None, lumi=lumi)
plot.draw()
plot.save()
mt_var_qg.Delete()
mt_var.Delete()
mt_nom.Delete()
#TFile.CurrentFile().Close("R")
mt_baseline_faketaus_data.close()
mt_inverted_faketaus_data.close()
ROOT.gROOT.CloseFiles()
ROOT.gROOT.GetListOfCanvases().Delete()
ROOT.gDirectory.GetList().Delete()
#print var_values
#print nom_values
# difference metrics
num = 0
denom = 0
for i in range(0, len(nom_values)):
num += var_values[i] * (var_values[i] - nom_values[i])**2
denom += var_values[i]
diff = num / denom
diff_list.append(diff)
diff_opt.append(diff_list)
os.system("rm MtOptimal/*")
os.system("mkdir -p MtOptimal")
print "\nWeights:\t", w_list, '\n'
optimalWeights = {}
for i in range(0, len(diff_opt)):
print optModes[i]
print "Differences:\t", diff_opt[i], "- Optimal: w =", w_list[
diff_opt[i].index(min(diff_opt[i]))]
optimalWeights[optModes[i]] = w_list[diff_opt[i].index(min(
diff_opt[i]))]
command = "cp *" + str(w_list[diff_opt[i].index(min(
diff_opt[i]))]) + "*" + optModes[i].replace("Opt",
"") + ".eps MtOptimal"
os.system(command)
print optimalWeights
writeWeightsToFile("OptimalWeights.py", optimalWeights)
writeNormalizationToFile("QCDPlusEWKFakeTauNormalizationFactors.py",
normalization_var_qg, labels)
def main():
style = tdrstyle.TDRStyle()
# Set ROOT batch mode boolean
ROOT.gROOT.SetBatch(parseOpts.batchMode)
ROOT.gErrorIgnoreLevel = 3000
# Get all datasets from the mcrab dir
datasetsMgr = GetDatasetsFromDir(parseOpts.mcrab, kwargs.get("analysis"))
# datasetsMgr = dataset.getDatasetsFromMulticrabDirs([parseOpts.mcrab], analysisName=kwargs.get("analysis"), includeOnlyTasks="ChargedHiggs_HplusTB_HplusToTB_M_200")
# datasetsMgr = dataset.getDatasetsFromMulticrabDirs([parseOpts.mcrab], analysisName=kwargs.get("analysis"), excludeTasks="M_200")
# Determine Integrated Luminosity
intLumi = GetLumi(datasetsMgr)
# Update to PU
datasetsMgr.updateNAllEventsToPUWeighted()
# Remove datasets
datasetsMgr.remove(kwargs.get("rmDataset"))
# datasetsMgr.remove(filter(lambda name: not "QCD" in name, datasetsMgr.getAllDatasetNames()))
# datasetsMgr.remove(filter(lambda name: "QCD" in name in name, datasetsMgr.getAllDatasetNames()))
# Set custom XSections
# datasetsMgr.getDataset("TT_ext3").setCrossSection(831.76)
# Default merging & ordering: "Data", "QCD", "SingleTop", "Diboson"
plots.mergeRenameReorderForDataMC(
datasetsMgr
) #WARNING: Merged MC histograms must be normalized to something!
# Remove datasets (for merged names)
datasetsMgr.remove(kwargs.get("rmDataset"))
# datasetsMgr.remove(filter(lambda name: not "QCD" in name, datasetsMgr.getAllDatasetNames()))
# datasetsMgr.remove(filter(lambda name: "QCD" in name in name, datasetsMgr.getAllDatasetNames()))
# For-loop: All Histogram names
for hName in hNames:
savePath, saveName = GetSavePathAndName(hName, **kwargs)
# Get efficiency histos
refEff, otherEff = GetCutEfficiencyTGraphs(datasetsMgr, hName, "kFCP",
**kwargs)
# refEff, otherEff = GetCutEfficiencyTGraphs(datasetsMgr, hName, "kFFC", **kwargs)
# refEff, otherEff = GetCutEfficiencyTGraphs(datasetsMgr, hName, "kBJeffrey", **kwargs)
# refEff, otherEff = GetCutEfficiencyTGraphs(datasetsMgr, hName, "kFNormal", **kwargs)
# Plot the efficiencies
p = plots.ComparisonManyPlot(refEff, otherEff)
# Create a frame
opts = {"ymin": 0.0, "ymaxfactor": 1.2} #"ymax": 5e-1}
ratioOpts = {"ymin": 0.0, "ymaxfactor": 1.2}
p.createFrame(saveName,
createRatio=kwargs.get("createRatio"),
opts=opts,
opts2=ratioOpts)
# Customise Legend
moveLegend = {"dx": -0.1, "dy": +0.0, "dh": -0.1}
p.setLegend(
histograms.moveLegend(histograms.createLegend(), **moveLegend))
#p.removeLegend()
# Customise frame
# p.setEnergy("13")
if kwargs.get("createRatio"):
p.getFrame2().GetYaxis().SetTitle("Ratio")
p.getFrame2().GetYaxis().SetTitleOffset(1.6)
# SetLog
SetLogAndGrid(p, **kwargs)
# Add cut line/box
_kwargs = {"lessThan": kwargs.get("cutLessThan")}
p.addCutBoxAndLine(cutValue=kwargs.get("cutValue"),
fillColor=kwargs.get("cutFillColour"),
box=kwargs.get("cutBox"),
line=kwargs.get("cutLine"),
**_kwargs)
# Move the refDataset to first in the draw order (back)
histoNames = [h.getName() for h in p.histoMgr.getHistos()]
p.histoMgr.reorder(
filter(
lambda n: plots._legendLabels[kwargs.get("refDataset")] not in
n, histoNames))
# Draw plots
p.draw()
# Customise text
histograms.addStandardTexts(lumi=intLumi)
# histograms.addText(0.4, 0.9, "Alexandros Attikis", 17)
# histograms.addText(0.4, 0.11, "Runs " + datasetsMgr.loadRunRange(), 17)
# Save canvas under custom dir
SaveAs(p, savePath, saveName, kwargs.get("saveFormats"))
return
def PlotHistograms(datasetsMgr_Mcrab644_TopPtRew,
datasetsMgr_Mcrab644_noTopPtRew,
datasetsMgr_Mcrab905_TopPtRew,
datasetsMgr_Mcrab905_noTopPtRew):
# Definitions
kwargs = {}
histos = []
# For-loop: All histos in list
dName = "TT"
# Multicrab *644, top pt reweighting:
p0 = plots.MCPlot(datasetsMgr_Mcrab644_TopPtRew,
"Analysis_/TopQuarkPt",
normalizeToLumi=opts.intLumi,
saveFormats=[],
**kwargs)
h_Mcrab644_TopPtRew = p0.histoMgr.getHisto(dName).getRootHisto().Clone(
"Mcrab644-ptRew")
histos.append(h_Mcrab644_TopPtRew)
# Multicrab *644, no top pt reweighting:
p1 = plots.MCPlot(datasetsMgr_Mcrab644_noTopPtRew,
"Analysis_/TopQuarkPt",
normalizeToLumi=opts.intLumi,
saveFormats=[],
**kwargs)
h_Mcrab644_noTopPtRew = p1.histoMgr.getHisto(dName).getRootHisto().Clone(
"Mcrab644-noptRew")
histos.append(h_Mcrab644_noTopPtRew)
# Multicrab *905, top pt reweighting:
p2 = plots.MCPlot(datasetsMgr_Mcrab905_TopPtRew,
"Analysis_/TopQuarkPt",
normalizeToLumi=opts.intLumi,
saveFormats=[],
**kwargs)
h_Mcrab905_TopPtRew = p2.histoMgr.getHisto(dName).getRootHisto().Clone(
"Mcrab905-ptRew")
histos.append(h_Mcrab905_TopPtRew)
# Multicrab *905, no top pt reweighting:
p3 = plots.MCPlot(datasetsMgr_Mcrab905_noTopPtRew,
"Analysis_/TopQuarkPt",
normalizeToLumi=opts.intLumi,
saveFormats=[],
**kwargs)
h_Mcrab905_noTopPtRew = p3.histoMgr.getHisto(dName).getRootHisto().Clone(
"Mcrab905-noptRew")
histos.append(h_Mcrab905_noTopPtRew)
# Normalise histos
for h in histos:
if opts.normaliseToOne:
h = h.Scale(1 / h.Integral())
# Make comparison plot
if opts.eight:
# p = plots.ComparisonManyPlot(h_Mcrab905_TopPtRew, [ h_Mcrab905_noTopPtRew], saveFormats=[])
p = plots.ComparisonManyPlot(h_Mcrab905_noTopPtRew,
[h_Mcrab905_TopPtRew],
saveFormats=[])
else:
# p = plots.ComparisonManyPlot(h_Mcrab644_TopPtRew, [h_Mcrab644_noTopPtRew], saveFormats=[])
# p = plots.ComparisonManyPlot(h_Mcrab644_noTopPtRew, [h_Mcrab644_TopPtRew], saveFormats=[])
p = plots.ComparisonManyPlot(
h_Mcrab644_noTopPtRew, [h_Mcrab644_TopPtRew, h_Mcrab905_TopPtRew],
saveFormats=[])
p.setLuminosity(opts.intLumi)
# Overwite signal style?
if opts.eight:
p.histoMgr.forHisto("Mcrab905-ptRew", styles.getABCDStyle("VR"))
p.histoMgr.forHisto("Mcrab905-noptRew", styles.getFakeBLineStyle())
else:
p.histoMgr.forHisto("Mcrab644-ptRew", styles.getABCDStyle("VR"))
p.histoMgr.forHisto("Mcrab644-noptRew", styles.getFakeBLineStyle())
# Set draw style
if opts.eight:
p.histoMgr.setHistoDrawStyle("Mcrab905-noptRew", "HIST")
p.histoMgr.setHistoDrawStyle("Mcrab905-ptRew", "AP")
else:
p.histoMgr.setHistoDrawStyle("Mcrab644-noptRew", "HIST")
p.histoMgr.setHistoDrawStyle("Mcrab644-ptRew", "AP")
# Set legend style
if opts.eight:
p.histoMgr.setHistoLegendStyle("Mcrab905-noptRew", "L") #"F"
p.histoMgr.setHistoLegendStyle("Mcrab905-ptRew", "LP")
else:
p.histoMgr.setHistoLegendStyle("Mcrab644-noptRew", "L") #"F"
p.histoMgr.setHistoLegendStyle("Mcrab644-ptRew", "LP")
if opts.eight:
p.histoMgr.setHistoLegendLabelMany({
"Mcrab905-ptRew": "p_{T} reweight (8 TeV)",
"Mcrab905-noptRew": "Default",
})
else:
p.histoMgr.setHistoLegendLabelMany({
"Mcrab644-ptRew": "p_{T} reweight (13 TeV)",
"Mcrab644-noptRew": "Default",
})
# Draw customised plot
if opts.eight:
saveName = "TopQuarkPt_PtReweight_8TeV"
else:
saveName = "TopQuarkPt_PtReweight_13TeV"
_units = "GeV/c"
_leg = {"x1": 0.55, "y1": 0.75, "x2": 0.85, "y2": 0.87}
if opts.normaliseToOne:
yLabel = "Arbitrary Units / %0.0f " + _units
else:
yLabel = "Events / %0.0f " + _units
plots.drawPlot(
p,
saveName,
xlabel="generated top p_{T} (%s)" % (_units),
ylabel=yLabel,
log=False,
rebinX=2,
cmsExtraText="Simulation", #"Preliminary",
ratio=True,
ratioType="errorPropagation", #"errorScale", "binomial"
divideByBinWidth=False,
ratioErrorOptions={
"numeratorStatSyst": False,
"denominatorStatSyst": True
},
ratioMoveLegend={
"dx": +0.21,
"dy": 0.03,
"dh": -0.08
},
ratioYlabel="Ratio ",
createLegend=_leg,
opts={
"xmin": 0.0,
"xmax": 800.0,
"ymin": 0.0,
"ymaxfactor": 1.2
},
opts2={
"ymin": 0.6,
"ymax": 1.4
},
cutBox={
"cutValue": 0.0,
"fillColor": 16,
"box": False,
"line": False,
"greaterThan": True
})
# Save plot in all formats
savePath = os.path.join(opts.saveDir, opts.optMode)
SavePlot(p, saveName, savePath)
return
def PlotHistosAndCalculateTF(datasetsMgr, histoList, binLabels, opts):
# Get the histogram customisations (keyword arguments)
_kwargs = GetHistoKwargs(histoList[0])
# Get the root histos for all datasets and Control Regions (CRs)
regions = ["SR", "VR", "CRone", "CRtwo"]
rhDict = GetRootHistos(datasetsMgr, histoList, regions, binLabels)
#=========================================================================================
# Calculate the Transfer Factor (TF) and save to file
#=========================================================================================
manager = FakeBNormalization.FakeBNormalizationManager(binLabels,
opts.mcrab,
opts.optMode,
verbose=False)
if opts.inclusiveOnly:
#manager.CalculateTransferFactor(binLabels[0], rhDict["CRone-FakeB"], rhDict["CRtwo-FakeB"])
binLabel = "Inclusive"
manager.CalculateTransferFactor("Inclusive",
rhDict["FakeB-CRone-Inclusive"],
rhDict["FakeB-CRtwo-Inclusive"])
else:
for bin in binLabels:
manager.CalculateTransferFactor(bin,
rhDict["FakeB-CRone-%s" % bin],
rhDict["FakeB-CRtwo-%s" % bin])
# Get unique a style for each region
for k in rhDict:
dataset = k.split("-")[0]
region = k.split("-")[1]
styles.getABCDStyle(region).apply(rhDict[k])
if "FakeB" in k:
styles.getFakeBStyle().apply(rhDict[k])
# sr.apply(rhDict[k])
# =========================================================================================
# Create the final plot object
# =========================================================================================
rData_SR = rhDict["Data-SR-Inclusive"]
rEWKGenuineB_SR = rhDict["EWK-SR-Inclusive-EWKGenuineB"]
rBkgSum_SR = rhDict["FakeB-VR-Inclusive"].Clone("BkgSum-SR-Inclusive")
rBkgSum_SR.Reset()
if opts.inclusiveOnly:
bin = "Inclusive"
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
binHisto_VR = rhDict["FakeB-VR-%s" % (bin)]
VRtoSR_TF = manager.GetTransferFactor(bin)
Print(
"Applying TF = %s%0.6f%s to VR shape" %
(ShellStyles.NoteStyle(), VRtoSR_TF, ShellStyles.NormalStyle()),
True)
binHisto_VR.Scale(VRtoSR_TF)
# Add the normalised histogram to the final Inclusive SR (predicted) histo
rBkgSum_SR.Add(binHisto_VR, +1)
else:
# For-loop: All bins
for i, bin in enumerate(binLabels, 1):
if bin == "Inclusive":
continue
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
binHisto_VR = rhDict["FakeB-VR-%s" % (bin)]
VRtoSR_TF = manager.GetTransferFactor(bin)
Print(
"Applying TF = %s%0.6f%s to VR shape" %
(ShellStyles.NoteStyle(), VRtoSR_TF,
ShellStyles.NormalStyle()), i == 1)
binHisto_VR.Scale(VRtoSR_TF)
# Add the normalised histogram to the final Inclusive SR (predicted) histo
rBkgSum_SR.Add(binHisto_VR, +1)
#Print("Got Verification Region (VR) shape %s%s%s" % (ShellStyles.NoteStyle(), rFakeB_VR.GetName(), ShellStyles.NormalStyle()), True)
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
#VRtoSR_TF = manager.GetTransferFactor("Inclusive")
#Print("Applying TF = %s%0.6f%s to VR shape" % (ShellStyles.NoteStyle(), VRtoSR_TF, ShellStyles.NormalStyle()), True)
#rBkgSum_SR.Scale(VRtoSR_TF)
# Plot histograms
if opts.altPlot:
# Add the SR EWK Genuine-b to the SR FakeB ( BkgSum = [FakeB] + [GenuineB-MC] = [VR * (CR1/CR2)] + [GenuineB-MC] )
rBkgSum_SR.Add(rEWKGenuineB_SR, +1)
# Change style
styles.getGenuineBStyle().apply(rBkgSum_SR)
# Remove unsupported settings of kwargs
_kwargs["stackMCHistograms"] = False
_kwargs["addLuminosityText"] = False
# Create the plot
p = plots.ComparisonManyPlot(rData_SR, [rBkgSum_SR], saveFormats=[])
# Set draw / legend style
p.histoMgr.setHistoDrawStyle("Data-SR-Inclusive", "P")
p.histoMgr.setHistoLegendStyle("Data-SR-Inclusive", "LP")
p.histoMgr.setHistoDrawStyle("BkgSum-SR-Inclusive", "HIST")
p.histoMgr.setHistoLegendStyle("BkgSum-SR-Inclusive", "F")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Data-SR": "Data",
"BkgSum-SR": "Fake-b + Gen-b",
})
else:
# Create empty histogram stack list
myStackList = []
# Signal
p2 = plots.DataMCPlot(datasetsMgr,
"ForTestQGLR/QGLR_SR/QGLR_SRInclusive",
saveFormats=[])
hSignal_800 = p2.histoMgr.getHisto(
'ChargedHiggs_HplusTB_HplusToTB_M_800').getRootHisto()
hhSignal_800 = histograms.Histo(
hSignal_800, 'ChargedHiggs_HplusTB_HplusToTB_M_800',
"H^{+} m_{H^+}=800 GeV")
hhSignal_800.setIsDataMC(isData=False, isMC=True)
myStackList.append(hhSignal_800)
hSignal_250 = p2.histoMgr.getHisto(
'ChargedHiggs_HplusTB_HplusToTB_M_250').getRootHisto()
hhSignal_250 = histograms.Histo(
hSignal_250, 'ChargedHiggs_HplusTB_HplusToTB_M_250',
"H^{+} m_{H^+}=250 GeV"
) #plots._legendLabels['ChargedHiggs_HplusTB_HplusToTB_M_250'])
hhSignal_250.setIsDataMC(isData=False, isMC=True)
#myStackList.append(hhSignal_250)
hSignal_500 = p2.histoMgr.getHisto(
'ChargedHiggs_HplusTB_HplusToTB_M_500').getRootHisto()
hhSignal_500 = histograms.Histo(
hSignal_500, 'ChargedHiggs_HplusTB_HplusToTB_M_500',
"H^{+} m_{H^+}=500 GeV"
) #plots._legendLabels['ChargedHiggs_HplusTB_HplusToTB_M_500'])
hhSignal_500.setIsDataMC(isData=False, isMC=True)
#myStackList.append(hhSignal_500)
hSignal_1000 = p2.histoMgr.getHisto(
'ChargedHiggs_HplusTB_HplusToTB_M_1000').getRootHisto()
hhSignal_1000 = histograms.Histo(
hSignal_1000, 'ChargedHiggs_HplusTB_HplusToTB_M_1000',
"H^{+} m_{H^+}=1000 GeV"
) #plots._legendLabels['ChargedHiggs_HplusTB_HplusToTB_M_500'])
hhSignal_1000.setIsDataMC(isData=False, isMC=True)
#myStackList.append(hhSignal_1000)
# Add the FakeB data-driven background to the histogram list
hFakeB = histograms.Histo(rBkgSum_SR, "FakeB", "Fake-b")
hFakeB.setIsDataMC(isData=False, isMC=True)
myStackList.append(hFakeB)
# Add the EWKGenuineB MC background to the histogram list
hGenuineB = histograms.Histo(rEWKGenuineB_SR, "GenuineB",
"EWK Genuine-b")
hGenuineB.setIsDataMC(isData=False, isMC=True)
myStackList.append(hGenuineB)
# Add the collision datato the histogram list
hData = histograms.Histo(rData_SR, "Data", "Data")
hData.setIsDataMC(isData=True, isMC=False)
myStackList.insert(0, hData)
p = plots.DataMCPlot2(myStackList, saveFormats=[])
p.setLuminosity(opts.intLumi)
p.setDefaultStyles()
# Draw the plot and save it
hName = "test"
plots.drawPlot(p, hName, **_kwargs)
SavePlot(p,
hName,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png", ".pdf"])
#==========================================================================================
# Calculate Cut-Flow Efficiency
#==========================================================================================
kwargs = {
"rebinX": 1,
"xlabel": "QGLR",
"ylabel": "Significance / %.02f ",
"opts": {
"ymin": 0.0,
"ymaxfactor": 1.3
},
"createLegend": {
"x1": 0.55,
"y1": 0.70,
"x2": 0.92,
"y2": 0.92
},
# "cutBox" : {"cutValue": 0.0, "fillColor" : 16, "box": False, "line": False, "greaterThan": True},
}
efficiencyList = []
xValues = []
yValues_250 = []
yValues_500 = []
yValues_800 = []
yValues_1000 = []
yValues_Bkg = []
nBins = hSignal_250.GetNbinsX() + 1
hBkg = p.histoMgr.getHisto(
"ChargedHiggs_HplusTB_HplusToTB_M_800").getRootHisto().Clone("Bkg")
hBkg.Reset()
# Bkg: FakeB + Genuine B
hBkg.Add(hFakeB.getRootHisto(), +1)
hBkg.Add(hGenuineB.getRootHisto(), +1)
for i in range(0, nBins):
# Cut value
cut = hSignal_250.GetBinCenter(i)
passed_250 = hSignal_250.Integral(i, hSignal_250.GetXaxis().GetNbins())
passed_500 = hSignal_500.Integral(i, hSignal_500.GetXaxis().GetNbins())
passed_800 = hSignal_800.Integral(i, hSignal_800.GetXaxis().GetNbins())
passed_1000 = hSignal_1000.Integral(i,
hSignal_1000.GetXaxis().GetNbins())
passed_Bkg = hBkg.Integral(i, hBkg.GetXaxis().GetNbins())
total_250 = hSignal_250.Integral()
total_500 = hSignal_500.Integral()
total_800 = hSignal_800.Integral()
total_1000 = hSignal_1000.Integral()
total_Bkg = hBkg.Integral()
eff_250 = float(passed_250) / total_250
eff_500 = float(passed_500) / total_500
eff_800 = float(passed_800) / total_800
eff_1000 = float(passed_1000) / total_1000
eff_Bkg = float(passed_Bkg) / total_Bkg
xValues.append(cut)
yValues_250.append(eff_250)
yValues_500.append(eff_500)
yValues_800.append(eff_800)
yValues_1000.append(eff_1000)
yValues_Bkg.append(eff_Bkg)
# Create the Efficiency Plot
tGraph_250 = ROOT.TGraph(len(xValues), array.array("d", xValues),
array.array("d", yValues_250))
tGraph_500 = ROOT.TGraph(len(xValues), array.array("d", xValues),
array.array("d", yValues_500))
tGraph_800 = ROOT.TGraph(len(xValues), array.array("d", xValues),
array.array("d", yValues_800))
tGraph_1000 = ROOT.TGraph(len(xValues), array.array("d", xValues),
array.array("d", yValues_1000))
tGraph_Bkg = ROOT.TGraph(len(xValues), array.array("d", xValues),
array.array("d", yValues_Bkg))
styles.getSignalStyleHToTB_M("200").apply(tGraph_250)
styles.getSignalStyleHToTB_M("500").apply(tGraph_500)
styles.getSignalStyleHToTB_M("800").apply(tGraph_800)
styles.getSignalStyleHToTB_M("1000").apply(tGraph_1000)
styles.getQCDLineStyle().apply(tGraph_Bkg)
drawStyle = "CPE"
effGraph_250 = histograms.HistoGraph(tGraph_250,
"H^{+} m_{H^{+}} = 250 GeV", "lp",
drawStyle)
effGraph_500 = histograms.HistoGraph(tGraph_500,
"H^{+} m_{H^{+}} = 500 GeV", "lp",
drawStyle)
effGraph_800 = histograms.HistoGraph(tGraph_800,
"H^{+} m_{H^{+}} = 800 GeV", "lp",
drawStyle)
effGraph_1000 = histograms.HistoGraph(tGraph_1000,
"H^{+} m_{H^{+}} = 1000 GeV", "lp",
drawStyle)
effGraph_Bkg = histograms.HistoGraph(tGraph_Bkg, "Bkg", "lp", drawStyle)
efficiencyList.append(effGraph_250)
efficiencyList.append(effGraph_500)
efficiencyList.append(effGraph_800)
efficiencyList.append(effGraph_1000)
efficiencyList.append(effGraph_Bkg)
# Efficiency plot
pE = plots.PlotBase(efficiencyList, saveFormats=["pdf"])
pE.createFrame("QGLR_Efficiency")
pE.setEnergy("13")
pE.getFrame().GetYaxis().SetLabelSize(18)
pE.getFrame().GetXaxis().SetLabelSize(20)
pE.getFrame().GetYaxis().SetTitle("Efficiency / 0.01")
pE.getFrame().GetXaxis().SetTitle("QGLR Cut")
# Add Standard Texts to plot
histograms.addStandardTexts()
# Customise Legend
moveLegend = {"dx": -0.50, "dy": -0.5, "dh": -0.1}
pE.setLegend(histograms.moveLegend(histograms.createLegend(),
**moveLegend))
pE.draw()
# plots.drawPlot(pE, "QGLR_Efficiency", **kwargs)
SavePlot(pE,
"QGLR_Efficiency",
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png", ".pdf"])
#==========================================================================================
# Calculate Significance
#==========================================================================================
SignalName = "ChargedHiggs_HplusTB_HplusToTB_M_800"
hSignif_250 = p.histoMgr.getHisto(SignalName).getRootHisto().Clone(
SignalName)
hSignif_500 = p.histoMgr.getHisto(SignalName).getRootHisto().Clone(
SignalName)
hSignif_800 = p.histoMgr.getHisto(SignalName).getRootHisto().Clone(
SignalName)
hSignif_1000 = p.histoMgr.getHisto(SignalName).getRootHisto().Clone(
SignalName)
hSignif_250.Reset()
hSignif_500.Reset()
hSignif_800.Reset()
hSignif_1000.Reset()
hBkg = p.histoMgr.getHisto(SignalName).getRootHisto().Clone("Bkg")
hBkg.Reset()
# Bkg: FakeB + Genuine B
hBkg.Add(hFakeB.getRootHisto(), +1)
hBkg.Add(hGenuineB.getRootHisto(), +1)
nBins = hSignif_250.GetNbinsX() + 1
# For-loop: All histo bins
for i in range(1, nBins + 1):
sigmaB = ROOT.Double(0)
b = hBkg.IntegralAndError(i, nBins, sigmaB)
s_250 = hSignal_250.Integral(i, nBins)
s_500 = hSignal_500.Integral(i, nBins)
s_800 = hSignal_800.Integral(i, nBins)
s_1000 = hSignal_1000.Integral(i, nBins)
# Calculate significance
signif_250 = stat.significance(s_250, b, sigmaB,
option="Simple") #Asimov")
signif_500 = stat.significance(s_500, b, sigmaB,
option="Simple") #Asimov")
signif_800 = stat.significance(s_800, b, sigmaB,
option="Simple") #Asimov")
signif_1000 = stat.significance(s_1000, b, sigmaB,
option="Simple") #"Asimov")
# Set signif for this bin
hSignif_250.SetBinContent(i, signif_250)
hSignif_500.SetBinContent(i, signif_500)
hSignif_800.SetBinContent(i, signif_800)
hSignif_1000.SetBinContent(i, signif_1000)
# Apply style
s_250 = styles.getSignalStyleHToTB_M("200")
s_250.apply(hSignif_250)
s_500 = styles.getSignalStyleHToTB_M("500")
s_500.apply(hSignif_500)
s_800 = styles.getSignalStyleHToTB_M("800")
s_800.apply(hSignif_800)
s_1000 = styles.getSignalStyleHToTB_M("1000")
s_1000.apply(hSignif_1000)
hList = []
hList.append(hSignif_250)
hList.append(hSignif_500)
hList.append(hSignif_800)
hList.append(hSignif_1000)
hSignif_250.SetName("H^{+} m_{H^{+}} = 250 GeV")
hSignif_500.SetName("H^{+} m_{H^{+}} = 500 GeV")
hSignif_800.SetName("H^{+} m_{H^{+}} = 800 GeV")
hSignif_1000.SetName("H^{+} m_{H^{+}} = 1000 GeV")
pS = plots.PlotBase(hList, saveFormats=["png", "pdf"])
pS.setLuminosity(opts.intLumi)
# Drawing style
pS.histoMgr.setHistoDrawStyleAll("HIST")
pS.histoMgr.setHistoLegendStyleAll("L")
pS.histoMgr.forEachHisto(lambda h: h.getRootHisto().SetMarkerSize(1.0))
pS.histoMgr.forEachHisto(
lambda h: h.getRootHisto().SetLineStyle(ROOT.kSolid))
pS.histoMgr.forEachHisto(
lambda h: h.getRootHisto().SetMarkerStyle(ROOT.kFullCircle))
# Draw the plot
name = "QGLR_Signif" + "GE"
plots.drawPlot(pS, name, **kwargs)
SavePlot(pS,
name,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png", ".pdf"])
#=========================================================================================
# Calculate the Transfer Factor (TF) and save to file
#=========================================================================================
Verbose("Write the normalisation factors to a python file", True)
fileName = os.path.join(
opts.mcrab, "FakeBTransferFactors%s.py" % (getModuleInfoString(opts)))
manager.writeNormFactorFile(fileName, opts)
return
def BaselineVsInvertedPlots(datasetsMgr, histoName, analysisType="Inverted"):
# Sanity check
IsBaselineOrInverted(analysisType)
# Get the Data (Inclusive)
p1 = plots.ComparisonPlot(*getHistos(datasetsMgr, "Data", histoName, analysisType))
p1.histoMgr.normalizeMCToLuminosity(datasetsMgr.getDataset("Data").getLuminosity())
# Get the EWK (GenuineB)
defaultFolder = "ForFakeBMeasurement"
genuineBFolder = defaultFolder + "EWKGenuineB"
fakeBFolder = defaultFolder + "EWKFakeB"
histoNameNew = histoName.replace( defaultFolder, genuineBFolder)
p2 = plots.ComparisonPlot(*getHistos(datasetsMgr, "EWK", histoNameNew, analysisType) )
p2.histoMgr.normalizeMCToLuminosity(datasetsMgr.getDataset("Data").getLuminosity())
# Get Data histos
baseline_Data = p1.histoMgr.getHisto("Baseline-Data").getRootHisto().Clone("Baseline-Data")
inverted_Data = p1.histoMgr.getHisto("Inverted-Data").getRootHisto().Clone("Inverted-Data")
# Get EWK histos
baseline_EWKGenuineB = p2.histoMgr.getHisto("Baseline-EWK").getRootHisto().Clone("Baseline-EWKGenuineB")
inverted_EWKGenuineB = p2.histoMgr.getHisto("Inverted-EWK").getRootHisto().Clone("Inverted-EWKGenuineB")
# Get FakeB (Baseline): FakeB = Data-EWKGenuineB
baseline_FakeB = p1.histoMgr.getHisto("Baseline-Data").getRootHisto().Clone("Baseline-FakeB")
baseline_FakeB.Add(baseline_EWKGenuineB, -1)
# Get FakeB (Inverted): FakeB = Data-EWKGenuineB
inverted_FakeB = p1.histoMgr.getHisto("Inverted-Data").getRootHisto().Clone("Inverted-FakeB")
inverted_FakeB.Add(inverted_EWKGenuineB, -1)
# Normalize histograms to unit area
baseline_FakeB.Scale(1.0/baseline_FakeB.Integral())
inverted_FakeB.Scale(1.0/inverted_FakeB.Integral())
# Create the final plot object
p = plots.ComparisonManyPlot(baseline_FakeB, [inverted_FakeB], saveFormats=[]) #[".C", ".png", ".pdf"])
p.setLuminosity(GetLumi(datasetsMgr))
# Apply styles
p.histoMgr.forHisto("Baseline-FakeB" , styles.getBaselineStyle() )
p.histoMgr.forHisto("Inverted-FakeB" , styles.getInvertedStyle() )
# Set draw style
p.histoMgr.setHistoDrawStyle("Baseline-FakeB", "AP")
p.histoMgr.setHistoDrawStyle("Inverted-FakeB", "HIST")
# Set legend style
p.histoMgr.setHistoLegendStyle("Baseline-FakeB", "LP")
p.histoMgr.setHistoLegendStyle("Inverted-FakeB", "F")
# p.histoMgr.setHistoLegendStyleAll("LP")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Baseline-FakeB" : "FakeB (Baseline)",
"Inverted-FakeB" : "FakeB (Inverted)",
})
# Draw the histograms
_cutBox = None
_rebinX = 1
_opts = {"ymin": 1e-4, "ymaxfactor": 2.0}
_format = "%0.0f"
_xlabel = None
if "dijetm" in histoName.lower():
_rebinX = 2
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jj} (%s)" % (_units)
_cutBox = {"cutValue": 80.399, "fillColor": 16, "box": False, "line": True, "greaterThan": True}
_opts["xmax"] = 400.0
if "trijetm" in histoName.lower():
_rebinX = 5
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jjb} (%s)" % _units
_cutBox = {"cutValue": 173.21, "fillColor": 16, "box": False, "line": True, "greaterThan": True}
_opts["xmax"] = 1500.0
if "pt" in histoName.lower():
_rebinX = 2
_format = "%0.0f GeV/c"
if "eta" in histoName.lower():
_format = "%0.2f"
_cutBox = {"cutValue": 0., "fillColor": 16, "box": False, "line": True, "greaterThan": True}
_opts["xmin"] = -3.0
_opts["xmax"] = +3.0
if "deltaeta" in histoName.lower():
_format = "%0.2f"
_opts["xmin"] = 0.0
_opts["xmax"] = 6.0
if "bdisc" in histoName.lower():
_format = "%0.2f"
if "tetrajetm" in histoName.lower():
_rebinX = 10
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jjjb} (%s)" % (_units)
_opts["xmax"] = 3500.0
plots.drawPlot(p, histoName,
xlabel = _xlabel,
ylabel = "Arbitrary Units / %s" % (_format),
log = True,
rebinX = _rebinX, cmsExtraText = "Preliminary",
createLegend = {"x1": 0.62, "y1": 0.78, "x2": 0.92, "y2": 0.92},
opts = _opts,
opts2 = {"ymin": 0.6, "ymax": 1.4},
ratio = True,
ratioInvert = False,
ratioYlabel = "Ratio",
cutBox = _cutBox,
)
# Save plot in all formats
SavePlot(p, histoName, os.path.join(opts.saveDir, "BaselineVsInverted", opts.optMode) )
return
def PlotHistos(d_noSF, d_withSF, num_histoList, den_histoList, opts):
# Get the histogram customisations (keyword arguments)
_kwargs = GetHistoKwargs(num_histoList[0])
# Get the root histos for all datasets and Control Regions (CRs)
regions = ["SR", "VR", "CR1", "CR2"]
labels = ["Genuine", "Fake", "Inclusive"]
#==========================================================================================
# Get Dictionaries
#==========================================================================================
rhDict_den_noSF = GetRootHistos(d_noSF, den_histoList, regions)
rhDict_num_noSF = GetRootHistos(d_noSF, num_histoList, regions)
rhDict_num_withSF = GetRootHistos(d_withSF, num_histoList, regions)
# =========================================================================================
# Normalization Factors (see: getNormalization.py)
# =========================================================================================
#f1=0.626877; f2=0.880767;
f1 = 0.625454
f2 = 0.836566
#noTopPtRew
#f1 = 0.626893; f2 = 0.880846; #noDeltaRqq
#f1 = 0.625454; f2 = 0.836566; #noDeltaRqq, noTopPtRew
# =========================================================================================
# (A) Apply Normalization Factors (see: getNormalizations.py)
# =========================================================================================
# Normalize all histograms (QCD and TT) to normalization factors
for re in regions:
rhDict_den_noSF["NormQCD-" + re + "-Inclusive"] = rhDict_den_noSF[
"QCD-" + re + "-Inclusive"].Clone("NormQCD-" + re + "-Inclusive")
rhDict_den_noSF["NormQCD-" + re + "-Inclusive"].Scale(f1)
rhDict_num_noSF["NormQCD-" + re + "-Inclusive"] = rhDict_num_noSF[
"QCD-" + re + "-Inclusive"].Clone("NormQCD-" + re + "-Inclusive")
rhDict_num_noSF["NormQCD-" + re + "-Inclusive"].Scale(f1)
rhDict_num_withSF["NormQCD-" + re + "-Inclusive"] = rhDict_num_withSF[
"QCD-" + re + "-Inclusive"].Clone("NormQCD-" + re + "-Inclusive")
rhDict_num_withSF["NormQCD-" + re + "-Inclusive"].Scale(f1)
for la in labels:
rhDict_den_noSF["NormTT-" + re + "-" +
la] = rhDict_den_noSF["TT-" + re + "-" +
la].Clone("NormTT-" + re +
"-" + la)
rhDict_den_noSF["NormTT-" + re + "-" + la].Scale(f2)
rhDict_num_noSF["NormTT-" + re + "-" +
la] = rhDict_num_noSF["TT-" + re + "-" +
la].Clone("NormTT-" + re +
"-" + la)
rhDict_num_noSF["NormTT-" + re + "-" + la].Scale(f2)
rhDict_num_withSF["NormTT-" + re + "-" +
la] = rhDict_num_withSF["TT-" + re + "-" +
la].Clone("NormTT-" +
re + "-" + la)
rhDict_num_withSF["NormTT-" + re + "-" + la].Scale(f2)
# =========================================================================================
# (B) Estimate Inclusive TT in SR
# =========================================================================================
# (B1) Inclusive TT in Data (Denominator) = Data - F1*QCD - EWK - ST
rhDict_den_noSF["TTinData-SR-Inclusive"] = rhDict_den_noSF[
"Data-SR-Inclusive"].Clone("Inclusive t#bar{t} (Data)")
rhDict_den_noSF["TTinData-SR-Inclusive"].Add(
rhDict_den_noSF["NormQCD-SR-Inclusive"], -1)
rhDict_den_noSF["TTinData-SR-Inclusive"].Add(
rhDict_den_noSF["EWK-SR-Inclusive"], -1)
rhDict_den_noSF["TTinData-SR-Inclusive"].Add(
rhDict_den_noSF["SingleTop-SR-Inclusive"], -1)
# (B2) Inclusive TT in Data (Numerator) = Data - (F1*QCD -EWK - ST)*SF
rhDict_num_noSF["TTinData-SR-Inclusive"] = rhDict_num_noSF[
"Data-SR-Inclusive"].Clone("Inclusive t#bar{t} (Data)")
rhDict_num_noSF["TTinData-SR-Inclusive"].Add(
rhDict_num_withSF["NormQCD-SR-Inclusive"], -1)
rhDict_num_noSF["TTinData-SR-Inclusive"].Add(
rhDict_num_withSF["EWK-SR-Inclusive"], -1)
rhDict_num_noSF["TTinData-SR-Inclusive"].Add(
rhDict_num_withSF["SingleTop-SR-Inclusive"], -1)
# ==========================================================================================
# (C) Plot Inclusive Efficiency (Data Vs MC)
# ==========================================================================================
_kwargs["opts"] = {"xmax": 800, "ymaxfactor": 2.0}
_kwargs["ratioYlabel"] = "Data/MC"
_kwargs["ratio"] = True
_kwargs["stackMCHistograms"] = False
_kwargs["createLegend"] = {"x1": 0.60, "y1": 0.75, "x2": 0.95, "y2": 0.92}
_kwargs["ratioInvert"] = True
num_data = rhDict_num_noSF["TTinData-SR-Inclusive"].Clone(
"t#bar{t}_{SR} (Data)")
den_data = rhDict_den_noSF["TTinData-SR-Inclusive"].Clone(
"t#bar{t}_{SR} (Data)")
num_mc = rhDict_num_noSF["TT-SR-Inclusive"].Clone("t#bar{t}_{SR} (MC)")
den_mc = rhDict_den_noSF["TT-SR-Inclusive"].Clone("t#bar{t}_{SR} (MC)")
num_data.Rebin(2)
num_mc.Rebin(2)
den_data.Rebin(2)
den_mc.Rebin(2)
styles.getABCDStyle("CR4").apply(num_mc)
styles.getABCDStyle("CR4").apply(den_mc)
# Denominator
hName = "InclusiveTT_SR_Denominator"
hData_Den = histograms.Histo(den_data,
"t#bar{t}_{SR} (Data)",
"Data",
drawStyle="AP")
hData_Den.setIsDataMC(isData=True, isMC=False)
hMC_Den = histograms.Histo(den_mc,
"t#bar{t}_{SR} (MC)",
"MC",
drawStyle="HIST")
hMC_Den.setIsDataMC(isData=False, isMC=True)
pDen = plots.ComparisonManyPlot(hData_Den, [hMC_Den], saveFormats=[])
pDen.setLuminosity(opts.intLumi)
pDen.setDefaultStyles()
plots.drawPlot(pDen, hName, **_kwargs)
SavePlot(pDen,
hName,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png"])
# Numerator
hName = "InclusiveTT_SR_Numerator"
hData_Num = histograms.Histo(num_data,
"t#bar{t}_{SR} (Data)",
"Data",
drawStyle="AP")
hData_Num.setIsDataMC(isData=True, isMC=False)
hMC_Num = histograms.Histo(num_mc,
"t#bar{t}_{SR} (MC)",
"MC",
drawStyle="HIST")
hMC_Num.setIsDataMC(isData=False, isMC=True)
pNum = plots.ComparisonManyPlot(hData_Num, [hMC_Num], saveFormats=[])
pNum.setLuminosity(opts.intLumi)
pNum.setDefaultStyles()
plots.drawPlot(pNum, hName, **_kwargs)
SavePlot(pNum,
hName,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png"])
# =========================
# Inclusive Efficiency
# =========================
_kwargs = {
"xlabel": "p_{T} (GeV/c)",
"ylabel": "Efficiency",
"ratioYlabel": "Data/MC",
"ratio": True,
"ratioInvert": False,
"ratioType": None,
"ratioCreateLegend": True,
"ratioMoveLegend": {
"dx": -0.51,
"dy": 0.03,
"dh": -0.08
},
"ratioErrorOptions": {
"numeratorStatSyst": False,
"denominatorStatSyst": False
},
"errorBarsX": True,
"stackMCHistograms": False,
"addMCUncertainty": False,
"addLuminosityText": False,
"addCmsText": True,
"cmsExtraText": "Preliminary",
"opts": {
"ymin": 0.0,
"ymaxfactor": 1.5,
"xmax": 600
},
"opts2": {
"ymin": 0.6,
"ymax": 1.5
},
"log": False,
"createLegend": {
"x1": 0.64,
"y1": 0.80,
"x2": 0.95,
"y2": 0.92
},
}
_kwargs["cutBoxY"] = {
"cutValue": 1.10,
"fillColor": ROOT.kGray + 1,
"fillStyle": 3001,
"box": False,
"line": True,
"greaterThan": True,
"mainCanvas": False,
"ratioCanvas": True,
"mirror": True
}
bins = [0, 100, 200, 300, 400, 500, 600]
xBins = array.array('d', bins)
nx = len(xBins) - 1
# Data
h0_data_den = rhDict_den_noSF["TTinData-SR-Inclusive"].Clone(
"t#bar{t}_{SR} (Data)")
h0_data_num = rhDict_num_noSF["TTinData-SR-Inclusive"].Clone(
"t#bar{t}_{SR} (Data)")
# MC
h0_mc_den = rhDict_den_noSF["TT-SR-Inclusive"].Clone("t#bar{t}_{SR} (MC)")
h0_mc_num = rhDict_num_noSF["TT-SR-Inclusive"].Clone("t#bar{t}_{SR} (MC)")
h0_data_den = h0_data_den.Rebin(nx, "", xBins)
h0_data_num = h0_data_num.Rebin(nx, "", xBins)
h0_mc_den = h0_mc_den.Rebin(nx, "", xBins)
h0_mc_num = h0_mc_num.Rebin(nx, "", xBins)
hNumerator_Data, hDenominator_Data = GetHistosForEfficiency(
h0_data_num, h0_data_den)
hNumerator_MC, hDenominator_MC = GetHistosForEfficiency(
h0_mc_num, h0_mc_den)
eff_data = ROOT.TEfficiency(hNumerator_Data, hDenominator_Data)
eff_mc = ROOT.TEfficiency(hNumerator_MC, hDenominator_MC)
eff_data.SetStatisticOption(ROOT.TEfficiency.kFCP)
eff_mc.SetStatisticOption(ROOT.TEfficiency.kFCP)
geff_data = convert2TGraph(eff_data)
geff_mc = convert2TGraph(eff_mc)
styles.dataStyle.apply(geff_data)
styles.ttStyle.apply(geff_mc)
Graph_Data = histograms.HistoGraph(geff_data, "t#bar{t}_{SR} (Data) ", "p",
"P")
Graph_MC = histograms.HistoGraph(geff_mc, "t#bar{t}_{SR} (MC)", "p", "P")
p = plots.ComparisonManyPlot(Graph_MC, [Graph_Data], saveFormats=[])
saveName = "Efficiency_InclusiveTT_SR"
savePath = os.path.join(opts.saveDir, opts.optMode)
plots.drawPlot(p, savePath, **_kwargs)
SavePlot(p,
saveName,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png", ".pdf", ".C"])
# Save results in JSON
if (opts.inclusiveEff):
name = opts.noSFcrab.split("_")[-4]
name = name.replace(opts.analysisName, "")
print "name = ", name
jsonName = "toptagEff_BDT" + name + "_InclusiveTT_TopMassCut400.json"
runRange = "273150-284044"
analysis = opts.analysisName
label = "2016"
plotDir = os.path.join(opts.folder, jsonName)
pythonWriter.addParameters(plotDir, label, runRange, opts.intLumi,
geff_data)
pythonWriter.addMCParameters(label, geff_mc)
fileName_json = jsonName
pythonWriter.writeJSON(fileName_json)
# ==========================================================================================
# (D) Estimate Genuine TT in SR
# ==========================================================================================
# (D1) Genuine TT in Data - Denominator = Data - F1*QCD - F2*FakeTT - EWK - ST
rhDict_den_noSF["TTinData-SR-Genuine"] = rhDict_den_noSF[
"Data-SR-Inclusive"].Clone("genuine t#bar{t} (Data)")
rhDict_den_noSF["TTinData-SR-Genuine"].Add(
rhDict_den_noSF["NormQCD-SR-Inclusive"], -1)
rhDict_den_noSF["TTinData-SR-Genuine"].Add(
rhDict_den_noSF["NormTT-SR-Fake"], -1)
rhDict_den_noSF["TTinData-SR-Genuine"].Add(
rhDict_den_noSF["EWK-SR-Inclusive"], -1)
rhDict_den_noSF["TTinData-SR-Genuine"].Add(
rhDict_den_noSF["SingleTop-SR-Inclusive"], -1)
# (D2) Genuine TT in Data - Numerator = Data - [F1*QCD - F2*FakeTT - ST - EWK] * SF
rhDict_num_noSF["TTinData-SR-Genuine"] = rhDict_num_noSF[
"Data-SR-Inclusive"].Clone("genuine t#bar{t} (Data)")
rhDict_num_noSF["TTinData-SR-Genuine"].Add(
rhDict_num_withSF["NormQCD-SR-Inclusive"], -1)
rhDict_num_noSF["TTinData-SR-Genuine"].Add(
rhDict_num_withSF["NormTT-SR-Fake"], -1)
rhDict_num_noSF["TTinData-SR-Genuine"].Add(
rhDict_num_withSF["SingleTop-SR-Inclusive"], -1)
rhDict_num_noSF["TTinData-SR-Genuine"].Add(
rhDict_num_withSF["EWK-SR-Inclusive"], -1)
# ========================================================================================
# (E) Plot Numerator and Denominator (Data Vs MC)
# ========================================================================================
_kwargs = GetHistoKwargs(num_histoList[0])
_kwargs["opts"] = {"xmax": 800, "ymaxfactor": 2.0}
_kwargs["ratioYlabel"] = "Data/MC"
_kwargs["ratio"] = True
_kwargs["stackMCHistograms"] = False
_kwargs["createLegend"] = {"x1": 0.60, "y1": 0.75, "x2": 0.95, "y2": 0.92}
_kwargs["ratioInvert"] = True
num_data.Reset()
den_data.Reset()
num_mc.Reset()
den_mc.Reset()
num_data = rhDict_num_noSF["TTinData-SR-Genuine"].Clone(
"genuine t#bar{t}_{SR} (Data)")
den_data = rhDict_den_noSF["TTinData-SR-Genuine"].Clone(
"genuine t#bar{t}_{SR} (Data)")
num_mc = rhDict_num_noSF["TT-SR-Genuine"].Clone(
"genuine t#bar{t}_{SR} (MC)")
den_mc = rhDict_den_noSF["TT-SR-Genuine"].Clone(
"genuine t#bar{t}_{SR} (MC)")
num_data.Rebin(2)
num_mc.Rebin(2)
den_data.Rebin(2)
den_mc.Rebin(2)
styles.getABCDStyle("CR4").apply(num_mc)
styles.getABCDStyle("CR4").apply(den_mc)
# Denominator
hName = "GenuineTT_SR_Denominator"
hData_Den = histograms.Histo(den_data,
"genuine t#bar{t}_{SR} (Data)",
"Data",
drawStyle="AP")
hData_Den.setIsDataMC(isData=True, isMC=False)
hMC_Den = histograms.Histo(den_mc,
"genuine t#bar{t}_{SR} (MC)",
"MC",
drawStyle="HIST")
hMC_Den.setIsDataMC(isData=False, isMC=True)
pDenumerator = plots.ComparisonManyPlot(hData_Den, [hMC_Den],
saveFormats=[])
pDenumerator.setLuminosity(opts.intLumi)
pDenumerator.setDefaultStyles()
plots.drawPlot(pDenumerator, hName, **_kwargs)
SavePlot(pDenumerator,
hName,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png"])
# Numerator
hName = "GenuineTT_SR_Numerator"
hData_Num = histograms.Histo(num_data,
"genuine t#bar{t}_{SR} (Data)",
"Data",
drawStyle="AP")
hData_Num.setIsDataMC(isData=True, isMC=False)
hMC_Num = histograms.Histo(num_mc,
"genuine t#bar{t}_{SR} (MC)",
"MC",
drawStyle="HIST")
hMC_Num.setIsDataMC(isData=False, isMC=True)
pNumerator = plots.ComparisonManyPlot(hData_Num, [hMC_Num], saveFormats=[])
pNumerator.setLuminosity(opts.intLumi)
pNumerator.setDefaultStyles()
plots.drawPlot(pNumerator, hName, **_kwargs)
SavePlot(pNumerator,
hName,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png"])
# ========================================================================================
# (F) Plot Genuine TT Efficiency
# ========================================================================================
_kwargs = {
"xlabel": "p_{T} (GeV/c)",
"ylabel": "Efficiency",
"ratioYlabel": "Data/MC",
"ratio": True,
"ratioInvert": False,
"ratioType": None, #"errorScale",
"ratioCreateLegend": True,
"ratioMoveLegend": {
"dx": -0.51,
"dy": 0.03,
"dh": -0.08
},
"ratioErrorOptions": {
"numeratorStatSyst": False,
"denominatorStatSyst": False
},
"errorBarsX": True,
"stackMCHistograms": False,
"addMCUncertainty": False,
"addLuminosityText": False,
"addCmsText": True,
"cmsExtraText": "Preliminary",
"opts": {
"ymin": 0.0,
"ymaxfactor": 1.25,
"xmax": 600
},
"opts2": {
"ymin": 0.55,
"ymax": 1.55
},
"log": False,
"createLegend": {
"x1": 0.54,
"y1": 0.80,
"x2": 0.95,
"y2": 0.92
},
}
_kwargs["cutBoxY"] = {
"cutValue": 1.10,
"fillColor": ROOT.kGray + 1,
"fillStyle": 3001,
"box": False,
"line": True,
"greaterThan": True,
"mainCanvas": False,
"ratioCanvas": True,
"mirror": True
}
bins = [0, 100, 200, 300, 400, 500, 600]
xBins = array.array('d', bins)
nx = len(xBins) - 1
# Data
h1_data_den = rhDict_den_noSF["TTinData-SR-Genuine"].Clone(
"genuine t#bar{t}_{SR} (Data)")
h1_data_num = rhDict_num_noSF["TTinData-SR-Genuine"].Clone(
"genuine t#bar{t}_{SR} (Data)")
# MC
h1_mc_den = rhDict_den_noSF["TT-SR-Genuine"].Clone(
"genuine t#bar{t}_{SR} (MC)")
h1_mc_num = rhDict_num_noSF["TT-SR-Genuine"].Clone(
"genuine t#bar{t}_{SR} (MC)")
h1_data_den = h1_data_den.Rebin(nx, "", xBins)
h1_data_num = h1_data_num.Rebin(nx, "", xBins)
h1_mc_den = h1_mc_den.Rebin(nx, "", xBins)
h1_mc_num = h1_mc_num.Rebin(nx, "", xBins)
h_Numerator_Data, h_Denominator_Data = GetHistosForEfficiency(
h1_data_num, h1_data_den)
h_Numerator_MC, h_Denominator_MC = GetHistosForEfficiency(
h1_mc_num, h1_mc_den)
effi_data = ROOT.TEfficiency(h_Numerator_Data, h_Denominator_Data)
effi_mc = ROOT.TEfficiency(h_Numerator_MC, h_Denominator_MC)
effi_data.SetStatisticOption(ROOT.TEfficiency.kFCP)
effi_mc.SetStatisticOption(ROOT.TEfficiency.kFCP)
geffi_data = convert2TGraph(effi_data)
geffi_mc = convert2TGraph(effi_mc)
styles.dataStyle.apply(geffi_data)
styles.ttStyle.apply(geffi_mc)
Graph_Data = histograms.HistoGraph(geffi_data,
"genuine t#bar{t}_{SR} (Data) ", "p",
"P")
Graph_MC = histograms.HistoGraph(geffi_mc, "genuine t#bar{t}_{SR} (MC)",
"p", "P")
pp = plots.ComparisonManyPlot(Graph_MC, [Graph_Data], saveFormats=[])
saveName = "Efficiency_GenuineTT_SR"
savePath = os.path.join(opts.saveDir, opts.optMode)
plots.drawPlot(pp, savePath, **_kwargs)
SavePlot(pp,
saveName,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png", ".pdf", ".C"])
# Save results in JSON
if (not opts.inclusiveEff):
name = opts.noSFcrab.split("_")[-4]
name = name.replace(opts.analysisName, "")
jsonName = "toptagEff_BDT" + name + "_GenuineTT_TopMassCut400.json"
runRange = "273150-284044"
analysis = opts.analysisName
label = "2016"
plotDir = os.path.join(opts.folder, jsonName)
pythonWriter.addParameters(plotDir, label, runRange, opts.intLumi,
geffi_data)
pythonWriter.addMCParameters(label, geffi_mc)
fileName_json = jsonName
pythonWriter.writeJSON(fileName_json)
return
def main(opts):
style = tdrstyle.TDRStyle()
# Set ROOT batch mode boolean
ROOT.gROOT.SetBatch(opts.batchMode)
# Get all datasets from the mcrab dir
# def GetDatasetsFromDir(mcrab, opts, **kwargs): #iro
datasetsMgr = GetDatasetsFromDir(opts.mcrab, opts,
**kwargs) #kwargs.get("analysis"))
datasetsMgr_fixed = GetDatasetsFromDir(opts.mcrab, opts, **kwargs_fixed)
# Determine Integrated Luminosity (If Data datasets present)
intLumi = GetLumi(datasetsMgr)
# Update to PU
datasetsMgr.updateNAllEventsToPUWeighted()
# Remove datasets
datasetsMgr.remove(kwargs.get("rmDataset"))
datasetsMgr_fixed.remove(kwargs_fixed.get("rmDataset"))
# datasetsMgr.remove(filter(lambda name: not "QCD" in name, datasetsMgr.getAllDatasetNames()))
# datasetsMgr.remove(filter(lambda name: "QCD" in name in name, datasetsMgr.getAllDatasetNames()))
# Set custom XSections
#datasetsMgr.getDataset("QCD_bEnriched_HT1000to1500").setCrossSection(1.0)
#datasetsMgr.getDataset("QCD_bEnriched_HT1500to2000").setCrossSection(1.0)
#datasetsMgr.getDataset("QCD_bEnriched_HT2000toInf").setCrossSection(1.0)
#datasetsMgr.getDataset("QCD_bEnriched_HT300to500").setCrossSection(1.0)
#datasetsMgr.getDataset("QCD_bEnriched_HT500to700").setCrossSection(1.0)
#datasetsMgr.getDataset("QCD_bEnriched_HT700to1000").setCrossSection(1.0)
# Default merging & ordering: "Data", "QCD", "SingleTop", "Diboson"
plots.mergeRenameReorderForDataMC(datasetsMgr)
plots.mergeRenameReorderForDataMC(datasetsMgr_fixed)
# Remove datasets (for merged names)
datasetsMgr.remove(kwargs.get("rmDataset"))
datasetsMgr_fixed.remove(kwargs_fixed.get("rmDataset"))
# Print the cross
datasetsMgr.PrintCrossSections()
for h_prefix in ["reco", "gen"]:
# Get ref histo (?) here and the fixed histos (TT, QCD, QCD-b
inclusiveHisto, fixedHistos = GetHistosForPlotter(
datasetsMgr_fixed, h_prefix + "MHT", **kwargs_fixed)
inclusiveHisto.setName(inclusiveHisto.getName() + " (inclusive)")
#for hi in fixedHistos:
# print(type(hi), hi.getName())
#return
# For-loop: All Histogram names
for counter, hName in enumerate(hNames):
# Get the save path and name
savePath, saveName = GetSavePathAndName(h_prefix + hName, **kwargs)
# Get Histos for Plotter
refHisto_, otherHistos_ = GetHistosForPlotter(
datasetsMgr, h_prefix + hName, **kwargs)
refHisto = refHisto_
otherHistos = otherHistos_ + fixedHistos
#for hi in otherHistos:
# print hi.getName()
#return
# Create a comparison plot
p = plots.ComparisonManyPlot(refHisto, otherHistos)
# Remove negative contributions
#RemoveNegativeBins(datasetsMgr, hName, p)
# Create a frame
if kwargs.get("logY") == True:
opts = {"ymin": 8e-5, "ymax": 2}
#opts = {"ymin": 1e-3, "ymax": 1}
else:
opts = {"ymin": 8.e-5, "ymax": 2}
ratioOpts = {"ymin": 0.0, "ymax": 2.0}
p.createFrame(saveName,
createRatio=kwargs.get("createRatio"),
opts=opts,
opts2=ratioOpts)
# Customise Legend
moveLegend = {"dx": -0.2, "dy": +0.0, "dh": -0.1}
p.setLegend(
histograms.moveLegend(histograms.createLegend(), **moveLegend))
#p.removeLegend()
# Customise frame
p.getFrame().GetYaxis().SetTitle(getTitleY(refHisto, **kwargs))
#p.setEnergy("13")
if kwargs.get("createRatio"):
p.getFrame2().GetYaxis().SetTitle("Ratio")
p.getFrame2().GetYaxis().SetTitleOffset(1.6)
# SetLog
SetLogAndGrid(p, **kwargs)
# Add cut line/box
_kwargs = {"lessThan": kwargs.get("cutLessThan")}
p.addCutBoxAndLine(cutValue=kwargs.get("cutValue"),
fillColor=kwargs.get("cutFillColour"),
box=kwargs.get("cutBox"),
line=kwargs.get("cutLine"),
**_kwargs)
# Move the refDataset to first in the draw order (back)
histoNames = [h.getName() for h in p.histoMgr.getHistos()]
p.histoMgr.reorder(
filter(
lambda n: plots._legendLabels[kwargs.get("refDataset")]
not in n, histoNames))
# Draw plots
p.draw()
# Customise text
histograms.addStandardTexts(lumi=intLumi)
# histograms.addText(0.4, 0.9, "Alexandros Attikis", 17)
# histograms.addText(0.4, 0.11, "Runs " + datasetsMgr.loadRunRange(), 17)
# Save canvas under custom dir
if not os.path.exists(savePath):
os.mkdir(savePath)
SaveAs(p, savePath, saveName, kwargs.get("saveFormats"))
return
def PlotComparison(datasetsMgr1, datasetsMgr2, datasetsMgr3, hBaseline,
hInverted, ext):
# Create corresponding paths for GenuineB and FakeB histograms (not only Inclusive)
hBaseline_Inclusive = hBaseline #no extra string
hInverted_Inclusive = hInverted #no extra string
hBaseline_GenuineB = hBaseline_Inclusive.replace(
opts.folder, opts.folder + "EWKGenuineB")
hInverted_GenuineB = hInverted_Inclusive.replace(
opts.folder, opts.folder + "EWKGenuineB")
hBaseline_FakeB = hBaseline_Inclusive.replace(opts.folder,
opts.folder + "EWKFakeB")
hInverted_FakeB = hInverted_Inclusive.replace(opts.folder,
opts.folder + "EWKFakeB")
# Create the histograms in the Baseline (SR) and Inverted (CR) regions
pBaseline_Inclusive1 = plots.DataMCPlot(datasetsMgr1, hBaseline_Inclusive)
pBaseline_GenuineB1 = plots.DataMCPlot(datasetsMgr1, hBaseline_GenuineB)
pBaseline_FakeB1 = plots.DataMCPlot(datasetsMgr1, hBaseline_FakeB)
pInverted_Inclusive1 = plots.DataMCPlot(datasetsMgr1, hInverted_Inclusive)
pInverted_GenuineB1 = plots.DataMCPlot(datasetsMgr1, hInverted_GenuineB)
pInverted_FakeB1 = plots.DataMCPlot(datasetsMgr1, hInverted_FakeB)
pBaseline_Inclusive2 = plots.DataMCPlot(datasetsMgr2, hBaseline_Inclusive)
pBaseline_GenuineB2 = plots.DataMCPlot(datasetsMgr2, hBaseline_GenuineB)
pBaseline_FakeB2 = plots.DataMCPlot(datasetsMgr2, hBaseline_FakeB)
pInverted_Inclusive2 = plots.DataMCPlot(datasetsMgr2, hInverted_Inclusive)
pInverted_GenuineB2 = plots.DataMCPlot(datasetsMgr2, hInverted_GenuineB)
pInverted_FakeB2 = plots.DataMCPlot(datasetsMgr2, hInverted_FakeB)
pBaseline_Inclusive3 = plots.DataMCPlot(datasetsMgr3, hBaseline_Inclusive)
pBaseline_GenuineB3 = plots.DataMCPlot(datasetsMgr3, hBaseline_GenuineB)
pBaseline_FakeB3 = plots.DataMCPlot(datasetsMgr3, hBaseline_FakeB)
pInverted_Inclusive3 = plots.DataMCPlot(datasetsMgr3, hInverted_Inclusive)
pInverted_GenuineB3 = plots.DataMCPlot(datasetsMgr3, hInverted_GenuineB)
pInverted_FakeB3 = plots.DataMCPlot(datasetsMgr3, hInverted_FakeB)
# Extract the correct SR and CR histograms
baseline_Data1 = pBaseline_Inclusive1.histoMgr.getHisto(
"Data").getRootHisto().Clone("Baseline-Data1")
baseline_EWKGenuineB1 = pBaseline_GenuineB1.histoMgr.getHisto(
"EWK").getRootHisto().Clone("Baseline-EWKGenuineB1")
baseline_EWKFakeB1 = pBaseline_FakeB1.histoMgr.getHisto(
"EWK").getRootHisto().Clone("Baseline-EWKFakeB1")
inverted_Data1 = pInverted_Inclusive1.histoMgr.getHisto(
"Data").getRootHisto().Clone("Inverted-Data1")
inverted_EWKGenuineB1 = pInverted_GenuineB1.histoMgr.getHisto(
"EWK").getRootHisto().Clone("Inverted-EWKGenuineB1")
inverted_EWKFakeB1 = pInverted_FakeB1.histoMgr.getHisto(
"EWK").getRootHisto().Clone("Inverted-EWKFakeB1")
baseline_Data2 = pBaseline_Inclusive2.histoMgr.getHisto(
"Data").getRootHisto().Clone("Baseline-Data2")
baseline_EWKGenuineB2 = pBaseline_GenuineB2.histoMgr.getHisto(
"EWK").getRootHisto().Clone("Baseline-EWKGenuineB2")
baseline_EWKFakeB2 = pBaseline_FakeB2.histoMgr.getHisto(
"EWK").getRootHisto().Clone("Baseline-EWKFakeB2")
inverted_Data2 = pInverted_Inclusive2.histoMgr.getHisto(
"Data").getRootHisto().Clone("Inverted-Data2")
inverted_EWKGenuineB2 = pInverted_GenuineB2.histoMgr.getHisto(
"EWK").getRootHisto().Clone("Inverted-EWKGenuineB2")
inverted_EWKFakeB2 = pInverted_FakeB2.histoMgr.getHisto(
"EWK").getRootHisto().Clone("Inverted-EWKFakeB2")
baseline_Data3 = pBaseline_Inclusive3.histoMgr.getHisto(
"Data").getRootHisto().Clone("Baseline-Data3")
baseline_EWKGenuineB3 = pBaseline_GenuineB3.histoMgr.getHisto(
"EWK").getRootHisto().Clone("Baseline-EWKGenuineB3")
baseline_EWKFakeB3 = pBaseline_FakeB3.histoMgr.getHisto(
"EWK").getRootHisto().Clone("Baseline-EWKFakeB3")
inverted_Data3 = pInverted_Inclusive3.histoMgr.getHisto(
"Data").getRootHisto().Clone("Inverted-Data3")
inverted_EWKGenuineB3 = pInverted_GenuineB3.histoMgr.getHisto(
"EWK").getRootHisto().Clone("Inverted-EWKGenuineB3")
inverted_EWKFakeB3 = pInverted_FakeB3.histoMgr.getHisto(
"EWK").getRootHisto().Clone("Inverted-EWKFakeB3")
# FakeB = Data -EWKGenuineB
baseline_FakeB1 = baseline_Data1.Clone("Baseline-FakeB1")
inverted_FakeB1 = inverted_Data1.Clone("Inverted-FakeB1")
baseline_FakeB2 = baseline_Data2.Clone("Baseline-FakeB2")
inverted_FakeB2 = inverted_Data2.Clone("Inverted-FakeB2")
baseline_FakeB3 = baseline_Data3.Clone("Baseline-FakeB3")
inverted_FakeB3 = inverted_Data3.Clone("Inverted-FakeB3")
# Subtract the EWK GenuineB
baseline_FakeB1.Add(baseline_EWKGenuineB1, -1)
inverted_FakeB1.Add(inverted_EWKGenuineB1, -1)
baseline_FakeB2.Add(baseline_EWKGenuineB2, -1)
inverted_FakeB2.Add(inverted_EWKGenuineB2, -1)
baseline_FakeB3.Add(baseline_EWKGenuineB3, -1)
inverted_FakeB3.Add(inverted_EWKGenuineB3, -1)
# Normalize histograms to unit area
if opts.normaliseToOne:
baseline_FakeB1.Scale(1.0 / baseline_FakeB1.Integral())
inverted_FakeB1.Scale(1.0 / inverted_FakeB1.Integral())
baseline_FakeB2.Scale(1.0 / baseline_FakeB2.Integral())
inverted_FakeB2.Scale(1.0 / inverted_FakeB2.Integral())
baseline_FakeB3.Scale(1.0 / baseline_FakeB3.Integral())
inverted_FakeB3.Scale(1.0 / inverted_FakeB3.Integral())
# Create the final plot object
if ext == "CR1" or ext == "SR":
p = plots.ComparisonManyPlot(baseline_FakeB1,
[baseline_FakeB2, baseline_FakeB3],
saveFormats=[])
elif ext == "CR2" or ext == "VR":
p = plots.ComparisonManyPlot(inverted_FakeB1,
[inverted_FakeB2, inverted_FakeB3],
saveFormats=[])
else:
raise Exception("Unexpected extension %s" % (ext))
p.setLuminosity(opts.intLumi)
# Get the BDT cut values from the multicrab name
BDT1 = find_between(opts.mcrab1, "MVAm1p00to", "_").replace("p", ".")
BDT2 = find_between(opts.mcrab2, "MVAm1p00to", "_").replace("p", ".")
BDT3 = find_between(opts.mcrab3, "MVAm1p00to", "_").replace("p", ".")
# Apply histogram styles
if ext == "CR1" or ext == "SR":
p.histoMgr.forHisto("Baseline-FakeB1", styles.getFakeBLineStyle()
) # getABCDStyle("SR") , getABCDStyle("VR")
p.histoMgr.forHisto("Baseline-FakeB2", styles.genuineBAltStyle)
p.histoMgr.forHisto("Baseline-FakeB3", styles.getABCDStyle("SR"))
# Set drawing style
p.histoMgr.setHistoDrawStyle("Baseline-FakeB1", "HIST")
p.histoMgr.setHistoDrawStyle("Baseline-FakeB2", "AP")
p.histoMgr.setHistoDrawStyle("Baseline-FakeB3", "AP")
# Set legend styles
p.histoMgr.setHistoLegendStyle("Baseline-FakeB1", "L")
p.histoMgr.setHistoLegendStyle("Baseline-FakeB2", "LP")
p.histoMgr.setHistoLegendStyle("Baseline-FakeB3", "LP")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Baseline-FakeB1":
"%s (BDT < %s)" % (ext, BDT1),
"Baseline-FakeB2":
"%s (BDT < %s)" % (ext, BDT2),
"Baseline-FakeB3":
"%s (BDT < %s)" % (ext, BDT3),
})
else:
p.histoMgr.forHisto("Inverted-FakeB1", styles.getFakeBLineStyle())
p.histoMgr.forHisto("Inverted-FakeB2", styles.genuineBAltStyle)
p.histoMgr.forHisto("Inverted-FakeB3", styles.getABCDStyle("SR"))
# Set drawing styles
p.histoMgr.setHistoDrawStyle("Inverted-FakeB1", "HIST")
p.histoMgr.setHistoDrawStyle("Inverted-FakeB2", "AP")
p.histoMgr.setHistoDrawStyle("Inverted-FakeB3", "AP")
# Set legend styles
p.histoMgr.setHistoLegendStyle("Inverted-FakeB1", "L")
p.histoMgr.setHistoLegendStyle("Inverted-FakeB2", "LP")
p.histoMgr.setHistoLegendStyle("Inverted-FakeB3", "LP")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Inverted-FakeB1":
"%s (BDT < %s)" % (ext, BDT1),
"Inverted-FakeB2":
"%s (BDT < %s)" % (ext, BDT2),
"Inverted-FakeB3":
"%s (BDT < %s)" % (ext, BDT3),
})
# Get histogram keyword arguments
kwargs_ = GetHistoKwargs(hBaseline_Inclusive, ext, opts)
# Draw the histograms
plots.drawPlot(p, hBaseline_Inclusive, **kwargs_) #iro
# Save plot in all formats
saveName = hBaseline_Inclusive.split("/")[-1]
saveName = saveName.replace("Baseline_", "")
saveName = saveName.replace("Inverted_", "")
saveName = saveName.replace("_AfterAllSelections", "_" + ext)
saveName = saveName.replace("_AfterCRSelections", "_" + ext)
savePath = os.path.join(opts.saveDir, opts.optMode)
SavePlot(p, saveName, savePath, saveFormats=[".png", ".pdf"])
return
def PlotAndFitTemplates(datasetsMgr, histoName, addQcdBaseline, opts):
Verbose("PlotAndFitTemplates()")
# Create comparison plot
p1 = plots.ComparisonPlot(
getHisto(datasetsMgr, "Data", "topSelection_Baseline/%s" % histoName, "Baseline"),
getHisto(datasetsMgr, "EWK" , "topSelection_Baseline/%s" % histoName, "Baseline")
)
p1.histoMgr.normalizeMCToLuminosity(datasetsMgr.getDataset("Data").getLuminosity())
p2 = plots.ComparisonPlot(
getHisto(datasetsMgr, "Data", "topSelection_Inverted/%s" % histoName, "Inverted"),
getHisto(datasetsMgr, "EWK" , "topSelection_Inverted/%s" % histoName, "Inverted")
)
p2.histoMgr.normalizeMCToLuminosity(datasetsMgr.getDataset("Data").getLuminosity())
# Get Baseline histos
Data_baseline = p1.histoMgr.getHisto("Baseline-Data").getRootHisto().Clone("Baseline_Data")
EWK_baseline = p1.histoMgr.getHisto("Baseline-EWK").getRootHisto().Clone("Baseline_EWK")
QCD_baseline = p1.histoMgr.getHisto("Baseline-Data").getRootHisto().Clone("Baseline_QCD")
# Get Inverted histos
Data_inverted = p2.histoMgr.getHisto("Inverted-Data").getRootHisto().Clone("Inverted_Data")
EWK_inverted = p2.histoMgr.getHisto("Inverted-EWK").getRootHisto().Clone("Inverted_EWK")
QCD_inverted = p2.histoMgr.getHisto("Inverted-Data").getRootHisto().Clone("Inverted_QCD")
# Create QCD histos: QCD = Data-EWK
QCD_baseline.Add(EWK_baseline, -1)
QCD_inverted.Add(EWK_inverted, -1)
# Normalize histograms to unit area
if 0:
EWK_baseline.Scale(1.0/EWK_baseline.Integral())
EWK_inverted.Scale(1.0/EWK_inverted.Integral())
QCD_baseline.Scale(1.0/QCD_baseline.Integral())
QCD_inverted.Scale(1.0/QCD_inverted.Integral())
# Create the final plot object
if addQcdBaseline:
compareHistos = [EWK_baseline, QCD_baseline]
else:
compareHistos = [EWK_baseline]
p = plots.ComparisonManyPlot(QCD_inverted, compareHistos, saveFormats=[])
p.setLuminosity(GetLumi(datasetsMgr))
#=========================================================================================
# Start Fit process
#=========================================================================================
binLabels = ["Inclusive"]
moduleInfoString = opts.optMode
FITMIN = 0
FITMAX = 1500
manager = QCDNormalization.QCDNormalizationManagerDefault(binLabels, opts.mcrab, moduleInfoString)
#=========================================================================================
# Create templates (EWK fakes, EWK genuine, QCD; data template is created by manager)
#=========================================================================================
template_EWKFakeB_Baseline = manager.createTemplate("EWKFakeB_Baseline")
template_EWKFakeB_Inverted = manager.createTemplate("EWKFakeB_Inverted")
template_EWKInclusive_Baseline = manager.createTemplate("EWKInclusive_Baseline")
template_EWKInclusive_Inverted = manager.createTemplate("EWKInclusive_Inverted")
template_QCD_Baseline = manager.createTemplate("QCD_Baseline")
template_QCD_Inverted = manager.createTemplate("QCD_Inverted")
#=========================================================================================
# Inclusive EWK
#=========================================================================================
# par[0]*ROOT.Math.crystalball_function(x[0], par[1], par[2], par[3], par[4]) +
# par[5]*ROOT.TMath.BreitWigner(x[0], par[6], par[7]) +
# (1-par[0]-par[5])*ROOT.TMath.Landau(x[0], par[8], par[9])
#template_EWKInclusive_Baseline.setFitter(QCDNormalization.FitFunction("EWKFunction", boundary=200, norm=1, rejectPoints=0), FITMIN, FITMAX)
template_EWKInclusive_Baseline.setFitter(QCDNormalization.FitFunction("EWKFunction", boundary=200, norm=1, rejectPoints=0), FITMIN, 800)
template_EWKInclusive_Baseline.setDefaultFitParam(defaultInitialValue=None,
# p0 p1 p2 p3 p4 p5 p6 p7 p8 p9
#defaultLowerLimit=[0.0, 150.0, 0.0, -5.0, 0.0, 0.0, 150.0, 0.0, 100.0, 0.0],
#defaultUpperLimit=[1.0, 300.0, 50.0, 0.0, 1.0, 1.0, 200.0, 100.0, 200.0, 100.0])
defaultLowerLimit=[0.0, 160.0, 0.0, -1.0, 0.0],
defaultUpperLimit=[1.0, 180.0, 60.0, 0.0, 1e6])
#=========================================================================================
# Note that the same function is used for QCD only and QCD+EWK fakes
#=========================================================================================
#par[0]*ROOT.Math.lognormal_pdf(x[0], par[1], par[2]) + par[3]*ROOT.TMath.Exp(-x[0]*par[4]) + (1-par[0]-par[3])*ROOT.TMath.Gaus(x[0], par[5], part[6])
# 0 = 0.8489 for coeff of lognorm
# 1 = 1.42978 for logshape
# 2 = 238.546 for logmean
#
# 3 = 0.047 for coeff of exp
# 4 = -0.0048 for exp
#
# 5 = 45.486 for gaus sigma
# 6 = 204.6 for gaus mean
#my lognormal is of the form:
#lognorm(x,m0,k) = exp{-[log(x/m0)]^2/[2*log(k)]^2}/sqrt[2pi*log(k)*x]
#and differs than the Math::lognormal_pdf parametrization which takes as arguments lognormal(x,m,s,x0)
#where m = log(m0) and s=log(k)
#TMath::LogNormal return Math::lognormal_pdf
#my exponential is exp(x*a) so the sign comes from the fit
#and my gaussian is exp[-0.5*mean*mean/(sigma*sigma)]
# Double_t LogNormal(x, sigma, theta = 0, m = 1)
#template_QCD_Inverted.setFitter(QCDNormalization.FitFunction("QCDFunction", boundary=350, norm=1), FITMIN, FITMAX)
template_QCD_Inverted.setFitter(QCDNormalization.FitFunction("QCDFunction", boundary=350, norm=1), 100, 800)
template_QCD_Inverted.setDefaultFitParam(defaultInitialValue=None,
defaultLowerLimit=[0.0, 0.0, 200.0, 0.0, -0.1, 200.0, 0.0],
defaultUpperLimit=[1.0, 2.0, 400.0, 0.1, +0.0, 300.0, 60.0])
#=========================================================================================
# Set histograms to the templates
#=========================================================================================
template_EWKFakeB_Baseline.setHistogram(EWK_baseline, "Inclusive")
template_EWKFakeB_Inverted.setHistogram(EWK_inverted, "Inclusive")
template_EWKInclusive_Baseline.setHistogram(EWK_baseline, "Inclusive")
template_EWKInclusive_Inverted.setHistogram(EWK_inverted, "Inclusive")
template_QCD_Baseline.setHistogram(QCD_baseline, "Inclusive")
template_QCD_Inverted.setHistogram(QCD_inverted, "Inclusive")
#=========================================================================================
# Make plots of templates
#=========================================================================================
manager.plotTemplates()
#=========================================================================================
# Fit individual templates to histogram "data_baseline", with custom fit options
#=========================================================================================
fitOptions = "R B L W M Q"
manager.calculateNormalizationCoefficients(Data_baseline, fitOptions, FITMIN, FITMAX)
# Append analysisType to histogram name
saveName = histoName
# Draw the histograms #alex
plots.drawPlot(p, saveName, **GetHistoKwargs(histoName) ) #the "**" unpacks the kwargs_
_kwargs = {"lessThan": True}
p.addCutBoxAndLine(cutValue=173.21, fillColor=ROOT.kRed, box=False, line=True, **_kwargs)
# Save plot in all formats
#SavePlot(p, saveName, os.path.join(opts.saveDir, "Templates") )
return
def PlotHistos(noSF_datasetsMgr, withCR2SF_datasetsMgr, num_histoList, den_histoList, opts):
# Get the histogram customisations (keyword arguments)
_kwargs = GetHistoKwargs(num_histoList[0])
# Get the root histos for all datasets and Control Regions (CRs)
regions = ["SR", "VR", "CR1", "CR2"]
labels = ["Genuine", "Fake", "Inclusive"]
#==========================================================================================
# Get Dictionaries
#==========================================================================================
rhDict_den_noSF = GetRootHistos(noSF_datasetsMgr, den_histoList, regions)
rhDict_num_noSF = GetRootHistos(noSF_datasetsMgr, num_histoList, regions)
rhDict_num_withCR2SF = GetRootHistos(withCR2SF_datasetsMgr, num_histoList, regions) # Scale Factors from CR2 are only applied in the Numerator on EWK+QCD+ST
#=========================================================================================
# Normalization Factors (see: getNormalization.py)
#=========================================================================================
# Marina
f1=0.619886; f2=0.904877;
# =========================================================================================
# (A) Apply Normalization Factors (see: getNormalizations.py)
# =========================================================================================
# Normalize all histograms (QCD and TT) to normalization factors
for re in regions:
rhDict_den_noSF["NormQCD-"+re+"-Inclusive"] = rhDict_den_noSF["QCD-"+re+"-Inclusive"].Clone("NormQCD-"+re+"-Inclusive")
rhDict_den_noSF["NormQCD-"+re+"-Inclusive"].Scale(f1)
rhDict_num_noSF["NormQCD-"+re+"-Inclusive"] =rhDict_num_noSF["QCD-"+re+"-Inclusive"].Clone("NormQCD-"+re+"-Inclusive")
rhDict_num_noSF["NormQCD-"+re+"-Inclusive"].Scale(f1)
rhDict_num_withCR2SF["NormQCD-"+re+"-Inclusive"] = rhDict_num_withCR2SF["QCD-"+re+"-Inclusive"].Clone("NormQCD-"+re+"-Inclusive")
rhDict_num_withCR2SF["NormQCD-"+re+"-Inclusive"].Scale(f1)
for la in labels:
rhDict_den_noSF["NormTT-"+re+"-"+la] = rhDict_den_noSF["TT-"+re+"-"+la].Clone("NormTT-"+re+"-"+la)
rhDict_den_noSF["NormTT-"+re+"-"+la].Scale(f2)
rhDict_num_noSF["NormTT-"+re+"-"+la] = rhDict_num_noSF["TT-"+re+"-"+la].Clone("NormTT-"+re+"-"+la)
rhDict_num_noSF["NormTT-"+re+"-"+la].Scale(f2)
# ==========================================================================================
# (B) Estimate Inclusive TT in SR
# ==========================================================================================
# (B1) Inclusive TT in Data - Denominator = Data - F1*QCD - - EWK - ST
rhDict_den_noSF["TTinData-SR-Inclusive"] = rhDict_den_noSF["Data-SR-Inclusive"].Clone("t#bar{t} (Data)")
rhDict_den_noSF["TTinData-SR-Inclusive"].Add(rhDict_den_noSF["NormQCD-SR-Inclusive"], -1)
rhDict_den_noSF["TTinData-SR-Inclusive"].Add(rhDict_den_noSF["EWK-SR-Inclusive"], -1)
rhDict_den_noSF["TTinData-SR-Inclusive"].Add(rhDict_den_noSF["SingleTop-SR-Inclusive"], -1)
# (B2) Inclusive TT in Data - Numerator = Data - F1*QCD*SF_{CR2} - ST*SF_{CR2} - EWK*SF_{CR2}
rhDict_num_noSF["TTinData-SR-Inclusive"] = rhDict_num_noSF["Data-SR-Inclusive"].Clone("t#bar{t} (Data)")
rhDict_num_noSF["TTinData-SR-Inclusive"].Add(rhDict_num_withCR2SF["NormQCD-SR-Inclusive"], -1)
rhDict_num_noSF["TTinData-SR-Inclusive"].Add(rhDict_num_withCR2SF["SingleTop-SR-Inclusive"], -1)
rhDict_num_noSF["TTinData-SR-Inclusive"].Add(rhDict_num_withCR2SF["EWK-SR-Inclusive"], -1)
# (B3) Inclusive TT in MC - Denominator: rhDict_den_noSF["TT-SR-Inclusive"]
# (B4) Inclusive TT in MC - Numerator: rhDict_num_noSF["TT-SR-Inclusive"]
# ========================================================================================
# (C) Plot Numerator and Denominator (Data Vs MC)
# ========================================================================================
_kwargs["opts"] = {"xmax" : 800, "ymaxfactor" : 2.0}
_kwargs["ratioYlabel"] = "Data/MC"
_kwargs["ratio"] = True
_kwargs["stackMCHistograms"] = False
_kwargs["createLegend"] = {"x1": 0.68, "y1": 0.75, "x2": 0.95, "y2": 0.92}
_kwargs["ratioInvert"] = True
num_data = rhDict_num_noSF["TTinData-SR-Inclusive"].Clone("t#bar{t} (Data)")
den_data = rhDict_den_noSF["TTinData-SR-Inclusive"].Clone("t#bar{t} (Data)")
num_mc = rhDict_num_noSF["TT-SR-Inclusive"].Clone("t#bar{t} (MC)")
den_mc = rhDict_den_noSF["TT-SR-Inclusive"].Clone("t#bar{t} (MC)")
num_data.Rebin(2)
num_mc.Rebin(2)
den_data.Rebin(2)
den_mc.Rebin(2)
styles.getABCDStyle("CR4").apply(num_mc)
styles.getABCDStyle("CR4").apply(den_mc)
# Denominator
hName = "InclusiveTT_SR_Denominator_LeadingJet"
hData_Den = histograms.Histo( den_data, "t#bar{t} (Data)", "Data", drawStyle="AP"); hData_Den.setIsDataMC(isData=True, isMC=False)
hMC_Den = histograms.Histo( den_mc, "t#bar{t} (MC)", "MC", drawStyle="HIST"); hMC_Den.setIsDataMC(isData=False, isMC=True)
pDen = plots.ComparisonManyPlot(hData_Den, [hMC_Den], saveFormats=[])
pDen.setLuminosity(opts.intLumi)
pDen.setDefaultStyles()
plots.drawPlot(pDen, hName, **_kwargs)
SavePlot(pDen, hName, os.path.join(opts.saveDir, opts.optMode), saveFormats = [".png", ".C", ".pdf"])
# Numerator
hName = "InclusiveTT_SR_Numerator_LeadingJet"
hData_Num = histograms.Histo( num_data, "t#bar{t} (Data)", "Data", drawStyle="AP"); hData_Num.setIsDataMC(isData=True, isMC=False)
hMC_Num = histograms.Histo( num_mc, "t#bar{t} (MC)", "MC", drawStyle="HIST"); hMC_Num.setIsDataMC(isData=False, isMC=True)
pNum = plots.ComparisonManyPlot(hData_Num, [hMC_Num], saveFormats=[])
pNum.setLuminosity(opts.intLumi)
pNum.setDefaultStyles()
plots.drawPlot(pNum, hName, **_kwargs)
SavePlot(pNum, hName, os.path.join(opts.saveDir, opts.optMode), saveFormats = [".png", ".C", ".pdf"])
# ========================================================================================
# (D) Plot Genuine TT Efficiency
# ========================================================================================
_kwargs = {
"xlabel" : "p_{T} (GeV/c)",
"ylabel" : "Efficiency",
"ratioYlabel" : "Data/MC",
"ratio" : True,
"ratioInvert" : False,
"ratioType" : "errorScale",
"ratioCreateLegend": True,
"ratioMoveLegend" : {"dx": -0.51, "dy": 0.03, "dh": -0.08},
"ratioErrorOptions": {"numeratorStatSyst": False, "denominatorStatSyst": False},
"errorBarsX" : True,
"stackMCHistograms": False,
"addMCUncertainty" : False,
"addLuminosityText": False,
"addCmsText" : True,
"cmsExtraText" : "Preliminary",
"opts" : {"ymin": 0.0, "ymaxfactor": 1.28, "xmax" : 600},
"opts2" : {"ymin": 0.72, "ymax": 1.28},
"log" : False,
"createLegend" : {"x1": 0.68, "y1": 0.80, "x2": 0.95, "y2": 0.92},
}
bins = [0, 100, 200, 300, 400, 500, 600]
xBins = array.array('d', bins)
nx = len(xBins)-1
# Data
h0_data_den = rhDict_den_noSF["TTinData-SR-Inclusive"].Clone("t#bar{t} (Data)")
h0_data_num = rhDict_num_noSF["TTinData-SR-Inclusive"].Clone("t#bar{t} (Data)")
# MC
h0_mc_den = rhDict_den_noSF["TT-SR-Inclusive"].Clone("t#bar{t} (MC)")
h0_mc_num = rhDict_num_noSF["TT-SR-Inclusive"].Clone("t#bar{t} (MC)")
h0_data_den = h0_data_den.Rebin(nx, "", xBins)
h0_data_num = h0_data_num.Rebin(nx, "", xBins)
h0_mc_den = h0_mc_den.Rebin(nx, "", xBins)
h0_mc_num = h0_mc_num.Rebin(nx, "", xBins)
hNumerator_Data, hDenominator_Data = GetHistosForEfficiency(h0_data_num, h0_data_den)
hNumerator_MC, hDenominator_MC = GetHistosForEfficiency(h0_mc_num, h0_mc_den)
eff_data = ROOT.TEfficiency(hNumerator_Data, hDenominator_Data)
eff_mc = ROOT.TEfficiency(hNumerator_MC, hDenominator_MC)
eff_data.SetStatisticOption(ROOT.TEfficiency.kFCP)
eff_mc.SetStatisticOption(ROOT.TEfficiency.kFCP)
geff_data = convert2TGraph(eff_data)
geff_mc = convert2TGraph(eff_mc)
styles.dataStyle.apply(geff_data)
styles.ttStyle.apply(geff_mc)
Graph_Data = histograms.HistoGraph(geff_data, "t#bar{t} (Data) ", "p", "P")
Graph_MC = histograms.HistoGraph(geff_mc, "t#bar{t} (MC)", "p", "P")
p = plots.ComparisonManyPlot(Graph_MC, [Graph_Data], saveFormats=[])
saveName = "Efficiency_InclusiveTT_SR_LeadingJet"
savePath = os.path.join(opts.saveDir, opts.optMode)
plots.drawPlot(p, savePath, **_kwargs)
SavePlot(p, saveName, os.path.join(opts.saveDir, opts.optMode), saveFormats = [".png", ".pdf", ".C"])
# =============================
# Export JSON file
# =============================
#jsonName = "Efficiency_InclusiveTT_SR_MET50_MuIso0p1_InvMET20_InvMuIso0p1.json"
#runRange = "273150-284044"
#analysis = opts.analysisName
#label = "2016"
#plotDir = os.path.join(opts.folder, jsonName)
#pythonWriter.addParameters(plotDir, label, runRange, opts.intLumi, geff_data)
#pythonWriter.addMCParameters(label, geff_mc)
#pythonWriter.writeJSON(jsonName)
return
def DoPlots(datasetsMgr, histoName, analysisType="Inverted", bType="GenuineB"):
# Sanity checks
IsBaselineOrInverted(analysisType)
IsGenuineOrFake(bType)
# Definitions
defaultFolder = ""
if "FakeBPurity" in histoName:
defaultFolder = "FakeBPurity"
elif "ForFakeBMeasurement" + histoName:
defaultFolder = "ForFakeBMeasurement"
else:
raise Exception("This should never happen")
# Define folders for inclusive/genuine/fakes
inclusiveFolder = defaultFolder
genuineFolder = defaultFolder + "EWKGenuineB"
fakeFolder = defaultFolder + "EWKFakeB"
inclusiveHisto = histoName.replace(defaultFolder, inclusiveFolder)
genuineHisto = histoName.replace(defaultFolder, genuineFolder)
fakeHisto = histoName.replace(defaultFolder, fakeFolder)
# Get the inclusive histograms
p0 = plots.DataMCPlot(datasetsMgr, inclusiveHisto)
Data = p0.histoMgr.getHisto("Data").getRootHisto().Clone("Data")
# Get the genuine-b histograms
p1 = plots.DataMCPlot(datasetsMgr, genuineHisto)
EWKGenuineB = p1.histoMgr.getHisto("EWK").getRootHisto().Clone(
"EWKGenuineB")
QCDGenuineB = p1.histoMgr.getHisto("QCD").getRootHisto().Clone(
"QCDGenuineB")
# Get the fake-b histograms
p2 = plots.DataMCPlot(datasetsMgr, fakeHisto)
EWKFakeB = p2.histoMgr.getHisto("EWK").getRootHisto().Clone("EWKFakeB")
QCDFakeB = p2.histoMgr.getHisto("QCD").getRootHisto().Clone("QCDFakeB")
# Normalize histograms to unit area
if 0:
Data.Scale(1.0 / Data.Integral())
EWKGenuineB.Scale(1.0 / EWKGenuineB.Integral())
EWKFakeB.Scale(1.0 / EWKFakeB.Integral())
QCDGenuineB.Scale(1.0 / QCDGenuineB.Integral())
QCDFakeB.Scale(1.0 / EWKFakeB.Integral())
# Create the final plot object
comparisonList = [EWKGenuineB, QCDGenuineB, EWKFakeB, QCDFakeB]
p = plots.ComparisonManyPlot(Data, comparisonList, saveFormats=[])
p.setLuminosity(GetLumi(datasetsMgr))
# Apply styles
p.histoMgr.forHisto("Data", styles.getDataStyle())
p.histoMgr.forHisto("EWKGenuineB",
styles.getAltEWKStyle()) #GenuineBStyle()
p.histoMgr.forHisto("QCDGenuineB", styles.getQCDStyle())
p.histoMgr.forHisto("EWKFakeB", styles.getGenuineBStyle())
p.histoMgr.forHisto("QCDFakeB", styles.getFakeBStyle())
# Set draw style
p.histoMgr.setHistoDrawStyle("Data", "AP")
p.histoMgr.setHistoDrawStyle("EWKGenuineB", "AP")
p.histoMgr.setHistoDrawStyle("QCDGenuineB", "AP")
p.histoMgr.setHistoDrawStyle("EWKFakeB", "AP")
p.histoMgr.setHistoDrawStyle("QCDFakeB", "AP")
# Set legend style
p.histoMgr.setHistoLegendStyle("Data", "P")
p.histoMgr.setHistoLegendStyle("EWKGenuineB", "P")
p.histoMgr.setHistoLegendStyle("QCDGenuineB", "P")
p.histoMgr.setHistoLegendStyle("EWKFakeB", "P")
p.histoMgr.setHistoLegendStyle("QCDFakeB", "P")
# p.histoMgr.setHistoLegendStyleAll("LP")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Data": "Data",
"EWKGenuineB": "EWK-GenuineB",
"QCDGenuineB": "QCD-GenuineB",
"EWKFakeB": "EWK-FakeB",
"QCDFakeB": "QCD-FakeB",
#"Data" : "Data (%s)" % (analysisType),
#"EWKGenuineB": "EWK-GenuineB (%s)" % (analysisType),
#"QCDGenuineB": "QCD-GenuineB (%s)" % (analysisType),
#"EWKFakeB" : "EWK-FakeB (%s)" % (analysisType),
#"QCDFakeB" : "QCD-FakeB (%s)" % (analysisType),
})
# Draw the histograms
_cutBox = None
_rebinX = 1
_opts = {"ymin": 1e0, "ymaxfactor": 2.0}
_format = "%0.0f"
_xlabel = None
if "dijetm" in histoName.lower():
_rebinX = 2
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jj} (%s)" % (_units)
_cutBox = {
"cutValue": 80.399,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
_opts["xmax"] = 400.0
if "trijetm" in histoName.lower():
_rebinX = 5
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jjb} (%s)" % _units
_cutBox = {
"cutValue": 173.21,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
_opts["xmax"] = 1500.0
if "pt" in histoName.lower():
_rebinX = 2
_format = "%0.0f GeV/c"
if "eta" in histoName.lower():
_format = "%0.2f"
_cutBox = {
"cutValue": 0.,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
_opts["xmin"] = -3.0
_opts["xmax"] = +3.0
if "deltaeta" in histoName.lower():
_format = "%0.2f"
_opts["xmin"] = 0.0
_opts["xmax"] = 6.0
if "bdisc" in histoName.lower():
_format = "%0.2f"
if "tetrajetm" in histoName.lower():
_rebinX = 10
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jjjb} (%s)" % (_units)
_opts["xmax"] = 3500.0
if "ancestry" in histoName.lower():
_rebinX = 1
_units = ""
_format = "%0.0f " + _units
_opts["xmax"] = 32.0
plots.drawPlot(
p,
histoName,
xlabel=_xlabel,
ylabel="Arbitrary Units / %s" % (_format),
log=True,
rebinX=_rebinX,
cmsExtraText="Preliminary",
createLegend={
"x1": 0.62,
"y1": 0.72,
"x2": 0.92,
"y2": 0.92
},
opts=_opts,
opts2={
"ymin": 0.0,
"ymax": 1.5
}, #{"ymin": 0.6, "ymax": 1.4},
ratio=True,
ratioInvert=False,
ratioYlabel="Ratio",
cutBox=_cutBox,
)
# Save plot in all formats
SavePlot(p, histoName,
os.path.join(opts.saveDir, "GenuineVsFake", opts.optMode))
return
def PlotHistograms(datasetsMgr, histoName):
# Get Histogram name and its kwargs
rootHistos = []
bdiscList = ["Loose", "Medium"]
saveName = histoName.rsplit("/")[-1]
kwargs = GetHistoKwargs(saveName, opts)
myBdiscs = []
histoName = histoName.replace(opts.folder, "")
stylesList = [styles.FakeBStyle1, styles.FakeBStyle3, styles.FakeBStyle2, styles.FakeBStyle4]
#stylesList = [styles.fakeBLineStyle1, styles.FakeBStyle2, styles.FakeBStyle3, styles.FakeBStyle4]
# For-loop: All histograms in all regions
for bdisc in bdiscList:
hName_ = histoName.replace(opts.refBdisc, bdisc)
hName = opts.folder + "/" + hName_
if "Data" in datasetsMgr.getAllDatasetNames():
p = plots.DataMCPlot(datasetsMgr, hName, saveFormats=[])
else:
p = plots.MCPlot(datasetsMgr, hName, normalizeToLumi=opts.intLumi, saveFormats=[])
# Append (non-empty) dataset ROOT histos to a list for plotting
h = p.histoMgr.getHisto(opts.dataset).getRootHisto()
if h.GetEntries() > 0:
h.SetName(bdisc)
rootHistos.append(h)
myBdiscs.append(bdisc)
# Create a comparison plot for a given dataset in all CRs
if len(rootHistos) < 2:
Print("Cannot plot comparison due to too few non-empty histograms present (=%i)" % (len(rootHistos)), False)
return
# Move ref histo to top of rootHisto list
for rh in rootHistos:
if opts.refBdisc in rh.GetName():
s = rootHistos.pop( rootHistos.index(rh) )
#rootHistos.insert(0, s)
rootHistos.insert(len(rootHistos), s)
# Draw the comparison plot (first argument the reference histo for ratio purposes)
p = plots.ComparisonManyPlot(rootHistos[-1], rootHistos[:-1], saveFormats=[])
# p = plots.ComparisonManyPlot(rootHistos[0], rootHistos[1:], saveFormats=[])
p.setLuminosity(opts.intLumi)
if opts.normalizeToOne:
p.histoMgr.forEachHisto(lambda h: h.getRootHisto().Scale(1.0/h.getRootHisto().Integral()))
# Apply drawing/legend styles
for i, bdisc in enumerate(myBdiscs, 0):
stylesList[i].apply(p.histoMgr.getHisto(bdisc).getRootHisto())
if bdisc == opts.refBdisc:
p.histoMgr.setHistoDrawStyle(bdisc, "AP")
p.histoMgr.setHistoLegendStyle(bdisc,"LP")
else:
p.histoMgr.setHistoDrawStyle(bdisc, "AP")
p.histoMgr.setHistoLegendStyle(bdisc, "LP")
#p.histoMgr.setHistoDrawStyle(bdisc, "HIST")
#p.histoMgr.setHistoLegendStyle(bdisc, "F")
# Add dataset name on canvas
p.appendPlotObject(histograms.PlotText(0.18, 0.88, plots._legendLabels[opts.dataset], bold=True, size=22))
#p.appendPlotObject(histograms.PlotText(0.18, 0.88, plots._legendLabels[opts.dataset + " (%s)" % ], bold=True, size=22))
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Loose" : "Loose (%s)" % (GetCRLabel(histoName)),
"Medium": "Medium (%s)" % (GetCRLabel(histoName)),
})
# Draw the plot
plots.drawPlot(p, saveName, **kwargs) #the "**" unpacks the kwargs_ dictionary
# Save the plots in custom list of saveFormats
SavePlot(p, saveName, os.path.join(opts.saveDir), [".png", ".pdf"] )
return
def PlotEfficiency_comparison(datasetsMgr, numPath, denPath, datasetsMgr_DR,
intLumi):
# Definitions
myList = []
index = 0
_kwargs = GetHistoKwargs(numPath, opts)
# For-loop: All datasets
#for dataset in datasetsMgr.getAllDatasets():
if 1:
#if "Fake" in numPath:
# return
dataset = datasetsMgr.getDataset("TT")
dataset_DR = datasetsMgr_DR.getDataset("TT")
#if "Fake" in numPath:
# dataset = datasetsMgr.getDataset("QCD")
# dataset_DR = datasetsMgr_DR.getDataset("QCD")
legend = "t#bar{t} (#Delta R < 0.30, #Delta p_{T} / p_{T} < 0.32)"
legend_DR = "t#bar{t} (#Delta R < 0.30)"
styleDef = styles.ttStyle
style_DR = styles.signalStyleHToTB500 #800
n = dataset_DR.getDatasetRootHisto(numPath)
n.normalizeToLuminosity(intLumi)
num_DR = n.getHistogram()
d = dataset_DR.getDatasetRootHisto(denPath)
d.normalizeToLuminosity(intLumi)
den_DR = d.getHistogram()
#=========================================
n = dataset.getDatasetRootHisto(numPath)
n.normalizeToLuminosity(intLumi)
num = n.getHistogram()
d = dataset.getDatasetRootHisto(denPath)
d.normalizeToLuminosity(intLumi)
den = d.getHistogram()
#=========================================
if "binList" in _kwargs:
xBins = _kwargs["binList"]
nx = len(xBins) - 1
num = num.Rebin(nx, "", xBins)
den = den.Rebin(nx, "", xBins)
num_DR = num_DR.Rebin(nx, "", xBins)
den_DR = den_DR.Rebin(nx, "", xBins)
for i in range(1, num.GetNbinsX() + 1):
nbin = num.GetBinContent(i)
dbin = den.GetBinContent(i)
nbin_DR = num_DR.GetBinContent(i)
dbin_DR = den_DR.GetBinContent(i)
eps = nbin / dbin
eps_DR = nbin_DR / dbin_DR
ratio_DR = eps / eps_DR
if ratio_DR > 1:
ratio_DR = 1 / ratio_DR
print "bin: ", i, "eps: ", round(eps,
5), "eps_DR: ", round(eps_DR, 5)
print "bin: ", i, "eps/eps_DR: ", (1.0 - round(ratio_DR, 3)) * 100
# Sanity checks
if den.GetEntries() == 0 or num.GetEntries() == 0:
# continue
return
if num.GetEntries() > den.GetEntries():
# continue
return
# Sanity check (Histograms are valid and consistent) - Always false!
# if not ROOT.TEfficiency.CheckConsistency(num, den):
# continue
# Create Efficiency plots with Clopper-Pearson stats
eff = ROOT.TEfficiency(num, den)
eff.SetStatisticOption(ROOT.TEfficiency.kFCP)
eff_DR = ROOT.TEfficiency(num_DR, den_DR)
eff_DR.SetStatisticOption(ROOT.TEfficiency.kFCP)
eff = convert2TGraph(eff)
eff_DR = convert2TGraph(eff_DR)
# Apply default style (according to dataset name)
#plots._plotStyles[dataset.getName()].apply(eff)
#styleDef.apply(eff)
#style_DR.apply(eff_DR)
styles.markerStyles[0].apply(eff)
styles.markerStyles[1].apply(eff_DR)
'''
eff_DR.SetLineStyle(ROOT.kSolid)
eff.SetLineWidth(2)
eff_DR.SetLineWidth(2)
eff.SetLineStyle(ROOT.kSolid)
eff_DR.SetLineStyle(ROOT.kSolid)
eff.SetMarkerStyle(ROOT.kFullTriangleUp)
eff_DR.SetMarkerStyle(ROOT.kFullTriangleUp)
eff.SetMarkerSize(1.2)
eff_DR.SetMarkerSize(1.2)
'''
# Append in list
myList.append(histograms.HistoGraph(eff, legend, "p", "P"))
myList.append(histograms.HistoGraph(eff_DR, legend_DR, "p", "P"))
# Save plot in all formats
#savePath = os.path.join(opts.saveDir, opts.optMode)
#plots.drawPlot(p, savePath, **_kwargs)
#SavePlot(p, saveName, savePath, saveFormats = [".png", ".pdf"])
# Define stuff
numPath = numPath.replace("AfterAllSelections_", "")
numPath = numPath.replace("LeadingTrijet_Pt", "LdgTopPt")
if "Genuine" in numPath:
TTcateg = "_TTgenuine"
elif "Fake" in numPath:
TTcateg = "_TTfake"
else:
TTcateg = "_TTinclusive"
if "SR" in numPath:
region = "_SR"
if "VR" in numPath:
region = "_VR"
if "CR1" in numPath:
region = "_CR1"
if "CR2" in numPath:
region = "_CR2"
saveName = "Eff_" + numPath.split("/")[-1] + TTcateg + "_BDTtraining"
# Plot the efficiency
p = plots.ComparisonManyPlot(
histograms.HistoGraph(eff, legend, "p", "P"),
[histograms.HistoGraph(eff_DR, legend_DR, "p", "P")],
saveFormats=[".pdf", ".png", ".C"])
leg = ROOT.TLegend(0.2, 0.8, 0.81, 0.87)
leg.SetFillStyle(0)
leg.SetFillColor(0)
leg.SetBorderSize(0)
#{"dx": -0.55, "dy": -0.55, "dh": -0.08}
leg.SetHeader("t#bar{t}")
#if "Fake" in numPath:
# leg.SetHeader("QCD")
leg.Draw()
#moveLegend = {"dx": -0.0, "dy": +0.0, "dh": +0.1}
#moveLegend = {"dx": -0.1, "dy": +0.0, "dh": +0.1}
#p.setLegend(histograms.moveLegend(histograms.createLegend(), **moveLegend))
# Save plot in all formats
savePath = os.path.join(SAVEDIR, "HplusMasses",
numPath.split("/")[0], opts.optMode)
#savePath = os.path.join(opts.saveDir, numPath.split("/")[0], opts.optMode)
plots.drawPlot(p, SAVEDIR, **_kwargs)
#leg.Draw()
SavePlot(p, saveName, SAVEDIR, saveFormats=[".png", ".pdf", ".C"])
return
def PlotHistoGraphs(hGraphList, _kwargs):
# Create & draw the plot
p = plots.ComparisonManyPlot(hGraphList[0], hGraphList[1:], saveFormats=[])
p.setLuminosity(opts.intLumi)
if 0:
p.histoMgr.setHistoLegendStyleAll("P")
p.histoMgr.setHistoDrawStyleAll("LP")
p.histoMgr.setHistoDrawStyle(hGraphList[0].getRootHisto().GetName(),
"HIST")
if opts.saveName == None:
opts.saveName = hGraphList[0].getRootHisto().GetName().split(
"_")[0] + "VsCutflow"
# Draw the plot
p.histoMgr.forEachHisto(
lambda h: h.getRootHisto().SetLineStyle(ROOT.kSolid))
p.histoMgr.forEachHisto(lambda h: h.getRootHisto().SetLineWidth(3))
p.histoMgr.forEachHisto(
lambda h: h.getRootHisto().SetMarkerSize(1.3)) #1.2
if opts.acceptance:
p.histoMgr.forEachHisto(
lambda h: h.getRootHisto().SetMarkerStyle(ROOT.kFullCircle))
plots.drawPlot(p, opts.saveName, **_kwargs)
if not opts.acceptance:
p.getPad2().SetLogy(True)
# Add some text
if opts.refCounter == "passed PV":
xPos = [0.15, 0.24, 0.37, 0.50, 0.65, 0.77,
0.90] #does not work for every reference counter!
else:
xPos = [
0.15 + float(i) / (float(len(opts.binLabels)))
for i in range(0, len(opts.binLabels))
]
# For-loop: All bin labels
for i, b in enumerate(opts.binLabels, 0):
if opts.acceptance:
break
# Calculate coordinats
dx = 0.10 * (i)
dy = 0.0
if _kwargs["ratio"]:
dy = -0.4
# Basic text replacemenets to get compact bin text
bin = b.replace("passed ", "").replace(")", "").replace(
"selection", "").replace("(", "").replace("Selection",
"").replace("PV", "pv")
label = bin.replace("mu", "#mu").replace("Passed", "").replace(
"tau", "#tau").replace(" Veto",
"-veto").replace("Selected Events",
"selected")
label = label.replace("jet", "jets").replace("-", " ")
if 1:
#histograms.addText(0.16+dx, 0.08+dy, label, 19)
histograms.addText(xPos[i], 0.08 + dy, label, 19)
else:
# Automatic assignment (not perfect, yet!)
x = opts.xValues[i] / opts.xValues[-1]
xlow = opts.xErrLow[i] / opts.xErrLow[-1]
xhigh = opts.xErrHigh[i] / opts.xErrHigh[-1]
if i == 0:
x = 0.15
if i > 2:
x -= 0.05
if i == len(opts.binLabels) - 1:
x = 0.92
if not opts.acceptance:
histograms.addText(x, 0.08 + dy, label, 19)
# Save the plot
SavePlot(p,
opts.saveName,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".C", ".png", ".pdf"])
return
def PurityPlots(datasetsMgr, histoName, analysisType="Inverted"):
'''
Create plots with "FakeB=Data-EWKGenuineB"
'''
Verbose(
"Plotting histogram %s for Data, EWK, QCD for %s" %
(histoName, analysisType), True)
# Sanity check
IsBaselineOrInverted(analysisType)
defaultFolder = "FakeBPurity"
genuineBFolder = defaultFolder + "EWKGenuineB"
fakeBFolder = defaultFolder + "EWKFakeB"
# Get histos (Data, EWK) for Inclusive
p1 = plots.ComparisonPlot(*getHistos(datasetsMgr, histoName, analysisType))
p1.histoMgr.normalizeMCToLuminosity(
datasetsMgr.getDataset("Data").getLuminosity())
# Get histos (Data, EWK) for GenuineB
p2 = plots.ComparisonPlot(
*getHistos(datasetsMgr, histoName.replace(
defaultFolder, genuineBFolder), analysisType))
p2.histoMgr.normalizeMCToLuminosity(
datasetsMgr.getDataset("Data").getLuminosity())
# Clone histograms
Data = p1.histoMgr.getHisto(analysisType +
"-Data").getRootHisto().Clone(analysisType +
"-Data")
EWK = p1.histoMgr.getHisto(analysisType +
"-EWK").getRootHisto().Clone(analysisType +
"-EWK")
EWKGenuineB = p2.histoMgr.getHisto(
analysisType + "-EWK").getRootHisto().Clone(analysisType + "-EWK")
FakeB = p1.histoMgr.getHisto(analysisType +
"-Data").getRootHisto().Clone(analysisType +
"-FakeB")
# Subtract EWKGEnuineB from Data to get FakeB
FakeB.Add(EWKGenuineB, -1)
#FakeB.Add(EWK, -1)
# Dos not work
# p1.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(2))
# p2.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(2))
# Comparison plot. The first argument is the reference histo. All other histograms are compared with respect to that.
FakeB_Purity, xMin, xMax = getPurityHisto(FakeB,
Data,
inclusiveBins=False,
printValues=False)
EWKGenuineB_Purity, xMin, xMax = getPurityHisto(EWKGenuineB,
Data,
inclusiveBins=False,
printValues=False)
p = plots.ComparisonManyPlot(FakeB_Purity, [EWKGenuineB_Purity],
saveFormats=[])
# Apply histo styles
p.histoMgr.forHisto(
analysisType + "-FakeB",
styles.getInvertedLineStyle()) #styles.getFakeBLineStyle() )
p.histoMgr.forHisto(
analysisType + "-EWK",
styles.getAltEWKLineStyle()) #styles.getAltEWKStyle() )
# Set draw style
p.histoMgr.setHistoDrawStyle(analysisType + "-FakeB", "HIST")
p.histoMgr.setHistoDrawStyle(analysisType + "-EWK", "HIST")
# Set legend style
p.histoMgr.setHistoLegendStyle(analysisType + "-FakeB", "L")
p.histoMgr.setHistoLegendStyle(analysisType + "-EWK", "L")
# p.histoMgr.setHistoLegendStyleAll("LP")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
analysisType + "-FakeB": "FakeB",
analysisType + "-EWK": "GenuineB (EWK)",
})
# Draw the histograms
_cutBox = None
_rebinX = 1
_opts = {"ymin": 1e-3, "ymaxfactor": 1.2}
_format = "%0.0f"
_opts["xmax"] = xMax
_xlabel = None
if "dijetm" in histoName.lower():
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jj} (%s)" % (_units)
_cutBox = {
"cutValue": 80.399,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
if "trijetm" in histoName.lower():
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jjb} (%s)" % _units
_cutBox = {
"cutValue": 173.21,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
_opts["xmax"] = 1500.0
if "pt" in histoName.lower():
_format = "%0.0f GeV/c"
if "eta" in histoName.lower():
_format = "%0.2f"
_cutBox = {
"cutValue": 0.,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
_opts["xmin"] = -3.0
_opts["xmax"] = +3.0
if "deltaeta" in histoName.lower():
_format = "%0.2f"
_opts["xmin"] = 0.0
_opts["xmax"] = 6.0
if "bdisc" in histoName.lower():
_format = "%0.2f"
if "tetrajetm" in histoName.lower():
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jjjb} (%s)" % (_units)
_opts["xmax"] = 3500.0
# Do the plot
plots.drawPlot(
p,
histoName,
xlabel=_xlabel,
ylabel="Purity / {0}".format(_format),
log=False,
rebinX=_rebinX, # Can only Rebin BEFORE calculating purity
cmsExtraText="Preliminary",
createLegend={
"x1": 0.60,
"y1": 0.80,
"x2": 0.92,
"y2": 0.92
},
opts=_opts,
opts2={
"ymin": 1e-5,
"ymax": 1e0
},
ratio=False,
ratioInvert=False,
ratioYlabel="Ratio",
cutBox=_cutBox,
)
# Save plot in all formats
SavePlot(p, histoName,
os.path.join(opts.saveDir, "Purity",
opts.optMode)) #, saveFormats = [".png"] )
return
def doPlot(self, opts, myAllShapeNuisances, f, mass, luminosity, signalTable, rebinList=None):
def rebin(h, rebinList):
if rebinList == None or h == None:
return h
myArray = array.array("d",rebinList)
hnew = h.Rebin(len(rebinList)-1,h.GetTitle(),myArray)
h.Delete()
return hnew
print "Doing plots for:",self._name
hNominal = f.Get(self._cardReader.getHistoNameForColumn(self._name))
hNominal = rebin(hNominal, rebinList)
hNominal.SetFillStyle(0)
hNominalFine = f.Get(self._cardReader.getHistoNameForColumn(self._name)+"_fineBinning")
hNominalFine = rebin(hNominalFine, rebinList)
hNominalHisto = histograms.Histo(hNominal, self._name, drawStyle="HIST")
# Determine label
mySignalLabels = ["HH","HW","Hp"]
mySignalStatus = False
for l in mySignalLabels:
if l in self._name:
mySignalStatus = True
myMCLabels = ["HH","HW","Hp","MC"]
myMCStatus = False
for mclab in myMCLabels:
if mclab in self._name:
myMCStatus = True
histograms.cmsTextMode = histograms.CMSMode.PRELIMINARY
if myMCStatus:
histograms.cmsTextMode = histograms.CMSMode.SIMULATION_PRELIMINARY
x = 0.6
size = 20
myRatioContainer = RatioPlotContainer(self._label)
for uncName in self._uncertaintyShapes:
myShortName = uncName
print "... uncertainty:",myShortName
myLongName = self._cardReader.getHistoNameForNuisance(self._name, uncName)
hup = f.Get("%sUp"%(myLongName))
hup = rebin(hup, rebinList)
hup.SetFillStyle(0)
up = dataset.RootHistoWithUncertainties(hup)
upFine = f.Get("%sUp_fineBinning"%(myLongName))
upFine = rebin(upFine, rebinList)
nom = dataset.RootHistoWithUncertainties(hNominal.Clone())
nom.makeFlowBinsVisible()
hdown = f.Get("%sDown"%(myLongName))
hdown = rebin(hdown, rebinList)
hdown.SetFillStyle(0)
down = dataset.RootHistoWithUncertainties(hdown)
downFine = f.Get("%sDown_fineBinning"%(myLongName))
downFine = rebin(downFine, rebinList)
up.getRootHisto().SetLineColor(ROOT.kRed)
nom.getRootHisto().SetLineColor(ROOT.kBlack)
down.getRootHisto().SetLineColor(ROOT.kBlue)
upHisto = histograms.Histo(up, "Up %.1f"%_integral(up.getRootHisto()), drawStyle="HIST", legendStyle="l")
downHisto = histograms.Histo(down, "Down %.1f"%_integral(down.getRootHisto()), drawStyle="HIST", legendStyle="l")
nomHisto = histograms.Histo(nom, "Nominal %.1f"%_integral(nom.getRootHisto()), drawStyle="HIST", legendStyle="l")
# Add fit uncert. as stat uncert.
for i in range(0,9):
tailFitUp = f.Get("%s_TailFit_par%dUp"%(myLongName,i))
tailFitDown = f.Get("%s_TailFit_par%dDown"%(myLongName,i))
if tailFitUp != None and tailFitDown != None:
nom.addShapeUncertaintyFromVariation("%s_TailFit_par%d"%(self._name,i),tailFitUp,tailFitDown)
tailFitUp.Delete()
tailFitDown.Delete()
tailfitNames = filter(lambda n: "_TailFit_" in n, nom.getShapeUncertaintyNames())
nom.setShapeUncertaintiesAsStatistical(tailfitNames)
# Do plot
plot = plots.ComparisonManyPlot(nomHisto, [upHisto, downHisto])
plot.setLuminosity(luminosity)
plot.histoMgr.forEachHisto(lambda h: h.getRootHisto().SetLineWidth(3))
myPlotName = "%s/shapeSyst_%s_syst%s" % (_dirname, self._label, uncName.replace("Up",""))
myParams = {}
myParams["ylabel"] = "Events"
myParams["log"] = False
#myParams["opts2"] = {"ymin": 0.0, "ymax":2.0}
myParams["opts2"] = {"ymin": 0.7, "ymax":1.3}
myParams["opts"] = {"ymin": 0.0}
myParams["ratio"] = True
myParams["ratioType"] = "errorScale"
myParams["ratioYlabel"] = "Var./Nom."
myParams["addLuminosityText"] = True
myParams["customizeBeforeDraw"] = customizeMarker
#myParams["ratioErrorOptions"] = {"numeratorStatSyst": False}
myParams["addMCUncertainty"] = True
plots.drawPlot(plot, myPlotName, **myParams)
myRatioContainer.addRatioPlot(plot, myShortName)
# Analyse up and down variation
if mySignalStatus and upFine != None and downFine != None:
a = abs(upFine.Integral()/hNominalFine.Integral() - 1.0)
b = abs(1.0 - downFine.Integral()/hNominalFine.Integral())
r = a
if b > a:
r = b
if uncName in signalTable.keys():
if r < signalTable[uncName]["min"]:
signalTable[uncName]["min"] = r
if r > signalTable[uncName]["max"]:
signalTable[uncName]["max"] = r
else:
signalTable[uncName] = {}
signalTable[uncName]["min"] = r
signalTable[uncName]["max"] = r
# Create plots with only the ratio plot
if opts.individual:
myRatioContainer.drawIndividually()
else:
myRatioContainer.drawAllInOne(myAllShapeNuisances, luminosity)
def PlotEfficiency(datasetsMgr, numPath, denPath):
# Definitions
myList = []
_kwargs = GetHistoKwargs(numPath, opts)
nx = 0
if len(_kwargs["binList"]) > 0:
xBins = _kwargs["binList"]
nx = len(xBins) - 1
counter = 0
# For-loop: All datasets
for dataset in datasetsMgr.getAllDatasets():
if dataset.isMC():
n = dataset.getDatasetRootHisto(numPath)
d = dataset.getDatasetRootHisto(denPath)
num = n.getHistogram()
den = d.getHistogram()
if nx > 0:
num = num.Rebin(nx, "", xBins)
den = den.Rebin(nx, "", xBins)
else:
num = dataset.getDatasetRootHisto(numPath).getHistogram()
den = dataset.getDatasetRootHisto(denPath).getHistogram()
if nx > 0:
num = num.Rebin(nx, "", xBins)
den = den.Rebin(nx, "", xBins)
# Calculations
total = den.Integral(0, den.GetXaxis().GetNbins() + 1)
selected = num.Integral(0, num.GetXaxis().GetNbins() + 1)
if 0:
print "Numerical Efficiency", numPath, dataset.getName(
), ":", round(selected / total, 3)
# Sanity checks
if den.GetEntries() == 0 or num.GetEntries() == 0:
continue
if num.GetEntries() > den.GetEntries():
continue
# Create Efficiency plots with Clopper-Pearson stats
eff = ROOT.TEfficiency(num, den)
eff.SetStatisticOption(ROOT.TEfficiency.kFCP) #FCP
datasetTT = datasetsMgr.getDataset("TT")
# Get the histograms
numTT = datasetTT.getDatasetRootHisto(numPath).getHistogram()
denTT = datasetTT.getDatasetRootHisto(denPath).getHistogram()
if nx > 0:
numTT = numTT.Rebin(nx, "", xBins) #num.Rebin(nx, "", xBins)
denTT = denTT.Rebin(nx, "", xBins) #den.Rebin(nx, "", xBins)
'''
for i in range(1, num.GetNbinsX()+1):
nbin = num.GetBinContent(i)
dbin = den.GetBinContent(i)
nbinTT = numTT.GetBinContent(i)
dbinTT = denTT.GetBinContent(i)
eps = nbin/dbin
epsTT = nbinTT/dbinTT
ratioTT = eps/epsTT
if ratioTT > 1:
ratioTT = 1/ratioTT
#print "bin: ", i, "eps: ", round(eps,5) , "epsTT: ", round(epsTT,5)
#print "bin: ", i, "eps/epsTT: ", (1.0 - round(ratioTT, 3))*100
'''
eff_ref = ROOT.TEfficiency(numTT, denTT)
eff_ref.SetStatisticOption(ROOT.TEfficiency.kFCP) #FCP
# Convert to TGraph
gEff = convert2TGraph(eff)
gEffRef = convert2TGraph(eff_ref)
# Style definitions
stylesDef = styles.ttStyle
styles0 = styles.signalStyleHToTB300
styles1 = styles.signalStyleHToTB500
styles2 = styles.signalStyleHToTB800
styles3 = styles.signalStyleHToTB500
styles4 = styles.signalStyleHToTB1000
styles5 = styles.signalStyleHToTB2000
styles6 = styles.signalStyleHToTB180
styles7 = styles.signalStyleHToTB3000
styles8 = styles.signalStyleHToTB200
if dataset.getName() == "TT":
styles.ttStyle.apply(gEffRef)
legend_ref = "t#bar{t}"
if opts.type == "partonShower":
legend_ref = "t#bar{t} (Pythia8)"
elif opts.type == "evtGen":
legend_ref = "t#bar{t} (Powheg)"
refGraph = histograms.HistoGraph(gEffRef, legend_ref, "p", "P")
else:
styles.markerStyles[counter].apply(gEff)
legend = dataset.getName().replace("TT_", "t#bar{t} (").replace(
"isr", "ISR ").replace("fsr", "FSR ")
legend = legend.replace("hdamp", "hdamp ").replace("DOWN",
"down").replace(
"UP", "up")
legend = legend.replace("mtop1665", "m_{t} = 166.5 GeV")
legend = legend.replace("mtop1695", "m_{t} = 169.5 GeV")
legend = legend.replace("mtop1715", "m_{t} = 171.5 GeV")
legend = legend.replace("mtop1735", "m_{t} = 173.5 GeV")
legend = legend.replace("mtop1755", "m_{t} = 175.5 GeV")
legend = legend.replace("mtop1785", "m_{t} = 178.5 GeV")
legend = legend.replace("TuneEE5C", "Herwig++")
legend += ")"
counter += 1
#myList.append(histograms.HistoGraph(gEff, legend, "lp", "P"))
myList.append(histograms.HistoGraph(gEff, legend, "p", "P"))
# Define stuff
numPath = numPath.replace("AfterAllSelections_", "")
saveName = "Efficiency_%s_%s" % (opts.folder, opts.type)
saveName = saveName.replace("__", "_Inclusive_")
# Plot the efficiency
p = plots.ComparisonManyPlot(refGraph, myList, saveFormats=[])
savePath = os.path.join(opts.saveDir, opts.optMode)
plots.drawPlot(p, savePath, **_kwargs)
# Save plot in all formats
SavePlot(p, saveName, savePath, saveFormats=[".png", ".pdf", ".C"])
return
def PlotEfficiency(datasetsMgr, datasetsMgr40, intLumi):
# Definitions
myList = []
dataset_TT = datasetsMgr.getDataset("TT")
dataset40_TT = datasetsMgr40.getDataset("TT")
dataset_QCD = datasetsMgr.getDataset("QCD")
dataset40_QCD = datasetsMgr40.getDataset("QCD")
# Efficiency
hNumerator = os.path.join(opts.folder, "AllTopQuarkPt_MatchedBDT")
hDenominator = os.path.join(opts.folder,
"TopQuarkPt") #AllTopQuarkPt_Matched
n_TT = dataset40_TT.getDatasetRootHisto(hNumerator)
n_TT.normalizeToLuminosity(intLumi)
num40_TT = n_TT.getHistogram()
d_TT = dataset40_TT.getDatasetRootHisto(hDenominator)
d_TT.normalizeToLuminosity(intLumi)
den40_TT = d_TT.getHistogram()
# Misidentification rate
hNumerator = os.path.join(opts.folder, "TrijetFakePt_BDT")
hDenominator = os.path.join(opts.folder, "TrijetFakePt")
n_QCD = dataset40_QCD.getDatasetRootHisto(hNumerator)
n_QCD.normalizeToLuminosity(intLumi)
num40_QCD = n_QCD.getHistogram()
d_QCD = dataset40_QCD.getDatasetRootHisto(hDenominator)
d_QCD.normalizeToLuminosity(intLumi)
den40_QCD = d_QCD.getHistogram()
# Customise binning
_kwargs = GetHistoKwargs(opts)
if "binList" in _kwargs:
xBins = _kwargs["binList"]
nx = len(xBins) - 1
num40_TT = num40_TT.Rebin(nx, "", xBins)
den40_TT = den40_TT.Rebin(nx, "", xBins)
num40_QCD = num40_QCD.Rebin(nx, "", xBins)
den40_QCD = den40_QCD.Rebin(nx, "", xBins)
# Calculate efficiency
eff40_TT = ROOT.TEfficiency(num40_TT, den40_TT)
eff40_TT.SetStatisticOption(ROOT.TEfficiency.kFCP)
eff40_QCD = ROOT.TEfficiency(num40_QCD, den40_QCD)
eff40_QCD.SetStatisticOption(ROOT.TEfficiency.kFCP) #
eff40_TT = convert2TGraph(eff40_TT)
eff40_QCD = convert2TGraph(eff40_QCD)
styles.ttStyle.apply(eff40_TT)
styles.qcdStyle.apply(eff40_QCD)
# Append in list
gEff40_TT = histograms.HistoGraph(eff40_TT, "t#bar{t}", "lp", "P")
#gEff40_QCD = histograms.HistoGraph(eff40_QCD, "QCD multijet", "lp", "P")
gEff40_QCD = histograms.HistoGraph(eff40_QCD, "QCD", "lp", "P")
myList.append(gEff40_TT)
myList.append(gEff40_QCD)
# Define save name
saveName = "TopTagEfficiency"
# Plot the efficiency
#p = plots.PlotBase(datasetRootHistos=myList, saveFormats=[])
p = plots.ComparisonManyPlot(gEff40_TT, [gEff40_QCD], saveFormats=[])
#p = plots.ComparisonPlot(gEff40_TT, gEff40_QCD, saveFormats=[])
plots.drawPlot(p, saveName, **_kwargs)
# Save plot in all formats
savePath = os.path.join(opts.saveDir, opts.optMode)
save_path = os.path.join(savePath, "BDT0p40")
SavePlot(p, saveName, save_path, saveFormats=[".png", ".C", ".pdf"])
return
def PlotTemplates(datasetsMgr, histoName, analysisType="Inverted"):
Verbose("Plotting EWK Vs QCD unity-normalised histograms")
# Create comparison plot
p1 = plots.ComparisonPlot(
getHisto(datasetsMgr, "Data", histoName, "Baseline"),
getHisto(datasetsMgr, "Data", histoName, "Inverted")
)
p1.histoMgr.normalizeMCToLuminosity(datasetsMgr.getDataset("Data").getLuminosity())
defaultFolder = "ForFakeBMeasurement"
genuineBFolder = defaultFolder + "EWKGenuineB"
fakeBFolder = defaultFolder + "EWKFakeB"
histoNameNew = histoName.replace( defaultFolder, genuineBFolder)
p2 = plots.ComparisonPlot(
getHisto(datasetsMgr, "EWK", histoNameNew, "Baseline"),
getHisto(datasetsMgr, "EWK", histoNameNew, "Inverted")
)
p2.histoMgr.normalizeMCToLuminosity(datasetsMgr.getDataset("Data").getLuminosity())
# Get EWKGenuineB histos
EWKGenuineB_baseline = p2.histoMgr.getHisto("Baseline-EWK").getRootHisto().Clone("Baseline-EWKGenuineB")
EWKGenuineB_inverted = p2.histoMgr.getHisto("Inverted-EWK").getRootHisto().Clone("Inverted-EWKGenuineB")
# Get FakeB histos
FakeB_baseline = p1.histoMgr.getHisto("Baseline-Data").getRootHisto().Clone("Baseline-FakeB")
FakeB_baseline.Add(EWKGenuineB_baseline, -1)
FakeB_inverted = p1.histoMgr.getHisto("Inverted-Data").getRootHisto().Clone("Inverted-FakeB")
FakeB_inverted.Add(EWKGenuineB_inverted, -1)
# Normalize histograms to unit area
EWKGenuineB_baseline.Scale(1.0/EWKGenuineB_baseline.Integral())
EWKGenuineB_inverted.Scale(1.0/EWKGenuineB_inverted.Integral())
FakeB_baseline.Scale(1.0/FakeB_baseline.Integral())
FakeB_inverted.Scale(1.0/FakeB_inverted.Integral())
# Create the final plot object
comparisonList = [EWKGenuineB_baseline]
p = plots.ComparisonManyPlot(FakeB_inverted, comparisonList, saveFormats=[])
p.setLuminosity(GetLumi(datasetsMgr))
# Apply styles
p.histoMgr.forHisto("Baseline-EWKGenuineB", styles.getBaselineStyle() )
p.histoMgr.forHisto("Inverted-FakeB" , styles.getInvertedStyle() )
# Set draw style
p.histoMgr.setHistoDrawStyle("Baseline-EWKGenuineB", "AP")
p.histoMgr.setHistoDrawStyle("Inverted-FakeB" , "HIST")
# Set legend style
p.histoMgr.setHistoLegendStyle("Baseline-EWKGenuineB", "LP")
p.histoMgr.setHistoLegendStyle("Inverted-FakeB" , "LP")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Baseline-EWKGenuineB": "GenuineB (EWK)", # (Baseline)
"Inverted-FakeB" : "FakeB", # (Inverted)
})
# Append analysisType to histogram name
saveName = histoName
# Draw the histograms #alex
plots.drawPlot(p, saveName, **GetHistoKwargs(histoName) ) #the "**" unpacks the kwargs_
# _kwargs = {"lessThan": True}
# p.addCutBoxAndLine(cutValue=200, fillColor=ROOT.kRed, box=False, line=True, ***_kwargs)
# Add text
text = opts.optMode.replace("OptChiSqrCutValue", "#chi^{2} #leq ")
histograms.addText(0.21, 0.85, text)
# Save plot in all formats
saveDir = os.path.join(opts.saveDir, "Templates", opts.optMode)
SavePlot(p, saveName, saveDir, saveFormats = [".C", ".png", ".pdf"])
return
def PlotHistograms(datasetsMgr, histoList, binLabels, opts):
'''
histoList contains all histograms for all bins for CR1 and CR2
'''
# Get the root histos for all datasets and Control Regions (CRs)
rhDict = GetRootHistos(datasetsMgr, histoList)
# For-loop: All root-histo keys (All fake-B bins, all CRs, (CR1, CR2, ..) and all folders (Data, EWKFakeB, EWKGenuineB)
for key1 in rhDict:
# Definitions
region1 = "CRone"
region2 = "CRtwo"
key2 = key1.replace(region1, region2)
dataset = key1.split("-")[0]
region = key1.split("-")[1]
bin = key1.split("-")[2]
hName1 = rhDict[key1].GetName()
hName2 = rhDict[key2].GetName()
bInclusive = "Inclusive" in key1
# Dataset and Region filter
if dataset != "FakeB":
continue
# This gives CR1. can get CR2 by replacing CR1 with CR2 (histo-names are identical otherwise)
if region != region1:
continue
Verbose("Accessing histogram %s" % key1, False)
if bInclusive:
Verbose(
"The histo key is \"%s\" and its name is \"%s\"" %
(key1, rhDict[key1].GetName()), True)
rFakeB_CRone = rhDict[key1].Clone()
rFakeB_CRone.Reset("ICES")
rFakeB_CRtwo = rhDict[key2].Clone()
rFakeB_CRtwo.Reset("ICES")
# For-loop: All fakeB bins (to add-up all binned histos)
for i, b in enumerate(binLabels, 1):
if "Inclusive" in b:
Verbose("Skipping bin-label %s" % (b), False)
continue
else:
Verbose("Adding bin %s" % (b), False)
# Determine keys
k1 = key1.replace("Inclusive", b)
k2 = key2.replace("Inclusive", b)
# Normalise bin histo to one (before adding to inclusive histo)
Verbose("Cloning histogram %s" % (rhDict[k1].GetName()), False)
h1 = rhDict[k1].Clone()
h2 = rhDict[k2].Clone()
# First normalise the histos
h1.Scale(1.0 / h1.Integral())
h2.Scale(1.0 / h2.Integral())
# Add-up individual bins
rFakeB_CRone.Add(h1, +1)
rFakeB_CRtwo.Add(h2, +1)
else:
# Get the histos
rFakeB_CRone = rhDict[key1]
rFakeB_CRtwo = rhDict[key2]
# Normalise the histos?
if opts.normaliseToOne:
rFakeB_CRone.Scale(1.0 / rFakeB_CRone.Integral())
rFakeB_CRtwo.Scale(1.0 / rFakeB_CRtwo.Integral())
# Apply histogram styles
styles.getABCDStyle("CRone").apply(rFakeB_CRone)
styles.getABCDStyle("CRtwo").apply(rFakeB_CRtwo)
# Create the plot
p = plots.ComparisonManyPlot(rFakeB_CRone, [rFakeB_CRtwo],
saveFormats=[])
p.setLuminosity(opts.intLumi)
# Set draw/legend style
p.histoMgr.setHistoDrawStyle(hName1, "AP")
p.histoMgr.setHistoLegendStyle(hName1, "LP")
p.histoMgr.setHistoDrawStyle(hName2, "HIST")
p.histoMgr.setHistoLegendStyle(hName2, "F")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
hName1: "CR1",
hName2: "CR2",
})
# Draw the plot and save it
if bin == "Inclusive":
histoName = histoList[0] + "_CR1vCR2_combined"
else:
histoName = histoList[0] + "_CR1vCR2_bin%s" % (bin)
saveName = histoName.split("/")[-1].replace("CRone0_",
"").replace("CRtwo0_", "")
# Get the histogram customisations (keyword arguments)
p.appendPlotObject(
histograms.PlotText(0.20,
0.88,
GetBinText(bin),
bold=True,
size=22))
plots.drawPlot(p, saveName, **GetHistoKwargs(saveName))
SavePlot(p,
saveName,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png"]) #, ".pdf"])
return