def doCounters(datasetsEmb, datasetsSig, datasetName):
lumi = datasetsEmb.getLuminosity()
# Counters
eventCounterEmb = tauEmbedding.EventCounterMany(datasetsEmb)
eventCounterSig = counter.EventCounter(datasetsSig)
def isNotThis(name):
return name != datasetName
eventCounterEmb.removeColumns(filter(isNotThis, datasetsEmb.getAllDatasetNames()))
eventCounterSig.removeColumns(filter(isNotThis, datasetsSig.getAllDatasetNames()))
eventCounterSig.normalizeMCToLuminosity(lumi)
tdCount = dataset.TreeDraw("dummy", weight=tauEmbedding.signalNtuple.weightBTagging)
tdCountMET = tdCount.clone(weight=tauEmbedding.signalNtuple.weight, selection=tauEmbedding.signalNtuple.metCut)
tdCountBTagging = tdCount.clone(selection=And(tauEmbedding.signalNtuple.metCut, tauEmbedding.signalNtuple.bTaggingCut))
tdCountDeltaPhi160 = tdCount.clone(selection=And(tauEmbedding.signalNtuple.metCut, tauEmbedding.signalNtuple.bTaggingCut, tauEmbedding.signalNtuple.deltaPhi160Cut))
tdCountDeltaPhi130 = tdCount.clone(selection=And(tauEmbedding.signalNtuple.metCut, tauEmbedding.signalNtuple.bTaggingCut, tauEmbedding.signalNtuple.deltaPhi130Cut))
def addRow(name, td):
tdEmb = td.clone(tree=analysisEmb+"/tree")
tdSig = td.clone(tree=analysisSig+"/tree")
eventCounterEmb.mainCounterAppendRow(name, tdEmb)
eventCounterSig.getMainCounter().appendRow(name, tdSig)
addRow("JetsForEffs", tdCount.clone(weight=tauEmbedding.signalNtuple.weight))
addRow("METForEffs", tdCountMET)
addRow("BTagging (SF)", tdCountBTagging)
addRow("DeltaPhi < 160", tdCountDeltaPhi160)
addRow("BTagging (SF) again", tdCountBTagging)
addRow("DeltaPhi < 130", tdCountDeltaPhi130)
table = counter.CounterTable()
col = eventCounterEmb.getMainCounterTable().getColumn(name=datasetName)
table.appendColumn(counter.efficiencyColumn("Embedded eff", col))
col = eventCounterSig.getMainCounterTable().getColumn(name=datasetName)
table.appendColumn(counter.efficiencyColumn("Normal eff", col))
table.keepOnlyRows(["btagging", "METForEffs", "BTagging (SF)", "DeltaPhi < 160", "DeltaPhi < 130"])
row = table.getRow(name="btagging")
table.removeRow(name="btagging")
table.insertRow(1, row)
table.renameRows({
"METForEffs": "MET > 50",
"btagging": "b tagging",
"BTagging (SF)": "b tagging with SF (w.r.t MET)",
"DeltaPhi < 130": "DeltaPhi < 130 (w.r.t. btagSF)"
})
effFormat = counter.TableFormatText(counter.CellFormatTeX(valueFormat='%.4f', withPrecision=2))
# print table.format(effFormat)
fname = "counters_selections_%s.txt"%datasetName
f = open(fname, "w")
f.write(table.format(effFormat))
f.close()
print "Printed selection counters to", fname
def doTauCounters(datasetsEmb,
datasetsSig,
datasetName,
ntupleCacheEmb,
ntupleCacheSig,
normalizeEmb=True):
lumi = datasetsEmb.getLuminosity()
# Take unweighted counters for embedded, to get a handle on the muon isolation efficiency
eventCounterEmb = tauEmbedding.EventCounterMany(
datasetsEmb,
counters="/" + tauAnalysisEmb + "Counters",
normalize=normalizeEmb)
eventCounterSig = counter.EventCounter(datasetsSig,
counters="/" + tauAnalysisEmb +
"Counters")
def isNotThis(name):
return name != datasetName
eventCounterEmb.removeColumns(
filter(isNotThis, datasetsEmb.getAllDatasetNames()))
eventCounterSig.removeColumns(
filter(isNotThis, datasetsSig.getAllDatasetNames()))
eventCounterEmb.mainCounterAppendRows(
ntupleCacheEmb.histogram("counters/weighted/counter"))
eventCounterSig.getMainCounter().appendRows(
ntupleCacheSig.histogram("counters/weighted/counter"))
eventCounterSig.normalizeMCToLuminosity(lumi)
table = counter.CounterTable()
col = eventCounterEmb.getMainCounterTable().getColumn(name=datasetName)
col.setName("Embedded")
table.appendColumn(col)
col = eventCounterSig.getMainCounterTable().getColumn(name=datasetName)
col.setName("Normal")
table.appendColumn(col)
lastCountEmb = table.getCount(colName="Embedded",
irow=table.getNrows() - 1)
lastCountNormal = table.getCount(colName="Normal",
irow=table.getNrows() - 1)
postfix = ""
if not normalizeEmb:
postfix = "_notEmbNormalized"
effFormat = counter.TableFormatLaTeX(
counter.CellFormatTeX(valueFormat="%.4f", withPrecision=2))
countFormat = counter.TableFormatText(
counter.CellFormatText(valueFormat="%.4f"),
#columnSeparator=" ;"
)
fname = "counters_tau_" + datasetName + postfix + ".txt"
f = open(fname, "w")
f.write(table.format(countFormat))
f.write("\n")
try:
ratio = lastCountNormal.clone()
ratio.divide(lastCountEmb)
f.write("Normal/embedded = %.4f +- %.4f\n\n" %
(ratio.value(), ratio.uncertainty()))
except ZeroDivisionError:
pass
f.close()
print "Printed tau counters to", fname
if not normalizeEmb:
return
tableEff = counter.CounterTable()
tableEff.appendColumn(
counter.efficiencyColumn("Embedded eff",
table.getColumn(name="Embedded")))
tableEff.appendColumn(
counter.efficiencyColumn("Normal eff", table.getColumn(name="Normal")))
embeddingMuonIsolationEff = tableEff.getCount(
rowName="tauEmbeddingMuonsCount", colName="Embedded eff")
embeddingTauIsolationEff = tableEff.getCount(rowName="Isolation",
colName="Embedded eff")
embeddingTotalIsolationEff = embeddingMuonIsolationEff.clone()
embeddingTotalIsolationEff.multiply(embeddingTauIsolationEff)
# Remove unnecessary rows
rowNames = [
# "All events",
"Decay mode finding",
"Eta cut",
"Pt cut",
"Leading track pt",
"Against electron",
"Against muon",
"Isolation",
"One prong",
"Rtau",
]
tableEff.keepOnlyRows(rowNames)
rowIndex = tableEff.getRowNames().index("Isolation")
tableEff.insertRow(
rowIndex,
counter.CounterRow("Mu isolation (emb)",
["Embedded eff", "Normal eff"],
[embeddingMuonIsolationEff, None]))
tableEff.insertRow(
rowIndex + 1,
counter.CounterRow("Tau isolation (emb)",
["Embedded eff", "Normal eff"],
[embeddingTauIsolationEff, None]))
tableEff.setCount2(embeddingTotalIsolationEff,
rowName="Isolation",
colName="Embedded eff")
#tableEff.setCount2(None, rowName="pT > 15", colName="Normal eff")
#print table.format(effFormat)
fname = "counters_tau_" + datasetName + "_eff.txt"
f = open(fname, "w")
f.write(tableEff.format(effFormat))
f.write("\n")
f.close()
print "Printed tau efficiencies to", fname
def doCounters(datasetsEmb2, datasetsSig2, datasetName):
lumi = datasetsEmb2.getDataset("Data").getLuminosity()
datasetsEmb = datasetsEmb2.deepCopy()
datasetsSig = datasetsSig2.deepCopy()
datasetsEmb.remove(
filter(lambda name: name != datasetName,
datasetsEmb.getAllDatasetNames()))
datasetsSig.remove(
filter(lambda name: name != datasetName,
datasetsSig.getAllDatasetNames()))
# Counters
eventCounterEmb = counter.EventCounter(datasetsEmb,
counters=analysisEmb + "Counters")
eventCounterSig = counter.EventCounter(datasetsSig,
counters=analysisSig + "Counters")
eventCounterEmb.normalizeMCToLuminosity(lumi)
eventCounterSig.normalizeMCToLuminosity(lumi)
#effFormat = counter.TableFormatText(counter.CellFormatText(valueFormat='%.4f'))
#effFormat = counter.TableFormatConTeXtTABLE(counter.CellFormatTeX(valueFormat='%.4f'))
effFormat = counter.TableFormatText(
counter.CellFormatTeX(valueFormat='%.4f'))
counterEmb = eventCounterEmb.getMainCounter()
counterSig = eventCounterSig.getMainCounter()
treeDraw = dataset.TreeDraw("dummy")
tdEmb = treeDraw.clone(tree=analysisEmb + "/tree")
tdSig = treeDraw.clone(tree=analysisSig + "/tree")
selectionsCumulative = []
tauSelectionsCumulative = []
def sel(name, selection):
selectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
sel = "&&".join(sel)
counterEmb.appendRow(name, tdEmb.clone(selection=sel))
counterSig.appendRow(name, tdSig.clone(selection=sel))
def tauSel(name, selection):
tauSelectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
sel = "&&".join(sel)
counterEmb.appendRow(name, tdEmb.clone(selection=sel))
counterSig.appendRow(name, tdSig.clone(selection=sel))
# sel("Primary vertex", tauPlot.pvSelection)
sel(">= 1 tau candidate", "Length$(taus_p4) >= 1")
tauSel("Decay mode finding", tauPlot.decayModeFinding)
tauSel("pT > 15", "(taus_p4.Pt() > 15)")
tauSel("pT > 40", tauPlot.tauPtCut)
tauSel("eta < 2.1", tauPlot.tauEtaCut)
tauSel("leading track pT > 20", tauPlot.tauLeadPt)
tauSel("ECAL fiducial", tauPlot.ecalFiducial)
tauSel("againstElectron", tauPlot.electronRejection)
tauSel("againstMuon", tauPlot.muonRejection)
tauSel("isolation", tauPlot.tightIsolation)
tauSel("oneProng", tauPlot.oneProng)
tauSel("Rtau", tauPlot.rtau)
sel("3 jets", tauPlot.jetEventSelection)
sel("MET", tauPlot.metSelection)
sel("btag", tauPlot.btagEventSelection)
table = counter.CounterTable()
col = counterEmb.getTable().getColumn(name=datasetName)
col.setName("Embedded")
table.appendColumn(col)
col = counterSig.getTable().getColumn(name=datasetName)
col.setName("Normal")
table.appendColumn(col)
col = table.getColumn(name="Embedded")
table.insertColumn(1, counter.efficiencyColumn(col.getName() + " eff",
col))
col = table.getColumn(name="Normal")
table.appendColumn(counter.efficiencyColumn(col.getName() + " eff", col))
print "%s counters" % datasetName
print table.format(effFormat)
def doPlots(datasetsEmb, datasetsSig, datasetName):
lumi = datasetsEmb.getDataset("Data").getLuminosity()
plots._legendLabels[datasetName+"_Embedded"] = "Embedded "+plots._legendLabels[datasetName]
plots._legendLabels[datasetName+"_Normal"] = "Normal "+plots._legendLabels[datasetName]
def createPlot(name):
name2Emb = name
name2Sig = name
if isinstance(name, basestring):
name2Emb = analysisEmb+"/"+name
name2Sig = analysisSig+"/"+name
else:
name2Emb = name.clone(tree=analysisEmb+"/tree")
name2Sig = name.clone(tree=analysisSig+"/tree")
emb = datasetsEmb.getDataset(datasetName).getDatasetRootHisto(name2Emb)
emb.setName("Embedded")
sig = datasetsSig.getDataset(datasetName).getDatasetRootHisto(name2Sig)
sig.setName("Normal")
p = plots.ComparisonPlot(emb, sig)
p.histoMgr.normalizeMCToLuminosity(lumi)
p.histoMgr.setHistoLegendLabelMany({
"Embedded": "Embedded "+plots._legendLabels[datasetName],
"Normal": "Normal "+plots._legendLabels[datasetName],
})
p.histoMgr.forEachHisto(styles.generator())
return p
opts2 = {"ymin": 0, "ymax": 2}
def drawControlPlot(path, xlabel, **kwargs):
drawPlot(createPlot("ControlPlots/"+path), "mcembsig_"+datasetName+"_"+path, xlabel, opts2=opts2, **kwargs)
# Control plots
drawControlPlot("SelectedTau_pT_AfterStandardSelections", "#tau-jet p_{T} (GeV/c)", opts={"xmax": 250}, rebin=2, cutBox={"cutValue": 40, "greaterThan": 40})
drawControlPlot("SelectedTau_eta_AfterStandardSelections", "#tau-jet #eta", opts={"xmin": -2.2, "xmax": 2.2}, ylabel="Events / %.1f", rebin=4, log=False, moveLegend={"dy":-0.6, "dx":-0.2})
drawControlPlot("SelectedTau_phi_AfterStandardSelections", "#tau-jet #phi", rebin=10, ylabel="Events / %.2f", log=False)
drawControlPlot("SelectedTau_LeadingTrackPt_AfterStandardSelections", "#tau-jet ldg. charged particle p_{T} (GeV/c)", opts={"xmax": 300}, rebin=2, cutBox={"cutValue": 20, "greaterThan": True})
drawControlPlot("SelectedTau_Rtau_AfterStandardSelections", "R_{#tau} = p^{ldg. charged particle}/p^{#tau jet}", opts={"xmin": 0.65, "xmax": 1.05, "ymin": 1e-1, "ymaxfactor": 5}, rebin=5, ylabel="Events / %.2f", moveLegend={"dx":-0.3}, cutBox={"cutValue":0.7, "greaterThan":True})
drawControlPlot("SelectedTau_p_AfterStandardSelections", "#tau-jet p (GeV/c)", rebin=2)
drawControlPlot("SelectedTau_LeadingTrackP_AfterStandardSelections", "#tau-jet ldg. charged particle p (GeV/c)", rebin=2)
#drawControlPlot("IdentifiedElectronPt_AfterStandardSelections", "Electron p_{T} (GeV/c)")
#drawControlPlot("IdentifiedMuonPt_AfterStandardSelections", "Muon p_{T} (GeV/c)")
drawControlPlot("Njets_AfterStandardSelections", "Number of jets", ylabel="Events")
drawControlPlot("MET", "Uncorredted PF E_{T}^{miss} (GeV)", rebin=5, opts={"xmax": 400}, cutLine=50)
drawControlPlot("NBjets", "Number of selected b jets", opts={"xmax": 6}, ylabel="Events", moveLegend={"dx":-0.3, "dy":-0.5}, cutLine=1)
treeDraw = dataset.TreeDraw("dummy", weight="weightPileup")
tdDeltaPhi = treeDraw.clone(varexp="acos( (tau_p4.Px()*met_p4.Px()+tau_p4.Py()*met_p4.Py())/(tau_p4.Pt()*met_p4.Et()) )*57.3 >>tmp(18, 0, 180)")
tdMt = treeDraw.clone(varexp="sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))) >>tmp(20,0,200)")
# DeltaPhi
xlabel = "#Delta#phi(#tau, MET) (^{#circ})"
def customDeltaPhi(h):
yaxis = h.getFrame().GetYaxis()
yaxis.SetTitleOffset(0.8*yaxis.GetTitleOffset())
drawPlot(createPlot(tdDeltaPhi.clone()), "mcembsig_"+datasetName+"_deltaPhi_1AfterTauID", xlabel, log=False, opts2=opts2, ylabel="Events / %.0f^{#circ}", function=customDeltaPhi, moveLegend={"dx":-0.22}, cutLine=[130, 160])
# mT
xlabel = "m_{T} (#tau jet, E_{T}^{miss}) (GeV/c^{2})"
drawPlot(createPlot(tdMt.clone()), "mcembsig_"+datasetName+"_transverseMass_1AfterTauID", xlabel, opts2=opts2, ylabel="Events / %.0f GeV/c^{2}")
# After all cuts
metCut = "(met_p4.Et() > 50)"
bTaggingCut = "passedBTagging"
selection = "&&".join([metCut, bTaggingCut])
drawPlot(createPlot(treeDraw.clone(varexp="tau_p4.Pt() >>tmp(20,0,200)", selection=selection)), "mcembsig_"+datasetName+"_selectedTauPt_3AfterBTagging", "#tau-jet p_{T} (GeV/c)", opts2={"ymin": 0, "ymax": 2})
drawPlot(createPlot(treeDraw.clone(varexp="met_p4.Pt() >>tmp(16,0,400)", selection=selection)), "mcembsig_"+datasetName+"_MET_3AfterBTagging", "E_{T}^{miss} (GeV)", ylabel="Events / %.0f GeV", opts2={"ymin": 0, "ymax": 2})
drawPlot(createPlot(tdMt.clone(selection=selection)), "mcembsig_"+datasetName+"_transverseMass_3AfterBTagging", xlabel, opts2={"ymin": 0, "ymax": 2}, ylabel="Events / %.0f GeV/c^{2}")
eventCounterEmb = counter.EventCounter(datasetsEmb, counters=analysisEmb+"Counters")
eventCounterSig = counter.EventCounter(datasetsSig, counters=analysisSig+"Counters")
eventCounterEmb.normalizeMCToLuminosity(lumi)
eventCounterSig.normalizeMCToLuminosity(lumi)
#effFormat = counter.TableFormatText(counter.CellFormatText(valueFormat='%.4f'))
#effFormat = counter.TableFormatConTeXtTABLE(counter.CellFormatTeX(valueFormat='%.4f'))
effFormat = counter.TableFormatText(counter.CellFormatTeX(valueFormat='%.4f'))
for function, cname in [
(lambda c: c.getMainCounterTable(), "Main"),
(lambda c: c.getSubCounterTable("TauIDPassedEvt::tauID_HPSTight"), "Tau")
]:
tableEmb = function(eventCounterEmb)
tableSig = function(eventCounterSig)
table = counter.CounterTable()
col = tableEmb.getColumn(name=datasetName)
col.setName("Embedded")
table.appendColumn(col)
col = tableSig.getColumn(name=datasetName)
col.setName("Normal")
table.appendColumn(col)
print "%s counters" % cname
print table.format()
if cname == "Main":
#map(lambda t: t.keepOnlyRows([
table.keepOnlyRows([
"All events",
"Trigger and HLT_MET cut",
"taus == 1",
#"trigger scale factor",
"electron veto",
"muon veto",
"MET",
"njets",
"btagging",
"btagging scale factor",
"JetsForEffs",
"METForEffs",
"BTagging",
"DeltaPhi < 160",
"DeltaPhi < 130"
])#, [tableEmb, tableSig])
else:
#map(lambda t: t.keepOnlyRows([
table.keepOnlyRows([
"AllTauCandidates",
"DecayModeFinding",
"TauJetPt",
"TauJetEta",
#"TauLdgTrackExists",
"TauLdgTrackPtCut",
"TauECALFiducialCutsCracksAndGap",
"TauAgainstElectronCut",
"TauAgainstMuonCut",
#"EMFractionCut",
"HPS",
"TauOneProngCut",
"TauRtauCut",
])#, [tableEmb, tableSig])
col = table.getColumn(name="Embedded")
table.insertColumn(1, counter.efficiencyColumn(col.getName()+" eff", col))
col = table.getColumn(name="Normal")
table.appendColumn(counter.efficiencyColumn(col.getName()+" eff", col))
print "%s counters" % cname
print table.format(effFormat)
def doCounters(datasetsEmb, datasetsSig, datasetName):
lumi = datasetsEmb.getLuminosity()
# Counters
eventCounterEmb = tauEmbedding.EventCounterMany(datasetsEmb, counters=analysisEmb+"Counters/weighted")
eventCounterSig = counter.EventCounter(datasetsSig, counters=analysisSig+"Counters/weighted")
def isNotThis(name):
return name != datasetName
#eventCounterSig.normalizeMCToLuminosity(lumi)
#print eventCounterSig.getMainCounterTable().format()
#return
eventCounterEmb.removeColumns(filter(isNotThis, datasetsEmb.getAllDatasetNames()))
eventCounterSig.removeColumns(filter(isNotThis, datasetsSig.getAllDatasetNames()))
eventCounterSig.normalizeMCToLuminosity(lumi)
tdCount = dataset.TreeDraw("dummy", weight=weightBTagging)
tdCountMET = tdCount.clone(weight=weight, selection=metCut)
tdCountBTagging = tdCount.clone(selection=And(metCut, bTaggingCut))
tdCountDeltaPhi160 = tdCount.clone(selection=And(metCut, bTaggingCut, deltaPhi160Cut))
tdCountDeltaPhi130 = tdCount.clone(selection=And(metCut, bTaggingCut, deltaPhi130Cut))
def addRow(name, td):
tdEmb = td.clone(tree=analysisEmb+"/tree")
tdSig = td.clone(tree=analysisSig+"/tree")
eventCounterEmb.mainCounterAppendRow(name, tdEmb)
eventCounterSig.getMainCounter().appendRow(name, tdSig)
addRow("JetsForEffs", tdCount.clone(weight=weight))
addRow("METForEffs", tdCountMET)
addRow("BTagging (SF)", tdCountBTagging)
addRow("DeltaPhi < 160", tdCountDeltaPhi160)
addRow("BTagging (SF) again", tdCountBTagging)
addRow("DeltaPhi < 130", tdCountDeltaPhi130)
#effFormat = counter.TableFormatText(counter.CellFormatText(valueFormat='%.4f'))
#effFormat = counter.TableFormatConTeXtTABLE(counter.CellFormatTeX(valueFormat='%.4f'))
effFormat = counter.TableFormatText(counter.CellFormatTeX(valueFormat='%.4f'))
f = open("counters_%s.txt"%datasetName, "w")
for function, cname in [
(lambda c: c.getMainCounterTable(), "Main"),
(lambda c: c.getSubCounterTable("TauIDPassedEvt::tauID_HPSTight"), "Tau")
]:
tableEmb = function(eventCounterEmb)
tableSig = function(eventCounterSig)
table = counter.CounterTable()
col = tableEmb.getColumn(name=datasetName)
col.setName("Embedded")
table.appendColumn(col)
col = tableSig.getColumn(name=datasetName)
col.setName("Normal")
table.appendColumn(col)
f.write("%s counters\n" % cname)
f.write(table.format())
f.write("\n")
if cname == "Main":
#map(lambda t: t.keepOnlyRows([
table.keepOnlyRows([
"All events",
"Trigger and HLT_MET cut",
"taus == 1",
#"trigger scale factor",
"electron veto",
"muon veto",
"MET",
"njets",
"btagging",
"btagging scale factor",
"JetsForEffs",
"METForEffs",
"BTagging (SF)",
"DeltaPhi < 160",
"BTagging (SF) again",
"DeltaPhi < 130"
])#, [tableEmb, tableSig])
else:
#map(lambda t: t.keepOnlyRows([
table.keepOnlyRows([
"AllTauCandidates",
"DecayModeFinding",
"TauJetPt",
"TauJetEta",
#"TauLdgTrackExists",
"TauLdgTrackPtCut",
"TauECALFiducialCutsCracksAndGap",
"TauAgainstElectronCut",
"TauAgainstMuonCut",
#"EMFractionCut",
"HPS",
"TauOneProngCut",
"TauRtauCut",
])#, [tableEmb, tableSig])
col = table.getColumn(name="Embedded")
table.insertColumn(1, counter.efficiencyColumn(col.getName()+" eff", col))
col = table.getColumn(name="Normal")
table.appendColumn(counter.efficiencyColumn(col.getName()+" eff", col))
f.write("%s counters\n" % cname)
f.write(table.format(effFormat))
f.write("\n\n")
f.close()
def doCounters(datasetsEmb):
isCorrected = isinstance(datasetsEmb, result.DatasetsDYCorrection)
if isCorrected:
eventCounter = result.EventCounterDYCorrection(datasetsEmb, counters=analysisEmb+counters)
else:
scaleNormalization = analysisEmb != "signalAnalysis"
eventCounter = result.EventCounterMany(datasetsEmb, counters=analysisEmb+counters, scaleNormalization=scaleNormalization)
# Add counts
sels = []
tdCount = treeDraw.clone(weight=weightBTagging)
tdCountMET = tdCount.clone(weight=weight, selection="&&".join(sels+[metCut]))
tdCountBTagging = tdCount.clone(selection="&&".join(sels+[metCut, bTaggingCut]))
tdCountDeltaPhi160 = tdCount.clone(selection="&&".join(sels+[metCut, bTaggingCut, deltaPhi160Cut]))
tdCountDeltaPhi130 = tdCount.clone(selection="&&".join(sels+[metCut, bTaggingCut, deltaPhi130Cut]))
tdCountDeltaPhi90 = tdCount.clone(selection="&&".join(sels+[metCut, bTaggingCut, deltaPhi90Cut]))
eventCounter.mainCounterAppendRow("JetsForEffs", tdCount.clone(weight=weight, selection="&&".join(sels)))
eventCounter.mainCounterAppendRow("METForEffs", tdCountMET)
eventCounter.mainCounterAppendRow("BTagging", tdCountBTagging)
eventCounter.mainCounterAppendRow("DeltaPhi < 160", tdCountDeltaPhi160)
eventCounter.mainCounterAppendRow("DeltaPhi < 130", tdCountDeltaPhi130)
eventCounter.mainCounterAppendRow("DeltaPhi < 90", tdCountDeltaPhi90)
if not isCorrected:
td1 = tdCount.clone(selection=metCut+"&&"+bTaggingCut+"&& (tecalometNoHF_p4.Pt() > 60)")
td2 = tdCount.clone(selection=metCut+"&&"+bTaggingCut+"&& (tecalomet_p4.Pt() > 60)")
td3 = dataset.TreeDrawCompound(td1, {
"SingleMu_Mu_170722-172619_Aug05": td2,
"SingleMu_Mu_172620-173198_Prompt": td2,
"SingleMu_Mu_173236-173692_Prompt": td2,
})
eventCounter.mainCounterAppendRow("BTagging+CaloMetNoHF", td1)
eventCounter.mainCounterAppendRow("BTagging+CaloMet", td2)
eventCounter.mainCounterAppendRow("BTagging+CaloMet(NoHF)", td3)
#(mainTable, mainTableChi2) = eventCounter.getMainCounterTableFit()
mainTable = eventCounter.getMainCounterTable()
ewkDatasets = ["WJets", "TTJets", "DYJetsToLL", "SingleTop", "Diboson"]
allDatasets = None
if "QCD_Pt20_MuEnriched" in datasetsEmb.getAllDatasetNames():
allDatasets = ["QCD_Pt20_MuEnriched"]+ewkDatasets
def ewkSum(table):
table.insertColumn(1, counter.sumColumn("EWKMCsum", [table.getColumn(name=name) for name in ewkDatasets]))
if allDatasets != None:
table.insertColumn(2, counter.sumColumn("MCSum", [table.getColumn(name=name) for name in allDatasets]))
ewkSum(mainTable)
cellFormat = counter.TableFormatText(counter.CellFormatTeX(valueFormat='%.3f'))
#print mainTableChi2.format(cellFormat)
print mainTable.format(cellFormat)
tauTable = eventCounter.getSubCounterTable("TauIDPassedEvt::tauID_HPSTight")
ewkSum(tauTable)
print tauTable.format(cellFormat)
# Efficiencies
mainTable.keepOnlyRows([
"All events",
"Trigger and HLT_MET cut",
"taus == 1",
# "trigger scale factor",
"electron veto",
"muon veto",
"MET",
"njets",
"btagging",
"btagging scale factor",
"JetsForEffs",
"METForEffs",
"BTagging",
"DeltaPhi < 160",
"DeltaPhi < 130"
])
tauTable.keepOnlyRows([
"AllTauCandidates",
"DecayModeFinding",
"TauJetPt",
"TauJetEta",
"TauLdgTrackExists",
"TauLdgTrackPtCut",
"TauECALFiducialCutsCracksAndGap",
"TauAgainstElectronCut",
"TauAgainstMuonCut",
#"EMFractionCut",
"HPS",
"TauOneProngCut",
"TauRtauCut",
])
effFormat = counter.TableFormatText(counter.CellFormatTeX(valueFormat='%.4f'))
#effFormat = counter.TableFormatConTeXtTABLE(counter.CellFormatTeX(valueFormat='%.4f'))
for name, table in [("Main", mainTable), ("Tau ID", tauTable)]:
effTable = counter.CounterTable()
col = table.getColumn(name="Data")
effTable.appendColumn(col)
effTable.appendColumn(counter.efficiencyColumn(col.getName()+" eff", col))
col = table.getColumn(name="EWKMCsum")
effTable.appendColumn(col)
effTable.appendColumn(counter.efficiencyColumn(col.getName()+" eff", col))
print "%s counter efficiencies" % name
print effTable.format(effFormat)
if isCorrected:
return
print "Trigger uncertainties"
bins = [40, 50, 60, 80]
tauPtPrototype = ROOT.TH1F("tauPtTrigger", "Tau pt", len(bins)-1, array.array("d", bins))
runs = [
"(160431 <= run && run <= 167913)",
"(170722 <= run && run <= 173198)",
"(173236 <= run && run <= 173692)",
#"(160431 <= run && run <= 173692)",
]
for name, td in [
("BTagging", tdCountBTagging),
("DeltaPhi160", tdCountDeltaPhi160),
("DeltaPhi130", tdCountDeltaPhi130),
("DeltaPhi90", tdCountDeltaPhi90)
]:
t = td.clone(varexp="tau_p4.Pt() >>tauPtTrigger")
NallSum = 0
NSum = 0
absUncSquareSum = 0
for runRegion in runs:
#neventsPlot = createPlot(dataset.treeDrawToNumEntries(t.clone(weight="weightTrigger")))
#uncertaintyPlot = createPlot(dataset.treeDrawToNumEntries(t.clone(weight="weightTriggerAbsUnc*weightTriggerAbsUnc/(weightTrigger*weightTrigger)")))
tmp = t.clone(selection=t.selection+"&&"+runRegion)
(th1all, gr) = datasetsEmb.getHistogram("Data", tmp.clone(weight="")) # Nall
(th1, gr) = datasetsEmb.getHistogram("Data", tmp.clone(weight="weightTrigger")) # Nevents
(th12, gr) = datasetsEmb.getHistogram("Data", tmp.clone(weight="weightTriggerAbsUnc")) # uncertainty
Nall = th1all.Integral(0, th1all.GetNbinsX()+1)
N = th1.Integral(0, th1.GetNbinsX()+1)
#absSum2 = th12.Integral(0, th12.GetNbinsX()+1)
#absUnc = math.sqrt(absSum2)
#absUnc = th12.Integral(0, 2)
NallSum += Nall
NSum += N
absUnc = tauEmbeddingPlot.squareSum(th12)
absUncSquareSum += absUnc
absUnc = math.sqrt(absUnc)
relUnc = 0
if N > 0:
relUnc = absUnc/N
print "%-15s for runs %s Nall = %.2f, N = %.2f, absolute uncertainty %.2f, relative uncertainty %.4f" % (name, runRegion, Nall, N, absUnc, relUnc)
absUnc = math.sqrt(absUncSquareSum)
relUnc = absUnc/NSum
print "%-15s Nall = %.2f, N = %.2f, absolute uncertainty %.2f, relative uncertainty %.4f" % (name, NallSum, NSum, absUnc, relUnc)
print
def doCounters(datasetsEmb, datasetsSig, datasetName):
lumi = datasetsEmb.getLuminosity()
# Counters
eventCounterEmb = tauEmbedding.EventCounterMany(datasetsEmb)
eventCounterSig = counter.EventCounter(datasetsSig)
def isNotThis(name):
return name != datasetName
eventCounterEmb.removeColumns(
filter(isNotThis, datasetsEmb.getAllDatasetNames()))
eventCounterSig.removeColumns(
filter(isNotThis, datasetsSig.getAllDatasetNames()))
eventCounterSig.normalizeMCToLuminosity(lumi)
tdCount = dataset.TreeDraw("dummy",
weight=tauEmbedding.signalNtuple.weightBTagging)
tdCountMET = tdCount.clone(weight=tauEmbedding.signalNtuple.weight,
selection=tauEmbedding.signalNtuple.metCut)
tdCountBTagging = tdCount.clone(
selection=And(tauEmbedding.signalNtuple.metCut,
tauEmbedding.signalNtuple.bTaggingCut))
tdCountDeltaPhi160 = tdCount.clone(selection=And(
tauEmbedding.signalNtuple.metCut, tauEmbedding.signalNtuple.
bTaggingCut, tauEmbedding.signalNtuple.deltaPhi160Cut))
tdCountDeltaPhi130 = tdCount.clone(selection=And(
tauEmbedding.signalNtuple.metCut, tauEmbedding.signalNtuple.
bTaggingCut, tauEmbedding.signalNtuple.deltaPhi130Cut))
def addRow(name, td):
tdEmb = td.clone(tree=analysisEmb + "/tree")
tdSig = td.clone(tree=analysisSig + "/tree")
eventCounterEmb.mainCounterAppendRow(name, tdEmb)
eventCounterSig.getMainCounter().appendRow(name, tdSig)
addRow("JetsForEffs",
tdCount.clone(weight=tauEmbedding.signalNtuple.weight))
addRow("METForEffs", tdCountMET)
addRow("BTagging (SF)", tdCountBTagging)
addRow("DeltaPhi < 160", tdCountDeltaPhi160)
addRow("BTagging (SF) again", tdCountBTagging)
addRow("DeltaPhi < 130", tdCountDeltaPhi130)
table = counter.CounterTable()
col = eventCounterEmb.getMainCounterTable().getColumn(name=datasetName)
table.appendColumn(counter.efficiencyColumn("Embedded eff", col))
col = eventCounterSig.getMainCounterTable().getColumn(name=datasetName)
table.appendColumn(counter.efficiencyColumn("Normal eff", col))
table.keepOnlyRows([
"btagging", "METForEffs", "BTagging (SF)", "DeltaPhi < 160",
"DeltaPhi < 130"
])
row = table.getRow(name="btagging")
table.removeRow(name="btagging")
table.insertRow(1, row)
table.renameRows({
"METForEffs": "MET > 50",
"btagging": "b tagging",
"BTagging (SF)": "b tagging with SF (w.r.t MET)",
"DeltaPhi < 130": "DeltaPhi < 130 (w.r.t. btagSF)"
})
effFormat = counter.TableFormatText(
counter.CellFormatTeX(valueFormat='%.4f', withPrecision=2))
# print table.format(effFormat)
fname = "counters_selections_%s.txt" % datasetName
f = open(fname, "w")
f.write(table.format(effFormat))
f.close()
print "Printed selection counters to", fname
def doCounters(datasetsEmb, datasetsSig, datasetName):
lumi = datasetsEmb.getLuminosity()
# Counters
eventCounterEmb = result.EventCounterMany(datasetsEmb,
counters=analysisEmb +
"Counters/weighted")
eventCounterSig = counter.EventCounter(datasetsSig,
counters=analysisSig +
"Counters/weighted")
def isNotThis(name):
return name != datasetName
eventCounterEmb.removeColumns(
filter(isNotThis, datasetsEmb.getAllDatasetNames()))
eventCounterSig.removeColumns(
filter(isNotThis, datasetsSig.getAllDatasetNames()))
eventCounterSig.normalizeMCToLuminosity(lumi)
tdCount = dataset.TreeDraw("dummy", weight=weightBTagging)
tdCountMET = tdCount.clone(weight=weight, selection=metCut)
tdCountBTagging = tdCount.clone(selection=And(metCut, bTaggingCut))
tdCountDeltaPhi160 = tdCount.clone(
selection=And(metCut, bTaggingCut, deltaPhi160Cut))
tdCountDeltaPhi130 = tdCount.clone(
selection=And(metCut, bTaggingCut, deltaPhi130Cut))
def addRow(name, td):
tdEmb = td.clone(tree=analysisEmb + "/tree")
tdSig = td.clone(tree=analysisSig + "/tree")
eventCounterEmb.mainCounterAppendRow(name, tdEmb)
eventCounterSig.getMainCounter().appendRow(name, tdSig)
addRow("JetsForEffs", tdCount.clone(weight=weight))
addRow("METForEffs", tdCountMET)
addRow("BTagging (SF)", tdCountBTagging)
addRow("DeltaPhi < 160", tdCountDeltaPhi160)
addRow("BTagging (SF) again", tdCountBTagging)
addRow("DeltaPhi < 130", tdCountDeltaPhi130)
#effFormat = counter.TableFormatText(counter.CellFormatText(valueFormat='%.4f'))
#effFormat = counter.TableFormatConTeXtTABLE(counter.CellFormatTeX(valueFormat='%.4f'))
effFormat = counter.TableFormatText(
counter.CellFormatTeX(valueFormat='%.4f'))
f = open("counters_%s.txt" % datasetName, "w")
for function, cname in [
(lambda c: c.getMainCounterTable(), "Main"),
(lambda c: c.getSubCounterTable("TauIDPassedEvt::tauID_HPSTight"),
"Tau")
]:
tableEmb = function(eventCounterEmb)
tableSig = function(eventCounterSig)
table = counter.CounterTable()
col = tableEmb.getColumn(name=datasetName)
col.setName("Embedded")
table.appendColumn(col)
col = tableSig.getColumn(name=datasetName)
col.setName("Normal")
table.appendColumn(col)
f.write("%s counters\n" % cname)
f.write(table.format())
f.write("\n")
if cname == "Main":
#map(lambda t: t.keepOnlyRows([
table.keepOnlyRows([
"All events",
"Trigger and HLT_MET cut",
"taus == 1",
#"trigger scale factor",
"electron veto",
"muon veto",
"MET",
"njets",
"btagging",
"btagging scale factor",
"JetsForEffs",
"METForEffs",
"BTagging (SF)",
"DeltaPhi < 160",
"BTagging (SF) again",
"DeltaPhi < 130"
]) #, [tableEmb, tableSig])
else:
#map(lambda t: t.keepOnlyRows([
table.keepOnlyRows([
"AllTauCandidates",
"DecayModeFinding",
"TauJetPt",
"TauJetEta",
#"TauLdgTrackExists",
"TauLdgTrackPtCut",
"TauECALFiducialCutsCracksAndGap",
"TauAgainstElectronCut",
"TauAgainstMuonCut",
#"EMFractionCut",
"HPS",
"TauOneProngCut",
"TauRtauCut",
]) #, [tableEmb, tableSig])
col = table.getColumn(name="Embedded")
table.insertColumn(
1, counter.efficiencyColumn(col.getName() + " eff", col))
col = table.getColumn(name="Normal")
table.appendColumn(
counter.efficiencyColumn(col.getName() + " eff", col))
f.write("%s counters\n" % cname)
f.write(table.format(effFormat))
f.write("\n\n")
f.close()
def main():
datasets = dataset.getDatasetsFromMulticrabCfg(counters=baseline+"Counters")
datasets.remove([
# "SingleMu_Mu_160431-163261_May10",
# "SingleMu_Mu_163270-163869_May10",
# "SingleMu_Mu_165088-166150_Prompt",
# "SingleMu_Mu_166161-166164_Prompt",
# "SingleMu_Mu_166346-166346_Prompt",
# "SingleMu_Mu_166374-167043_Prompt",
# "SingleMu_Mu_167078-167913_Prompt",
# "SingleMu_Mu_170722-172619_Aug05",
# "SingleMu_Mu_172620-173198_Prompt",
# "SingleMu_Mu_173236-173692_Prompt",
])
datasets.loadLuminosities()
plots.mergeRenameReorderForDataMC(datasets)
values = {}
analyses = [
("Baseline", baseline),
("Plus", plus),
("Minus", minus)
]
mainTable = counter.CounterTable()
tauTable = counter.CounterTable()
cntr = "Counters"
if normalize:
cntr += "/weighted"
for name, analysis in analyses:
eventCounter = counter.EventCounter(datasets, counters=analysis+cntr)
eventCounter.normalizeMCByLuminosity()
if normalize:
tauEmbedding.scaleNormalization(eventCounter)
col = eventCounter.getMainCounterTable().getColumn(name="Data")
col.setName(name)
mainTable.appendColumn(col)
effcol = counter.efficiencyColumn(col.getName()+" eff", col)
mainTable.appendColumn(effcol)
values[name+"Main"] = effcol
value = col.getCount(col.getRowNames().index(count)).value()
values[name] = value
col = eventCounter.getSubCounterTable("TauIDPassedEvt::tauID_HPSTight").getColumn(name="Data")
col.setName(name)
tauTable.appendColumn(col)
effcol = counter.efficiencyColumn(col.getName()+" eff", col)
tauTable.appendColumn(effcol)
values[name+"Tau"] = effcol
mainTable.appendColumn(counter.divideColumn("Plus eff/Baseline", values["PlusMain"], values["BaselineMain"]))
mainTable.appendColumn(counter.divideColumn("Minus eff/Baseline", values["MinusMain"], values["BaselineMain"]))
tauTable.appendColumn(counter.divideColumn("Plus eff/Baseline", values["PlusTau"], values["BaselineTau"]))
tauTable.appendColumn(counter.divideColumn("Minus eff/Baseline", values["MinusTau"], values["BaselineTau"]))
print mainTable.format()
print tauTable.format()
plusDiff = abs(values["Baseline"] - values["Plus"])
minusDiff = abs(values["Baseline"] - values["Minus"])
maxDiff = max(plusDiff, minusDiff)
rel = maxDiff / values["Baseline"]
print "Count %s, baseline %.3f, plus %.3f, minus %.3f" % (count, values["Baseline"], values["Plus"], values["Minus"])
print "Plus diff %.3f, minus diff %.3f" % (plusDiff, minusDiff)
print "Relative uncertainty from tau energy scale %.6f" % (rel)
style = tdrstyle.TDRStyle()
histograms.createLegend.moveDefaults(dx=-0.32, dh=-0.15)
metCut = "(met_p4.Et() > 50)"
bTaggingCut = "passedBTagging"
tdMt = dataset.TreeDraw("dummy",
weight="weightPileup*weightTrigger*weightBTagging",
selection=metCut+"&&"+bTaggingCut,
varexp="sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))) >>tmp(40,0,400)"
)
output = ROOT.TFile.Open("mt_variated_ewk.root", "RECREATE")
#doPlot(datasets, analyses, tdMt, "mt_variated")
doPlot(datasets, analyses, "transverseMass", "mt_variated_btagging", output, "Dphi180")
doPlot(datasets, analyses, "transverseMassAfterDeltaPhi160", "mt_variated_deltaPhi160", output, "Dphi160")
doPlot(datasets, analyses, "transverseMassAfterDeltaPhi130", "mt_variated_deltaPhi130", output, "Dphi130")
doPlot(datasets, analyses, "transverseMassAfterDeltaPhi90", "mt_variated_deltaPhi90", output, "Dphi90")
output.Close()
def doCounters(datasetsEmb):
isCorrected = isinstance(datasetsEmb, result.DatasetsDYCorrection)
if isCorrected:
eventCounter = result.EventCounterDYCorrection(datasetsEmb,
counters=analysisEmb +
counters)
else:
scaleNormalization = analysisEmb != "signalAnalysis"
eventCounter = result.EventCounterMany(
datasetsEmb,
counters=analysisEmb + counters,
scaleNormalization=scaleNormalization)
# Add counts
sels = []
tdCount = treeDraw.clone(weight=weightBTagging)
tdCountMET = tdCount.clone(weight=weight,
selection="&&".join(sels + [metCut]))
tdCountBTagging = tdCount.clone(selection="&&".join(sels +
[metCut, bTaggingCut]))
tdCountDeltaPhi160 = tdCount.clone(
selection="&&".join(sels + [metCut, bTaggingCut, deltaPhi160Cut]))
tdCountDeltaPhi130 = tdCount.clone(
selection="&&".join(sels + [metCut, bTaggingCut, deltaPhi130Cut]))
tdCountDeltaPhi90 = tdCount.clone(
selection="&&".join(sels + [metCut, bTaggingCut, deltaPhi90Cut]))
eventCounter.mainCounterAppendRow(
"JetsForEffs", tdCount.clone(weight=weight, selection="&&".join(sels)))
eventCounter.mainCounterAppendRow("METForEffs", tdCountMET)
eventCounter.mainCounterAppendRow("BTagging", tdCountBTagging)
eventCounter.mainCounterAppendRow("DeltaPhi < 160", tdCountDeltaPhi160)
eventCounter.mainCounterAppendRow("DeltaPhi < 130", tdCountDeltaPhi130)
eventCounter.mainCounterAppendRow("DeltaPhi < 90", tdCountDeltaPhi90)
if not isCorrected:
td1 = tdCount.clone(selection=metCut + "&&" + bTaggingCut +
"&& (tecalometNoHF_p4.Pt() > 60)")
td2 = tdCount.clone(selection=metCut + "&&" + bTaggingCut +
"&& (tecalomet_p4.Pt() > 60)")
td3 = dataset.TreeDrawCompound(
td1, {
"SingleMu_Mu_170722-172619_Aug05": td2,
"SingleMu_Mu_172620-173198_Prompt": td2,
"SingleMu_Mu_173236-173692_Prompt": td2,
})
eventCounter.mainCounterAppendRow("BTagging+CaloMetNoHF", td1)
eventCounter.mainCounterAppendRow("BTagging+CaloMet", td2)
eventCounter.mainCounterAppendRow("BTagging+CaloMet(NoHF)", td3)
#(mainTable, mainTableChi2) = eventCounter.getMainCounterTableFit()
mainTable = eventCounter.getMainCounterTable()
ewkDatasets = ["WJets", "TTJets", "DYJetsToLL", "SingleTop", "Diboson"]
allDatasets = None
if "QCD_Pt20_MuEnriched" in datasetsEmb.getAllDatasetNames():
allDatasets = ["QCD_Pt20_MuEnriched"] + ewkDatasets
def ewkSum(table):
table.insertColumn(
1,
counter.sumColumn(
"EWKMCsum",
[table.getColumn(name=name) for name in ewkDatasets]))
if allDatasets != None:
table.insertColumn(
2,
counter.sumColumn(
"MCSum",
[table.getColumn(name=name) for name in allDatasets]))
ewkSum(mainTable)
cellFormat = counter.TableFormatText(
counter.CellFormatTeX(valueFormat='%.3f'))
#print mainTableChi2.format(cellFormat)
print mainTable.format(cellFormat)
tauTable = eventCounter.getSubCounterTable(
"TauIDPassedEvt::tauID_HPSTight")
ewkSum(tauTable)
print tauTable.format(cellFormat)
# Efficiencies
mainTable.keepOnlyRows([
"All events",
"Trigger and HLT_MET cut",
"taus == 1",
# "trigger scale factor",
"electron veto",
"muon veto",
"MET",
"njets",
"btagging",
"btagging scale factor",
"JetsForEffs",
"METForEffs",
"BTagging",
"DeltaPhi < 160",
"DeltaPhi < 130"
])
tauTable.keepOnlyRows([
"AllTauCandidates",
"DecayModeFinding",
"TauJetPt",
"TauJetEta",
"TauLdgTrackExists",
"TauLdgTrackPtCut",
"TauECALFiducialCutsCracksAndGap",
"TauAgainstElectronCut",
"TauAgainstMuonCut",
#"EMFractionCut",
"HPS",
"TauOneProngCut",
"TauRtauCut",
])
effFormat = counter.TableFormatText(
counter.CellFormatTeX(valueFormat='%.4f'))
#effFormat = counter.TableFormatConTeXtTABLE(counter.CellFormatTeX(valueFormat='%.4f'))
for name, table in [("Main", mainTable), ("Tau ID", tauTable)]:
effTable = counter.CounterTable()
col = table.getColumn(name="Data")
effTable.appendColumn(col)
effTable.appendColumn(
counter.efficiencyColumn(col.getName() + " eff", col))
col = table.getColumn(name="EWKMCsum")
effTable.appendColumn(col)
effTable.appendColumn(
counter.efficiencyColumn(col.getName() + " eff", col))
print "%s counter efficiencies" % name
print effTable.format(effFormat)
if isCorrected:
return
print "Trigger uncertainties"
bins = [40, 50, 60, 80]
tauPtPrototype = ROOT.TH1F("tauPtTrigger", "Tau pt",
len(bins) - 1, array.array("d", bins))
runs = [
"(160431 <= run && run <= 167913)",
"(170722 <= run && run <= 173198)",
"(173236 <= run && run <= 173692)",
#"(160431 <= run && run <= 173692)",
]
for name, td in [("BTagging", tdCountBTagging),
("DeltaPhi160", tdCountDeltaPhi160),
("DeltaPhi130", tdCountDeltaPhi130),
("DeltaPhi90", tdCountDeltaPhi90)]:
t = td.clone(varexp="tau_p4.Pt() >>tauPtTrigger")
NallSum = 0
NSum = 0
absUncSquareSum = 0
for runRegion in runs:
#neventsPlot = createPlot(dataset.treeDrawToNumEntries(t.clone(weight="weightTrigger")))
#uncertaintyPlot = createPlot(dataset.treeDrawToNumEntries(t.clone(weight="weightTriggerAbsUnc*weightTriggerAbsUnc/(weightTrigger*weightTrigger)")))
tmp = t.clone(selection=t.selection + "&&" + runRegion)
(th1all,
gr) = datasetsEmb.getHistogram("Data",
tmp.clone(weight="")) # Nall
(th1, gr) = datasetsEmb.getHistogram(
"Data", tmp.clone(weight="weightTrigger")) # Nevents
(th12, gr) = datasetsEmb.getHistogram(
"Data", tmp.clone(weight="weightTriggerAbsUnc")) # uncertainty
Nall = th1all.Integral(0, th1all.GetNbinsX() + 1)
N = th1.Integral(0, th1.GetNbinsX() + 1)
#absSum2 = th12.Integral(0, th12.GetNbinsX()+1)
#absUnc = math.sqrt(absSum2)
#absUnc = th12.Integral(0, 2)
NallSum += Nall
NSum += N
absUnc = tauEmbeddingPlot.squareSum(th12)
absUncSquareSum += absUnc
absUnc = math.sqrt(absUnc)
relUnc = 0
if N > 0:
relUnc = absUnc / N
print "%-15s for runs %s Nall = %.2f, N = %.2f, absolute uncertainty %.2f, relative uncertainty %.4f" % (
name, runRegion, Nall, N, absUnc, relUnc)
absUnc = math.sqrt(absUncSquareSum)
relUnc = absUnc / NSum
print "%-15s Nall = %.2f, N = %.2f, absolute uncertainty %.2f, relative uncertainty %.4f" % (
name, NallSum, NSum, absUnc, relUnc)
print
def doCounters(datasets, mcLumi=None):
createPlot = lambda name: createPlotCommon(name, datasets, mcLumi)
eventCounter = counter.EventCounter(datasets, counters=countersWeighted)
sels = [
# "(sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))) < 20)",
# "(20 < sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))))", "(sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))) < 80)",
# "(80 < sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))))", "(sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))) < 120)",
# "(120 < sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))))",
]
tdCount = treeDraw.clone(weight=weightBTagging)
tdCountMET = tdCount.clone(weight=weight,
selection="&&".join(sels + [metCut]))
tdCountBTagging = tdCount.clone(selection="&&".join(sels +
[metCut, bTaggingCut]))
tdCountDeltaPhi160 = tdCount.clone(
selection="&&".join(sels + [metCut, bTaggingCut, deltaPhi160Cut]))
tdCountDeltaPhi130 = tdCount.clone(
selection="&&".join(sels + [metCut, bTaggingCut, deltaPhi130Cut]))
tdCountDeltaPhi90 = tdCount.clone(
selection="&&".join(sels + [metCut, bTaggingCut, deltaPhi90Cut]))
# eventCounter.getMainCounter().appendRow("JetsForEffs", tdCount.clone(weight=weight, selection="&&".join(sels)))
# eventCounter.getMainCounter().appendRow("METForEffs", tdCountMET)
# eventCounter.getMainCounter().appendRow("BTagging", tdCountBTagging)
# eventCounter.getMainCounter().appendRow("DeltaPhi < 160", tdCountDeltaPhi160)
# eventCounter.getMainCounter().appendRow("DeltaPhi < 130", tdCountDeltaPhi130)
# eventCounter.getMainCounter().appendRow("DeltaPhi < 90", tdCountDeltaPhi90)
td1 = tdCount.clone(selection=metCut + "&&" + bTaggingCut +
"&& (tecalometNoHF_p4.Pt() > 60)")
td2 = tdCount.clone(selection=metCut + "&&" + bTaggingCut +
"&& (tecalomet_p4.Pt() > 60)")
td3 = dataset.TreeDrawCompound(
td1, {
"SingleMu_Mu_170722-172619_Aug05": td2,
"SingleMu_Mu_172620-173198_Prompt": td2,
"SingleMu_Mu_173236-173692_Prompt": td2,
})
# eventCounter.getMainCounter().appendRow("BTagging+CaloMetNoHF", td1)
# eventCounter.getMainCounter().appendRow("BTagging+CaloMet", td2)
# eventCounter.getMainCounter().appendRow("BTagging+CaloMet(NoHF)", td3)
if mcLumi != None:
eventCounter.normalizeMCToLuminosity(mcLumi)
else:
eventCounter.normalizeMCByLuminosity()
tauEmbedding.scaleNormalization(eventCounter)
ewkDatasets = ["WJets", "TTJets", "DYJetsToLL", "SingleTop", "Diboson"]
table = eventCounter.getMainCounterTable()
mainTable = table
#muonAnalysis.addSumColumn(table)
#mainTable.insertColumn(2, counter.sumColumn("EWKMCsum", [mainTable.getColumn(name=name) for name in ewkDatasets]))
#muonAnalysis.addDataMcRatioColumn(table)
if datasets.hasDataset("EWKSignal"):
mainTable.insertColumn(
7,
counter.divideColumn(
"SignalFraction",
mainTable.getColumn(name="TTToHplus_" + keepSignal),
mainTable.getColumn(name="EWKSignal")))
datasets.printInfo()
print "============================================================"
print "Main counter (%s)" % eventCounter.getNormalizationString()
cellFormat = counter.TableFormatText(
counter.CellFormatTeX(valueFormat='%.3f'))
print table.format(cellFormat)
tauTable = eventCounter.getSubCounterTable(
"TauIDPassedEvt::TauSelection_HPS")
#muonAnalysis.addSumColumn(tauTable)
tauTable.insertColumn(
2,
counter.sumColumn(
"EWKMCsum",
[tauTable.getColumn(name=name) for name in ewkDatasets]))
print tauTable.format(cellFormat)
# print eventCounter.getSubCounterTable("TauIDPassedJets::tauID_HPSTight").format()
# table = eventCounter.getSubCounterTable("Trigger")
# muonAnalysis.addSumColumn(table)
# print table.format(cellFormat)
mainTable.keepOnlyRows([
"All events",
"Trigger and HLT_MET cut",
"taus == 1",
# "trigger scale factor",
"electron veto",
"muon veto",
"MET",
"njets",
"btagging",
"btagging scale factor",
"JetsForEffs",
"METForEffs",
"BTagging",
"DeltaPhi < 160",
"DeltaPhi < 130"
])
tauTable.keepOnlyRows([
"AllTauCandidates",
"DecayModeFinding",
"TauJetPt",
"TauJetEta",
"TauLdgTrackExists",
"TauLdgTrackPtCut",
"TauECALFiducialCutsCracksAndGap",
"TauAgainstElectronCut",
"TauAgainstMuonCut",
#"EMFractionCut",
"HPS",
"TauOneProngCut",
"TauRtauCut",
])
#effFormat = counter.TableFormatText(counter.CellFormatText(valueFormat='%.4f'))
effFormat = counter.TableFormatText(
counter.CellFormatTeX(valueFormat='%.4f'))
#effFormat = counter.TableFormatConTeXtTABLE(counter.CellFormatTeX(valueFormat='%.4f'))
for name, table in [("Main", mainTable), ("Tau ID", tauTable)]:
effTable = counter.CounterTable()
col = table.getColumn(name="Data")
effTable.appendColumn(col)
effTable.appendColumn(
counter.efficiencyColumn(col.getName() + " eff", col))
col = table.getColumn(name="EWKMCsum")
effTable.appendColumn(col)
effTable.appendColumn(
counter.efficiencyColumn(col.getName() + " eff", col))
print "%s counter efficiencies" % name
print effTable.format(effFormat)
print "Trigger uncertainties"
bins = [40, 50, 60, 80]
tauPtPrototype = ROOT.TH1F("tauPtTrigger", "Tau pt",
len(bins) - 1, array.array("d", bins))
runs = [
"(160431 <= run && run <= 167913)",
"(170722 <= run && run <= 173198)",
"(173236 <= run && run <= 173692)",
#"(160431 <= run && run <= 173692)",
]
for name, td in [("BTagging", tdCountBTagging),
("DeltaPhi160", tdCountDeltaPhi160),
("DeltaPhi130", tdCountDeltaPhi130),
("DeltaPhi90", tdCountDeltaPhi90)]:
t = td.clone(varexp="tau_p4.Pt() >>tauPtTrigger")
NallSum = 0
NSum = 0
absUncSquareSum = 0
for runRegion in runs:
#neventsPlot = createPlot(dataset.treeDrawToNumEntries(t.clone(weight="weightTrigger")))
#uncertaintyPlot = createPlot(dataset.treeDrawToNumEntries(t.clone(weight="weightTriggerAbsUnc*weightTriggerAbsUnc/(weightTrigger*weightTrigger)")))
tmp = t.clone(selection=t.selection + "&&" + runRegion)
nallPlot = createPlot(tmp.clone(weight=""))
neventsPlot = createPlot(tmp.clone(weight="weightTrigger"))
uncertaintyPlot = createPlot(
tmp.clone(weight="weightTriggerAbsUnc"))
th1all = nallPlot.histoMgr.getHisto("Data").getRootHisto()
th1 = neventsPlot.histoMgr.getHisto("Data").getRootHisto()
th12 = uncertaintyPlot.histoMgr.getHisto("Data").getRootHisto()
Nall = th1all.Integral(0, th1all.GetNbinsX() + 1)
N = th1.Integral(0, th1.GetNbinsX() + 1)
#absSum2 = th12.Integral(0, th12.GetNbinsX()+1)
#absUnc = math.sqrt(absSum2)
#absUnc = th12.Integral(0, 2)
NallSum += Nall
NSum += N
absUnc = tauEmbedding.squareSum(th12)
absUncSquareSum += absUnc
absUnc = math.sqrt(absUnc)
relUnc = 0
if N > 0:
relUnc = absUnc / N
print "%-15s for runs %s Nall = %.2f, N = %.2f, absolute uncertainty %.2f, relative uncertainty %.4f" % (
name, runRegion, Nall, N, absUnc, relUnc)
absUnc = math.sqrt(absUncSquareSum)
relUnc = absUnc / NSum
print "%-15s Nall = %.2f, N = %.2f, absolute uncertainty %.2f, relative uncertainty %.4f" % (
name, NallSum, NSum, absUnc, relUnc)
print
def doCounters(datasetsEmb2, datasetsSig2, datasetName):
lumi = datasetsEmb2.getDataset("Data").getLuminosity()
datasetsEmb = datasetsEmb2.deepCopy()
datasetsSig = datasetsSig2.deepCopy()
datasetsEmb.remove(filter(lambda name: name != datasetName, datasetsEmb.getAllDatasetNames()))
datasetsSig.remove(filter(lambda name: name != datasetName, datasetsSig.getAllDatasetNames()))
# Counters
eventCounterEmb = counter.EventCounter(datasetsEmb, counters=analysisEmb+"Counters")
eventCounterSig = counter.EventCounter(datasetsSig, counters=analysisSig+"Counters")
eventCounterEmb.normalizeMCToLuminosity(lumi)
eventCounterSig.normalizeMCToLuminosity(lumi)
#effFormat = counter.TableFormatText(counter.CellFormatText(valueFormat='%.4f'))
#effFormat = counter.TableFormatConTeXtTABLE(counter.CellFormatTeX(valueFormat='%.4f'))
effFormat = counter.TableFormatText(counter.CellFormatTeX(valueFormat='%.4f'))
counterEmb = eventCounterEmb.getMainCounter()
counterSig = eventCounterSig.getMainCounter()
treeDraw = dataset.TreeDraw("dummy")
tdEmb = treeDraw.clone(tree=analysisEmb+"/tree")
tdSig = treeDraw.clone(tree=analysisSig+"/tree")
selectionsCumulative = []
tauSelectionsCumulative = []
def sel(name, selection):
selectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
sel = "&&".join(sel)
counterEmb.appendRow(name, tdEmb.clone(selection=sel))
counterSig.appendRow(name, tdSig.clone(selection=sel))
def tauSel(name, selection):
tauSelectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
sel = "&&".join(sel)
counterEmb.appendRow(name, tdEmb.clone(selection=sel))
counterSig.appendRow(name, tdSig.clone(selection=sel))
# sel("Primary vertex", tauPlot.pvSelection)
sel(">= 1 tau candidate", "Length$(taus_p4) >= 1")
tauSel("Decay mode finding", tauPlot.decayModeFinding)
tauSel("pT > 15", "(taus_p4.Pt() > 15)")
tauSel("pT > 40", tauPlot.tauPtCut)
tauSel("eta < 2.1", tauPlot.tauEtaCut)
tauSel("leading track pT > 20", tauPlot.tauLeadPt)
tauSel("ECAL fiducial", tauPlot.ecalFiducial)
tauSel("againstElectron", tauPlot.electronRejection)
tauSel("againstMuon", tauPlot.muonRejection)
tauSel("isolation", tauPlot.tightIsolation)
tauSel("oneProng", tauPlot.oneProng)
tauSel("Rtau", tauPlot.rtau)
sel("3 jets", tauPlot.jetEventSelection)
sel("MET", tauPlot.metSelection)
sel("btag", tauPlot.btagEventSelection)
table = counter.CounterTable()
col = counterEmb.getTable().getColumn(name=datasetName)
col.setName("Embedded")
table.appendColumn(col)
col = counterSig.getTable().getColumn(name=datasetName)
col.setName("Normal")
table.appendColumn(col)
col = table.getColumn(name="Embedded")
table.insertColumn(1, counter.efficiencyColumn(col.getName()+" eff", col))
col = table.getColumn(name="Normal")
table.appendColumn(counter.efficiencyColumn(col.getName()+" eff", col))
print "%s counters" % datasetName
print table.format(effFormat)
def main():
datasets = dataset.getDatasetsFromMulticrabCfg(counters=baseline +
"Counters",
weightedCounters=False)
datasets.remove([
# "SingleMu_Mu_160431-163261_May10",
# "SingleMu_Mu_163270-163869_May10",
# "SingleMu_Mu_165088-166150_Prompt",
# "SingleMu_Mu_166161-166164_Prompt",
# "SingleMu_Mu_166346-166346_Prompt",
# "SingleMu_Mu_166374-167043_Prompt",
# "SingleMu_Mu_167078-167913_Prompt",
# "SingleMu_Mu_170722-172619_Aug05",
# "SingleMu_Mu_172620-173198_Prompt",
# "SingleMu_Mu_173236-173692_Prompt",
])
datasets.loadLuminosities()
plots.mergeRenameReorderForDataMC(datasets)
values = {}
analyses = [("Baseline", baseline), ("Plus", plus), ("Minus", minus)]
mainTable = counter.CounterTable()
tauTable = counter.CounterTable()
cntr = "Counters"
if normalize:
cntr += "/weighted"
for name, analysis in analyses:
eventCounter = counter.EventCounter(datasets, counters=analysis + cntr)
eventCounter.normalizeMCByLuminosity()
if normalize:
tauEmbedding.scaleNormalization(eventCounter)
col = eventCounter.getMainCounterTable().getColumn(name="Data")
col.setName(name)
mainTable.appendColumn(col)
effcol = counter.efficiencyColumn(col.getName() + " eff", col)
mainTable.appendColumn(effcol)
values[name + "Main"] = effcol
value = col.getCount(col.getRowNames().index(count)).value()
values[name] = value
col = eventCounter.getSubCounterTable(
"TauIDPassedEvt::tauID_HPSTight").getColumn(name="Data")
col.setName(name)
tauTable.appendColumn(col)
effcol = counter.efficiencyColumn(col.getName() + " eff", col)
tauTable.appendColumn(effcol)
values[name + "Tau"] = effcol
mainTable.appendColumn(
counter.divideColumn("Plus eff/Baseline", values["PlusMain"],
values["BaselineMain"]))
mainTable.appendColumn(
counter.divideColumn("Minus eff/Baseline", values["MinusMain"],
values["BaselineMain"]))
tauTable.appendColumn(
counter.divideColumn("Plus eff/Baseline", values["PlusTau"],
values["BaselineTau"]))
tauTable.appendColumn(
counter.divideColumn("Minus eff/Baseline", values["MinusTau"],
values["BaselineTau"]))
print mainTable.format()
print tauTable.format()
plusDiff = abs(values["Baseline"] - values["Plus"])
minusDiff = abs(values["Baseline"] - values["Minus"])
maxDiff = max(plusDiff, minusDiff)
rel = maxDiff / values["Baseline"]
print "Count %s, baseline %.3f, plus %.3f, minus %.3f" % (
count, values["Baseline"], values["Plus"], values["Minus"])
print "Plus diff %.3f, minus diff %.3f" % (plusDiff, minusDiff)
print "Relative uncertainty from tau energy scale %.6f" % (rel)
style = tdrstyle.TDRStyle()
histograms.createLegend.moveDefaults(dx=-0.32, dh=-0.15)
metCut = "(met_p4.Et() > 50)"
bTaggingCut = "passedBTagging"
tdMt = dataset.TreeDraw(
"dummy",
weight="weightPileup*weightTrigger*weightBTagging",
selection=metCut + "&&" + bTaggingCut,
varexp=
"sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))) >>tmp(40,0,400)"
)
output = ROOT.TFile.Open("mt_variated_ewk.root", "RECREATE")
#doPlot(datasets, analyses, tdMt, "mt_variated")
doPlot(datasets, analyses, "transverseMass", "mt_variated_btagging",
output, "Dphi180")
doPlot(datasets, analyses, "transverseMassAfterDeltaPhi160",
"mt_variated_deltaPhi160", output, "Dphi160")
doPlot(datasets, analyses, "transverseMassAfterDeltaPhi130",
"mt_variated_deltaPhi130", output, "Dphi130")
doPlot(datasets, analyses, "transverseMassAfterDeltaPhi90",
"mt_variated_deltaPhi90", output, "Dphi90")
output.Close()
def doCounters(datasets, mcLumi=None):
createPlot = lambda name: createPlotCommon(name, datasets, mcLumi)
eventCounter = counter.EventCounter(datasets, counters=countersWeighted)
sels = [
# "(sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))) < 20)",
# "(20 < sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))))", "(sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))) < 80)",
# "(80 < sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))))", "(sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))) < 120)",
# "(120 < sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi()))))",
]
tdCount = treeDraw.clone(weight=weightBTagging)
tdCountMET = tdCount.clone(weight=weight, selection="&&".join(sels+[metCut]))
tdCountBTagging = tdCount.clone(selection="&&".join(sels+[metCut, bTaggingCut]))
tdCountDeltaPhi160 = tdCount.clone(selection="&&".join(sels+[metCut, bTaggingCut, deltaPhi160Cut]))
tdCountDeltaPhi130 = tdCount.clone(selection="&&".join(sels+[metCut, bTaggingCut, deltaPhi130Cut]))
tdCountDeltaPhi90 = tdCount.clone(selection="&&".join(sels+[metCut, bTaggingCut, deltaPhi90Cut]))
eventCounter.getMainCounter().appendRow("JetsForEffs", tdCount.clone(weight=weight, selection="&&".join(sels)))
eventCounter.getMainCounter().appendRow("METForEffs", tdCountMET)
eventCounter.getMainCounter().appendRow("BTagging", tdCountBTagging)
eventCounter.getMainCounter().appendRow("DeltaPhi < 160", tdCountDeltaPhi160)
eventCounter.getMainCounter().appendRow("DeltaPhi < 130", tdCountDeltaPhi130)
eventCounter.getMainCounter().appendRow("DeltaPhi < 90", tdCountDeltaPhi90)
td1 = tdCount.clone(selection=metCut+"&&"+bTaggingCut+"&& (tecalometNoHF_p4.Pt() > 60)")
td2 = tdCount.clone(selection=metCut+"&&"+bTaggingCut+"&& (tecalomet_p4.Pt() > 60)")
td3 = dataset.TreeDrawCompound(td1, {
"SingleMu_Mu_170722-172619_Aug05": td2,
"SingleMu_Mu_172620-173198_Prompt": td2,
"SingleMu_Mu_173236-173692_Prompt": td2,
})
eventCounter.getMainCounter().appendRow("BTagging+CaloMetNoHF", td1)
eventCounter.getMainCounter().appendRow("BTagging+CaloMet", td2)
eventCounter.getMainCounter().appendRow("BTagging+CaloMet(NoHF)", td3)
if mcLumi != None:
eventCounter.normalizeMCToLuminosity(mcLumi)
else:
eventCounter.normalizeMCByLuminosity()
tauEmbedding.scaleNormalization(eventCounter)
ewkDatasets = [
"WJets", "TTJets",
"DYJetsToLL", "SingleTop", "Diboson"
]
table = eventCounter.getMainCounterTable()
mainTable = table
muonAnalysis.addSumColumn(table)
mainTable.insertColumn(2, counter.sumColumn("EWKMCsum", [mainTable.getColumn(name=name) for name in ewkDatasets]))
# table = eventCounter.getSubCounterTable("Trigger")
# muonAnalysis.reorderCounterTable(table)
muonAnalysis.addDataMcRatioColumn(table)
if datasets.hasDataset("EWKSignal"):
mainTable.insertColumn(7, counter.divideColumn("SignalFraction", mainTable.getColumn(name="TTToHplus_"+keepSignal), mainTable.getColumn(name="EWKSignal")))
datasets.printInfo()
print "============================================================"
print "Main counter (%s)" % eventCounter.getNormalizationString()
cellFormat = counter.TableFormatText(counter.CellFormatTeX(valueFormat='%.3f'))
print table.format(cellFormat)
tauTable = eventCounter.getSubCounterTable("TauIDPassedEvt::tauID_HPSTight")
#muonAnalysis.addSumColumn(tauTable)
tauTable.insertColumn(2, counter.sumColumn("EWKMCsum", [tauTable.getColumn(name=name) for name in ewkDatasets]))
print tauTable.format(cellFormat)
# print eventCounter.getSubCounterTable("TauIDPassedJets::tauID_HPSTight").format()
# table = eventCounter.getSubCounterTable("Trigger")
# muonAnalysis.addSumColumn(table)
# print table.format(cellFormat)
mainTable.keepOnlyRows([
"All events",
"Trigger and HLT_MET cut",
"taus == 1",
# "trigger scale factor",
"electron veto",
"muon veto",
"MET",
"njets",
"btagging",
"btagging scale factor",
"JetsForEffs",
"METForEffs",
"BTagging",
"DeltaPhi < 160",
"DeltaPhi < 130"
])
tauTable.keepOnlyRows([
"AllTauCandidates",
"DecayModeFinding",
"TauJetPt",
"TauJetEta",
"TauLdgTrackExists",
"TauLdgTrackPtCut",
"TauECALFiducialCutsCracksAndGap",
"TauAgainstElectronCut",
"TauAgainstMuonCut",
#"EMFractionCut",
"HPS",
"TauOneProngCut",
"TauRtauCut",
])
#effFormat = counter.TableFormatText(counter.CellFormatText(valueFormat='%.4f'))
effFormat = counter.TableFormatText(counter.CellFormatTeX(valueFormat='%.4f'))
#effFormat = counter.TableFormatConTeXtTABLE(counter.CellFormatTeX(valueFormat='%.4f'))
for name, table in [("Main", mainTable), ("Tau ID", tauTable)]:
effTable = counter.CounterTable()
col = table.getColumn(name="Data")
effTable.appendColumn(col)
effTable.appendColumn(counter.efficiencyColumn(col.getName()+" eff", col))
col = table.getColumn(name="EWKMCsum")
effTable.appendColumn(col)
effTable.appendColumn(counter.efficiencyColumn(col.getName()+" eff", col))
print "%s counter efficiencies" % name
print effTable.format(effFormat)
print "Trigger uncertainties"
bins = [40, 50, 60, 80]
tauPtPrototype = ROOT.TH1F("tauPtTrigger", "Tau pt", len(bins)-1, array.array("d", bins))
runs = [
"(160431 <= run && run <= 167913)",
"(170722 <= run && run <= 173198)",
"(173236 <= run && run <= 173692)",
#"(160431 <= run && run <= 173692)",
]
for name, td in [
("BTagging", tdCountBTagging),
("DeltaPhi160", tdCountDeltaPhi160),
("DeltaPhi130", tdCountDeltaPhi130),
("DeltaPhi90", tdCountDeltaPhi90)
]:
t = td.clone(varexp="tau_p4.Pt() >>tauPtTrigger")
NallSum = 0
NSum = 0
absUncSquareSum = 0
for runRegion in runs:
#neventsPlot = createPlot(dataset.treeDrawToNumEntries(t.clone(weight="weightTrigger")))
#uncertaintyPlot = createPlot(dataset.treeDrawToNumEntries(t.clone(weight="weightTriggerAbsUnc*weightTriggerAbsUnc/(weightTrigger*weightTrigger)")))
tmp = t.clone(selection=t.selection+"&&"+runRegion)
nallPlot = createPlot(tmp.clone(weight=""))
neventsPlot = createPlot(tmp.clone(weight="weightTrigger"))
uncertaintyPlot = createPlot(tmp.clone(weight="weightTriggerAbsUnc"))
th1all = nallPlot.histoMgr.getHisto("Data").getRootHisto()
th1 = neventsPlot.histoMgr.getHisto("Data").getRootHisto()
th12 = uncertaintyPlot.histoMgr.getHisto("Data").getRootHisto()
Nall = th1all.Integral(0, th1all.GetNbinsX()+1)
N = th1.Integral(0, th1.GetNbinsX()+1)
#absSum2 = th12.Integral(0, th12.GetNbinsX()+1)
#absUnc = math.sqrt(absSum2)
#absUnc = th12.Integral(0, 2)
NallSum += Nall
NSum += N
absUnc = squareSum(th12)
absUncSquareSum += absUnc
absUnc = math.sqrt(absUnc)
relUnc = 0
if N > 0:
relUnc = absUnc/N
print "%-15s for runs %s Nall = %.2f, N = %.2f, absolute uncertainty %.2f, relative uncertainty %.4f" % (name, runRegion, Nall, N, absUnc, relUnc)
absUnc = math.sqrt(absUncSquareSum)
relUnc = absUnc/NSum
print "%-15s Nall = %.2f, N = %.2f, absolute uncertainty %.2f, relative uncertainty %.4f" % (name, NallSum, NSum, absUnc, relUnc)
print
def doCounters(datasetsEmb, datasetsSig, datasetName, normalizeEmb=True):
lumi = datasetsEmb.getLuminosity()
# Counters
eventCounterEmb = tauEmbedding.EventCounterMany(
datasetsEmb,
normalize=normalizeEmb) #, counters=analysisEmb+"/counters")
eventCounterSig = counter.EventCounter(datasetsSig)
def isNotThis(name):
return name != datasetName
eventCounterEmb.removeColumns(
filter(isNotThis, datasetsEmb.getAllDatasetNames()))
eventCounterSig.removeColumns(
filter(isNotThis, datasetsSig.getAllDatasetNames()))
eventCounterSig.normalizeMCToLuminosity(lumi)
tdCount = dataset.TreeDraw("dummy",
weight=tauEmbedding.signalNtuple.weightBTagging)
tdCountMET = tdCount.clone(weight=tauEmbedding.signalNtuple.weight,
selection=tauEmbedding.signalNtuple.metCut)
tdCountBTagging = tdCount.clone(
selection=And(tauEmbedding.signalNtuple.metCut,
tauEmbedding.signalNtuple.bTaggingCut))
tdCountDeltaPhi160 = tdCount.clone(selection=And(
tauEmbedding.signalNtuple.metCut, tauEmbedding.signalNtuple.
bTaggingCut, tauEmbedding.signalNtuple.deltaPhi160Cut))
tdCountDeltaPhi130 = tdCount.clone(selection=And(
tauEmbedding.signalNtuple.metCut, tauEmbedding.signalNtuple.
bTaggingCut, tauEmbedding.signalNtuple.deltaPhi130Cut))
def addRow(name, td):
tdEmb = td.clone(tree=analysisEmb + "/tree")
tdSig = td.clone(tree=analysisSig + "/tree")
eventCounterEmb.mainCounterAppendRow(name, tdEmb)
eventCounterSig.getMainCounter().appendRow(name, tdSig)
# addRow("JetsForEffs", tdCount.clone(weight=tauEmbedding.signalNtuple.weight))
# addRow("METForEffs", tdCountMET)
# addRow("BTagging (SF)", tdCountBTagging)
# addRow("DeltaPhi < 160", tdCountDeltaPhi160)
# addRow("BTagging (SF) again", tdCountBTagging)
# addRow("DeltaPhi < 130", tdCountDeltaPhi130)
table = counter.CounterTable()
col = eventCounterEmb.getMainCounterTable().getColumn(name=datasetName)
col.setName("Embedded")
table.appendColumn(col)
col = eventCounterSig.getMainCounterTable().getColumn(name=datasetName)
col.setName("Normal")
table.appendColumn(col)
tableTau = counter.CounterTable()
tmp = "TauIDPassedEvt::TauSelection_HPS"
col = eventCounterEmb.getSubCounterTable(tmp).getColumn(name=datasetName)
col.setName("Embedded")
tableTau.appendColumn(col)
col = eventCounterSig.getSubCounterTable(tmp).getColumn(name=datasetName)
col.setName("Normal")
tableTau.appendColumn(col)
postfix = ""
if not normalizeEmb:
postfix = "_notEmbNormalized"
fname = "counters_selections_%s%s.txt" % (datasetName, postfix)
f = open(fname, "w")
f.write(table.format())
f.write("\n")
f.write(tableTau.format())
f.close()
print "Printed selection counters to", fname
if not normalizeEmb:
return
# Calculate efficiencies
table.keepOnlyRows([
"njets", "MET", "btagging", "btagging scale factor",
"DeltaPhi(Tau,MET) upper limit"
])
# btag SF efficiency w.r.t. MET
row = table.getRow(name="MET")
row.setName("METForEff")
table.insertRow(3, row)
tableEff = counter.CounterTable()
tableEff.appendColumn(
counter.efficiencyColumn("Embedded eff",
table.getColumn(name="Embedded")))
tableEff.appendColumn(
counter.efficiencyColumn("Normal eff", table.getColumn(name="Normal")))
tableEff.removeRow(name="METForEff")
effFormat = counter.TableFormatText(
counter.CellFormatTeX(valueFormat='%.4f', withPrecision=2))
# print table.format(effFormat)
fname = "counters_selections_%s_eff.txt" % datasetName
f = open(fname, "w")
f.write(tableEff.format(effFormat))
f.close()
print "Printed selection efficiencies to", fname
def doCounters(datasetsEmb, datasetsSig, datasetName):
lumi = datasetsEmb.getLuminosity()
treeDraw = dataset.TreeDraw("dummy", weight=weight)
# Counters
eventCounterEmb = tauEmbedding.EventCounterMany(datasetsEmb, counters=analysisEmb+"Counters")
eventCounterSig = counter.EventCounter(datasetsSig, counters=analysisSig+"Counters")
def isNotThis(name):
return name != datasetName
eventCounterEmb.removeColumns(filter(isNotThis, datasetsEmb.getAllDatasetNames()))
eventCounterSig.removeColumns(filter(isNotThis, datasetsSig.getAllDatasetNames()))
eventCounterSig.normalizeMCToLuminosity(lumi)
#effFormat = counter.TableFormatText(counter.CellFormatText(valueFormat='%.4f'))
#effFormat = counter.TableFormatConTeXtTABLE(counter.CellFormatTeX(valueFormat='%.4f'))
effFormat = counter.TableFormatText(counter.CellFormatTeX(valueFormat='%.4f'))
tdEmb = treeDraw.clone(tree=analysisEmb+"/tree")
tdSig = treeDraw.clone(tree=analysisSig+"/tree")
selectionsCumulative = []
tauSelectionsCumulative = []
def sel(name, selection):
selectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
sel = "&&".join(sel)
eventCounterEmb.mainCounterAppendRow(name, tdEmb.clone(selection=sel))
eventCounterSig.getMainCounter().appendRow(name, tdSig.clone(selection=sel))
def tauSel(name, selection):
tauSelectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
sel = "&&".join(sel)
eventCounterEmb.mainCounterAppendRow(name, tdEmb.clone(selection=sel))
eventCounterSig.getMainCounter().appendRow(name, tdSig.clone(selection=sel))
# sel("Primary vertex", tauEmbedding.tauNtuple.pvSelection)
sel(">= 1 tau candidate", "Length$(taus_p4) >= 1")
tauSel("Decay mode finding", tauEmbedding.tauNtuple.decayModeFinding)
tauSel("pT > 15", tauEmbedding.tauNtuple.tauPtPreCut)
tauSel("pT > 40", tauEmbedding.tauNtuple.tauPtCut)
tauSel("eta < 2.1", tauEmbedding.tauNtuple.tauEtaCut)
tauSel("leading track pT > 20", tauEmbedding.tauNtuple.tauLeadPt)
tauSel("ECAL fiducial", tauEmbedding.tauNtuple.ecalFiducial)
tauSel("againstElectron", tauEmbedding.tauNtuple.electronRejection)
tauSel("againstMuon", tauEmbedding.tauNtuple.muonRejection)
tauSel("isolation", tauEmbedding.tauNtuple.tightIsolation)
tauSel("oneProng", tauEmbedding.tauNtuple.oneProng)
tauSel("Rtau", tauEmbedding.tauNtuple.rtau)
sel("3 jets", tauEmbedding.tauNtuple.jetEventSelection)
sel("MET", tauEmbedding.tauNtuple.metSelection)
sel("btag", tauEmbedding.tauNtuple.btagEventSelection)
table = counter.CounterTable()
col = eventCounterEmb.getMainCounterTable().getColumn(name=datasetName)
col.setName("Embedded")
table.appendColumn(col)
col = eventCounterSig.getMainCounterTable().getColumn(name=datasetName)
col.setName("Normal")
table.appendColumn(col)
col = table.getColumn(name="Embedded")
table.insertColumn(1, counter.efficiencyColumn(col.getName()+" eff", col))
col = table.getColumn(name="Normal")
table.appendColumn(counter.efficiencyColumn(col.getName()+" eff", col))
print "%s counters" % datasetName
print table.format(effFormat)
f = open("counters_"+datasetName+".txt", "w")
f.write(table.format(effFormat))
f.write("\n")
f.close()
def doCounters(datasets):
# Counters
eventCounter = counter.EventCounter(datasets, counters=counters)
mainCounter = eventCounter.getMainCounter()
selectionsCumulative = []
tauSelectionsCumulative = []
td = treeDraw.clone(weight="")
def sel(name, selection):
selectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
mainCounter.appendRow(name, td.clone(selection="&&".join(sel)))
def tauSel(name, selection):
tauSelectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
mainCounter.appendRow(name, td.clone(selection="&&".join(sel)))
sel("Primary vertex", pvSelection)
sel(">= 1 tau candidate", "Length$(taus_p4) >= 1")
tauSel("Decay mode finding", decayModeFinding)
tauSel("pT > 15", "(taus_p4.Pt() > 15)")
tauSel("pT > 40", tauPtCut) #
tauSel("eta < 2.1", tauEtaCut)
tauSel("leading track pT > 20", tauLeadPt)
tauSel("ECAL fiducial", ecalFiducial)
tauSel("againstElectron", electronRejection) #
tauSel("againstMuon", muonRejection)
tauSel("isolation", tightIsolation) #
tauSel("oneProng", oneProng) #
tauSel("Rtau", rtau) #
sel("3 jets", jetEventSelection)
sel("MET", metSelection)
sel("btag", btagEventSelection)
sel("deltaPhi<160", deltaPhi160Selection)
fullSelection = "&&".join(
selectionsCumulative +
["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)])
fullSelectionCaloMetNoHF = fullSelection + "&&" + caloMetNoHF
fullSelectionCaloMet = fullSelection + "&&" + caloMet
#print fullSelection
f = open("pickEvents.txt", "w")
def printPickEvent(tree):
f.write("%d:%d:%d\n" % (tree.run, tree.lumi, tree.event))
ts = dataset.TreeScan(td.tree,
function=printPickEvent,
selection=fullSelection)
ts2 = dataset.TreeScan(td.tree,
function=printPickEvent,
selection=fullSelectionCaloMetNoHF)
ts3 = dataset.TreeScan(td.tree,
function=printPickEvent,
selection=fullSelectionCaloMet)
ts4 = dataset.TreeDrawCompound(
ts2, {
"SingleMu_Mu_170722-172619_Aug05": ts3,
"SingleMu_Mu_172620-173198_Prompt": ts3,
"SingleMu_Mu_173236-173692_Prompt": ts3,
})
datasets.getDataset("Data").getDatasetRootHisto(ts4)
f.close()
ewkDatasets = [
"WJets",
"TTJets",
# "DYJetsToLL", "SingleTop", "Diboson"
]
eventCounter.normalizeMCByLuminosity()
mainTable = eventCounter.getMainCounterTable()
#mainTable.insertColumn(2, counter.sumColumn("EWKMCsum", [mainTable.getColumn(name=name) for name in ewkDatasets]))
cellFormat = counter.TableFormatText(
counter.CellFormatText(valueFormat='%.3f',
#valueOnly=True
),
# columnSeparator = ";",
)
print mainTable.format(cellFormat)
return
effFormat = counter.TableFormatText(
counter.CellFormatTeX(valueFormat='%.4f'))
effTable = counter.CounterTable()
col = table.getColumn(name="Data")
effTable.appendColumn(col)
effTable.appendColumn(counter.efficiencyColumn(col.getName() + " eff",
col))
col = table.getColumn(name="EWKMCsum")
effTable.appendColumn(col)
effTable.appendColumn(counter.efficiencyColumn(col.getName() + " eff",
col))
print effTable.format(effFormat)
def doTauCounters(datasetsEmb, datasetsSig, datasetName):
lumi = datasetsEmb.getLuminosity()
treeDraw = dataset.TreeDraw("dummy", weight=tauEmbedding.tauNtuple.weight[tauEmbedding.era])
eventCounterEmb = tauEmbedding.EventCounterMany(datasetsEmb)
eventCounterSig = counter.EventCounter(datasetsSig)
def isNotThis(name):
return name != datasetName
eventCounterEmb.removeColumns(filter(isNotThis, datasetsEmb.getAllDatasetNames()))
eventCounterSig.removeColumns(filter(isNotThis, datasetsSig.getAllDatasetNames()))
eventCounterSig.normalizeMCToLuminosity(lumi)
effFormat = counter.TableFormatLaTeX(counter.CellFormatTeX(valueFormat="%.4f", withPrecision=2))
tdEmb = treeDraw.clone(tree=tauAnalysisEmb+"/tree")
tdSig = treeDraw.clone(tree=tauAnalysisSig+"/tree")
selectionsCumulative = []
tauSelectionsCumulative = []
rowNames = []
def sel(name, selection):
selectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
sel = "&&".join(sel)
eventCounterEmb.mainCounterAppendRow(name, tdEmb.clone(selection=sel))
eventCounterSig.getMainCounter().appendRow(name, tdSig.clone(selection=sel))
rowNames.append(name)
def tauSel(name, selection):
tauSelectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
sel = "&&".join(sel)
eventCounterEmb.mainCounterAppendRow(name, tdEmb.clone(selection=sel))
eventCounterSig.getMainCounter().appendRow(name, tdSig.clone(selection=sel))
rowNames.append(name)
sel(">= 1 tau candidate", "Length$(taus_p4) >= 1")
tauSel("Decay mode finding", tauEmbedding.tauNtuple.decayModeFinding)
tauSel("pT > 15", "taus_p4.Pt() > 15")
tauSel("pT > 40", tauEmbedding.tauNtuple.tauPtCut)
tauSel("eta < 2.1", tauEmbedding.tauNtuple.tauEtaCut)
tauSel("leading track pT > 20", tauEmbedding.tauNtuple.tauLeadPt)
tauSel("ECAL fiducial", tauEmbedding.tauNtuple.ecalFiducial)
tauSel("againstElectron", tauEmbedding.tauNtuple.electronRejection)
tauSel("againstMuon", tauEmbedding.tauNtuple.muonRejection)
tauSel("isolation", tauEmbedding.tauNtuple.tightIsolation)
tauSel("oneProng", tauEmbedding.tauNtuple.oneProng)
tauSel("Rtau", tauEmbedding.tauNtuple.rtau)
sel("MET", tauEmbedding.tauNtuple.metSelection)
table = counter.CounterTable()
col = eventCounterEmb.getMainCounterTable().getColumn(name=datasetName)
table.appendColumn(counter.efficiencyColumn("Embedded eff", col))
col = eventCounterSig.getMainCounterTable().getColumn(name=datasetName)
table.appendColumn(counter.efficiencyColumn("Normal eff", col))
embeddingMuonIsolationEff = table.getCount(rowName="tauEmbeddingMuonsCount", colName="Embedded eff")
embeddingTauIsolationEff = table.getCount(rowName="isolation", colName="Embedded eff")
embeddingTotalIsolationEff = embeddingMuonIsolationEff.clone()
embeddingTotalIsolationEff.multiply(embeddingTauIsolationEff)
# Remove unnecessary rows
del rowNames[0]
table.keepOnlyRows(rowNames)
rowIndex = table.getRowNames().index("isolation")
table.insertRow(rowIndex, counter.CounterRow("Mu isolation (emb)", ["Embedded eff", "Normal eff"],
[embeddingMuonIsolationEff, None]))
table.insertRow(rowIndex+1, counter.CounterRow("Tau isolation (emb)", ["Embedded eff", "Normal eff"],
[embeddingTauIsolationEff, None]))
table.setCount2(embeddingTotalIsolationEff, rowName="isolation", colName="Embedded eff")
table.setCount2(None, rowName="pT > 15", colName="Normal eff")
#print table.format(effFormat)
fname = "counters_tau_"+datasetName+".txt"
f = open(fname, "w")
f.write(table.format(effFormat))
f.write("\n")
f.close()
print "Printed tau counters to", fname
def doCounters(datasets):
# Counters
eventCounter = counter.EventCounter(datasets, counters=counters)
mainCounter = eventCounter.getMainCounter();
selectionsCumulative = []
tauSelectionsCumulative = []
td = treeDraw.clone(weight="")
def sel(name, selection):
selectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
mainCounter.appendRow(name, td.clone(selection="&&".join(sel)))
def tauSel(name, selection):
tauSelectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
mainCounter.appendRow(name, td.clone(selection="&&".join(sel)))
sel("Primary vertex", pvSelection)
sel(">= 1 tau candidate", "Length$(taus_p4) >= 1")
tauSel("Decay mode finding", decayModeFinding)
tauSel("pT > 15", "(taus_p4.Pt() > 15)")
tauSel("pT > 40", tauPtCut) #
tauSel("eta < 2.1", tauEtaCut)
tauSel("leading track pT > 20", tauLeadPt)
tauSel("ECAL fiducial", ecalFiducial)
tauSel("againstElectron", electronRejection) #
tauSel("againstMuon", muonRejection)
tauSel("isolation", tightIsolation) #
tauSel("oneProng", oneProng) #
tauSel("Rtau", rtau) #
sel("3 jets", jetEventSelection)
sel("MET", metSelection)
sel("btag", btagEventSelection)
sel("deltaPhi<160", deltaPhi160Selection)
fullSelection = "&&".join(selectionsCumulative+["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)])
fullSelectionCaloMetNoHF = fullSelection+"&&"+caloMetNoHF
fullSelectionCaloMet = fullSelection+"&&"+caloMet
#print fullSelection
f = open("pickEvents.txt", "w")
def printPickEvent(tree):
f.write("%d:%d:%d\n" % (tree.run, tree.lumi, tree.event))
ts = dataset.TreeScan(td.tree, function=printPickEvent, selection=fullSelection)
ts2 = dataset.TreeScan(td.tree, function=printPickEvent, selection=fullSelectionCaloMetNoHF)
ts3 = dataset.TreeScan(td.tree, function=printPickEvent, selection=fullSelectionCaloMet)
ts4 = dataset.TreeDrawCompound(ts2, {
"SingleMu_Mu_170722-172619_Aug05": ts3,
"SingleMu_Mu_172620-173198_Prompt": ts3,
"SingleMu_Mu_173236-173692_Prompt": ts3,
})
datasets.getDataset("Data").getDatasetRootHisto(ts4)
f.close()
ewkDatasets = [
"WJets", "TTJets",
# "DYJetsToLL", "SingleTop", "Diboson"
]
eventCounter.normalizeMCByLuminosity()
mainTable = eventCounter.getMainCounterTable()
#mainTable.insertColumn(2, counter.sumColumn("EWKMCsum", [mainTable.getColumn(name=name) for name in ewkDatasets]))
cellFormat = counter.TableFormatText(counter.CellFormatText(valueFormat='%.3f',
#valueOnly=True
),
# columnSeparator = ";",
)
print mainTable.format(cellFormat)
return
effFormat = counter.TableFormatText(counter.CellFormatTeX(valueFormat='%.4f'))
effTable = counter.CounterTable()
col = table.getColumn(name="Data")
effTable.appendColumn(col)
effTable.appendColumn(counter.efficiencyColumn(col.getName()+" eff", col))
col = table.getColumn(name="EWKMCsum")
effTable.appendColumn(col)
effTable.appendColumn(counter.efficiencyColumn(col.getName()+" eff", col))
print effTable.format(effFormat)
def doTauCounters(datasetsEmb, datasetsSig, datasetName):
lumi = datasetsEmb.getLuminosity()
treeDraw = dataset.TreeDraw(
"dummy", weight=tauEmbedding.tauNtuple.weight[tauEmbedding.era])
eventCounterEmb = tauEmbedding.EventCounterMany(datasetsEmb)
eventCounterSig = counter.EventCounter(datasetsSig)
def isNotThis(name):
return name != datasetName
eventCounterEmb.removeColumns(
filter(isNotThis, datasetsEmb.getAllDatasetNames()))
eventCounterSig.removeColumns(
filter(isNotThis, datasetsSig.getAllDatasetNames()))
eventCounterSig.normalizeMCToLuminosity(lumi)
effFormat = counter.TableFormatLaTeX(
counter.CellFormatTeX(valueFormat="%.4f", withPrecision=2))
tdEmb = treeDraw.clone(tree=tauAnalysisEmb + "/tree")
tdSig = treeDraw.clone(tree=tauAnalysisSig + "/tree")
selectionsCumulative = []
tauSelectionsCumulative = []
rowNames = []
def sel(name, selection):
selectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
sel = "&&".join(sel)
eventCounterEmb.mainCounterAppendRow(name, tdEmb.clone(selection=sel))
eventCounterSig.getMainCounter().appendRow(name,
tdSig.clone(selection=sel))
rowNames.append(name)
def tauSel(name, selection):
tauSelectionsCumulative.append(selection)
sel = selectionsCumulative[:]
if len(tauSelectionsCumulative) > 0:
sel += ["Sum$(%s) >= 1" % "&&".join(tauSelectionsCumulative)]
sel = "&&".join(sel)
eventCounterEmb.mainCounterAppendRow(name, tdEmb.clone(selection=sel))
eventCounterSig.getMainCounter().appendRow(name,
tdSig.clone(selection=sel))
rowNames.append(name)
sel(">= 1 tau candidate", "Length$(taus_p4) >= 1")
tauSel("Decay mode finding", tauEmbedding.tauNtuple.decayModeFinding)
tauSel("pT > 15", "taus_p4.Pt() > 15")
tauSel("pT > 40", tauEmbedding.tauNtuple.tauPtCut)
tauSel("eta < 2.1", tauEmbedding.tauNtuple.tauEtaCut)
tauSel("leading track pT > 20", tauEmbedding.tauNtuple.tauLeadPt)
tauSel("ECAL fiducial", tauEmbedding.tauNtuple.ecalFiducial)
tauSel("againstElectron", tauEmbedding.tauNtuple.electronRejection)
tauSel("againstMuon", tauEmbedding.tauNtuple.muonRejection)
tauSel("isolation", tauEmbedding.tauNtuple.tightIsolation)
tauSel("oneProng", tauEmbedding.tauNtuple.oneProng)
tauSel("Rtau", tauEmbedding.tauNtuple.rtau)
sel("MET", tauEmbedding.tauNtuple.metSelection)
table = counter.CounterTable()
col = eventCounterEmb.getMainCounterTable().getColumn(name=datasetName)
table.appendColumn(counter.efficiencyColumn("Embedded eff", col))
col = eventCounterSig.getMainCounterTable().getColumn(name=datasetName)
table.appendColumn(counter.efficiencyColumn("Normal eff", col))
embeddingMuonIsolationEff = table.getCount(
rowName="tauEmbeddingMuonsCount", colName="Embedded eff")
embeddingTauIsolationEff = table.getCount(rowName="isolation",
colName="Embedded eff")
embeddingTotalIsolationEff = embeddingMuonIsolationEff.clone()
embeddingTotalIsolationEff.multiply(embeddingTauIsolationEff)
# Remove unnecessary rows
del rowNames[0]
table.keepOnlyRows(rowNames)
rowIndex = table.getRowNames().index("isolation")
table.insertRow(
rowIndex,
counter.CounterRow("Mu isolation (emb)",
["Embedded eff", "Normal eff"],
[embeddingMuonIsolationEff, None]))
table.insertRow(
rowIndex + 1,
counter.CounterRow("Tau isolation (emb)",
["Embedded eff", "Normal eff"],
[embeddingTauIsolationEff, None]))
table.setCount2(embeddingTotalIsolationEff,
rowName="isolation",
colName="Embedded eff")
table.setCount2(None, rowName="pT > 15", colName="Normal eff")
#print table.format(effFormat)
fname = "counters_tau_" + datasetName + ".txt"
f = open(fname, "w")
f.write(table.format(effFormat))
f.write("\n")
f.close()
print "Printed tau counters to", fname
