def getCustomisedHisto(datasets, h, bIsTH2): if bIsTH2: print "*** Disabling bMCUncertainty and bStackHistos for TH2 plots" bAddMCUncertainty = False bStackHistos = False else: bAddMCUncertainty = True bStackHistos = True # Determine number of Data/MC datasets present nDataDatasets = len(datasets.getDataDatasets()) nMCDatasets = len(datasets.getMCDatasets()) # Sanity check for Ratio plot. If no MC datasets are found disable it (overwrite user-defined options) if nMCDatasets < 1: h.bRatio == False #print "%snMCDatasets = %i" % (" "*0, nMCDatasets) if h.yMin is not None and h.yMax is not None: drawPlot = plots.PlotDrawer(stackMCHistograms=bStackHistos, addMCUncertainty=bAddMCUncertainty, log=h.bLogY, ratio=h.bRatio, addLuminosityText=True, ratioYlabel="Ratio", opts={ "ymin": h.yMin, "ymax": h.yMax }, opts2={ "ymin": yMinRatio, "ymax": yMaxRatio }, optsLog={ "ymin": h.yMin, "ymax": h.yMax }) else: drawPlot = plots.PlotDrawer(stackMCHistograms=bStackHistos, addMCUncertainty=bAddMCUncertainty, log=h.bLogY, ratio=h.bRatio, addLuminosityText=True, ratioYlabel="Ratio", opts={"ymaxfactor": yMaxFactor}, opts2={ "ymin": yMinRatio, "ymax": yMaxRatio }, optsLog={ "ymin": 1E-01, "ymaxfactor": yMaxFactorLog }) return drawPlot
def dataMCExample(datasets): # Create data-MC comparison plot, with the default # - legend labels (defined in plots._legendLabels) # - plot styles (defined in plots._plotStyles, and in styles) # - drawing styles ('HIST' for MC, 'EP' for data) # - legend styles ('L' for MC, 'P' for data) plot = plots.DataMCPlot(datasets, #"ForDataDrivenCtrlPlots/SelectedTau_pT_AfterStandardSelections" "tauPt", # Since the data datasets were removed, we have to set the luminosity by hand normalizeToLumi=20000 ) # Same as below, but more compact plots.drawPlot(plot, "taupt", xlabel="Tau p_{T} (GeV/c)", ylabel="Number of events", rebin=10, stackMCHistograms=True, addMCUncertainty=True, addLuminosityText=True, opts={"ymin": 1e-1, "ymaxfactor": 10}, log=True) drawPlot = plots.PlotDrawer(stackMCHistograms=True, addMCUncertainty=True, addLuminosityText=True, opts={"ymin": 1e-1, "ymaxfactor": 10}) def createDrawPlot(name, **kwargs): drawPlot( plots.DataMCPlot(datasets, name, normalizeToLumi=20000), name, **kwargs) createDrawPlot("tauEta", xlabel="", ylabel="Number of events", rebin=1, log=False) createDrawPlot("Met", xlabel="E_{T}^{miss} (GeV)", ylabel="Number of events", rebin=1, log=True) createDrawPlot("MetPhi", xlabel="#Phi^{miss} ", ylabel="Number of events", rebin=1, log=False) createDrawPlot("jetPt", xlabel="p_{T}^{jet} (GeV/c)", ylabel="Number of events", rebin=1, log=True) createDrawPlot("jetEta", xlabel="", ylabel="Number of events", rebin=1, log=False) createDrawPlot("jetPhi", xlabel="#Phi^{jet}", ylabel="Number of events", rebin=1, log=False)
def doPlots(datasets, histoDict, xLabelDict, yLabelDict, MyCuts, SaveExtension): ''' def doPlots(datasets, histoDict, xLabelDict, yLabelDict, MyCuts, SaveExtension): ''' ### Create a progress bar to inform user of progress status maxValue = len(histoDict) print "\n*** Preparing %s histogram(s) for the cut group:\n \"%s\"" % ( maxValue, MyCuts) pBar = StartProgressBar(maxValue) drawPlot = plots.PlotDrawer(bStackHistos, addMCUncertainty=bAddMCUncertainty, log=bLogY, ratio=bRatioPlot, addLuminosityText=bAddLumiText, ratioYlabel="Ratio", opts={ "ymin": yMin, "ymax": yMax }, optsLog={ "ymin": yMinLog, "ymax": yMaxLog }) ### Define the event "weight" to be used if "passedBTagging" in MyCuts: EvtWeight = "(weightPileup*weightTrigger*weightPrescale*weightBTagging)" else: EvtWeight = "weightPileup*weightTrigger*weightPrescale" print "*** And Event weight:\n \"%s\"" % (EvtWeight) treeDraw = dataset.TreeDraw("tree", weight=EvtWeight) MyTreeDraw = treeDraw.clone(selection=MyCuts) ### Loop over all hName and expressions in the histogram dictionary "histoDict". Create & Draw plot counter = 0 for key in histoDict: hName = key histo = MyTreeDraw.clone(varexp=histoDict[hName]) fileName = "%s_%s" % (hName, SaveExtension) xLabel = xLabelDict[hName] yLabel = yLabelDict[hName] ### Go ahead and draw the plot p = createPlot(datasets, histo, normalizeToOne=bNormalizeToOne) drawPlot(p, fileName, rebin=1, xlabel=xLabel, ylabel=yLabel) ### Increment counter and pdate progress bar counter = counter + 1 pBar.update(counter) ### Stop pbar once done with the loop pBar.finish() return
def doQcdPurPlots(p, drawPlot, datasets, hExpr, hName, xLabel, yLabel, SaveExtension): if getBool("bRemoveEwk"): print "*** WARNING: No Ewk samples found. Skipping QCD Purity plots." return histograms.createLegend.setDefaults(x1=xLegMin * (0.90), x2=xLegMax * (0.95), y1=yLegMin, y2=yLegMax * 1.2) saveName = "%s_%s" % (hName, SaveExtension + "_QcdPurity") ### Setup the histogram text mode and create plot p2 = createTH1Plot(datasets, hExpr, normalizeToOne=False) ### Define the purity histogram binning Bins = [40.0, 50.0, 60.0, 70.0, 80.0, 100.0, 120.0, 150.0, 200.0] myBins = array.array('d', Bins) ### Loop over all histograms to determine the number of signal and bkg events to calculate qcdPurity for htmp in p.histoMgr.getHistos(): name = htmp.getName() h = htmp.getRootHisto().Rebin(len(myBins) - 1, name, myBins) htmp.setRootHisto(h) if (name in "Data"): hQcdPur = p.histoMgr.getHisto("Data").getRootHisto().Clone( "hQcdPur") p2.histoMgr.removeHisto(name) elif (name in ["TTToHplus", "QCD"]): p2.histoMgr.removeHisto(name) else: hQcdPur.Add(h, -1) p2.histoMgr.removeHisto(name) hQcdPur.Divide(p.histoMgr.getHisto("Data").getRootHisto()) Purity = histograms.Histo(setQcdPurityHistoStyle(hQcdPur), "Purity = #frac{Data-Ewk MC}{Data}", "", "") p2.histoMgr.appendHisto(Purity) ### Draw the plot with custom options and save drawPlot = plots.PlotDrawer(stackMCHistograms=getBool("bStackHistos"), addMCUncertainty=getBool("bAddMCUncertainty"), log=False, ratio=getBool("bStackHistos"), addLuminosityText=getBool("bAddLumiText"), opts={ "ymin": yMinPurity, "ymax": yMaxPurity }) drawPlot(p2, saveName, rebin=1, xlabel=xLabel, ylabel=yLabel) return
def doPlots(datasets): def createPlot(name, **kwargs): return plots.DataMCPlot(datasets, name, **kwargs) drawPlot = plots.PlotDrawer(stackMCHistograms=True, addMCUncertainty=True, log=True, ratio=True, addLuminosityText=True, ratioYlabel="Ratio", optsLog={"ymin": 1e-1}, opts2={ "ymin": 0, "ymax": 2 }) selections = [ ("Full_", And(muonSelection, muonVeto, electronVeto, jetSelection)), # ("FullNoIso_", And(muonSelectionNoIso, muonVetoNoIso, electronVeto, jetSelectionNoIso)), # ("Analysis_", "&&".join([muonSelection, muonVeto, electronVeto, jetSelection, metcut, btagging])), ] for name, selection in selections: tdMuon = treeDraw.clone(selection=selection) histograms.cmsTextMode = histograms.CMSMode.PRELIMINARY td = tdMuon.clone(varexp="muons_p4.Pt() >>tmp(40,0,400)") drawPlot(createPlot(td), name + "muon_pt_log", "Muon ^{}p_{T} (GeV/c)", ylabel="Events / %.0f GeV/c", cutBox={ "cutValue": 40, "greaterThan": True }) histograms.cmsTextMode = histograms.CMSMode.NONE td = tdMuon.clone(varexp="pfMet_p4.Pt() >>tmp(40,0,400)") drawPlot(createPlot(td), name + "met_log", "Uncorrected PF ^{}E_{T}^{miss} (GeV)", ylabel="Events / %.0f GeV") td = tdMuon.clone( varexp= "sqrt(2 * muons_p4.Pt() * pfMet_p4.Et() * (1-cos(muons_p4.Phi()-pfMet_p4.Phi()))) >>tmp(40,0,400)" ) drawPlot(createPlot(td), name + "mt_log", "m_{T}(#mu, ^{}E_{T}^{miss}) (GeV/^{}c^{2})", ylabel="Events / %.0f GeV/^{}c^{2}")
if outputDir is not None: outputDir += "_embdatamc" doPlots(datasetsEmb, outputDir) tauEmbedding.writeToFile(outputDir, "input.txt", "Embedded: %s\n" % os.getcwd()) drawPlotCommon = plots.PlotDrawer( ylabel="Events / %.0f", stackMCHistograms=True, log=True, addMCUncertainty=True, opts2={ "ymin": 0, "ymax": 2 }, ratio=True, ratioType="errorScale", ratioCreateLegend=True, ratioYlabel="Data/Sim.", ratioErrorOptions={"numeratorStatSyst": False}, addLuminosityText=True) def doPlots(datasetsEmb, outputDir): lumi = datasetsEmb.getDataset("Data").getLuminosity() def createPlot(name): # p = plots.DataMCPlot(datasetsEmb, systematicsEmbMC.histogram(name), normalizeToLumi=lumi) drhData = datasetsEmb.getDataset("Data").getDatasetRootHisto(name)
def doPlots(datasets, datasetName, selectionName, ntupleCache): createPlot = PlotCreator(datasets, datasetName, ntupleCache) drawPlot = plots.PlotDrawer(addMCUncertainty=True, log=True, stackMCHistograms=False, ratio=True, ratioInvert=True, optsLog={"ymin": 1e-1}, opts2={ "ymin": 0.9, "ymax": 1.02 }) def customize(p): p.setRatios([ plots._createRatio(p.numeratorRaw, p.denominatorRaw, ytitle="Fraction", isBinomial=True) ]) def createDrawPlot(histo, fname, xlabel, **kwargs): p = createPlot(histo) drawPlot(p, fname, xlabel, customizeBeforeDraw=customize, **kwargs) #opts2def = {"DYJetsToLL": {"ymin":0, "ymax": 1.5}}.get(datasetName, {"ymin": 0.9, "ymax": 1.02}) #moveLegend = {"DYJetsToLL": {"dx": -0.02}}.get(datasetName, {}) opts2def = {} moveLegend = {} if selectionName != "TauLike": opts2def["ymin"] = 0.98 opts2def["ymax"] = 1.005 prefix = "muiso_" + selectionName + "_" postfix = "_" + datasetName opts2 = opts2def createDrawPlot("tauPt", prefix + "TauPt" + postfix, "#tau-jet p_{T} (GeV/c)", ylabel="Events / %.0f GeV/c", opts2=opts2, cutLine=40, moveLegend=moveLegend) createDrawPlot("tauEta", prefix + "TauEta" + postfix, "#tau-jet #eta", ylabel="Events / %.1f", opts2=opts2, cutLine=[-2.1, 2.1], moveLegend=moveLegend) createDrawPlot("tauPhi", prefix + "TauPhi" + postfix, "#tau-jet #phi", ylabel="Events / %.1f", opts2=opts2, moveLegend=moveLegend) createDrawPlot("tauLeadingTrackPt", prefix + "TauLeadingTrackPt" + postfix, "#tau-jet leading ch. cand. p_{T} (GeV/c)", ylabel="Events / %.0f GeV/c", opts2=opts2, cutLine=20, moveLegend=moveLegend) createDrawPlot("tauRtau", prefix + "TauRtau" + postfix, "#tau-jet R_{#tau}", ylabel="Events / %.1f", opts2=opts2, cutLine=0.7, moveLegend=moveLegend) createDrawPlot("vertexCount", prefix + "VertexCount" + postfix, "Number of good PV", ylabel="Events / %.0f", opts2=opts2, moveLegend=moveLegend)
def doSignifPlots(p, drawPlot, datasets, histo, hName, xLabel, yLabel, saveName, cutDir): ''' def doSignifPlots(p, drawPlot, datasets, histo, hName, xLabel, yLabel, saveName, CutDir): ''' nDataDatasets = len(datasets.getDataDatasets()) nMCDatasets = len(datasets.getMCDatasets()) if nMCDatasets < 1: print "*** WARNING: No MC datasets found. Skipping significance plots." return if cutDir == "<": saveName = saveName + "_SignifLessThan" saveName = saveName.replace("/", "_") MyIntegral = lambda h, bin: h.Integral(0, bin) elif cutDir == ">": saveName = saveName + "_SignifGreaterThan" saveName = saveName.replace("/", "_") MyIntegral = lambda h, bin: h.Integral(bin, nBins) else: print "%sERROR! Unsupported cut-direction string %s used. Exiting ROOT" % ( cutDir) sys.exit() yLabel = "Significance" + "(" + cutDir + ")" # Legend and save-name histograms.createLegend.setDefaults(x1=0.65, x2=0.90, y1=0.8, y2=0.92) ### Setup the histogram text mode and create plot histograms.cmsTextMode = histograms.CMSMode.SIMULATION p2 = createTH1Plot(datasets, hName, normalizeToOne=False) ### Construct an empty histogram (same binning as variable distribution) hBinSignif = p.histoMgr.getHisto( "TTToHplus_M" + signalMass).getRootHisto().Clone(saveName + "_Clone") hBinSignif.Reset() nBinsX = hBinSignif.GetNbinsX() nBins = nBinsX + 1 ### Loop over all histogram bins for iBin in xrange(0, nBins): ### Initialise variables to be used in Significance calculation nSignal = 0 nBackgr = 0 signifError = 0 signifValue = 0 # Loop over all histograms to determine the number of signal and bkg events to calculate significance for htmp in p.histoMgr.getHistos(): h = htmp.getRootHisto() name = htmp.getName() if ("Data" in name or "sum_errors" in name): continue elif ("TTToHplus_M" + signalMass in name): #print "*** Signal-Histo = ", (name) nSignal = MyIntegral(h, iBin) else: if name == "StackedMC": hStackedMC = p.histoMgr.getHisto( "StackedMC").getRootHisto().Clone("hStackedMC_Clone") for htmp in hStackedMC.GetHists(): name = htmp.GetName() if ("MCuncertainty") in name: continue #print "*** Bkg-Histo = ", (name) nBackgr += MyIntegral(htmp, iBin) eBackgr = 0 #FIXME else: if ("MCuncertainty") in name: continue #print "*** Bkg-Histo = ", (name) nBackgr += MyIntegral(h, iBin) eBackgr = 0 #FIXME if nSignal < 9e-04: nSignal = 0.0 if nBackgr > 0: #FIXME signifValue = math.sqrt( 2 * ((nSignal + nBackgr) * math.log(1 + (nSignal / nBackgr)) - nSignal)) #G. Cowan (sysErrorBackgr=0) signifError = 0.0001 #FIXME else: signifValue = 0 signifError = 0.0001 #FIXME # Calculate error on significance if nSignal > 0 and nBackgr > 0: #signifErrorSquared = ( (1+2*math.log(1+nSignal/nBackgr)/(2*signifValue) )**2)*nSignal + ( ( (2*math.log(1+nSignal/nBackgr) - 2*nSignal/nBackgr)/(2*signifValue**2) )**2)**nBackgr #signifErrorSquared = ((signifValue/nSignal)**2)*nSignal + ((0.5*(signifValue/nBackgr))**2)*nBackgr #signifError = math.sqrt(signifErrorSquared) signifError = 0.0001 else: signifError = 0.0001 #print " nSignal = %s, nBackgr = %s, signifValue = %s, signifError = %s" % (nSignal, nBackgr, signifValue, signifError) #attikis #print "*** iBin=%s ; Sig=%s ; S=%s ; B=%s" % (iBin, signifValue, nSignal, nBackgr) hBinSignif.SetBinContent(iBin, signifValue) hBinSignif.SetBinError(iBin, signifError) # Loop over histograms and remove all histos for htmp in p2.histoMgr.getHistos(): h = htmp.getRootHisto() name = htmp.getName() if name == "StackedMC": hStackedMC = p.histoMgr.getHisto("StackedMC").getRootHisto().Clone( "hStackedMC_Clone") for htmp in hStackedMC.GetHists(): p2.histoMgr.removeHisto(name) else: p2.histoMgr.removeHisto(name) ### Add the significance plots to the histo-manager h = histograms.Histo(setSignificanceHistoStyle(hBinSignif), " m_{H^{#pm}} = " + signalMass + " GeV/c^{2}", "HP", "HP") h.setIsDataMC(False, True) p2.histoMgr.appendHisto(h) ### Draw the plot with custom options and save drawPlot = plots.PlotDrawer(stackMCHistograms=False, addMCUncertainty=False, log=False, ratio=False, addLuminosityText=True, opts={"ymaxfactor": 1.2}) drawPlot(p2, saveName, xlabel=histo.xlabel, ylabel=yLabel, rebinToWidthX=histo.binWidthX, cutLine=getHistoCutLines(histo)) return
def doPlots(datasets, histoDict, MyCuts, SaveExtension): ''' doPlots(datasets, histoDict, MyCuts, SaveExtension): This module takes the "histoDict" dictionary (which maps the histogram names and tree expressions) and the TCut expression "MyCuts" to first create and then plot the histograms, using the given "datasets". The "SaveExtension" is the string attached to the name all plotted histograms, primarily to distinguish the plot type. ''' def createPlot(name, **kwargs): ''' createPlot(name, **kwargs): This module is used to create the histograms for the given "name". The user can pass arguments including the histogram name, expression, labels, cut boxes etc.. ''' if mcOnly: ### If 'normalizeToOne' is given in kwargs, we don't need the normalizeToLumi (or actually the library raises an Exception) args = {} args.update(kwargs) if not ("normalizeToOne" in args and args["normalizeToOne"]): args["normalizeToLumi"] = mcOnlyLumi p = plots.MCPlot(datasets, name, **args) p.histoMgr.setHistoLegendStyleAll("L") return p else: p = plots.DataMCPlot(datasets, name, **kwargs) return p p.setDefaultStyles() return p ### Function returns a progress bar object (pBar) and a CallBack(int, int) function maxValue = len(histoDict) print "*** Preparing %s histogram(s) for the cut group:\n %s" % (maxValue, MyCuts) ### Create a progress bar to inform user of progress status pBar = StartProgressBar(maxValue) ### Customise my plots if mcOnly: drawPlot = plots.PlotDrawer(stackMCHistograms=False, addMCUncertainty=True, log=bLogY, ratio=False, addLuminosityText= not bNormalizeToOne, ratioYlabel="Ratio", optsLog={"ymin": yMin}, opts2={"ymin": yMinRatio, "ymax": yMaxRatio}) else: drawPlot = plots.PlotDrawer(stackMCHistograms=True, addMCUncertainty=True, log=bLogY, ratio=True, addLuminosityText=True, ratioYlabel="Ratio", optsLog={"ymin": yMin}, opts2={"ymin": yMinRatio, "ymax": yMaxRatio}) ### Define the tree to be used with the given cuts if "passedBTagging" in MyCuts: EvtWeight = "(weightPileup*weightTrigger*weightPrescale*weightBTagging)"; else: EvtWeight = "weightPileup*weightTrigger*weightPrescale" print "*** Drawing tree with event weight:\n %s" % (EvtWeight) treeDraw = dataset.TreeDraw("tree", weight=EvtWeight) MyTreeDraw = treeDraw.clone(selection=MyCuts) ### Loop over all hName and expressions in the dictionary "histoDict" counter=0 for hName in histoDict: #print "*** Plotting \"%s\": %s" % (hName, histoDict[hName]) histo = MyTreeDraw.clone(varexp=histoDict[hName]) if mcOnly: drawPlot(createPlot(histo, normalizeToOne = bNormalizeToOne), "%s_%s" % (hName, SaveExtension), hName, ylabel="Events / %.1f ", cutBox={"cutValue":0.0, "greaterThan":True}) else: drawPlot(createPlot(histo, normalizeToOne = False), "%s_%s" % (hName, SaveExtension), hName, ylabel="Events / %.1f ", cutBox={"cutValue":0.0, "greaterThan":True}) # Increment counter and pdate progress bar counter = counter+1 pBar.update(counter) ### Stop pbar once done with the loop pBar.finish()
dop("SingleTop", mtOnly=False) dop("Diboson", mtOnly=False) # dop("DYJetsToLL", mtOnly=True) # dop("SingleTop", mtOnly=True) # dop("Diboson", mtOnly=True) #drawPlotCommon = tauEmbedding.PlotDrawerTauEmbeddingEmbeddedNormal(ylabel="Events / %.0f GeV", stackMCHistograms=False, log=True, addMCUncertainty=True, ratio=True, addLuminosityText=True) drawPlotCommon = plots.PlotDrawer(ylabel="Events / %.0f", stackMCHistograms=False, log=True, addMCUncertainty=True, ratio=True, ratioType="errorScale", ratioCreateLegend=True, opts2={ "ymin": 0, "ymax": 2 }, addLuminosityText=True, errorBarsX=True) def strIntegral(th1): return "%.1f" % aux.th1Integral(th1) def doPlots(datasetsEmb, datasetsSig, datasetName,
def doPlots(myDsetMgr, opts, mySuffix): # Create the plot objects and pass them to the formatting # functions to be formatted, drawn and saved to files drawPlot = plots.PlotDrawer(ylabel="N_{events}", log=True, ratio=True, ratioYlabel="Data/MC", opts2={ "ymin": 0, "ymax": 2 }, stackMCHistograms=True, addMCUncertainty=True, addLuminosityText=True) global plotIndex plotIndex = 1 def createDrawPlot(name, moveSignalText={}, fullyBlinded=False, addBlindedText=True, moveBlindedText={}, **kwargs): # Create the plot object print "Creating plot:", name args = {} if mcOnly: args["normalizeToLumi"] = mcOnlyLumi p = plots.DataMCPlot(myDsetMgr, name, **args) # Remove data if fully blinded if not mcOnly and fullyBlinded and p.histoMgr.hasHisto("Data"): p.histoMgr.removeHisto("Data") if addBlindedText: tb = histograms.PlotTextBox(xmin=0.4, ymin=None, xmax=0.6, ymax=0.84, size=17) tb.addText("Data blinded") tb.move(**moveBlindedText) p.appendPlotObject(tb) # Add the signal information text box if not opts.noSignal: st = histograms.createSignalText() st.move(**moveSignalText) p.appendPlotObject(st) # Set the file name global plotIndex filename = "%s/%03d_%s" % (mySuffix, plotIndex, name.replace("/", "_")) plotIndex += 1 # Draw the plot drawPlot(p, filename, **kwargs) # common arguments for plots which make sense only for MC mcArgs = {"fullyBlinded": True, "addBlindedText": False} # Common plots myCommonPlotDirs = [ "VertexSelection", "TauSelection", "TauWeight", "ElectronVeto", "MuonVeto", "JetSelection", "MET", "BTagging", "Selected", "FakeTaus_BTagging", "FakeTaus_Selected" ] def createDrawCommonPlot(path, **kwargs): for plotDir in myCommonPlotDirs: args = {} args.update(kwargs) if "transverseMass" in path: if "BTagging" in plotDir or "Selected" in plotDir: args[ "customizeBeforeFrame"] = lambda p: plots.partiallyBlind( p, maxShownValue=60) elif "Selected" in plotDir: args["fullyBlinded"] = True if "FakeTaus" in plotDir: args.update(mcArgs) createDrawPlot(path % plotDir, **args) #phiBinWidth = 2*3.14159/72 phiBinWidth = 2 * 3.14159 / 36 myDirs = [ "NormalisationAnalysis/DYEnrichedWithGenuineTaus", "NormalisationAnalysis/DYEnrichedWithFakeTaus", "NormalisationAnalysis/WJetsEnrichedWithGenuineTaus", "NormalisationAnalysis/WJetsEnrichedWithFakeTaus", "NormalisationAnalysis/TTJetsEnrichedWithGenuineTaus", "NormalisationAnalysis/TTJetsEnrichedWithFakeTaus" ] for myDir in myDirs: createDrawPlot(myDir + "/tauPt", xlabel="#tau p_{T}, GeV/c") createDrawPlot(myDir + "/nJets", xlabel="N_{jets}") createDrawPlot(myDir + "/met", xlabel="E_{T}^{miss}, GeV") createDrawPlot(myDir + "/metPhi", xlabel="E_{T}^{miss} #phi, GeV") createDrawPlot(myDir + "/nBJets", xlabel="N_{b jets}") createDrawPlot(myDir + "/transverseMass", xlabel="m_T(#tau,E_{T}^{miss}), GeV/c^{2}") createDrawPlot(myDir + "/zMass", xlabel="m_Z(#ell#ell), GeV/c^{2}") createDrawPlot(myDir + "/fakeTauTauPt", xlabel="#tau p_{T}, GeV/c") createDrawPlot(myDir + "/fakeTauNJets", xlabel="N_{jets}") createDrawPlot(myDir + "/fakeTauMet", xlabel="E_{T}^{miss}, GeV") createDrawPlot(myDir + "/fakeTauMetPhi", xlabel="E_{T}^{miss} #phi, GeV") createDrawPlot(myDir + "/fakeTauNBJets", xlabel="N_{b jets}") createDrawPlot(myDir + "/fakeTauTransverseMass", xlabel="m_T(#tau,E_{T}^{miss}), GeV/c^{2}") createDrawPlot(myDir + "/fakeTauZMass", xlabel="m_Z(#ell#ell), GeV/c^{2}")
def doPlots(datasets, histoDict, MyCuts, SaveExtension): ''' doPlots(datasets, histoDict, MyCuts, SaveExtension): This module takes the "histoDict" dictionary (which maps the histogram names and tree expressions) and the TCut expression "MyCuts" to first create and then plot the histograms, using the given "datasets". The "SaveExtension" is the string attached to the name all plotted histograms, primarily to distinguish the plot type. ''' # Function to create the plots def createPlot(name, **kwargs): ''' createPlot(name, **kwargs): This module is used to create the histograms for the given "name". The user can pass arguments including the histogram name, expression, labels, cut boxes etc.. ''' p = plots.DataMCPlot(datasets, name, **kwargs) p.setDefaultStyles() return p print "\n*** Cuts to be applied: %s" % (MyCuts) # Function returns a progress bar object (pBar) and a CallBack(int, int) function maxValue = len(histoDict) print "*** Preparing %s histogram(s) for the given cut group" % (maxValue) # Create a progress bar to inform user of progress status pBar = StartProgressBar(maxValue) # Customise my plots drawPlot = plots.PlotDrawer(stackMCHistograms=True, addMCUncertainty=True, log=True, ratio=False, addLuminosityText=True, ratioYlabel="Ratio", optsLog={"ymin": 1e-1}, opts2={ "ymin": 0, "ymax": 2 }) # Define the tree to be used with the standard cuts MyTreeDraw = treeDraw.clone(selection=MyCuts) # Loop over all hName and expressions in the dictionary "histoDict" counter = 0 for hName in histoDict: #print "*** Plotted \"%s\": %s" % (hName, histoDict[hName]) histo = MyTreeDraw.clone(varexp=histoDict[hName]) drawPlot(createPlot(histo), "%s_%s" % (hName, SaveExtension), hName, ylabel="Events / %.1f ", cutBox={ "cutValue": 0.0, "greaterThan": True }) # Increment counter and pdate progress bar counter = counter + 1 pBar.update(counter) # Stop pbar once done with the loop pBar.finish()
def doPlots(myDsetMgr, opts, mySuffix, isSystematicVariation): # Create the plot objects and pass them to the formatting # functions to be formatted, drawn and saved to files drawPlot = plots.PlotDrawer(ylabel="N_{events}", log=True, ratio=True, ratioYlabel="Data/MC", opts2={"ymin": 0, "ymax": 2}, stackMCHistograms=True, addMCUncertainty=True, addLuminosityText=True) global plotIndex plotIndex = 1 def createDrawPlot(name, moveSignalText={}, fullyBlinded=False, addBlindedText=True, moveBlindedText={}, forSystVar=False, **kwargs): if isSystematicVariation and not forSystVar: return # Create the plot object print "Creating plot:",name args = {} if mcOnly: args["normalizeToLumi"] = mcOnlyLumi p = plots.DataMCPlot(myDsetMgr, name, **args) # Remove data if fully blinded if not mcOnly and fullyBlinded and p.histoMgr.hasHisto("Data"): p.histoMgr.removeHisto("Data") if addBlindedText: tb = histograms.PlotTextBox(xmin=0.4, ymin=None, xmax=0.6, ymax=0.84, size=17) tb.addText("Data blinded") tb.move(**moveBlindedText) p.appendPlotObject(tb) # Add the signal information text box if not opts.noSignal: st = histograms.createSignalText() st.move(**moveSignalText) p.appendPlotObject(st) # Set the file name global plotIndex filename = "%s/%03d_%s"%(mySuffix, plotIndex, name.replace("/", "_")) plotIndex += 1 # Draw the plot drawPlot(p, filename, **kwargs) # common arguments for plots which make sense only for MC mcArgs = {"fullyBlinded": True, "addBlindedText": False, "ratio": False} # Common plots myCommonPlotDirs = ["TauSelection","TauWeight","ElectronVeto","MuonVeto","JetSelection","MET","BTagging","Selected","FakeTaus_BTagging","FakeTaus_Selected"] def createDrawCommonPlot(path, **kwargs): for plotDir in myCommonPlotDirs: args = {} if opts.blind: if "transverseMass" in path: if "BTagging" in plotDir or "Selected" in plotDir: args["customizeBeforeFrame"] = lambda p: plots.partiallyBlind(p, maxShownValue=60) elif "fullMass" in path: if "JetSelection" in plotDir or "MET" in plotDir or "BTagging" in plotDir or "Selected" in plotDir: args["customizeBeforeFrame"] = lambda p: plots.partiallyBlind(p, minShownValue=80, maxShownValue=180, invert=True) elif "Selected" in plotDir: args["fullyBlinded"] = True if "FakeTaus" in plotDir: args.update(mcArgs) args.update(kwargs) createDrawPlot(path%plotDir, **args) #phiBinWidth = 2*3.14159/72 phiBinWidth = 2*3.14159/36 #createDrawPlot("CommonPlots/AtEveryStep/Trigger/nVertices", xlabel="N_{Vertices}") if True: createDrawCommonPlot("CommonPlots/AtEveryStep/%s/nVertices", xlabel="N_{Vertices}") createDrawCommonPlot("CommonPlots/AtEveryStep/%s/tau_fakeStatus", xlabel="Fake tau status", **mcArgs) createDrawCommonPlot("CommonPlots/AtEveryStep/%s/tau_pT", xlabel="#tau p_{T}, GeV/c", rebinToWidthX=20) createDrawCommonPlot("CommonPlots/AtEveryStep/%s/tau_eta", xlabel="#tau #eta") createDrawCommonPlot("CommonPlots/AtEveryStep/%s/tau_phi", xlabel="#tau #phi", rebinToWidthX=phiBinWidth) createDrawCommonPlot("CommonPlots/AtEveryStep/%s/tau_Rtau", xlabel="R_{#tau}", rebinToWidthX=0.05, opts={"xmin": 0.5, "xmax": 1}, moveLegend={"dx": -0.5}) createDrawCommonPlot("CommonPlots/AtEveryStep/%s/electrons_N", xlabel="N_{electrons}") createDrawCommonPlot("CommonPlots/AtEveryStep/%s/muons_N", xlabel="N_{muons}") createDrawCommonPlot("CommonPlots/AtEveryStep/%s/jets_N", xlabel="N_{jets}") createDrawCommonPlot("CommonPlots/AtEveryStep/%s/jets_N_allIdentified", xlabel="N_{all identified jets}") createDrawCommonPlot("CommonPlots/AtEveryStep/%s/MET_Raw", xlabel="Raw MET, GeV", rebinToWidthX=20) createDrawCommonPlot("CommonPlots/AtEveryStep/%s/MET_MET", xlabel="MET, GeV", rebinToWidthX=20) createDrawCommonPlot("CommonPlots/AtEveryStep/%s/MET_phi", xlabel="MET #phi", rebinToWidthX=phiBinWidth) createDrawCommonPlot("CommonPlots/AtEveryStep/%s/bjets_N", xlabel="N_{b jets}", opts={"xmax": 8}) createDrawCommonPlot("CommonPlots/AtEveryStep/%s/DeltaPhi_TauMET", xlabel="#Delta#phi(#tau,MET)") createDrawCommonPlot("CommonPlots/AtEveryStep/%s/hDeltaR_TauMETJet1MET", xlabel="#sqrt{(180^{o}-#Delta#phi(#tau,MET))^{2} + #Delta#phi(MET,jet_{1})^{2}}") createDrawCommonPlot("CommonPlots/AtEveryStep/%s/hDeltaR_TauMETJet2MET", xlabel="#sqrt{(180^{o}-#Delta#phi(#tau,MET))^{2} + #Delta#phi(MET,jet_{2})^{2}}") createDrawCommonPlot("CommonPlots/AtEveryStep/%s/hDeltaR_TauMETJet3MET", xlabel="#sqrt{(180^{o}-#Delta#phi(#tau,MET))^{2} + #Delta#phi(MET,jet_{3})^{2}}") createDrawCommonPlot("CommonPlots/AtEveryStep/%s/hDeltaR_TauMETJet4MET", xlabel="#sqrt{(180^{o}-#Delta#phi(#tau,MET))^{2} + #Delta#phi(MET,jet_{4})^{2}}") createDrawCommonPlot("CommonPlots/AtEveryStep/%s/transverseMass", xlabel="m_{T}(#tau,MET)", rebinToWidthX=20) createDrawCommonPlot("CommonPlots/AtEveryStep/%s/fullMass", xlabel="m_{T}(#tau,MET)", rebinToWidthX=20) myDir = "Vertices" createDrawPlot(myDir+"/verticesBeforeWeight", xlabel="N_{vertices}") createDrawPlot(myDir+"/verticesAfterWeight", xlabel="N_{vertices}") #createDrawPlot(myDir+"/verticesTriggeredBeforeWeight", xlabel="N_{vertices}") #createDrawPlot(myDir+"/verticesTriggeredAfterWeight", xlabel="N_{vertices}") myDir = "TauSelection" createDrawPlot(myDir+"/N_TriggerMatchedTaus", xlabel="N_{trg. matched taus}") createDrawPlot(myDir+"/N_TriggerMatchedSeparateTaus", xlabel="N_{trg. matched separate taus}") createDrawPlot(myDir+"/TauCand_DecayModeFinding", xlabel="HPS Decay Mode", opts={"xmax": 16, "nbinsx": 16}, customizeBeforeDraw=tauEmbedding.decayModeCheckCustomize) createDrawPlot(myDir+"/TauSelection_all_tau_candidates_N", xlabel="N_{tau candidates}", opts={"xmax": 8}) createDrawPlot(myDir+"/TauSelection_all_tau_candidates_pt", xlabel="p_{T} of all tau candidates, GeV/c", rebinToWidthX=10) createDrawPlot(myDir+"/TauSelection_all_tau_candidates_eta", xlabel="#eta of all tau candiates", rebinToWidthX=0.1) createDrawPlot(myDir+"/TauSelection_all_tau_candidates_phi", xlabel="#phi of all tau candidates", rebinToWidthX=phiBinWidth) createDrawPlot(myDir+"/TauSelection_all_tau_candidates_MC_purity", xlabel="MC purity of all tau candidates", **mcArgs) createDrawPlot(myDir+"/TauCand_JetPt", xlabel="p_{T} of tau candidates, GeV/c", rebinToWidthX=10) createDrawPlot(myDir+"/TauCand_JetEta", xlabel="#eta of tau candidates", rebinToWidthX=0.1) createDrawPlot(myDir+"/TauCand_LdgTrackPtCut", xlabel="p_{T}^{ldg.ch.particle} of tau candidates, GeV/c", rebinToWidthX=10) #createDrawPlot(myDir+"/TauCand_EMFractionCut", xlabel="EM energy fraction of tau candidates") createDrawPlot(myDir+"/TauSelection_cleaned_tau_candidates_N", xlabel="N_{cleaned tau candidates}", opts={"xmax": 8}) createDrawPlot(myDir+"/TauSelection_cleaned_tau_candidates_pt", xlabel="p_{T} of cleaned tau candidates, GeV/c", rebinToWidthX=10) createDrawPlot(myDir+"/TauSelection_cleaned_tau_candidates_eta", xlabel="#eta of cleaned tau candidates", rebinToWidthX=0.1) createDrawPlot(myDir+"/TauSelection_cleaned_tau_candidates_phi", xlabel="#phi of cleaned tau candidates", rebinToWidthX=phiBinWidth) createDrawPlot(myDir+"/TauSelection_cleaned_tau_candidates_MC_purity", xlabel="MC purity of cleaned tau candidates", **mcArgs) createDrawPlot(myDir+"/IsolationPFChargedHadrCandsPtSum", xlabel="#sum p_{T} of PF ch. hadr. candidates, GeV/c", opts={"xmax": 40}) createDrawPlot(myDir+"/IsolationPFGammaCandEtSum", xlabel="#sum p_{T} of PF gamma candidates, GeV/c", opts={"xmax": 40}) createDrawPlot(myDir+"/TauID_NProngsCut", xlabel="N_{prongs}", opts={"xmax": 5}) #createDrawPlot(myDir+"/TauID_ChargeCut", xlabel="Q_{tau}") createDrawPlot(myDir+"/TauID_RtauCut", xlabel="R_{#tau}", rebinToWidthX=0.1) createDrawPlot(myDir+"/TauSelection_selected_taus_N", xlabel="N_{selected taus}", opts={"xmax": 8}) createDrawPlot(myDir+"/TauSelection_selected_taus_pt", xlabel="p_{T} of selected taus", rebinToWidthX=10) createDrawPlot(myDir+"/TauSelection_selected_taus_eta", xlabel="#eta of selected taus", rebinToWidthX=0.1) createDrawPlot(myDir+"/TauSelection_selected_taus_phi", xlabel="#phi of selected taus", rebinToWidthX=phiBinWidth) createDrawPlot(myDir+"/TauSelection_selected_taus_MC_purity", xlabel="MC purity of selected taus", **mcArgs) myDir = "FakeTauIdentifier_TauID" createDrawPlot(myDir+"/TauMatchType", xlabel="MC #tau decay", **mcArgs) createDrawPlot(myDir+"/TauOrigin", xlabel="MC #tau origin", **mcArgs) createDrawPlot(myDir+"/MuOrigin", xlabel="MC #mu origin", **mcArgs) createDrawPlot(myDir+"/ElectronOrigin", xlabel="MC e origin", **mcArgs) myDir = "SelectedTau" createDrawPlot(myDir+"/SelectedTau_pT_AfterTauID", xlabel="p_{T} of selected taus, GeV/c", rebinToWidthX=10) createDrawPlot(myDir+"/SelectedTau_eta_AfterTauID", xlabel="#eta of selected taus", rebinToWidthX=0.1, opts={"xmin": -2.4, "xmax": 2.4}) createDrawPlot(myDir+"/SelectedTau_phi_AfterTauID", xlabel="#phi of selected taus", rebinToWidthX=phiBinWidth) createDrawPlot(myDir+"/SelectedTau_Rtau_AfterTauID", xlabel="R_{#tau} of selected taus", rebinToWidthX=0.1) createDrawPlot(myDir+"/SelectedTau_pT_AfterCuts", xlabel="p_{T} of tau after selections, GeV/c", rebinToWidthX=10) createDrawPlot(myDir+"/SelectedTau_eta_AfterCuts", xlabel="#eta of tau after selections", rebinToWidthX=0.1) createDrawPlot(myDir+"/SelectedTau_Rtau_AfterCuts", xlabel="R_{#tau} of tau after selections", rebinToWidthX=0.1, moveLegend={"dx": -0.5}) myDir = "ElectronSelection" createDrawPlot(myDir+"/ElectronPt_all", xlabel="p_{T} of electron candidates, GeV/c", rebinToWidthX=5) createDrawPlot(myDir+"/ElectronEta_all", xlabel="#eta of electron candidates") createDrawPlot(myDir+"/ElectronPt_veto", xlabel="p_{T}^{veto electron} (GeV/c)", ylabel="Identified electrons / %.0f GeV/c", opts={"xmax": 250,"xmin": 0, "ymaxfactor": 2}, cutLine=15) createDrawPlot(myDir+"/ElectronEta_veto", xlabel="#eta^{veto electron}", ylabel="Identified electrons / %.1f", opts={"xmin": -3,"ymin": 0.1, "xmax": 3, "ymaxfactor": 10}, moveLegend={"dy":0.01, "dx":-0.07, "dh":-0.06}, cutLine=[-2.5, 2.5]) createDrawPlot(myDir+"/NumberOfVetoElectrons", xlabel="Number of selected veto electrons", ylabel="Events", opts={"xmax": 6,"ymaxfactor": 2}) createDrawPlot(myDir+"/ElectronPt_tight", xlabel="p_{T}^{tight electron} (GeV/c)", ylabel="Identified electrons / %.0f GeV/c", opts={"xmax": 250,"xmin": 0, "ymaxfactor": 2}, cutLine=15) createDrawPlot(myDir+"/ElectronEta_tight", xlabel="#eta^{tight electron}", ylabel="Identified electrons / %.1f", opts={"xmin": -3,"ymin": 0.1, "xmax": 3, "ymaxfactor": 10}, moveLegend={"dy":0.01, "dx":-0.07, "dh":-0.06}, cutLine=[-2.5, 2.5]) createDrawPlot(myDir+"/NumberOfTightElectrons", xlabel="Number of selected tight electrons", ylabel="Events", opts={"xmax": 6,"ymaxfactor": 2}, cutLine=1) myDir = "MuonSelection" createDrawPlot(myDir+"/LooseMuonPt", xlabel="p_{T} of #mu candidates, GeV/c", ylabel="N_{muons}", rebinToWidthX=5) createDrawPlot(myDir+"/LooseMuonEta", xlabel="#eta of #mu candidates", ylabel="N_{muons}") createDrawPlot(myDir+"/MuonTransverseImpactParameter", xlabel="IP_{T} of #mu candidates, mm", ylabel="N_{muons}") createDrawPlot(myDir+"/MuonDeltaIPz", xlabel="IP_{z} - PV_{z} of #mu candidates, cm", ylabel="N_{muons}") createDrawPlot(myDir+"/MuonRelIsol", xlabel="#mu rel. isol.", ylabel="N_{muons}") createDrawPlot(myDir+"/NumberOfLooseMuons", xlabel="Number of loose #mus", opts={"xmax": 8}) createDrawPlot(myDir+"/NumberOfTightMuons", xlabel="Number of tight #mus", opts={"xmax": 8}) createDrawPlot(myDir+"/MuonPt_BeforeIsolation", xlabel="#mu p_{T} before isolation, GeV/c") createDrawPlot(myDir+"/MuonEta_BeforeIsolation", xlabel="#mu #eta before isolation") myDir = "JetSelection" createDrawPlot(myDir+"/jet_pt", xlabel="p_{T} of jet candidates, GeV/c", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_pt_central", xlabel="p_{T} of central jet candidates, GeV/c", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_eta", xlabel="#eta of jet candidates", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_phi", xlabel="#phi of jet candidates", ylabel="N_{jets}", rebinToWidthX=phiBinWidth) createDrawPlot(myDir+"/firstJet_pt", xlabel="p_{T} of first jet, GeV/c") createDrawPlot(myDir+"/firstJet_eta", xlabel="#eta of first jet") createDrawPlot(myDir+"/firstJet_phi", xlabel="#phi of first jet", rebinToWidthX=phiBinWidth) createDrawPlot(myDir+"/secondJet_pt", xlabel="p_{T} of second jet, GeV/c") createDrawPlot(myDir+"/secondJet_eta", xlabel="#eta of second jet") createDrawPlot(myDir+"/secondJet_phi", xlabel="#phi of second jet", rebinToWidthX=phiBinWidth) createDrawPlot(myDir+"/thirdJet_pt", xlabel="p_{T} of third jet, GeV/c") createDrawPlot(myDir+"/thirdJet_eta", xlabel="#eta of third jet") createDrawPlot(myDir+"/thirdJet_phi", xlabel="#phi of third jet", rebinToWidthX=phiBinWidth) createDrawPlot(myDir+"/NumberOfSelectedJets", xlabel="N_{selected jets}") createDrawPlot(myDir+"/jet_PUIDmva", xlabel="Jet PU ID MVA output") myDir = "JetSelection/SelectedJets" createDrawPlot(myDir+"/jet_pt", xlabel="p_{T} of accepted jets, GeV/c", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_eta", xlabel="#eta of accepted jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_phi", xlabel="#phi of accepted jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_NeutralEmEnergyFraction", xlabel="NeutralEmEnergyFraction of accepted jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_NeutralHadronEnergyFraction", xlabel="NeutralHadronEnergyFraction of accepted jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_PhotonEnergyFraction", xlabel="PhotonEnergyFraction of accepted jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_ChargedHadronEnergyFraction", xlabel="ChargedEnergyFraction of accepted jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_NeutralHadronMultiplicity", xlabel="NeutralHadronMultiplicity of accepted jets", ylabel="N_{jets}", opts={"xmax": 10}) createDrawPlot(myDir+"/jet_PhotonMultiplicity", xlabel="PhotonMultiplicity of accepted jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_ChargedMultiplicity", xlabel="ChargedMultiplicity of accepted jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_PartonFlavour", xlabel="PartonFlavour of accepted jets", ylabel="N_{jets}", **mcArgs) myDir = "JetSelection/ExcludedJets" createDrawPlot(myDir+"/jet_pt", xlabel="p_{T} of rejected jets, GeV/c", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_eta", xlabel="#eta of rejected jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_phi", xlabel="#phi of rejected jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_NeutralEmEnergyFraction", xlabel="NeutralEmEnergyFraction of rejected jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_NeutralHadronEnergyFraction", xlabel="NeutralHadronEnergyFraction of rejected jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_PhotonEnergyFraction", xlabel="PhotonEnergyFraction of rejected jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_ChargedHadronEnergyFraction", xlabel="ChargedEnergyFraction of rejected jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_NeutralHadronMultiplicity", xlabel="NeutralHadronMultiplicity of rejected jets", ylabel="N_{jets}", opts={"xmax": 10}) createDrawPlot(myDir+"/jet_PhotonMultiplicity", xlabel="PhotonMultiplicity of rejected jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_ChargedMultiplicity", xlabel="ChargedMultiplicity of rejected jets", ylabel="N_{jets}") createDrawPlot(myDir+"/jet_PartonFlavour", xlabel="PartonFlavour of rejected jets", ylabel="N_{jets}", **mcArgs) myDir = "JetSelection/ReferenceJetToTau" createDrawPlot(myDir+"/MatchingDeltaR", xlabel="#DeltaR(#tau,ref.jet)", ylabel="N_{jets}") createDrawPlot(myDir+"/PartonFlavour", xlabel="pdgID", ylabel="N_{jets}", **mcArgs) createDrawPlot(myDir+"/PtRatio", xlabel="p_{T}^{#tau} / p_{T}^{ref.jet}", ylabel="N_{jets}") myDir = "MET" createDrawPlot(myDir+"/met", xlabel="MET, GeV", ylabel="N_{events}", rebin=4) createDrawPlot(myDir+"/metPhi", xlabel="MET #phi", rebinToWidthX=phiBinWidth) createDrawPlot(myDir+"/metSignif", xlabel="MET significance") createDrawPlot(myDir+"/metSumEt", xlabel="MET #sum E_{T}, GeV") myDir = "Btagging" createDrawPlot(myDir+"/NumberOfBtaggedJets", xlabel="N_{selected b jets}") createDrawPlot(myDir+"/jet_bdiscriminator", xlabel="b-taggind discriminator", ylabel="N_{jets}") createDrawPlot(myDir+"/bjet_pt", xlabel="p_{T} of selected b jets, GeV/c", ylabel="N_{jets}") createDrawPlot(myDir+"/bjet_eta", xlabel="#eta of selected b jets", ylabel="N_{jets}") createDrawPlot(myDir+"/bjet1_pt", xlabel="p_{T} of first b jets, GeV/c", ylabel="N_{jets}") createDrawPlot(myDir+"/bjet1_eta", xlabel="#eta of first b jets", ylabel="N_{jets}") createDrawPlot(myDir+"/bjet2_pt", xlabel="p_{T} of second b jets, GeV/c", ylabel="N_{jets}") createDrawPlot(myDir+"/bjet2_eta", xlabel="#eta of second b jets", ylabel="N_{jets}") createDrawPlot(myDir+"/MCMatchForPassedJets", xlabel="MCMatchForPassedJets", ylabel="N_{jets}") myDir = "TauFakeRate/eToTau" createDrawPlot(myDir+"/etotau_mZ_all", xlabel="m_{ee} / GeV/c^{2}") createDrawPlot(myDir+"/etotau_mZ_decayMode0", xlabel="m_{ee} / GeV/c^{2}") createDrawPlot(myDir+"/etotau_mZ_decayMode1", xlabel="m_{ee} / GeV/c^{2}") createDrawPlot(myDir+"/etotau_mZ_decayMode2", xlabel="m_{ee} / GeV/c^{2}") createDrawPlot(myDir+"/etotau_taupT_all", xlabel="#tau p_{T} / GeV/c") createDrawPlot(myDir+"/etotau_taupT_decayMode0", xlabel="#tau p_{T} / GeV/c") createDrawPlot(myDir+"/etotau_taupT_decayMode1", xlabel="#tau p_{T}/ GeV/c") createDrawPlot(myDir+"/etotau_taupT_decayMode2", xlabel="#tau p_{T} / GeV/c") # Data driven control plots myDir = "ForDataDrivenCtrlPlots" createDrawPlot(myDir+"/Njets", forSystVar=True, xlabel="N_{jets}") createDrawPlot(myDir+"/NjetsAfterJetSelectionAndMETSF", forSystVar=True, xlabel="N_{jets}") for i in range (1,4): createDrawPlot(myDir+"/ImprovedDeltaPhiCutsJet%dCollinear"%i, forSystVar=True, xlabel="#sqrt{(#Delta#phi(#tau,MET))^{2}+(180^{o}-#Delta#phi(jet_{%d},MET))^{2}}"%i) createDrawPlot(myDir+"/SelectedTau_pT_AfterStandardSelections", xlabel="#tau p_{T} / GeV/c") createDrawPlot(myDir+"/SelectedTau_eta_AfterStandardSelections", xlabel="#tau #eta") createDrawPlot(myDir+"/SelectedTau_phi_AfterStandardSelections", xlabel="#tau #phi") createDrawPlot(myDir+"/SelectedTau_LeadingTrackPt_AfterStandardSelections", xlabel="#tau ldg. ch. particle p_{T} / GeV/c") createDrawPlot(myDir+"/SelectedTau_Rtau_AfterStandardSelections", xlabel="R_{#tau}") createDrawPlot(myDir+"/SelectedTau_pT_AfterStandardSelections", xlabel="#tau p_{T} / GeV/c") createDrawPlot(myDir+"/SelectedTau_p_AfterStandardSelections", xlabel="#tau p / GeV/c") createDrawPlot(myDir+"/SelectedTau_LeadingTrackP_AfterStandardSelections", xlabel="#tau ldg. ch. particle p / GeV/c") createDrawPlot(myDir+"/Njets_AfterStandardSelections", xlabel="N_{jets}") createDrawPlot(myDir+"/MET", forSystVar=True, xlabel="MET / GeV", rebinToWidthX=20) createDrawPlot(myDir+"/NBjets", forSystVar=True, xlabel="N_{b jets}") for i in range (1,4): createDrawPlot(myDir+"/ImprovedDeltaPhiCutsJet%dBackToBack"%i, forSystVar=True, xlabel="#sqrt{(180^{o}-#Delta#phi(#tau,MET))^{2}+(#Delta#phi(jet_{%d},MET))^{2}}"%i) # Final shapes createDrawPlot("shapeTransverseMass", forSystVar=True, xlabel="Transverse mass, GeV/c^{2}", ylabel="N_{events}", rebinToWidthX=20, customizeBeforeFrame=lambda p: plots.partiallyBlind(p, maxShownValue=60)) createDrawPlot("shapeEWKFakeTausTransverseMass", forSystVar=True, xlabel="Transverse mass EWK fake taus, GeV/c^{2}", ylabel="N_{events}", rebin=10, **mcArgs) createDrawPlot("shapeInvariantMass", forSystVar=True, xlabel="Invariant mass, GeV/c^{2}", ylabel="N_{events}", rebin=4, fullyBlinded=True) createDrawPlot("shapeEWKFakeTausInvariantMass", forSystVar=True, xlabel="Invariant mass EWK fake taus, GeV/c^{2}", ylabel="N_{events}", rebin=4, **mcArgs) # main directory createDrawPlot("deltaPhi", xlabel="#Delta#phi(#tau jet, MET), ^{o}", ylabel="N_{events}", rebin=20) createDrawPlot("alphaT", xlabel="#alpha_{T}", opts={"xmax": 2}, customizeBeforeFrame=lambda p: plots.partiallyBlind(p, maxShownValue=0.5)) #createDrawPlot("deltaPhiJetMet", xlabel="min #Delta#phi(jet, MET), ^{o}", fullyBlinded=True) #createDrawPlot("maxDeltaPhiJetMet", xlabel="max #Delta#phi(#tau jet, MET), ^{o}", fullyBlinded=True) createDrawPlot("SignalSelectionFlow", xlabel="Step", opts={"xmax": 7}) #createDrawPlot("SignalSelectionFlowVsVertices"", xlabel="N_{vertices}", ylabel="Step",) #createDrawPlot("SignalSelectionFlowVsVerticesFakeTaus", xlabel="N_{vertices}", ylabel="Step") # Normalization plots myNormalizationPlotDirs = myDsetMgr.getDataset("Data").getDirectoryContent("NormalisationAnalysis") def createDrawNormalizationPlots(path, **kwargs): for plotDir in myNormalizationPlotDirs: args = {} args.update(kwargs) createDrawPlot(path%plotDir, **args) createDrawNormalizationPlots("NormalisationAnalysis/%s/tauPt", xlabel="#tau p_{T} / GeV/c") createDrawNormalizationPlots("NormalisationAnalysis/%s/nJets", xlabel="N_{jets}") createDrawNormalizationPlots("NormalisationAnalysis/%s/met", xlabel="MET / GeV") createDrawNormalizationPlots("NormalisationAnalysis/%s/metPhi", xlabel="MET #phi") createDrawNormalizationPlots("NormalisationAnalysis/%s/nBJets", xlabel="N_{b jets}") createDrawNormalizationPlots("NormalisationAnalysis/%s/transverseMass", xlabel="m_{T}(#tau,MET) / GeV/c^{2}") createDrawNormalizationPlots("NormalisationAnalysis/%s/zMass", xlabel="m_{Z} / GeV/c^{2}") createDrawNormalizationPlots("NormalisationAnalysis/%s/HplusPt", xlabel="p_{T}(H+) / GeV/c")
def doTH1Plots(datasets, histoDict, xLabelDict, yLabelDict, MyCuts, SaveExtension): ''' def doTH1Plots(datasets, histoDict, xLabelDict, yLabelDict, MyCuts, SaveExtension): ''' ### Create a progress bar to inform user of progress status. Calculate the number of TH1 histos only maxValue = 0 for key in histoDict: if "_Vs_" in key: continue else: maxValue += 1 if bDataMinusEwk==True and bMcOnly==False: maxValue= maxValue*2 if maxValue==0: print "*** NOTE! No TH1 histos to plot. Exiting doTH1Plots() module." return print "\n*** Preparing %s TH1 histogram(s) for the cut group:\n \"%s\"" % (maxValue, MyCuts) pBar = StartProgressBar(maxValue) if bCustomRange: drawPlot = plots.PlotDrawer(stackMCHistograms=bStackHistos, addMCUncertainty=bAddMCUncertainty, log=bLogY, ratio=not bMcOnly, addLuminosityText=bAddLumiText, ratioYlabel="Ratio", opts={"ymin": yMin, "ymax": yMax}, opts2={"ymin": yMinRatio, "ymax": yMaxRatio}, optsLog={"ymin": yMinLog, "ymax": yMaxLog}) else: drawPlot = plots.PlotDrawer(stackMCHistograms=bStackHistos, addMCUncertainty=bAddMCUncertainty, log=bLogY, ratio=bStackHistos, addLuminosityText=bAddLumiText, opts={"ymaxfactor": yMaxFactor}, opts2={"ymin": yMinRatio, "ymax": yMaxRatio}, optsLog={"ymin": yMinLog, "ymaxfactor": yMaxFactor}) ### Define the event "weight" to be used if "passedBTagging" in MyCuts: #EvtWeight = "(weightPileup*weightTrigger*weightPrescale*weightBTagging)" EvtWeight = "(weightPileup*weightTauTrigger*weightPrescale*weightBTagging)" else: #EvtWeight = "weightPileup*weightTrigger*weightPrescale" EvtWeight = "weightPileup*weightTauTrigger*weightPrescale" print "*** And Event weight:\n \"%s\"" % (EvtWeight) treeDraw = dataset.TreeDraw("tree", weight=EvtWeight) MyTreeDraw = treeDraw.clone(selection=MyCuts) ### Loop over all hName and expressions in the histogram dictionary "histoDict". Create & Draw plot counter=0 for key in histoDict: if "_Vs_" in key: continue hName = key histo = MyTreeDraw.clone(varexp=histoDict[hName]) fileName = "%s_%s" % (hName, SaveExtension) xLabel = xLabelDict[hName] yLabel = yLabelDict[hName] ### Go ahead and draw the plot p = createTH1Plot(datasets, histo, normalizeToOne = bNormalizeToOne) drawPlot(p, fileName, rebin=1, xlabel=xLabel, ylabel=yLabel) ### Increment counter and pdate progress bar counter = counter+1 pBar.update(counter) ### Do Data plots with QCD= Data-Ewk_MC. Only executed if certain (boolean) conditions are met. doDataMinusEWk(p, drawPlot, datasets, counter, histo, hName, xLabel, yLabel, SaveExtension) pBar.update(counter) ### Stop pbar once done with the loop pBar.finish() return
def doPlots(datasets, selectionName, ntupleCache, selectorName): def createPlot(name, **kwargs): args = kwargs.copy() if mcOnly: args["normalizeToLumi"] = mcLuminosity return plots.DataMCPlot(datasets, ntupleCache.histogram(name, selectorName), **args) drawPlot = plots.PlotDrawer( stackMCHistograms=True, addMCUncertainty=True, log=True, ratio=not mcOnly, addLuminosityText=True, ratioYlabel="Ratio", optsLog={"ymin": 1e-1}, opts2={ "ymin": 0, "ymax": 2 }, #opts2={"ymin": 0.6, "ymax": 1.4}, ) metBinning = range(0, 200, 10) + range(200, 300, 20) + [300, 350, 400] ptBinning = range(0, 40, 10) + [41] + range(50, 200, 10) + range( 200, 400, 20) zoomedOpts2 = {"ymin": 0.6, "ymax": 1.4} prefix = era + "_" + selectionName + "_" drawPlot(createPlot("selectedMuonPt_AfterJetSelection"), prefix + "muon_pt_log", "Muon p_{T} (GeV/c)", ylabel="dN/dp_{T} / %.0f-%.0f GeV/c", cutBox={ "cutValue": 41, "greaterThan": True }, rebin=ptBinning, divideByBinWidth=True, opts2=zoomedOpts2) drawPlot(createPlot("selectedMuonEta_AfterJetSelection"), prefix + "muon_eta", "Muon #eta", ylabel="Events / %.1f", cutLine=[-2.1, 2.1], log=False, rebin=5) drawPlot(createPlot("selectedMuonPhi_AfterJetSelection"), prefix + "muon_phi", "Muon #phi", ylabel="Events / %.1f", log=False, rebin=8) drawPlot(createPlot("uncorrectedMet_AfterJetSelection"), prefix + "rawmet_pt_log", "Uncorrected PF E_{T}^{miss} (GeV)", ylabel="dN/dE_{T}^{miss} / %.0f-%.0f 1/GeV", rebin=metBinning, divideByBinWidth=True) drawPlot(createPlot("transverseMassUncorrectedMet_AfterJetSelection"), prefix + "rawmt_log", "m_{T}(#mu, E_{T}^{miss}) (GeV/c^{2})", ylabel="dN/dm_{T} / %.0f-%.0f 1/GeV/c^{2}", rebin=metBinning, divideByBinWidth=True) drawPlot(createPlot("type1Met_AfterJetSelection"), prefix + "met_pt_log", "Type-1 PF E_{T}^{miss} (GeV)", ylabel="dN/dE_{T}^{miss} / %.0f-%.0f 1/GeV", rebin=metBinning, divideByBinWidth=True, opts2=zoomedOpts2) drawPlot(createPlot("type1MetPhi_AfterJetSelection"), prefix + "met_phi", "Type-1 PF E_{T}^{miss} #phi", ylabel="Events / %.2f", log=False, rebin=2, moveLegend={"dy": -0.4}) drawPlot(createPlot("transverseMassType1Met_AfterJetSelection"), prefix + "mt_log", "m_{T}(#mu, E_{T}^{miss}) (GeV/c^{2})", ylabel="dN/dm_{T} / %.0f-%.0f 1/GeV/c^{2}", rebin=metBinning, divideByBinWidth=True, opts2=zoomedOpts2) drawPlot(createPlot("nbjets_AfterJetSelection"), prefix + "nbjets_log", "Number of b jets", ylabel="Events") for x in ["0", "1", "2", "ging"]: drawPlot(createPlot("selectedMuonPt_AfterBTag%s" % x), prefix + "muon_pt_btag%s_log" % x, "Muon p_{T} (GeV/c)", ylabel="dN/dp_{T} / %.0f-%.0f GeV/c", cutBox={ "cutValue": 41, "greaterThan": True }, rebin=ptBinning, divideByBinWidth=True) drawPlot(createPlot("type1Met_AfterBTag%s" % x), prefix + "met_pt_btag%s_log" % x, "Type-1 PF E_{T}^{miss} (GeV)", ylabel="dN/dE_{T}^{miss} / %.0f-%.0f GeV", rebin=metBinning, divideByBinWidth=True) drawPlot(createPlot("transverseMassType1Met_AfterBTag%s" % x), prefix + "mt_btag%s_log" % x, "m_{T}(#mu, E_{T}^{miss}) (GeV/c^{2})", ylabel="dN/dm_{T} / %.0f-%.0f 1/GeV/c^{2}", rebin=metBinning, divideByBinWidth=True) drawPlot(createPlot("type1MetPhi_AfterBTagging"), prefix + "met_phi_btagging", "Type-1 PF E_{T}^{miss} #phi ", ylabel="Events / %.2f", log=False, rebin=2, moveLegend={"dy": -0.4}) # plotEfficiency(datasets, ["Data", "TTJets", "WJets", "QCD_Pt20_MuEnriched"], # allPath=ntupleCache.histogram("muonVertexCount_AfterDB"), # passedPath=ntupleCache.histogram("muonVertexCount_AfterIsolation"), # name=prefix+"muonIsolationEfficiency", xlabel="Number of good vertices", ylabel="Muon selection efficiency", # rebinBins=range(0, 25)+[25, 30, 35, 40, 50] # ) # plotEfficiency(datasets, ["TTJets", "WJets"], # allPath=ntupleCache.histogram("muonVertexCount_AfterDB_MuFromW"), # passedPath=ntupleCache.histogram("muonVertexCount_AfterIsolation_MuFromW"), # name=prefix+"muonIsolationEfficiency_MuFromW", xlabel="Number of good vertices", ylabel="Muon selection efficiency", # rebinBins=range(0, 25)+[25, 30, 35, 40, 50] # ) if "NoIso" in selectionName: drawPlot( createPlot("selectedMuonChargedHadronEmbIso_AfterJetSelection"), prefix + "chargedHadronIso_log", "Charged hadron #Sigma p_{T} (GeV/c)", ylabel="Events / %.1f GeV/c") drawPlot( createPlot("selectedMuonPuChargedHadronEmbIso_AfterJetSelection"), prefix + "puChargedHadronIso_log", "Charged hadron #Sigma p_{T} (GeV/c)", ylabel="Events / %.1f GeV/c") drawPlot( createPlot("selectedMuonNeutralHadronEmbIso_AfterJetSelection"), prefix + "neutralHadronIso_log", "Neutral hadron #Sigma p_{T} (GeV/c)", ylabel="Events / %.1f GeV/c") drawPlot(createPlot("selectedMuonPhotonEmbIso_AfterJetSelection"), prefix + "photonIso_log", "Photon #Sigma p_{T} (GeV/c)", ylabel="Events / %.1f GeV/c") drawPlot(createPlot("selectedMuonEmbIso_AfterJetSelection"), prefix + "embeddingIso_log", "Isolation variable (GeV/c)", ylabel="Events / %.1f GeV/c") drawPlot(createPlot("selectedMuonStdIso_AfterJetSelection"), prefix + "standardIso_log", "Isolation variable", ylabel="Events / %.1f GeV/c")
def doTH1Plots(datasets, HistoList, MyCuts, SaveExtension): ''' def doTH1Plots(datasets, HistoList, MyCuts, SaveExtension): Loops over all histograms defined in HistoHelper.py and customises each plot accordingly. Global booleans and other options are also taken care of (including x- and y- min, max, ratio, logY, etc..). See the beginning of the file for all available options. ''' if getBool("bCustomRange"): drawPlot = plots.PlotDrawer( stackMCHistograms=getBool("bStackHistos"), addMCUncertainty=getBool("bAddMCUncertainty"), log=getBool("bLogY"), ratio=getBool("bRatio"), addLuminosityText=getBool("bAddLumiText"), ratioYlabel="Ratio", opts={ "ymin": yMin, "ymax": yMax }, opts2={ "ymin": yMinRatio, "ymax": yMaxRatio }, optsLog={ "ymin": yMinLog, "ymax": yMaxLog }) else: drawPlot = plots.PlotDrawer( stackMCHistograms=getBool("bStackHistos"), addMCUncertainty=getBool("bAddMCUncertainty"), log=getBool("bLogY"), ratio=getBool("bRatio"), addLuminosityText=getBool("bAddLumiText"), opts={"ymaxfactor": yMaxFactor}, opts2={ "ymin": yMinRatio, "ymax": yMaxRatio }, optsLog={"ymaxfactor": yMaxFactorLog}) ### Define the event "weight" to be used if "passedBTagging" in MyCuts: EvtWeight = "(weightPileup*weightTauTrigger*weightPrescale*weightBTagging)" else: EvtWeight = "weightPileup*weightTauTrigger*weightPrescale" print "*** Cuts applied: \"%s\"" % (MyCuts) print "*** Weight applied: \"%s\"" % (EvtWeight) treeDraw = dataset.TreeDraw("tree", weight=EvtWeight) MyTreeDraw = treeDraw.clone(selection=MyCuts) ### Go ahead and draw the plot histograms.createLegend.setDefaults(x1=xLegMin, x2=xLegMax, y1=yLegMin, y2=yLegMax) ### Loop over all hName and expressions in the histogram list. Create & Draw plot counter = 0 for h in HistoList: hName = h.name hExpr = MyTreeDraw.clone(varexp=h.expr) saveName = "TH1_%s" % (hName) xLabel = h.xlabel yLabel = h.ylabel iBinWidth = h.binWidthX ### Consider hName with "_Vs_" in the name as a TH2 histogram if "_Vs_" in hName: continue p = createTH1Plot(datasets, hExpr, normalizeToOne=getBool("bNormalizeToOne")) if not getBool("bStackHistos"): drawPlot(p, saveName + SaveExtension, xlabel=xLabel, ylabel=yLabel, rebinToWidthX=iBinWidth) else: drawPlot(p, saveName + "_Stacked" + SaveExtension, xlabel=xLabel, ylabel=yLabel, rebinToWidthX=iBinWidth) ### Do Data plots with QCD=Data-EwkMc. Only executed if certain (boolean) conditions are met. if getBool("bDataMinusEwk") and not getBool("bRemoveData"): if getBool("bCustomRange"): drawPlot2 = plots.PlotDrawer( stackMCHistograms=getBool("bStackHistos"), addMCUncertainty=False, log=getBool("bLogY"), ratio=False, addLuminosityText=getBool("bAddLumiText"), ratioYlabel="Ratio", opts={ "ymin": yMin, "ymax": yMax }, optsLog={ "ymin": yMinLog, "ymax": yMaxLog }) else: drawPlot2 = plots.PlotDrawer( stackMCHistograms=getBool("bStackHistos"), addMCUncertainty=False, log=getBool("bLogY"), ratio=False, addLuminosityText=getBool("bAddLumiText"), opts={"ymaxfactor": yMaxFactor}, optsLog={"ymaxfactor": yMaxFactorLog}) doDataMinusEwk(p, drawPlot2, datasets, hExpr, hName, xLabel, yLabel, iBinWidth, SaveExtension, hType={"TH1": True}) ### Do QCD Purity plots if getBool("bQcdPurity"): doQcdPurPlots(p, drawPlot, datasets, hExpr, hName, xLabel, "Purity", SaveExtension) return
import HiggsAnalysis.HeavyChHiggsToTauNu.tools.tdrstyle as tdrstyle import HiggsAnalysis.HeavyChHiggsToTauNu.tools.styles as styles import HiggsAnalysis.HeavyChHiggsToTauNu.tools.plots as plots import HiggsAnalysis.HeavyChHiggsToTauNu.tools.crosssection as xsect import HiggsAnalysis.HeavyChHiggsToTauNu.tools.systematics as systematics import HiggsAnalysis.HeavyChHiggsToTauNu.qcdInverted.fakeRateWeighting as fakeRateWeighting import HiggsAnalysis.HeavyChHiggsToTauNu.qcdInverted.qcdInvertedResult as qcdInvertedResult from HiggsAnalysis.HeavyChHiggsToTauNu.tools.ShellStyles import * era = "Run2012ABCD" searchMode = "Light" drawPlot1 = plots.PlotDrawer( ylabel="w", cmsTextPosition="left", createLegend=None, ) drawPlot2 = plots.PlotDrawer( ylabel="Fake rate probability", cmsTextPosition="left", moveLegend={ "dx": -0.05, "dy": 0.02 }, opts={ "ymin": 0.0, "ymax": 0.2 }, )
def doTH2Plots(datasets, histoDict, xLabelDict, yLabelDict, MyCuts, SaveExtension): ''' def doTH2Plots(datasets, histoDict, xLabelDict, yLabelDict, MyCuts, SaveExtension): ''' if McTypesPresent>1: print "*** WARNING: More than one MC-type histo found present (McTypesPresent=%s). This is not allowed for a TH2. Aboring plotting of TH2." %(McTypesPresent) return if bMcOnly==False: print "*** NOTE: bMcOnly is set to %s. Disabling all MC samples for the TH2 plots. Only \"Data\" is available." % (bMcOnly) bMergeEwk = True bRemoveSignal = True bRemoveEwk = True bRemoveQcd = True ### Create a progress bar to inform user of progress status. Calculate the number of TH1 histos only maxValue = 0 for key in histoDict: if not "_Vs_" in key: continue else: maxValue += 1 if maxValue==0: print "*** NOTE! No TH2 histos to plot. Exiting doTH2Plots() module." return print "\n*** Preparing %s TH2 histogram(s) for the cut group:\n \"%s\"" % (maxValue, MyCuts) pBar = StartProgressBar(maxValue) if bCustomRange: drawPlot = plots.PlotDrawer(stackMCHistograms=False, addMCUncertainty=bAddMCUncertainty, log=false, ratio=False, addLuminosityText=bAddLumiText, ratioYlabel="Ratio", opts={"ymin": yMin, "ymax": yMax}, optsLog={"ymin": yMinLog, "ymax": yMaxLog}) else: drawPlot = plots.PlotDrawer(stackMCHistograms=False, addMCUncertainty=bAddMCUncertainty, log=False, ratio=False, addLuminosityText=bAddLumiText, ratioYlabel="Ratio") ### Define the event "weight" to be used if "passedBTagging" in MyCuts: #EvtWeight = "(weightPileup*weightTrigger*weightPrescale*weightBTagging)" EvtWeight = "(weightPileup*weightTauTrigger*weightPrescale*weightBTagging)" else: #EvtWeight = "weightPileup*weightTrigger*weightPrescale" EvtWeight = "weightPileup*weightTauTrigger*weightPrescale" print "*** And Event weight:\n \"%s\"" % (EvtWeight) treeDraw = dataset.TreeDraw("tree", weight=EvtWeight) MyTreeDraw = treeDraw.clone(selection=MyCuts) ### Loop over all hName and expressions in the histogram dictionary "histoDict". Create & Draw plot counter=0 for key in histoDict: if not "_Vs_" in key: continue else: hName = key histo = MyTreeDraw.clone(varexp=histoDict[hName]) fileName = "%s_%s" % (hName, SaveExtension) xLabel = xLabelDict[hName] yLabel = yLabelDict[hName] ### Go ahead and draw the plot p = createTH2Plot(datasets, histo, normalizeToOne = bNormalizeToOne) drawPlot(p, fileName, rebin=1, xlabel=xLabel, ylabel=yLabel) ### Increment counter and pdate progress bar counter = counter+1 pBar.update(counter) ### Stop pbar once done with the loop pBar.finish() return
# names = datasetMgr.getAllDatasetNames() #d_ttjets = datasets.getDataset("TTJets") #print d_ttjets.getNAllEvents() # Create plots doPlots(datasets) if interactiveMode: raw_input("*** Press \"Enter\" to exit pyROOT: ") # Default plot drawing options, all of these can be overridden in the # individual drawPlot() calls drawPlot = plots.PlotDrawer(log=True, addLuminosityText=True, stackMCHistograms=True, addMCUncertainty=True) # Define plots to draw def doPlots(datasets): def createPlot(name, massbr_x=0.42, massbr_y=0.87, normone_x=0.25, normone_y=0.5, **kwargs): args = {} args.update(kwargs) if mcOnly: args["normalizeToLumi"] = mcOnlyLumi
#!/usr/bin/env python import array import ROOT ROOT.gROOT.SetBatch(True) import HiggsAnalysis.HeavyChHiggsToTauNu.tools.histograms as histograms import HiggsAnalysis.HeavyChHiggsToTauNu.tools.plots as plots import HiggsAnalysis.HeavyChHiggsToTauNu.tools.tdrstyle as tdrstyle import HiggsAnalysis.HeavyChHiggsToTauNu.tools.aux as aux drawPlot = plots.PlotDrawer( # ylabel="Normalization coefficient ^{}w_{j}", # ylabel="Fake rate probability ^{}w_{j}", ylabel="Fake rate probability", cmsTextPosition="right", createLegend=None, ) def main(): style = tdrstyle.TDRStyle() # hand-picked values from an output from Lauri th1 = ROOT.TH1F("factors", "factors", 7, 0, 7) th1.SetBinContent(1, 0.0614187118715) th1.SetBinContent(2, 0.0579929858899) th1.SetBinContent(3, 0.0502462685164) th1.SetBinContent(4, 0.0524329776127) th1.SetBinContent(5, 0.0519288842156)
plots._legendLabels["TTToHplus_M120"] = "with H^{#pm}#rightarrow#tau^{#pm}#nu" # Apply TDR style style = tdrstyle.TDRStyle() # Create plots doPlots(datasets) # Print counters massPoints = [80, 90, 100, 120, 140, 150, 155, 160] doCounters(datasetsAllSignals, massPoints) # Signal efficiency plots for WH # doEfficiencyPlots(datasetsAllSignals, massPoints) drawPlot = plots.PlotDrawer(ylabel="Events / %.0f (GeV/c^{2})", log=True, addLuminosityText=True, stackMCHistograms=True, addMCUncertainty=True) def doPlots(datasets): def createPlot(name, **kwargs): return plots.DataMCPlot(datasets, analysis+"/"+name, **kwargs) def addMassBRText(plot, x, y): mass = "m_{H^{+}} = 120 GeV/c^{2}" br = "#it{B}(t #rightarrow H^{+}b)=0.05" size = 20 separation= 0.04 plot.appendPlotObject(histograms.PlotText(x, y, mass, size=size)) plot.appendPlotObject(histograms.PlotText(x, y-separation, br, size=size)) # Number of vertices (unit area) p = createPlot("Vertices/verticesTriggeredAfterWeight", normalizeToOne=True)
def doTH1Plots(datasets, HistoTemplateList, SaveExtension): ''' def doTH1Plots(datasets, HistoTemplateList, SaveExtension): Loops over all histograms defined in HistoHelper.py and customises each plot accordingly. The global boolean options are also taken care of including x- and y- min, max, ratio, logY, etc.. ''' if getBool("bCustomRange"): drawPlot = plots.PlotDrawer( stackMCHistograms=getBool("bStackHistos"), addMCUncertainty=getBool("bAddMCUncertainty"), log=getBool("bLogY"), ratio=getBool("bRatio"), addLuminosityText=getBool("bAddLumiText"), ratioYlabel="Ratio", opts={ "ymin": yMin, "ymax": yMax }, opts2={ "ymin": yMinRatio, "ymax": yMaxRatio }, optsLog={ "ymin": yMinLog, "ymax": yMaxLog }) else: drawPlot = plots.PlotDrawer( stackMCHistograms=getBool("bStackHistos"), addMCUncertainty=getBool("bAddMCUncertainty"), log=getBool("bLogY"), ratio=getBool("bRatio"), addLuminosityText=getBool("bAddLumiText"), opts={"ymaxfactor": yMaxFactor}, opts2={ "ymin": yMinRatio, "ymax": yMaxRatio }, optsLog={"ymaxfactor": yMaxFactorLog}) ### Go ahead and draw the plot histograms.createLegend.setDefaults(x1=xLegMin, x2=xLegMax, y1=yLegMin, y2=yLegMax) ### Loop over all hName and expressions in the histogram list. Create & Draw plot counter = 0 for h in HistoTemplateList: hName = h.name hPath = h.path fileName = "%s_%s" % (hName, SaveExtension) xLabel = h.xlabel yLabel = h.ylabel iBinWidth = h.binWidthX if "_Vs_" in hName: continue p = createTH1Plot(datasets, hPath, normalizeToOne=getBool("bNormalizeToOne")) if not getBool("bStackHistos"): drawPlot(p, fileName, rebinToWidthX=iBinWidth) else: drawPlot(p, fileName + "_Stacked", xlabel=xLabel, ylabel=yLabel, rebinToWidthX=iBinWidth) ### Do Data plots with QCD=Data-EwkMc. Only executed if certain (boolean) conditions are met. if getBool("bDataMinusEwk") and not getBool("bRemoveData"): if getBool("bCustomRange"): drawPlot2 = plots.PlotDrawer( stackMCHistograms=getBool("bStackHistos"), addMCUncertainty=False, log=getBool("bLogY"), ratio=False, addLuminosityText=getBool("bAddLumiText"), ratioYlabel="Ratio", opts={ "ymin": yMin, "ymax": yMax }, optsLog={ "ymin": yMinLog, "ymax": yMaxLog }) else: drawPlot2 = plots.PlotDrawer( stackMCHistograms=getBool("bStackHistos"), addMCUncertainty=False, log=getBool("bLogY"), ratio=False, addLuminosityText=getBool("bAddLumiText"), opts={"ymaxfactor": yMaxFactor}, optsLog={"ymaxfactor": yMaxFactorLog}) doDataMinusEwk(p, drawPlot2, datasets, hPath, hName, xLabel, yLabel, iBinWidth, SaveExtension, hType={"TH1": True}) return
def efficiencyplot(opts, dsetMgr, luminosity, myDir): myDirInRootFile = "BTaggingEfficiencyInMC" myAllJetsTemplate = "genuine%sJet%s" myBJetsTemplate = "genuine%sJetWithBTag%s" myPartonList = ["B","C","G","UDS","L"] mySuffixList = ["Pt","Eta"] # Specify output histogram binning myHistoSpecsPt = { "rangeMin": 0.0, "rangeMax": 500.0, # if an empty list is given, then uniform bin width is used: #"variableBinSizeLowEdges": [20,30,40,50,60,70,80,90,100,120,140,160,200,250,300,350,400], # B and C "variableBinSizeLowEdges": [20,30,60,100,150,250], # G and UDS "xtitle": "Jet p_{T} / GeV/c", "ytitle": "dN_{jets}/dp_{T}, arb. normalization" } myHistoSpecsEta = { "rangeMin": -2.5, "rangeMax": 2.5, "variableBinSizeLowEdges": [-2.5,-2.0,-1.5,-1.0,-0.5,0.0,0.5,1.0,1.5,2.0], # if an empty list is given, then uniform bin width is used "xtitle": "Jet #eta", "ytitle": "dN_{jets}/d#eta, arb. normalization" } myHistoSpecsList = {"Pt": myHistoSpecsPt, "Eta": myHistoSpecsEta } drawPlot = plots.PlotDrawer(log=True, ratio=False, addLuminosityText=False, optsLog={"ymin": 1e-4, "ymax": 300}, cmsText="CMS preliminary") drawPlotEfficiency = plots.PlotDrawer(log=False, ratio=False, addLuminosityText=False, cmsText="CMS preliminary", opts={"ymin": 0, "ymax": 1}, ylabel="Efficiency") # Loop over variables myResult = BtagEfficiencyResult() for suffix in mySuffixList: # Store binning to result myResult.addGeneralInfo(myDir.replace("btagEfficiency_","")) myResult.addBinning(suffix, myHistoSpecsList[suffix]["variableBinSizeLowEdges"]) # Initialize lists for histograms.Histo objects hAllJetsList = [] hBJetsList = [] hEfficiencyList = [] # Loop over partons for parton in myPartonList: print HighlightStyle()+"Creating plots for parton %s, variable %s%s"%(parton,suffix,NormalStyle()) # Obtain histograms myAllJetsDsetHisto = dsetMgr.getDataset(opts.dset).getDatasetRootHisto("%s/%s"%(myDirInRootFile,myAllJetsTemplate%(parton,suffix))) myAllJetsDsetHisto.normalizeToLuminosity(luminosity) hAllJets = myAllJetsDsetHisto.getHistogram().Clone() myBJetsDsetHisto = dsetMgr.getDataset(opts.dset).getDatasetRootHisto("%s/%s"%(myDirInRootFile,myBJetsTemplate%(parton,suffix))) myBJetsDsetHisto.normalizeToLuminosity(luminosity) hBJets = myBJetsDsetHisto.getHistogram().Clone() # Setup histogramming myModifier = ShapeHistoModifier(myHistoSpecsList[suffix]) # Make plot for all jets myPlotName = "%sForAll%sJets"%(suffix,parton) myLabel = "All %s jets"%(parton.replace("L","udsg").lower()) hBinnedAllJets = myModifier.createEmptyShapeHistogram(myPlotName) myModifier.addShape(source=hAllJets,dest=hBinnedAllJets) myModifier.finaliseShape(dest=hBinnedAllJets) rootHistoObjectAll = histograms.Histo(hBinnedAllJets.Clone(),myLabel,legendStyle="LV",drawStyle="E") hAllJetsList.append(rootHistoObjectAll) plot = plots.PlotBase([rootHistoObjectAll]) styles.dataStyle(plot.histoMgr.getHisto(myLabel)) drawPlot(plot,"%s/%s"%(myDir,myPlotName),divideByBinWidth=True,xlabel=myHistoSpecsList[suffix]["xtitle"],ylabel=myHistoSpecsList[suffix]["ytitle"]) plot.save() # Make plot for b jets myPlotName = "%sForBtagged%sJets"%(suffix,parton) myLabel = "All btagged %s jets"%(parton.replace("L","udsg").lower()) hBinnedBJets = myModifier.createEmptyShapeHistogram(myPlotName) myModifier.addShape(source=hBJets,dest=hBinnedBJets) myModifier.finaliseShape(dest=hBinnedBJets) rootHistoObjectB = histograms.Histo(hBinnedBJets.Clone(),myLabel,legendStyle="LV",drawStyle="E") hBJetsList.append(rootHistoObjectB) plot = plots.PlotBase([rootHistoObjectB]) styles.dataStyle(plot.histoMgr.getHisto(myLabel)) drawPlot(plot,"%s/%s"%(myDir,myPlotName),divideByBinWidth=True,xlabel=myHistoSpecsList[suffix]["xtitle"],ylabel=myHistoSpecsList[suffix]["ytitle"]) plot.save() # Make efficiency plot and convert it to TH1 myEff = ROOT.TEfficiency(hBinnedBJets,hBinnedAllJets) myResult.addEffObject(myEff, myDir.replace("btagEfficiency_",""), "%stoB_by%s"%(parton.replace("L","UDSG"),suffix)) myPlotName = "Efficiency_%sForBtagged%sJets"%(suffix,parton) myLabel = "%s#rightarrowb"%(parton.replace("L","udsg").lower()) rootHistoObjectEff = histograms.HistoEfficiency(myEff,myLabel,legendStyle="LV",drawStyle="") hEfficiencyList.append(rootHistoObjectEff) plot = plots.PlotBase([rootHistoObjectEff]) styles.dataStyle(plot.histoMgr.getHisto(myLabel)) drawPlotEfficiency(plot,"%s/%s"%(myDir,myPlotName),xlabel=myHistoSpecsList[suffix]["xtitle"]) # opts={"log":False} plot.save() # Set plotting styles for i in range(0,len(hAllJetsList)): styles.applyStyle(hAllJetsList[i].getRootHisto(),i) styles.applyStyle(hBJetsList[i].getRootHisto(),i) styles.applyStyle(hEfficiencyList[i].getRootHisto(),i) # Do plots with different parton flavors on same canvas plot = plots.PlotBase(hAllJetsList) drawPlot(plot,"%s/%s"%(myDir,"Combined_%sForAllJets"%suffix),xlabel=myHistoSpecsList[suffix]["xtitle"],ylabel=myHistoSpecsList[suffix]["ytitle"]) plot.save() plot = plots.PlotBase(hBJetsList) drawPlot(plot,"%s/%s"%(myDir,"Combined_%sForBTaggedJets"%suffix),xlabel=myHistoSpecsList[suffix]["xtitle"],ylabel=myHistoSpecsList[suffix]["ytitle"]) plot.save() plot = plots.PlotBase(hEfficiencyList) drawPlotEfficiency(plot,"%s/%s"%(myDir,"Combined_Efficiency_%s"%suffix),xlabel=myHistoSpecsList[suffix]["xtitle"]) plot.save() # Save to disk the efficiency results myResult.writeResultToDisk(myDir)