estimate.initCache(setup.defaultCacheDir()) # Accounting for leptonPtCutVar = "LeptonTightInvIsoNoSieie0_pt" leptonEtaCutVar = "abs(LeptonTightInvIsoNoSieie0_eta+LeptonTightInvIsoNoSieie0_deltaEtaSC)" QCDTF_updates_2J = copy.deepcopy(QCDTF_updates) key = (data_sample.name, "AR", args.variable, "_".join(map(str, args.binning)), data_sample.weightString, data_sample.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist = dirDB.get(key).Clone("data") else: dataHist = data_sample.get1DHistoFromDraw(args.variable, binning=args.binning, selectionString=selection) dirDB.add(key, dataHist.Clone("data"), overwrite=True) dataHist_SB = dataHist.Clone("data_SB") dataHist_SB.Scale(0) genCat = [None] if args.photonCat: hists = {} genCat = [ "noChgIsoNoSieiephotoncat0", "noChgIsoNoSieiephotoncat1", "noChgIsoNoSieiephotoncat2", "noChgIsoNoSieiephotoncat3", "noChgIsoNoSieiephotoncat4" ] catSettings = { "noChgIsoNoSieiephotoncat0": { "texName": "gen #gamma",
data_sample_4p.setSelectionString([ filterCutData, "reweightHEM>0", cutInterpreter.cutString(args.mode), selection ]) data_sample_4p.setWeightString("weight") key = (data_sample_4p.name, "4p", args.variable, "_".join(map(str, args.binning)), data_sample_4p.weightString, data_sample_4p.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist_4p = dirDB.get(key).Clone("4p") else: dataHist_4p = data_sample_4p.get1DHistoFromDraw(args.variable, binning=args.binning) dirDB.add(key, dataHist_4p.Clone("4p"), overwrite=True) key = (data_sample_3.name, "3", args.variable, "_".join(map(str, args.binning)), data_sample_3.weightString, data_sample_3.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist_3 = dirDB.get(key).Clone("3") else: dataHist_3 = data_sample_3.get1DHistoFromDraw(args.variable, binning=args.binning) dirDB.add(key, dataHist_3.Clone("3"), overwrite=True) key = (data_sample_2.name, "2", args.variable, "_".join(map(str, args.binning)), data_sample_2.weightString, data_sample_2.selectionString, selection) if dirDB.contains(key) and not args.overwrite:
class DataObservation(): def __init__(self, name, process, cacheDir=None): self.name = name self.process = process self.initCache(cacheDir) def initCache(self, cacheDir="dataObs"): if cacheDir: self.cacheDir = os.path.join(cache_directory, cacheDir) try: os.makedirs(cacheDir) except: pass cacheDirName = os.path.join(cacheDir, self.name) self.cache = MergingDirDB(cacheDirName) if not self.cache: raise else: self.cache = None def uniqueKey(self, region, channel, setup): ## this is used in MCBasedEstimate if hasattr(setup, "blinding"): return str(region), channel, json.dumps( setup.sys, sort_keys=True), json.dumps( setup.parameters, sort_keys=True), json.dumps(setup.lumi, sort_keys=True), setup.blinding else: return str(region), channel, json.dumps( setup.sys, sort_keys=True), json.dumps( setup.parameters, sort_keys=True), json.dumps(setup.lumi, sort_keys=True) # alias for cachedObservation to make it easier to call the same function as for the mc"s def cachedEstimate(self, region, channel, setup, signalAddon=None, save=True, overwrite=False, checkOnly=False): return self.cachedObservation(region, channel, setup, overwrite=overwrite, checkOnly=checkOnly) def cachedObservation(self, region, channel, setup, save=True, overwrite=False, checkOnly=False): key = self.uniqueKey(region, channel, setup) if (self.cache and self.cache.contains(key)) and not overwrite: res = self.cache.get(key) logger.debug("Loading cached %s result for %r : %r" % (self.name, key, res)) elif self.cache and not checkOnly: res = self.observation(region, channel, setup, overwrite) _res = self.cache.add(key, res, overwrite=True) logger.debug("Adding cached %s result for %r" % (self.name, key)) elif not checkOnly: res = self.observation(region, channel, setup, overwrite) else: res = u_float(-1, 0) return res if res >= 0 or checkOnly else u_float(0, 0) def writeToCache(self, region, channel, setup, value, signalAddon=None, save=True, overwrite=False, checkOnly=False): key = self.uniqueKey(region, channel, setup) if (self.cache and self.cache.contains(key)) and not overwrite: res = self.cache.get(key) if res.val != value.val: print "Warning, caches estimate not equal to input value: have %s, got %s" % ( res, value) logger.debug("Loading cached %s result for %r : %r" % (self.name, key, res)) elif self.cache and not checkOnly: _res = self.cache.add(key, value, overwrite=True) res = value logger.debug("Adding cached %s result for %r" % (self.name, key)) else: res = u_float(-1, 0) return res if res >= 0 or checkOnly else u_float(0, 0) def observation(self, region, channel, setup, overwrite): if setup.nJet == "3p": setup4p = setup.sysClone(parameters={"nJet": (4, -1)}) setup3 = setup.sysClone(parameters={"nJet": (3, 3)}) return sum([ self.cachedEstimate(region, channel, s, overwrite=overwrite) for s in [setup3, setup4p] ]) if channel == "all": return sum([ self.cachedEstimate(region, c, setup, overwrite=overwrite) for c in lepChannels ]) elif channel == "SFtight": return sum([ self.cachedEstimate(region, c, setup, overwrite=overwrite) for c in dilepChannels ]) else: preSelection = setup.preselection("Data", channel=channel) # cut = "&&".join([region.cutString(setup.sys['selectionModifier']), preSelection['cut']]) cut = "&&".join([region.cutString(), preSelection['cut']]) logger.debug("Using cut %s" % cut) weight = preSelection['weightStr'] if hasattr(setup, "blinding") and setup.blinding: weight += "*" + setup.blinding return u_float(**self.process.getYieldFromDraw( selectionString=cut, weightString=weight))
filterCutData, "reweightHEM>0", cutInterpreter.cutString(high + "-" + args.mode), copy.deepcopy(dataselection) ]) data_high.setWeightString("weight") key = (mc_high.name, "high", args.variable, "_".join(map(str, bins)), mc_high.weightString, mc_high.selectionString) if dirDB.contains(key) and not args.overwrite: mcHist_high = dirDB.get(key).Clone("high") else: mcHist_high = mc_high.get1DHistoFromDraw(args.variable, binning=bins, binningIsExplicit=True, addOverFlowBin="upper") dirDB.add(key, mcHist_high.Clone("high"), overwrite=True) key = (mc_low.name, "low", args.variable, "_".join(map(str, bins)), mc_low.weightString, mc_low.selectionString) if dirDB.contains(key) and not args.overwrite: mcHist_low = dirDB.get(key).Clone("low") else: mcHist_low = mc_low.get1DHistoFromDraw(args.variable, binning=bins, binningIsExplicit=True, addOverFlowBin="upper") dirDB.add(key, mcHist_low.Clone("low"), overwrite=True) key = (data_high.name, "high", args.variable, "_".join(map(str, bins)), data_high.weightString, data_high.selectionString) if dirDB.contains(key) and not args.overwrite:
]) dataE.setWeightString("weight") dataF.setSelectionString([ filterCutData, "reweightHEM>0", cutInterpreter.cutString(args.mode), selection ]) dataF.setWeightString("weight") key = (dataB.name, "B", args.variable, "_".join(map(str, args.binning)), dataB.weightString, dataB.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHistB = dirDB.get(key).Clone("B") else: dataHistB = dataB.get1DHistoFromDraw(args.variable, binning=args.binning) dirDB.add(key, dataHistB.Clone("B"), overwrite=True) key = (dataC.name, "C", args.variable, "_".join(map(str, args.binning)), dataC.weightString, dataC.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHistC = dirDB.get(key).Clone("C") else: dataHistC = dataC.get1DHistoFromDraw(args.variable, binning=args.binning) dirDB.add(key, dataHistC.Clone("C"), overwrite=True) key = (dataD.name, "D", args.variable, "_".join(map(str, args.binning)), dataD.weightString, dataD.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHistD = dirDB.get(key).Clone("D") else: dataHistD = dataD.get1DHistoFromDraw(args.variable, binning=args.binning)
ws, misIDSF_val[2016].val) ws17 = "+(%s*(PhotonNoChgIsoNoSieie0_photonCatMagic==2)*(%f-1)*(year==2017))" % ( ws, misIDSF_val[2017].val) ws18 = "+(%s*(PhotonNoChgIsoNoSieie0_photonCatMagic==2)*(%f-1)*(year==2018))" % ( ws, misIDSF_val[2018].val) weightStringAR = ws + ws16 + ws17 + ws18 key = (data_sample.name, "AR", args.variable, "_".join(map(str, args.binning)), data_sample.weightString, data_sample.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist = dirDB.get(key).Clone("data") else: dataHist = data_sample.get1DHistoFromDraw(args.variable, binning=args.binning, selectionString=selection) dirDB.add(key, dataHist.Clone("data"), overwrite=True) for s in mc: s.setWeightString(weightStringAR + "*" + sampleWeight) key = (s.name, "AR", args.variable, "_".join(map(str, args.binning)), s.weightString, s.selectionString, selection) if dirDB.contains(key) and not args.overwrite: s.hist = copy.deepcopy(dirDB.get(key).Clone(s.name)) else: s.hist = s.get1DHistoFromDraw(args.variable, binning=args.binning, selectionString=selection) dirDB.add(key, s.hist.Clone(s.name), overwrite=True) s.hist.style = styles.lineStyle(ROOT.kRed, width=2, errors=True) s.hist.legendText = "MC (all)"
selection = setup.selection( "MC", channel="all", **setup.defaultParameters() )["prefix"] selection = cutInterpreter.cutString( selection ) selection += "&&triggered==1" print selection if args.addCut: selection += "&&" + cutInterpreter.cutString( args.addCut ) print( "Using selection string: %s"%selection ) key = (data2018.name, "18", args.variable, "_".join(map(str,args.binning)), data2018.weightString, data2018.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist2018 = dirDB.get(key).Clone("edataAR18") else: dataHist2018 = data2018.get1DHistoFromDraw( args.variable, binning=args.binning, selectionString=selection ) dirDB.add(key, dataHist2018.Clone("edataAR18"), overwrite=True) key = (data2017.name, "17", args.variable, "_".join(map(str,args.binning)), data2017.weightString, data2017.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist2017 = dirDB.get(key).Clone("edataAR17") else: dataHist2017 = data2017.get1DHistoFromDraw( args.variable, binning=args.binning, selectionString=selection ) dirDB.add(key, dataHist2017.Clone("edataAR17"), overwrite=True) key = (data2016.name, "16", args.variable, "_".join(map(str,args.binning)), data2016.weightString, data2016.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist2016 = dirDB.get(key).Clone("mudataAR16") else: dataHist2016 = data2016.get1DHistoFromDraw( args.variable, binning=args.binning, selectionString=selection ) dirDB.add(key, dataHist2016.Clone("mudataAR17"), overwrite=True)
lumiString = "(35.92*(year==2016)+41.53*(year==2017)+59.74*(year==2018))" ws = "(%s*weight*reweightHEM*reweightTrigger*reweightL1Prefire*reweightPU*reweightLeptonTightSF*reweightLeptonTrackingTightSF*reweightPhotonSF*reweightPhotonElectronVetoSF*reweightBTag_SF)"%lumiString ws16 = "+(%s*(PhotonNoChgIsoNoSieie0_photonCatMagic==2)*(%f-1)*(year==2016))" %(ws, misIDSF_val[2016].val) ws17 = "+(%s*(PhotonNoChgIsoNoSieie0_photonCatMagic==2)*(%f-1)*(year==2017))" %(ws, misIDSF_val[2017].val) ws18 = "+(%s*(PhotonNoChgIsoNoSieie0_photonCatMagic==2)*(%f-1)*(year==2018))" %(ws, misIDSF_val[2018].val) if not addSF: weightStringAR = ws else: weightStringAR = ws + ws16 + ws17 + ws18 key = (data_sample.name, "AR", args.variable, "_".join(map(str,args.binning)), data_sample.weightString, data_sample.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist = dirDB.get(key).Clone("dataAR") else: dataHist = data_sample.get1DHistoFromDraw( args.variable, binning=args.binning, selectionString=selection, addOverFlowBin="upper" ) dirDB.add(key, dataHist.Clone("dataAR"), overwrite=True) for s in mc: s.setWeightString( weightStringAR + "*" + sampleWeight ) key = (s.name, "AR", args.variable, "_".join(map(str,args.binning)), s.weightString, s.selectionString, selection) if dirDB.contains(key) and not args.overwrite: s.hist = copy.deepcopy(dirDB.get(key).Clone(s.name+"AR")) else: s.hist = s.get1DHistoFromDraw( args.variable, binning=args.binning, selectionString=selection, addOverFlowBin="upper" ) dirDB.add(key, s.hist.Clone("%s_AR"%s.name), overwrite=True) if addSF: if "DY" in s.name: s.hist.Scale(DYSF_val[args.year].val) elif "ZG" in s.name:# and njets < 4: s.hist.Scale(ZGSF_val[args.year].val)
invVariable = replaceVariable[ args.variable] if args.variable in replaceVariable.keys( ) else args.variable # histos key = (data_sample.name, "Binv", args.variable, "_".join(map(str, args.binning)), data_sample.weightString, data_sample.selectionString, preSelection) if dirDB.contains(key) and not args.overwrite: dataHist_SB = dirDB.get(key) else: dataHist_SB = data_sample.get1DHistoFromDraw(invVariable, binning=args.binning, selectionString=preSelection, addOverFlowBin="upper") dirDB.add(key, dataHist_SB, overwrite=True) key = (data_sample.name, "AR", args.variable, "_".join(map(str, args.binning)), data_sample.weightString, data_sample.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist = dirDB.get(key) else: dataHist = data_sample.get1DHistoFromDraw(args.variable, binning=args.binning, selectionString=selection, addOverFlowBin="upper") dirDB.add(key, dataHist, overwrite=True) dataHist_SB.style = styles.errorStyle(ROOT.kBlack) dataHist_SB.legendText = "Observed (%s)" % args.mode.replace("mu", "#mu") dataHist.style = styles.errorStyle(ROOT.kBlack)
selection = setup.selection( "MC", channel="all", **setup.defaultParameters() )["prefix"] selection = cutInterpreter.cutString( selection ) selection += "&&pTStitching==1&&triggered==1" print selection if args.addCut: selection += "&&" + cutInterpreter.cutString( args.addCut ) print( "Using selection string: %s"%selection ) key = (mc18.name, "18", args.variable, "_".join(map(str,args.binning)), mc18.weightString, mc18.selectionString, selection) if dirDB.contains(key) and not args.overwrite: mcHist18 = dirDB.get(key).Clone("18") else: mcHist18 = mc18.get1DHistoFromDraw( args.variable, binning=args.binning, selectionString=selection ) dirDB.add(key, mcHist18.Clone("18"), overwrite=True) key = (mc17.name, "17", args.variable, "_".join(map(str,args.binning)), mc17.weightString, mc17.selectionString, selection) if dirDB.contains(key) and not args.overwrite: mcHist17 = dirDB.get(key).Clone("17") else: mcHist17 = mc17.get1DHistoFromDraw( args.variable, binning=args.binning, selectionString=selection ) dirDB.add(key, mcHist17.Clone("17"), overwrite=True) key = (mc16.name, "16", args.variable, "_".join(map(str,args.binning)), mc16.weightString, mc16.selectionString, selection) if dirDB.contains(key) and not args.overwrite: mcHist16 = dirDB.get(key).Clone("16") else: mcHist16 = mc16.get1DHistoFromDraw( args.variable, binning=args.binning, selectionString=selection ) dirDB.add(key, mcHist16.Clone("16"), overwrite=True)
def plotRegions(sorted=True): # get region histograms if args.year == "combined": hists_tmp = Results.getRegionHistos(postFit=args.postFit, plotBins=plotBins, nuisances=plotNuisances, addStatOnlyHistos=True, bkgSubstracted=args.bkgSubstracted, labelFormater=labelFormater) for i, dir in enumerate(Results.channels): if i == 0: hists = { key: hist.Clone(str(i) + dir + key) for key, hist in hists_tmp[dir].iteritems() if not args.plotNuisances or key not in plotNuisances } #copy.deepcopy(hists_tmp) if args.plotNuisances: for n in plotNuisances: hists.update({ n: { "up": hists_tmp[dir][n]["up"].Clone( str(i) + dir + n + "up"), "down": copy.deepcopy(hists_tmp[dir][n]["down"].Clone( str(i) + dir + n + "down")) } }) hists[n]["up"].legendText = hists_tmp[dir][n][ "up"].legendText hists[n]["up"].style = hists_tmp[dir][n]["up"].style hists[n]["down"].legendText = hists_tmp[dir][n][ "down"].legendText hists[n]["down"].style = hists_tmp[dir][n][ "down"].style else: for key, hist in hists_tmp[dir].iteritems(): if args.plotNuisances and key in plotNuisances: hists[key]["up"].Add( hist["up"].Clone(str(i) + dir + key + "up")) hists[key]["down"].Add( hist["down"].Clone(str(i) + dir + key + "down")) else: hists[key].Add(hist.Clone(str(i) + dir + key)) else: hists = Results.getRegionHistos(postFit=args.postFit, plotBins=plotBins, nuisances=plotNuisances, addStatOnlyHistos=True, bkgSubstracted=args.bkgSubstracted, labelFormater=labelFormater)["Bin0"] if args.plotNuisances and args.plotNuisances[0] == "total": hists["totalUnc"] = Results.sumNuisanceHistos(hists, addStatUnc=True, postFit=args.postFit) for i_n, ni in enumerate(plotNuisances): del hists[ni] error = [] for i in range(hists["totalUnc"]["up"].GetNbinsX()): print i + 1, hists["totalUnc"]["relUp"].GetBinContent( i + 1) - hists["total"].GetBinError(i + 1) > 0, abs( hists["totalUnc"]["relUp"].GetBinContent(i + 1) - hists["total"].GetBinError(i + 1) ), abs(hists["totalUnc"]["relUp"].GetBinContent(i + 1) - hists["total"].GetBinError(i + 1) ) / hists["total"].GetBinError(i + 1) error.append( abs(hists["totalUnc"]["relUp"].GetBinContent(i + 1) - hists["total"].GetBinError(i + 1)) / hists["total"].GetBinError(i + 1)) global max print "Max difference: %f, Mean difference: %f" % (max(error), np.mean(error)) differential = False ch = "all" xLabel = "" if args.substituteCard: subCard = args.substituteCard.split("_") if args.bkgSubstracted and args.substituteCard: hists = replaceHistoBinning(hists) differential = True ch = subCard[-1] minMax = 0.29 #0.19 if args.postFit else 0.9 if args.bkgSubstracted: minMax = 0.29 #0.19 if args.postFit else 0.9 ratioCenter = None boxes, ratio_boxes = getErrorBoxes(copy.copy(hists["signal"]), minMax, lineColor=ROOT.kOrange - 2, fillColor=ROOT.kOrange - 2, hashcode=1001, ratioCenter=ratioCenter) boxes_stat, ratio_boxes_stat = getErrorBoxes(copy.copy( hists["signal_stat"]), minMax, lineColor=ROOT.kAzure - 3, fillColor=ROOT.kAzure - 3, hashcode=1001, ratioCenter=ratioCenter) else: boxes, ratio_boxes = getUncertaintyBoxes( copy.copy(hists["total"]), minMax, lineColor=ROOT.kGray + 3, fillColor=ROOT.kGray + 3, hashcode=formatSettings(nBins)["hashcode"]) if args.postFit: boxes_stat, ratio_boxes_stat = getUncertaintyBoxes( copy.copy(hists["total_stat"]), minMax, lineColor=ROOT.kAzure - 3, fillColor=ROOT.kAzure - 3, hashcode=1001) hists["data"].style = styles.errorStyle(ROOT.kBlack) hists[ "data"].legendText = "data" if not args.bkgSubstracted else "bkg-sub. data (#color[61]{stat}, #color[92]{total} error, %s)" % ( ch.replace("mu", "#mu") if ch != "all" else "e+#mu") hists["data"].legendOption = "p" if args.bkgSubstracted else "p" if args.bkgSubstracted: hists["signal"].style = styles.lineStyle(ROOT.kOrange + 7, width=2, errors=False) hists[ "signal"].legendText = "tt#gamma SM prediction" # (detector level)" else: for h_key, h in hists.iteritems(): if "total" in h_key or h_key not in processes: continue hists[h_key].legendText = default_processes[h_key]["texName"] hists[h_key].style = styles.fillStyle( default_processes[h_key]["color"], errors=False) hists[h_key].LabelsOption("v", "X") # some settings and things like e.g. uncertainty boxes drawObjects_ = drawObjects( nBins=nBins, isData=(not args.expected), lumi_scale=lumi_scale, postFit=args.postFit, cardfile=args.substituteCard if args.substituteCard else args.cardfile, preliminary=args.preliminary) drawObjects_ += boxes if args.postFit: drawObjects_ += boxes_stat # if args.bkgSubstracted: drawObjects_ += boxes_stat drawObjects_ += drawDivisions(crLabel, misIDPOI=("misIDPOI" in args.cardfile)) drawObjects_ += drawPTDivisions(crLabel, ptLabels) histModifications = [] if not differential: histModifications += [ lambda h: h.GetYaxis().SetTitleSize( formatSettings(nBins)["textsize"]) ] histModifications += [ lambda h: h.GetYaxis().SetLabelSize( formatSettings(nBins)["ylabelsize"]) ] histModifications += [ lambda h: h.GetYaxis().SetTitleOffset( formatSettings(nBins)["textoffset"]) ] histModifications += [ setPTBinLabels(ptLabels, crName, fac=formatSettings(nBins)["offsetfactor"] * hists["total"].GetMaximum()) ] ratioHistModifications = [] if not differential: ratioHistModifications += [ lambda h: h.GetYaxis().SetTitleSize( formatSettings(nBins)["textsize"]) ] ratioHistModifications += [ lambda h: h.GetYaxis().SetLabelSize( formatSettings(nBins)["ylabelsize"]) ] ratioHistModifications += [ lambda h: h.GetYaxis().SetTitleOffset( formatSettings(nBins)["textoffset"]) ] ratioHistModifications += [ lambda h: h.GetXaxis().SetTitleSize( formatSettings(nBins)["textsize"]) ] ratioHistModifications += [ lambda h: h.GetXaxis().SetLabelSize( formatSettings(nBins)["xlabelsize"]) ] ratioHistModifications += [ lambda h: h.GetXaxis().SetLabelOffset(0.035) ] addon = [] if args.bkgSubstracted: addon += ["bkgSub"] if args.substituteCard: addon += ["rebinned"] + [cr for cr in subCard ] #if cr not in args.cardfile.split("_") ] if args.plotNuisances: addon += args.plotNuisances # plot name if args.plotRegions and args.plotChannels: plotName = "_".join( ["regions"] + addon + args.plotRegions + [ch for ch in args.plotChannels if not "tight" in ch]) elif args.plotRegions: plotName = "_".join(["regions"] + addon + args.plotRegions) elif args.plotChannels: plotName = "_".join( ["regions"] + addon + [ch for ch in args.plotChannels if not "tight" in ch]) else: plotName = "_".join(["regions"] + addon) if args.cacheHistogram: from Analysis.Tools.MergingDirDB import MergingDirDB from TTGammaEFT.Tools.user import cache_directory cache_dir = os.path.join(cache_directory, "unfolding", str(args.year), "bkgSubstracted", "expected" if args.expected else "observed") dirDB = MergingDirDB(cache_dir) if not dirDB: raise addon = [] if args.plotRegions: addon += args.plotRegions if args.plotChannels: addon += args.plotChannels systematics = [ sys for sys in Results.getPulls(postFit=True).keys() if not "prop" in sys ] # data histogram name = ["bkgSubtracted", args.substituteCard, args.cardfile, "data"] print "_".join(name + addon) dirDB.add("_".join(name + addon), hists["data"], overwrite=True) # bkg substracted total histogram (signal) with total error name = ["bkgSubtracted", args.substituteCard, args.cardfile, "signal"] print "_".join(name + addon) dirDB.add("_".join(name + addon), hists["signal"], overwrite=True) # bkg substracted total histogram (signal) with stat error name = [ "bkgSubtracted", args.substituteCard, args.cardfile, "signal_stat" ] print "_".join(name + addon) dirDB.add("_".join(name + addon), hists["signal_stat"], overwrite=True) # get histo list plots, ratioHistos = Results.getRegionHistoList( hists, processes=processes, noData=False, sorted=sorted and not args.bkgSubstracted, bkgSubstracted=args.bkgSubstracted, directory="dc_2016" if args.year == "combined" else "Bin0") if args.plotRegionPlot: plotting.draw( Plot.fromHisto( plotName, plots, texX="" if not differential else xLabel, texY="Observed - Background" if args.bkgSubstracted else "Number of Events", ), logX=False, logY=True, sorting=False, plot_directory=plotDirectory, legend=[(0.2, 0.86 if args.bkgSubstracted else formatSettings(nBins)["legylower"], 0.9, 0.9), formatSettings(nBins)["legcolumns"]] if not differential else (0.15, 0.80, 0.9, 0.9), widths={ "x_width": formatSettings(nBins)["padwidth"], "y_width": formatSettings(nBins)["padheight"], "y_ratio_width": formatSettings(nBins)["padratio"] } if not differential else {}, yRange=(0.7, hists["total"].GetMaximum() * formatSettings(nBins)["heightFactor"]) if not differential else "auto", ratio={ "yRange": (1 - minMax, 1 + minMax), "texY": "Data/Pred." if args.bkgSubstracted else "Data/MC", "histos": ratioHistos, "drawObjects": ratio_boxes + ratio_boxes_stat if args.postFit else ratio_boxes, "histModifications": ratioHistModifications }, drawObjects=drawObjects_ if not differential else drawObjectsDiff(lumi_scale) + boxes + boxes_stat, histModifications=histModifications, copyIndexPHP=True, extensions=["png", "pdf", "root"] if args.bkgSubstracted else ["png"], # pdfs are quite large for sorted histograms (disco plot) redrawHistos=args.bkgSubstracted, ) del hists
matrix.Fill(reco_variable_overflow[year], fiducial_variable_val, gen_weight_val) if r.event.is_fiducial: # note: there is no reco_reweight_val because we construct the gen spectrum # counter counter_fid += 1 yield_fid += gen_weight_val fiducial_spectrum.Fill(fiducial_variable_val, gen_weight_val) logger.info( "total: %6.2f (%6.2f) fiducial: %6.2f (%6.2f) fiducial+reco %6.2f (%6.2f) reco-total: %6.2f (%6.2f)", yield_tot, counter_tot, yield_fid, counter_fid, yield_fid_reco, counter_fid_reco, yield_reco, counter_reco) dirDB.add(loop_key, (matrix, fiducial_spectrum, reco_spectrum), overwrite=True) # Unfolding matrix plot_matrix = Plot2D.fromHisto("unfolding_matrix", [[matrix]], texY=tex_gen, texX=tex_reco + " +%i*(year-2016)" % max_reco_val) plotting.draw2D( plot_matrix, plot_directory=plot_directory_, logX=False, logY=False, logZ=True, drawObjects=drawObjects(), widths={'x_width': 500 * len(args.years)}, copyIndexPHP=True,
ISR_unc.append(ISR_scale_rel) FSR_unc.append(FSR_scale_rel) Scale_unc.append(scale_rel) # Store results key = uniqueKey(args.selectEstimator, region, c, setup) + tuple( str(args.year)) scaleKeys = [] scaleKeys.append(tuple(list(key) + ["DownDown"])) scaleKeys.append(tuple(list(key) + ["DownNom"])) scaleKeys.append(tuple(list(key) + ["NomDown"])) scaleKeys.append(tuple(list(key) + ["NomUp"])) scaleKeys.append(tuple(list(key) + ["UpNom"])) scaleKeys.append(tuple(list(key) + ["UpUp"])) PDF_cache.add(key, delta_sigma_rel, overwrite=True) scale_cache.add(key, scale_rel, overwrite=True) PS_cache.add(key, PS_scale_rel, overwrite=True) ISR_cache.add(key, ISR_scale_rel, overwrite=True) FSR_cache.add(key, FSR_scale_rel, overwrite=True) for i_s, var in enumerate(scales): print i_s, var, scaleKeys[i_s] scale_cache.add(scaleKeys[i_s], var, overwrite=True) logger.info("Min. PDF uncertainty: %.3f" % min(PDF_unc)) logger.info("Max. PDF uncertainty: %.3f" % max(PDF_unc)) logger.info("Av. PDF uncertainty: %.3f" % (sum(PDF_unc) / len(PDF_unc) if PDF_unc else 1.)) logger.info("Min. PS uncertainty: %.3f" % min(PS_unc)) logger.info("Max. PS uncertainty: %.3f" % max(PS_unc)) logger.info("Av. PS uncertainty: %.3f" %
selection = setup.selection( "MC", channel="all", **setup.defaultParameters() )["prefix"] selection = cutInterpreter.cutString( selection ) selection += "&&triggered==1" print selection if args.addCut: selection += "&&" + cutInterpreter.cutString( args.addCut ) print( "Using selection string: %s"%selection ) key = (data_sample_e.name, "AR", args.variable, "_".join(map(str,args.binning)), data_sample_e.weightString, data_sample_e.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist_e = dirDB.get(key).Clone("edataAR") else: dataHist_e = data_sample_e.get1DHistoFromDraw( args.variable, binning=args.binning, selectionString=selection ) dirDB.add(key, dataHist_e.Clone("edataAR"), overwrite=True) key = (data_sample_mu.name, "AR", args.variable, "_".join(map(str,args.binning)), data_sample_mu.weightString, data_sample_mu.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist_mu = dirDB.get(key).Clone("mudataAR") else: dataHist_mu = data_sample_mu.get1DHistoFromDraw( args.variable, binning=args.binning, selectionString=selection ) dirDB.add(key, dataHist_mu.Clone("mudataAR"), overwrite=True) dataHist_mu.style = styles.errorStyle( ROOT.kBlack ) dataHist_mu.legendText = "data (#mu)" dataHist_e.style = styles.errorStyle( ROOT.kRed ) dataHist_e.legendText = "data (e)" histos = [[dataHist_mu], [dataHist_e]]
reconstruction = Plot( name="reconstruction", texX="p^{gen}_{T}(#gamma) / p^{reco}_{T}(#gamma)", attribute=lambda event, sample: getattr(event, args.genPtVariable) / event.PhotonGood0_pt if selection(event, sample) else -999, binning=reconstructionBinning, read_variables=read_variables, ) plotting.fill([unfold2D, reconstruction], read_variables=read_variables) matrix = unfold2D.histos[0][0] resHisto = reconstruction.histos[0][0] dirDB.add(resMatrix, matrix, overwrite=True) dirDB.add(resRes, resHisto, overwrite=True) matrix.Scale(lumi_scale) resHisto.Scale(lumi_scale) histos = {} histos["gen"] = matrix.ProjectionX("gen") histos["efficiency"] = ROOT.TH1D("efficiency", "efficiency", nGen, xminGen, xmaxGen) histos["purity"] = ROOT.TH1D("purity", "purity", nReco, xminReco, xmaxReco) histos["recoMC"] = matrix.ProjectionY("reco") histos["reconstruction"] = resHisto if args.noData: histos["reco"] = histos["recoMC"] else: histos["reco"] = dataHisto
fiducial_variable_val, gen_weight_val) if r.event.is_fiducial: # note: there is no reco_reweight_val because we construct the gen spectrum # counter counter_fid += 1 yield_fid += gen_weight_val fiducial_spectrum.Fill(fiducial_variable_val, gen_weight_val) logger.info( "total: %6.2f (%6.2f) fiducial: %6.2f (%6.2f) fiducial+reco %6.2f (%6.2f) reco-total: %6.2f (%6.2f)", yield_tot, counter_tot, yield_fid, counter_fid, yield_fid_reco, counter_fid_reco, yield_reco, counter_reco) dirDB.add(loop_key, (matrix, fiducial_spectrum, reco_spectrum, yield_fid, yield_fid_reco, yield_reco), overwrite=True) # Unfolding matrix plot_matrix = Plot2D.fromHisto("unfolding_matrix", [[matrix]], texY=settings.tex_gen, texX=settings.tex_reco + " +%i*(year-2016)" % settings.max_reco_val) plotting.draw2D( plot_matrix, plot_directory=plot_directory_, logX=False, logY=False, logZ=True, drawObjects=drawObjects(), widths={'x_width': 500 * len(settings.years)},
class SystematicEstimator: __metaclass__ = abc.ABCMeta def __init__(self, name, cacheDir=None): logger.info("Initializing Systematic Estimator for %s"%name) self.name = name self.initCache(cacheDir) self.processCut = None if "_gen" in name: self.processCut = "cat0" #"photoncat0" elif "_misID" in name: self.processCut = "cat2" #"photoncat2" elif "_had" in name: self.processCut = "cat134" #"photoncat134" elif "_prompt" in name: self.processCut = "cat02" #"photoncat02" elif "_np" in name: self.processCut = "cat134" #"photoncat134" elif "_hp" in name: self.processCut = "cat1" #"photoncat1" elif "_fake" in name: self.processCut = "cat3" #"photoncat3" elif "_PU" in name: self.processCut = "cat4" #"photoncat4" def initCache(self, cacheDir="systematics"): logger.info("Initializing cache for %s in directory %s"%(self.name, cacheDir)) if cacheDir: self.cacheDir = os.path.join(cache_directory, cacheDir) try: os.makedirs(cacheDir) except: pass cacheDirName = os.path.join(cacheDir, self.name) self.cache = MergingDirDB(cacheDirName) if not self.cache: raise Exeption("Cache not initiated!") if self.name.count("DD"): helperCacheDirName = os.path.join(cacheDir, self.name+"_helper") self.helperCache = MergingDirDB(helperCacheDirName) if not self.helperCache: raise histoHelperCacheDirName = os.path.join(cacheDir, self.name+"_histo") self.histoHelperCache = MergingDirDB(histoHelperCacheDirName) if not self.histoHelperCache: raise tfCacheDirName = os.path.join(cacheDir, self.name+"_tf") self.tfCache = MergingDirDB(tfCacheDirName) if not self.tfCache: raise elif self.name.count("had"): helperCacheDirName = os.path.join(cacheDir, "had_helper") self.helperCache = MergingDirDB(helperCacheDirName) if not self.helperCache: raise else: self.helperCache=None self.tfCache=None else: self.cache=None self.helperCache=None self.tfCache=None # For the datadriven subclasses which often need the same getYieldFromDraw we write those yields to a cache def yieldFromCache(self, setup, process, c, selectionString, weightString, overwrite=False): s = (process, c, selectionString, weightString) if self.helperCache and self.helperCache.contains(s) and not overwrite: return self.helperCache.get(s) else: yieldFromDraw = u_float(**setup.processes[process].getYieldFromDraw(selectionString, weightString)) if self.helperCache: self.helperCache.add(s, yieldFromDraw, overwrite=True) return yieldFromDraw # For the datadriven subclasses which often need the same mT histos we write those yields to a cache def histoFromCache(self, var, binning, setup, process, c, selectionString, weightString, overwrite=False): s = (var, "_".join(map(str,binning)), process, c, selectionString, weightString) if self.histoHelperCache and self.histoHelperCache.contains(s) and not overwrite: return self.histoHelperCache.get(s).Clone(process+c+var) else: histo = setup.processes[process].get1DHistoFromDraw( var, binning=binning, selectionString=selectionString, weightString=weightString, addOverFlowBin="upper" ) if self.histoHelperCache: self.histoHelperCache.add(s, histo.Clone(process+c+var), overwrite=True) return histo.Clone(process+c+var) def uniqueKey(self, region, channel, setup, signalAddon=None, qcdUpdates={}): sysForKey = setup.sys.copy() sysForKey["reweight"] = "TEMP" reweightKey = '["' + '", "'.join(sorted([i for i in setup.sys['reweight']])) + '"]' # little hack to preserve order of list when being dumped into json key = region, channel, json.dumps(sysForKey, sort_keys=True).replace('"TEMP"',reweightKey), json.dumps(setup.parameters, sort_keys=True), json.dumps(setup.lumi, sort_keys=True) if qcdUpdates: key += tuple(json.dumps(qcdUpdates, sort_keys=True)) if signalAddon: key += tuple(signalAddon) return key def replace(self, i, r): try: if i.count("reweight"): return i.replace(r[0], r[1]) else: return i except: return i def cachedEstimate(self, region, channel, setup, signalAddon=None, save=True, overwrite=False, checkOnly=False): key = self.uniqueKey(region, channel, setup, signalAddon=signalAddon) if (self.cache and self.cache.contains(key)) and not overwrite: res = self.cache.get(key) logger.debug( "Loading cached %s result for %r : %r"%(self.name, key, res) ) elif self.cache and not checkOnly: logger.debug( "Calculating %s result for %r"%(self.name, key) ) res = self._estimate( region, channel, setup, signalAddon=signalAddon, overwrite=overwrite ) _res = self.cache.add( key, res, overwrite=True ) logger.debug( "Adding cached %s result for %r : %r" %(self.name, key, res) ) elif not checkOnly: res = self._estimate( region, channel, setup, signalAddon=signalAddon, overwrite=overwrite) else: res = u_float(-1,0) return res if res >= 0 or checkOnly else u_float(0,0) def writeToCache(self, region, channel, setup, value, signalAddon=None, save=True, overwrite=False, checkOnly=False): key = self.uniqueKey(region, channel, setup, signalAddon=signalAddon) if (self.cache and self.cache.contains(key)) and not overwrite: res = self.cache.get(key) # if res.val != value.val: print "Warning, caches estimate not equal to input value: have %s, got %s"%(res, value) # logger.debug( "Loading cached %s result for %r : %r"%(self.name, key, res) ) elif self.cache and not checkOnly: _res = self.cache.add( key, value, overwrite=True ) res = value logger.debug( "Adding cached %s result for %r : %r" %(self.name, key, res) ) else: res = u_float(-1,0) return res if res >= 0 or checkOnly else u_float(0,0) def cachedTransferFactor(self, channel, setup, qcdUpdates=None, save=True, overwrite=False, checkOnly=False): key = self.uniqueKey("region", channel, setup, qcdUpdates=qcdUpdates) if (self.tfCache and self.tfCache.contains(key)) and not overwrite: res = self.tfCache.get(key) logger.debug( "Loading cached %s result for %r : %r"%(self.name, key, res) ) elif self.tfCache and not checkOnly: logger.debug( "Calculating %s result for %r"%(self.name, key) ) # res = self._dataDrivenTransferFactor( channel, setup, qcdUpdates=qcdUpdates, overwrite=overwrite ) res = self._fittedTransferFactor( channel, setup, qcdUpdates=qcdUpdates, overwrite=overwrite ) _res = self.tfCache.add( key, res, overwrite=True ) logger.debug( "Adding cached transfer factor for %r : %r" %(key, res) ) elif not checkOnly: # res = self._dataDrivenTransferFactor( channel, setup, qcdUpdates=qcdUpdates, overwrite=overwrite ) res = self._fittedTransferFactor( channel, setup, qcdUpdates=qcdUpdates, overwrite=overwrite ) else: res = u_float(-1,0) return res if res > 0 or checkOnly else u_float(0,0) def cachedQCDMCTransferFactor(self, channel, setup, qcdUpdates=None, save=True, overwrite=False, checkOnly=False): key = self.uniqueKey("regionQCDMC", channel, setup, qcdUpdates=qcdUpdates) if (self.tfCache and self.tfCache.contains(key)) and not overwrite: res = self.tfCache.get(key) logger.debug( "Loading cached %s result for %r : %r"%(self.name, key, res) ) elif self.tfCache and not checkOnly: logger.debug( "Calculating %s result for %r"%(self.name, key) ) # res = self._dataDrivenTransferFactor( channel, setup, qcdUpdates=qcdUpdates, overwrite=overwrite ) res = self._transferFactor( channel, setup, qcdUpdates=qcdUpdates, overwrite=overwrite ) _res = self.tfCache.add( key, res, overwrite=True ) logger.debug( "Adding cached transfer factor for %r : %r" %(key, res) ) elif not checkOnly: # res = self._dataDrivenTransferFactor( channel, setup, qcdUpdates=qcdUpdates, overwrite=overwrite ) res = self._transferFactor( channel, setup, qcdUpdates=qcdUpdates, overwrite=overwrite ) else: res = u_float(-1,0) return res if res > 0 or checkOnly else u_float(0,0) def cachedFakeFactor(self, region, channel, setup, overwrite=False, checkOnly=False): key = self.uniqueKey(region, channel, setup) if (self.helperCache and self.helperCache.contains(key)) and not overwrite: res = self.helperCache.get(key) logger.debug( "Loading cached %s result for %r : %r"%(self.name, key, res) ) elif self.helperCache and not checkOnly: logger.debug( "Calculating %s result for %r"%(self.name, key) ) res = self._dataDrivenFakeCorrectionFactor( region, channel, setup, overwrite=overwrite ) _res = self.helperCache.add( key, res, overwrite=True ) logger.debug( "Adding cached transfer factor for %r : %r" %(key, res) ) elif not checkOnly: res = self._dataDrivenFakeCorrectionFactor( region, channel, setup, overwrite=overwrite ) else: res = u_float(-1,0) return res if res > 0 or checkOnly else u_float(0,0) @abc.abstractmethod def _estimate(self, region, channel, setup, signalAddon=None, overwrite=False): """Estimate yield in "region" using setup""" return def _transferFactor(self, channel, setup, overwrite=False): """Estimate transfer factor for QCD in "region" using setup""" return def _dataDrivenTransferFactor(self, channel, setup, qcdUpdates=None, overwrite=False): """Estimate transfer factor for QCD in "region" using setup""" return def _fittedTransferFactor(self, channel, setup, qcdUpdates=None, overwrite=False): """Estimate transfer factor for QCD in "region" using setup""" return def _dataDrivenFakeCorrectionFactor(self, region, channel, setup, overwrite=False): """Estimate fake factor for hadronic fakes in "region" using setup""" return def TransferFactorStatistic(self, region, channel, setup): ref = self.cachedTransferFactor(channel, setup) up = u_float(ref.val + ref.sigma) down = u_float(ref.val - ref.sigma) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def TuneSystematic(self, region, channel, setup): up = self.cachedEstimate(region, channel, setup, signalAddon="TuneUp") down = self.cachedEstimate(region, channel, setup, signalAddon="TuneDown") ref = self.cachedEstimate(region, channel, setup) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def topPtSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightTopPt"]})) return abs((up-ref)/ref) if ref > 0 else up def ErdOnSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup, signalAddon="erdOn") return abs((up-ref)/ref) if ref > 0 else up def QCDbasedSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup, signalAddon="QCDbased") return abs((up-ref)/ref) if ref > 0 else up def GluonMoveSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup, signalAddon="GluonMove") return abs((up-ref)/ref) if ref > 0 else up def PUSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightPUUp"]})) down = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightPUDown"]})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def EERSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"eResUp"})) down = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"eResDown"})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def EESSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"eScaleUp"})) down = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"eScaleDown"})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) # def MERSystematic(self, region, channel, setup): # ref = self.cachedEstimate(region, channel, setup) # up = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"muTotalUp"})) # down = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"muTotalDown"})) # return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def JERSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"jerUp"})) down = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"jerDown"})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def JECSystematic(self, region, channel, setup, jes="Total"): ref = self.cachedEstimate(region, channel, setup) if ref == 0: return u_float(0,0) up = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"jes%sUp"%jes})) down = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"jes%sDown"%jes})) unc = abs(0.5*(up-down)/ref) if unc.val == 0: uncUp = abs((ref-up)/ref) uncDown = abs((ref-down)/ref) unc = uncUp if uncUp.val >= uncDown.val else uncDown if unc.val == 0: return u_float(0,0) return unc def unclusteredSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"unclustEnUp"})) down = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"unclustEnDown"})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def L1PrefireSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightL1PrefireUp"]})) down = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightL1PrefireDown"]})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def btaggingSFbSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightBTag_SF_b_Up"]})) down = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightBTag_SF_b_Down"]})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def btaggingSFlSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightBTag_SF_l_Up"]})) down = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightBTag_SF_l_Down"]})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def leptonSFSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightLeptonTightSFUp"]})) down = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightLeptonTightSFDown"]})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def leptonSFStatSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightLeptonTightSFStatUp"]})) down = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightLeptonTightSFStatDown"]})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def leptonSFSystSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightLeptonTightSFSystUp"]})) down = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightLeptonTightSFSystDown"]})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def leptonTrackingSFSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightLeptonTrackingTightSFUp"]})) down = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightLeptonTrackingTightSFDown"]})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def photonSFSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightPhotonSFUp"]})) down = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightPhotonSFDown"]})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def photonSFAltSigSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightPhotonSFAltSigUp"]})) down = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightPhotonSFAltSigDown"]})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def photonElectronVetoSFSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightPhotonElectronVetoSFUp"]})) down = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightPhotonElectronVetoSFDown"]})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def triggerSystematic(self, region, channel, setup): ref = self.cachedEstimate(region, channel, setup) up = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightTriggerUp"]})) down = self.cachedEstimate(region, channel, setup.sysClone({"reweight":["reweightTriggerDown"]})) return abs(0.5*(up-down)/ref) if ref > 0 else u_float(0,0) def getBkgSysJobs(self, region, channel, setup): l = [ (region, channel, setup.sysClone({"reweight":["reweightTopPt"]}), None), (region, channel, setup.sysClone({"reweight":["reweightPUUp"]}), None), (region, channel, setup.sysClone({"reweight":["reweightPUDown"]}), None), (region, channel, setup.sysClone({"selectionModifier":"eScaleUp"}), None), (region, channel, setup.sysClone({"selectionModifier":"eScaleDown"}), None), (region, channel, setup.sysClone({"selectionModifier":"eResUp"}), None), (region, channel, setup.sysClone({"selectionModifier":"eResDown"}), None), # (region, channel, setup.sysClone({"selectionModifier":"muTotalUp"}), None), # (region, channel, setup.sysClone({"selectionModifier":"muTotalDown"}), None), (region, channel, setup.sysClone({"selectionModifier":"jerUp"}), None), (region, channel, setup.sysClone({"selectionModifier":"jerDown"}), None), # (region, channel, setup.sysClone({"selectionModifier":"jesTotalUp"}), None), # (region, channel, setup.sysClone({"selectionModifier":"jesTotalDown"}), None), # (region, channel, setup.sysClone({"selectionModifier":"unclustEnUp"}), None), # (region, channel, setup.sysClone({"selectionModifier":"unclustEnDown"}), None), (region, channel, setup.sysClone({"reweight":["reweightL1PrefireUp"]}), None), (region, channel, setup.sysClone({"reweight":["reweightL1PrefireDown"]}), None), (region, channel, setup.sysClone({"reweight":["reweightBTag_SF_b_Up"]}), None), (region, channel, setup.sysClone({"reweight":["reweightBTag_SF_b_Down"]}), None), (region, channel, setup.sysClone({"reweight":["reweightBTag_SF_l_Up"]}), None), (region, channel, setup.sysClone({"reweight":["reweightBTag_SF_l_Down"]}), None), (region, channel, setup.sysClone({"reweight":["reweightLeptonTrackingTightSFUp"]}), None), (region, channel, setup.sysClone({"reweight":["reweightLeptonTrackingTightSFDown"]}), None), (region, channel, setup.sysClone({"reweight":["reweightPhotonSFUp"]}), None), (region, channel, setup.sysClone({"reweight":["reweightPhotonSFDown"]}), None), (region, channel, setup.sysClone({"reweight":["reweightPhotonSFAltSigUp"]}), None), (region, channel, setup.sysClone({"reweight":["reweightPhotonSFAltSigDown"]}), None), (region, channel, setup.sysClone({"reweight":["reweightPhotonElectronVetoSFUp"]}), None), (region, channel, setup.sysClone({"reweight":["reweightPhotonElectronVetoSFDown"]}), None), (region, channel, setup.sysClone({"reweight":["reweightTriggerUp"]}), None), (region, channel, setup.sysClone({"reweight":["reweightTriggerDown"]}), None), (region, channel, setup.sysClone({"reweight":["reweightLeptonTightSFStatUp"]}), None), (region, channel, setup.sysClone({"reweight":["reweightLeptonTightSFStatDown"]}), None), (region, channel, setup.sysClone({"reweight":["reweightLeptonTightSFSystUp"]}), None), (region, channel, setup.sysClone({"reweight":["reweightLeptonTightSFSystDown"]}), None), (region, channel, setup.sysClone({"reweight":["reweightLeptonTightSFUp"]}), None), (region, channel, setup.sysClone({"reweight":["reweightLeptonTightSFDown"]}), None), ] # JEC Tags, (standard is "Total") jesTags = ['FlavorQCD', 'RelativeBal', 'HF', 'BBEC1', 'EC2', 'Absolute', 'Absolute_%i'%setup.year, 'HF_%i'%setup.year, 'EC2_%i'%setup.year, 'RelativeSample_%i'%setup.year, 'BBEC1_%i'%setup.year] for jes in jesTags: l += [ (region, channel, setup.sysClone({"selectionModifier":"jes%sUp"%jes}), None), (region, channel, setup.sysClone({"selectionModifier":"jes%sDown"%jes}), None), ] return l def getSigSysJobs(self, region, channel, setup): # in case there is a difference, enter it here (originally for fastSim) l = self.getBkgSysJobs(region = region, channel = channel, setup = setup) l += [ (region, channel, setup, "TuneUp"), (region, channel, setup, "TuneDown"), (region, channel, setup, "erdOn"), (region, channel, setup, "QCDbased"), (region, channel, setup, "GluonMove"), ] return l def getTexName(self, channel, rootTex=True): try: name = self.texName except: try: name = self.process[channel].texName except: try: texNames = [self.process[c].texName for c in allChannels] # If all, only take texName if it is the same for all lepChannels if texNames.count(texNames[0]) == len(texNames): name = texNames[0] else: name = self.name except: name = self.name if not rootTex: name = "$" + name.replace("#","\\") + "$" # Make it tex format return name
addSel = cutInterpreter.cutString( addSel ) print addSel for iso, invIso in replaceSelection.iteritems(): addSel = addSel.replace(iso,invIso) print preSelection print addSel preSelection += "&&" + addSel else: raise Exception("Region not implemented") key = (data_sample.name, "mTinv", "_".join(map(str,binning)), data_sample.weightString, data_sample.selectionString, preSelection) if dirDB.contains(key) and not args.overwrite: dataHist_SB = dirDB.get(key).Clone("mTinv") else: dataHist_SB = data_sample.get1DHistoFromDraw( mTinv, binning=binning, selectionString=preSelection, addOverFlowBin="upper" ) dirDB.add(key, dataHist_SB.Clone("mTinv"), overwrite=True) key = (data_sample.name, "mT", "_".join(map(str,binning)), data_sample.weightString, data_sample.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist = dirDB.get(key).Clone("mT") else: dataHist = data_sample.get1DHistoFromDraw( "mT", binning=binning, selectionString=selection, addOverFlowBin="upper" ) dirDB.add(key, dataHist.Clone("mT"), overwrite=True) qcdHist = dataHist_SB.Clone("QCD") dataHist_SB.style = styles.errorStyle( ROOT.kBlack ) dataHist_SB.legendText = "Observed (%s)"%args.mode.replace("mu","#mu") dataHist.style = styles.errorStyle( ROOT.kBlack ) dataHist.legendText = "Observed (%s)"%args.mode.replace("mu","#mu") qcdHist.style = styles.fillStyle( color.QCD )
# Plot ranges polString = "[0]*x**2+[1]*x**3+[2]*x**4+[3]*x**5+[4]*x**6+[5]*x**7+[6]*x**8" # get TGraph from results data list xhist = toGraph( "f", "f", results ) func = ROOT.TF1("func",polString,args.binning[1], args.binning[2] ) func.SetNpx(10000) xhist.Fit(func,"NO") x68max = func.GetX( 0.989, args.binning[1], args.binning[2] ) x95max = func.GetX( 3.84, args.binning[1], args.binning[2] ) xmax = func.GetX( args.yRange[1], args.binning[1], args.binning[2] ) sConfig = "_".join( [args.sample, args.selection, args.pdf] ) res = { 95:x95max, 68:x68max } limitCache.add( sConfig, res, overwrite=True ) xhist.SetLineWidth(0) func.SetFillColor(ROOT.kWhite) func.SetFillStyle(1001) func.SetLineWidth(3) func.SetLineColor(ROOT.kBlack) print '68', x68max print '95', x95max ROOT.gStyle.SetPadLeftMargin(0.14) ROOT.gStyle.SetPadRightMargin(0.1) ROOT.gStyle.SetPadTopMargin(0.11)
if event.PhotonNoChgIsoNoSieie0_photonCatMagic == 2 and event.year == 2017 else 1.) * (misIDSF_val[2018].val if event.PhotonNoChgIsoNoSieie0_photonCatMagic == 2 and event.year == 2018 else 1.) for s in mc: s.setWeightString(weightStringAR) key = (s.name, "AR", args.variable, "_".join(map(str, args.binning)), s.weightString, s.selectionString, selection) if dirDB.contains(key) and not args.overwrite: s.hist = copy.deepcopy(dirDB.get(key).Clone(s.name + "AR")) else: s.hist = s.get1DHistoFromDraw( args.variable, binning=args.binning, selectionString=selection) #, addOverFlowBin="upper" ) dirDB.add(key, s.hist.Clone("%s_AR" % s.name)) s.style = styles.lineStyle(s.color, width=2, dotted=False, dashed=False, errors=True) s.hist.style = styles.lineStyle(s.color, width=2, dotted=False, dashed=False, errors=True) s.hist.legendText = s.texName histos = [[s.hist] for s in mc]
selection = cutInterpreter.cutString(selection) selection += "&&pTStitching==1&&triggered==1" print selection if args.addCut: selection += "&&" + cutInterpreter.cutString(args.addCut) print("Using selection string: %s" % selection) key = (mc_e.name, "AR", args.variable, "_".join(map(str, args.binning)), mc_e.weightString, mc_e.selectionString, selection) if dirDB.contains(key) and not args.overwrite: mcHist_e = dirDB.get(key.Clone("e")) else: mcHist_e = mc_e.get1DHistoFromDraw(args.variable, binning=args.binning, selectionString=selection) dirDB.add(key, mcHist_e.Clone("e"), overwrite=True) key = (mc_mu.name, "AR", args.variable, "_".join(map(str, args.binning)), mc_mu.weightString, mc_mu.selectionString, selection) if dirDB.contains(key) and not args.overwrite: mcHist_mu = dirDB.get(key.Clone("mu")) else: mcHist_mu = mc_mu.get1DHistoFromDraw(args.variable, binning=args.binning, selectionString=selection) dirDB.add(key, mcHist_mu.Clone("mu"), overwrite=True) mcHist_mu.style = styles.lineStyle(ROOT.kBlack, width=2, errors=True) mcHist_mu.legendText = "MC (#mu)" mcHist_e.style = styles.lineStyle(ROOT.kRed, width=2, errors=True)
preSelection = preSelection.replace(iso, invIso) addSel = addSel.replace(iso, invIso) preSelection += "&&" + addSel else: raise Exception("Region not implemented") key = (data_sample.name, "mTinv", "_".join(map(str, binning)), data_sample.weightString, data_sample.selectionString, preSelection) if dirDB.contains(key) and not args.overwrite: dataHist_SB = dirDB.get(key) else: dataHist_SB = data_sample.get1DHistoFromDraw(mTinv, binning=binning, selectionString=preSelection, addOverFlowBin="upper") dirDB.add(key, dataHist_SB) key = (data_sample.name, "mT", "_".join(map(str, binning)), data_sample.weightString, data_sample.selectionString, selection) if dirDB.contains(key) and not args.overwrite: dataHist = dirDB.get(key) else: dataHist = data_sample.get1DHistoFromDraw("mT", binning=binning, selectionString=selection, addOverFlowBin="upper") dirDB.add(key, dataHist) qcdHist = dataHist_SB.Clone("QCD") dataHist_SB.style = styles.errorStyle(ROOT.kBlack)