def calculatePlot(dset, neventsCount, name, postfix, treeDraw=None, rejected=None, embedding=None, faketau=None, case1=None, case2=None, case3=None, case4=None):
datasetName = dset.getName()
if treeDraw is None:
h = dset.getDatasetRootHisto(name+"_"+postfix).getHistogram()
else:
h = dset.getDatasetRootHisto(treeDraw).getHistogram()
ROOT.gStyle.SetPaintTextFormat(".0f")
createDrawPlot("count_"+datasetName+"_"+name+"_"+postfix, h)
hFrac = h.Clone("hfrac")
hFracErr = h.Clone("hfracErr")
counts = Counts()
for xbin in xrange(1, h.GetNbinsX()+1):
for ybin in xrange(1, h.GetNbinsY()+1):
value = h.GetBinContent(xbin, ybin)
counts.all += value
this = (h.GetXaxis().GetBinLabel(xbin), h.GetYaxis().GetBinLabel(ybin))
if rejected is not None and this in rejected:
counts.rejected += value
elif embedding is not None and this in embedding:
counts.embedding += value
elif faketau is not None and this in faketau:
counts.faketau += value
elif case1 is not None and this in case1:
counts.case1 += value
elif case2 is not None and this in case2:
counts.case2 += value
elif case3 is not None and this in case3:
counts.case3 += value
elif case4 is not None and this in case4:
counts.case4 += value
frac = dataset.divideBinomial(dataset.Count(value, 0), neventsCount)
frac.multiply(dataset.Count(100))
hFrac.SetBinContent(xbin, ybin, frac.value())
hFracErr.SetBinContent(xbin, ybin, frac.uncertainty())
# print name
# counts.printResults()
# print
try:
counts.crossCheck()
except Exception as e:
raise Exception(str(e)+"\nBin sources:\nrejected: %s\nembedding: %s\nfaketau: %s\ncase1: %s\ncase2: %s\ncase3: %s\ncase4: %s" % (rejected, embedding, faketau, case1, case2, case3, case4))
ROOT.gStyle.SetPaintTextFormat(".4f")
createDrawPlot("frac_"+datasetName+"_"+name+"_"+postfix, hFrac)
# createDrawPlot("frac_"+datasetName+"_"+name+"_"+postfix+"_Uncertainty", hFracErr)
return counts
def normaliseEmbedding(th1):
for bin in xrange(0, th1.GetNbinsX() + 1):
value = dataset.Count(th1.GetBinContent(bin), th1.GetBinError(bin))
value.multiply(embeddingNormalisation)
th1.SetBinContent(bin, value.value())
th1.SetBinError(bin, value.uncertainty())
def addRow(name, newktt, nsignal):
fraction = None
if nsignal != None:
fraction = nsignal.clone()
total = nsignal.clone()
total.add(newktt)
fraction.divide(total)
fraction.multiply(dataset.Count(100))
result.appendRow(counter.CounterRow(name, ["EWK+tt events", "Signal events", "Signal fraction (\%)"], [newktt, nsignal, fraction]))
def signalAreaEvents(embedded, expected, normfactor):
mtMin = 0
lowBin = embedded.FindBin(mtMin)
upBin = embedded.GetNbinsX() + 1 # include the overflow bin
#embeddedCount = integrate(embedded, lowBin, upBin)
#expectedCount = integrate(expected, lowBin, upBin)
#embeddedCount = dataset.Count(embedded.Integral(lowBin, upBin), 0)
#expectedCount = dataset.Count(expected.Integral(lowBin, upBin), 0)
embeddedCount = dataset.Count(embedded.Integral(), 0)
expectedCount = dataset.Count(expected.Integral(), 0)
prediction = embeddedCount.copy()
prediction.multiply(normfactor)
print "Embedded events %.2f" % embeddedCount.value()
print "Predicted events %.2f +- %.2f" % (prediction.value(),
prediction.uncertainty())
print "Expected events %.2f" % expectedCount.value()
def addRow(name):
col = table.getColumn(name=name)
minimum = col.getCount(name="Min")
maximum = col.getCount(name="Max")
# Maximum deviation from average
dev1 = col.getCount(name="Max-mean")
dev2 = col.getCount(name="Mean-min")
if dev2.value() > dev1.value():
dev1 = dev2
dev1.divide(col.getCount(name="Mean"))
dev1.multiply(dataset.Count(100))
ftable.appendRow(counter.CounterRow(name,
["Minimum", "Maximum", "Largest deviation from average (%)"],
[minimum, maximum, dev1]))
def doPlots(table, onlyWjets, mcEvents, normalize, lumi):
nrows = table.getNrows()
function = ROOT.TF1("fitFunction", "[0]")
function.SetParameter(0, 0)
f2 = ROOT.TF1("fitG", "gaus")
f2.SetLineColor(ROOT.kRed)
f2.SetLineWidth(2)
binning = {
"Data": (8, 60, 100),
"Diboson": (8, 0, 2),
"DYJetsToLL": (8, 1, 5),
"EWKMCsum": (8, 40, 120),
"SingleTop": (8, 3, 6),
"TTJets": (10, 25, 35),
"W3Jets": (10, 6, 11),
"WJets": (14, 10, 80),
}
if onlyWjets:
binning["WJets"] = (24, 10, 90)
if not normalize:
binning["Data"] = (10, 70, 120)
binning["EWKMCsum"] = (6, 60, 120)
binning["SingleTop"] = (8, 4, 6)
binning["TTJets"] = (10, 32, 42)
binning["W3Jets"] = (12, 6, 12)
if onlyWjets:
binning["WJets"] = (10, 20, 60)
if mcEvents:
binning["TTJets"] = (12, 320, 440)
binning["WJets"] = (24, 30, 90)
for icol in xrange(table.getNcolumns()):
name = table.getColumnNames()[icol]
label = plots._legendLabels.get(name, name)
if name != "Data":
label += " simulation"
h = ROOT.TH1F(name, name, nrows, 0, nrows)
h2 = ROOT.TH1F(name+"_dist", name, *(binning.get(name, (10, 0, 100))))
mean = dataset.Count(0, 0)
for irow in xrange(nrows):
count = table.getCount(irow, icol)
h.SetBinContent(irow+1, count.value())
h.SetBinError(irow+1, count.uncertainty())
h2.Fill(count.value())
mean.add(count)
mean = dataset.Count(mean.value()/nrows, mean.uncertainty()/nrows)
h.Fit("fitFunction")
value = function.GetParameter(0)
error = function.GetParError(0)
# function.SetParameters(1., 40., 1.);
# function.SetParLimits(0, 0.0, 1.0);
# fitResult = graph.Fit(function, "NRSE+EX0");
# print "Fit status", fitResult.Status()
# #fitResult.Print("V");
# #fitResult.GetCovarianceMatrix().Print();
# function.SetLineColor(graph.GetMarkerColor());
# function.SetLineWidth(2);
function.Draw("same")
ROOT.gPad.Update()
stat = h.FindObject("stats")
if stat:
stat.SetX1NDC(0.2)
stat.SetX2NDC(0.44)
stat.SetY1NDC(0.2)
stat.SetY2NDC(0.3)
stat.SetTextColor(ROOT.kRed)
stat.SetLineColor(ROOT.kRed)
# return (function, fitResult)
styles.dataStyle.apply(h)
p = plots.PlotBase([h])
p.histoMgr.setHistoDrawStyle(name, "EP")
p.createFrame("fluctuation_"+name, opts={"ymin": 0, "ymaxfactor": 1.2, "nbins": nrows})
p.frame.GetXaxis().SetTitle("Embedding trial number")
ylabel = "Simulation"
if name == "Data":
ylabel = "Data"
ylabel += " events"
p.frame.GetYaxis().SetTitle(ylabel)
step = 1
start = 0
if onlyWjets:
start = 4
step = 5
for irow in xrange(start, nrows, step):
p.frame.GetXaxis().SetBinLabel(irow+1, "%d"%(irow+1))
xmin = p.frame.GetXaxis().GetXmin()
xmax = p.frame.GetXaxis().GetXmax()
leg = histograms.moveLegend(histograms.createLegend(), dx=-0.07, dy=-0.6, dh=-0.15)
leg.AddEntry(h, "Trial values", "P")
def createLine(val, st=1, col=ROOT.kRed):
l = ROOT.TLine(xmin, val, xmax, val)
l.SetLineWidth(2)
l.SetLineStyle(st)
l.SetLineColor(col)
return l
fv = createLine(value)
leg.AddEntry(fv, "Fitted value", "L")
p.appendPlotObject(fv)
# fe = createLine(value+error, ROOT.kDashed)
# leg.AddEntry(fe, "Fit uncertainty", "L")
# p.appendPlotObject(fe)
# p.appendPlotObject(createLine(value-error, ROOT.kDashed))
v = createLine(mean.value(), col=ROOT.kBlue)
leg.AddEntry(v, "Mean", "L")
p.appendPlotObject(v)
ve = createLine(mean.value()+mean.uncertainty(), st=ROOT.kDashed, col=ROOT.kBlue)
leg.AddEntry(ve, "Mean uncertainty", "L")
p.appendPlotObject(ve)
p.appendPlotObject(createLine(mean.value()-mean.uncertainty(), st=ROOT.kDashed, col=ROOT.kBlue))
p.legend = leg
p.appendPlotObject(histograms.PlotText(0.65, 0.33, label, size=20))
p.draw()
if name != "Data":
histograms.addCmsPreliminaryText(text="Simulation")
histograms.addEnergyText()
histograms.addLuminosityText(None, None, lumi)
p.save()
###############
f2.SetParameter(1, value)
h2.Fit("fitG")
# f2.Draw("same")
ROOT.gPad.Update()
stat = h2.FindObject("stats")
if stat:
stat.SetX1NDC(0.62)
stat.SetX2NDC(0.9)
stat.SetY1NDC(0.7)
stat.SetY2NDC(0.85)
stat.SetTextColor(ROOT.kRed)
stat.SetLineColor(ROOT.kRed)
styles.dataStyle.apply(h2)
p = plots.PlotBase([h2])
p.histoMgr.setHistoDrawStyle(name+"_dist", "HIST")
p.createFrame("fluctuation_"+name+"_dist", opts={"ymin": 0, "ymaxfactor": 1.4, "nbins": nrows})
p.frame.GetXaxis().SetTitle(ylabel)
p.frame.GetYaxis().SetTitle("Occurrances")
ymin = p.frame.GetYaxis().GetXmin()
ymax = p.frame.GetYaxis().GetXmax()
leg = histograms.moveLegend(histograms.createLegend(), dx=-0.07, dy=-0.25, dh=-0.15)
leg.AddEntry(h2, "Trials", "F")
leg.AddEntry(f2, "Gaussian fit", "L")
def createLine2(val, st=1):
l = ROOT.TLine(val, ymin, val, ymax)
l.SetLineWidth(1)
l.SetLineColor(ROOT.kBlue)
l.SetLineStyle(st)
return l
p.appendPlotObject(h2, "FUNC")
p.appendPlotObject(stat)
p.appendPlotObject(histograms.PlotText(0.65, 0.88, label, size=20))
# fv = createLine2(value)
# leg.AddEntry(fv, "Fit of values", "L")
# p.appendPlotObject(fv)
# fe = createLine2(value+error, ROOT.kDashed)
# leg.AddEntry(fe, "Fit of values unc.", "L")
# p.appendPlotObject(fe)
# p.appendPlotObject(createLine2(value-error, ROOT.kDashed))
p.legend = leg
p.draw()
if name != "Data":
histograms.addCmsPreliminaryText(text="Simulation")
histograms.addEnergyText()
histograms.addLuminosityText(None, None, lumi)
p.save()
def integrate(th, firstBin, lastBin):
integral = dataset.Count(0, 0)
for bin in xrange(firstBin, lastBin + 1):
integral.add(dataset.Count(th.GetBinContent(bin), th.GetBinError(bin)))
return integral
def doScaleFactors(histoSig, histoEmb, outputDir, opts):
binning = systematics._dataDrivenCtrlPlotBinning["shapeTransverseMass"]
histoSig.Rebin(len(binning) - 1, "newsig", array.array("d", binning))
histoEmb.Rebin(len(binning) - 1, "newemb", array.array("d", binning))
grSig = histoSig.getSystematicUncertaintyGraph()
grEmb = histoEmb.getSystematicUncertaintyGraph()
hSig = histoSig.getRootHisto()
hEmb = histoEmb.getRootHisto()
scaleFactors = []
scaleFactors_stat = []
identities = []
def equal(a, b):
if a == 0.0:
return b == 0.0
return abs((a - b) / a) < 0.0001
for i in xrange(0, grSig.GetN()):
lowEdge = grSig.GetX()[i] - grSig.GetErrorXlow(i)
sig_val = grSig.GetY()[i]
sig_err_up = grSig.GetErrorYhigh(i)
sig_err_down = grSig.GetErrorYlow(i)
emb_val = grEmb.GetY()[i]
emb_err_up = grEmb.GetErrorYhigh(i)
emb_err_down = grEmb.GetErrorYlow(i)
# Employ count
cemb = dataset.Count(emb_val, emb_err_up, emb_err_down)
csig = dataset.Count(sig_val, sig_err_up, sig_err_down)
csig.divide(cemb)
cemb_stat = dataset.Count(hEmb.GetBinContent(i + 1),
hEmb.GetBinError(i + 1))
csig_stat = dataset.Count(hSig.GetBinContent(i + 1),
hSig.GetBinError(i + 1))
csig_stat.divide(cemb_stat)
if not equal(lowEdge, hEmb.GetBinLowEdge(i + 1)):
raise Exception("Low edges not equal (%.10g vs %.10g)" %
(lowEdge, hEmb.GetBinLowEdge(i + 1)))
if not equal(csig.value(), csig_stat.value()):
raise Exception("Values not equal (%.10g vs %.10g)" %
(csig.value(), csig_stat.value()))
print "bin %.1f, sf %.7f +%.7f -%.7f (stat +-%.7f)" % (
lowEdge, csig.value(), csig.uncertainty(), csig.systUncertainty(),
csig_stat.uncertainty())
d = OrderedDict.OrderedDict()
d["mt"] = lowEdge
d["efficiency"] = csig.value()
d["uncertaintyPlus"] = csig.uncertainty()
d["uncertaintyMinus"] = csig.systUncertainty()
scaleFactors.append(d)
d = OrderedDict.OrderedDict()
d["mt"] = lowEdge
d["efficiency"] = csig.value()
d["uncertaintyPlus"] = csig_stat.uncertainty()
d["uncertaintyMinus"] = csig_stat.uncertainty()
scaleFactors_stat.append(d)
d = OrderedDict.OrderedDict()
d["mt"] = lowEdge
d["efficiency"] = 1.0
d["uncertaintyPlus"] = 0.0
d["uncertaintyMinus"] = 0.0
identities.append(d)
par = OrderedDict.OrderedDict()
par2 = OrderedDict.OrderedDict()
par2["firstRun"] = 1 # to support also dataEfficiency in MC
par2["lastRun"] = 208686
par2["luminosity"] = 1 # dummy value, not used for anything
par2["bins"] = scaleFactors
par["Run2012ABCD"] = par2
par2 = OrderedDict.OrderedDict()
par2["firstRun"] = 1 # to support also dataEfficiency in MC
par2["lastRun"] = 208686
par2["luminosity"] = 1 # dummy value, not used for anything
par2["bins"] = scaleFactors_stat
par["Run2012ABCD_statOnly"] = par2
ret = OrderedDict.OrderedDict()
ret["_multicrab_embedded"] = os.getcwd()
ret["_multicrab_signalAnalysisGenTau"] = opts.dirSig
ret["dataParameters"] = par
ret["mcParameters"] = {"Run2012ABCD": {"bins": identities}}
tauEmbedding.writeToFile(outputDir, "embedding_mt_weight.json",
json.dumps(ret, indent=2))
import HiggsAnalysis.HeavyChHiggsToTauNu.tools.tdrstyle as tdrstyle
import HiggsAnalysis.HeavyChHiggsToTauNu.tools.styles as styles
# Configuration
#analysis = "signalAnalysis"
analysis = "signalAnalysisTauSelectionHPSTightTauBased"
counters = analysis + "Counters/weighted"
prefix = "TauEmbeddingDataSignalAnalysisData"
embeddingSignalAnalysis = "."
signalAnalysis = "../../multicrab_signalAnalysis_tauIdScan_110411_165833"
useData = True
useData = False
embeddingNormalisation = dataset.Count(0.700, 0.345)
if not useData:
embeddingNormalisation = dataset.Count(0.369, 0.042) # MC
prefix = prefix.replace("Data", "MC")
# main function
def main():
# Read the datasets
# Take only TT+W from signal analysis, and data from embedding+signal analysis
datasetsEmbSig = dataset.getDatasetsFromMulticrabCfg(
cfgfile=embeddingSignalAnalysis + "/multicrab.cfg", counters=counters)
datasetsSig = dataset.getDatasetsFromMulticrabCfg(cfgfile=signalAnalysis +
"/multicrab.cfg",
counters=counters)
def process(datasets, datasetName, postfix, countName):
# Handle counter
eventCounter = counter.EventCounter(datasets)
mainTable = eventCounter.getMainCounterTable()
neventsCount = mainTable.getCount(rowName=countName, colName=datasetName)
nevents = neventsCount.value()
# column = eventCounter.getSubCounterTable("Classification"+postfix).getColumn(name=datasetName)
#
# columnFraction = column.clone()
# columnFraction.setName("Fraction (%)")
#
# # Consistency check, and do the division
# tmp = 0
# for irow in xrange(column.getNrows()):
# tmp += column.getCount(irow).value()
#
# frac = dataset.divideBinomial(columnFraction.getCount(irow), neventsCount)
# frac.multiply(dataset.Count(100))
# columnFraction.setCount(irow, frac)
#
# if int(nevents) != int(tmp):
# raise Exception("Consistency check failed: nevents = %d, tmp = %d" % (int(nevents), int(tmp)))
#
table = counter.CounterTable()
# table.appendColumn(column)
# table.appendColumn(columnFraction)
#
cellFormat = counter.CellFormatText(valueFormat='%.4f', withPrecision=2)
tableFormat = counter.TableFormatText(cellFormat)
print
print "Dataset %s, step %s, nevents %d" % (datasetName, postfix, int(nevents))
print table.format(tableFormat)
# Make plots
dset = datasets.getDataset(datasetName)
tmp = Counts()
oldCanvasDefW = ROOT.gStyle.GetCanvasDefW()
ROOT.gStyle.SetCanvasDefW(int(oldCanvasDefW*1.5))
# (tauID, leptonVeto)
def usualRejected(obj2):
_tauIDLabels = tauIDLabels(obj2)
ret = [("None", "None"), ("None", "#tau_{1}")]
ret.extend([(x, "#tau_{1}") for x in _tauIDLabels[4:]])
ret.extend([(x, obj2) for x in _tauIDLabels])
ret.extend([(x, "Other") for x in _tauIDLabels])
return ret
usualEmbedding = [("#tau_{1}", "None"), ("#tau_{1}+other (corr. sel.)", "None")]
def usualFakeTau(obj2):
return [(x, "None") for x in tauIDLabels(obj2)[4:]]
doubleFakeTau = [("Other", "None")]
usualCase1 = [(x, "#tau_{1}") for x in tauIDLabels("")[1:4]]
usualCase3 = [("#tau_{1}+other (wrong sel.)", "None")]
embCase4 = [(x, "None") for x in tauIDLabels("")[1:4]]
def doubleCase2(obj2):
return [(obj2, "None"), (obj2+"+other", "None")]
selectionStep = {"Before": "",
"AfterJetSelection": "passJetSelection",
"AfterMET": "passMET",
"AfterBTag": "passBTag",
"AfterAllSelections": "passDeltaPhi"}[postfix]
treeDraw = dataset.TreeDraw("tree", varexp="LeptonVetoStatus:TauIDStatus >>htemp(%d,0,%d, %d,0,%d" % (Enum.tauSize, Enum.tauSize, Enum.leptonSize, Enum.leptonSize))
for name, obj2, obj2Type in [
("tau1_electron2", "e_{2}", Enum.obj2Electron),
("tau1_quark2", "q_{2}", Enum.obj2Quark),
("tau1_muon2_nonEmb", "#mu_{2}", Enum.obj2Muon),
]:
tmp += calculatePlot(dset, neventsCount, name, postfix,
treeDraw=treeDraw.clone(selection=And("Obj2Type==%d"%obj2Type, selectionStep), binLabelsX=tauIDLabels(obj2), binLabelsY=leptonVetoLabels(obj2)),
rejected=usualRejected(obj2), embedding=usualEmbedding, faketau=usualFakeTau(obj2),
case1=usualCase1, case3=usualCase3)
tmp += calculatePlot(dset, neventsCount, "tau1_muon2_Emb", postfix,
treeDraw=treeDraw.clone(selection=And("Obj2Type==%d"%Enum.obj2MuonEmb, selectionStep), binLabelsX=tauIDLabels("#mu_{2}"), binLabelsY=leptonVetoLabels("#mu_{2}")),
rejected=usualRejected("#mu_{2}")+usualCase1,
faketau=usualFakeTau("#mu_{2}"),
case4=embCase4)
# createMuon2Plot(dset, "tau1_muon2_Emb", postfix)
for name, obj2, obj2Type in [
("tau1_tau2_notInAcceptance", "#tau_{2}", Enum.obj2TauNotInAcceptance),
("tau1_tauh2", "#tau_{h,2}", Enum.obj2Tauh),
("tau1_taue2", "#tau_{e,2}", Enum.obj2Taue),
("tau1_taumu2_nonEmb", "#tau_{#mu,2}", Enum.obj2Taumu),
]:
tmp += calculatePlot(dset, neventsCount, name, postfix,
treeDraw=treeDraw.clone(selection=And("Obj2Type==%d"%obj2Type, selectionStep), binLabelsX=tauIDLabels(obj2), binLabelsY=leptonVetoLabels(obj2)),
rejected=usualRejected(obj2), embedding=usualEmbedding, faketau=doubleFakeTau,
case1=usualCase1, case3=usualCase3,
case2=doubleCase2(obj2))
tmp += calculatePlot(dset, neventsCount, "tau1_taumu2_Emb", postfix,
treeDraw=treeDraw.clone(selection=And("Obj2Type==%d"%Enum.obj2TaumuEmb, selectionStep), binLabelsX=tauIDLabels("#tau_{#mu,2}"), binLabelsY=leptonVetoLabels("#tau_{#mu,2}")),
rejected=usualRejected("#tau_{#mu,2}")+usualCase1,
faketau=doubleFakeTau,
case4=embCase4)
ROOT.gStyle.SetCanvasDefW(oldCanvasDefW)
## Ntuple stuff
embeddingSelection = Or(*[And("Obj2Type == %d"%obj2, "LeptonVetoStatus == %d"%Enum.leptonNone, Or(*["TauIDStatus == %d" % x for x in [Enum.tauTau1, Enum.tauTau1OtherCorrect]]))
for obj2 in [Enum.obj2Electron, Enum.obj2Quark, Enum.obj2Muon, Enum.obj2TauNotInAcceptance, Enum.obj2Tauh, Enum.obj2Taue, Enum.obj2Taumu]])
case1Selection = Or(*[And("Obj2Type == %d"%obj2, "LeptonVetoStatus == %d"%Enum.leptonTau1, Or(*["TauIDStatus == %d" % x for x in [Enum.tauTau1, Enum.tauTau1OtherCorrect, Enum.tauTau1OtherWrong]]))
for obj2 in [Enum.obj2Electron, Enum.obj2Quark, Enum.obj2Muon, Enum.obj2TauNotInAcceptance, Enum.obj2Tauh, Enum.obj2Taue, Enum.obj2Taumu]])
case2Selection = Or(*[And("Obj2Type == %d"%obj2, "LeptonVetoStatus == %d"%Enum.leptonNone, Or(*["TauIDStatus == %d" % x for x in [Enum.tauObj2, Enum.tauObj2Other]]))
for obj2 in [Enum.obj2TauNotInAcceptance, Enum.obj2Tauh, Enum.obj2Taue, Enum.obj2Taumu]])
embeddingSelection = And(selectionStep, embeddingSelection)
case1Selection = And(selectionStep, case1Selection)
case2Selection = And(selectionStep, case2Selection)
createTransverseMassPlot(dset, "case1", postfix, nominalSelection=embeddingSelection, compareSelection=case1Selection,
nominalLegend="Embedding (correct)", compareLegend="Case 1")
createTransverseMassPlot(dset, "case2", postfix, nominalSelection=embeddingSelection, compareSelection=case2Selection,
nominalLegend="Embedding (correct)", compareLegend="Case 2")
# plotNames = [
# "tau1_electron2",
# "tau1_quark2",
# "tau1_muon2_nonEmb",
# "tau1_muon2_Emb",
# "tau1_tau2_notInAcceptance",
# "tau1_tauh2",
# "tau1_taue2",
# "tau1_taumu2_nonEmb",
# "tau1_taumu2_Emb"
# ]
# for name in plotNames:
# tmp += calculatePlot(dset, neventsCount, name, postfix)
if int(nevents) != int(tmp.all):
raise Exception("Consistency check failed: nevents = %d, tmp = %d" % (int(nevents), int(tmp.all)))
tmp.printResults()
print
tmp.printLegend()
tmp.crossCheck()
allEmbeddingIncluded = int(tmp.embedding) + int(tmp.case1) + int(tmp.case3)
print
print "So, the number of events included by embedding is %d" % allEmbeddingIncluded
print "Of these,"
frac = dataset.divideBinomial(dataset.Count(int(tmp.embedding)), dataset.Count(allEmbeddingIncluded))
frac.multiply(dataset.Count(100))
print " * %d (%s %%) are included correctly" % (int(tmp.embedding), cellFormat.format(frac))
frac = dataset.divideBinomial(dataset.Count(int(tmp.case3)), dataset.Count(allEmbeddingIncluded))
frac.multiply(dataset.Count(100))
print " * %d (%s %%) are included correctly, but wrong object is chosen as tau_h" % (int(tmp.case3), cellFormat.format(frac))
frac = dataset.divideBinomial(dataset.Count(int(tmp.case1)), dataset.Count(allEmbeddingIncluded))
frac.multiply(dataset.Count(100))
print " * %d (%s %%) are included incorrectly (tau_1 identified in lepton veto)" % (int(tmp.case1), cellFormat.format(frac))
print "In addition, the following events are incorrectly rejected"
# Note that these ratios are NOT binomial!
# Although apparently, in practice, the result is the same
#frac = dataset.divideBinomial(dataset.Count(int(tmp.case2)), dataset.Count(allEmbeddingIncluded))
frac = dataset.Count(tmp.case2, math.sqrt(tmp.case2))
frac.divide(dataset.Count(allEmbeddingIncluded, math.sqrt(allEmbeddingIncluded)))
frac.multiply(dataset.Count(100))
print " * %d (%s %%): tau_1 not identified as tau_h, but decay of tau_2 would be" % (int(tmp.case2), cellFormat.format(frac))
#frac = dataset.divideBinomial(dataset.Count(int(tmp.case4)), dataset.Count(allEmbeddingIncluded))
frac = dataset.Count(tmp.case4, math.sqrt(tmp.case4))
frac.divide(dataset.Count(allEmbeddingIncluded, math.sqrt(allEmbeddingIncluded)))
frac.multiply(dataset.Count(100))
print " * %d (%s %%): mu_2 would be accepted for embedding, and is not identified in lepton veto" % (int(tmp.case4), cellFormat.format(frac))
def main():
# Read the datasets
#datasets = dataset.getDatasetsFromMulticrabCfg(counters=counters)
datasets = dataset.getDatasetsFromMulticrabCfg(analysisName=analysis,
searchMode=searchMode,
dataEra=dataEra,
optimizationMode=optMode)
datasets.updateNAllEventsToPUWeighted()
datasets.loadLuminosities()
plots.mergeRenameReorderForDataMC(datasets)
# Remove signals other than M120
### datasets.remove(filter(lambda name: "TTToHplus" in name and not "M120" in name, datasets.getAllDatasetNames()))
#datasets.remove(filter(lambda name: "HplusTB" in name, datasets.getAllDatasetNames()))
datasets.remove(
filter(lambda name: "TTToHplusBHminusB" in name,
datasets.getAllDatasetNames()))
datasets.remove(
filter(lambda name: "TTToHplus" in name,
datasets.getAllDatasetNames()))
# Set the signal cross sections to a given BR(t->H), BR(h->taunu)
xsect.setHplusCrossSectionsToBR(datasets, br_tH=0.05, br_Htaunu=1)
# Set the signal cross sections to a value from MSSM
# xsect.setHplusCrossSectionsToMSSM(datasets, tanbeta=20, mu=200)
### plots.mergeWHandHH(datasets) # merging of WH and HH signals must be done after setting the cross section
style = tdrstyle.TDRStyle()
eventCounter = counter.EventCounter(datasets)
#eventCounter = counter.EventCounter(datasets, counters=counters)
eventCounter.normalizeMCByCrossSection()
mainTable = eventCounter.getMainCounterTable()
cellFormat = counter.TableFormatText(cellFormat=counter.CellFormatText(
valueOnly=True))
print mainTable.format(cellFormat)
#eventCounterUnweighted = counter.EventCounter(datasets, mainCounterOnly=True, counters="counters")
#eventCounterUnweighted.normalizeMCByCrossSection()
#mainTableUnweighted = eventCounterUnweighted.getMainCounterTable()
#print mainTableUnweighted.format(cellFormat)
signalDatasets = [
"HplusTB_M180",
"HplusTB_M190",
"HplusTB_M200",
"HplusTB_M220",
"HplusTB_M250",
"HplusTB_M300",
#"HplusTB_M400",
#"HplusTB_M500",
#"HplusTB_M600",
#"TTToHplusBWB_M80",
#"TTToHplusBWB_M90",
#"TTToHplusBWB_M100",
#"TTToHplusBWB_M120",
#"TTToHplusBWB_M140",
#"TTToHplusBWB_M150",
#"TTToHplusBWB_M155",
#"TTToHplusBWB_M160",
]
allName = "Trigger and HLT_MET cut"
cuts = [
#"Offline selection begins",
"Trigger and HLT_MET cut",
"primary vertex",
"taus == 1",
"tau trigger scale factor",
"electron veto",
"muon veto",
"njets",
"QCD tail killer collinear",
"MET",
"btagging",
"btagging scale factor",
"QCD tail killer back-to-back"
]
xvalues = [180, 190, 200, 220, 250, 300]
#xvalues = [80, 90, 100, 120, 140, 150, 155, 160]
xerrs = [0] * len(xvalues)
yvalues = {}
yerrs = {}
for cut in cuts:
yvalues[cut] = []
yerrs[cut] = []
for name in signalDatasets:
column = mainTable.getColumn(name=name)
#columnUnweighted = mainTableUnweighted.getColumn(name=name)
# Get the counts (returned objects are of type dataset.Count,
# and have both value and uncertainty
#allCount = column.getCount(column.getRowNames().index("Trigger and HLT_MET cut"))
# Somewhat weird way to get total cross section via unweighted counters
#rowNames = column.getRowNames()
#if "allEvents" in rowNames:
# allCount = columnUnweighted.getCount(rowNames.index("allEvents"))
#else:
# # Hack needed because non-triggered signal pattuples do not have allEvents counter!
# allCount = columnUnweighted.getCount(rowNames.index("primaryVertexAllEvents"))
#dset = datasets.getDataset(name)
#allCount.multiply(dataset.Count(dset.getNAllEvents()/dset.getNAllEventsUnweighted()))
allCount = dataset.Count(
datasets.getDataset(name).getCrossSection(), 0)
for cut in cuts:
cutCount = column.getCount(column.getRowNames().index(cut))
eff = cutCount.clone()
eff.divide(allCount) # N(cut) / N(all)
if column.getRowNames().index(cut) == 9: ## btagging
print cut, eff.value()
yvalues[cut].append(eff.value())
yerrs[cut].append(eff.uncertainty())
def createErrors(cutname):
gr = ROOT.TGraphErrors(len(xvalues), array.array("d", xvalues),
array.array("d", yvalues[cutname]),
array.array("d", xerrs),
array.array("d", yerrs[cutname]))
gr.SetMarkerStyle(24)
gr.SetMarkerColor(2)
gr.SetMarkerSize(0.9)
gr.SetLineStyle(1)
gr.SetLineWidth(2)
return gr
#gtrig = createErrors("primary vertex")
gtrig = createErrors("Trigger and HLT_MET cut")
print gtrig
gtrig.SetLineColor(38)
gtrig.SetMarkerColor(38)
gtrig.SetMarkerStyle(20)
gtrig.SetLineStyle(2)
gtrig.SetMarkerSize(2)
gtau = createErrors("taus == 1")
gtau.SetLineColor(2)
gtau.SetMarkerColor(2)
gtau.SetMarkerStyle(20)
gtau.SetMarkerSize(2)
gtau.SetLineStyle(3)
#gtau = createErrors("trigger scale factor")
gveto = createErrors("muon veto")
gveto.SetLineColor(1)
gveto.SetMarkerColor(1)
gveto.SetMarkerStyle(21)
gveto.SetMarkerSize(2)
gveto.SetLineStyle(4)
gjets = createErrors("njets")
gjets.SetLineColor(4)
gjets.SetMarkerColor(4)
gjets.SetMarkerStyle(22)
gjets.SetMarkerSize(2)
gjets.SetLineStyle(1)
gcoll = createErrors("QCD tail killer collinear")
gcoll.SetLineColor(6)
gcoll.SetMarkerColor(6)
gcoll.SetMarkerStyle(26)
gcoll.SetMarkerSize(2)
gcoll.SetLineStyle(2)
gmet = createErrors("MET")
gmet.SetLineColor(1)
gmet.SetMarkerColor(1)
gmet.SetMarkerStyle(24)
gmet.SetMarkerSize(2)
gmet.SetLineStyle(5)
gbtag = createErrors("btagging")
gbtag.SetLineColor(2)
gbtag.SetMarkerColor(2)
gbtag.SetMarkerStyle(25)
gbtag.SetMarkerSize(2)
gbtag.SetLineStyle(6)
print gbtag
gback = createErrors("QCD tail killer back-to-back")
gback.SetLineColor(7)
gback.SetMarkerColor(7)
gback.SetMarkerStyle(23)
gback.SetMarkerSize(2)
gback.SetLineStyle(1)
#gtau = createErrors("trigger scale factor")
glist = [gtrig, gtau, gveto, gjets, gcoll, gmet, gbtag, gback]
opts = {"xmin": 175, "xmax": 310, "ymin": 0.001}
canvasFrame = histograms.CanvasFrame(
[histograms.HistoGraph(g, "", "") for g in glist], "SignalEfficiency",
**opts)
canvasFrame.frame.GetYaxis().SetTitle("Selection efficiency")
canvasFrame.frame.GetXaxis().SetTitle("m_{H^{#pm}} (GeV/c^{2})")
canvasFrame.canvas.SetLogy(True)
canvasFrame.frame.Draw()
for gr in glist:
gr.Draw("PC same")
histograms.addStandardTexts()
legend2 = histograms.createLegend(x1=0.5, y1=0.7, x2=0.9, y2=0.85)
legend2.AddEntry(gtrig, "Trigger", "lp")
legend2.AddEntry(gtau, "Loose #tau identification", "lp")
legend2.AddEntry(gveto, "lepton vetoes", "lp")
legend2.AddEntry(gjets, "3 jets", "lp")
legend2.Draw()
legend = histograms.createLegend(x1=0.35, y1=0.15, x2=0.7, y2=0.3)
legend.AddEntry(gcoll, "QCD tail killer collinear", "lp")
legend.AddEntry(gmet, "MET > 60 GeV", "lp")
legend.AddEntry(gbtag, "b tagging ", "lp")
legend.AddEntry(gback, "QCD tail killer back-to-back: Tight", "lp")
legend.Draw()
canvasFrame.canvas.SaveAs(".png")
canvasFrame.canvas.SaveAs(".C")
canvasFrame.canvas.SaveAs(".eps")
