def main():
# Create all datasets from a multicrab task
datasets = dataset.getDatasetsFromMulticrabCfg(counters=counters)
datasets.updateNAllEventsToPUWeighted()
# Read integrated luminosities of data datasets from lumi.json
datasets.loadLuminosities()
# Include only 120 mass bin of HW and HH datasets
datasets.remove(
filter(lambda name: "TTToHplus" in name and not "M120" in name,
datasets.getAllDatasetNames()))
# Default merging nad ordering of data and MC datasets
# All data datasets to "Data"
# All QCD datasets to "QCD"
# All single top datasets to "SingleTop"
# WW, WZ, ZZ to "Diboson"
plots.mergeRenameReorderForDataMC(datasets)
# Set BR(t->H) to 0.2, keep BR(H->tau) in 1
xsect.setHplusCrossSectionsToBR(datasets, br_tH=0.05, br_Htaunu=1)
# Merge WH and HH datasets to one (for each mass bin)
# TTToHplusBWB_MXXX and TTToHplusBHminusB_MXXX to "TTToHplus_MXXX"
plots.mergeWHandHH(datasets)
# Merge EWK datasets
datasets.merge("EWK",
["WJets", "TTJets", "DYJetsToLL", "SingleTop", "Diboson"])
# Apply TDR style
style = tdrstyle.TDRStyle()
# Create the normalized plot of transverse mass
# Read the histogram from the file
#mT = plots.DataMCPlot(datasets, analysis+"/transverseMass")
# Create the histogram from the tree (and see the selections explicitly)
td = dataset.TreeDraw(
analysis + "/tree",
weight="weightPileup*weightTrigger*weightPrescale",
selection="met_p4.Et() > 70 && Max$(jets_btag) > 1.7")
# mT = plots.DataMCPlot(datasets, td.clone(varexp="sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi())))>>dist(400, 0, 400)"))
# met = plots.DataMCPlot(datasets, td.clone(varexp="met_p4.Et()>>dist(400, 0, 400)"))
met5060 = plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging5060")
met6070 = plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging6070")
met7080 = plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging7080")
met80100 = plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging80100")
met100120 = plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging100120")
met120150 = plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging120150")
met150 = plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging150")
# Rebin before subtracting
met5060.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(1))
met6070.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(1))
met7080.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(1))
met80100.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(1))
met100120.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(1))
met120150.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(1))
met150.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(1))
data5060 = met5060.histoMgr.getHisto("Data").getRootHisto().Clone("Data")
data6070 = met6070.histoMgr.getHisto("Data").getRootHisto().Clone("Data")
data7080 = met7080.histoMgr.getHisto("Data").getRootHisto().Clone("Data")
data80100 = met80100.histoMgr.getHisto("Data").getRootHisto().Clone("Data")
data100120 = met100120.histoMgr.getHisto("Data").getRootHisto().Clone(
"Data")
data120150 = met120150.histoMgr.getHisto("Data").getRootHisto().Clone(
"Data")
data150 = met150.histoMgr.getHisto("Data").getRootHisto().Clone("Data")
# Create the data-EWK histogram and draw it
# diffBase = dataEwkDiff(metBase, "MET_base_data-ewk")
# diffInverted = dataEwkDiff(metInver,"MET_inverted_data-ewk")
# Draw the MET distribution
# transverseMass(metBase,"MET_base")
# transverseMass(metInver,"MET_inverted")
# Set the styles
# dataset._normalizeToOne(diffBase)
# dataset._normalizeToOne(diffInverted)
plot = plots.PlotBase()
plot.histoMgr.appendHisto(
histograms.Histo(data5060, "50 < p_{T}^{#tau jet} < 60 GeV"))
plot.histoMgr.appendHisto(
histograms.Histo(data6070, "60 < p_{T}^{#tau jet} < 70 GeV"))
plot.histoMgr.appendHisto(
histograms.Histo(data7080, "70 < p_{T}^{#tau jet} < 80 GeV"))
plot.histoMgr.appendHisto(
histograms.Histo(data80100, "80 < p_{T}^{#tau jet} < 100 GeV"))
plot.histoMgr.appendHisto(
histograms.Histo(data100120, "100 < p_{T}^{#tau jet} < 120 GeV"))
plot.histoMgr.appendHisto(
histograms.Histo(data120150, "120 < p_{T}^{#tau jet} < 150 GeV"))
plot.histoMgr.appendHisto(
histograms.Histo(data150, "p_{T}^{#tau jet} > 150 GeV"))
st1 = styles.getDataStyle().clone()
st2 = st1.clone()
st2.append(styles.StyleLine(lineColor=ROOT.kRed))
st3 = st1.clone()
st3.append(styles.StyleLine(lineColor=ROOT.kBlue))
st4 = st1.clone()
st4.append(styles.StyleLine(lineColor=ROOT.kGreen))
st5 = st1.clone()
st5.append(styles.StyleLine(lineColor=ROOT.kMagenta, lineStyle=2))
st6 = st1.clone()
st6.append(styles.StyleLine(lineColor=ROOT.kPink,
lineStyle=8)) # lineWidth=6))
st7 = st1.clone()
st7.append(styles.StyleLine(lineColor=ROOT.kBlue - 2, lineStyle=3))
plot.histoMgr.forHisto("50 < p_{T}^{#tau jet} < 60 GeV", st1)
plot.histoMgr.forHisto("60 < p_{T}^{#tau jet} < 70 GeV", st2)
plot.histoMgr.forHisto("70 < p_{T}^{#tau jet} < 80 GeV", st3)
plot.histoMgr.forHisto("80 < p_{T}^{#tau jet} < 100 GeV", st4)
plot.histoMgr.forHisto("100 < p_{T}^{#tau jet} < 120 GeV", st5)
plot.histoMgr.forHisto("120 < p_{T}^{#tau jet} < 150 GeV", st6)
plot.histoMgr.forHisto("p_{T}^{#tau jet} > 150 GeV", st7)
plot.createFrame(
"METinBins",
opts={
"xmax": 200,
"ymin": 1e-1,
"ymaxfactor": 1.5
},
# createRatio=True, opts2={"ymin": -5 , "ymax": 6 }, # bounds of the ratio plot
)
plot.getPad().SetLogy(True)
plot.setLegend(histograms.createLegend(0.6, 0.68, 0.8, 0.93))
plot.frame.GetXaxis().SetTitle("MET (GeV)")
plot.frame.GetYaxis().SetTitle("Data")
# Draw the plot
plot.draw()
plot.save()
def main():
if len(sys.argv) < 2:
usage()
# HISTONAME = "MET_InvertedTauIdJets"
# HISTONAME = "MET_InvertedTauIdJetsCollinear"
# HISTONAME = "MET_InvertedTauIdBveto"
HISTONAME = "MET_InvertedTauIdBvetoCollinear"
# HISTONAME = "MET_InvertedTauIdBtag"
# HISTONAME = "MTInvertedTauIdJet"
# HISTONAME = "MTInvertedTauIdPhi"
invertedhisto = HISTONAME
baselinehisto = HISTONAME.replace("Inverted", "BaseLine")
dirs = []
if len(sys.argv) < 2:
usage()
dirs.append(sys.argv[1])
# Create all datasets from a multicrab task
#datasets = dataset.getDatasetsFromMulticrabCfg(counters=counters)
datasets = dataset.getDatasetsFromMulticrabDirs(dirs,
dataEra=dataEra,
searchMode=searchMode,
analysisName=analysis)
# datasets = dataset.getDatasetsFromMulticrabDirs(dirs,counters=counters, dataEra=dataEra, analysisBaseName="signalAnalysisInvertedTau" )
# As we use weighted counters for MC normalisation, we have to
# As we use weighted counters for MC normalisation, we have to
# update the all event count to a separately defined value because
# the analysis job uses skimmed pattuple as an input
datasets.updateNAllEventsToPUWeighted()
# Read integrated luminosities of data datasets from lumi.json
datasets.loadLuminosities()
# Include only 120 mass bin of HW and HH datasets
datasets.remove(
filter(lambda name: "TTToHplus" in name and not "M120" in name,
datasets.getAllDatasetNames()))
datasets.remove(
filter(lambda name: "HplusTB" in name, datasets.getAllDatasetNames()))
# Default merging nad ordering of data and MC datasets
# All data datasets to "Data"
# All QCD datasets to "QCD"
# All single top datasets to "SingleTop"
# WW, WZ, ZZ to "Diboson"
plots.mergeRenameReorderForDataMC(datasets)
# Set BR(t->H) to 0.05, keep BR(H->tau) in 1
xsect.setHplusCrossSectionsToBR(datasets, br_tH=0.05, br_Htaunu=1)
# Merge WH and HH datasets to one (for each mass bin)
# TTToHplusBWB_MXXX and TTToHplusBHminusB_MXXX to "TTToHplus_MXXX"
plots.mergeWHandHH(datasets)
datasets.merge("EWK",
["TTJets", "WJets", "DYJetsToLL", "SingleTop", "Diboson"])
# Apply TDR style
style = tdrstyle.TDRStyle()
invertedQCD = InvertedTauID()
invertedQCD.setLumi(datasets.getDataset("Data").getLuminosity())
ptbin = ["4050"]
metBase = plots.DataMCPlot(datasets, "BaseLine/" + baselinehisto)
metInver = plots.DataMCPlot(datasets, "Inverted/" + invertedhisto)
# Rebin before subtracting
metBase.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(5))
metInver.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(5))
metInverted_data = metInver.histoMgr.getHisto("Data").getRootHisto().Clone(
"BaseLine/" + invertedhisto)
metInverted_EWK = metInver.histoMgr.getHisto("EWK").getRootHisto().Clone(
"BaseLine/" + invertedhisto)
# metInverted_MC = metInver.histoMgr.getHisto("QCD").getRootHisto().Clone("BaseLine/"+invertedhisto)
metBase_data = metBase.histoMgr.getHisto("Data").getRootHisto().Clone(
"BaseLine/" + baselinehisto)
metBase_EWK = metBase.histoMgr.getHisto("EWK").getRootHisto().Clone(
"BaseLine/" + baselinehisto)
if ReBinning:
rebinfactor = 1.3
histobins = []
histobins.append(0)
histobins.append(1)
i = 1
while histobins[len(histobins) - 1] < 400:
edge = histobins[i] + (histobins[i] -
histobins[i - 1]) * rebinfactor
histobins.append(edge)
i += 1
print histobins
# metBase_data = metBase_data.Rebin(len(histobins)-1, metInverted_EWK = metInver.histoMgr.getHisto("EWK").getRootHisto().Clone(analysis+"/"+invertedhisto) "",array.array("d", histobins))
metInverted_data = metInverted_data.Rebin(
len(histobins) - 1, "", array.array("d", histobins))
metBase_EWK = metBase_EWK.Rebin(
len(histobins) - 1, "", array.array("d", histobins))
metInverted_EWK = metInverted_EWK.Rebin(
len(histobins) - 1, "", array.array("d", histobins))
metBase_data.SetTitle("Data: BaseLine TauID")
metInverted_data.SetTitle("Data: Inverted TauID")
metBase_QCD = metBase_data.Clone("QCD")
metBase_QCD.Add(metBase_EWK, -1)
metBase_QCD.SetTitle("Data - EWK MC: BaseLine TauID")
invertedQCD.setLabel("BaseVsInverted")
invertedQCD.comparison(metInverted_data, metBase_data)
invertedQCD.setLabel("BaseMinusEWKVsInverted")
invertedQCD.comparison(metInverted_data, metBase_QCD)
invertedQCD.setLabel("McVsInverted")
# invertedQCD.comparison(metInverted_data,metInverted_MC)
invertedQCD.setLabel("EfficiencyBaseMinusEWKVsInverted")
invertedQCD.cutefficiency(metInverted_data, metBase_QCD)
def main():
datasets = dataset.getDatasetsFromMulticrabCfg(counters=counters)
datasets.updateNAllEventsToPUWeighted()
datasets.loadLuminosities()
plots.mergeRenameReorderForDataMC(datasets)
datasets.merge("EWK",
["TTJets", "WJets", "DYJetsToLL", "SingleTop", "Diboson"])
style = tdrstyle.TDRStyle()
metInver = plots.DataMCPlot(datasets, analysis + "/MET_InvertedTauIdJets")
metBase = plots.DataMCPlot(datasets, analysis + "/MET_BaseLineTauIdJets")
metBasePP = plots.DataMCPlot(datasets,
analysisPlusPlus + "/MET_BaseLineTauIdJets")
metBaseMP = plots.DataMCPlot(datasets,
analysisMinusPlus + "/MET_BaseLineTauIdJets")
metBasePM = plots.DataMCPlot(datasets,
analysisPlusMinus + "/MET_BaseLineTauIdJets")
metBaseMM = plots.DataMCPlot(datasets,
analysisMinusMinus + "/MET_BaseLineTauIdJets")
# Rebin before subtracting
rebin = 20
metInver.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(rebin))
metBase.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(rebin))
metBasePP.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(rebin))
metBaseMP.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(rebin))
metBasePM.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(rebin))
metBaseMM.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(rebin))
metInverted_data = metInver.histoMgr.getHisto("Data").getRootHisto().Clone(
analysis + "/MET_InvertedTauIdJets")
metBase_data = metBase.histoMgr.getHisto("Data").getRootHisto().Clone(
analysis + "/MET_BaselineTauIdJets")
metBase_EWK = metBase.histoMgr.getHisto("EWK").getRootHisto().Clone(
analysis + "/MET_BaselineTauIdJets")
metBase_EWKplusplus = metBasePP.histoMgr.getHisto(
"EWK").getRootHisto().Clone(analysisPlusPlus +
"/MET_BaselineTauIdJets")
metBase_EWKminusplus = metBaseMP.histoMgr.getHisto(
"EWK").getRootHisto().Clone(analysisMinusPlus +
"/MET_BaselineTauIdJets")
metBase_EWKplusminus = metBasePM.histoMgr.getHisto(
"EWK").getRootHisto().Clone(analysisPlusMinus +
"/MET_BaselineTauIdJets")
metBase_EWKminusminus = metBaseMM.histoMgr.getHisto(
"EWK").getRootHisto().Clone(analysisMinusMinus +
"/MET_BaselineTauIdJets")
invertedQCD = InvertedTauID()
invertedQCD.setLabel("noError")
invertedQCD.fitQCD(metInverted_data)
invertedQCD.fitEWK(metBase_EWK)
invertedQCD.fitData(metBase_data)
normalizationWithEWK = invertedQCD.getNormalization()
invertedQCD.setLabel("plusplusError")
invertedQCD.fitEWK(metBase_EWKplusplus)
invertedQCD.fitData(metBase_data)
normalizationWithEWKplusplus = invertedQCD.getNormalization()
invertedQCD.setLabel("minusplusError")
invertedQCD.fitEWK(metBase_EWKminusplus)
invertedQCD.fitData(metBase_data)
normalizationWithEWKminusplus = invertedQCD.getNormalization()
invertedQCD.setLabel("plusminusError")
invertedQCD.fitEWK(metBase_EWKplusminus)
invertedQCD.fitData(metBase_data)
normalizationWithEWKplusminus = invertedQCD.getNormalization()
invertedQCD.setLabel("minusminusError")
invertedQCD.fitEWK(metBase_EWKminusminus)
invertedQCD.fitData(metBase_data)
normalizationWithEWKminusminus = invertedQCD.getNormalization()
invertedQCD.Summary()
print "Difference in normalization due to JES ++ variation", (
normalizationWithEWK -
normalizationWithEWKplusplus) / normalizationWithEWK
print "Difference in normalization due to JES -+ variation", (
normalizationWithEWK -
normalizationWithEWKminusplus) / normalizationWithEWK
print "Difference in normalization due to JES +- variation", (
normalizationWithEWK -
normalizationWithEWKplusminus) / normalizationWithEWK
print "Difference in normalization due to JES -- variation", (
normalizationWithEWK -
normalizationWithEWKminusminus) / normalizationWithEWK
def main():
# HISTONAME = "TauIdJets"
HISTONAME = "TauIdBtag"
# Create all datasets from a multicrab task
datasets = dataset.getDatasetsFromMulticrabCfg(counters=counters)
# Read integrated luminosities of data datasets from lumi.json
datasets.loadLuminosities()
# Include only 120 mass bin of HW and HH datasets
datasets.remove(filter(lambda name: "TTToHplus" in name and not "M120" in name, datasets.getAllDatasetNames()))
# Default merging nad ordering of data and MC datasets
# All data datasets to "Data"
# All QCD datasets to "QCD"
# All single top datasets to "SingleTop"
# WW, WZ, ZZ to "Diboson"
plots.mergeRenameReorderForDataMC(datasets)
# Set BR(t->H) to 0.05, keep BR(H->tau) in 1
xsect.setHplusCrossSectionsToBR(datasets, br_tH=0.05, br_Htaunu=1)
# Merge WH and HH datasets to one (for each mass bin)
# TTToHplusBWB_MXXX and TTToHplusBHminusB_MXXX to "TTToHplus_MXXX"
plots.mergeWHandHH(datasets)
datasets.merge("EWK", [
"TTJets",
"WJets",
"DYJetsToLL",
"SingleTop",
"Diboson"
])
# Apply TDR style
style = tdrstyle.TDRStyle()
invertedQCD = InvertedTauID()
invertedQCD.setLumi(datasets.getDataset("Data").getLuminosity())
bins = ["inclusive"]
# bins = ["4050","5060","6070","7080","80100","100120","120150","150"]
# bins = ["4050"]
for bin in bins:
invertedQCD.setLabel(bin)
if bin == "inclusive":
bin = ""
metBase = plots.DataMCPlot(datasets, analysis+"/MET_BaseLine"+HISTONAME+bin)
metInver = plots.DataMCPlot(datasets, analysis+"/MET_Inverted"+HISTONAME+bin)
# Rebin before subtracting
metBase.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(10))
metInver.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(10))
metInverted_data = metInver.histoMgr.getHisto("Data").getRootHisto().Clone(analysis+"/MET_Inverted"+HISTONAME+bin)
metInverted_EWK = metInver.histoMgr.getHisto("EWK").getRootHisto().Clone(analysis+"/MET_Inverted"+HISTONAME+bin)
metBase_data = metBase.histoMgr.getHisto("Data").getRootHisto().Clone(analysis+"/MET_Baseline"+HISTONAME+bin)
metBase_EWK = metBase.histoMgr.getHisto("EWK").getRootHisto().Clone(analysis+"/MET_Baseline"+HISTONAME+bin)
metBase_QCD = metBase_data.Clone("QCD")
metBase_QCD.Add(metBase_EWK,-1)
invertedQCD.plotHisto(metInverted_data,"inverted")
invertedQCD.plotHisto(metBase_data,"baseline")
invertedQCD.fitQCD(metInverted_data)
invertedQCD.fitEWK(metBase_EWK,"LR")
invertedQCD.fitData(metBase_data)
invertedQCD.getNormalization()
invertedQCD.Summary()
plots.mergeRenameReorderForDataMC(datasets)
# This can be used to merge datasets:
#datasets.merge("TTJetsPlusWJets", ["TTJets", "WJets"], keepSources=True)
# Override the data luminosity (should not be used except for testing)
#datasets.getDataset("Data").setLuminosity(35)
# Create the plot, the latter argument is the path to the histogram in the ROOT files
if mcOnly:
h = plots.MCPlot(datasets,
analysis + "/FullHiggsMass/HiggsMass",
normalizeToLumi=mcOnlyLumi)
else:
h = plots.DataMCPlot(datasets, analysis + "/FullHiggsMass/HiggsMass")
# TTJets
drh_reco = datasets.getDataset("TTToHplusBWB_M120").getDatasetRootHisto(
analysis + "/FullHiggsMass/HiggsMass")
drh_gen = datasets.getDataset("TTToHplusBWB_M120").getDatasetRootHisto(
analysis + "/GenParticleAnalysis/genFullHiggsMass")
drh_reco.normalizeToLuminosity(mcOnlyLumi)
drh_gen.normalizeToLuminosity(mcOnlyLumi)
h_reco = drh_reco.getHistogram() # returns TH1
h_gen = drh_gen.getHistogram()
h_reco.SetName("Reco")
h_gen.SetName("Gen")
def main():
errorBars = False
# Create all datasets from a multicrab task
datasets = dataset.getDatasetsFromMulticrabCfg(counters=counters)
# Read integrated luminosities of data datasets from lumi.json
datasets.loadLuminosities()
# Include only 120 mass bin of HW and HH datasets
datasets.remove(filter(lambda name: "TTToHplus" in name and not "M120" in name, datasets.getAllDatasetNames()))
# Default merging nad ordering of data and MC datasets
# All data datasets to "Data"
# All QCD datasets to "QCD"
# All single top datasets to "SingleTop"
# WW, WZ, ZZ to "Diboson"
plots.mergeRenameReorderForDataMC(datasets)
# Set BR(t->H) to 0.05, keep BR(H->tau) in 1
xsect.setHplusCrossSectionsToBR(datasets, br_tH=0.05, br_Htaunu=1)
# Merge WH and HH datasets to one (for each mass bin)
# TTToHplusBWB_MXXX and TTToHplusBHminusB_MXXX to "TTToHplus_MXXX"
plots.mergeWHandHH(datasets)
datasets.merge("EWK", [
"TTJets",
"WJets",
"DYJetsToLL",
"SingleTop",
"Diboson"
])
# Apply TDR style
style = tdrstyle.TDRStyle()
invertedQCD = InvertedTauID()
invertedQCD.setLumi(datasets.getDataset("Data").getLuminosity())
invertedQCD.useErrorBars(errorBars)
metBase = plots.DataMCPlot(datasets, analysis+"/MET_BaseLineTauIdJets")
metInver = plots.DataMCPlot(datasets, analysis+"/MET_InvertedTauIdJets")
# Rebin before subtracting
metBase.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(10))
metInver.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(10))
metInverted_data = metInver.histoMgr.getHisto("Data").getRootHisto().Clone(analysis+"/MET_InvertedTauIdJets")
metInverted_EWK = metInver.histoMgr.getHisto("EWK").getRootHisto().Clone(analysis+"/MET_InvertedTauIdJets")
metBase_data = metBase.histoMgr.getHisto("Data").getRootHisto().Clone(analysis+"/MET_BaselineTauIdJets")
metBase_EWK = metBase.histoMgr.getHisto("EWK").getRootHisto().Clone(analysis+"/MET_BaselineTauIdJets")
metBase_data.SetTitle("Data: BaseLine TauID")
metInverted_data.SetTitle("Data: Inverted TauID")
metBase_QCD = metBase_data.Clone("QCD")
metBase_QCD.Add(metBase_EWK,-1)
metBase_QCD.SetTitle("Data - EWK MC: BaseLine TauID")
metInverted_data.GetXaxis().SetTitle("PFMET (GeV)")
invertedQCD.setLabel("BaseVsInverted")
# invertedQCD.comparison(metInverted_data,metBase_data)
invertedQCD.setLabel("BaseMinusEWKVsInverted")
# invertedQCD.comparison(metInverted_data,metBase_QCD)
invertedQCD.cutefficiency(metInverted_data,metBase_QCD)
def main():
# Create all datasets from a multicrab task
datasets = dataset.getDatasetsFromMulticrabCfg(counters=counters)
# Read integrated luminosities of data datasets from lumi.json
datasets.loadLuminosities()
# Include only 120 mass bin of HW and HH datasets
datasets.remove(
filter(lambda name: "TTToHplus" in name and not "M120" in name,
datasets.getAllDatasetNames()))
# Default merging nad ordering of data and MC datasets
# All data datasets to "Data"
# All QCD datasets to "QCD"
# All single top datasets to "SingleTop"
# WW, WZ, ZZ to "Diboson"
plots.mergeRenameReorderForDataMC(datasets)
# Set BR(t->H) to 0.05, keep BR(H->tau) in 1
xsect.setHplusCrossSectionsToBR(datasets, br_tH=0.05, br_Htaunu=1)
# Merge WH and HH datasets to one (for each mass bin)
# TTToHplusBWB_MXXX and TTToHplusBHminusB_MXXX to "TTToHplus_MXXX"
plots.mergeWHandHH(datasets)
ttjets2 = datasets.getDataset("TTJets").deepCopy()
ttjets2.setCrossSection(
ttjets2.getCrossSection() -
datasets.getDataset("TTToHplus_M120").getCrossSection())
print "Set TTJets2 cross section to %f" % ttjets2.getCrossSection()
ttjets2.setName("TTJets2")
datasets.append(ttjets2)
datasets.merge("EWKnott", ["WJets", "DYJetsToLL", "SingleTop", "Diboson"])
tmp = datasets.getDataset("EWKnott").deepCopy()
tmp.setName("EWKnott2")
datasets.append(tmp)
datasets.merge("EWK", ["EWKnott", "TTJets"])
# Apply TDR style
style = tdrstyle.TDRStyle()
invertedQCD = InvertedTauID()
metBase = plots.DataMCPlot(datasets, analysis + "/MET_BaseLineTauIdJets")
metInver = plots.DataMCPlot(datasets, analysis + "/MET_InvertedTauIdJets")
# Rebin before subtracting
metBase.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(20))
metInver.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(20))
metInverted_data = metInver.histoMgr.getHisto("Data").getRootHisto().Clone(
analysis + "/MET_InvertedTauIdJets")
metInverted_EWK = metInver.histoMgr.getHisto("EWK").getRootHisto().Clone(
analysis + "/MET_InvertedTauIdJets")
metBase_data = metBase.histoMgr.getHisto("Data").getRootHisto().Clone(
analysis + "/MET_BaselineTauIdJets")
metBase_EWK = metBase.histoMgr.getHisto("EWK").getRootHisto().Clone(
analysis + "/MET_BaselineTauIdJets")
metBase_QCD = metBase_data.Clone("QCD")
metBase_QCD.Add(metBase_EWK, -1)
metBase_EWK.SetTitle("MC EWK")
invertedQCD.setLabel("InvData")
invertedQCD.fitQCD(metInverted_data)
invertedQCD.setLabel("ChiSq")
invertedQCD.fitEWK(metBase_EWK, "R")
invertedQCD.fitData(metBase_data)
normalizationWithChiSq = invertedQCD.getNormalization()
invertedQCD.setLabel("LogLikelihood")
invertedQCD.fitEWK(metBase_EWK, "LR")
invertedQCD.fitData(metBase_data)
normalizationWithLogLL = invertedQCD.getNormalization()
print "Difference Signal vs no signal in EWK fit", (
normalizationWithLogLL -
normalizationWithChiSq) / normalizationWithChiSq
def createPlot(name, **kwargs):
return plots.DataMCPlot(datasets, name, **kwargs)
datasets.loadLuminosities()
# Merge:
# - all data datasets to 'Data'
# - all QCD datasets to 'QCD'
# - all single top datasets to 'SingleTop'
# Rename the physical dataset names to logical (essentially drop the Tune and Winter10)
# Reorder to the 'standard' order, all 'nonstandard' are left to the end
plots.mergeRenameReorderForDataMC(datasets)
# Override the data luminosity (should not be used except for testing)
#datasets.getDataset("Data").setLuminosity(35)
# Create the plot, latter argument is the path to the histogram in the ROOT files
h = plots.DataMCPlot(
datasets,
"qcdMeasurementMethod2Part1Counters/TauSelection_all_tau_candidates_pt")
# Stack MC histograms
h.stackMCHistograms()
#tauPt.stackMCHistograms(stackSignal=True) # Stack also the signal datasets?
h.addMCUncertainty()
# Create canvas and frame for only the distributions
h.createFrame("taupt_new")
h.frame.GetXaxis().SetTitle("#tau p_T (GeV/c)")
h.frame.GetYaxis().SetTitle("#tau cands / 1 GeV/c")
# Create legend
h.setLegend(histograms.createLegend())
def main():
# Read the datasets
datasets = dataset.getDatasetsFromMulticrabCfg(counters=counters)
datasets.remove([
"WJets_TuneD6T_Winter10",
"TTJets_TuneD6T_Winter10",
"TTToHplusBWB_M140_Spring11",
"TTToHplusBWB_M80_Spring11",
"TTToHplusBWB_M90_Spring11",
"TTToHplusBWB_M155_Spring11",
"TTToHplusBWB_M150_Spring11",
"TTToHplusBWB_M160_Spring11",
"TTToHplusBWB_M100_Spring11",
"TTToHplusBHminusB_M80_Spring11",
"TTToHplusBHminusB_M100_Spring11",
"TTToHplusBHminusB_M160_Spring11",
"TTToHplusBHminusB_M150_Spring11",
"TTToHplusBHminusB_M140_Spring11",
"TTToHplusBHminusB_M155_Spring11",
"TauPlusX_160431-161016_Prompt",
"TauPlusX_162803-162828_Prompt",
"QCD_Pt30to50_TuneZ2_Spring11",
"QCD_Pt50to80_TuneZ2_Spring11",
"QCD_Pt80to120_TuneZ2_Spring11",
"QCD_Pt120to170_TuneZ2_Spring11",
"QCD_Pt170to300_TuneZ2_Spring11",
"QCD_Pt300to470_TuneZ2_Spring11",
"HplusTB_M180_Summer11",
"HplusTB_M190_Summer11",
"HplusTB_M250_Summer11",
"HplusTB_M300_Summer11",
"HplusTB_M220_Summer11",
"HplusTB_M200_Summer11",
# "Tau_165970-166164_Prompt", "Tau_166374-167043_Prompt", "Tau_167078-167784_Prompt", "Tau_165088-165633_Prompt"
# "Tau_163270-163869_May10","Tau_161217-163261_May10", "Tau_160431-161176_May10"
])
datasets.loadLuminosities()
# Take signals from 42X
datasets.remove(
filter(lambda name: "TTToHplus" in name and not "M120" in name,
datasets.getAllDatasetNames()))
# datasetsSignal = dataset.getDatasetsFromMulticrabCfg(cfgfile="/home/rkinnune/signalAnalysis/CMSSW_4_2_4_patch1/src/HiggsAnalysis/HeavyChHiggsToTauNu/test/multicrab_110621_150040/multicrab.cfg", counters=counters)
#Rtau =0
# datasetsSignal = dataset.getDatasetsFromMulticrabCfg(cfgfile="/home/rkinnune/signalAnalysis/CMSSW_4_2_5/src/HiggsAnalysis/HeavyChHiggsToTauNu/test/multicrab_110804_104313/multicrab.cfg", counters=counters)
# datasetsSignal.selectAndReorder(["HplusTB_M200_Summer11"])
# datasetsSignal = dataset.getDatasetsFromMulticrabCfg(cfgfile="/home/rkinnune/signalAnalysis/CMSSW_4_2_4_patch1/src/HiggsAnalysis/HeavyChHiggsToTauNu/test/multicrab_110622_112321/multicrab.cfg", counters=counters)
#datasetsSignal = dataset.getDatasetsFromMulticrabCfg(cfgfile="/home/rkinnune/signalAnalysis/CMSSW_4_1_5/src/HiggsAnalysis/HeavyChHiggsToTauNu/test/Signal_v11f_scaledb_424/multicrab.cfg", counters=counters)
#datasetsSignal.selectAndReorder(["TTToHplusBWB_M120_Summer11", "TTToHplusBHminusB_M120_Summer11"])
#datasetsSignal.renameMany({"TTToHplusBWB_M120_Summer11" :"TTToHplusBWB_M120_Spring11",
# "TTToHplusBHminusB_M120_Summer11": "TTToHplusBHminusB_M120_Spring11"})
#datasets.extend(datasetsSignal)
plots.mergeRenameReorderForDataMC(datasets)
# Set the signal cross sections to the ttbar
# xsect.setHplusCrossSectionsToTop(datasets)
# Set the signal cross sections to a given BR(t->H), BR(h->taunu)
xsect.setHplusCrossSectionsToBR(datasets, br_tH=0.2, br_Htaunu=1)
# Set the signal cross sections to a value from MSSM
# xsect.setHplusCrossSectionsToMSSM(datasets, tanbeta=20, mu=200)
plots.mergeWHandHH(
datasets
) # merging of WH and HH signals must be done after setting the cross section
# Apply TDR style
style = tdrstyle.TDRStyle()
# Create the plot objects and pass them to the formatting
# functions to be formatted, drawn and saved to files
# selectionFlow(plots.DataMCPlot(datasets, analysis+"/SignalSelectionFlow"), "SignalSelectionFlow")
# met(plots.DataMCPlot(datasets, analysis+"/TauEmbeddingAnalysis_afterTauId_embeddingMet"), ratio=True)
# met(plots.DataMCPlot(datasets, analysis+"/TauEmbeddingAnalysis_begin_embeddingMet"), ratio=True)
# met2(plots.DataMCPlot(datasets, analysis+"/Met_BeforeTauId"), "MetBeforeTauId", rebin=40)
met2(plots.DataMCPlot(datasets, analysis + "/QCD_MET_AfterJetSelection"),
"QCD_MET_AfterJetSelection",
rebin=1)
met2(plots.DataMCPlot(datasets, analysis + "/QCD_MET_AfterJetsBtagging"),
"QCD_MET_AfterJetsBtagging",
rebin=1)
met2(plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging4050"),
"QCD_MET_AfterJetsBtagging4050",
rebin=1)
met2(plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging5060"),
"QCD_MET_AfterJetsBtagging5060",
rebin=1)
met2(plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging6070"),
"QCD_MET_AfterJetsBtagging6070",
rebin=1)
met2(plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging7080"),
"QCD_MET_AfterJetsBtagging7080",
rebin=1)
met2(plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging80100"),
"QCD_MET_AfterJetsBtagging80100",
rebin=1)
met2(plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging100120"),
"QCD_MET_AfterJetsBtagging100120",
rebin=1)
met2(plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging120150"),
"QCD_MET_AfterJetsBtagging120150",
rebin=1)
met2(plots.DataMCPlot(datasets,
analysis + "/QCD_MET_AfterJetsBtagging150"),
"QCD_MET_AfterJetsBtagging150",
rebin=1)
# Set temporarily the signal cross sections to a value from MSSM
# xsect.setHplusCrossSections(datasets, tanbeta=20, mu=200)
# datasets.getDataset("TTToHplusBHminusB_M120").setCrossSection(0.2*165)
# datasets.getDataset("TTToHplusBWB_M120").setCrossSection(0.2*165)
####################
datasets_tm = datasets
# datasets_tm = datasets.deepCopy()
# xsect.setHplusCrossSectionsToBR(datasets, br_tH=0.2, br_Htaunu=1)
# xsect.setHplusCrossSectionsToBR(datasets_tm, br_tH=0.2, br_Htaunu=1)
# datasets_tm.merge("TTToHplus_M120", ["TTToHplusBWB_M120", "TTToHplusBHminusB_M120"])
transverseMass2(plots.DataMCPlot(
datasets, analysis + "/QCD_TransverseMass_AfterJetSelection"),
"QCD_TransverseMass_AfterJetSelection",
rebin=1)
transverseMass2(plots.DataMCPlot(
datasets, analysis + "/QCD_TransverseMass_AfterJetSelectionMetCut"),
"QCD_TransverseMass_AfterJetSelectionMetCut",
rebin=1)
transverseMass2(plots.DataMCPlot(
datasets, analysis + "/QCD_TransverseMass_AfterJetsBtagging"),
"QCD_TransverseMass_AfterJetsBtagging",
rebin=1)
transverseMass2(plots.DataMCPlot(
datasets, analysis + "/QCD_TransverseMass_AfterBigBox"),
"QCD_TransverseMass_AfterBigBox",
rebin=1)
transverseMass2(plots.DataMCPlot(
datasets, analysis + "/QCD_TransverseMass_AfterBigBoxAndMet"),
"QCD_TransverseMass_AfterBigBoxAndMet",
rebin=1)
transverseMass2(plots.DataMCPlot(
datasets, analysis + "/QCD_TransverseMass_AfterBigBoxAndBtag"),
"QCD_TransverseMass_AfterBigBoxAndBtag",
rebin=1)
transverseMass2(plots.DataMCPlot(
datasets, analysis + "/QCD_TransverseMass_AfterBigBoxAndTauID"),
"QCD_TransverseMass_AfterBigBoxAndTauID",
rebin=1)
# xsect.setHplusCrossSections(datasets, toTop=True)
# genComparison(datasets)
# zMassComparison(datasets)
# topMassComparison(datasets)
# topPtComparison(datasets)
# vertexComparison(datasets)
eventCounter = counter.EventCounter(datasets, counters=countersWeighted)
eventCounter.normalizeMCByLuminosity()
# eventCounter.normalizeMCToLuminosity(73)
print "============================================================"
print "Main counter (MC normalized by collision data luminosity)"
print eventCounter.getMainCounterTable().format()
# print eventCounter.getSubCounterTable("GlobalMuon_ID").format()
# print eventCounter.getSubCounterTable("tauIDTauSelection").format()
# print eventCounter.getSubCounterTable("TauIDPassedEvt::tauID_HPSTight").format()
# print eventCounter.getSubCounterTable("TauIDPassedJets::tauID_HPSTight").format()
print eventCounter.getSubCounterTable("b-tagging").format()
print eventCounter.getSubCounterTable("Jet selection").format()
print eventCounter.getSubCounterTable("Jet main").format()
drh1 = datasets.getDataset("Data").getDatasetRootHisto(
analysis + "/QCD_MET_AfterJetSelection")
drh2 = datasets.getDataset("Data").getDatasetRootHisto(
analysis + "/QCD_MET_AfterJetsBtagging7080")
drh1.setName("Base")
drh1.normalizeToOne()
drh2.normalizeToOne()
# drh1.normalizeMCByLuminosity()
plot = plots.ComparisonPlot(drh1, drh2)
# plot = plots.PlotBase(drh1)
# plot = plots.MCPlot(drh1)
# Rebin, if necessary
plot.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(1))
# drh1.normalizeMCByLuminosity()
# plot = plots.PlotBase(drh1)
# plot = plots.MCPlot(drh
# Create frame with a ratio pad
plot.createFrame("distribution", opts={"ymin": 1e-5, "ymaxfactor": 1.5})
# createRatio=True, opts2={"ymin": -10, "ymax": 50}, # bounds of the ratio plot
# )
plot.draw()
plot.save()
mt = plots.DataMCPlot(datasets, analysis + "/QCD_MET_AfterJetSelection")
mt.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(10))
mt_data = mt.histoMgr.getHisto("Data").getRootHisto().Clone("mt_data")
def plot(datasets):
metCut = "met_p4.Et() > 50"
tauPtCut = "tau_p4.Pt() > 40"
jetNumCut = "Sum$(jets_p4.Pt() > 30) >= 3"
tauLeadingCandPtCut = "tau_leadPFChargedHadrCand_p4.Pt() > 20"
rtauCut = "tau_leadPFChargedHadrCand_p4.P()/tau_p4.P() > 0.7"
btag = "jets_btag > 1.7"
deltaPhiCut = "acos((tau_p4.Px()*met_p4.Px()+tau_p4.Py()*met_p4.Py())/tau_p4.Pt()/met_p4.Et())*57.2958 < 160"
tauSelCut = "tau_p4.Pt() > 40 && tau_leadPFChargedHadrCand_p4.Pt() > 20 && tau_leadPFChargedHadrCand_p4.P()/tau_p4.P() > 0.7"
tauJetsCut = "tau_p4.Pt() > 40 && tau_leadPFChargedHadrCand_p4.Pt() > 20 && tau_leadPFChargedHadrCand_p4.P()/tau_p4.P() > 0.7 && Sum$(jets_p4.Pt() > 30) >= 3 "
tauJetsMetCut = "tau_p4.Pt() > 40 && tau_leadPFChargedHadrCand_p4.Pt() > 20 && tau_leadPFChargedHadrCand_p4.P()/tau_p4.P() > 0.7 && Sum$(jets_p4.Pt() > 30) >= 3 && met_p4.Et() > 50"
noTagging = jetNumCut + "&&abs(jets_flavour)==5"
btagging = noTagging + "&&jets_btag > 1.7"
noTaggingLight = jetNumCut + "&&abs(jets_flavour) < 4"
btaggingLight = noTaggingLight + "&&jets_btag > 1.7"
noTaggingMet = jetNumCut + "&&met_p4.Et() > 50" + "&&abs(jets_flavour)==5"
btaggingMet = noTaggingMet + "&&jets_btag > 1.7"
###########################################
hpt = plots.DataMCPlot(
datasets,
treeDraw.clone(varexp="jets_p4.Et()>>dist(25,0,500)",
selection=noTagging))
hptt = hpt.histoMgr.getHisto("TTJets").getRootHisto().Clone("TTJets")
# hptt = hpt.histoMgr.getHisto("TTToHplusBWB_M120").getRootHisto().Clone("TTToHplusBWB_M120")
# hptt_btag = hptb.histoMgr.getHisto("TTJets").getRootHisto()
hpt.stackMCHistograms()
# hpt.addMCUncertainty()
# jet Et
hpt.createFrameFraction("jetEt",
opts={
"ymin": 0.0001,
"ymaxfactor": 1.1
},
opts2={
"ymin": 0.01,
"ymax": 1.5
})
hpt.setLegend(histograms.createLegend())
hpt.getPad().SetLogy(True)
hpt.frame.GetXaxis().SetTitle("Et jet")
hpt.frame.GetYaxis().SetTitle("Events /%.0f GeV/c" % hpt.binWidth())
hpt.draw()
hpt.addStandardTexts()
hpt.save()
# jet Et with b tagging
hptb = plots.DataMCPlot(
datasets,
treeDraw.clone(varexp="jets_p4.Et()>>dist(25,0,500)",
selection=btagging))
hptb.stackMCHistograms()
hptb.createFrameFraction("jetEt_btag",
opts={
"ymin": 0.0001,
"ymaxfactor": 1.1
},
opts2={
"ymin": 0.01,
"ymax": 1.5
})
hptb.setLegend(histograms.createLegend())
hptb.getPad().SetLogy(True)
hptb.frame.GetXaxis().SetTitle("Et jet btag")
hptb.frame.GetYaxis().SetTitle("Events /%.0f GeV/c" % hptb.binWidth())
hptb.draw()
hptb.addStandardTexts()
hptb.save()
##################################################
# MET cut comparison
# Clone the data one
hpt120 = hpt.histoMgr.getHisto("TTToHplusBWB_M120").getRootHisto().Clone(
"TTToHplusBWB_M120")
hpt120_btag = hptb.histoMgr.getHisto("TTToHplusBWB_M120").getRootHisto()
# hptt = hpt.histoMgr.getHisto("TTJets_TuneZ2_Summer11").getRootHisto().Clone("TTJets_TuneZ2_Summer11")
# hptt_btag = hptb.histoMgr.getHisto("TTJets_TuneZ2_Summer11").getRootHisto()
# hptt = hpt.histoMgr.getHisto("TTToHplusBWB_M120").getRootHisto().Clone("TTToHplusBWB_M120")
# hptt_btag = hptb.histoMgr.getHisto("TTToHplusBWB_M120").getRootHisto()
# tagged et / et
hpt120_btag.Divide(hpt120)
hpt120_btag.SetName("btagEff_pt")
# jet Et with b tagging and tau Et cut
hptmetb = plots.DataMCPlot(
datasets,
treeDraw.clone(varexp="jets_p4.Et()>>dist(25,0,500)",
selection=btaggingMet))
hptmet = plots.DataMCPlot(
datasets,
treeDraw.clone(varexp="jets_p4.Et()>>dist(25,0,500)",
selection=noTaggingMet))
# Clone the data one
hptmet120 = hptmet.histoMgr.getHisto(
"TTToHplusBWB_M120").getRootHisto().Clone("TTToHplusBWB_M120")
hptmet120_btag = hptmetb.histoMgr.getHisto(
"TTToHplusBWB_M120").getRootHisto()
# tagged et / et
hptmet120_btag.Divide(hptmet120)
hptmet120_btag.SetName("btagEff_pt_metcut")
canvas3 = ROOT.TCanvas("canvas3", "", 500, 500)
canvas3.SetLogy()
# hmt.SetMaximum(3.0)
hpt120_btag.SetMarkerColor(2)
hpt120_btag.SetMarkerSize(1)
hpt120_btag.SetMarkerStyle(21)
hpt120_btag.SetLineStyle(1)
hpt120_btag.SetLineWidth(1)
hpt120_btag.Draw("EP")
hptmet120_btag.SetMarkerColor(4)
hptmet120_btag.SetMarkerSize(1)
hptmet120_btag.SetMarkerStyle(22)
hptmet120_btag.SetLineStyle(1)
hptmet120_btag.SetLineColor(4)
hptmet120_btag.SetLineWidth(1)
hptmet120_btag.Draw("same")
hpt120_btag.GetYaxis().SetTitle("B-tagging efficiency")
# hmt.GetYaxis().SetTitleSize(20.0)
# data_btag.GetYaxis().SetTitleOffset(1.5)
hpt120_btag.GetXaxis().SetTitle("E_{T}^{jet} (GeV)")
tex1 = ROOT.TLatex(0.35, 0.8, "No MET cut")
tex1.SetNDC()
tex1.SetTextSize(20)
tex1.Draw()
marker1 = ROOT.TMarker(0.3, 0.815, hpt120_btag.GetMarkerStyle())
marker1.SetNDC()
marker1.SetMarkerColor(hpt120_btag.GetMarkerColor())
marker1.SetMarkerSize(0.9 * hpt120_btag.GetMarkerSize())
marker1.Draw()
tex2 = ROOT.TLatex(0.35, 0.7, "MET > 50 GeV")
tex2.SetNDC()
tex2.SetTextSize(20)
tex2.Draw()
marker2 = ROOT.TMarker(0.3, 0.715, hptmet120_btag.GetMarkerStyle())
marker2.SetNDC()
marker2.SetMarkerColor(hptmet120_btag.GetMarkerColor())
marker2.SetMarkerSize(0.9 * hptmet120_btag.GetMarkerSize())
marker2.Draw()
tex4 = ROOT.TLatex(0.2, 0.95,
"7 TeV CMS Preliminary ")
tex4.SetNDC()
tex4.SetTextSize(20)
tex4.Draw()
canvas3.Print("btagEff_pt.png")
##################################################
# Higgs mass comparison
hpt80 = hpt.histoMgr.getHisto("TTToHplusBWB_M80").getRootHisto().Clone(
"TTToHplusBWB_M80")
hpt80_btag = hptb.histoMgr.getHisto("TTToHplusBWB_M80").getRootHisto()
# tagged et / et
hpt80_btag.Divide(hpt80)
hpt80_btag.SetName("btagEff80_pt")
hpt160 = hpt.histoMgr.getHisto("TTToHplusBWB_M160").getRootHisto().Clone(
"TTToHplusBWB_M160")
hpt160_btag = hptb.histoMgr.getHisto("TTToHplusBWB_M160").getRootHisto()
# tagged et / et
hpt160_btag.Divide(hpt160)
hpt160_btag.SetName("btagEff160_pt")
# hpttt = hpt.histoMgr.getHisto("TTJets").getRootHisto().Clone("TTJets")
# hpttt = hpt.histoMgr.getHisto("TTJets").getRootHisto()
hpttt_btag = hptb.histoMgr.getHisto("TTJets").getRootHisto()
# hpttt = hpt.histoMgr.getHisto("TTToHplusBWB_M160").getRootHisto().Clone("TTToHplusBWB_M160")
# hpttt_btag = hptb.histoMgr.getHisto("TTToHplusBWB_M160").getRootHisto()
# tagged et / et
hpttt_btag.Divide(hpttt)
hpttt_btag.SetName("btagEfftt_pt")
canvas5 = ROOT.TCanvas("canvas5", "", 500, 500)
canvas5.SetLogy()
hpt120_btag.SetMaximum(1.5)
hpt120_btag.SetMarkerColor(2)
hpt120_btag.SetMarkerSize(1)
hpt120_btag.SetMarkerStyle(21)
hpt120_btag.SetLineStyle(1)
hpt120_btag.SetLineWidth(1)
hpt120_btag.Draw("P")
hpt80_btag.SetMarkerColor(4)
hpt80_btag.SetMarkerSize(1)
hpt80_btag.SetMarkerStyle(22)
hpt80_btag.SetLineStyle(1)
hpt80_btag.SetLineColor(4)
hpt80_btag.SetLineWidth(1)
hpt80_btag.Draw("same")
hpt160_btag.SetMarkerColor(7)
hpt160_btag.SetMarkerSize(1)
hpt160_btag.SetMarkerStyle(25)
hpt160_btag.SetLineStyle(1)
hpt160_btag.SetLineColor(7)
hpt160_btag.SetLineWidth(1)
hpt160_btag.Draw("same")
hpttt_btag.SetMarkerColor(6)
hpttt_btag.SetMarkerSize(1)
hpttt_btag.SetMarkerStyle(24)
hpttt_btag.SetLineStyle(1)
hpttt_btag.SetLineColor(6)
hpttt_btag.SetLineWidth(1)
hpttt_btag.Draw("same")
hpt120_btag.GetYaxis().SetTitle("B-tagging efficiency")
# hmt.GetYaxis().SetTitleSize(20.0)
# data_btag.GetYaxis().SetTitleOffset(1.5)
hpt120_btag.GetXaxis().SetTitle("E_{T}^{jet} (GeV)")
tex1 = ROOT.TLatex(0.25, 0.8, "m_{H^{#pm}} = 120 GeV/c^{2}")
tex1.SetNDC()
tex1.SetTextSize(20)
tex1.Draw()
marker1 = ROOT.TMarker(0.22, 0.815, hpt120_btag.GetMarkerStyle())
marker1.SetNDC()
marker1.SetMarkerColor(hpt120_btag.GetMarkerColor())
marker1.SetMarkerSize(0.9 * hpt120_btag.GetMarkerSize())
marker1.Draw()
tex2 = ROOT.TLatex(0.25, 0.75, "m_{H^{#pm}} = 80 GeV/c^{2}")
tex2.SetNDC()
tex2.SetTextSize(20)
tex2.Draw()
marker2 = ROOT.TMarker(0.22, 0.755, hpt80_btag.GetMarkerStyle())
marker2.SetNDC()
marker2.SetMarkerColor(hpt80_btag.GetMarkerColor())
marker2.SetMarkerSize(0.9 * hpt80_btag.GetMarkerSize())
marker2.Draw()
tex3 = ROOT.TLatex(0.25, 0.7, "m_{H^{#pm}} = 160 GeV/c^{2}")
tex3.SetNDC()
tex3.SetTextSize(20)
tex3.Draw()
marker3 = ROOT.TMarker(0.22, 0.715, hpt160_btag.GetMarkerStyle())
marker3.SetNDC()
marker3.SetMarkerColor(hpt160_btag.GetMarkerColor())
marker3.SetMarkerSize(0.9 * hpt160_btag.GetMarkerSize())
marker3.Draw()
tex4 = ROOT.TLatex(0.25, 0.65, "tt")
tex4.SetNDC()
tex4.SetTextSize(20)
tex4.Draw()
marker4 = ROOT.TMarker(0.22, 0.655, hpttt_btag.GetMarkerStyle())
marker4.SetNDC()
marker4.SetMarkerColor(hpttt_btag.GetMarkerColor())
marker4.SetMarkerSize(0.9 * hpttt_btag.GetMarkerSize())
marker4.Draw()
tex5 = ROOT.TLatex(0.2, 0.95,
"7 TeV CMS Preliminary ")
tex5.SetNDC()
tex5.SetTextSize(20)
tex5.Draw()
canvas5.Print("btagEff_pt_mH.png")
#######################################################################
# canvas = ROOT.TCanvas("canvas","",500,500)
# hpt120_btag.GetYaxis().SetTitle("B-tagging efficiency")
# hpt120_btag.GetXaxis().SetTitle("p_{T}^{jet} (GeV)")
# hpt120_btag.Draw()
# histo = hpt120_btag.Clone("histo")
## rangeMin = htopmass.GetXaxis().GetXmin()
## rangeMax = htopmass.GetXaxis().GetXmax()
# rangeMin = 30
# rangeMax = 500
# numberOfParameters = 3
# print "Fit range ",rangeMin, " - ",rangeMax
# class FitFunction:
# def __call__( self, x, par ):
## return exp(par[0] + par[1]*x[0])
# return par[0] + par[1]*x[0] + par[2]*x[0]*x[0]
## return par[0] + par[1]*x[0] + par[2]*x[0]*x[0] + par[3]*x[0]*x[0]*x[0]
# theFit = TF1('theFit',FitFunction(),rangeMin,rangeMax,numberOfParameters)
# theFit.SetParLimits(0,-20000,20000)
# theFit.SetParLimits(1,-20000,20000)
# theFit.SetParLimits(2,-20000,20000)
# theFit.SetParLimits(3,-20000,20000)
## gStyle.SetOptFit(0)
# data_btag.Fit(theFit,"LR")
# theFit.SetRange(rangeMin,rangeMax)
# theFit.SetLineStyle(1)
# theFit.SetLineWidth(2)
# theFit.Draw("same")
# tex4 = ROOT.TLatex(0.2,0.95,"CMS Preliminary ")
# tex4.SetNDC()
# tex4.SetTextSize(20)
# tex4.Draw()
# tex2 = ROOT.TLatex(0.6,0.7,"tt->tbH^{#pm}")
# tex2.SetNDC()
# tex2.SetTextSize(20)
# tex2.Draw()
# tex3 = ROOT.TLatex(0.6,0.6,"m_{H^{#pm}} = 120 GeV/c^{2}")
# tex3.SetNDC()
# tex3.SetTextSize(20)
# tex3.Draw()
# tex5 = ROOT.TLatex(0.6,0.5,"No MET cut")
# tex5.SetNDC()
# tex5.SetTextSize(20)
# tex5.Draw()
# print "Fit range ",rangeMin, " - ",rangeMax
# canvas.Print("jetEtFit.png")
########################################################
# plot discriminator
histo3 = plots.DataMCPlot(
datasets,
treeDraw.clone(varexp="jets_btag>>dist(50,-20,20)",
selection=noTagging))
# histo2.histoMgr.forEachHisto(lambda histo: histo.getRootHisto().Rebin(10))
histo3.stackMCHistograms()
histo3.createFrameFraction("b-discriminator",
opts={
"ymin": 0.0001,
"ymaxfactor": 1.1
},
opts2={
"ymin": 0.01,
"ymax": 1.5
})
histo3.setLegend(histograms.createLegend())
histo3.getPad().SetLogy(True)
histo3.frame.GetXaxis().SetTitle("b discriminator")
histo3.frame.GetYaxis().SetTitle("Events")
histo3.draw()
histo3.addStandardTexts()
histo3.save()
heta = plots.DataMCPlot(
datasets,
treeDraw.clone(varexp="jets_p4.Eta()>>dist(30,-3,3)",
selection=noTagging))
# histo2.histoMgr.forEachHisto(lambda histo: histo.getRootHisto().Rebin(10))
heta.stackMCHistograms()
heta.createFrameFraction("jetEta",
opts={
"ymin": 0.01,
"ymaxfactor": 2.0
},
opts2={
"ymin": 0.01,
"ymax": 1.5
})
heta.setLegend(histograms.createLegend())
heta.getPad().SetLogy(True)
heta.frame.GetXaxis().SetTitle("#eta^{jet}")
heta.frame.GetYaxis().SetTitle("Events")
heta.draw()
heta.addStandardTexts()
heta.save()
hetab = plots.DataMCPlot(
datasets,
treeDraw.clone(varexp="jets_p4.Eta()>>dist(30,-3,3)",
selection=btagging))
# histo2.histoMgr.forEachHisto(lambda histo: histo.getRootHisto().Rebin(10))
hetab.stackMCHistograms()
hetab.createFrameFraction("jetEta_btag",
opts={
"ymin": 0.01,
"ymaxfactor": 2.0
},
opts2={
"ymin": 0.01,
"ymax": 1.5
})
hetab.setLegend(histograms.createLegend())
hetab.getPad().SetLogy(True)
hetab.frame.GetXaxis().SetTitle("#eta^{b tagged jet}")
hetab.frame.GetYaxis().SetTitle("Events")
hetab.draw()
hetab.addStandardTexts()
hetab.save()
##################################################
# Higgs mass comparison
heta80 = heta.histoMgr.getHisto("TTToHplusBWB_M80").getRootHisto().Clone(
"TTToHplusBWB_M80")
heta80_btag = hetab.histoMgr.getHisto("TTToHplusBWB_M80").getRootHisto()
# tagged et / et
heta80_btag.Divide(heta80)
heta80_btag.SetName("btagEff80_eta")
heta160 = heta.histoMgr.getHisto("TTToHplusBWB_M160").getRootHisto().Clone(
"TTToHplusBWB_M160")
heta160_btag = hetab.histoMgr.getHisto("TTToHplusBWB_M160").getRootHisto()
# tagged et / et
heta160_btag.Divide(heta160)
heta160_btag.SetName("btagEff160_eta")
hetatt = heta.histoMgr.getHisto("TTJets").getRootHisto().Clone("TTJets")
hetatt_btag = hetab.histoMgr.getHisto("TTJets").getRootHisto()
# tagged et / et
hetatt_btag.Divide(hetatt)
hetatt_btag.SetName("btagEfftt_eta")
canvas5a = ROOT.TCanvas("canvas5a", "", 500, 500)
canvas5a.SetLogy()
heta120_btag.SetMaximum(1.5)
heta120_btag.SetMarkerColor(2)
heta120_btag.SetMarkerSize(1)
heta120_btag.SetMarkerStyle(21)
heta120_btag.SetLineStyle(1)
heta120_btag.SetLineWidth(1)
heta120_btag.Draw("P")
heta80_btag.SetMarkerColor(4)
heta80_btag.SetMarkerSize(1)
heta80_btag.SetMarkerStyle(22)
heta80_btag.SetLineStyle(1)
heta80_btag.SetLineColor(4)
heta80_btag.SetLineWidth(1)
heta80_btag.Draw("same")
heta160_btag.SetMarkerColor(7)
heta160_btag.SetMarkerSize(1)
heta160_btag.SetMarkerStyle(25)
heta160_btag.SetLineStyle(1)
heta160_btag.SetLineColor(7)
heta160_btag.SetLineWidth(1)
heta160_btag.Draw("same")
hetatt_btag.SetMarkerColor(6)
hetatt_btag.SetMarkerSize(1)
hetatt_btag.SetMarkerStyle(24)
hetatt_btag.SetLineStyle(1)
hetatt_btag.SetLineColor(6)
hetatt_btag.SetLineWidth(1)
hetatt_btag.Draw("same")
heta120_btag.GetYaxis().SetTitle("B-tagging efficiency")
# hmt.GetYaxis().SetTitleSize(20.0)
# data_btag.GetYaxis().SetTitleOffset(1.5)
heta120_btag.GetXaxis().SetTitle("E_{T}^{jet} (GeV)")
tex1 = ROOT.TLatex(0.25, 0.8, "m_{H^{#pm}} = 120 GeV/c^{2}")
tex1.SetNDC()
tex1.SetTextSize(20)
tex1.Draw()
marker1 = ROOT.TMarker(0.22, 0.815, heta120_btag.GetMarkerStyle())
marker1.SetNDC()
marker1.SetMarkerColor(heta120_btag.GetMarkerColor())
marker1.SetMarkerSize(0.9 * heta120_btag.GetMarkerSize())
marker1.Draw()
tex2 = ROOT.TLatex(0.25, 0.75, "m_{H^{#pm}} = 80 GeV/c^{2}")
tex2.SetNDC()
tex2.SetTextSize(20)
tex2.Draw()
marker2 = ROOT.TMarker(0.22, 0.755, heta80_btag.GetMarkerStyle())
marker2.SetNDC()
marker2.SetMarkerColor(heta80_btag.GetMarkerColor())
marker2.SetMarkerSize(0.9 * heta80_btag.GetMarkerSize())
marker2.Draw()
tex3 = ROOT.TLatex(0.25, 0.7, "m_{H^{#pm}} = 160 GeV/c^{2}")
tex3.SetNDC()
tex3.SetTextSize(20)
tex3.Draw()
marker3 = ROOT.TMarker(0.22, 0.715, heta160_btag.GetMarkerStyle())
marker3.SetNDC()
marker3.SetMarkerColor(heta160_btag.GetMarkerColor())
marker3.SetMarkerSize(0.9 * heta160_btag.GetMarkerSize())
marker3.Draw()
tex4 = ROOT.TLatex(0.25, 0.65, "tt")
tex4.SetNDC()
tex4.SetTextSize(20)
tex4.Draw()
marker4 = ROOT.TMarker(0.22, 0.655, hetatt_btag.GetMarkerStyle())
marker4.SetNDC()
marker4.SetMarkerColor(hetatt_btag.GetMarkerColor())
marker4.SetMarkerSize(0.9 * hetatt_btag.GetMarkerSize())
marker4.Draw()
tex5 = ROOT.TLatex(0.2, 0.95,
"7 TeV CMS Preliminary ")
tex5.SetNDC()
tex5.SetTextSize(20)
tex5.Draw()
canvas5a.Print("btagEff_eta_mH.png")
#######################################################################
canvas4 = ROOT.TCanvas("canvas4", "", 500, 500)
canvas4.SetLogy()
# hmt.SetMaximum(3.0)
heta120_btag.SetMarkerColor(4)
heta120_btag.SetMarkerSize(1)
heta120_btag.SetMarkerStyle(24)
heta120_btag.SetLineStyle(1)
heta120_btag.SetLineColor(4)
heta120_btag.SetLineWidth(1)
heta120_btag.Draw("EP")
heta120_btag.GetYaxis().SetTitle("B-tagging efficiency")
# hmt.GetYaxis().SetTitleSize(20.0)
# data_btag.GetYaxis().SetTitleOffset(1.5)
heta120_btag.GetXaxis().SetTitle("#eta^{jet} ")
tex4 = ROOT.TLatex(0.2, 0.95,
"7 TeV CMS Preliminary ")
tex4.SetNDC()
tex4.SetTextSize(20)
tex4.Draw()
canvas4.Print("btagEff_eta.png")
def createDrawPlot(name, **kwargs):
drawPlot( plots.DataMCPlot(datasets, name, normalizeToLumi=20000), name, **kwargs)
def main():
# Create all datasets from a multicrab task
datasets = dataset.getDatasetsFromMulticrabCfg(counters=counters)
# As we use weighted counters for MC normalisation, we have to
# update the all event count to a separately defined value because
# the analysis job uses skimmed pattuple as an input
datasets.updateNAllEventsToPUWeighted()
# Read integrated luminosities of data datasets from lumi.json
datasets.loadLuminosities()
# Include only 120 mass bin of HW and HH datasets
datasets.remove(
filter(lambda name: "TTToHplus" in name and not "M120" in name,
datasets.getAllDatasetNames()))
# Default merging nad ordering of data and MC datasets
# All data datasets to "Data"
# All QCD datasets to "QCD"
# All single top datasets to "SingleTop"
# WW, WZ, ZZ to "Diboson"
plots.mergeRenameReorderForDataMC(datasets)
# Set BR(t->H) to 0.05, keep BR(H->tau) in 1
xsect.setHplusCrossSectionsToBR(datasets, br_tH=0.05, br_Htaunu=1)
# Merge WH and HH datasets to one (for each mass bin)
# TTToHplusBWB_MXXX and TTToHplusBHminusB_MXXX to "TTToHplus_MXXX"
plots.mergeWHandHH(datasets)
ttjets2 = datasets.getDataset("TTJets").deepCopy()
ttjets2.setCrossSection(
ttjets2.getCrossSection() -
datasets.getDataset("TTToHplus_M120").getCrossSection())
print "Set TTJets2 cross section to %f" % ttjets2.getCrossSection()
ttjets2.setName("TTJets2")
datasets.append(ttjets2)
datasets.merge("EWKnott", ["WJets", "DYJetsToLL", "SingleTop", "Diboson"])
tmp = datasets.getDataset("EWKnott").deepCopy()
tmp.setName("EWKnott2")
datasets.append(tmp)
datasets.merge("EWK", ["EWKnott", "TTJets"])
datasets.merge("EWKS", [
"EWKnott2",
"TTJets2",
"TTToHplus_M120",
])
# Apply TDR style
style = tdrstyle.TDRStyle()
invertedQCD = InvertedTauID()
metBase = plots.DataMCPlot(datasets, analysis + "/MET_BaseLineTauIdJets")
metInver = plots.DataMCPlot(datasets, analysis + "/MET_InvertedTauIdJets")
# Rebin before subtracting
metBase.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(20))
metInver.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(20))
metInverted_data = metInver.histoMgr.getHisto("Data").getRootHisto().Clone(
analysis + "/MET_InvertedTauIdJets")
metInverted_EWK = metInver.histoMgr.getHisto("EWK").getRootHisto().Clone(
analysis + "/MET_InvertedTauIdJets")
metBase_data = metBase.histoMgr.getHisto("Data").getRootHisto().Clone(
analysis + "/MET_BaselineTauIdJets")
metBase_EWK = metBase.histoMgr.getHisto("EWK").getRootHisto().Clone(
analysis + "/MET_BaselineTauIdJets")
metBase_EWKS = metBase.histoMgr.getHisto("EWKS").getRootHisto().Clone(
analysis + "/MET_BaselineTauIdJets")
metBase_QCD = metBase_data.Clone("QCD")
metBase_QCD.Add(metBase_EWK, -1)
metBase_EWK.SetTitle("MC EWK")
metBase_EWKS.SetTitle("MC EWK + Signal")
invertedQCD.setLabel("EWK_vs_SEWK")
invertedQCD.comparison(metBase_EWK, metBase_EWKS, 0)
invertedQCD.setLabel("EWK_vs_SEWK_Normalized")
invertedQCD.comparison(metBase_EWK, metBase_EWKS, 1)
invertedQCD.setLabel("InvData")
invertedQCD.fitQCD(metInverted_data)
invertedQCD.setLabel("EWK")
invertedQCD.fitEWK(metBase_EWK)
invertedQCD.fitData(metBase_data)
normalizationWithEWK = invertedQCD.getNormalization()
invertedQCD.setLabel("EWKS")
invertedQCD.fitEWK(metBase_EWKS)
invertedQCD.fitData(metBase_data)
normalizationWithEWKS = invertedQCD.getNormalization()
print "Difference Signal vs no signal in EWK fit", (
normalizationWithEWKS - normalizationWithEWK) / normalizationWithEWK
def main(argv):
# HISTONAME = "TauIdJets"
# HISTONAME = "TauIdJetsCollinear"
# HISTONAME = "TauIdBtag"
# HISTONAME = "TauIdBvetoCollinear"
# HISTONAME = "TauIdBveto"
HISTONAME = "TauIdAfterCollinearCuts"
dirs = []
if len(sys.argv) < 2:
usage()
dirs.append(sys.argv[1])
# Create all datasets from a multicrab task
# datasets = dataset.getDatasetsFromMulticrabCfg(counters=counters, dataEra=dataEra, analysisBaseName="signalAnalysisInvertedTau")
#datasets = dataset.getDatasetsFromMulticrabDirs(dirs,counters=counters, dataEra=dataEra, analysisBaseName="signalAnalysisInvertedTau")
datasets = dataset.getDatasetsFromMulticrabDirs(dirs,dataEra=dataEra, searchMode=searchMode, analysisName=analysis, optimizationMode=optimizationMode)
# datasets = dataset.getDatasetsFromMulticrabDirs(dirs,counters=counters, dataEra=dataEra)
# Check multicrab consistency
consistencyCheck.checkConsistencyStandalone(dirs[0],datasets,name="QCD inverted")
# As we use weighted counters for MC normalisation, we have to
# update the all event count to a separately defined value because
# the analysis job uses skimmed pattuple as an input
datasets.updateNAllEventsToPUWeighted()
# Read integrated luminosities of data datasets from lumi.json
datasets.loadLuminosities()
# Include only 120 mass bin of HW and HH datasets
datasets.remove(filter(lambda name: "TTToHplus" in name and not "M120" in name, datasets.getAllDatasetNames()))
datasets.remove(filter(lambda name: "HplusTB" in name, datasets.getAllDatasetNames()))
datasets.remove(filter(lambda name: "Hplus_taunu_t-channel" in name, datasets.getAllDatasetNames()))
datasets.remove(filter(lambda name: "Hplus_taunu_tW-channel" in name, datasets.getAllDatasetNames()))
# Default merging nad ordering of data and MC datasets
# All data datasets to "Data"
# All QCD datasets to "QCD"
# All single top datasets to "SingleTop"
# WW, WZ, ZZ to "Diboson"
plots.mergeRenameReorderForDataMC(datasets)
# Set BR(t->H) to 0.05, keep BR(H->tau) in 1
xsect.setHplusCrossSectionsToBR(datasets, br_tH=0.05, br_Htaunu=1)
# Merge WH and HH datasets to one (for each mass bin)
# TTToHplusBWB_MXXX and TTToHplusBHminusB_MXXX to "TTToHplus_MXXX"
plots.mergeWHandHH(datasets)
datasets.merge("EWK", [
"TTJets",
"WJets",
"DYJetsToLL",
"SingleTop",
"Diboson"
])
# Apply TDR style
style = tdrstyle.TDRStyle()
style.setOptStat(True)
invertedQCD = InvertedTauID()
invertedQCD.setLumi(datasets.getDataset("Data").getLuminosity())
invertedQCD.setInfo([dataEra,searchMode,HISTONAME])
histonames = datasets.getDataset("Data").getDirectoryContent("baseline/METBaseline"+HISTONAME)
bins = []
binLabels = []
for histoname in histonames:
bins.append(histoname.replace("METBaseline"+HISTONAME,""))
title = datasets.getDataset("Data").getDatasetRootHisto("baseline/METBaseline"+HISTONAME+"/"+histoname).getHistogram().GetTitle()
title = title.replace("METBaseline"+HISTONAME,"")
title = title.replace("#tau p_{T}","taup_T")
title = title.replace("#tau eta","taueta")
title = title.replace("<","lt")
title = title.replace(">","gt")
title = title.replace("=","eq")
title = title.replace("..","to")
title = title.replace(".","p")
title = title.replace("/","_")
binLabels.append(title)
print
print "Histogram bins available",bins
# bins = ["Inclusive"]
# bins = ["taup_Tleq50","taup_Teq50to60"]
print "Using bins ",bins
print
print "Bin labels"
for i in range(len(binLabels)):
line = bins[i]
while len(line) < 10:
line += " "
line += ": "+binLabels[i]
print line
print
for i,bin in enumerate(bins):
invertedQCD.setLabel(binLabels[i])
metBase = plots.DataMCPlot(datasets, "baseline/METBaseline"+HISTONAME+"/METBaseline"+HISTONAME+bin)
metInver = plots.DataMCPlot(datasets, "Inverted/METInverted"+HISTONAME+"/METInverted"+HISTONAME+bin)
# Rebin before subtracting
metBase.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(5))
metInver.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(5))
metInverted_data = metInver.histoMgr.getHisto("Data").getRootHisto().Clone("Inverted/METInverted"+HISTONAME+"/METInverted"+HISTONAME+bin)
metInverted_EWK = metInver.histoMgr.getHisto("EWK").getRootHisto().Clone("Inverted/METInverted"+HISTONAME+"/METInverted"+HISTONAME+bin)
metBase_data = metBase.histoMgr.getHisto("Data").getRootHisto().Clone("Baseline/METBaseLine"+HISTONAME+"/METBaseline"+HISTONAME+bin)
metBase_EWK = metBase.histoMgr.getHisto("EWK").getRootHisto().Clone("Baseline/METBaseLine"+HISTONAME+"/METBaseline"+HISTONAME+bin)
metBase_QCD = metBase_data.Clone("QCD")
metBase_QCD.Add(metBase_EWK,-1)
metInverted_QCD = metInverted_data.Clone("QCD")
metInverted_QCD.Add(metInverted_EWK,-1)
metInverted_data = addlabels(metInverted_data)
metInverted_EWK = addlabels(metInverted_EWK)
metBase_data = addlabels(metBase_data)
metBase_EWK = addlabels(metBase_EWK)
metInverted_QCD = addlabels(metInverted_QCD)
invertedQCD.plotHisto(metInverted_data,"inverted")
invertedQCD.plotHisto(metInverted_EWK,"invertedEWK")
invertedQCD.plotHisto(metBase_data,"baseline")
invertedQCD.plotHisto(metBase_EWK,"baselineEWK")
fitOptions = "LRB"
# fitOptions = "RB"
# fitOptions = "IEB"
# ROOT.TVirtualFitter.SetDefaultFitter("Minuit")
# ROOT.TVirtualFitter.SetDefaultFitter("Minuit2")
# fitOptions = "Q" # Chi2 Fit
# fitOptions = "VEB" # Chi2 Fit with Minos Error
# fitOptions = "IEB" # Chi2 Fit with Integral and Minos
# fitOptions = "VLEB" # Likelihood Fit with Minos Error
# ROOT.TVirtualFitter.SetDefaultFitter("Fumili")
# ROOT.TVirtualFitter.SetDefaultFitter("Fumili2")
# fitOptions = "Q" # Chi2 Fit
# fitOptions = "VE" # Chi2 Fit with Minos Error
# fitOptions = "IE" # Chi2 Fit with Integral and Minos
# fitOptions = "VLE" # Likelihood Fit with Minos Error
invertedQCD.fitEWK(metInverted_EWK,fitOptions)
invertedQCD.fitEWK(metBase_EWK,fitOptions)
invertedQCD.fitQCD(metInverted_QCD,fitOptions)
invertedQCD.fitData(metBase_data)
invertedQCD.getNormalization()
invertedQCD.Summary()
invertedQCD.WriteNormalizationToFile("QCDInvertedNormalizationFactors.py")
invertedQCD.WriteLatexOutput("fits.tex")
def main():
# Create all datasets from a multicrab task
datasets = dataset.getDatasetsFromMulticrabCfg(analysisName=analysis)
# As we use weighted counters for MC normalisation, we have to
# update the all event count to a separately defined value because
# the analysis job uses skimmed pattuple as an input
datasets.updateNAllEventsToPUWeighted()
# Read integrated luminosities of data datasets from lumi.json
datasets.loadLuminosities()
# Include only 120 mass bin of HW and HH datasets
datasets.remove(
filter(lambda name: "TTToHplus" in name and not "M120" in name,
datasets.getAllDatasetNames()))
datasets.remove(
filter(lambda name: "HplusTB" in name, datasets.getAllDatasetNames()))
# Default merging nad ordering of data and MC datasets
# All data datasets to "Data"
# All QCD datasets to "QCD"
# All single top datasets to "SingleTop"
# WW, WZ, ZZ to "Diboson"
plots.mergeRenameReorderForDataMC(datasets)
# Set BR(t->H) to 0.2, keep BR(H->tau) in 1
xsect.setHplusCrossSectionsToBR(datasets, br_tH=0.05, br_Htaunu=1)
# Merge WH and HH datasets to one (for each mass bin)
# TTToHplusBWB_MXXX and TTToHplusBHminusB_MXXX to "TTToHplus_MXXX"
plots.mergeWHandHH(datasets)
# Merge EWK datasets
datasets.merge("EWK",
["WJets", "TTJets", "DYJetsToLL", "SingleTop", "Diboson"])
# Apply TDR style
style = tdrstyle.TDRStyle()
# Create the normalized plot of transverse mass
# Read the histogram from the file
#mT = plots.DataMCPlot(datasets, "transverseMass")
# Create the histogram from the tree (and see the selections explicitly)
td = dataset.TreeDraw(
"tree",
weight="weightPileup*weightTrigger*weightPrescale",
selection="met_p4.Et() > 70 && Max$(jets_btag) > 1.7")
mT = plots.DataMCPlot(
datasets,
td.clone(
varexp=
"sqrt(2 * tau_p4.Pt() * met_p4.Et() * (1-cos(tau_p4.Phi()-met_p4.Phi())))>>dist(400, 0, 400)"
))
# Rebin before subtracting
mT.histoMgr.forEachHisto(lambda h: h.getRootHisto().Rebin(20))
# Create the data-EWK histogram and draw it
dataEwkDiff(mT)
# Draw the mT distribution
transverseMass(mT)
def createPlot(name):
name2 = name
if isinstance(name, basestring):
name2 = analysis+"/"+name
return plots.DataMCPlot(datasets, name2)
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)
def main():
# weight = ""
weight = "VertexWeight"
# weight = "PileupWeight"
# mainAnalysis = "muonSelectionPFPt40Met20NJets3"
mainAnalysis = "muonSelectionPFPt40Met20NJets3%s" % weight
tauIsoAnalyses = [
# "muonSelectionPFPt40Met20NJets3%sIsoTauVLoose" % weight,
# "muonSelectionPFPt40Met20NJets3%sIsoTauLoose" % weight,
# "muonSelectionPFPt40Met20NJets3%sIsoTauMedium" % weight,
# "muonSelectionPFPt40Met20NJets3%sIsoTauTight" % weight,
# "muonSelectionPFPt40Met20NJets3%sIsoTauLikeTight" % weight,
# "muonSelectionPFPt40Met20NJets3%sIsoTauLikeTightSc015" % weight,
# "muonSelectionPFPt40Met20NJets3%sIsoTauLikeTightSc02" % weight,
"muonSelectionPFPt40Met20NJets3%sIsoTauLikeTightIc04" % weight,
# "muonSelectionPFPt40Met20NJets3%sIsoTauLikeTightSc015Ic04" % weight,
# "muonSelectionPFPt40Met20NJets3%sIsoTauLikeTightSc02Ic04" % weight,
# "muonSelectionPFPt40Met20NJets3%sIsoTauLikeMedium" % weight,
# "muonSelectionPFPt40Met20NJets3%sIsoTauLikeLoose" % weight,
# "muonSelectionPFPt40Met20NJets3%sIsoTauLikeVLoose" % weight,
]
signals = [
"TTJets",
"WJets",
# "SingleTop",
# "DYJetsToLL", "Diboson"
]
backgrounds = [
"QCD_Pt20_MuEnriched",
# "DYJetsToLL", "Diboson"
]
sel = muonAnalysis.Selections(mainAnalysis)
selection = sel.selectionJet
datasets = dataset.getDatasetsFromMulticrabCfg(counters=mainAnalysis +
"countAnalyzer/weighted")
datasets.loadLuminosities()
# datasets.remove(["SingleMu_163270-163869_Prompt", "SingleMu_162803-163261_Prompt", "SingleMu_160431-161016_Prompt"])
datasets41x = dataset.getDatasetsFromMulticrabCfg(
cfgfile=
"/home/mkortela/hplus/CMSSW_4_1_5/src/HiggsAnalysis/HeavyChHiggsToTauNu/test/tauEmbedding/multicrab_muonAnalysis_chargedGamma_110617_002143/multicrab.cfg",
counters=mainAnalysis + "countAnalyzer/weighted")
datasets41x.selectAndReorder([
"TToBLNu_s-channel_TuneZ2_Spring11",
"TToBLNu_t-channel_TuneZ2_Spring11",
"TToBLNu_tW-channel_TuneZ2_Spring11", "WW_TuneZ2_Spring11",
"WZ_TuneZ2_Spring11", "ZZ_TuneZ2_Spring11"
])
datasets.extend(datasets41x)
plots.mergeRenameReorderForDataMC(datasets)
style = tdrstyle.TDRStyle()
histograms.createLegend.moveDefaults(dx=-0.15, dy=0.1, dh=-0.1)
# QCD fraction for the continuous isolation variables
prefix = selection + "_"
isoPassed = []
isoNames = ["sumIsoRel", "pfSumIsoRel"]
#isoNames = ["sumIsoRelFull", "pfSumIsoRelFull"]
additionalIsoNames = [
"tauTightIso",
"tauMediumIso",
"tauLooseIso",
"tauVLooseIso",
"tauTightSc015Iso", # "tauTightSc02Iso",
"tauTightIc04Iso",
"tauTightSc015Ic04Iso", # "tauTightSc02Ic04Iso",
"tauTightIc04SumPtIso",
"tauTightIc04MaxPtIso",
"tauTightIc04ChargedIso",
"tauTightIc04GammaIso",
]
for iso in isoNames + additionalIsoNames:
isoPassed.append(
muonAnalysis.muonIso(plots.DataMCPlot(datasets,
selection + "/muon_" + iso),
prefix,
iso,
rebin=5,
opts={"ymin": 1e-1}))
for tauIso in tauIsoAnalyses:
tmp = muonAnalysis.Selections(tauIso).selectionJet
muonAnalysis.muonIso(
plots.DataMCPlot(datasets, tmp + "/muon_" + iso), tmp + "_",
iso)
for iso in additionalIsoNames:
opts = {"ymin": 1e-1}
rebin = 1
ratio = False
if iso in ["tauTightIc04Iso", "tauTightIso"]:
opts["xmax"] = 50
opts["ymax"] = 5e4
ratio = True
elif iso in ["tauTightIc04ChargedIso", "tauTightIc04GammaIso"]:
opts["xmax"] = 30
opts["ymax"] = 5e4
ratio = True
elif "Pt" in iso:
rebin = 5
muonAnalysis.muonIso(plots.DataMCPlot(datasets,
selection + "/muon_" + iso),
prefix,
iso,
rebin=rebin,
opts=opts,
ratio=ratio)
isoPlot = muonAnalysis.PlotIso(isoPassed, isoNames)
muonAnalysis.muonIsoQcd(isoPlot, prefix)
# Get the tau isolation values
s_count = {}
b_count = {}
sum_count = {}
for isoAnalysis in [mainAnalysis] + tauIsoAnalyses:
dsets = dataset.getDatasetsFromMulticrabCfg(counters=isoAnalysis +
"countAnalyzer/weighted")
dsets.loadLuminosities()
plots.mergeRenameReorderForDataMC(dsets)
dsets.merge("Signal2", signals)
dsets.merge("Background2", backgrounds)
stmp = dsets.getDataset("Signal2").deepCopy()
btmp = dsets.getDataset("Background2").deepCopy()
dsets.merge("MCSum", dsets.getMCDatasetNames())
stmp.setName("Signal")
btmp.setName("Background")
dsets.append(stmp)
dsets.append(btmp)
ec = counter.EventCounter(dsets)
ec.normalizeMCByCrossSection()
tbl = ec.getMainCounterTable()
idx = tbl.getColumn(
name="Signal").getRowNames().index(isoAnalysis +
"countJetMultiplicityCut")
sc = tbl.getColumn(name="Signal").getCount(idx).value()
bc = tbl.getColumn(name="Background").getCount(idx).value()
sumc = tbl.getColumn(name="MCSum").getCount(idx).value()
s_count[isoAnalysis] = sc
b_count[isoAnalysis] = bc
sum_count[isoAnalysis] = sumc
s_eff = {}
b_rej = {}
b_frac = {}
for isoAnalysis in tauIsoAnalyses:
s_eff[isoAnalysis] = s_count[isoAnalysis] / s_count[mainAnalysis]
b_rej[isoAnalysis] = 1 - b_count[isoAnalysis] / b_count[mainAnalysis]
b_frac[isoAnalysis] = b_count[isoAnalysis] / sum_count[isoAnalysis]
print s_eff[isoAnalysis], b_rej[isoAnalysis], b_frac[isoAnalysis]
# Plot the ROC
datasets.merge("Signal", signals)
datasets.merge("Background", backgrounds)
# datasets.selectAndReorder(["Signal", "Background"])
print ", ".join([d.getName() for d in datasets.getAllDatasets()])
histograms.createLegend.setDefaults(x1=0.2, y1=0.5, x2=0.4, y2=0.8)
seff = PlotEff(datasets, "Signal",
[selection + "/muon_" + iso for iso in isoNames], isoNames)
beff = PlotEff(datasets, "Background",
[selection + "/muon_" + iso for iso in isoNames], isoNames)
plotEff(seff, prefix)
plotEff(beff, prefix)
plot = PlotRoc(datasets)
plotf = PlotRocFraction(datasets)
for p in [plot, plotf]:
for iso in isoNames:
p.addCurve(selection + "/muon_" + iso, iso)
for iso in tauIsoAnalyses:
plot.addPoint(s_eff[iso], b_rej[iso], iso)
plotf.addPoint(s_eff[iso], b_frac[iso], iso)
plot.finalize()
plotf.finalize()
plotRoc(plot, prefix)
#plot.pointStyle()
plotRoc(
plot,
prefix,
postfix=
"_zoom", #opts={"ymin": 0.97, "ymax": 1.005, "xmin": 0.2, "xmax": 1},
opts={
"ymin": 0.8,
"ymax": 1.005,
"xmin": 0.2,
"xmax": 1
},
moveLegend={"dy": -0.1})
#plotRoc(plot, prefix, postfix="_zoom2", opts={"xmin": 0.8, "xmax": 1})
plotRoc(plotf,
prefix,
opts={
"ymax": 0.4,
"xmax": 1.0
},
moveLegend={"dy": 0.1})
#plotRoc(plotf, prefix, opts={"ymax":0.1, "xmax":1.0})
plotRoc(plotf, prefix, log=True, moveLegend={"dy": -0.2})
#expectedCount = dataset.Count(expected.Integral(lowBin, upBin), 0)
embeddedCount = dataset.Count(embedded.Integral(), 0)
expectedCount = dataset.Count(expected.Integral(), 0)
prediction = embeddedCount.copy()
prediction.multiply(normfactor)
print "Embedded events %.2f" % embeddedCount.value()
print "Predicted events %.2f +- %.2f" % (prediction.value(),
prediction.uncertainty())
print "Expected events %.2f" % expectedCount.value()
#mtEmbedded = plots.DataMCPlot(datasets, analysis+"/transverseMass")
#mtExpected = plots.DataMCPlot(datasetsExpected, analysis+"/transverseMass")
mtEmbedded = plots.DataMCPlot(
datasets, analysis + "/TauEmbeddingAnalysis_afterBTagging_TransverseMass")
mtExpected = plots.DataMCPlot(
datasetsExpected,
analysis + "/TauEmbeddingAnalysis_afterBTagging_TransverseMass")
def run(func, getter):
return func(getter(mtEmbedded.histoMgr), getter(mtExpected.histoMgr))
norms = {}
for d in ["Data"]: #, "TTJets", "WJets"]:
print
print "From %s" % d
norms[d] = run(normalizationFactor, lambda h: h.getHisto(d).getRootHisto())