def DoPlots(datasetsMgr, histoName, analysisType="Inverted", bType="GenuineB"):
# Sanity checks
IsBaselineOrInverted(analysisType)
IsGenuineOrFake(bType)
# Definitions
defaultFolder = ""
if "FakeBPurity" in histoName:
defaultFolder = "FakeBPurity"
elif "ForFakeBMeasurement" + histoName:
defaultFolder = "ForFakeBMeasurement"
else:
raise Exception("This should never happen")
# Define folders for inclusive/genuine/fakes
inclusiveFolder = defaultFolder
genuineFolder = defaultFolder + "EWKGenuineB"
fakeFolder = defaultFolder + "EWKFakeB"
inclusiveHisto = histoName.replace(defaultFolder, inclusiveFolder)
genuineHisto = histoName.replace(defaultFolder, genuineFolder)
fakeHisto = histoName.replace(defaultFolder, fakeFolder)
# Get the inclusive histograms
p0 = plots.DataMCPlot(datasetsMgr, inclusiveHisto)
Data = p0.histoMgr.getHisto("Data").getRootHisto().Clone("Data")
# Get the genuine-b histograms
p1 = plots.DataMCPlot(datasetsMgr, genuineHisto)
EWKGenuineB = p1.histoMgr.getHisto("EWK").getRootHisto().Clone(
"EWKGenuineB")
QCDGenuineB = p1.histoMgr.getHisto("QCD").getRootHisto().Clone(
"QCDGenuineB")
# Get the fake-b histograms
p2 = plots.DataMCPlot(datasetsMgr, fakeHisto)
EWKFakeB = p2.histoMgr.getHisto("EWK").getRootHisto().Clone("EWKFakeB")
QCDFakeB = p2.histoMgr.getHisto("QCD").getRootHisto().Clone("QCDFakeB")
# Normalize histograms to unit area
if 0:
Data.Scale(1.0 / Data.Integral())
EWKGenuineB.Scale(1.0 / EWKGenuineB.Integral())
EWKFakeB.Scale(1.0 / EWKFakeB.Integral())
QCDGenuineB.Scale(1.0 / QCDGenuineB.Integral())
QCDFakeB.Scale(1.0 / EWKFakeB.Integral())
# Create the final plot object
comparisonList = [EWKGenuineB, QCDGenuineB, EWKFakeB, QCDFakeB]
p = plots.ComparisonManyPlot(Data, comparisonList, saveFormats=[])
p.setLuminosity(GetLumi(datasetsMgr))
# Apply styles
p.histoMgr.forHisto("Data", styles.getDataStyle())
p.histoMgr.forHisto("EWKGenuineB",
styles.getAltEWKStyle()) #GenuineBStyle()
p.histoMgr.forHisto("QCDGenuineB", styles.getQCDStyle())
p.histoMgr.forHisto("EWKFakeB", styles.getGenuineBStyle())
p.histoMgr.forHisto("QCDFakeB", styles.getFakeBStyle())
# Set draw style
p.histoMgr.setHistoDrawStyle("Data", "AP")
p.histoMgr.setHistoDrawStyle("EWKGenuineB", "AP")
p.histoMgr.setHistoDrawStyle("QCDGenuineB", "AP")
p.histoMgr.setHistoDrawStyle("EWKFakeB", "AP")
p.histoMgr.setHistoDrawStyle("QCDFakeB", "AP")
# Set legend style
p.histoMgr.setHistoLegendStyle("Data", "P")
p.histoMgr.setHistoLegendStyle("EWKGenuineB", "P")
p.histoMgr.setHistoLegendStyle("QCDGenuineB", "P")
p.histoMgr.setHistoLegendStyle("EWKFakeB", "P")
p.histoMgr.setHistoLegendStyle("QCDFakeB", "P")
# p.histoMgr.setHistoLegendStyleAll("LP")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Data": "Data",
"EWKGenuineB": "EWK-GenuineB",
"QCDGenuineB": "QCD-GenuineB",
"EWKFakeB": "EWK-FakeB",
"QCDFakeB": "QCD-FakeB",
#"Data" : "Data (%s)" % (analysisType),
#"EWKGenuineB": "EWK-GenuineB (%s)" % (analysisType),
#"QCDGenuineB": "QCD-GenuineB (%s)" % (analysisType),
#"EWKFakeB" : "EWK-FakeB (%s)" % (analysisType),
#"QCDFakeB" : "QCD-FakeB (%s)" % (analysisType),
})
# Draw the histograms
_cutBox = None
_rebinX = 1
_opts = {"ymin": 1e0, "ymaxfactor": 2.0}
_format = "%0.0f"
_xlabel = None
if "dijetm" in histoName.lower():
_rebinX = 2
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jj} (%s)" % (_units)
_cutBox = {
"cutValue": 80.399,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
_opts["xmax"] = 400.0
if "trijetm" in histoName.lower():
_rebinX = 5
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jjb} (%s)" % _units
_cutBox = {
"cutValue": 173.21,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
_opts["xmax"] = 1500.0
if "pt" in histoName.lower():
_rebinX = 2
_format = "%0.0f GeV/c"
if "eta" in histoName.lower():
_format = "%0.2f"
_cutBox = {
"cutValue": 0.,
"fillColor": 16,
"box": False,
"line": True,
"greaterThan": True
}
_opts["xmin"] = -3.0
_opts["xmax"] = +3.0
if "deltaeta" in histoName.lower():
_format = "%0.2f"
_opts["xmin"] = 0.0
_opts["xmax"] = 6.0
if "bdisc" in histoName.lower():
_format = "%0.2f"
if "tetrajetm" in histoName.lower():
_rebinX = 10
_units = "GeV/c^{2}"
_format = "%0.0f " + _units
_xlabel = "m_{jjjb} (%s)" % (_units)
_opts["xmax"] = 3500.0
if "ancestry" in histoName.lower():
_rebinX = 1
_units = ""
_format = "%0.0f " + _units
_opts["xmax"] = 32.0
plots.drawPlot(
p,
histoName,
xlabel=_xlabel,
ylabel="Arbitrary Units / %s" % (_format),
log=True,
rebinX=_rebinX,
cmsExtraText="Preliminary",
createLegend={
"x1": 0.62,
"y1": 0.72,
"x2": 0.92,
"y2": 0.92
},
opts=_opts,
opts2={
"ymin": 0.0,
"ymax": 1.5
}, #{"ymin": 0.6, "ymax": 1.4},
ratio=True,
ratioInvert=False,
ratioYlabel="Ratio",
cutBox=_cutBox,
)
# Save plot in all formats
SavePlot(p, histoName,
os.path.join(opts.saveDir, "GenuineVsFake", opts.optMode))
return
def PlotHistosAndCalculateTF(datasetsMgr, histoList, binLabels, opts):
# Get the histogram customisations (keyword arguments)
_kwargs = GetHistoKwargs(histoList[0])
# Get the root histos for all datasets and Control Regions (CRs)
regions = ["SR", "VR", "CRone", "CRtwo", "CRthree", "CRfour"]
rhDict = GetRootHistos(datasetsMgr, histoList, regions, binLabels)
#=========================================================================================
# Calculate the Transfer Factor (TF) and save to file
#=========================================================================================
manager = FakeBNormalization.FakeBNormalizationManager(binLabels, opts.mcrab, opts.optMode, verbose=False)
if opts.inclusiveOnly:
#manager.CalculateTransferFactor(binLabels[0], rhDict["CRone-FakeB"], rhDict["CRtwo-FakeB"])
binLabel = "Inclusive"
manager.CalculateTransferFactor("Inclusive", rhDict["FakeB-CRone-Inclusive"], rhDict["FakeB-CRtwo-Inclusive"], rhDict["FakeB-CRthree-Inclusive"], rhDict["FakeB-CRfour-Inclusive"])
else:
for bin in binLabels:
manager.CalculateTransferFactor(bin, rhDict["FakeB-CRone-%s" % bin], rhDict["FakeB-CRtwo-%s" % bin], rhDict["FakeB-CRthree-%s" % bin], rhDict["FakeB-CRfour-%s" % bin])
# Get unique a style for each region
for k in rhDict:
dataset = k.split("-")[0]
region = k.split("-")[1]
styles.getABCDStyle(region).apply(rhDict[k])
if "FakeB" in k:
styles.getFakeBStyle().apply(rhDict[k])
# sr.apply(rhDict[k])
# =========================================================================================
# Create the final plot object
# =========================================================================================
rData_SR = rhDict["Data-SR-Inclusive"]
rEWKGenuineB_SR = rhDict["EWK-SR-Inclusive-EWKGenuineB"]
rBkgSum_SR = rhDict["FakeB-VR-Inclusive"].Clone("BkgSum-SR-Inclusive")
rBkgSum_SR.Reset()
if opts.inclusiveOnly:
bin = "Inclusive"
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
binHisto_VR = rhDict["FakeB-VR-%s" % (bin)]
VRtoSR_TF = manager.GetTransferFactor(bin)
Print("Applying TF = %s%0.6f%s to VR shape" % (ShellStyles.NoteStyle(), VRtoSR_TF, ShellStyles.NormalStyle()), True)
binHisto_VR.Scale(VRtoSR_TF)
# Add the normalised histogram to the final Inclusive SR (predicted) histo
rBkgSum_SR.Add(binHisto_VR, +1)
else:
# For-loop: All bins
for i, bin in enumerate(binLabels, 1):
if bin == "Inclusive":
continue
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
binHisto_VR = rhDict["FakeB-VR-%s" % (bin)]
VRtoSR_TF = manager.GetTransferFactor(bin)
Print("Applying TF = %s%0.6f%s to VR shape" % (ShellStyles.NoteStyle(), VRtoSR_TF, ShellStyles.NormalStyle()), i==1)
binHisto_VR.Scale(VRtoSR_TF)
# Add the normalised histogram to the final Inclusive SR (predicted) histo
rBkgSum_SR.Add(binHisto_VR, +1)
#Print("Got Verification Region (VR) shape %s%s%s" % (ShellStyles.NoteStyle(), rFakeB_VR.GetName(), ShellStyles.NormalStyle()), True)
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
#VRtoSR_TF = manager.GetTransferFactor("Inclusive")
#Print("Applying TF = %s%0.6f%s to VR shape" % (ShellStyles.NoteStyle(), VRtoSR_TF, ShellStyles.NormalStyle()), True)
#rBkgSum_SR.Scale(VRtoSR_TF)
# Plot histograms
if opts.altPlot:
# Add the SR EWK Genuine-b to the SR FakeB ( BkgSum = [FakeB] + [GenuineB-MC] = [VR * (CR1/CR2)] + [GenuineB-MC] )
rBkgSum_SR.Add(rEWKGenuineB_SR, +1)
# Change style
styles.getGenuineBStyle().apply(rBkgSum_SR)
# Remove unsupported settings of kwargs
_kwargs["stackMCHistograms"] = False
_kwargs["addLuminosityText"] = False
# Create the plot
p = plots.ComparisonManyPlot(rData_SR, [rBkgSum_SR], saveFormats=[])
# Set draw / legend style
p.histoMgr.setHistoDrawStyle("Data-SR-Inclusive", "P")
p.histoMgr.setHistoLegendStyle("Data-SR-Inclusive" , "LP")
p.histoMgr.setHistoDrawStyle("BkgSum-SR-Inclusive", "HIST")
p.histoMgr.setHistoLegendStyle("BkgSum-SR-Inclusive" , "F")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Data-SR" : "Data",
"BkgSum-SR" : "Fake-b + Gen-b",
})
else:
# Create empty histogram stack list
myStackList = []
# Add the FakeB data-driven background to the histogram list
hFakeB = histograms.Histo(rBkgSum_SR, "FakeB", "Fake-b")
hFakeB.setIsDataMC(isData=False, isMC=True)
myStackList.append(hFakeB)
# Add the EWKGenuineB MC background to the histogram list
hGenuineB = histograms.Histo(rEWKGenuineB_SR, "GenuineB", "EWK Genuine-b")
hGenuineB.setIsDataMC(isData=False, isMC=True)
myStackList.append(hGenuineB)
# Add the collision datato the histogram list
hData = histograms.Histo(rData_SR, "Data", "Data")
hData.setIsDataMC(isData=True, isMC=False)
myStackList.insert(0, hData)
p = plots.DataMCPlot2( myStackList, saveFormats=[])
p.setLuminosity(opts.intLumi)
p.setDefaultStyles()
# Draw the plot and save it
hName = opts.histoKey #"test"
plots.drawPlot(p, hName, **_kwargs)
SavePlot(p, hName, os.path.join(opts.saveDir, opts.optMode), saveFormats = [".png"])
#=========================================================================================
# Calculate the Transfer Factor (TF) and save to file
#=========================================================================================
Verbose("Write the normalisation factors to a python file", True)
fileName = os.path.join(opts.mcrab, "FakeBTransferFactors%s.py"% ( getModuleInfoString(opts) ) )
manager.writeTransferFactorsToFile(fileName, opts)
return
def PlotHistosAndCalculateTF(datasetsMgr, histoList, binLabels, opts):
# Get the histogram customisations (keyword arguments)
_kwargs = GetHistoKwargs(histoList[0])
# Get the root histos for all datasets and Control Regions (CRs)
regions = ["SR", "VR", "CRone", "CRtwo"]
rhDict = GetRootHistos(datasetsMgr, histoList, regions, binLabels)
#=========================================================================================
# Calculate the Transfer Factor (TF) and save to file
#=========================================================================================
manager = FakeBNormalization.FakeBNormalizationManager(binLabels,
opts.mcrab,
opts.optMode,
verbose=False)
if opts.inclusiveOnly:
#manager.CalculateTransferFactor(binLabels[0], rhDict["CRone-FakeB"], rhDict["CRtwo-FakeB"])
binLabel = "Inclusive"
manager.CalculateTransferFactor("Inclusive",
rhDict["FakeB-CRone-Inclusive"],
rhDict["FakeB-CRtwo-Inclusive"])
else:
for bin in binLabels:
manager.CalculateTransferFactor(bin,
rhDict["FakeB-CRone-%s" % bin],
rhDict["FakeB-CRtwo-%s" % bin])
# Get unique a style for each region
for k in rhDict:
dataset = k.split("-")[0]
region = k.split("-")[1]
styles.getABCDStyle(region).apply(rhDict[k])
if "FakeB" in k:
styles.getFakeBStyle().apply(rhDict[k])
# sr.apply(rhDict[k])
# =========================================================================================
# Create the final plot object
# =========================================================================================
rData_SR = rhDict["Data-SR-Inclusive"]
rEWKGenuineB_SR = rhDict["EWK-SR-Inclusive-EWKGenuineB"]
rBkgSum_SR = rhDict["FakeB-VR-Inclusive"].Clone("BkgSum-SR-Inclusive")
rBkgSum_SR.Reset()
if opts.inclusiveOnly:
bin = "Inclusive"
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
binHisto_VR = rhDict["FakeB-VR-%s" % (bin)]
VRtoSR_TF = manager.GetTransferFactor(bin)
Print(
"Applying TF = %s%0.6f%s to VR shape" %
(ShellStyles.NoteStyle(), VRtoSR_TF, ShellStyles.NormalStyle()),
True)
binHisto_VR.Scale(VRtoSR_TF)
# Add the normalised histogram to the final Inclusive SR (predicted) histo
rBkgSum_SR.Add(binHisto_VR, +1)
else:
# For-loop: All bins
for i, bin in enumerate(binLabels, 1):
if bin == "Inclusive":
continue
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
binHisto_VR = rhDict["FakeB-VR-%s" % (bin)]
VRtoSR_TF = manager.GetTransferFactor(bin)
Print(
"Applying TF = %s%0.6f%s to VR shape" %
(ShellStyles.NoteStyle(), VRtoSR_TF,
ShellStyles.NormalStyle()), i == 1)
binHisto_VR.Scale(VRtoSR_TF)
# Add the normalised histogram to the final Inclusive SR (predicted) histo
rBkgSum_SR.Add(binHisto_VR, +1)
#Print("Got Verification Region (VR) shape %s%s%s" % (ShellStyles.NoteStyle(), rFakeB_VR.GetName(), ShellStyles.NormalStyle()), True)
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
#VRtoSR_TF = manager.GetTransferFactor("Inclusive")
#Print("Applying TF = %s%0.6f%s to VR shape" % (ShellStyles.NoteStyle(), VRtoSR_TF, ShellStyles.NormalStyle()), True)
#rBkgSum_SR.Scale(VRtoSR_TF)
# Plot histograms
if opts.altPlot:
# Add the SR EWK Genuine-b to the SR FakeB ( BkgSum = [FakeB] + [GenuineB-MC] = [VR * (CR1/CR2)] + [GenuineB-MC] )
rBkgSum_SR.Add(rEWKGenuineB_SR, +1)
# Change style
styles.getGenuineBStyle().apply(rBkgSum_SR)
# Remove unsupported settings of kwargs
_kwargs["stackMCHistograms"] = False
_kwargs["addLuminosityText"] = False
# Create the plot
p = plots.ComparisonManyPlot(rData_SR, [rBkgSum_SR], saveFormats=[])
# Set draw / legend style
p.histoMgr.setHistoDrawStyle("Data-SR-Inclusive", "P")
p.histoMgr.setHistoLegendStyle("Data-SR-Inclusive", "LP")
p.histoMgr.setHistoDrawStyle("BkgSum-SR-Inclusive", "HIST")
p.histoMgr.setHistoLegendStyle("BkgSum-SR-Inclusive", "F")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Data-SR": "Data",
"BkgSum-SR": "Fake-b + Gen-b",
})
else:
# Create empty histogram stack list
myStackList = []
# Signal
p2 = plots.DataMCPlot(datasetsMgr,
"ForTestQGLR/QGLR_SR/QGLR_SRInclusive",
saveFormats=[])
hSignal_800 = p2.histoMgr.getHisto(
'ChargedHiggs_HplusTB_HplusToTB_M_800').getRootHisto()
hhSignal_800 = histograms.Histo(
hSignal_800, 'ChargedHiggs_HplusTB_HplusToTB_M_800',
"H^{+} m_{H^+}=800 GeV")
hhSignal_800.setIsDataMC(isData=False, isMC=True)
myStackList.append(hhSignal_800)
hSignal_250 = p2.histoMgr.getHisto(
'ChargedHiggs_HplusTB_HplusToTB_M_250').getRootHisto()
hhSignal_250 = histograms.Histo(
hSignal_250, 'ChargedHiggs_HplusTB_HplusToTB_M_250',
"H^{+} m_{H^+}=250 GeV"
) #plots._legendLabels['ChargedHiggs_HplusTB_HplusToTB_M_250'])
hhSignal_250.setIsDataMC(isData=False, isMC=True)
#myStackList.append(hhSignal_250)
hSignal_500 = p2.histoMgr.getHisto(
'ChargedHiggs_HplusTB_HplusToTB_M_500').getRootHisto()
hhSignal_500 = histograms.Histo(
hSignal_500, 'ChargedHiggs_HplusTB_HplusToTB_M_500',
"H^{+} m_{H^+}=500 GeV"
) #plots._legendLabels['ChargedHiggs_HplusTB_HplusToTB_M_500'])
hhSignal_500.setIsDataMC(isData=False, isMC=True)
#myStackList.append(hhSignal_500)
hSignal_1000 = p2.histoMgr.getHisto(
'ChargedHiggs_HplusTB_HplusToTB_M_1000').getRootHisto()
hhSignal_1000 = histograms.Histo(
hSignal_1000, 'ChargedHiggs_HplusTB_HplusToTB_M_1000',
"H^{+} m_{H^+}=1000 GeV"
) #plots._legendLabels['ChargedHiggs_HplusTB_HplusToTB_M_500'])
hhSignal_1000.setIsDataMC(isData=False, isMC=True)
#myStackList.append(hhSignal_1000)
# Add the FakeB data-driven background to the histogram list
hFakeB = histograms.Histo(rBkgSum_SR, "FakeB", "Fake-b")
hFakeB.setIsDataMC(isData=False, isMC=True)
myStackList.append(hFakeB)
# Add the EWKGenuineB MC background to the histogram list
hGenuineB = histograms.Histo(rEWKGenuineB_SR, "GenuineB",
"EWK Genuine-b")
hGenuineB.setIsDataMC(isData=False, isMC=True)
myStackList.append(hGenuineB)
# Add the collision datato the histogram list
hData = histograms.Histo(rData_SR, "Data", "Data")
hData.setIsDataMC(isData=True, isMC=False)
myStackList.insert(0, hData)
p = plots.DataMCPlot2(myStackList, saveFormats=[])
p.setLuminosity(opts.intLumi)
p.setDefaultStyles()
# Draw the plot and save it
hName = "test"
plots.drawPlot(p, hName, **_kwargs)
SavePlot(p,
hName,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png", ".pdf"])
#==========================================================================================
# Calculate Cut-Flow Efficiency
#==========================================================================================
kwargs = {
"rebinX": 1,
"xlabel": "QGLR",
"ylabel": "Significance / %.02f ",
"opts": {
"ymin": 0.0,
"ymaxfactor": 1.3
},
"createLegend": {
"x1": 0.55,
"y1": 0.70,
"x2": 0.92,
"y2": 0.92
},
# "cutBox" : {"cutValue": 0.0, "fillColor" : 16, "box": False, "line": False, "greaterThan": True},
}
efficiencyList = []
xValues = []
yValues_250 = []
yValues_500 = []
yValues_800 = []
yValues_1000 = []
yValues_Bkg = []
nBins = hSignal_250.GetNbinsX() + 1
hBkg = p.histoMgr.getHisto(
"ChargedHiggs_HplusTB_HplusToTB_M_800").getRootHisto().Clone("Bkg")
hBkg.Reset()
# Bkg: FakeB + Genuine B
hBkg.Add(hFakeB.getRootHisto(), +1)
hBkg.Add(hGenuineB.getRootHisto(), +1)
for i in range(0, nBins):
# Cut value
cut = hSignal_250.GetBinCenter(i)
passed_250 = hSignal_250.Integral(i, hSignal_250.GetXaxis().GetNbins())
passed_500 = hSignal_500.Integral(i, hSignal_500.GetXaxis().GetNbins())
passed_800 = hSignal_800.Integral(i, hSignal_800.GetXaxis().GetNbins())
passed_1000 = hSignal_1000.Integral(i,
hSignal_1000.GetXaxis().GetNbins())
passed_Bkg = hBkg.Integral(i, hBkg.GetXaxis().GetNbins())
total_250 = hSignal_250.Integral()
total_500 = hSignal_500.Integral()
total_800 = hSignal_800.Integral()
total_1000 = hSignal_1000.Integral()
total_Bkg = hBkg.Integral()
eff_250 = float(passed_250) / total_250
eff_500 = float(passed_500) / total_500
eff_800 = float(passed_800) / total_800
eff_1000 = float(passed_1000) / total_1000
eff_Bkg = float(passed_Bkg) / total_Bkg
xValues.append(cut)
yValues_250.append(eff_250)
yValues_500.append(eff_500)
yValues_800.append(eff_800)
yValues_1000.append(eff_1000)
yValues_Bkg.append(eff_Bkg)
# Create the Efficiency Plot
tGraph_250 = ROOT.TGraph(len(xValues), array.array("d", xValues),
array.array("d", yValues_250))
tGraph_500 = ROOT.TGraph(len(xValues), array.array("d", xValues),
array.array("d", yValues_500))
tGraph_800 = ROOT.TGraph(len(xValues), array.array("d", xValues),
array.array("d", yValues_800))
tGraph_1000 = ROOT.TGraph(len(xValues), array.array("d", xValues),
array.array("d", yValues_1000))
tGraph_Bkg = ROOT.TGraph(len(xValues), array.array("d", xValues),
array.array("d", yValues_Bkg))
styles.getSignalStyleHToTB_M("200").apply(tGraph_250)
styles.getSignalStyleHToTB_M("500").apply(tGraph_500)
styles.getSignalStyleHToTB_M("800").apply(tGraph_800)
styles.getSignalStyleHToTB_M("1000").apply(tGraph_1000)
styles.getQCDLineStyle().apply(tGraph_Bkg)
drawStyle = "CPE"
effGraph_250 = histograms.HistoGraph(tGraph_250,
"H^{+} m_{H^{+}} = 250 GeV", "lp",
drawStyle)
effGraph_500 = histograms.HistoGraph(tGraph_500,
"H^{+} m_{H^{+}} = 500 GeV", "lp",
drawStyle)
effGraph_800 = histograms.HistoGraph(tGraph_800,
"H^{+} m_{H^{+}} = 800 GeV", "lp",
drawStyle)
effGraph_1000 = histograms.HistoGraph(tGraph_1000,
"H^{+} m_{H^{+}} = 1000 GeV", "lp",
drawStyle)
effGraph_Bkg = histograms.HistoGraph(tGraph_Bkg, "Bkg", "lp", drawStyle)
efficiencyList.append(effGraph_250)
efficiencyList.append(effGraph_500)
efficiencyList.append(effGraph_800)
efficiencyList.append(effGraph_1000)
efficiencyList.append(effGraph_Bkg)
# Efficiency plot
pE = plots.PlotBase(efficiencyList, saveFormats=["pdf"])
pE.createFrame("QGLR_Efficiency")
pE.setEnergy("13")
pE.getFrame().GetYaxis().SetLabelSize(18)
pE.getFrame().GetXaxis().SetLabelSize(20)
pE.getFrame().GetYaxis().SetTitle("Efficiency / 0.01")
pE.getFrame().GetXaxis().SetTitle("QGLR Cut")
# Add Standard Texts to plot
histograms.addStandardTexts()
# Customise Legend
moveLegend = {"dx": -0.50, "dy": -0.5, "dh": -0.1}
pE.setLegend(histograms.moveLegend(histograms.createLegend(),
**moveLegend))
pE.draw()
# plots.drawPlot(pE, "QGLR_Efficiency", **kwargs)
SavePlot(pE,
"QGLR_Efficiency",
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png", ".pdf"])
#==========================================================================================
# Calculate Significance
#==========================================================================================
SignalName = "ChargedHiggs_HplusTB_HplusToTB_M_800"
hSignif_250 = p.histoMgr.getHisto(SignalName).getRootHisto().Clone(
SignalName)
hSignif_500 = p.histoMgr.getHisto(SignalName).getRootHisto().Clone(
SignalName)
hSignif_800 = p.histoMgr.getHisto(SignalName).getRootHisto().Clone(
SignalName)
hSignif_1000 = p.histoMgr.getHisto(SignalName).getRootHisto().Clone(
SignalName)
hSignif_250.Reset()
hSignif_500.Reset()
hSignif_800.Reset()
hSignif_1000.Reset()
hBkg = p.histoMgr.getHisto(SignalName).getRootHisto().Clone("Bkg")
hBkg.Reset()
# Bkg: FakeB + Genuine B
hBkg.Add(hFakeB.getRootHisto(), +1)
hBkg.Add(hGenuineB.getRootHisto(), +1)
nBins = hSignif_250.GetNbinsX() + 1
# For-loop: All histo bins
for i in range(1, nBins + 1):
sigmaB = ROOT.Double(0)
b = hBkg.IntegralAndError(i, nBins, sigmaB)
s_250 = hSignal_250.Integral(i, nBins)
s_500 = hSignal_500.Integral(i, nBins)
s_800 = hSignal_800.Integral(i, nBins)
s_1000 = hSignal_1000.Integral(i, nBins)
# Calculate significance
signif_250 = stat.significance(s_250, b, sigmaB,
option="Simple") #Asimov")
signif_500 = stat.significance(s_500, b, sigmaB,
option="Simple") #Asimov")
signif_800 = stat.significance(s_800, b, sigmaB,
option="Simple") #Asimov")
signif_1000 = stat.significance(s_1000, b, sigmaB,
option="Simple") #"Asimov")
# Set signif for this bin
hSignif_250.SetBinContent(i, signif_250)
hSignif_500.SetBinContent(i, signif_500)
hSignif_800.SetBinContent(i, signif_800)
hSignif_1000.SetBinContent(i, signif_1000)
# Apply style
s_250 = styles.getSignalStyleHToTB_M("200")
s_250.apply(hSignif_250)
s_500 = styles.getSignalStyleHToTB_M("500")
s_500.apply(hSignif_500)
s_800 = styles.getSignalStyleHToTB_M("800")
s_800.apply(hSignif_800)
s_1000 = styles.getSignalStyleHToTB_M("1000")
s_1000.apply(hSignif_1000)
hList = []
hList.append(hSignif_250)
hList.append(hSignif_500)
hList.append(hSignif_800)
hList.append(hSignif_1000)
hSignif_250.SetName("H^{+} m_{H^{+}} = 250 GeV")
hSignif_500.SetName("H^{+} m_{H^{+}} = 500 GeV")
hSignif_800.SetName("H^{+} m_{H^{+}} = 800 GeV")
hSignif_1000.SetName("H^{+} m_{H^{+}} = 1000 GeV")
pS = plots.PlotBase(hList, saveFormats=["png", "pdf"])
pS.setLuminosity(opts.intLumi)
# Drawing style
pS.histoMgr.setHistoDrawStyleAll("HIST")
pS.histoMgr.setHistoLegendStyleAll("L")
pS.histoMgr.forEachHisto(lambda h: h.getRootHisto().SetMarkerSize(1.0))
pS.histoMgr.forEachHisto(
lambda h: h.getRootHisto().SetLineStyle(ROOT.kSolid))
pS.histoMgr.forEachHisto(
lambda h: h.getRootHisto().SetMarkerStyle(ROOT.kFullCircle))
# Draw the plot
name = "QGLR_Signif" + "GE"
plots.drawPlot(pS, name, **kwargs)
SavePlot(pS,
name,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png", ".pdf"])
#=========================================================================================
# Calculate the Transfer Factor (TF) and save to file
#=========================================================================================
Verbose("Write the normalisation factors to a python file", True)
fileName = os.path.join(
opts.mcrab, "FakeBTransferFactors%s.py" % (getModuleInfoString(opts)))
manager.writeNormFactorFile(fileName, opts)
return
def PlotHistosAndCalculateTF(runRange, datasetsMgr, histoList, binLabels,
opts):
# Get the histogram customisations (keyword arguments)
_kwargs = GetHistoKwargs(histoList[0])
# Get the root histos for all datasets and Control Regions (CRs)
regions = ["SR", "VR", "CRone", "CRtwo", "CRthree", "CRfour"]
rhDict = GetRootHistos(datasetsMgr, histoList, regions, binLabels)
#=========================================================================================
# Calculate the Transfer Factor (TF) and save to file
#=========================================================================================
manager = FakeBNormalization.FakeBNormalizationManager(binLabels,
opts.mcrab,
opts.optMode,
verbose=False)
if opts.inclusiveOnly:
binLabel = "Inclusive"
manager.CalculateTransferFactor("Inclusive",
rhDict["FakeB-CRone-Inclusive"],
rhDict["FakeB-CRtwo-Inclusive"],
rhDict["FakeB-CRthree-Inclusive"],
rhDict["FakeB-CRfour-Inclusive"])
else:
for bin in binLabels:
manager.CalculateTransferFactor(bin,
rhDict["FakeB-CRone-%s" % bin],
rhDict["FakeB-CRtwo-%s" % bin],
rhDict["FakeB-CRthree-%s" % bin],
rhDict["FakeB-CRfour-%s" % bin])
# Get unique a style for each region
for k in rhDict:
dataset = k.split("-")[0]
region = k.split("-")[1]
styles.getABCDStyle(region).apply(rhDict[k])
if "FakeB" in k:
styles.getFakeBStyle().apply(rhDict[k])
# sr.apply(rhDict[k])
# =========================================================================================
# Create the final plot object
# =========================================================================================
rData_SR = rhDict["Data-SR-Inclusive"]
rEWKGenuineB_SR = rhDict["EWK-SR-Inclusive-EWKGenuineB"]
rBkgSum_SR = rhDict["FakeB-VR-Inclusive"].Clone("BkgSum-SR-Inclusive")
rBkgSum_SR.Reset()
if opts.inclusiveOnly:
bin = "Inclusive"
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
binHisto_VR = rhDict["FakeB-VR-%s" % (bin)]
VRtoSR_TF = manager.GetTransferFactor(bin)
Verbose(
"Applying TF = %s%0.6f%s to VR shape" %
(ShellStyles.NoteStyle(), VRtoSR_TF, ShellStyles.NormalStyle()),
True)
binHisto_VR.Scale(VRtoSR_TF)
# Add the normalised histogram to the final Inclusive SR (predicted) histo
rBkgSum_SR.Add(binHisto_VR, +1)
else:
# For-loop: All bins
for i, bin in enumerate(binLabels, 1):
if bin == "Inclusive":
continue
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
binHisto_VR = rhDict["FakeB-VR-%s" % (bin)]
VRtoSR_TF = manager.GetTransferFactor(bin)
Verbose(
"Applying TF = %s%0.6f%s to VR shape" %
(ShellStyles.NoteStyle(), VRtoSR_TF,
ShellStyles.NormalStyle()), i == 1)
binHisto_VR.Scale(VRtoSR_TF)
# Add the normalised histogram to the final Inclusive SR (predicted) histo
rBkgSum_SR.Add(binHisto_VR, +1)
# Plot histograms
if opts.altPlot:
# Add the SR EWK Genuine-b to the SR FakeB ( BkgSum = [FakeB] + [GenuineB-MC] = [VR * (CR1/CR2)] + [GenuineB-MC] )
rBkgSum_SR.Add(rEWKGenuineB_SR, +1)
# Change style
styles.getGenuineBStyle().apply(rBkgSum_SR)
# Remove unsupported settings of kwargs
_kwargs["stackMCHistograms"] = False
_kwargs["addLuminosityText"] = False
# Create the plot
p = plots.ComparisonManyPlot(rData_SR, [rBkgSum_SR], saveFormats=[])
# Set draw / legend style
p.histoMgr.setHistoDrawStyle("Data-SR-Inclusive", "P")
p.histoMgr.setHistoLegendStyle("Data-SR-Inclusive", "LP")
p.histoMgr.setHistoDrawStyle("BkgSum-SR-Inclusive", "HIST")
p.histoMgr.setHistoLegendStyle("BkgSum-SR-Inclusive", "F")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Data-SR": "Data",
"BkgSum-SR": "Fake-b + Gen-b",
})
else:
# Create empty histogram stack list
myStackList = []
# Add the FakeB data-driven background to the histogram list
hFakeB = histograms.Histo(rBkgSum_SR, "FakeB", "Fake-b")
hFakeB.setIsDataMC(isData=False, isMC=True)
myStackList.append(hFakeB)
# Add the EWKGenuineB MC background to the histogram list
hGenuineB = histograms.Histo(rEWKGenuineB_SR, "GenuineB",
"EWK Genuine-b")
hGenuineB.setIsDataMC(isData=False, isMC=True)
myStackList.append(hGenuineB)
# Add the collision datato the histogram list
hData = histograms.Histo(rData_SR, "Data", "Data")
hData.setIsDataMC(isData=True, isMC=False)
myStackList.insert(0, hData)
p = plots.DataMCPlot2(myStackList, saveFormats=[])
p.setLuminosity(opts.intLumi)
p.setDefaultStyles()
# Draw the plot and save it
hName = opts.histoKey
plots.drawPlot(p, hName, **_kwargs)
SavePlot(p,
hName,
os.path.join(opts.saveDir, opts.optMode),
saveFormats=[".png"])
#=========================================================================================
# Calculate the Transfer Factor (TF) and save to file
#=========================================================================================
Verbose("Write the normalisation factors to a python file", True)
fileName = os.path.join(opts.mcrab,
"FakeBTransferFactors_%s.py" % (runRange))
manager.writeTransferFactorsToFile(fileName, opts)
return
def PlotHistosAndCalculateTF(datasetsMgr, histoList, binLabels, opts):
# Get the histogram customisations (keyword arguments)
_kwargs = GetHistoKwargs(histoList[0])
# Get the root histos for all datasets and Control Regions (CRs)
regions = ["SR", "VR", "CRone", "CRtwo"]
rhDict = GetRootHistos(datasetsMgr, histoList, regions, binLabels)
#=========================================================================================
# Calculate the Transfer Factor (TF) and save to file
#=========================================================================================
manager = FakeBNormalization.FakeBNormalizationManager(binLabels, opts.mcrab, opts.optMode, verbose=False)
if opts.inclusiveOnly:
#manager.CalculateTransferFactor(binLabels[0], rhDict["CRone-FakeB"], rhDict["CRtwo-FakeB"])
binLabel = "Inclusive"
manager.CalculateTransferFactor("Inclusive", rhDict["FakeB-CRone-Inclusive"], rhDict["FakeB-CRtwo-Inclusive"])
else:
for bin in binLabels:
manager.CalculateTransferFactor(bin, rhDict["FakeB-CRone-%s" % bin], rhDict["FakeB-CRtwo-%s" % bin])
# Get unique a style for each region
for k in rhDict:
dataset = k.split("-")[0]
region = k.split("-")[1]
styles.getABCDStyle(region).apply(rhDict[k])
if "FakeB" in k:
styles.getFakeBStyle().apply(rhDict[k])
# sr.apply(rhDict[k])
# =========================================================================================
# Create the final plot object
# =========================================================================================
rData_SR = rhDict["Data-SR-Inclusive"]
rEWKGenuineB_SR = rhDict["EWK-SR-Inclusive-EWKGenuineB"]
rBkgSum_SR = rhDict["FakeB-VR-Inclusive"].Clone("BkgSum-SR-Inclusive")
rBkgSum_SR.Reset()
if opts.inclusiveOnly:
bin = "Inclusive"
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
binHisto_VR = rhDict["FakeB-VR-%s" % (bin)]
VRtoSR_TF = manager.GetTransferFactor(bin)
Print("Applying TF = %s%0.6f%s to VR shape" % (ShellStyles.NoteStyle(), VRtoSR_TF, ShellStyles.NormalStyle()), True)
binHisto_VR.Scale(VRtoSR_TF)
# Add the normalised histogram to the final Inclusive SR (predicted) histo
rBkgSum_SR.Add(binHisto_VR, +1)
else:
# For-loop: All bins
for i, bin in enumerate(binLabels, 1):
if bin == "Inclusive":
continue
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
binHisto_VR = rhDict["FakeB-VR-%s" % (bin)]
VRtoSR_TF = manager.GetTransferFactor(bin)
Print("Applying TF = %s%0.6f%s to VR shape" % (ShellStyles.NoteStyle(), VRtoSR_TF, ShellStyles.NormalStyle()), i==1)
binHisto_VR.Scale(VRtoSR_TF)
# Add the normalised histogram to the final Inclusive SR (predicted) histo
rBkgSum_SR.Add(binHisto_VR, +1)
#Print("Got Verification Region (VR) shape %s%s%s" % (ShellStyles.NoteStyle(), rFakeB_VR.GetName(), ShellStyles.NormalStyle()), True)
# Normalise the VR histogram with the Transfer Factor ( BkgSum = VR * (CR1/CR2) )
#VRtoSR_TF = manager.GetTransferFactor("Inclusive")
#Print("Applying TF = %s%0.6f%s to VR shape" % (ShellStyles.NoteStyle(), VRtoSR_TF, ShellStyles.NormalStyle()), True)
#rBkgSum_SR.Scale(VRtoSR_TF)
# Plot histograms
if opts.altPlot:
# Add the SR EWK Genuine-b to the SR FakeB ( BkgSum = [FakeB] + [GenuineB-MC] = [VR * (CR1/CR2)] + [GenuineB-MC] )
rBkgSum_SR.Add(rEWKGenuineB_SR, +1)
# Change style
styles.getGenuineBStyle().apply(rBkgSum_SR)
# Remove unsupported settings of kwargs
_kwargs["stackMCHistograms"] = False
_kwargs["addLuminosityText"] = False
# Create the plot
p = plots.ComparisonManyPlot(rData_SR, [rBkgSum_SR], saveFormats=[])
# Set draw / legend style
p.histoMgr.setHistoDrawStyle("Data-SR-Inclusive", "P")
p.histoMgr.setHistoLegendStyle("Data-SR-Inclusive" , "LP")
p.histoMgr.setHistoDrawStyle("BkgSum-SR-Inclusive", "HIST")
p.histoMgr.setHistoLegendStyle("BkgSum-SR-Inclusive" , "F")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Data-SR" : "Data",
"BkgSum-SR" : "Fake-b + Gen-b",
})
else:
# Create empty histogram stack list
myStackList = []
# Signal
p2 = plots.DataMCPlot(datasetsMgr, "ForTestQGLR/QGLR_SR/QGLR_SRInclusive", saveFormats=[])
hSignal_800 = p2.histoMgr.getHisto('ChargedHiggs_HplusTB_HplusToTB_M_800').getRootHisto()
hhSignal_800= histograms.Histo(hSignal_800, 'ChargedHiggs_HplusTB_HplusToTB_M_800', "H^{+} m_{H^+}=800 GeV")
hhSignal_800.setIsDataMC(isData=False, isMC=True)
myStackList.append(hhSignal_800)
hSignal_250 = p2.histoMgr.getHisto('ChargedHiggs_HplusTB_HplusToTB_M_250').getRootHisto()
hhSignal_250= histograms.Histo(hSignal_250, 'ChargedHiggs_HplusTB_HplusToTB_M_250', "H^{+} m_{H^+}=250 GeV")#plots._legendLabels['ChargedHiggs_HplusTB_HplusToTB_M_250'])
hhSignal_250.setIsDataMC(isData=False, isMC=True)
#myStackList.append(hhSignal_250)
hSignal_500 = p2.histoMgr.getHisto('ChargedHiggs_HplusTB_HplusToTB_M_500').getRootHisto()
hhSignal_500= histograms.Histo(hSignal_500, 'ChargedHiggs_HplusTB_HplusToTB_M_500', "H^{+} m_{H^+}=500 GeV")#plots._legendLabels['ChargedHiggs_HplusTB_HplusToTB_M_500'])
hhSignal_500.setIsDataMC(isData=False, isMC=True)
#myStackList.append(hhSignal_500)
hSignal_1000 = p2.histoMgr.getHisto('ChargedHiggs_HplusTB_HplusToTB_M_1000').getRootHisto()
hhSignal_1000= histograms.Histo(hSignal_1000, 'ChargedHiggs_HplusTB_HplusToTB_M_1000', "H^{+} m_{H^+}=1000 GeV")#plots._legendLabels['ChargedHiggs_HplusTB_HplusToTB_M_500'])
hhSignal_1000.setIsDataMC(isData=False, isMC=True)
#myStackList.append(hhSignal_1000)
# Add the FakeB data-driven background to the histogram list
hFakeB = histograms.Histo(rBkgSum_SR, "FakeB", "Fake-b")
hFakeB.setIsDataMC(isData=False, isMC=True)
myStackList.append(hFakeB)
# Add the EWKGenuineB MC background to the histogram list
hGenuineB = histograms.Histo(rEWKGenuineB_SR, "GenuineB", "EWK Genuine-b")
hGenuineB.setIsDataMC(isData=False, isMC=True)
myStackList.append(hGenuineB)
# Add the collision datato the histogram list
hData = histograms.Histo(rData_SR, "Data", "Data")
hData.setIsDataMC(isData=True, isMC=False)
myStackList.insert(0, hData)
p = plots.DataMCPlot2( myStackList, saveFormats=[])
p.setLuminosity(opts.intLumi)
p.setDefaultStyles()
# Draw the plot and save it
hName = "test"
plots.drawPlot(p, hName, **_kwargs)
SavePlot(p, hName, os.path.join(opts.saveDir, opts.optMode), saveFormats = [".png", ".pdf"])
#==========================================================================================
# Calculate Cut-Flow Efficiency
#==========================================================================================
kwargs = {
"rebinX" : 1,
"xlabel" : "QGLR",
"ylabel" : "Significance / %.02f ",
"opts" : {"ymin": 0.0, "ymaxfactor": 1.3},
"createLegend": {"x1": 0.55, "y1": 0.70, "x2": 0.92, "y2": 0.92},
# "cutBox" : {"cutValue": 0.0, "fillColor" : 16, "box": False, "line": False, "greaterThan": True},
}
efficiencyList = []
xValues = []
yValues_250 = []
yValues_500 = []
yValues_800 = []
yValues_1000 = []
yValues_Bkg = []
nBins = hSignal_250.GetNbinsX()+1
hBkg = p.histoMgr.getHisto("ChargedHiggs_HplusTB_HplusToTB_M_800").getRootHisto().Clone("Bkg")
hBkg.Reset()
# Bkg: FakeB + Genuine B
hBkg.Add(hFakeB.getRootHisto(), +1)
hBkg.Add(hGenuineB.getRootHisto(), +1)
for i in range (0, nBins):
# Cut value
cut = hSignal_250.GetBinCenter(i)
passed_250 = hSignal_250.Integral(i, hSignal_250.GetXaxis().GetNbins())
passed_500 = hSignal_500.Integral(i, hSignal_500.GetXaxis().GetNbins())
passed_800 = hSignal_800.Integral(i, hSignal_800.GetXaxis().GetNbins())
passed_1000 = hSignal_1000.Integral(i, hSignal_1000.GetXaxis().GetNbins())
passed_Bkg = hBkg.Integral(i, hBkg.GetXaxis().GetNbins())
total_250 = hSignal_250.Integral()
total_500 = hSignal_500.Integral()
total_800 = hSignal_800.Integral()
total_1000 = hSignal_1000.Integral()
total_Bkg = hBkg.Integral()
eff_250 = float(passed_250)/total_250
eff_500 = float(passed_500)/total_500
eff_800 = float(passed_800)/total_800
eff_1000 = float(passed_1000)/total_1000
eff_Bkg = float(passed_Bkg)/total_Bkg
xValues.append(cut)
yValues_250.append(eff_250)
yValues_500.append(eff_500)
yValues_800.append(eff_800)
yValues_1000.append(eff_1000)
yValues_Bkg.append(eff_Bkg)
# Create the Efficiency Plot
tGraph_250 = ROOT.TGraph(len(xValues), array.array("d", xValues), array.array("d", yValues_250))
tGraph_500 = ROOT.TGraph(len(xValues), array.array("d", xValues), array.array("d", yValues_500))
tGraph_800 = ROOT.TGraph(len(xValues), array.array("d", xValues), array.array("d", yValues_800))
tGraph_1000 = ROOT.TGraph(len(xValues), array.array("d", xValues), array.array("d", yValues_1000))
tGraph_Bkg = ROOT.TGraph(len(xValues), array.array("d", xValues), array.array("d", yValues_Bkg))
styles.getSignalStyleHToTB_M("200").apply(tGraph_250)
styles.getSignalStyleHToTB_M("500").apply(tGraph_500)
styles.getSignalStyleHToTB_M("800").apply(tGraph_800)
styles.getSignalStyleHToTB_M("1000").apply(tGraph_1000)
styles.getQCDLineStyle().apply(tGraph_Bkg)
drawStyle = "CPE"
effGraph_250 = histograms.HistoGraph(tGraph_250, "H^{+} m_{H^{+}} = 250 GeV", "lp", drawStyle)
effGraph_500 = histograms.HistoGraph(tGraph_500, "H^{+} m_{H^{+}} = 500 GeV", "lp", drawStyle)
effGraph_800 = histograms.HistoGraph(tGraph_800, "H^{+} m_{H^{+}} = 800 GeV", "lp", drawStyle)
effGraph_1000 = histograms.HistoGraph(tGraph_1000, "H^{+} m_{H^{+}} = 1000 GeV", "lp", drawStyle)
effGraph_Bkg = histograms.HistoGraph(tGraph_Bkg, "Bkg", "lp", drawStyle)
efficiencyList.append(effGraph_250)
efficiencyList.append(effGraph_500)
efficiencyList.append(effGraph_800)
efficiencyList.append(effGraph_1000)
efficiencyList.append(effGraph_Bkg)
# Efficiency plot
pE = plots.PlotBase(efficiencyList, saveFormats=["pdf"])
pE.createFrame("QGLR_Efficiency")
pE.setEnergy("13")
pE.getFrame().GetYaxis().SetLabelSize(18)
pE.getFrame().GetXaxis().SetLabelSize(20)
pE.getFrame().GetYaxis().SetTitle("Efficiency / 0.01")
pE.getFrame().GetXaxis().SetTitle("QGLR Cut")
# Add Standard Texts to plot
histograms.addStandardTexts()
# Customise Legend
moveLegend = {"dx": -0.50, "dy": -0.5, "dh": -0.1}
pE.setLegend(histograms.moveLegend(histograms.createLegend(), **moveLegend))
pE.draw()
# plots.drawPlot(pE, "QGLR_Efficiency", **kwargs)
SavePlot(pE, "QGLR_Efficiency", os.path.join(opts.saveDir, opts.optMode), saveFormats=[".png", ".pdf"] )
#==========================================================================================
# Calculate Significance
#==========================================================================================
SignalName = "ChargedHiggs_HplusTB_HplusToTB_M_800"
hSignif_250 = p.histoMgr.getHisto(SignalName).getRootHisto().Clone(SignalName)
hSignif_500 = p.histoMgr.getHisto(SignalName).getRootHisto().Clone(SignalName)
hSignif_800 = p.histoMgr.getHisto(SignalName).getRootHisto().Clone(SignalName)
hSignif_1000 = p.histoMgr.getHisto(SignalName).getRootHisto().Clone(SignalName)
hSignif_250.Reset()
hSignif_500.Reset()
hSignif_800.Reset()
hSignif_1000.Reset()
hBkg = p.histoMgr.getHisto(SignalName).getRootHisto().Clone("Bkg")
hBkg.Reset()
# Bkg: FakeB + Genuine B
hBkg.Add(hFakeB.getRootHisto(), +1)
hBkg.Add(hGenuineB.getRootHisto(), +1)
nBins = hSignif_250.GetNbinsX()+1
# For-loop: All histo bins
for i in range (1, nBins+1):
sigmaB = ROOT.Double(0)
b = hBkg.IntegralAndError(i, nBins, sigmaB)
s_250 = hSignal_250.Integral(i, nBins)
s_500 = hSignal_500.Integral(i, nBins)
s_800 = hSignal_800.Integral(i, nBins)
s_1000 = hSignal_1000.Integral(i, nBins)
# Calculate significance
signif_250 = stat.significance(s_250, b, sigmaB, option="Simple")#Asimov")
signif_500 = stat.significance(s_500, b, sigmaB, option="Simple")#Asimov")
signif_800 = stat.significance(s_800, b, sigmaB, option="Simple")#Asimov")
signif_1000 = stat.significance(s_1000, b, sigmaB, option="Simple")#"Asimov")
# Set signif for this bin
hSignif_250.SetBinContent(i, signif_250)
hSignif_500.SetBinContent(i, signif_500)
hSignif_800.SetBinContent(i, signif_800)
hSignif_1000.SetBinContent(i, signif_1000)
# Apply style
s_250 = styles.getSignalStyleHToTB_M("200")
s_250.apply(hSignif_250)
s_500 = styles.getSignalStyleHToTB_M("500")
s_500.apply(hSignif_500)
s_800 = styles.getSignalStyleHToTB_M("800")
s_800.apply(hSignif_800)
s_1000 = styles.getSignalStyleHToTB_M("1000")
s_1000.apply(hSignif_1000)
hList = []
hList.append(hSignif_250)
hList.append(hSignif_500)
hList.append(hSignif_800)
hList.append(hSignif_1000)
hSignif_250.SetName("H^{+} m_{H^{+}} = 250 GeV")
hSignif_500.SetName("H^{+} m_{H^{+}} = 500 GeV")
hSignif_800.SetName("H^{+} m_{H^{+}} = 800 GeV")
hSignif_1000.SetName("H^{+} m_{H^{+}} = 1000 GeV")
pS = plots.PlotBase(hList, saveFormats=["png", "pdf"])
pS.setLuminosity(opts.intLumi)
# Drawing style
pS.histoMgr.setHistoDrawStyleAll("HIST")
pS.histoMgr.setHistoLegendStyleAll("L")
pS.histoMgr.forEachHisto(lambda h: h.getRootHisto().SetMarkerSize(1.0))
pS.histoMgr.forEachHisto(lambda h: h.getRootHisto().SetLineStyle(ROOT.kSolid))
pS.histoMgr.forEachHisto(lambda h: h.getRootHisto().SetMarkerStyle(ROOT.kFullCircle))
# Draw the plot
name = "QGLR_Signif" + "GE"
plots.drawPlot(pS, name, **kwargs)
SavePlot(pS, name, os.path.join(opts.saveDir, opts.optMode), saveFormats=[".png", ".pdf"] )
#=========================================================================================
# Calculate the Transfer Factor (TF) and save to file
#=========================================================================================
Verbose("Write the normalisation factors to a python file", True)
fileName = os.path.join(opts.mcrab, "FakeBTransferFactors%s.py"% ( getModuleInfoString(opts) ) )
manager.writeNormFactorFile(fileName, opts)
return
def PlotTemplates(datasetsMgr, histoName):
Verbose("Plotting EWK Vs QCD unity-normalised histograms")
# FIXME - First pseudo-multicrab had the Fake/Genuine boolean REVERSED
# FIXME - First pseudo-multicrab had the Fake/Genuine boolean REVERSED
# FIXME - First pseudo-multicrab had the Fake/Genuine boolean REVERSED
# FIXME - First pseudo-multicrab had the Fake/Genuine boolean REVERSED
defaultFolder = "ForFakeBMeasurement"
genuineBFolder = "ForFakeBMeasurementEWKFakeB"
fakeBFolder = "ForFakeBMeasurementEWKGenuineB"
# Create comparison plot
p1 = plots.ComparisonPlot(
getHisto(datasetsMgr, "Data", "%s" % histoName, "Baseline"),
getHisto(datasetsMgr, "EWK",
"%s" % histoName.replace(defaultFolder, genuineBFolder),
"Baseline"))
p1.histoMgr.normalizeMCToLuminosity(
datasetsMgr.getDataset("Data").getLuminosity())
p2 = plots.ComparisonPlot(
getHisto(datasetsMgr, "Data", "%s" % histoName, "Inverted"),
getHisto(datasetsMgr, "EWK",
"%s" % histoName.replace(defaultFolder, genuineBFolder),
"Inverted"))
p2.histoMgr.normalizeMCToLuminosity(
datasetsMgr.getDataset("Data").getLuminosity())
p3 = plots.ComparisonPlot(
getHisto(datasetsMgr, "Data", "%s" % histoName, "Baseline"),
getHisto(datasetsMgr, "EWK",
"%s" % histoName.replace(defaultFolder, fakeBFolder),
"Baseline"))
p3.histoMgr.normalizeMCToLuminosity(
datasetsMgr.getDataset("Data").getLuminosity())
p4 = plots.ComparisonPlot(
getHisto(datasetsMgr, "Data", "%s" % histoName, "Inverted"),
getHisto(datasetsMgr, "EWK",
"%s" % histoName.replace(defaultFolder, fakeBFolder),
"Inverted"))
p4.histoMgr.normalizeMCToLuminosity(
datasetsMgr.getDataset("Data").getLuminosity())
# Get EWK histos
EWKGenuineB_baseline = p1.histoMgr.getHisto(
"Baseline-EWK").getRootHisto().Clone("Baseline-EWKGenuineB")
EWKGenuineB_inverted = p2.histoMgr.getHisto(
"Inverted-EWK").getRootHisto().Clone("Inverted-EWKGenuineB")
EWKFakeB_baseline = p3.histoMgr.getHisto(
"Baseline-EWK").getRootHisto().Clone("Baseline-EWKFakeB")
EWKFakeB_inverted = p4.histoMgr.getHisto(
"Inverted-EWK").getRootHisto().Clone("Inverted-EWKFakeB")
# Data histos
Data_baseline = p1.histoMgr.getHisto("Baseline-Data").getRootHisto().Clone(
"Baseline-Data")
Data_inverted = p2.histoMgr.getHisto("Inverted-Data").getRootHisto().Clone(
"Inverted-Data")
# Create FakeB (Data-EWK_GenuineB) histos
FakeB_baseline = p1.histoMgr.getHisto(
"Baseline-Data").getRootHisto().Clone("Baseline-FakeB")
FakeB_inverted = p2.histoMgr.getHisto(
"Inverted-Data").getRootHisto().Clone("Inverted-FakeB")
FakeB_baseline.Add(EWKGenuineB_baseline, -1)
FakeB_inverted.Add(EWKGenuineB_inverted, -1)
# Normalize histograms to unit area
if 1:
Data_baseline.Scale(1.0 / Data_baseline.Integral())
Data_inverted.Scale(1.0 / Data_inverted.Integral())
EWKGenuineB_baseline.Scale(1.0 / EWKGenuineB_baseline.Integral())
EWKGenuineB_inverted.Scale(1.0 / EWKGenuineB_inverted.Integral())
EWKFakeB_baseline.Scale(1.0 / EWKFakeB_baseline.Integral())
EWKFakeB_inverted.Scale(1.0 / EWKFakeB_inverted.Integral())
FakeB_baseline.Scale(1.0 / FakeB_baseline.Integral())
FakeB_inverted.Scale(1.0 / FakeB_inverted.Integral())
# Create the final plot object
compareHistos = [EWKGenuineB_baseline]
# compareHistos = [EWKGenuineB_baseline, EWKGenuineB_inverted, EWKFakeB_inverted, Data_inverted]
# compareHistos = [EWKGenuineB_inverted, EWKFakeB_inverted, Data_inverted]
# compareHistos = [EWKGenuineB_baseline, EWKFakeB_baseline, EWKGenuineB_inverted, EWKFakeB_inverted]
# compareHistos = [FakeB_baseline, EWKGenuineB_baseline, EWKFakeB_baseline, EWKGenuineB_inverted, EWKFakeB_inverted]
p = plots.ComparisonManyPlot(FakeB_inverted, compareHistos, saveFormats=[])
p.setLuminosity(GetLumi(datasetsMgr))
# Apply styles
p.histoMgr.forHisto("Inverted-FakeB", styles.getInvertedLineStyle())
p.histoMgr.forHisto("Baseline-EWKGenuineB", styles.getBaselineLineStyle())
if 0:
p.histoMgr.forHisto("Baseline-FakeB", styles.getInvertedLineStyle())
p.histoMgr.forHisto("Baseline-EWKFakeB", styles.getFakeBStyle())
p.histoMgr.forHisto("Inverted-EWKGenuineB", styles.getGenuineBStyle())
p.histoMgr.forHisto("Inverted-EWKFakeB", styles.getFakeBLineStyle())
p.histoMgr.forHisto("Inverted-Data", styles.getDataStyle())
# Set draw style
p.histoMgr.setHistoDrawStyle("Inverted-FakeB", "HIST")
p.histoMgr.setHistoDrawStyle("Baseline-EWKGenuineB", "HIST")
if 0:
p.histoMgr.setHistoDrawStyle("Baseline-FakeB", "AP")
p.histoMgr.setHistoDrawStyle("Baseline-EWKFakeB", "HIST")
p.histoMgr.setHistoDrawStyle("Inverted-EWKGenuineB", "AP")
p.histoMgr.setHistoDrawStyle("Inverted-EWKFakeB", "HIST")
p.histoMgr.setHistoDrawStyle("Inverted-Data", "AP")
# Set legend style
p.histoMgr.setHistoLegendStyle("Inverted-FakeB", "L")
p.histoMgr.setHistoLegendStyle("Baseline-EWKGenuineB", "L")
if 0:
p.histoMgr.setHistoLegendStyle("Baseline-FakeB", "P")
p.histoMgr.setHistoLegendStyle("Baseline-EWKFakeB", "FL")
p.histoMgr.setHistoLegendStyle("Inverted-EWKGenuineB", "P")
p.histoMgr.setHistoLegendStyle("Inverted-EWKFakeB", "L")
p.histoMgr.setHistoLegendStyle("Inverted-Data", "LP")
# Set legend labels
p.histoMgr.setHistoLegendLabelMany({
"Inverted-FakeB":
"FakeB (Inverted)", # (I)",
#"Inverted-Data" : "Data (I)",
"Baseline-EWKGenuineB":
"EWK (Baseline)", #-GenuineB (B)",
#"Baseline-FakeB" : "FakeB",
#"Baseline-EWKFakeB" : "EWK-FakeB (B)",
#"Inverted-EWKGenuineB": "EWK-GenuineB (I)",
#"Inverted-EWKFakeB" : "EWK-FakeB (I)",
})
# Append analysisType to histogram name
saveName = histoName
# Draw the histograms #alex
plots.drawPlot(p, saveName,
**GetHistoKwargs(histoName)) #the "**" unpacks the kwargs_
# Add text
text = opts.optMode.replace("OptChiSqrCutValue", "#chi^{2} #leq ")
histograms.addText(0.21, 0.85, text)
# Save plot in all formats
saveDir = os.path.join(opts.saveDir, "Test", opts.optMode)
SavePlot(p, saveName, saveDir, saveFormats=[".png"])
return