def main(): dirEmbs = ["."] + [os.path.join("..", d) for d in result.dirEmbs[1:]] #dirSig = "../"+result.dirSig datasetsEmb = result.DatasetsMany(dirEmbs, baseline + "Counters") #datasetsSig = dataset.getDatasetsFromMulticrabCfg(cfgfile=dirSig+"/multicrab.cfg", counters=analysisSig+"Counters") datasetsEmb.forEach(plots.mergeRenameReorderForDataMC) datasetsEmb.setLumiFromData() #plots.mergeRenameReorderForDataMC(datasetsSig) tauEmbedding.normalize = True tauEmbedding.era = "Run2011A" values = {} analyses = [("Baseline", baseline), ("Plus", plus), ("Minus", minus)] cntr = "Counters/weighted" mainTable = counter.CounterTable() tauTable = counter.CounterTable() for name, analysis in analyses: c = datasetsEmb.getCounter("Data", analysis + cntr + "/counter") c.setName(name) mainTable.appendColumn(c) col = mainTable.getColumn(name=name) value = col.getCount(col.getRowNames().index(count)).value() values[name] = value 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) doPlot(datasetsEmb, analyses, "transverseMass", "mt_variated_btagging", "Without #Delta#phi(#tau jet, E_{T}^{miss}) cut") doPlot(datasetsEmb, analyses, "transverseMassAfterDeltaPhi160", "mt_variated_deltaPhi160", "#Delta#phi(#tau jet, E_{T}^{miss}) < 160^{o}") doPlot(datasetsEmb, analyses, "transverseMassAfterDeltaPhi130", "mt_variated_deltaPhi130", "#Delta#phi(#tau jet, E_{T}^{miss}) < 130^{o}")
def doCounters(datasets, massPoints): eventCounter = counter.EventCounter(datasets) eventCounter.normalizeMCByLuminosity() rows1 = [ "Trigger and HLT_MET cut", "taus == 1", "trigger scale factor", "electron veto", "muon veto", "njets", "MET" ] rows2 = [ "btagging scale factor", "deltaPhiTauMET<160", "deltaPhiTauMET<130", ] tableAll = eventCounter.getMainCounterTable() tableAll.keepOnlyRows(rows1+rows2) tableWH = counter.CounterTable() tableHH = counter.CounterTable() for mass in massPoints: tableWH.appendColumn(tableAll.getColumn(name="TTToHplusBWB_M%d"%mass)) tableHH.appendColumn(tableAll.getColumn(name="TTToHplusBHminusB_M%d"%mass)) tableWH2 = tableWH.clone() tableWH.keepOnlyRows(rows1) tableWH2.keepOnlyRows(rows2) tableHH2 = tableHH.clone() tableHH.keepOnlyRows(rows1) tableHH2.keepOnlyRows(rows2) format1 = counter.TableFormatText(counter.CellFormatTeX(valueFormat="%.0f", valueOnly=True)) format12 = counter.TableFormatText(counter.CellFormatTeX(valueFormat="%.1f", valueOnly=True)) format2 = counter.TableFormatText(counter.CellFormatTeX(valueFormat="%.2f", withPrecision=1)) print "tt -> bW bH+" print tableWH.format(format1) print tableWH2.format(format2) print print print "tt -> bH+ bH-" print tableHH.format(format12) print tableHH2.format(format2)
def getMainCounterTable(emb, sig): ec = counter.EventCounter(emb) ec2 = counter.EventCounter(sig) colName = "Data" if not useData: ec.normalizeMCByLuminosity() ec2.normalizeMCByLuminosity() colName = "MC" table = counter.CounterTable() col = ec.getMainCounterTable().getColumn(name=colName) col.setName("Embedded") table.appendColumn(col) col = col.copy() col.setName("Embedded (norm)") col.multiply(embeddingNormalisation.value(), embeddingNormalisation.uncertainty()) table.appendColumn(col) col = ec2.getMainCounterTable().getColumn(name=colName) col.setName("Normal") table.appendColumn(col) return table
def getCounter(self, datasetName, name): if not datasetName in self.residualNames: return self.datasetsEmb.getCounter(datasetName, name) # Ugly hack sigName = name if isinstance(sigName, basestring): sigName = sigName.replace(self.analysisEmb, self.analysisSig) else: sigName = sigName.clone( tree=sigName.tree.replace(self.analysisEmb, self.analysisSig)) # Get properly normalized embedded data, embedded DY and normal DY histograms (embHisto, tmp) = self.datasetsEmb.getHistogram(datasetName, name) sigHisto = self.datasetsSig.getDataset( datasetName).getDatasetRootHisto(sigName) # DatasetRootHisto sigHisto.normalizeToLuminosity(self.datasetsEmb.getLuminosity()) sigHisto = sigHisto.getHistogram() # ROOT.TH1 table = counter.CounterTable() table.appendColumn(counter.HistoCounter("Embedded", embHisto)) table.appendColumn(counter.HistoCounter("Normal", sigHisto)) table.removeNonFullRows() embColumn = table.getColumn(name="Embedded") sigColumn = table.getColumn(name="Normal") residual = counter.subtractColumn(datasetName + " residual", sigColumn, embColumn) return residual
def main(): dirEmbs = ["."] + [os.path.join("..", d) for d in result.dirEmbs[1:]] tauEmbedding.normalize = True tauEmbedding.era = "Run2011A" table = counter.CounterTable() for i in xrange(len(dirEmbs)): tmp = dirEmbs[:] del tmp[i] row = doCounters(tmp) row.setName("Removed embedding %d" % i) table.appendRow(row) arows = [] arows.append(counter.meanRow(table)) arows.append(counter.maxRow(table)) arows.append(counter.minRow(table)) arows.append(counter.subtractRow("Max-mean", arows[1], arows[0])) arows.append(counter.subtractRow("Mean-min", arows[0], arows[2])) for r in arows: table.appendRow(r) cellFormat = counter.TableFormatText( counter.CellFormatTeX(valueFormat='%.3f')) print "DeltaPhi < 160" print print table.format(cellFormat)
def writeRootHisto(self, directory, dstName, srcEmbName, isCounter): if not self.datasetsEmb.hasHistogram(self.datasetName, srcEmbName): return # Get properly normalized embedded data (embDataHisto, tmp) = self.datasetsEmb.getHistogram(self.datasetName, srcEmbName) histo = None if isCounter: embDataCounter = counter.HistoCounter("EmbData", embDataHisto) table = counter.CounterTable() table.appendColumn(embDataCounter) column = table.getColumn(name="EmbData") histo = dataset._counterToHisto(dstName, column.getPairList()) else: histo = embDataHisto histo.SetName(dstName) histo.SetDirectory(directory) histo.Write() histo.Delete() # could this help??? print "%s/%s" % (directory.GetPath(), dstName)
def doCounters(datasetsEmb): eventCounter = tauEmbedding.EventCounterMany(datasetsEmb, normalize=True) #row = "btagging scale factor" row = "deltaPhiTauMET<160" #row = "deltaPhiTauMET<130" table = eventCounter.getMainCounterTable() table.keepOnlyRows([row]) result = counter.CounterTable() 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])) addRow("No signal", table.getCount(irow=0, colName="EWKMC"), None) ewkWithSignal = table.getCount(irow=0, colName="EWKScaled") for mass in [80, 90, 100, 120, 140, 150, 155, 160]: addRow("H+ M%d"%mass, ewkWithSignal, table.getCount(irow=0, colName="TTToHplus_M%d"%mass)) #cellFormat = counter.TableFormatLaTeX(counter.CellFormatTeX(valueFormat='%.3f')) cellFormat = counter.TableFormatLaTeX(counter.CellFormatTeX(valueFormat='%.4f', withPrecision=2)) print result.format(cellFormat)
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) tableEmb = eventCounterEmb.getMainCounterTable() tableSig = eventCounterSig.getMainCounterTable() table = counter.CounterTable() col = tableEmb.getColumn(name=datasetName) col.setName(datasetName+" emb") table.appendColumn(col) col = tableSig.getColumn(name=datasetName) col.setName(datasetName+" norm") table.appendColumn(col) table.keepOnlyRows([ "njets", "MET", "btagging", "btagging scale factor", "deltaPhiTauMET<160", "deltaPhiTauMET<130", ]) table.renameRows({"njets": "tau ID"}) return table
def getMainCounterTable(self, dataset): table = counter.CounterTable() for an, dm in zip(self.analyses, self.datasetManagers): eventCounter = counter.EventCounter(dm) eventCounter.normalizeMCByLuminosity() tmpTable = eventCounter.getMainCounterTable() col = tmpTable.getColumn(name=dataset) col.setName(legends[an]) table.appendColumn(col) return table
def writeRootHisto(self, directory, dstName, srcEmbName, srcSigName, isCounter): if not self.datasetsEmb.hasHistogram( self.datasetName, srcEmbName) or not self.datasetSig.hasRootHisto(srcSigName): return histo = None # Get properly normalized embedded and normal MC (embMcHisto, tmp) = self.datasetsEmb.getHistogram(self.datasetName, srcEmbName) sigMcHisto = self.datasetSig.getDatasetRootHisto( srcSigName).getHistogram() # ROOT.TH1 #print embMcHisto, sigMcHisto if self.normalOnly: histo = sigMcHisto elif self.embeddedOnly: histo = embMcHisto else: if isCounter: embMcCounter = counter.HistoCounter("EmbMc", embMcHisto) sigMcCounter = counter.HistoCounter("SigMc", sigMcHisto) table = counter.CounterTable() table.appendColumn(embMcCounter) table.appendColumn(sigMcCounter) table.removeNonFullRows() if table.getNrows() == 0: return embMcColumn = table.getColumn(name="EmbMc") sigMcColumn = table.getColumn(name="SigMc") residual = counter.subtractColumn("Correction", sigMcColumn, embMcColumn) histo = dataset._counterToHisto(dstName, residual.getPairList()) else: # Residual MC: normal-embedded sigMcHisto.Add(embMcHisto, -1) histo = sigMcHisto histo.SetName(dstName) histo.SetDirectory(directory) histo.Write() histo.Delete() # could this help??? print "%s/%s" % (directory.GetPath(), dstName)
def doCounters(muonDatasets, tauDatasets, datasetName): ecMuon = counter.EventCounter(muonDatasets) ecMuonWeighted = counter.EventCounter(muonDatasets, counters="counters/weighted") ecTau = counter.EventCounter(tauDatasets) def isNotThis(name): return name != datasetName ecMuon.removeColumns(filter(isNotThis, muonDatasets.getAllDatasetNames())) ecMuonWeighted.removeColumns( filter(isNotThis, muonDatasets.getAllDatasetNames())) ecTau.removeColumns(filter(isNotThis, tauDatasets.getAllDatasetNames())) ecMuon.normalizeMCToLuminosity(mcLumi) ecMuonWeighted.normalizeMCToLuminosity(mcLumi) ecTau.normalizeMCToLuminosity(mcLumi) table = counter.CounterTable() col = ecMuon.getMainCounterTable().getColumn(name=datasetName) col.setName("Muon") col.setCount( -1, ecMuonWeighted.getMainCounterTable().getCount(irow=-1, colName=datasetName)) muonEvents = col.getCount(name="= 1 gen muon").clone() muonEventsWeighted = col.getCount(-1).clone() table.appendColumn(col) col = ecTau.getMainCounterTable().getColumn(name=datasetName) col.setName("Tau") tauEvents = col.getCount(-1).clone() table.appendColumn(col) print table.format() ratio = tauEvents.clone() ratio.divide(muonEvents) ratioWeighted = tauEvents.clone() ratioWeighted.divide(muonEventsWeighted) print "Tau/Muon = %f +- %f" % (ratio.value(), ratio.uncertainty()) print "Tau/Muon(ID) = %f +- %f" % (ratioWeighted.value(), ratioWeighted.uncertainty()) print ratio = muonEvents.clone() ratio.divide(tauEvents) ratioWeighted = muonEventsWeighted.clone() ratioWeighted.divide(tauEvents) print "Muon/Tau = %f +- %f" % (ratio.value(), ratio.uncertainty()) print "Muon(ID)/Tau = %f +- %f" % (ratioWeighted.value(), ratioWeighted.uncertainty())
def doCounters(muonDatasets, tauDatasets, datasetName, ntupleCacheMuon, ntupleCacheTau): ecMuon = counter.EventCounter(muonDatasets) #ecMuonWeighted = counter.EventCounter(muonDatasets, counters="counters/weighted") ecTau = counter.EventCounter(tauDatasets) def isNotThis(name): return name != datasetName ecMuon.removeColumns(filter(isNotThis, muonDatasets.getAllDatasetNames())) #ecMuonWeighted.removeColumns(filter(isNotThis, muonDatasets.getAllDatasetNames())) ecTau.removeColumns(filter(isNotThis, tauDatasets.getAllDatasetNames())) ecMuon.normalizeMCToLuminosity(mcLumi) #ecMuonWeighted.normalizeMCToLuminosity(mcLumi) ecTau.normalizeMCToLuminosity(mcLumi) ecMuon.getMainCounter().appendRows( ntupleCacheMuon.histogram("counters/weighted/counter")) ecTau.getMainCounter().appendRows( ntupleCacheTau.histogram("counters/weighted/counter")) table = counter.CounterTable() muonCol = ecMuon.getMainCounterTable().getColumn(name=datasetName) muonCol.setName("Muon") #col.setCount(-1, ecMuonWeighted.getMainCounterTable().getCount(irow=-1, colName=datasetName)) table.appendColumn(muonCol) tauCol = ecTau.getMainCounterTable().getColumn(name=datasetName) tauCol.setName("Tau") table.appendColumn(tauCol) print table.format() def printRatio(muonCount, tauCount): ratio1 = tauCol.getCount(name=tauCount).clone() ratio1.divide(muonCol.getCount(name=muonCount)) ratio2 = muonCol.getCount(name=muonCount).clone() ratio2.divide(tauCol.getCount(name=tauCount)) print "Tau/Muon = %f +- %f, Muon/Tau = %f +- %f" % ( ratio1.value(), ratio1.uncertainty(), ratio2.value(), ratio2.uncertainty()) print "Generator level" printRatio("= 1 gen muon", "= 1 gen tau") print print "Reco muon vs. gen tau, after muon veto" printRatio("muon id eff weighting", "reco muon veto")
def main(): dirEmbs = ["."] + [os.path.join("..", d) for d in tauEmbedding.dirEmbs[1:]] dirSig = "../" + tauEmbedding.dirSig # dirEmbs = dirEmbs[:2] datasetsEmb = tauEmbedding.DatasetsMany(dirEmbs, analysisEmb + "/counters", normalizeMCByLuminosity=True) datasetsSig = dataset.getDatasetsFromMulticrabCfg( cfgfile=dirSig + "/multicrab.cfg", counters=analysisSig + "/counters") datasetsSig.updateNAllEventsToPUWeighted() datasetsEmb.forEach(plots.mergeRenameReorderForDataMC) datasetsEmb.setLumiFromData() plots.mergeRenameReorderForDataMC(datasetsSig) def mergeEWK(datasets): datasets.merge( "EWKMC", ["WJets", "TTJets", "DYJetsToLL", "SingleTop", "Diboson"], keepSources=True) mergeEWK(datasetsSig) datasetsEmb.forEach(mergeEWK) plots._legendLabels["EWKMC"] = "EWK" # Apply TDR style style = tdrstyle.TDRStyle() histograms.cmsTextMode = histograms.CMSMode.SIMULATION histograms.cmsText[histograms.CMSMode.SIMULATION] = "Simulation" histograms.createLegend.setDefaults(y1=0.93, y2=0.75, x1=0.52, x2=0.93) tauEmbedding.normalize = True tauEmbedding.era = "Run2011AB" table = counter.CounterTable() def dop(name): doPlots(datasetsEmb, datasetsSig, name) tbl = doCounters(datasetsEmb, datasetsSig, name) for icol in xrange(tbl.getNcolumns()): table.appendColumn(tbl.getColumn(icol)) dop("TTJets") dop("WJets") dop("DYJetsToLL") dop("SingleTop") dop("Diboson") cellFormat = counter.TableFormatLaTeX( counter.CellFormatTeX(valueFormat='%.4f', withPrecision=2)) print table.format(cellFormat)
def doCounters(datasetsEmb, datasetsSig): rows = [ "njets", "MET", "btagging scale factor", "deltaPhiTauMET<160", "deltaPhiTauMET<130" ] residuals = ["DYJetsToLL residual", "WW residual"] # Normal MC eventCounterNormal = counter.EventCounter(datasetsSig) eventCounterNormal.normalizeMCToLuminosity(datasetsEmb.getLuminosity()) tableNormal = eventCounterNormal.getMainCounterTable() tableNormal.keepOnlyRows(rows) # Embedded data and MC, residual MC eventCounter = tauEmbedding.EventCounterResidual(datasetsEmb) table = eventCounter.getMainCounterTable() table.keepOnlyRows(rows) # Build the result result = counter.CounterTable() c = table.getColumn(name="Data") c.setName("Embedded data") result.appendColumn(c) #result.appendColumn(table.getColumn(name="EWKMC")) for name in residuals: result.appendColumn(table.getColumn(name=name)) result.appendColumn( counter.sumColumn( "Emb. data + res. MC", [table.getColumn(name=name) for name in ["Data"] + residuals])) result.appendColumn( counter.sumColumn( "Emb. MC + res. MC", [table.getColumn(name=name) for name in ["EWKMC"] + residuals])) c = tableNormal.getColumn(name="EWKMC") c.setName("Normal MC") result.appendColumn(c) # Final formatting result.renameRows({ "njets": "tau-jet identification", "btagging scale factor": "b tagging" }) cellFormat = counter.TableFormatLaTeX( counter.CellFormatTeX(valueFormat='%.4f', withPrecision=2)) print result.format(cellFormat)
def getCounter(self, datasetName, name): if not datasetName in ["Data", "EWKMC", "DYJetsToLL"]: (embDataHisto, tmp) = self.datasetsEmb.getHistogram(datasetName, name) return counter.HistoCounter(datasetName, embDataHisto) # Ugly hack sigName = name if isinstance(sigName, basestring): sigName = sigName.replace(self.analysisEmb, self.analysisSig) else: sigName = sigName.clone( tree=sigName.tree.replace(self.analysisEmb, self.analysisSig)) # Get properly normalized embedded data, embedded DY and normal DY histograms (embDataHisto, tmp) = self.datasetsEmb.getHistogram(datasetName, name) (embDyHisto, tmp) = self.datasetsEmb.getHistogram("DYJetsToLL", name) sigDyHisto = self.datasetsSig.getDataset( "DYJetsToLL").getDatasetRootHisto(sigName) # DatasetRootHisto sigDyHisto.normalizeToLuminosity(self.datasetsEmb.getLuminosity()) sigDyHisto = sigDyHisto.getHistogram() # ROOT.TH1 embDataCounter = counter.HistoCounter("EmbData", embDataHisto) embDyCounter = counter.HistoCounter("EmbDy", embDyHisto) sigDyCounter = counter.HistoCounter("SigDy", sigDyHisto) table = counter.CounterTable() table.appendColumn(embDataCounter) table.appendColumn(embDyCounter) table.appendColumn(sigDyCounter) table.removeNonFullRows() column = table.getColumn(name="EmbData") embDyColumn = table.getColumn(name="EmbDy") sigDyColumn = table.getColumn(name="SigDy") dyCorrection = counter.subtractColumn("Correction", sigDyColumn, embDyColumn) column = counter.sumColumn(datasetName, [column, dyCorrection]) return column
def doCountersOld(datasetsEmb, counterName="counter"): datasetNames = datasetsEmb.getAllDatasetNames() table = counter.CounterTable() for name in datasetNames: table.appendColumn( datasetsEmb.getCounter( name, analysisEmb + "Counters/weighted/" + counterName)) ewkDatasets = ["WJets", "TTJets", "DYJetsToLL", "SingleTop", "Diboson"] table.insertColumn( 2, counter.sumColumn("EWKMCsum", [table.getColumn(name=name) for name in ewkDatasets])) print "============================================================" if isinstance(datasetsEmb, result.DatasetsDYCorrection): print "DY correction applied" cellFormat = counter.TableFormatText( counter.CellFormatTeX(valueFormat='%.3f')) print table.format(cellFormat)
def do(onlyWjets, mcEvents, normalize, formatCounters, formatPlots): dirEmbs = tauEmbedding.dirEmbs[:] if onlyWjets: dirEmbs.extend(dirEmbsWjets) dirEmbs = ["."] + [os.path.join("..", d) for d in dirEmbs[1:]] # dirEmbs = dirEmbs[0:2] # Read luminosity datasets = dataset.getDatasetsFromMulticrabCfg(cfgfile=dirEmbs[0]+"/multicrab.cfg", counters=analysisEmb+"Counters", weightedCounters=False) datasets.loadLuminosities() plots.mergeRenameReorderForDataMC(datasets) lumi = datasets.getDataset("Data").getLuminosity() style = tdrstyle.TDRStyle() histograms.cmsTextMode = histograms.CMSMode.SIMULATION histograms.cmsText[histograms.cmsTextMode] = "Simulation" tauEmbedding.normalize=normalize tauEmbedding.era = "Run2011A" table = counter.CounterTable() for i, d in enumerate(dirEmbs): datasets = dataset.getDatasetsFromMulticrabCfg(cfgfile=d+"/multicrab.cfg", counters=analysisEmb+"Counters", weightedCounters=False) if onlyWjets: datasets.remove(filter(lambda n: n != "WJets_TuneZ2_Summer11", datasets.getAllDatasetNames())) else: if mcEvents: datasets.remove(filter(lambda n: n != "WJets_TuneZ2_Summer11" and n != "TTJets_TuneZ2_Summer11" and not "SingleMu" in n, datasets.getAllDatasetNames())) datasets.loadLuminosities() datasets.remove(filter(lambda name: "HplusTB" in name, datasets.getAllDatasetNames())) datasets.remove(filter(lambda name: "TTToHplus" in name, datasets.getAllDatasetNames())) tauEmbedding.updateAllEventsToWeighted(datasets) plots.mergeRenameReorderForDataMC(datasets) row = doCounters(datasets, onlyWjets, mcEvents, normalize, lumi) row.setName("Embedding %d" % i) table.appendRow(row) if formatPlots: doPlots(table, onlyWjets, mcEvents, normalize, lumi) if not formatCounters: return arows = [] arows.append(counter.meanRow(table)) arows.extend(counter.meanRowFit(table)) arows.append(counter.maxRow(table)) arows.append(counter.minRow(table)) for r in arows: table.appendRow(r) print table.format() ftable = counter.CounterTable() def addRow(name): col = table.getColumn(name=name) minimum = col.getCount(name="Min") maximum = col.getCount(name="Max") mean = col.getCount(name="Mean") ftable.appendRow(counter.CounterRow(name, ["Mean", "Minimum", "Maximum"], [mean, minimum, maximum])) addRow("Data") addRow("EWKMCsum") addRow("TTJets") addRow("WJets") addRow("DYJetsToLL") addRow("SingleTop") addRow("Diboson") cellFormat2 = counter.TableFormatLaTeX(counter.CellFormatTeX(valueFormat="%.4f", withPrecision=2)) print ftable.format(cellFormat2)
def main(): dirEmbs = result.dirEmbs[:] if onlyWjets: dirEmbs.extend(dirEmbsWjets) dirEmbs = ["."] + [os.path.join("..", d) for d in dirEmbs[1:]] # dirEmbs = dirEmbs[0:2] style = tdrstyle.TDRStyle() tauEmbedding.normalize = normalize tauEmbedding.era = "Run2011A" ts = dataset.TreeScan(analysisEmb + "/tree", function=None, selection=And(metCut, bTaggingCut, deltaPhi160Cut)) def printPickEvent(f, tree): f.write("%d:%d:%d\n" % (tree.run, tree.lumi, tree.event)) table = counter.CounterTable() for i, d in enumerate(dirEmbs): datasets = dataset.getDatasetsFromMulticrabCfg( cfgfile=d + "/multicrab.cfg", counters=analysisEmb + "Counters") if onlyWjets: datasets.remove( filter(lambda n: n != "WJets_TuneZ2_Summer11", datasets.getAllDatasetNames())) else: if mcEvents: datasets.remove( filter( lambda n: n != "WJets_TuneZ2_Summer11" and n != "TTJets_TuneZ2_Summer11" and not "SingleMu" in n, datasets.getAllDatasetNames())) datasets.loadLuminosities() datasets.remove( filter(lambda name: "HplusTB" in name, datasets.getAllDatasetNames())) datasets.remove( filter(lambda name: "TTToHplus" in name, datasets.getAllDatasetNames())) tauEmbedding.updateAllEventsToWeighted(datasets) plots.mergeRenameReorderForDataMC(datasets) # for ds in datasets.getAllDatasets(): # f = open("pickEvents_%s_%d.txt" % (ds.getName(), i), "w") # ds.getDatasetRootHisto(ts.clone(function=lambda tree: printPickEvent(f, tree))) # f.close() row = doCounters(datasets) row.setName("Embedding %d" % i) table.appendRow(row) doPlots(table) arows = [] arows.append(counter.meanRow(table)) arows.extend(counter.meanRowFit(table)) arows.append(counter.maxRow(table)) arows.append(counter.minRow(table)) for r in arows: table.appendRow(r) # csvSplitter = counter.TableSplitter([" \pm "]) # cellFormat = counter.TableFormatText(counter.CellFormatTeX(valueFormat='%.3f'), columnSeparator=",") cellFormat = counter.TableFormatText( counter.CellFormatTeX(valueFormat='%.3f')) print "DeltaPhi < 160" print print table.format(cellFormat)
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 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(): dirEmbs = ["."] + [os.path.join("..", d) for d in tauEmbedding.dirEmbs[1:]] # dirEmbs = dirEmbs[:2] tauEmbedding.normalize=True tauEmbedding.era = "Run2011A" table = counter.CounterTable() for i in xrange(len(dirEmbs)): tmp = dirEmbs[:] del tmp[i] row = doCounters(tmp) row.setName("Removed embedding %d"%i) table.appendRow(row) arows = [] arows.append(counter.meanRow(table)) arows.append(counter.maxRow(table)) arows.append(counter.minRow(table)) arows.append(counter.subtractRow("Max-mean", arows[1], arows[0])) arows.append(counter.subtractRow("Mean-min", arows[0], arows[2])) for r in arows: table.appendRow(r) cellFormat = counter.TableFormatText(counter.CellFormatTeX(valueFormat='%.3f')) print "DeltaPhi < 160" print print table.format(cellFormat) print print # Format the table as in AN ftable = counter.CounterTable() 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])) addRow("Data") addRow("EWKMCsum") addRow("TTJets") addRow("WJets") addRow("DYJetsToLL") addRow("SingleTop") addRow("Diboson") cellFormat2 = counter.TableFormatLaTeX(counter.CellFormatTeX(valueFormat="%.4f", withPrecision=2)) cellFormat2.setColumnFormat(counter.CellFormatTeX(valueFormat="%.1f", valueOnly=True), index=2) print ftable.format(cellFormat2)
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 processDirectory(dset, srcDirName, dstDir, scaleBy, dsetSubtractFrom): # Get directories, recurse to them dirs = dset.getDirectoryContent(srcDirName, lambda o: isinstance(o, ROOT.TDirectory)) dirs = filter(lambda n: n != "configInfo", dirs) for d in dirs: newDir = dstDir.mkdir(d) processDirectory(dset, os.path.join(srcDirName, d), newDir, scaleBy, dsetSubtractFrom) # Then process histograms histos = dset.getDirectoryContent(srcDirName, lambda o: isinstance(o, ROOT.TH1)) dstDir.cd() shouldScale = True if srcDirName == "counters": # Don't touch unweighted counters shouldScale = False isCounter = srcDirName in ["counters", "counters/weighted"] for hname in histos: # drh = dset.getDatasetRootHisto(os.path.join(srcDirName, hname)) # hnew = drh.getHistogram() # TH1 hnew = dset.getAverageHistogram( os.path.join(srcDirName, hname), normalizeMCByCrossSection=(dsetSubtractFrom is not None)) hnew.SetName(hname) if shouldScale and hname not in "SplittedBinInfo": tauEmbedding.scaleTauBRNormalization(hnew) if scaleBy is not None: hnew.Scale(scaleBy) if dsetSubtractFrom is not None: drh = dsetSubtractFrom.getDatasetRootHisto( os.path.join(srcDirName, hname)) if dsetSubtractFrom.isMC(): drh.normalizeByCrossSection() hsub = drh.getHistogram() if not isCounter: # hnew = hsub-hnew hnew.Scale(-1) hnew.Add(hsub) else: cnew = counter.HistoCounter("Emb", hnew) csub = counter.HistoCounter("Norm", hsub) table = counter.CounterTable() table.appendColumn(cnew) table.appendColumn(csub) cres = counter.subtractColumn("Result", table.getColumn(name="Norm"), table.getColumn(name="Emb")) hnew2 = dataset._counterToHisto(hnew.GetName(), cres.getPairList()) hnew2.SetTitle(hnew.GetTitle()) hnew = hnew2 if srcDirName == "counters" and hname == "counter" and hnew.GetBinContent( 1) < 0: hnew.SetBinContent(1, 0) hnew.SetDirectory(dstDir) # # set the first count in main counters to 0 if it is negative, # # this is to circumvent certain assumptions made elsewhere in # # the code # if hname == "counter" and (srcDirName == "counters" or srcDirName == "counters/weighted") and hnew.GetBinContent(1) < 0: # hnew.SetBinContent(1, 0) # hnew.SetBinError(1, 0) hnew.Write() # ROOT.gDirectory.Delete(hname) hnew.Delete()
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 printCountersOld(datasets, datasetsMC, analysisPrefix, normalizeToLumi=None): print "============================================================" print "Dataset info: " datasets.printInfo() eventCounter = makeEventCounter(datasets) if normalizeToLumi == None: eventCounter.normalizeMCByLuminosity() else: eventCounter.normalizeMCToLuminosity(normalizeToLumi) mainCounterMap = { "allEvents": "All events", "passedTrigger": "Triggered", "passedScrapingVeto": "Scaping veto", "passedHBHENoiseFilter": "HBHE noise filter", "passedPrimaryVertexFilter": "PV filter", analysisPrefix+"countAll": "All events", analysisPrefix+"countTrigger": "Triggered", analysisPrefix+"countPrimaryVertex": "Good primary vertex", analysisPrefix+"countGlobalTrackerMuon": "Global \& tracker muon", analysisPrefix+"countMuonKin": "Muon \pT, $\eta$ cuts", analysisPrefix+"countMuonQuality": "Muon quality cuts", analysisPrefix+"countMuonIP": "Muon transverse IP", analysisPrefix+"countMuonVertexDiff": "Muon dz", analysisPrefix+"countJetMultiplicityCut": "Njets", analysisPrefix+"countMETCut": "MET cut" } latexFormat = counter.TableFormatLaTeX(counter.CellFormatTeX(valueFormat="%.0f")) latexFormat2 = counter.TableFormatLaTeX(counter.CellFormatTeX(valueFormat="%.1f")) #latexFormat = counter.TableFormatConTeXtTABLE(counter.CellFormatTeX(valueFormat="%.0f", valueOnly=True)) print "============================================================" print "Main counter (%s)" % eventCounter.getNormalizationString() #eventCounter.getMainCounter().printCounter() table = eventCounter.getMainCounterTable() # addSumColumn(table) # addTtwFractionColumn(table) # addPurityColumn(table) # addDyFractionColumn(table) # addQcdFractionColumn(table) # reorderCounterTable(table) # print table.format() print table.format(latexFormat) # print table.format(latexFormat2) return #print "------------------------------------------------------------" #print counterEfficiency(eventCounter.getMainCounterTable()).format(FloatDecimalFormat(4)) # mainTable = eventCounter.getMainCounterTable() # effTable = counterEfficiency(mainTable) # for icol in xrange(0, effTable.getNcolumns()): # column = effTable.getColumn(icol) # column.setName(column.getName()+" eff") # mainTable.insertColumn(icol*2+1, column) # print "------------------------------------------------------------" # printCounter(mainTable, FloatDecimalFormat(4)) eventCounter = makeEventCounter(datasetsMC) print "============================================================" print "Main counter (%s)" % eventCounter.getNormalizationString() print eventCounter.getMainCounterTable().format(counter.TableFormatText(counter.CellFormatText(valueOnly=True, valueFormat="%.0f"))) # Make the Data column entries comparable to the MC table.renameRows(mainCounterMap) dataCol = table.getColumn(0) table.removeColumn(0) dataCol.removeRow(2) # scraping dataCol.removeRow(2) # HBHE dataCol.removeRow(2) # pv filter dataCol.removeRow(2) # all events dataCol.removeRow(2) # triggered table.insertColumn(0, dataCol) addDataMcRatioColumn(table) # LaTeX tables for note latexFormat.setColumnFormat(counter.CellFormatTeX(valueFormat="%.3f"), name="Data/MCsum") latexFormat.setColumnFormat(counter.CellFormatTeX(valueFormat="%.1f"), name="SingleTop") tableDataMc = counter.CounterTable() tableDataMc.appendColumn(table.getColumn(name="Data")) tableDataMc.appendColumn(table.getColumn(name="MCsum")) tableDataMc.appendColumn(table.getColumn(name="Data/MCsum")) print tableDataMc.format(latexFormat) tableMc = counter.CounterTable() #tableMc.appendColumn(table.getColumn(name="MCsum")) for mcName in datasets.getMCDatasetNames(): tableMc.appendColumn(table.getColumn(name=mcName)) print tableMc.format(latexFormat) tableRatio = counter.CounterTable() for cname in ["TTJets/(TTJets+WJets)", "Purity", "QCD/MCsum", "DY/MCsum"]: tableRatio.appendColumn(table.getColumn(name=cname)) latexFormat.setColumnFormat(counter.CellFormatTeX(valueFormat="%.2f", valueOnly=True), name=cname) print tableRatio.format(latexFormat)
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(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): # All embedded events eventCounterAll = counter.EventCounter( datasetsEmb.getFirstDatasetManager(), counters=analysisEmbAll + counters) eventCounterAll.normalizeMCByLuminosity() tableAll = eventCounterAll.getMainCounterTable() tableAll.keepOnlyRows([ "All events", ]) tableAll.renameRows({"All events": "All embedded events"}) # Mu eff + Wtau mu eventCounterMuEff = counter.EventCounter( datasetsEmb.getFirstDatasetManager(), counters=analysisEmbNoTauEff + counters) eventCounterMuEff.normalizeMCByLuminosity() tauEmbedding.scaleNormalization(eventCounterMuEff) tableMuEff = eventCounterMuEff.getMainCounterTable() tableMuEff.keepOnlyRows(["All events"]) tableMuEff.renameRows({"All events": "mu eff + Wtaumu"}) # Event counts after embedding normalization, before tau trigger eff, # switch to calculate uncertainties of the mean of 10 trials eventCounterNoTauEff = tauEmbedding.EventCounterMany( datasetsEmb, counters=analysisEmbNoTauEff + counters) tableNoTauEff = eventCounterNoTauEff.getMainCounterTable() tableNoTauEff.keepOnlyRows([ "Trigger and HLT_MET cut", "njets", ]) tableNoTauEff.renameRows({ "Trigger and HLT_MET cut": "caloMET > 60", "njets": "tau ID" }) # Event counts after tau trigger eff eventCounter = tauEmbedding.EventCounterMany(datasetsEmb, counters=analysisEmb + counters) table = eventCounter.getMainCounterTable() table.keepOnlyRows([ "njets", "MET", "btagging scale factor", "deltaPhiTauMET<160", "deltaPhiTauMET<130" ]) table.renameRows({ "njets": "Tau trigger efficiency", "btagging scale factor": "b tagging" }) # Combine the rows to one table result = counter.CounterTable() for tbl in [tableAll, tableMuEff, tableNoTauEff, table]: for iRow in xrange(tbl.getNrows()): result.appendRow(tbl.getRow(index=iRow)) addMcSum(result) cellFormat = counter.TableFormatText( counter.CellFormatTeX(valueFormat='%.4f', withPrecision=2)) print result.format(cellFormat)
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))