def doSystematicsVariation(myMulticrabDir,era,searchMode,optimizationMode,syst,myOutputCreator,myShapeString,myNormFactors):
myModuleInfoString = "%s_%s_%s_%s"%(era, searchMode, optimizationMode,syst)
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
systDsetMgr = dsetMgrCreator.createDatasetManager(dataEra=era,searchMode=searchMode,optimizationMode=optimizationMode,systematicVariation=syst)
# Do the usual normalisation
systDsetMgr.updateNAllEventsToPUWeighted()
systDsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(systDsetMgr)
systDsetMgr.merge("EWK", ["TTJets","WJets","DYJetsToLL","SingleTop","Diboson"])
myLuminosity = systDsetMgr.getDataset("Data").getLuminosity()
# Obtain results
mySystModuleResults = pseudoMultiCrabCreator.PseudoMultiCrabModule(systDsetMgr, era, searchMode, optimizationMode, syst)
mySystResult = qcdInvertedResult.QCDInvertedResultManager(myShapeString, "AfterCollinearCuts", systDsetMgr, myLuminosity, myModuleInfoString, myNormFactors, shapeOnly=False, displayPurityBreakdown=False, noRebin=True)
mySystModuleResults.addShape(mySystResult.getShape(), myShapeString)
mySystModuleResults.addShape(mySystResult.getShapeMCEWK(), myShapeString+"_MCEWK")
mySystModuleResults.addShape(mySystResult.getShapePurity(), myShapeString+"_Purity")
mySystModuleResults.addDataDrivenControlPlots(mySystResult.getControlPlots(),mySystResult.getControlPlotLabels())
mySystResult.delete()
## Save module info
myOutputCreator.addModule(mySystModuleResults)
systDsetMgr.close()
dsetMgrCreator.close()
ROOT.gROOT.CloseFiles()
ROOT.gROOT.GetListOfCanvases().Delete()
ROOT.gDirectory.GetList().Delete()
def doSystematicsVariation(myMulticrabDir,era,searchMode,optimizationMode,syst,myOutputCreator,myShapeString):
myModuleInfoString = "%s_%s_%s_%s"%(era, searchMode, optimizationMode,syst)
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
systDsetMgr = dsetMgrCreator.createDatasetManager(dataEra=era,searchMode=searchMode,optimizationMode=optimizationMode,systematicVariation=syst)
# Do the usual normalisation
systDsetMgr.updateNAllEventsToPUWeighted()
systDsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(systDsetMgr)
systDsetMgr.merge("EWK", ["TTJets","WJets","DYJetsToLL","SingleTop","Diboson"])
myLuminosity = systDsetMgr.getDataset("Data").getLuminosity()
# Obtain results
mySystModuleResults = PseudoMultiCrabModule(systDsetMgr, era, searchMode, optimizationMode, syst)
mySystResult = None
if massType == "mt":
mySystResult = QCDFactorisedResultManager(myMtSpecs,systDsetMgr,myLuminosity,myModuleInfoString,shapeOnly=False)
elif massType == "invmass":
mySystResult = QCDFactorisedResultManager(myFullMassSpecs,systDsetMgr,myLuminosity,myModuleInfoString,shapeOnly=False)
mySystModuleResults.addShape(mySystResult.getShape(), myShapeString)
mySystModuleResults.addShape(mySystResult.getShapeMCEWK(), myShapeString+"_MCEWK")
mySystModuleResults.addShape(mySystResult.getShapePurity(), myShapeString+"_Purity")
mySystModuleResults.addDataDrivenControlPlots(mySystResult.getControlPlots(),mySystResult.getControlPlotLabels())
mySystResult.delete()
## Save module info
myOutputCreator.addModule(mySystModuleResults)
systDsetMgr.close()
dsetMgrCreator.close()
ROOT.gROOT.CloseFiles()
ROOT.gROOT.GetListOfCanvases().Delete()
def __init__(self, directories, **kwargs):
if len(directories) == 0:
raise Exception("Need at least one directory")
self._creators = filter(lambda c: c is not None, [
dataset.readFromMulticrabCfg(directory=d, **kwargs)
for d in directories
])
def main():
creator = dataset.readFromMulticrabCfg()
datasets = creator.createDatasetManager(dataEra=dataEra)
if not mcOnly:
datasets.loadLuminosities()
datasets.updateNAllEventsToPUWeighted()
plots.mergeRenameReorderForDataMC(datasets)
if not mcOnly:
mcOnlyLumi = datasets.getDataset("Data").getLuminosity()
datasets.remove(datasets.getDataDatasetNames())
histograms.cmsTextMode = histograms.CMSMode.SIMULATION
histograms.createLegend.moveDefaults(dx=-0.05, dh=-0.15)
xsect.setHplusCrossSectionsToBR(datasets, br_tH=0.01, br_Htaunu=1)
for dset in datasets.getAllDatasets():
if "HplusTB_" in dset.getName():
dset.setCrossSection(1.0)
plots.mergeWHandHH(datasets)
datasets.merge("EWK", ["TTJets",
"WJets",
"DYJetsToLL",
"SingleTop", "Diboson"
], keepSources=True)
style = tdrstyle.TDRStyle()
# Setup the systematics recipe object
systematics = dataset.Systematics(
allShapes=True,
#shapes=["SystVarJER", "SystVarJES", "SystVarMET", "SystVarTES"],
#verbose=True,
#additionalNormalizations={"Foo": 0.2, "Bar": 0.05},
)
histograms.uncertaintyMode.set(histograms.Uncertainty.StatOnly)
def dop(datasetName):
doPlots(datasets, datasetName, systematics)
doCounters(datasets, datasetName, creator.getSystematicVariationSources())
# dop("TTToHplus_M80")
dop("TTToHplus_M120")
# dop("TTToHplus_M160")
# dop("HplusTB_M180")
dop("HplusTB_M200")
# dop("HplusTB_M300")
dop("TTJets")
# dop("DYJetsToLL")
dop("WJets")
dop("EWK")
def doSystematicsVariation(myMulticrabDir, era, searchMode, optimizationMode,
syst, myOutputCreator, myShapeString, myNormFactors,
dataDrivenFakeTaus):
myModuleInfoString = "%s_%s_%s_%s" % (era, searchMode, optimizationMode,
syst)
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
systDsetMgr = dsetMgrCreator.createDatasetManager(
dataEra=era,
searchMode=searchMode,
optimizationMode=optimizationMode,
systematicVariation=syst)
# Do the usual normalisation
systDsetMgr.updateNAllEventsToPUWeighted()
systDsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(systDsetMgr)
systDsetMgr.merge(
"EWK", ["TTJets", "WJets", "DYJetsToLL", "SingleTop", "Diboson"])
myLuminosity = systDsetMgr.getDataset("Data").getLuminosity()
myFakeRateCalculator = fakeRate.FakeRateCalculator(
systDsetMgr,
myShapeString,
myNormFactors,
myLuminosity,
dataDrivenFakeTaus=dataDrivenFakeTaus)
# Obtain results
mySystModuleResults = pseudoMultiCrabCreator.PseudoMultiCrabModule(
systDsetMgr, era, searchMode, optimizationMode, syst)
mySystResult = qcdInvertedResult.QCDInvertedResultManager(
myShapeString,
"AfterCollinearCuts",
systDsetMgr,
myLuminosity,
myModuleInfoString,
myFakeRateCalculator.getTotalFakeRateProbabilities(),
dataDrivenFakeTaus=dataDrivenFakeTaus,
shapeOnly=False,
displayPurityBreakdown=False,
noRebin=True)
mySystModuleResults.addShape(mySystResult.getShape(), myShapeString)
mySystModuleResults.addShape(mySystResult.getShapeMCEWK(),
myShapeString + "_MCEWK")
mySystModuleResults.addShape(mySystResult.getShapePurity(),
myShapeString + "_Purity")
mySystModuleResults.addDataDrivenControlPlots(
mySystResult.getControlPlots(), mySystResult.getControlPlotLabels())
mySystResult.delete()
## Save module info
myOutputCreator.addModule(mySystModuleResults)
systDsetMgr.close()
dsetMgrCreator.close()
ROOT.gROOT.CloseFiles()
ROOT.gROOT.GetListOfCanvases().Delete()
ROOT.gDirectory.GetList().Delete()
def doNominalModule(myMulticrabDir,era,searchMode,optimizationMode,myOutputCreator,myShapeString,myNormFactors,myDisplayStatus):
# Construct info string of module
myModuleInfoString = "%s_%s_%s"%(era, searchMode, optimizationMode)
# Obtain dataset manager
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
dsetMgr = dsetMgrCreator.createDatasetManager(dataEra=era,searchMode=searchMode,optimizationMode=optimizationMode)
# Do the usual normalisation
dsetMgr.updateNAllEventsToPUWeighted()
dsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsetMgr)
dsetMgr.merge("EWK", ["TTJets","WJets","DYJetsToLL","SingleTop","Diboson"])
# Obtain luminosity
myLuminosity = dsetMgr.getDataset("Data").getLuminosity()
# Print info so that user can check that merge went correct
if myDisplayStatus:
dsetMgr.printDatasetTree()
print "Luminosity = %f 1/fb"%(myLuminosity / 1000.0)
print
myDisplayStatus = False
# Gather results
# Create containers for results
myModuleResults = pseudoMultiCrabCreator.PseudoMultiCrabModule(dsetMgr, era, searchMode, optimizationMode)
myQCDNormalizationSystResults = pseudoMultiCrabCreator.PseudoMultiCrabModule(dsetMgr, era, searchMode, optimizationMode, "SystVarQCDNormSource")
# Obtain results
myResult = qcdInvertedResult.QCDInvertedResultManager(myShapeString, "AfterCollinearCuts", dsetMgr, myLuminosity, myModuleInfoString, myNormFactors, shapeOnly=False, displayPurityBreakdown=True, noRebin=True)
# Store results
myModuleResults.addShape(myResult.getShape(), myShapeString)
myModuleResults.addShape(myResult.getShapeMCEWK(), myShapeString+"_MCEWK")
myModuleResults.addShape(myResult.getShapePurity(), myShapeString+"_Purity")
myModuleResults.addDataDrivenControlPlots(myResult.getControlPlots(),myResult.getControlPlotLabels())
myOutputCreator.addModule(myModuleResults)
# Up variation of QCD normalization (i.e. ctrl->signal region transition)
# Note that only the source histograms for the shape uncert are stored
# because the result must be calculated after rebinning
# (and rebinning is no longer done here for flexibility reasons)
myQCDNormalizationSystResults.addShape(myResult.getRegionSystNumerator(), myShapeString+"Numerator")
myQCDNormalizationSystResults.addShape(myResult.getRegionSystDenominator(), myShapeString+"Denominator")
myLabels = myResult.getControlPlotLabelsForQCDSyst()
for i in range(0,len(myLabels)):
myLabels[i] = myLabels[i]+"Numerator"
myQCDNormalizationSystResults.addDataDrivenControlPlots(myResult.getRegionSystNumeratorCtrlPlots(),myLabels)
for i in range(0,len(myLabels)):
myLabels[i] = myLabels[i].replace("Numerator","Denominator")
myQCDNormalizationSystResults.addDataDrivenControlPlots(myResult.getRegionSystDenominatorCtrlPlots(),myLabels)
myOutputCreator.addModule(myQCDNormalizationSystResults)
# Clean up
myResult.delete()
dsetMgr.close()
dsetMgrCreator.close()
ROOT.gROOT.CloseFiles()
ROOT.gROOT.GetListOfCanvases().Delete()
ROOT.gDirectory.GetList().Delete()
def doNominalModule(myMulticrabDir,era,searchMode,optimizationMode,myOutputCreator,myShapeString,myDisplayStatus):
# Construct info string of module
myModuleInfoString = "%s_%s_%s"%(era, searchMode, optimizationMode)
# Obtain dataset manager
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
dsetMgr = dsetMgrCreator.createDatasetManager(dataEra=era,searchMode=searchMode,optimizationMode=optimizationMode)
# Do the usual normalisation
dsetMgr.updateNAllEventsToPUWeighted()
dsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsetMgr)
dsetMgr.merge("EWK", ["TTJets","WJets","DYJetsToLL","SingleTop","Diboson"])
# Obtain luminosity
myLuminosity = dsetMgr.getDataset("Data").getLuminosity()
# Print info so that user can check that merge went correct
if myDisplayStatus:
dsetMgr.printDatasetTree()
print "Luminosity = %f 1/fb"%(myLuminosity / 1000.0)
print
myDisplayStatus = False
# Gather results
# Create containers for results
myModuleResults = PseudoMultiCrabModule(dsetMgr, era, searchMode, optimizationMode)
myQCDNormalizationSystUpResults = PseudoMultiCrabModule(dsetMgr, era, searchMode, optimizationMode, "SystVarQCDNormPlus")
myQCDNormalizationSystDownResults = PseudoMultiCrabModule(dsetMgr, era, searchMode, optimizationMode, "SystVarQCDNormMinus")
# Obtain results
myResult = None
if massType == "mt":
myResult = QCDFactorisedResultManager(myMtSpecs,dsetMgr,myLuminosity,myModuleInfoString,shapeOnly=False,displayPurityBreakdown=True)
elif massType == "invmass":
myResult = QCDFactorisedResultManager(myFullMassSpecs,dsetMgr,myLuminosity,myModuleInfoString,shapeOnly=False,displayPurityBreakdown=True)
myModuleResults.addShape(myResult.getShape(), myShapeString)
myModuleResults.addShape(myResult.getShapeMCEWK(), myShapeString+"_MCEWK")
myModuleResults.addShape(myResult.getShapePurity(), myShapeString+"_Purity")
myModuleResults.addDataDrivenControlPlots(myResult.getControlPlots(),myResult.getControlPlotLabels())
myOutputCreator.addModule(myModuleResults)
# Up variation of QCD normalization (i.e. ctrl->signal region transition)
myQCDNormalizationSystUpResults.addShape(myResult.getRegionSystUp(), myShapeString)
myQCDNormalizationSystUpResults.addDataDrivenControlPlots(myResult.getRegionSystUpCtrlPlots(),myResult.getControlPlotLabelsForQCDSyst())
myOutputCreator.addModule(myQCDNormalizationSystUpResults)
# Down variation of QCD normalization (i.e. ctrl->signal region transition)
myQCDNormalizationSystDownResults.addShape(myResult.getRegionSystDown(), myShapeString)
myQCDNormalizationSystDownResults.addDataDrivenControlPlots(myResult.getRegionSystDownCtrlPlots(),myResult.getControlPlotLabelsForQCDSyst())
myOutputCreator.addModule(myQCDNormalizationSystDownResults)
myResult.delete()
dsetMgr.close()
dsetMgrCreator.close()
ROOT.gROOT.CloseFiles()
ROOT.gROOT.GetListOfCanvases().Delete()
def doSystematicsVariation(myMulticrabDir, era, searchMode, optimizationMode,
syst, myOutputCreator, myShapeString):
myModuleInfoString = "%s_%s_%s_%s" % (era, searchMode, optimizationMode,
syst)
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
systDsetMgr = dsetMgrCreator.createDatasetManager(
dataEra=era,
searchMode=searchMode,
optimizationMode=optimizationMode,
systematicVariation=syst)
# Do the usual normalisation
systDsetMgr.updateNAllEventsToPUWeighted()
systDsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(systDsetMgr)
systDsetMgr.merge(
"EWK", ["TTJets", "WJets", "DYJetsToLL", "SingleTop", "Diboson"])
myLuminosity = systDsetMgr.getDataset("Data").getLuminosity()
# Obtain results
mySystModuleResults = PseudoMultiCrabModule(systDsetMgr, era, searchMode,
optimizationMode, syst)
mySystResult = None
if massType == "mt":
mySystResult = QCDFactorisedResultManager(myMtSpecs,
systDsetMgr,
myLuminosity,
myModuleInfoString,
shapeOnly=False)
elif massType == "invmass":
mySystResult = QCDFactorisedResultManager(myFullMassSpecs,
systDsetMgr,
myLuminosity,
myModuleInfoString,
shapeOnly=False)
mySystModuleResults.addShape(mySystResult.getShape(), myShapeString)
mySystModuleResults.addShape(mySystResult.getShapeMCEWK(),
myShapeString + "_MCEWK")
mySystModuleResults.addShape(mySystResult.getShapePurity(),
myShapeString + "_Purity")
mySystModuleResults.addDataDrivenControlPlots(
mySystResult.getControlPlots(), mySystResult.getControlPlotLabels())
mySystResult.delete()
## Save module info
myOutputCreator.addModule(mySystModuleResults)
systDsetMgr.close()
dsetMgrCreator.close()
ROOT.gROOT.CloseFiles()
ROOT.gROOT.GetListOfCanvases().Delete()
if opts.multicrabDir != None:
myMulticrabDir = opts.multicrabDir
if not os.path.exists("%s/multicrab.cfg" % myMulticrabDir):
raise Exception(
ErrorLabel() +
"No multicrab directory found at path '%s'! Please check path or specify it with --mdir!"
% (myMulticrabDir) + NormalStyle())
myShapes = ["mt", "invmass"]
if opts.transverseMassOnly != None and opts.transverseMassOnly:
myShapes = ["mt"]
elif opts.invariantMassOnly != None and opts.invariantMassOnly:
myShapes = ["invmass"]
# Obtain dsetMgrCreator and register it to module selector
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
# Obtain systematics names
mySystematicsNamesRaw = dsetMgrCreator.getSystematicVariationSources()
mySystematicsNames = []
for item in mySystematicsNamesRaw:
mySystematicsNames.append("%sPlus" % item)
mySystematicsNames.append("%sMinus" % item)
if opts.test:
mySystematicsNames = [mySystematicsNames[0]]
myModuleSelector.setPrimarySource("analysis", dsetMgrCreator)
# Select modules
myModuleSelector.doSelect(opts)
#dsetMgrCreator.close()
# Loop over era/searchMode/optimizationMode combos
myDisplayStatus = True
def main():
if len(sys.argv) == 1:
usage()
if not QCDInvertedDir(sys.argv[1:]):
print "No QCD inverted dir recognized from input",sys.argv[1:]
usage()
dirQCDInv = sys.argv[1]
dirs = []
dirs.append(dirQCDInv)
print "QCDInverted multicrab directory",dirQCDInv
print
taskDir = multicrab.createTaskDir("QCDInverted")
f = open(os.path.join(taskDir, "codeVersion.txt"), "w")
f.write(git.getCommitId()+"\n")
f.close()
f = open(os.path.join(taskDir, "codeStatus.txt"), "w")
f.write(git.getStatus()+"\n")
f.close()
f = open(os.path.join(taskDir, "codeDiff.txt"), "w")
f.write(git.getDiff()+"\n")
f.close()
f = open(os.path.join(taskDir, "inputInfo.txt"), "w")
f.write("Original directory:\n%s\n\n" % "\n".join(dirQCDInv))
f.write("\nQCDInverted analysis: %s\n" % analysis)
f.close()
f = open(os.path.join(taskDir, "multicrab.cfg"), "w")
f.write("[Data]\n")
f.write("CMSSW.pset = signalAnalysisInvertedTau_cfg.py\n")
f.close()
creator = dataset.readFromMulticrabCfg(directory=dirQCDInv)
optModes = []#creator.getOptimizationModes()
optModes.append("")
dataEras = creator.getDataEras()
dataEras = []
# dataEras.append("Run2011A")
# dataEras.append("Run2011AB")
dataEras.append("Run2011B")
print "optModes",optModes
print "dataEras",dataEras
directory = os.path.join(taskDir, "Data", "res")
os.makedirs(directory)
fOUT = ROOT.TFile.Open(os.path.join(directory, "histograms-Data.root"), "RECREATE")
lumiSaved = False
for optMode in optModes:
for dataEra in dataEras:
datasetsQCDInv = creator.createDatasetManager(dataEra=dataEra, searchMode=searchMode, analysisName=analysis, optimizationMode=optMode)
datasetsQCDInv.loadLuminosities()
datasetsQCDInv.updateNAllEventsToPUWeighted()
plots.mergeRenameReorderForDataMC(datasetsQCDInv)
datasetsQCDInv.mergeData()
datasetsQCDInv.merge("EWK", ["WJets", "DYJetsToLL", "SingleTop", "Diboson","TTJets"], keepSources=True)
if not lumiSaved:
# Save luminosity
data = {"Data": datasetsQCDInv.getDataset("Data").getLuminosity()}
f = open(os.path.join(taskDir, "lumi.json"), "w")
json.dump(data, f, indent=2)
f.close()
lumiSaved = True
anadir = fOUT.mkdir(analysis+searchMode+dataEra+optMode)
anadir.cd()
integrals = []
for massPlot in massPlots:
print "Processing",massPlot
massPlotDir = anadir.mkdir(massPlot)
anadir.cd(massPlot)
integral = write(fOUT,datasetsQCDInv,[massPlot])
integrals.append(integral[0])
for controlPlot in controlPlots:
print "Processing",controlPlot
controlPlotDir = anadir.mkdir(controlPlot)
anadir.cd(controlPlot)
controlPlotNames = datasetsQCDInv.getDataset("Data").getDirectoryContent(controlPlot)
controlPlotNamesWithPaths = []
for controlPlotName in controlPlotNames:
controlPlotNamesWithPaths.append(os.path.join(controlPlot,controlPlotName))
write(fOUT,datasetsQCDInv,controlPlotNamesWithPaths)
anadir.cd()
counterdir = anadir.mkdir("counters")
anadir.cd("counters")
counter = ROOT.TH1D("counter","counter",len(integrals),0,len(integrals))
for i,integral in enumerate(integrals):
binLabel = "integral_"+massPlots[i]
counter.SetBinContent(i+1,integral)
counter.GetXaxis().SetBinLabel(i+1,binLabel)
counter.Write()
weighteddir = counterdir.mkdir("weighted")
weighteddir.cd()
counter.Write()
addConfigInfo(fOUT, datasetsQCDInv.getDataset("Data"))
fOUT.Close()
print "Created multicrab-like dir for LandS:",taskDir
# Call the main function if the script is executed (i.e. not imported)
if __name__ == "__main__":
myModuleSelector = AnalysisModuleSelector() # Object for selecting data eras, search modes, and optimization modes
parser = OptionParser(usage="Usage: %prog [options]")
myModuleSelector.addParserOptions(parser)
parser.add_option("--noMCQCD", dest="noMCQCD", action="store_true", default=False, help="remove MC QCD")
parser.add_option("--noSignal", dest="noSignal", action="store_true", default=False, help="remove MC QCD")
parser.add_option("--mdir", dest="multicrabDir", help="path to multicrab directory")
(opts, args) = parser.parse_args()
# Get dataset manager creator and handle different era/searchMode/optimizationMode combinations
myPath = "."
if opts.multicrabDir != None:
myPath = opts.multicrabDir
signalDsetCreator = dataset.readFromMulticrabCfg(directory=myPath)
myModuleSelector.setPrimarySource("Signal analysis", signalDsetCreator)
myModuleSelector.doSelect(opts)
# Arguments are ok, proceed to run
myChosenModuleCount = len(myModuleSelector.getSelectedEras())*len(myModuleSelector.getSelectedSearchModes())*len(myModuleSelector.getSelectedOptimizationModes())
print "Will run over %d modules (%d eras x %d searchModes x %d optimizationModes)"%(myChosenModuleCount,len(myModuleSelector.getSelectedEras()),len(myModuleSelector.getSelectedSearchModes()),len(myModuleSelector.getSelectedOptimizationModes()))
myCount = 1
for era in myModuleSelector.getSelectedEras():
for searchMode in myModuleSelector.getSelectedSearchModes():
for optimizationMode in myModuleSelector.getSelectedOptimizationModes():
print "%sProcessing module %d/%d: era=%s searchMode=%s optimizationMode=%s%s"%(HighlightStyle(), myCount, myChosenModuleCount, era, searchMode, optimizationMode, NormalStyle())
main(opts,signalDsetCreator,era,searchMode,optimizationMode)
myCount += 1
print "\n%sPlotting done.%s"%(HighlightStyle(),NormalStyle())
def main(argv):
dirs = []
if len(sys.argv) < 2:
usage()
myMulticrabDir = sys.argv[1]
# Obtain normalization factors
myNormalizationFactorSource = "QCDInvertedNormalizationFactors.py"
myNormFactors = None
myNormFactorsSafetyCheck = None
if os.path.exists(myNormalizationFactorSource):
myNormFactorsImport = getattr(__import__(myNormalizationFactorSource.replace(".py","")), "QCDInvertedNormalization")
myNormFactorsSafetyCheck = getattr(__import__(myNormalizationFactorSource.replace(".py","")), "QCDInvertedNormalizationSafetyCheck")
#QCDInvertedNormalizationSafetyCheck(era)
myNormFactors = myNormFactorsImport.copy()
else:
raise Exception(ErrorLabel()+"Normalisation factors ('%s.py') not found!\nRun script InvertedTauID_Normalization.py to generate the normalization factors."%myNormalizationFactorSource)
myModuleSelector = AnalysisModuleSelector() # Object for selecting data eras, search modes, and optimization modes
parser = OptionParser(usage="Usage: %prog [options]",add_help_option=True,conflict_handler="resolve")
myModuleSelector.addParserOptions(parser)
parser.add_option("--mdir", dest="multicrabDir", action="store", help="Multicrab directory")
# Add here parser options, if necessary, following line is an example
#parser.add_option("--showcard", dest="showDatacard", action="store_true", default=False, help="Print datacards also to screen")
# Parse options
(opts, args) = parser.parse_args()
# Obtain multicrab directory
#myMulticrabDir = "../FakeTauComparison_140603_182139/"
if opts.multicrabDir != None:
myMulticrabDir = opts.multicrabDir
# Obtain dsetMgrCreator and register it to module selector
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
myModuleSelector.setPrimarySource("analysis", dsetMgrCreator)
# Select modules
myModuleSelector.doSelect(opts)
# Apply TDR style
style = tdrstyle.TDRStyle()
histograms.createLegend.moveDefaults(dx=-0.1, dh=-0.15)
# Give more space for digits on the y axis labels
style.tdrStyle.SetPadLeftMargin(0.19)
style.tdrStyle.SetTitleYOffset(1.6)
optModes = []
optModes.append("OptQCDTailKillerLoosePlus")
myDisplayStatus = True
# Loop over era/searchMode/optimizationMode options
for era in myModuleSelector.getSelectedEras():
for searchMode in myModuleSelector.getSelectedSearchModes():
for optimizationMode in optModes: #myModuleSelector.getSelectedOptimizationModes():
# Construct info string of module
myModuleInfoString = "%s_%s_%s"%(era, searchMode, optimizationMode)
print HighlightStyle()+"Module:",myModuleInfoString,NormalStyle()
# Obtain dataset manager
dsetMgr = dsetMgrCreator.createDatasetManager(dataEra=era,searchMode=searchMode,optimizationMode=optimizationMode)
# Do the usual normalisation
dsetMgr.updateNAllEventsToPUWeighted()
dsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsetMgr)
dsetMgr.merge("EWK", [
"TTJets",
"WJets",
"DYJetsToLL",
"SingleTop",
"Diboson"
])
# Make a directory for output
myDir = "QCDInv_ClosureTest_%s"%myModuleInfoString
createOutputdirectory(myDir)
# Obtain luminosity
myLuminosity = dsetMgr.getDataset("Data").getLuminosity()
# Print info so that user can check that merge went correct
if myDisplayStatus:
dsetMgr.printDatasetTree()
print "Luminosity = %f 1/fb"%(myLuminosity / 1000.0)
print
myDisplayStatus = False
# Run plots
doClosureTestPlots(opts, dsetMgr, myModuleInfoString, myDir, myLuminosity, myNormFactors)
# Check arguments
myStatus = True
if opts.mdir == None:
print "Error: Make sure you provide path to multicrab directory with --mdir!"
myStatus = False
elif not os.path.exists(opts.mdir):
raise Exception("Error: The path '%s' is not valid!"%opts.mdir)
if not myStatus or opts.helpStatus:
print ""
parser.print_help()
sys.exit()
if not opts.histo == None:
histogramName = opts.Histo
# Obtain dsetMgrCreator and register it to module selector
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=opts.mdir)
myModuleSelector.setPrimarySource("analysis", dsetMgrCreator)
myModuleSelector.doSelect(opts)
myModuleSelector.printSelectedCombinationCount()
# Read from multicrab.cfg the number of jobs
myDict = consistencyCheck.getNumberOfJobsFromMultiCrabCfg(opts.mdir)
# Loop over selected modules
myMergedDict = {}
for searchMode in myModuleSelector.getSelectedSearchModes():
for optimizationMode in myModuleSelector.getSelectedOptimizationModes():
for era in myModuleSelector.getSelectedEras():
dsetMgr = dsetMgrCreator.createDatasetManager(dataEra=era,searchMode=searchMode,optimizationMode=optimizationMode)
consistencyCheck.getNumberOfJobsFromMergedHistogramsFromDsetMgr(dsetMgr, myMergedDict)
def doNominalModule(myMulticrabDir, era, searchMode, optimizationMode,
myOutputCreator, myShapeString, myNormFactors,
myDisplayStatus):
# Construct info string of module
myModuleInfoString = "%s_%s_%s" % (era, searchMode, optimizationMode)
# Obtain dataset manager
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
dsetMgr = dsetMgrCreator.createDatasetManager(
dataEra=era, searchMode=searchMode, optimizationMode=optimizationMode)
# Do the usual normalisation
dsetMgr.updateNAllEventsToPUWeighted()
dsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsetMgr)
dsetMgr.merge("EWK",
["TTJets", "WJets", "DYJetsToLL", "SingleTop", "Diboson"])
# Obtain luminosity
myLuminosity = dsetMgr.getDataset("Data").getLuminosity()
# Print info so that user can check that merge went correct
if myDisplayStatus:
dsetMgr.printDatasetTree()
print "Luminosity = %f 1/fb" % (myLuminosity / 1000.0)
print
myDisplayStatus = False
# Gather results
# Create containers for results
myModuleResults = pseudoMultiCrabCreator.PseudoMultiCrabModule(
dsetMgr, era, searchMode, optimizationMode)
myQCDNormalizationSystResults = pseudoMultiCrabCreator.PseudoMultiCrabModule(
dsetMgr, era, searchMode, optimizationMode, "SystVarQCDNormSource")
# Obtain results
myResult = qcdInvertedResult.QCDInvertedResultManager(
myShapeString,
"AfterCollinearCuts",
dsetMgr,
myLuminosity,
myModuleInfoString,
myNormFactors,
shapeOnly=False,
displayPurityBreakdown=True,
noRebin=True)
# Store results
myModuleResults.addShape(myResult.getShape(), myShapeString)
myModuleResults.addShape(myResult.getShapeMCEWK(),
myShapeString + "_MCEWK")
myModuleResults.addShape(myResult.getShapePurity(),
myShapeString + "_Purity")
myModuleResults.addDataDrivenControlPlots(myResult.getControlPlots(),
myResult.getControlPlotLabels())
myOutputCreator.addModule(myModuleResults)
# Up variation of QCD normalization (i.e. ctrl->signal region transition)
# Note that only the source histograms for the shape uncert are stored
# because the result must be calculated after rebinning
# (and rebinning is no longer done here for flexibility reasons)
myQCDNormalizationSystResults.addShape(myResult.getRegionSystNumerator(),
myShapeString + "Numerator")
myQCDNormalizationSystResults.addShape(myResult.getRegionSystDenominator(),
myShapeString + "Denominator")
myLabels = myResult.getControlPlotLabelsForQCDSyst()
for i in range(0, len(myLabels)):
myLabels[i] = myLabels[i] + "Numerator"
myQCDNormalizationSystResults.addDataDrivenControlPlots(
myResult.getRegionSystNumeratorCtrlPlots(), myLabels)
for i in range(0, len(myLabels)):
myLabels[i] = myLabels[i].replace("Numerator", "Denominator")
myQCDNormalizationSystResults.addDataDrivenControlPlots(
myResult.getRegionSystDenominatorCtrlPlots(), myLabels)
myOutputCreator.addModule(myQCDNormalizationSystResults)
# Clean up
myResult.delete()
dsetMgr.close()
dsetMgrCreator.close()
ROOT.gROOT.CloseFiles()
ROOT.gROOT.GetListOfCanvases().Delete()
ROOT.gDirectory.GetList().Delete()
def main(argv):
dirs = []
if len(sys.argv) < 2:
usage()
myMulticrabDir = sys.argv[1]
# Obtain normalization factors
myNormalizationFactorSource = "QCDInvertedNormalizationFactors.py"
myNormFactors = None
myNormFactorsSafetyCheck = None
if os.path.exists(myNormalizationFactorSource):
myNormFactorsImport = getattr(
__import__(myNormalizationFactorSource.replace(".py", "")),
"QCDInvertedNormalization")
myNormFactorsSafetyCheck = getattr(
__import__(myNormalizationFactorSource.replace(".py", "")),
"QCDInvertedNormalizationSafetyCheck")
#QCDInvertedNormalizationSafetyCheck(era)
myNormFactors = myNormFactorsImport.copy()
else:
raise Exception(
ErrorLabel() +
"Normalisation factors ('%s.py') not found!\nRun script InvertedTauID_Normalization.py to generate the normalization factors."
% myNormalizationFactorSource)
myModuleSelector = AnalysisModuleSelector(
) # Object for selecting data eras, search modes, and optimization modes
parser = OptionParser(usage="Usage: %prog [options]",
add_help_option=True,
conflict_handler="resolve")
myModuleSelector.addParserOptions(parser)
parser.add_option("--mdir",
dest="multicrabDir",
action="store",
help="Multicrab directory")
# Add here parser options, if necessary, following line is an example
#parser.add_option("--showcard", dest="showDatacard", action="store_true", default=False, help="Print datacards also to screen")
# Parse options
(opts, args) = parser.parse_args()
# Obtain multicrab directory
#myMulticrabDir = "../FakeTauComparison_140603_182139/"
if opts.multicrabDir != None:
myMulticrabDir = opts.multicrabDir
# Obtain dsetMgrCreator and register it to module selector
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
myModuleSelector.setPrimarySource("analysis", dsetMgrCreator)
# Select modules
myModuleSelector.doSelect(opts)
# Apply TDR style
style = tdrstyle.TDRStyle()
histograms.createLegend.moveDefaults(dx=-0.1, dh=-0.15)
# Give more space for digits on the y axis labels
style.tdrStyle.SetPadLeftMargin(0.19)
style.tdrStyle.SetTitleYOffset(1.6)
optModes = []
optModes.append("OptQCDTailKillerLoosePlus")
myDisplayStatus = True
# Loop over era/searchMode/optimizationMode options
for era in myModuleSelector.getSelectedEras():
for searchMode in myModuleSelector.getSelectedSearchModes():
for optimizationMode in optModes: #myModuleSelector.getSelectedOptimizationModes():
# Construct info string of module
myModuleInfoString = "%s_%s_%s" % (era, searchMode,
optimizationMode)
print HighlightStyle(
) + "Module:", myModuleInfoString, NormalStyle()
# Obtain dataset manager
dsetMgr = dsetMgrCreator.createDatasetManager(
dataEra=era,
searchMode=searchMode,
optimizationMode=optimizationMode)
# Do the usual normalisation
dsetMgr.updateNAllEventsToPUWeighted()
dsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsetMgr)
dsetMgr.merge(
"EWK",
["TTJets", "WJets", "DYJetsToLL", "SingleTop", "Diboson"])
# Make a directory for output
myDir = "QCDInv_ClosureTest_%s" % myModuleInfoString
createOutputdirectory(myDir)
# Obtain luminosity
myLuminosity = dsetMgr.getDataset("Data").getLuminosity()
# Print info so that user can check that merge went correct
if myDisplayStatus:
dsetMgr.printDatasetTree()
print "Luminosity = %f 1/fb" % (myLuminosity / 1000.0)
print
myDisplayStatus = False
# Run plots
doClosureTestPlots(opts, dsetMgr, myModuleInfoString, myDir,
myLuminosity, myNormFactors)
def doNominalModule(myMulticrabDir, era, searchMode, optimizationMode,
myOutputCreator, myShapeString, myNormFactors,
myDisplayStatus, dataDrivenFakeTaus):
# Construct info string of module
myModuleInfoString = "%s_%s_%s" % (era, searchMode, optimizationMode)
# Obtain dataset manager
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
dsetMgr = dsetMgrCreator.createDatasetManager(
dataEra=era, searchMode=searchMode, optimizationMode=optimizationMode)
# Do the usual normalisation
dsetMgr.updateNAllEventsToPUWeighted()
dsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsetMgr)
dsetMgr.merge("EWK",
["TTJets", "WJets", "DYJetsToLL", "SingleTop", "Diboson"])
# dataset manager with tt contribution in ewk separated
dsetMgrSeparatedTT = dsetMgrCreator.createDatasetManager(
dataEra=era, searchMode=searchMode, optimizationMode=optimizationMode)
# Do the usual normalisation
dsetMgrSeparatedTT.updateNAllEventsToPUWeighted()
dsetMgrSeparatedTT.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsetMgrSeparatedTT)
# TT separated
dsetMgrSeparatedTT.merge("EWKNoTT",
["WJets", "DYJetsToLL", "SingleTop", "Diboson"])
dsetMgrSeparatedTT.merge("EWKTT", ["TTJets"])
# Obtain luminosity
myLuminosity = dsetMgr.getDataset("Data").getLuminosity()
myFakeRateCalculator = fakeRate.FakeRateCalculator(
dsetMgr,
myShapeString,
myNormFactors,
myLuminosity,
dataDrivenFakeTaus=dataDrivenFakeTaus)
# Print info so that user can check that merge went correct
if myDisplayStatus:
dsetMgr.printDatasetTree()
print "Luminosity = %f 1/fb" % (myLuminosity / 1000.0)
print
myDisplayStatus = False
# Gather results
# Create containers for results
myModuleResults = pseudoMultiCrabCreator.PseudoMultiCrabModule(
dsetMgr, era, searchMode, optimizationMode)
myQCDNormalizationSystResults = pseudoMultiCrabCreator.PseudoMultiCrabModule(
dsetMgr, era, searchMode, optimizationMode, "SystVarQCDNormSource")
# Obtain results
myResult = qcdInvertedResult.QCDInvertedResultManager(
myShapeString,
"AfterCollinearCuts",
dsetMgr,
myLuminosity,
myModuleInfoString,
myFakeRateCalculator.getTotalFakeRateProbabilities(),
dataDrivenFakeTaus=dataDrivenFakeTaus,
shapeOnly=False,
displayPurityBreakdown=True,
noRebin=True)
# Store results
myModuleResults.addShape(myResult.getShape(), myShapeString)
myModuleResults.addShape(myResult.getShapeMCEWK(),
myShapeString + "_MCEWK")
myModuleResults.addShape(myResult.getShapePurity(),
myShapeString + "_Purity")
myModuleResults.addDataDrivenControlPlots(myResult.getControlPlots(),
myResult.getControlPlotLabels())
myOutputCreator.addModule(myModuleResults)
# Up variation of QCD normalization (i.e. ctrl->signal region transition)
# Note that only the source histograms for the shape uncert are stored
# because the result must be calculated after rebinning
# (and rebinning is no longer done here for flexibility reasons)
numerator = myResult.getRegionSystNumerator()
denominator = myResult.getRegionSystDenominator()
#scale errors with weight at normalization point
#norm_weight = myFakeRateWeightCalculatorAtNorm.getAverageWeight()
average_weight = myFakeRateCalculator.getAverageWeight()
#print average_weight
fakeRate.scaleErrors(numerator, average_weight)
fakeRate.scaleErrors(denominator, average_weight)
myQCDNormalizationSystResults.addShape(numerator,
myShapeString + "Numerator")
myQCDNormalizationSystResults.addShape(denominator,
myShapeString + "Denominator")
myLabels = myResult.getControlPlotLabelsForQCDSyst()
for i in range(0, len(myLabels)):
myLabels[i] = myLabels[i] + "Numerator"
myQCDNormalizationSystResults.addDataDrivenControlPlots(
myResult.getRegionSystNumeratorCtrlPlots(), myLabels)
for i in range(0, len(myLabels)):
myLabels[i] = myLabels[i].replace("Numerator", "Denominator")
myQCDNormalizationSystResults.addDataDrivenControlPlots(
myResult.getRegionSystDenominatorCtrlPlots(), myLabels)
myOutputCreator.addModule(myQCDNormalizationSystResults)
# Up variation of fake weighting
myFakeWeightingSystResultsPlus = pseudoMultiCrabCreator.PseudoMultiCrabModule(
dsetMgr, era, searchMode, optimizationMode, "SystVarFakeWeightingPlus")
myResult_FakeWeightingPlus = qcdInvertedResult.QCDInvertedResultManager(
myShapeString,
"AfterCollinearCuts",
dsetMgr,
myLuminosity,
myModuleInfoString,
myFakeRateCalculator.getTotalFakeRateProbabilitiesSystVarUp(),
dataDrivenFakeTaus=dataDrivenFakeTaus,
shapeOnly=False,
displayPurityBreakdown=True,
noRebin=True)
myFakeWeightingSystResultsPlus.addShape(
myResult_FakeWeightingPlus.getShape(), myShapeString)
myFakeWeightingSystResultsPlus.addShape(
myResult_FakeWeightingPlus.getShapeMCEWK(), myShapeString + "_MCEWK")
myFakeWeightingSystResultsPlus.addShape(
myResult_FakeWeightingPlus.getShapePurity(), myShapeString + "_Purity")
myFakeWeightingSystResultsPlus.addDataDrivenControlPlots(
myResult_FakeWeightingPlus.getControlPlots(),
myResult.getControlPlotLabels())
myOutputCreator.addModule(myFakeWeightingSystResultsPlus)
# Down variation of fake weighting
myFakeWeightingSystResultsMinus = pseudoMultiCrabCreator.PseudoMultiCrabModule(
dsetMgr, era, searchMode, optimizationMode,
"SystVarFakeWeightingMinus")
myResult_FakeWeightingMinus = qcdInvertedResult.QCDInvertedResultManager(
myShapeString,
"AfterCollinearCuts",
dsetMgr,
myLuminosity,
myModuleInfoString,
myFakeRateCalculator.getTotalFakeRateProbabilitiesSystVarDown(),
dataDrivenFakeTaus=dataDrivenFakeTaus,
shapeOnly=False,
displayPurityBreakdown=True,
noRebin=True)
myFakeWeightingSystResultsMinus.addShape(
myResult_FakeWeightingMinus.getShape(), myShapeString)
myFakeWeightingSystResultsMinus.addShape(
myResult_FakeWeightingMinus.getShapeMCEWK(), myShapeString + "_MCEWK")
myFakeWeightingSystResultsMinus.addShape(
myResult_FakeWeightingMinus.getShapePurity(),
myShapeString + "_Purity")
myFakeWeightingSystResultsMinus.addDataDrivenControlPlots(
myResult_FakeWeightingMinus.getControlPlots(),
myResult.getControlPlotLabels())
myOutputCreator.addModule(myFakeWeightingSystResultsMinus)
# Scalar uncertainties as shapes for MC EWK
for scalarName in myScalarUncertainties.keys():
if scalarName == "probBtag":
myScalarDsetMgr = dsetMgrSeparatedTT
uncertAffectsTT = False
else:
myScalarDsetMgr = dsetMgr
uncertAffectsTT = True
# anti-correlation: flipped sign of variation
upScalarFakeRateCalculator = fakeRate.FakeRateCalculator(
myScalarDsetMgr,
myShapeString,
myNormFactors,
myLuminosity,
EWKUncertaintyFactor=1 -
myScalarUncertainties[scalarName].getUncertaintyUp(),
UncertAffectsTT=uncertAffectsTT,
dataDrivenFakeTaus=dataDrivenFakeTaus)
downScalarFakeRateCalculator = fakeRate.FakeRateCalculator(
myScalarDsetMgr,
myShapeString,
myNormFactors,
myLuminosity,
EWKUncertaintyFactor=1 +
myScalarUncertainties[scalarName].getUncertaintyDown(),
UncertAffectsTT=uncertAffectsTT,
dataDrivenFakeTaus=dataDrivenFakeTaus)
#print "Scalar uncertainty:", scalarName, myScalarUncertainties[scalarName].getUncertaintyDown(), myScalarUncertainties[scalarName].getUncertaintyUp()
upShape = qcdInvertedResult.QCDInvertedShape(
upScalarFakeRateCalculator.getShape(),
myModuleInfoString,
upScalarFakeRateCalculator.getTotalFakeRateProbabilities(),
optionPrintPurityByBins=False,
optionDoNQCDByBinHistograms=False) # prev: .getFakeTauShape()
downShape = qcdInvertedResult.QCDInvertedShape(
downScalarFakeRateCalculator.getShape(),
myModuleInfoString,
downScalarFakeRateCalculator.getTotalFakeRateProbabilities(),
optionPrintPurityByBins=False,
optionDoNQCDByBinHistograms=False) # prev: .getFakeTauShape()
# Up variation module
myScalarSystPlus = pseudoMultiCrabCreator.PseudoMultiCrabModule(
dsetMgr, era, searchMode, optimizationMode,
"SystVar%sPlus" % scalarName)
myScalarSystPlus.addShape(upShape.getResultShape(), myShapeString)
myScalarSystPlus.addShape(upShape.getResultMCEWK(),
myShapeString + "_MCEWK")
myScalarSystPlus.addShape(upShape.getResultPurity(),
myShapeString + "_Purity")
#myScalarSystPlus.addDataDrivenControlPlots(myResult_FakeWeightingMinus.getControlPlots(),myResult.getControlPlotLabels())
myOutputCreator.addModule(myScalarSystPlus)
# Down variation module
myScalarSystMinus = pseudoMultiCrabCreator.PseudoMultiCrabModule(
dsetMgr, era, searchMode, optimizationMode,
"SystVar%sMinus" % scalarName)
myScalarSystMinus.addShape(downShape.getResultShape(), myShapeString)
myScalarSystMinus.addShape(downShape.getResultMCEWK(),
myShapeString + "_MCEWK")
myScalarSystMinus.addShape(downShape.getResultPurity(),
myShapeString + "_Purity")
#myScalarSystMinus.addDataDrivenControlPlots(myResult_FakeWeightingMinus.getControlPlots(),myResult.getControlPlotLabels())
myOutputCreator.addModule(myScalarSystMinus)
# Clean up
myResult.delete()
dsetMgr.close()
dsetMgrCreator.close()
ROOT.gROOT.CloseFiles()
ROOT.gROOT.GetListOfCanvases().Delete()
ROOT.gDirectory.GetList().Delete()
help="remove MC QCD")
parser.add_option("--noSignal",
dest="noSignal",
action="store_true",
default=False,
help="remove MC QCD")
parser.add_option("--mdir",
dest="multicrabDir",
help="path to multicrab directory")
(opts, args) = parser.parse_args()
# Get dataset manager creator and handle different era/searchMode/optimizationMode combinations
myPath = "."
if opts.multicrabDir != None:
myPath = opts.multicrabDir
signalDsetCreator = dataset.readFromMulticrabCfg(directory=myPath)
myModuleSelector.setPrimarySource("Signal analysis", signalDsetCreator)
myModuleSelector.doSelect(opts)
# Arguments are ok, proceed to run
myChosenModuleCount = len(myModuleSelector.getSelectedEras()) * len(
myModuleSelector.getSelectedSearchModes()) * len(
myModuleSelector.getSelectedOptimizationModes())
print "Will run over %d modules (%d eras x %d searchModes x %d optimizationModes)" % (
myChosenModuleCount, len(myModuleSelector.getSelectedEras()),
len(myModuleSelector.getSelectedSearchModes()),
len(myModuleSelector.getSelectedOptimizationModes()))
myCount = 1
for era in myModuleSelector.getSelectedEras():
for searchMode in myModuleSelector.getSelectedSearchModes():
for optimizationMode in myModuleSelector.getSelectedOptimizationModes(
def doNominalModule(myMulticrabDir,era,searchMode,optimizationMode,myOutputCreator,myShapeString,myNormFactors,myDisplayStatus,dataDrivenFakeTaus):
# Construct info string of module
myModuleInfoString = "%s_%s_%s"%(era, searchMode, optimizationMode)
# Obtain dataset manager
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
dsetMgr = dsetMgrCreator.createDatasetManager(dataEra=era,searchMode=searchMode,optimizationMode=optimizationMode)
# Do the usual normalisation
dsetMgr.updateNAllEventsToPUWeighted()
dsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsetMgr)
dsetMgr.merge("EWK", ["TTJets","WJets","DYJetsToLL","SingleTop","Diboson"])
# dataset manager with tt contribution in ewk separated
dsetMgrSeparatedTT = dsetMgrCreator.createDatasetManager(dataEra=era,searchMode=searchMode,optimizationMode=optimizationMode)
# Do the usual normalisation
dsetMgrSeparatedTT.updateNAllEventsToPUWeighted()
dsetMgrSeparatedTT.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsetMgrSeparatedTT)
# TT separated
dsetMgrSeparatedTT.merge("EWKNoTT", ["WJets","DYJetsToLL","SingleTop","Diboson"])
dsetMgrSeparatedTT.merge("EWKTT", ["TTJets"])
# Obtain luminosity
myLuminosity = dsetMgr.getDataset("Data").getLuminosity()
myFakeRateCalculator = fakeRate.FakeRateCalculator(dsetMgr, myShapeString, myNormFactors, myLuminosity, dataDrivenFakeTaus = dataDrivenFakeTaus)
# Print info so that user can check that merge went correct
if myDisplayStatus:
dsetMgr.printDatasetTree()
print "Luminosity = %f 1/fb"%(myLuminosity / 1000.0)
print
myDisplayStatus = False
# Gather results
# Create containers for results
myModuleResults = pseudoMultiCrabCreator.PseudoMultiCrabModule(dsetMgr, era, searchMode, optimizationMode)
myQCDNormalizationSystResults = pseudoMultiCrabCreator.PseudoMultiCrabModule(dsetMgr, era, searchMode, optimizationMode, "SystVarQCDNormSource")
# Obtain results
myResult = qcdInvertedResult.QCDInvertedResultManager(myShapeString, "AfterCollinearCuts", dsetMgr, myLuminosity, myModuleInfoString, myFakeRateCalculator.getTotalFakeRateProbabilities(), dataDrivenFakeTaus=dataDrivenFakeTaus, shapeOnly=False, displayPurityBreakdown=True, noRebin=True)
# Store results
myModuleResults.addShape(myResult.getShape(), myShapeString)
myModuleResults.addShape(myResult.getShapeMCEWK(), myShapeString+"_MCEWK")
myModuleResults.addShape(myResult.getShapePurity(), myShapeString+"_Purity")
myModuleResults.addDataDrivenControlPlots(myResult.getControlPlots(),myResult.getControlPlotLabels())
myOutputCreator.addModule(myModuleResults)
# Up variation of QCD normalization (i.e. ctrl->signal region transition)
# Note that only the source histograms for the shape uncert are stored
# because the result must be calculated after rebinning
# (and rebinning is no longer done here for flexibility reasons)
numerator = myResult.getRegionSystNumerator()
denominator = myResult.getRegionSystDenominator()
#scale errors with weight at normalization point
#norm_weight = myFakeRateWeightCalculatorAtNorm.getAverageWeight()
average_weight = myFakeRateCalculator.getAverageWeight()
#print average_weight
fakeRate.scaleErrors(numerator, average_weight)
fakeRate.scaleErrors(denominator, average_weight)
myQCDNormalizationSystResults.addShape(numerator, myShapeString+"Numerator")
myQCDNormalizationSystResults.addShape(denominator, myShapeString+"Denominator")
myLabels = myResult.getControlPlotLabelsForQCDSyst()
for i in range(0,len(myLabels)):
myLabels[i] = myLabels[i]+"Numerator"
myQCDNormalizationSystResults.addDataDrivenControlPlots(myResult.getRegionSystNumeratorCtrlPlots(),myLabels)
for i in range(0,len(myLabels)):
myLabels[i] = myLabels[i].replace("Numerator","Denominator")
myQCDNormalizationSystResults.addDataDrivenControlPlots(myResult.getRegionSystDenominatorCtrlPlots(),myLabels)
myOutputCreator.addModule(myQCDNormalizationSystResults)
# Up variation of fake weighting
myFakeWeightingSystResultsPlus = pseudoMultiCrabCreator.PseudoMultiCrabModule(dsetMgr, era, searchMode, optimizationMode, "SystVarFakeWeightingPlus")
myResult_FakeWeightingPlus = qcdInvertedResult.QCDInvertedResultManager(myShapeString, "AfterCollinearCuts", dsetMgr, myLuminosity,myModuleInfoString, myFakeRateCalculator.getTotalFakeRateProbabilitiesSystVarUp(), dataDrivenFakeTaus=dataDrivenFakeTaus, shapeOnly=False, displayPurityBreakdown=True, noRebin=True)
myFakeWeightingSystResultsPlus.addShape(myResult_FakeWeightingPlus.getShape(), myShapeString)
myFakeWeightingSystResultsPlus.addShape(myResult_FakeWeightingPlus.getShapeMCEWK(), myShapeString+"_MCEWK")
myFakeWeightingSystResultsPlus.addShape(myResult_FakeWeightingPlus.getShapePurity(), myShapeString+"_Purity")
myFakeWeightingSystResultsPlus.addDataDrivenControlPlots(myResult_FakeWeightingPlus.getControlPlots(),myResult.getControlPlotLabels())
myOutputCreator.addModule(myFakeWeightingSystResultsPlus)
# Down variation of fake weighting
myFakeWeightingSystResultsMinus = pseudoMultiCrabCreator.PseudoMultiCrabModule(dsetMgr, era, searchMode, optimizationMode, "SystVarFakeWeightingMinus")
myResult_FakeWeightingMinus = qcdInvertedResult.QCDInvertedResultManager(myShapeString, "AfterCollinearCuts", dsetMgr, myLuminosity,myModuleInfoString, myFakeRateCalculator.getTotalFakeRateProbabilitiesSystVarDown(), dataDrivenFakeTaus=dataDrivenFakeTaus, shapeOnly=False, displayPurityBreakdown=True, noRebin=True)
myFakeWeightingSystResultsMinus.addShape(myResult_FakeWeightingMinus.getShape(), myShapeString)
myFakeWeightingSystResultsMinus.addShape(myResult_FakeWeightingMinus.getShapeMCEWK(), myShapeString+"_MCEWK")
myFakeWeightingSystResultsMinus.addShape(myResult_FakeWeightingMinus.getShapePurity(), myShapeString+"_Purity")
myFakeWeightingSystResultsMinus.addDataDrivenControlPlots(myResult_FakeWeightingMinus.getControlPlots(),myResult.getControlPlotLabels())
myOutputCreator.addModule(myFakeWeightingSystResultsMinus)
# Scalar uncertainties as shapes for MC EWK
for scalarName in myScalarUncertainties.keys():
if scalarName == "probBtag":
myScalarDsetMgr = dsetMgrSeparatedTT
uncertAffectsTT = False
else:
myScalarDsetMgr = dsetMgr
uncertAffectsTT = True
# anti-correlation: flipped sign of variation
upScalarFakeRateCalculator = fakeRate.FakeRateCalculator(myScalarDsetMgr, myShapeString, myNormFactors, myLuminosity, EWKUncertaintyFactor=1-myScalarUncertainties[scalarName].getUncertaintyUp(), UncertAffectsTT = uncertAffectsTT, dataDrivenFakeTaus = dataDrivenFakeTaus)
downScalarFakeRateCalculator = fakeRate.FakeRateCalculator(myScalarDsetMgr, myShapeString, myNormFactors, myLuminosity, EWKUncertaintyFactor=1+myScalarUncertainties[scalarName].getUncertaintyDown(), UncertAffectsTT = uncertAffectsTT, dataDrivenFakeTaus = dataDrivenFakeTaus)
#print "Scalar uncertainty:", scalarName, myScalarUncertainties[scalarName].getUncertaintyDown(), myScalarUncertainties[scalarName].getUncertaintyUp()
upShape = qcdInvertedResult.QCDInvertedShape(upScalarFakeRateCalculator.getShape(), myModuleInfoString, upScalarFakeRateCalculator.getTotalFakeRateProbabilities(), optionPrintPurityByBins=False, optionDoNQCDByBinHistograms=False) # prev: .getFakeTauShape()
downShape = qcdInvertedResult.QCDInvertedShape(downScalarFakeRateCalculator.getShape(), myModuleInfoString, downScalarFakeRateCalculator.getTotalFakeRateProbabilities(), optionPrintPurityByBins=False, optionDoNQCDByBinHistograms=False) # prev: .getFakeTauShape()
# Up variation module
myScalarSystPlus = pseudoMultiCrabCreator.PseudoMultiCrabModule(dsetMgr, era, searchMode, optimizationMode, "SystVar%sPlus"%scalarName)
myScalarSystPlus.addShape(upShape.getResultShape(), myShapeString)
myScalarSystPlus.addShape(upShape.getResultMCEWK(), myShapeString+"_MCEWK")
myScalarSystPlus.addShape(upShape.getResultPurity(), myShapeString+"_Purity")
#myScalarSystPlus.addDataDrivenControlPlots(myResult_FakeWeightingMinus.getControlPlots(),myResult.getControlPlotLabels())
myOutputCreator.addModule(myScalarSystPlus)
# Down variation module
myScalarSystMinus = pseudoMultiCrabCreator.PseudoMultiCrabModule(dsetMgr, era, searchMode, optimizationMode, "SystVar%sMinus"%scalarName)
myScalarSystMinus.addShape(downShape.getResultShape(), myShapeString)
myScalarSystMinus.addShape(downShape.getResultMCEWK(), myShapeString+"_MCEWK")
myScalarSystMinus.addShape(downShape.getResultPurity(), myShapeString+"_Purity")
#myScalarSystMinus.addDataDrivenControlPlots(myResult_FakeWeightingMinus.getControlPlots(),myResult.getControlPlotLabels())
myOutputCreator.addModule(myScalarSystMinus)
# Clean up
myResult.delete()
dsetMgr.close()
dsetMgrCreator.close()
ROOT.gROOT.CloseFiles()
ROOT.gROOT.GetListOfCanvases().Delete()
ROOT.gDirectory.GetList().Delete()
def doNominalModule(myMulticrabDir, era, searchMode, optimizationMode,
myOutputCreator, myShapeString, myDisplayStatus):
# Construct info string of module
myModuleInfoString = "%s_%s_%s" % (era, searchMode, optimizationMode)
# Obtain dataset manager
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
dsetMgr = dsetMgrCreator.createDatasetManager(
dataEra=era, searchMode=searchMode, optimizationMode=optimizationMode)
# Do the usual normalisation
dsetMgr.updateNAllEventsToPUWeighted()
dsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsetMgr)
dsetMgr.merge("EWK",
["TTJets", "WJets", "DYJetsToLL", "SingleTop", "Diboson"])
# Obtain luminosity
myLuminosity = dsetMgr.getDataset("Data").getLuminosity()
# Print info so that user can check that merge went correct
if myDisplayStatus:
dsetMgr.printDatasetTree()
print "Luminosity = %f 1/fb" % (myLuminosity / 1000.0)
print
myDisplayStatus = False
# Gather results
# Create containers for results
myModuleResults = PseudoMultiCrabModule(dsetMgr, era, searchMode,
optimizationMode)
myQCDNormalizationSystUpResults = PseudoMultiCrabModule(
dsetMgr, era, searchMode, optimizationMode, "SystVarQCDNormPlus")
myQCDNormalizationSystDownResults = PseudoMultiCrabModule(
dsetMgr, era, searchMode, optimizationMode, "SystVarQCDNormMinus")
# Obtain results
myResult = None
if massType == "mt":
myResult = QCDFactorisedResultManager(myMtSpecs,
dsetMgr,
myLuminosity,
myModuleInfoString,
shapeOnly=False,
displayPurityBreakdown=True)
elif massType == "invmass":
myResult = QCDFactorisedResultManager(myFullMassSpecs,
dsetMgr,
myLuminosity,
myModuleInfoString,
shapeOnly=False,
displayPurityBreakdown=True)
myModuleResults.addShape(myResult.getShape(), myShapeString)
myModuleResults.addShape(myResult.getShapeMCEWK(),
myShapeString + "_MCEWK")
myModuleResults.addShape(myResult.getShapePurity(),
myShapeString + "_Purity")
myModuleResults.addDataDrivenControlPlots(myResult.getControlPlots(),
myResult.getControlPlotLabels())
myOutputCreator.addModule(myModuleResults)
# Up variation of QCD normalization (i.e. ctrl->signal region transition)
myQCDNormalizationSystUpResults.addShape(myResult.getRegionSystUp(),
myShapeString)
myQCDNormalizationSystUpResults.addDataDrivenControlPlots(
myResult.getRegionSystUpCtrlPlots(),
myResult.getControlPlotLabelsForQCDSyst())
myOutputCreator.addModule(myQCDNormalizationSystUpResults)
# Down variation of QCD normalization (i.e. ctrl->signal region transition)
myQCDNormalizationSystDownResults.addShape(myResult.getRegionSystDown(),
myShapeString)
myQCDNormalizationSystDownResults.addDataDrivenControlPlots(
myResult.getRegionSystDownCtrlPlots(),
myResult.getControlPlotLabelsForQCDSyst())
myOutputCreator.addModule(myQCDNormalizationSystDownResults)
myResult.delete()
dsetMgr.close()
dsetMgrCreator.close()
ROOT.gROOT.CloseFiles()
ROOT.gROOT.GetListOfCanvases().Delete()
def main():
myShapeString = "shapeTransverseMass"
myEWKfakeShapeString = "shapeEWKFakeTausTransverseMass"
optimizationMode = "OptQCDTailKillerLoosePlus"
myModuleInfoString = "%s_%s_%s" % (era, searchMode, optimizationMode)
defaultBinning = [0, 20, 40, 60, 80, 100, 120, 140, 160, 200, 400]
myBaselineMulticrabDir = "/mnt/flustre/epekkari/signal_2014-07-01_nominal"
#myInvertedMulticrabDir = "/mnt/flustre/epekkari/FixedBugsQCDPlusEWKFakeTau_140919_164308"
myInvertedMulticrabDir = "/mnt/flustre/epekkari/FinalInvertedFakeTau_150218_132905_150218_133121"
#myInvertedMulticrabDir = "/mnt/flustre/epekkari/InvertedFakeTau-12-2_150212_170900"
#myInvertedMulticrabDir = "/home/epekkari/Analysis-4-12/CMSSW_5_3_9_patch3/src/HiggsAnalysis/HeavyChHiggsToTauNu/test/InvertedFakeTau-12-2_150212_170900"
# Inverted datasets
dsetMgrCreator = dataset.readFromMulticrabCfg(
directory=myInvertedMulticrabDir)
dsetMgr = dsetMgrCreator.createDatasetManager(
dataEra=era, searchMode=searchMode, optimizationMode=optimizationMode)
# Do the usual normalisation
dsetMgr.updateNAllEventsToPUWeighted()
dsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsetMgr)
dsetMgr.merge("EWK",
["TTJets", "WJets", "DYJetsToLL", "SingleTop", "Diboson"])
# Obtain luminosity
myLuminosity = dsetMgr.getDataset("Data").getLuminosity()
# Fake rate weighting
myFakeRateWeightCalculator = fakeRateWeighting.FakeRateWeightCalculator(
dsetMgr, myShapeString,
QCDInvertedNormalizationFactors.QCDInvertedNormalization, myLuminosity)
# QCD normalization factors
qcd_norm = getSimplifiedFactorDict(
QCDInvertedNormalizationFactors.QCDInvertedNormalization, "QCD")
# Convert from inverted to baseline
qcdShape = qcdInvertedResult.QCDInvertedShape(
myFakeRateWeightCalculator.getQCDShape(),
myModuleInfoString,
qcd_norm,
optionPrintPurityByBins=False,
optionDoNQCDByBinHistograms=False)
fakeTauShape = qcdInvertedResult.QCDInvertedShape(
myFakeRateWeightCalculator.getFakeTauShape(),
myModuleInfoString,
myFakeRateWeightCalculator.getTotalFakeRateProbabilities(),
optionPrintPurityByBins=False,
optionDoNQCDByBinHistograms=False)
qcd_mt = qcdShape.getResultShape()
fakeTau_mt = fakeTauShape.getResultShape()
datasets_baseline = refinedDataSets([myBaselineMulticrabDir], era,
searchMode, "signalAnalysis",
optimizationMode, False)
MCfake_mt_plot = plots.DataMCPlot(datasets_baseline, myEWKfakeShapeString)
MCfake_mt = MCfake_mt_plot.histoMgr.getHisto("EWK").getRootHisto().Clone(
myEWKfakeShapeString)
# Add MC fakes from baseline
qcd_mt.Add(MCfake_mt)
qcd_mt.SetName("Mis-ID #tau, sim. EWK+t#bar{t} no #tau_{h}")
fakeTau_mt.SetName("Mis-ID. #tau, data-driven EWK+t#bar{t} no #tau_{h}")
qcd_mt.SetLineColor(2)
qcd_mt.SetLineStyle(2)
fakeTau_mt.SetLineColor(1)
qcd_mt.SetLineWidth(2)
fakeTau_mt.SetLineWidth(2)
qcd_mt = qcd_mt.Rebin(
len(defaultBinning) - 1, "", array.array("d", defaultBinning))
fakeTau_mt = fakeTau_mt.Rebin(
len(defaultBinning) - 1, "", array.array("d", defaultBinning))
# Divide by binwidth
for i in range(0, qcd_mt.GetSize()):
qcd_mt.SetBinContent(i,
qcd_mt.GetBinContent(i) / qcd_mt.GetBinWidth(i))
fakeTau_mt.SetBinContent(
i,
fakeTau_mt.GetBinContent(i) / fakeTau_mt.GetBinWidth(i))
qcd_mt.SetBinError(i, qcd_mt.GetBinError(i) / qcd_mt.GetBinWidth(i))
fakeTau_mt.SetBinError(
i,
fakeTau_mt.GetBinError(i) / fakeTau_mt.GetBinWidth(i))
# Plot results
plotClosure(qcd_mt, fakeTau_mt, "Inclusive", optimizationMode)
plotFakeRateProbabilities(myFakeRateWeightCalculator.getWeights(),
myFakeRateWeightCalculator.getWeightErrors(),
myFakeRateWeightCalculator.getSortedFactors(),
optimizationMode)
# Check arguments
myStatus = True
if opts.mdir == None:
print "Error: Make sure you provide path to multicrab directory with --mdir!"
myStatus = False
elif not os.path.exists(opts.mdir):
raise Exception("Error: The path '%s' is not valid!" % opts.mdir)
if not myStatus or opts.helpStatus:
print ""
parser.print_help()
sys.exit()
if not opts.histo == None:
histogramName = opts.Histo
# Obtain dsetMgrCreator and register it to module selector
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=opts.mdir)
myModuleSelector.setPrimarySource("analysis", dsetMgrCreator)
myModuleSelector.doSelect(opts)
myModuleSelector.printSelectedCombinationCount()
# Read from multicrab.cfg the number of jobs
myDict = consistencyCheck.getNumberOfJobsFromMultiCrabCfg(opts.mdir)
# Loop over selected modules
myMergedDict = {}
for searchMode in myModuleSelector.getSelectedSearchModes():
for optimizationMode in myModuleSelector.getSelectedOptimizationModes(
):
for era in myModuleSelector.getSelectedEras():
dsetMgr = dsetMgrCreator.createDatasetManager(
dataEra=era,
parser.error("--mc and --residual can't be given at the same time")
multicrabDirs = args
createArgs = {"includeOnlyTasks": "SingleMu"}
datasetCreator = DatasetCreatorMany(multicrabDirs, **createArgs)
datasetCreatorMC = None
if len(opts.mcs) > 0:
if "*" in opts.mcs:
del createArgs["includeOnlyTasks"]
createArgs["excludeTasks"] = "SingleMu"
else:
createArgs["includeOnlyTasks"] = "|".join(opts.mcs)
datasetCreatorMC = DatasetCreatorMany(multicrabDirs, emptyDatasetsAsNone=True, **createArgs)
if opts.residual is not None:
datasetCreatorMC = DatasetCreatorMany(multicrabDirs, includeOnlyTasks=["DYJetsToLL"], emptyDatasetsAsNone=True)
datasetCreatorSig = dataset.readFromMulticrabCfg(directory=opts.residual, includeOnlyTasks=["DYJetsToLL"])
if opts.listAnalyses:
datasetCreator.printAnalyses()
sys.exit(0)
analysisName = opts.analysisName
if analysisName is None:
analysisName = ""
for a in datasetCreator.getAnalyses():
if len(a) > len(analysisName):
analysisName = a
if len(analysisName) == 0:
raise Exception("Did not find analysis name")
# Deduce eras
if datasetCreatorMC is not None:
eras = datasetCreatorMC.getDataEras()
def __init__(self, directories, **kwargs):
if len(directories) == 0:
raise Exception("Need at least one directory")
self._creators = filter(lambda c: c is not None, [dataset.readFromMulticrabCfg(directory=d, **kwargs) for d in directories])
if __name__ == "__main__":
style = tdrstyle.TDRStyle()
style.tdrStyle.SetPadRightMargin(0.15)
myModuleSelector = AnalysisModuleSelector() # Object for selecting data eras, search modes, and optimization modes
parser = OptionParser(usage="Usage: %prog [options]")
myModuleSelector.addParserOptions(parser)
parser.add_option("-d", dest="dirs", action="append", help="name of sample directory inside multicrab dir (multiple directories can be specified with multiple -d arguments)")
parser.add_option("--signaldir", dest="signalDir", action="store", help="signal Multicrab directory")
parser.add_option("--embdir", dest="embDir", action="store", help="embedding pseudo-Multicrab directory")
parser.add_option("--qcddir", dest="qcdDir", action="store", help="QCD pseudo-Multicrab directory")
parser.add_option("--dataonly", dest="dataonly", action="store_true", default=False, help="Do only data agreemement plots")
(opts, args) = parser.parse_args()
# Get dataset manager creator and handle different era/searchMode/optimizationMode combinations
signalDsetCreator = dataset.readFromMulticrabCfg(directory=opts.signalDir)
embDsetCreator = dataset.readFromMulticrabCfg(directory=opts.embDir)
qcdDsetCreator = dataset.readFromMulticrabCfg(directory=opts.qcdDir)
myModuleSelector.setPrimarySource("Signal analysis", signalDsetCreator)
myModuleSelector.addOtherSource("Embedding", embDsetCreator)
myModuleSelector.addOtherSource("QCD", qcdDsetCreator)
myModuleSelector.doSelect(opts)
# Arguments are ok, proceed to run
myChosenModuleCount = len(myModuleSelector.getSelectedEras())*len(myModuleSelector.getSelectedSearchModes())*len(myModuleSelector.getSelectedOptimizationModes())
print "Will run over %d modules (%d eras x %d searchModes x %d optimizationModes)"%(myChosenModuleCount,len(myModuleSelector.getSelectedEras()),len(myModuleSelector.getSelectedSearchModes()),len(myModuleSelector.getSelectedOptimizationModes()))
myCount = 1
for era in myModuleSelector.getSelectedEras():
for searchMode in myModuleSelector.getSelectedSearchModes():
for optimizationMode in myModuleSelector.getSelectedOptimizationModes():
print "%sProcessing module %d/%d: era=%s searchMode=%s optimizationMode=%s%s"%(HighlightStyle(), myCount, myChosenModuleCount, era, searchMode, optimizationMode, NormalStyle())
datasetCreator = DatasetCreatorMany(multicrabDirs, **createArgs)
datasetCreatorMC = None
if len(opts.mcs) > 0:
if "*" in opts.mcs:
del createArgs["includeOnlyTasks"]
createArgs["excludeTasks"] = "SingleMu"
else:
createArgs["includeOnlyTasks"] = "|".join(opts.mcs)
datasetCreatorMC = DatasetCreatorMany(multicrabDirs,
emptyDatasetsAsNone=True,
**createArgs)
if opts.residual is not None:
datasetCreatorMC = DatasetCreatorMany(multicrabDirs,
includeOnlyTasks=["DYJetsToLL"],
emptyDatasetsAsNone=True)
datasetCreatorSig = dataset.readFromMulticrabCfg(
directory=opts.residual, includeOnlyTasks=["DYJetsToLL"])
if opts.listAnalyses:
datasetCreator.printAnalyses()
sys.exit(0)
analysisName = opts.analysisName
if analysisName is None:
analysisName = ""
for a in datasetCreator.getAnalyses():
if len(a) > len(analysisName):
analysisName = a
if len(analysisName) == 0:
raise Exception("Did not find analysis name")
# Deduce eras
if datasetCreatorMC is not None:
eras = datasetCreatorMC.getDataEras()
myModuleSelector = AnalysisModuleSelector() # Object for selecting data eras, search modes, and optimization modes
parser = OptionParser(usage="Usage: %prog [options]",add_help_option=True,conflict_handler="resolve")
myModuleSelector.addParserOptions(parser)
parser.add_option("--mdir", dest="multicrabDir", action="store", help="Multicrab directory")
# Parse options
(opts, args) = parser.parse_args()
# Obtain multicrab directory
myMulticrabDir = "."
if opts.multicrabDir != None:
myMulticrabDir = opts.multicrabDir
# Obtain dsetMgrCreator and register it to module selector
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myMulticrabDir)
myModuleSelector.setPrimarySource("analysis", dsetMgrCreator)
# Select modules
myModuleSelector.doSelect(opts)
# Apply TDR style
style = tdrstyle.TDRStyle()
myDisplayStatus = True
# Loop over era/searchMode/optimizationMode options
for era in myModuleSelector.getSelectedEras():
for searchMode in myModuleSelector.getSelectedSearchModes():
# Construct info string of module
myModuleInfoString = "%s_%s"%(era, searchMode)
# Make a directory for output
myDir = "purityplots_%s"%myModuleInfoString
def main():
myShapeString = "shapeTransverseMass"
myEWKfakeShapeString = "shapeEWKFakeTausTransverseMass"
optimizationMode = "OptQCDTailKillerLoosePlus"
myModuleInfoString = "%s_%s_%s"%(era, searchMode, optimizationMode)
defaultBinning = [0,20,40,60,80,100,120,140,160,200,400]
myBaselineMulticrabDir = "/mnt/flustre/epekkari/signal_2014-07-01_nominal"
#myInvertedMulticrabDir = "/mnt/flustre/epekkari/FixedBugsQCDPlusEWKFakeTau_140919_164308"
myInvertedMulticrabDir = "/mnt/flustre/epekkari/FinalInvertedFakeTau_150218_132905_150218_133121"
#myInvertedMulticrabDir = "/mnt/flustre/epekkari/InvertedFakeTau-12-2_150212_170900"
#myInvertedMulticrabDir = "/home/epekkari/Analysis-4-12/CMSSW_5_3_9_patch3/src/HiggsAnalysis/HeavyChHiggsToTauNu/test/InvertedFakeTau-12-2_150212_170900"
# Inverted datasets
dsetMgrCreator = dataset.readFromMulticrabCfg(directory=myInvertedMulticrabDir)
dsetMgr = dsetMgrCreator.createDatasetManager(dataEra=era,searchMode=searchMode,optimizationMode=optimizationMode)
# Do the usual normalisation
dsetMgr.updateNAllEventsToPUWeighted()
dsetMgr.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsetMgr)
dsetMgr.merge("EWK", ["TTJets","WJets","DYJetsToLL","SingleTop","Diboson"])
# Obtain luminosity
myLuminosity = dsetMgr.getDataset("Data").getLuminosity()
# Fake rate weighting
myFakeRateWeightCalculator = fakeRateWeighting.FakeRateWeightCalculator(dsetMgr, myShapeString, QCDInvertedNormalizationFactors.QCDInvertedNormalization, myLuminosity)
# QCD normalization factors
qcd_norm = getSimplifiedFactorDict(QCDInvertedNormalizationFactors.QCDInvertedNormalization, "QCD")
# Convert from inverted to baseline
qcdShape = qcdInvertedResult.QCDInvertedShape(myFakeRateWeightCalculator.getQCDShape(), myModuleInfoString, qcd_norm, optionPrintPurityByBins=False, optionDoNQCDByBinHistograms=False)
fakeTauShape = qcdInvertedResult.QCDInvertedShape(myFakeRateWeightCalculator.getFakeTauShape(), myModuleInfoString, myFakeRateWeightCalculator.getTotalFakeRateProbabilities(), optionPrintPurityByBins=False, optionDoNQCDByBinHistograms=False)
qcd_mt = qcdShape.getResultShape()
fakeTau_mt = fakeTauShape.getResultShape()
datasets_baseline = refinedDataSets([myBaselineMulticrabDir], era, searchMode, "signalAnalysis", optimizationMode, False)
MCfake_mt_plot = plots.DataMCPlot(datasets_baseline, myEWKfakeShapeString)
MCfake_mt = MCfake_mt_plot.histoMgr.getHisto("EWK").getRootHisto().Clone(myEWKfakeShapeString)
# Add MC fakes from baseline
qcd_mt.Add(MCfake_mt)
qcd_mt.SetName("Mis-ID #tau, sim. EWK+t#bar{t} no #tau_{h}")
fakeTau_mt.SetName("Mis-ID. #tau, data-driven EWK+t#bar{t} no #tau_{h}")
qcd_mt.SetLineColor(2)
qcd_mt.SetLineStyle(2)
fakeTau_mt.SetLineColor(1)
qcd_mt.SetLineWidth(2)
fakeTau_mt.SetLineWidth(2)
qcd_mt = qcd_mt.Rebin(len(defaultBinning)-1,"", array.array("d",defaultBinning))
fakeTau_mt = fakeTau_mt.Rebin(len(defaultBinning)-1,"", array.array("d",defaultBinning))
# Divide by binwidth
for i in range(0,qcd_mt.GetSize()):
qcd_mt.SetBinContent(i, qcd_mt.GetBinContent(i)/qcd_mt.GetBinWidth(i))
fakeTau_mt.SetBinContent(i, fakeTau_mt.GetBinContent(i)/fakeTau_mt.GetBinWidth(i))
qcd_mt.SetBinError(i, qcd_mt.GetBinError(i)/qcd_mt.GetBinWidth(i))
fakeTau_mt.SetBinError(i, fakeTau_mt.GetBinError(i)/fakeTau_mt.GetBinWidth(i))
# Plot results
plotClosure(qcd_mt, fakeTau_mt, "Inclusive", optimizationMode)
plotFakeRateProbabilities(myFakeRateWeightCalculator.getWeights(), myFakeRateWeightCalculator.getWeightErrors(), myFakeRateWeightCalculator.getSortedFactors(), optimizationMode)
