def interp1Sigma(th1f_nom, th1f_down, th1f_up):
nomE = th1f_nom.Integral()
if nomE == 0:
return [1.000, 1.000]
downE = th1f_down.Integral() / nomE
upE = th1f_up.Integral() / nomE
if options.quadInterpolate != 0:
downE = quadInterpolate(
-1.0,
-1.0 * options.quadInterpolate,
0.0,
1.0 * options.quadInterpolate,
th1f_down.Integral(),
th1f_nom.Integral(),
th1f_up.Integral(),
)
upE = quadInterpolate(
1.0,
-1.0 * options.quadInterpolate,
0.0,
1.0 * options.quadInterpolate,
th1f_down.Integral(),
th1f_nom.Integral(),
th1f_up.Integral(),
)
if upE != upE:
upE = 1.000
if downE != downE:
downE = 1.000
return [downE, upE]
def py_quadInterpolate(C,X1,X2,X3,Y1,Y2,Y3): resL = quadInterpolate(-1*C,X1,X2,X3,Y1,Y2,Y3) resH = quadInterpolate(C,X1,X2,X3,Y1,Y2,Y3) if math.isnan(resL) or math.isinf(resL) or math.isnan(resH) or math.isinf(resL): return " - " if abs(resL - 1) < 0.00001 or abs(resL - 1) > 1: return " - " if abs(resH - 1) < 0.00001 or abs(resH - 1) > 1: return " - " return " %.3f/%.3f "%(resL,resH)
def interp1Sigma(th1f_nom,th1f_down,th1f_up):
nomE = th1f_nom.Integral()
if nomE==0: nomE=float('NaN')
downE = th1f_down.Integral()/nomE
upE = th1f_up.Integral()/nomE
if options.quadInterpolate!=0:
downE = quadInterpolate(-1.,-1.*options.quadInterpolate,0.,1.*options.quadInterpolate,th1f_down.Integral(),th1f_nom.Integral(),th1f_up.Integral())
upE = quadInterpolate(1.,-1.*options.quadInterpolate,0.,1.*options.quadInterpolate,th1f_down.Integral(),th1f_nom.Integral(),th1f_up.Integral())
if upE != upE: upE=1.000
if downE != downE: downE=1.000
return [downE,upE]
def interp1Sigma(th1f_nom,th1f_down,th1f_up): nomE = th1f_nom.Integral() if nomE==0: return [1.000,1.000] downE = th1f_down.Integral()/nomE upE = th1f_up.Integral()/nomE if options.quadInterpolate!=0: downE = quadInterpolate(-1.,-1.*options.quadInterpolate,0.,1.*options.quadInterpolate,th1f_down.Integral(),th1f_nom.Integral(),th1f_up.Integral()) upE = quadInterpolate(1.,-1.*options.quadInterpolate,0.,1.*options.quadInterpolate,th1f_down.Integral(),th1f_nom.Integral(),th1f_up.Integral()) if upE != upE: upE=1.000 if downE != downE: downE=1.000 return [downE,upE]
def writeCard(tfile, mass, scaleErr):
lumistring = "%1.1f fb^{-1}" % (options.intLumi)
print "Writing Datacard for mass -> ", mass
outPut = open(
cardOutDir + "/mva-datacard_" + runtype + "_%3.1f.txt" % mass, "w")
# Get All of the histograms we are going to use
# Data ->
dataHist = tfile.Get("th1f_data_" + runtype + "_%3.1f" % mass)
nBins = dataHist.GetNbinsX()
print "Number of Channels -> ", nBins
# bkg model ->
bkgHist = tfile.Get("th1f_bkg_" + runtype + "_%3.1f" % mass)
if options.Bias:
bkgHistCorr = tfile.Get("th1f_bkg_" + runtype +
"_%3.1f_fitsb_biascorr" % mass)
#if options.Bias: bkgHistCorr = tfile.Get("th1f_bkg_mc_"+runtype+"_%3.1f"%mass)
# 4 signal channels ->
gghHist = tfile.Get("th1f_sig_" + runtype + "_ggh_%3.1f" % mass)
vbfHist = tfile.Get("th1f_sig_" + runtype + "_vbf_%3.1f" % mass)
wzhHist = tfile.Get("th1f_sig_" + runtype + "_wzh_%3.1f" % mass)
tthHist = tfile.Get("th1f_sig_" + runtype + "_tth_%3.1f" % mass)
if options.signalyieldsweight > 0:
print "Re-weighting Signal yields x %d" % signalyieldsweight
gghHist.Scale(signalyieldsweight)
vbfHist.Scale(signalyieldsweight)
wzhHist.Scale(signalyieldsweight)
tthHist.Scale(signalyieldsweight)
###############################################################################
# Write the basics
outPut.write("Mva Binned Analysis DataCard (mH=%3.1f) \n" % mass)
outPut.write("DataCard extracted from %s \n" % tfile.GetName())
outPut.write(
"--------------------------------------------------------------\n")
outPut.write("imax *\n")
outPut.write("jmax *\n")
outPut.write("kmax *\n")
outPut.write(
"--------------------------------------------------------------\n")
## Now its the observation
outPut.write("bin ")
binL = 1
binH = nBins + 1
if options.binfromright > -1:
binL = nBins + 1 - options.binfromright
binH = binL + 1
if binL < 1:
sys.exit("Not enough bins to write %d" % options.binfromright)
for b in range(binL, binH):
outPut.write(" cat%d " % b)
outPut.write("\nobservation")
# backgroundContents = [bkgHist.GetBinContent(b) for b in range(1,nBins+1)]
backgroundContents = []
if options.Bias:
print "Using Bkg Model Corrected for mass bias"
backgroundContents = [
bkgHistCorr.GetBinContent(b) for b in range(1, nBins + 1)
]
else:
sys.exit("Simple Background model no longer available !!!! ")
if options.throwToy or options.throwGlobalToy or options.throwAsimov:
print "Throwing toy dataset"
# if options.throwGlobalToy: pseudoBackgroundOnlyDataset=generateFixedNData(backgroundContents,g_normalisation_toy)
if options.throwGlobalToy and not options.throwAsimov:
pseudoBackgroundOnlyDataset = fillToyBDT(dataHist)
else:
pseudoBackgroundOnlyDataset = [
g_r.Poisson(backgroundContents[b - 1])
for b in range(1, nBins + 1)
]
if options.throwAsimov:
pseudoBackgroundOnlyDataset = fillAsimovBDT(dataHist, bkgHistCorr)
for b in range(1, nBins + 1):
nd = pseudoBackgroundOnlyDataset[b - 1]
ns = 0
if options.expSig > 0 and not options.throwGlobalToy and not options.throwAsimov:
print "Injecting %.f x SM" % options.expSig
ns += getPoissonBinContent(gghHist, b, options.expSig)
ns += getPoissonBinContent(vbfHist, b, options.expSig)
ns += getPoissonBinContent(wzhHist, b, options.expSig)
ns += getPoissonBinContent(tthHist, b, options.expSig)
print 'here'
if options.throwAsimov: outPut.write(" %.2f " % (nd + ns))
else: outPut.write(" %d " % (nd + ns))
dataHist.SetBinContent(b, nd + ns)
dataHist.SetBinError(b, (nd + ns)**0.5)
else:
for b in range(binL, binH):
outPut.write(" %d " % dataHist.GetBinContent(b))
outPut.write(
"\n--------------------------------------------------------------\n")
## Now we do the signal and background parts
outPut.write("bin ")
for b in range(binL, binH):
outPut.write(" cat%d cat%d cat%d cat%d cat%d " % (b, b, b, b, b))
outPut.write("\nprocess ")
for b in range(binL, binH):
outPut.write(" ggh vbf wzh tth bkg ")
outPut.write("\nprocess ")
for b in range(binL, binH):
outPut.write(" 0 0 0 0 1 ")
outPut.write("\nrate ")
# if global toy need to randomise background within its error as well
if options.randomizeBackground:
# get signed error matrix from fit
th2f_errmat = tfile.Get("fUncorrErr_%s_%3.1f" %
(options.bdtType, mass))
for b in range(binL, binH):
# first randomise by scale error
randBkg = backgroundContents[b - 1] * (scaleErr**(1 + g_r.Gaus()))
# then randomise by bin to bin correlation error
for q in range(1, nBins):
berr = th2f_errmat.GetBinContent(q, b)
bkgCont = backgroundContents[b - 1] / sum(backgroundContents)
bias = quadInterpolate(1., -1., 0., 1., bkgCont - berr,
bkgCont, bkgCont + berr)
randBkg = randBkg * (bias**(1 + g_r.Gaus()))
outPut.write(" %.3f %.3f %.3f %.3f %.3f "\
%(getBinContent(gghHist,b),getBinContent(vbfHist,b),getBinContent(wzhHist,b),getBinContent(tthHist,b)\
,randBkg))
outPut.write(
"\n--------------------------------------------------------------\n"
)
else:
for b in range(binL, binH): outPut.write(" %.3f %.3f %.3f %.3f %.3f "\
%(getBinContent(gghHist,b),getBinContent(vbfHist,b),getBinContent(wzhHist,b),getBinContent(tthHist,b)\
,backgroundContents[b-1]))
outPut.write(
"\n--------------------------------------------------------------\n"
)
# This next bit is for the signal systematics, first lets do the easy ones, lumi and theory
outPut.write("\nlumi lnN ")
for b in range(binL, binH):
outPut.write(" %s %s %s %s - " % (lumi, lumi, lumi, lumi))
if options.theorySys:
outPut.write("\nQCDscale_ggH lnN ")
for b in range(binL, binH):
outPut.write(" %s - - - - " % (QCDscale_ggH))
outPut.write("\nQCDscale_qqH lnN ")
for b in range(binL, binH):
outPut.write(" - %s - - - " % (QCDscale_qqH))
outPut.write("\nQCDscale_VH lnN ")
for b in range(binL, binH):
outPut.write(" - - %s - - " % (QCDscale_VH))
outPut.write("\nQCDscale_ttH lnN ")
for b in range(binL, binH):
outPut.write(" - - - %s - " % (QCDscale_ttH))
outPut.write("\nPDF_ggH lnN ")
for b in range(binL, binH):
outPut.write(" %s - - - - " % (PDF_ggH))
outPut.write("\nPDF_qqH lnN ")
for b in range(binL, binH):
outPut.write(" - %s - - - " % (PDF_qqH))
outPut.write("\nPDF_VH lnN ")
for b in range(binL, binH):
outPut.write(" - - %s - - " % (PDF_VH))
outPut.write("\nPDF_ttH lnN ")
for b in range(binL, binH):
outPut.write(" - - - %s - " % (PDF_ttH))
outPut.write("\n")
# includeVBF means the last bin is the VBF tagged bin and we apply and additional
# 70% GGH(TTH) and 10% on the VBF(WZH) part of that category (configurable above)
nBins_inclusive = 0
if options.includeVBF:
print "Including VBF Systematics"
for b in range(binL, nBins + 1):
if dataHist.GetBinLowEdge(b) < 1: nBins_inclusive += 1
nBins_exclusive = nBins_vbf + nBins_vh
print "Number of Non VBF channels -> ", nBins_inclusive
print "Number of VBF channels -> ", nBins_vbf
print "Number of VH channels -> ", nBins_vh
print "Number of Exclu channels -> ", nBins_exclusive
# First is UEPS
# calculate the effect on each bin
numberOfGGH_dijet = sum([
gghHist.GetBinContent(b) * UEPS_ggH
for b in range(binH - nBins_exclusive, binH - nBins_vh)
])
numberOfTTH_dijet = sum([
tthHist.GetBinContent(b) * UEPS_ttH
for b in range(binH - nBins_exclusive, binH - nBins_vh)
])
numberOfVBF_dijet = sum([
vbfHist.GetBinContent(b) * UEPS_qqH
for b in range(binH - nBins_exclusive, binH - nBins_vh)
])
numberOfWZH_dijet = sum([
wzhHist.GetBinContent(b) * UEPS_VH
for b in range(binH - nBins_exclusive, binH - nBins_vh)
])
numberOfGGH_incl = sum([
gghHist.GetBinContent(b)
for b in range(binL, nBins_inclusive + binL)
])
numberOfTTH_incl = sum([
tthHist.GetBinContent(b)
for b in range(binL, nBins_inclusive + binL)
])
numberOfVBF_incl = sum([
vbfHist.GetBinContent(b)
for b in range(binL, nBins_inclusive + binL)
])
numberOfWZH_incl = sum([
wzhHist.GetBinContent(b)
for b in range(binL, nBins_inclusive + binL)
])
outPut.write("\nUEPS lnN ")
# inclusive bins
for b in range(binL, nBins_inclusive + binL): outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1.-(numberOfGGH_dijet/numberOfGGH_incl),1.+(numberOfGGH_dijet/numberOfGGH_incl),\
1.-(numberOfVBF_dijet/numberOfVBF_incl),1.+(numberOfVBF_dijet/numberOfVBF_incl),\
1.-(numberOfWZH_dijet/numberOfWZH_incl),1.+(numberOfWZH_dijet/numberOfWZH_incl),\
1.-(numberOfTTH_dijet/numberOfTTH_incl),1.+(numberOfTTH_dijet/numberOfTTH_incl)))
# exclusive bins - vbf
for b in range(binH - nBins_exclusive, binH - nBins_vh): outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1+UEPS_ggH,1-UEPS_ggH,1+UEPS_qqH,1-UEPS_qqH,1+UEPS_VH,1-UEPS_VH,1+UEPS_ttH,1-UEPS_ttH))
# exclusive bins - vh
for b in range(binH - nBins_vh, binH):
outPut.write(" - - - - - ")
outPut.write("\n")
# Next is JEC
numberOfGGH_dijet = sum([
gghHist.GetBinContent(b) * JEC_ggH
for b in range(binH - nBins_exclusive, binH - nBins_vh)
])
numberOfTTH_dijet = sum([
tthHist.GetBinContent(b) * JEC_ttH
for b in range(binH - nBins_exclusive, binH - nBins_vh)
])
numberOfVBF_dijet = sum([
vbfHist.GetBinContent(b) * JEC_qqH
for b in range(binH - nBins_exclusive, binH - nBins_vh)
])
numberOfWZH_dijet = sum([
wzhHist.GetBinContent(b) * JEC_VH
for b in range(binH - nBins_exclusive, binH - nBins_vh)
])
numberOfGGH_incl = sum([
gghHist.GetBinContent(b)
for b in range(binL, nBins_inclusive + binL)
])
numberOfTTH_incl = sum([
tthHist.GetBinContent(b)
for b in range(binL, nBins_inclusive + binL)
])
numberOfVBF_incl = sum([
vbfHist.GetBinContent(b)
for b in range(binL, nBins_inclusive + binL)
])
numberOfWZH_incl = sum([
wzhHist.GetBinContent(b)
for b in range(binL, nBins_inclusive + binL)
])
outPut.write("\nJEC lnN")
# inclusive bins
for b in range(binL, nBins_inclusive + binL): outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1.-(numberOfGGH_dijet/numberOfGGH_incl),1.+(numberOfGGH_dijet/numberOfGGH_incl),\
1.-(numberOfVBF_dijet/numberOfVBF_incl),1.+(numberOfVBF_dijet/numberOfVBF_incl),\
1.-(numberOfWZH_dijet/numberOfWZH_incl),1.+(numberOfWZH_dijet/numberOfWZH_incl),\
1.-(numberOfTTH_dijet/numberOfTTH_incl),1.+(numberOfTTH_dijet/numberOfTTH_incl)))
# exclusive bins - vbf
for b in range(binH - nBins_exclusive, binH - nBins_vh): outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1+JEC_ggH,1-JEC_ggH,1+JEC_qqH,1-JEC_qqH,1+JEC_VH,1-JEC_VH,1+JEC_ttH,1-JEC_ttH))
# exclusive bins - vh
for b in range(binH - nBins_vh, binH):
outPut.write(" - - - - - ")
# Now do PUJetID
numberOfGGH_dijet = sum([
gghHist.GetBinContent(b) * PUJetIDEff
for b in range(binH - nBins_exclusive, binH - nBins_vh)
])
numberOfTTH_dijet = sum([
tthHist.GetBinContent(b) * PUJetIDEff
for b in range(binH - nBins_exclusive, binH - nBins_vh)
])
numberOfVBF_dijet = sum([
vbfHist.GetBinContent(b) * PUJetIDEff
for b in range(binH - nBins_exclusive, binH - nBins_vh)
])
numberOfWZH_dijet = sum([
wzhHist.GetBinContent(b) * PUJetIDEff
for b in range(binH - nBins_exclusive, binH - nBins_vh)
])
numberOfGGH_incl = sum([
gghHist.GetBinContent(b)
for b in range(binL, nBins_inclusive + binL)
])
numberOfTTH_incl = sum([
tthHist.GetBinContent(b)
for b in range(binL, nBins_inclusive + binL)
])
numberOfVBF_incl = sum([
vbfHist.GetBinContent(b)
for b in range(binL, nBins_inclusive + binL)
])
numberOfWZH_incl = sum([
wzhHist.GetBinContent(b)
for b in range(binL, nBins_inclusive + binL)
])
outPut.write("\nCMS_eff_j lnN")
# inclusive bins
for b in range(binL, nBins_inclusive + binL): outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1.-(numberOfGGH_dijet/numberOfGGH_incl),1.+(numberOfGGH_dijet/numberOfGGH_incl),\
1.-(numberOfVBF_dijet/numberOfVBF_incl),1.+(numberOfVBF_dijet/numberOfVBF_incl),\
1.-(numberOfWZH_dijet/numberOfWZH_incl),1.+(numberOfWZH_dijet/numberOfWZH_incl),\
1.-(numberOfTTH_dijet/numberOfTTH_incl),1.+(numberOfTTH_dijet/numberOfTTH_incl)))
# exclusive bins - vbf
for b in range(binH - nBins_exclusive, binH - nBins_vh): outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1+PUJetIDEff,1-PUJetIDEff,1+PUJetIDEff,1-PUJetIDEff,1+PUJetIDEff,1-PUJetIDEff,1+PUJetIDEff,1-PUJetIDEff))
# exclusive bins - vh
for b in range(binH - nBins_vh, binH):
outPut.write(" - - - - - ")
# Now do UEPSMigration
outPut.write("\nUEPSMigration lnN")
numberOfGGH_loose = gghHist.GetBinContent(
binL + nBins_inclusive) * UEPS_Migration_ggH
numberOfVBF_loose = vbfHist.GetBinContent(
binL + nBins_inclusive) * UEPS_Migration_qqH
numberOfWZH_loose = wzhHist.GetBinContent(
binL + nBins_inclusive) * UEPS_Migration_VH
numberOfTTH_loose = tthHist.GetBinContent(
binL + nBins_inclusive) * UEPS_Migration_ttH
numberOfGGH_tight = gghHist.GetBinContent(
binH -
nBins_vh) if gghHist.GetBinContent(binH - nBins_vh) > 0 else 1.e10
numberOfVBF_tight = vbfHist.GetBinContent(
binH -
nBins_vh) if vbfHist.GetBinContent(binH - nBins_vh) > 0 else 1.e10
numberOfWZH_tight = wzhHist.GetBinContent(
binH -
nBins_vh) if wzhHist.GetBinContent(binH - nBins_vh) > 0 else 1.e10
numberOfTTH_tight = tthHist.GetBinContent(
binH -
nBins_vh) if tthHist.GetBinContent(binH - nBins_vh) > 0 else 1.e10
if abs(numberOfGGH_loose / numberOfGGH_tight) > 1.:
numberOfGGH_loose = 0.
if abs(numberOfVBF_loose / numberOfVBF_tight) > 1.:
numberOfVBF_loose = 0.
if abs(numberOfWZH_loose / numberOfWZH_tight) > 1.:
numberOfWZH_loose = 0.
if abs(numberOfTTH_loose / numberOfTTH_tight) > 1.:
numberOfTTH_loose = 0.
for b in range(binL, nBins_inclusive + binL):
outPut.write(" - - - - -")
if nBins_vbf > 0: outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1+UEPS_Migration_ggH,1-UEPS_Migration_ggH,1+UEPS_Migration_qqH,1-UEPS_Migration_qqH,1+UEPS_Migration_VH,1-UEPS_Migration_VH,1+UEPS_Migration_ttH,1-UEPS_Migration_ttH,\
1.-(numberOfGGH_loose/numberOfGGH_tight),1.+(numberOfGGH_loose/numberOfGGH_tight),\
1.-(numberOfVBF_loose/numberOfVBF_tight),1.+(numberOfVBF_loose/numberOfVBF_tight),\
1.-(numberOfWZH_loose/numberOfWZH_tight),1.+(numberOfWZH_loose/numberOfWZH_tight),\
1.-(numberOfTTH_loose/numberOfTTH_tight),1.+(numberOfTTH_loose/numberOfTTH_tight)))
if nBins_vh:
outPut.write(
" - - - - - - - - - - - - - - - \n")
# Now do JECMigration
outPut.write("\nJECMigration lnN")
numberOfGGH_loose = gghHist.GetBinContent(
binL + nBins_inclusive) * JEC_Migration_ggH
numberOfVBF_loose = vbfHist.GetBinContent(
binL + nBins_inclusive) * JEC_Migration_qqH
numberOfWZH_loose = wzhHist.GetBinContent(
binL + nBins_inclusive) * JEC_Migration_VH
numberOfTTH_loose = tthHist.GetBinContent(
binL + nBins_inclusive) * JEC_Migration_ttH
numberOfGGH_tight = gghHist.GetBinContent(
binH -
nBins_vh) if gghHist.GetBinContent(binH - nBins_vh) > 0 else 1.e10
numberOfVBF_tight = vbfHist.GetBinContent(
binH -
nBins_vh) if vbfHist.GetBinContent(binH - nBins_vh) > 0 else 1.e10
numberOfWZH_tight = wzhHist.GetBinContent(
binH -
nBins_vh) if wzhHist.GetBinContent(binH - nBins_vh) > 0 else 1.e10
numberOfTTH_tight = tthHist.GetBinContent(
binH -
nBins_vh) if tthHist.GetBinContent(binH - nBins_vh) > 0 else 1.e10
if abs(numberOfGGH_loose / numberOfGGH_tight) > 1.:
numberOfGGH_loose = 0.
if abs(numberOfVBF_loose / numberOfVBF_tight) > 1.:
numberOfVBF_loose = 0.
if abs(numberOfWZH_loose / numberOfWZH_tight) > 1.:
numberOfWZH_loose = 0.
if abs(numberOfTTH_loose / numberOfTTH_tight) > 1.:
numberOfTTH_loose = 0.
for b in range(binL, nBins_inclusive + binL):
outPut.write(" - - - - -")
if nBins_vbf > 0: outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1+JEC_Migration_ggH,1-JEC_Migration_ggH,1+JEC_Migration_qqH,1-JEC_Migration_qqH,1+JEC_Migration_VH,1-JEC_Migration_VH,1+JEC_Migration_ttH,1-JEC_Migration_ttH,\
1.-(numberOfGGH_loose/numberOfGGH_tight),1.+(numberOfGGH_loose/numberOfGGH_tight),\
1.-(numberOfVBF_loose/numberOfVBF_tight),1.+(numberOfVBF_loose/numberOfVBF_tight),\
1.-(numberOfWZH_loose/numberOfWZH_tight),1.+(numberOfWZH_loose/numberOfWZH_tight),\
1.-(numberOfTTH_loose/numberOfTTH_tight),1.+(numberOfTTH_loose/numberOfTTH_tight)))
if nBins_vh > 0:
outPut.write(
" - - - - - - - - - - - - - - - \n")
# Now do other exclusive tag systematics
# muon tag
outPut.write("\nCMS_eff_m lnN ")
for b in range(binL, nBins_inclusive + nBins_vbf + binL):
outPut.write(" - - - - -")
if nBins_vh > 0:
outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - " %
(1. - muon_tag_eff_ggH, 1. + muon_tag_eff_ggH,
1. - muon_tag_eff_qqH, 1. + muon_tag_eff_qqH,
1. - muon_tag_eff_VH, 1. + muon_tag_eff_VH,
1. - muon_tag_eff_ttH, 1. + muon_tag_eff_ttH))
for b in range(nBins_vbf + binL + 2, binH):
outPut.write(" - - - - -")
# electron tag
outPut.write("\nCMS_eff_e lnN ")
for b in range(binL, nBins_inclusive + nBins_vbf + binL + 1):
outPut.write(" - - - - -")
if nBins_vh > 0:
outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - " %
(1. - elec_tag_eff_ggH, 1. + elec_tag_eff_ggH,
1. - elec_tag_eff_qqH, 1. + elec_tag_eff_qqH,
1. - elec_tag_eff_VH, 1. + elec_tag_eff_VH,
1. - elec_tag_eff_ttH, 1. + elec_tag_eff_ttH))
for b in range(nBins_vbf + binL + 3, binH):
outPut.write(" - - - - -")
# MET tag
outPut.write("\nCMS_eff_met lnN ")
for b in range(binL, nBins_inclusive + nBins_vbf + binL + 2):
outPut.write(" - - - - -")
if nBins_vh > 0:
outPut.write(
" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - " %
(1. - met_tag_eff_ggH, 1. + met_tag_eff_ggH, 1. - met_tag_eff_qqH,
1. + met_tag_eff_qqH, 1. - met_tag_eff_VH, 1. + met_tag_eff_VH,
1. - met_tag_eff_ttH, 1. + met_tag_eff_ttH))
outPut.write("\n")
# Now is the very tedious part of the signal shape systematics, for each shape, simply do -/+ sigma
if options.signalSys:
print "Writing Systematics Part (could be slow)"
for sys in systematics:
gghHistU = tfile.Get("th1f_sig_" + runtype +
"_ggh_%3.1f_%sUp01_sigma" % (mass, sys))
vbfHistU = tfile.Get("th1f_sig_" + runtype +
"_vbf_%3.1f_%sUp01_sigma" % (mass, sys))
wzhHistU = tfile.Get("th1f_sig_" + runtype +
"_wzh_%3.1f_%sUp01_sigma" % (mass, sys))
tthHistU = tfile.Get("th1f_sig_" + runtype +
"_tth_%3.1f_%sUp01_sigma" % (mass, sys))
gghHistD = tfile.Get("th1f_sig_" + runtype +
"_ggh_%3.1f_%sDown01_sigma" % (mass, sys))
vbfHistD = tfile.Get("th1f_sig_" + runtype +
"_vbf_%3.1f_%sDown01_sigma" % (mass, sys))
wzhHistD = tfile.Get("th1f_sig_" + runtype +
"_wzh_%3.1f_%sDown01_sigma" % (mass, sys))
tthHistD = tfile.Get("th1f_sig_" + runtype +
"_tth_%3.1f_%sDown01_sigma" % (mass, sys))
#print gghHistU.GetName(), vbfHistU.GetName(), wzhHistU.GetName(), tthHistU.GetName()
#print gghHistD.GetName(), vbfHistD.GetName(), wzhHistD.GetName(), tthHistD.GetName()
if options.signalyieldsweight > 0:
gghHistU.Scale(signalyieldsweight)
vbfHistU.Scale(signalyieldsweight)
wzhHistU.Scale(signalyieldsweight)
tthHistU.Scale(signalyieldsweight)
gghHistD.Scale(signalyieldsweight)
vbfHistD.Scale(signalyieldsweight)
wzhHistD.Scale(signalyieldsweight)
tthHistD.Scale(signalyieldsweight)
if options.is2011: outPut.write("\n%s lnN " % sys)
else: outPut.write("\n%s lnN " % sys)
for b in range(binL, binH):
outPut.write(" %s %s %s %s - "%(\
py_quadInterpolate(1.,-3.,0.,3.,gghHistD.GetBinContent(b) \
,gghHist.GetBinContent(b) \
,gghHistU.GetBinContent(b)) \
,py_quadInterpolate(1.,-3.,0.,3.,vbfHistD.GetBinContent(b) \
,vbfHist.GetBinContent(b) \
,vbfHistU.GetBinContent(b)) \
,py_quadInterpolate(1.,-3.,0.,3.,wzhHistD.GetBinContent(b) \
,wzhHist.GetBinContent(b) \
,wzhHistU.GetBinContent(b)) \
,py_quadInterpolate(1.,-3.,0.,3.,tthHistD.GetBinContent(b) \
,tthHist.GetBinContent(b) \
,tthHistU.GetBinContent(b)) \
))
outPut.write("\n")
# Finally the background errors, these are realtively simple
if options.is2011: outPut.write("\nbkg_norm lnN ")
else: outPut.write("\nbkg_norm_8TeV lnN ")
for b in range(binL, binH):
outPut.write(" - - - - %.3f " % (scaleErr))
## now for the David errors
if options.Bias:
print "Including Mass Bias nuisances (bin-to-bin stat error included)"
# Input Signed Error Matrix from Fit
th2f_errmatrix = tfile.Get("fUncorrErr_%s_%3.1f" %
(options.bdtType, mass))
for b in range(
1, nBins
): # This error matrix is nBins-1 X nBins-1 due to constraint on sum on fractions
if options.is2011: outPut.write("\nmassBias%d lnN" % b)
else: outPut.write("\nmassBias%d_8TeV lnN" % b)
for q in range(binL, binH):
f_errentry = th2f_errmatrix.GetBinContent(b, q)
bkgC = backgroundContents[q - 1] / sum(backgroundContents)
bias_nuis = py_quadInterpolate(1., -1., 0., 1.,
bkgC - f_errentry, bkgC,
bkgC + f_errentry)
outPut.write(" - - - - %s " % (bias_nuis))
outPut.write("\n")
if options.B2B and (not options.Bias):
# bkg bins will be gmN errors instead
for b in range(binL, binH):
bkgScale = bkgHist.Integral() / bkgHist.GetEntries()
if options.is2011:
outPut.write("\nbkg_stat%d gmN %d " %
(b, int(backgroundContents[b - 1] / bkgScale)))
else:
outPut.write("\nbkg_stat%d_8TeV gmN %d " %
(b, int(backgroundContents[b - 1] / bkgScale)))
for q in range(binL, binH):
if q == b: outPut.write(" - - - - %.3f " % bkgScale)
else: outPut.write(" - - - - - ")
# Finally make a plot of what will go into the limit
if options.makePlot:
print "Plotting Limit Setting inputs to m%3.1f.pdf" % mass
if options.Bias: plotBKG = bkgHistCorr.Clone()
else: plotBKG = bkgHist.Clone()
plotDistributions(mass,dataHist.Clone() \
,[gghHist.Clone(),wzhHist.Clone(),tthHist.Clone(),vbfHist.Clone()]\
,plotBKG \
,[scaleErr-1. for b in range(nBins)])# put VBF at the end for plot option
outPut.write("\n") # done
outPut.close()
if syst == 'all':
allSyst = getListOfSystematicSources(file)
else:
allSyst = [ syst ]
for syst in allSyst:
nuis = {}
for cat in range(ncat):
nuis[cat]={}
for proc in procs:
nominal = file.Get("th1f_sig_%s_mass_m%d_cat%d" % (proc,mass, cat) )
up = file.Get("th1f_sig_%s_mass_m%d_cat%d_%sUp01_sigma" % (proc, mass, cat,syst) )
down = file.Get("th1f_sig_%s_mass_m%d_cat%d_%sDown01_sigma" % (proc,mass, cat,syst) )
if nominal.Integral() != 0:
downE = quadInterpolate(1.,-3.,0.,3.,down.Integral(),nominal.Integral(),up.Integral())
upE = quadInterpolate(-1.,-3.,0.,1.,down.Integral(),nominal.Integral(),up.Integral())
nuis[cat][proc] = (downE,upE)
else:
nuis[cat][proc] = (1.,1.)
print syst, ' lnN ',
for cat in range(ncat):
for proc in procs:
print "%1.3f/%1.3f " % nuis[cat][proc],
print "- ",
for cat in range(ncat,ntot):
for proc in procs:
print "%1.3f/%1.3f " % (1.,1.),
print "- ",
def writeCard(tfile,mass,scaleErr):
lumistring = "%1.1f fb^{-1}"%(options.intLumi)
print "Writing Datacard for mass -> ", mass
outPut = open(cardOutDir+"/mva-datacard_"+runtype+"_%3.1f.txt"%mass,"w")
# Get All of the histograms we are going to use
# Data ->
dataHist = tfile.Get("th1f_data_"+runtype+"_%3.1f"%mass)
nBins = dataHist.GetNbinsX()
print "Number of Channels -> ", nBins
# bkg model ->
bkgHist = tfile.Get("th1f_bkg_"+runtype+"_%3.1f"%mass)
if options.Bias: bkgHistCorr = tfile.Get("th1f_bkg_"+runtype+"_%3.1f_fitsb_biascorr"%mass)
#if options.Bias: bkgHistCorr = tfile.Get("th1f_bkg_mc_"+runtype+"_%3.1f"%mass)
# 4 signal channels ->
gghHist = tfile.Get("th1f_sig_"+runtype+"_ggh_%3.1f"%mass)
vbfHist = tfile.Get("th1f_sig_"+runtype+"_vbf_%3.1f"%mass)
wzhHist = tfile.Get("th1f_sig_"+runtype+"_wzh_%3.1f"%mass)
tthHist = tfile.Get("th1f_sig_"+runtype+"_tth_%3.1f"%mass)
if options.signalyieldsweight > 0:
print "Re-weighting Signal yields x %d"%signalyieldsweight
gghHist.Scale(signalyieldsweight)
vbfHist.Scale(signalyieldsweight)
wzhHist.Scale(signalyieldsweight)
tthHist.Scale(signalyieldsweight)
###############################################################################
# Write the basics
outPut.write("Mva Binned Analysis DataCard (mH=%3.1f) \n"%mass)
outPut.write("DataCard extracted from %s \n"%tfile.GetName())
outPut.write("--------------------------------------------------------------\n")
outPut.write("imax *\n")
outPut.write("jmax *\n")
outPut.write("kmax *\n")
outPut.write("--------------------------------------------------------------\n")
## Now its the observation
outPut.write("bin ")
binL=1
binH=nBins+1
if options.binfromright>-1:
binL=nBins+1-options.binfromright
binH=binL+1
if binL<1:
sys.exit("Not enough bins to write %d" %options.binfromright)
for b in range(binL,binH): outPut.write(" cat%d "%b)
outPut.write("\nobservation")
# backgroundContents = [bkgHist.GetBinContent(b) for b in range(1,nBins+1)]
backgroundContents = []
if options.Bias:
print "Using Bkg Model Corrected for mass bias"
backgroundContents = [bkgHistCorr.GetBinContent(b) for b in range(1,nBins+1)]
else: sys.exit("Simple Background model no longer available !!!! ")
if options.throwToy or options.throwGlobalToy or options.throwAsimov:
print "Throwing toy dataset"
# if options.throwGlobalToy: pseudoBackgroundOnlyDataset=generateFixedNData(backgroundContents,g_normalisation_toy)
if options.throwGlobalToy and not options.throwAsimov :pseudoBackgroundOnlyDataset=fillToyBDT(dataHist)
else: pseudoBackgroundOnlyDataset=[g_r.Poisson(backgroundContents[b-1]) for b in range(1,nBins+1)]
if options.throwAsimov: pseudoBackgroundOnlyDataset=fillAsimovBDT(dataHist,bkgHistCorr)
for b in range(1,nBins+1):
nd = pseudoBackgroundOnlyDataset[b-1]
ns = 0
if options.expSig>0 and not options.throwGlobalToy and not options.throwAsimov:
print "Injecting %.f x SM"%options.expSig
ns+=getPoissonBinContent(gghHist,b,options.expSig)
ns+=getPoissonBinContent(vbfHist,b,options.expSig)
ns+=getPoissonBinContent(wzhHist,b,options.expSig)
ns+=getPoissonBinContent(tthHist,b,options.expSig)
print 'here'
if options.throwAsimov: outPut.write(" %.2f "%(nd+ns))
else: outPut.write(" %d "%(nd+ns))
dataHist.SetBinContent(b,nd+ns)
dataHist.SetBinError(b,(nd+ns)**0.5)
else:
for b in range(binL,binH): outPut.write(" %d "%dataHist.GetBinContent(b))
outPut.write("\n--------------------------------------------------------------\n")
## Now we do the signal and background parts
outPut.write("bin ")
for b in range(binL,binH): outPut.write(" cat%d cat%d cat%d cat%d cat%d "%(b,b,b,b,b))
outPut.write("\nprocess ")
for b in range(binL,binH): outPut.write(" ggh vbf wzh tth bkg ")
outPut.write("\nprocess ")
for b in range(binL,binH): outPut.write(" 0 0 0 0 1 ")
outPut.write("\nrate ")
# if global toy need to randomise background within its error as well
if options.randomizeBackground:
# get signed error matrix from fit
th2f_errmat = tfile.Get("fUncorrErr_%s_%3.1f"%(options.bdtType,mass))
for b in range(binL,binH):
# first randomise by scale error
randBkg = backgroundContents[b-1]*(scaleErr**(1+g_r.Gaus()))
# then randomise by bin to bin correlation error
for q in range(1,nBins):
berr = th2f_errmat.GetBinContent(q,b)
bkgCont = backgroundContents[b-1]/sum(backgroundContents)
bias = quadInterpolate(1.,-1.,0.,1.,bkgCont-berr,bkgCont,bkgCont+berr)
randBkg = randBkg*(bias**(1+g_r.Gaus()))
outPut.write(" %.3f %.3f %.3f %.3f %.3f "\
%(getBinContent(gghHist,b),getBinContent(vbfHist,b),getBinContent(wzhHist,b),getBinContent(tthHist,b)\
,randBkg))
outPut.write("\n--------------------------------------------------------------\n")
else:
for b in range(binL,binH): outPut.write(" %.3f %.3f %.3f %.3f %.3f "\
%(getBinContent(gghHist,b),getBinContent(vbfHist,b),getBinContent(wzhHist,b),getBinContent(tthHist,b)\
,backgroundContents[b-1]))
outPut.write("\n--------------------------------------------------------------\n")
# This next bit is for the signal systematics, first lets do the easy ones, lumi and theory
outPut.write("\nlumi lnN ")
for b in range(binL,binH): outPut.write(" %s %s %s %s - "%(lumi,lumi,lumi,lumi))
if options.theorySys:
outPut.write("\nQCDscale_ggH lnN ")
for b in range(binL,binH): outPut.write(" %s - - - - "%(QCDscale_ggH))
outPut.write("\nQCDscale_qqH lnN ")
for b in range(binL,binH): outPut.write(" - %s - - - "%(QCDscale_qqH))
outPut.write("\nQCDscale_VH lnN ")
for b in range(binL,binH): outPut.write(" - - %s - - "%(QCDscale_VH))
outPut.write("\nQCDscale_ttH lnN ")
for b in range(binL,binH): outPut.write(" - - - %s - "%(QCDscale_ttH))
outPut.write("\nPDF_ggH lnN ")
for b in range(binL,binH): outPut.write(" %s - - - - "%(PDF_ggH))
outPut.write("\nPDF_qqH lnN ")
for b in range(binL,binH): outPut.write(" - %s - - - "%(PDF_qqH))
outPut.write("\nPDF_VH lnN ")
for b in range(binL,binH): outPut.write(" - - %s - - "%(PDF_VH))
outPut.write("\nPDF_ttH lnN ")
for b in range(binL,binH): outPut.write(" - - - %s - "%(PDF_ttH))
outPut.write("\n")
# includeVBF means the last bin is the VBF tagged bin and we apply and additional
# 70% GGH(TTH) and 10% on the VBF(WZH) part of that category (configurable above)
nBins_inclusive=0
if options.includeVBF:
print "Including VBF Systematics"
for b in range(binL,nBins+1):
if dataHist.GetBinLowEdge(b)<1: nBins_inclusive+=1
nBins_exclusive=nBins_vbf+nBins_vh
print "Number of Non VBF channels -> ", nBins_inclusive
print "Number of VBF channels -> ", nBins_vbf
print "Number of VH channels -> ", nBins_vh
print "Number of Exclu channels -> ", nBins_exclusive
# First is UEPS
# calculate the effect on each bin
numberOfGGH_dijet = sum([gghHist.GetBinContent(b)*UEPS_ggH for b in range(binH-nBins_exclusive,binH-nBins_vh)])
numberOfTTH_dijet = sum([tthHist.GetBinContent(b)*UEPS_ttH for b in range(binH-nBins_exclusive,binH-nBins_vh)])
numberOfVBF_dijet = sum([vbfHist.GetBinContent(b)*UEPS_qqH for b in range(binH-nBins_exclusive,binH-nBins_vh)])
numberOfWZH_dijet = sum([wzhHist.GetBinContent(b)*UEPS_VH for b in range(binH-nBins_exclusive,binH-nBins_vh)])
numberOfGGH_incl = sum([gghHist.GetBinContent(b) for b in range(binL,nBins_inclusive+binL)])
numberOfTTH_incl = sum([tthHist.GetBinContent(b) for b in range(binL,nBins_inclusive+binL)])
numberOfVBF_incl = sum([vbfHist.GetBinContent(b) for b in range(binL,nBins_inclusive+binL)])
numberOfWZH_incl = sum([wzhHist.GetBinContent(b) for b in range(binL,nBins_inclusive+binL)])
outPut.write("\nUEPS lnN ")
# inclusive bins
for b in range(binL,nBins_inclusive+binL): outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1.-(numberOfGGH_dijet/numberOfGGH_incl),1.+(numberOfGGH_dijet/numberOfGGH_incl),\
1.-(numberOfVBF_dijet/numberOfVBF_incl),1.+(numberOfVBF_dijet/numberOfVBF_incl),\
1.-(numberOfWZH_dijet/numberOfWZH_incl),1.+(numberOfWZH_dijet/numberOfWZH_incl),\
1.-(numberOfTTH_dijet/numberOfTTH_incl),1.+(numberOfTTH_dijet/numberOfTTH_incl)))
# exclusive bins - vbf
for b in range(binH-nBins_exclusive,binH-nBins_vh): outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1+UEPS_ggH,1-UEPS_ggH,1+UEPS_qqH,1-UEPS_qqH,1+UEPS_VH,1-UEPS_VH,1+UEPS_ttH,1-UEPS_ttH))
# exclusive bins - vh
for b in range(binH-nBins_vh,binH): outPut.write(" - - - - - ")
outPut.write("\n")
# Next is JEC
numberOfGGH_dijet = sum([gghHist.GetBinContent(b)*JEC_ggH for b in range(binH-nBins_exclusive,binH-nBins_vh)])
numberOfTTH_dijet = sum([tthHist.GetBinContent(b)*JEC_ttH for b in range(binH-nBins_exclusive,binH-nBins_vh)])
numberOfVBF_dijet = sum([vbfHist.GetBinContent(b)*JEC_qqH for b in range(binH-nBins_exclusive,binH-nBins_vh)])
numberOfWZH_dijet = sum([wzhHist.GetBinContent(b)*JEC_VH for b in range(binH-nBins_exclusive,binH-nBins_vh)])
numberOfGGH_incl = sum([gghHist.GetBinContent(b) for b in range(binL,nBins_inclusive+binL)])
numberOfTTH_incl = sum([tthHist.GetBinContent(b) for b in range(binL,nBins_inclusive+binL)])
numberOfVBF_incl = sum([vbfHist.GetBinContent(b) for b in range(binL,nBins_inclusive+binL)])
numberOfWZH_incl = sum([wzhHist.GetBinContent(b) for b in range(binL,nBins_inclusive+binL)])
outPut.write("\nJEC lnN")
# inclusive bins
for b in range(binL,nBins_inclusive+binL): outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1.-(numberOfGGH_dijet/numberOfGGH_incl),1.+(numberOfGGH_dijet/numberOfGGH_incl),\
1.-(numberOfVBF_dijet/numberOfVBF_incl),1.+(numberOfVBF_dijet/numberOfVBF_incl),\
1.-(numberOfWZH_dijet/numberOfWZH_incl),1.+(numberOfWZH_dijet/numberOfWZH_incl),\
1.-(numberOfTTH_dijet/numberOfTTH_incl),1.+(numberOfTTH_dijet/numberOfTTH_incl)))
# exclusive bins - vbf
for b in range(binH-nBins_exclusive,binH-nBins_vh): outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1+JEC_ggH,1-JEC_ggH,1+JEC_qqH,1-JEC_qqH,1+JEC_VH,1-JEC_VH,1+JEC_ttH,1-JEC_ttH))
# exclusive bins - vh
for b in range(binH-nBins_vh,binH): outPut.write(" - - - - - ")
# Now do PUJetID
numberOfGGH_dijet = sum([gghHist.GetBinContent(b)*PUJetIDEff for b in range(binH-nBins_exclusive,binH-nBins_vh)])
numberOfTTH_dijet = sum([tthHist.GetBinContent(b)*PUJetIDEff for b in range(binH-nBins_exclusive,binH-nBins_vh)])
numberOfVBF_dijet = sum([vbfHist.GetBinContent(b)*PUJetIDEff for b in range(binH-nBins_exclusive,binH-nBins_vh)])
numberOfWZH_dijet = sum([wzhHist.GetBinContent(b)*PUJetIDEff for b in range(binH-nBins_exclusive,binH-nBins_vh)])
numberOfGGH_incl = sum([gghHist.GetBinContent(b) for b in range(binL,nBins_inclusive+binL)])
numberOfTTH_incl = sum([tthHist.GetBinContent(b) for b in range(binL,nBins_inclusive+binL)])
numberOfVBF_incl = sum([vbfHist.GetBinContent(b) for b in range(binL,nBins_inclusive+binL)])
numberOfWZH_incl = sum([wzhHist.GetBinContent(b) for b in range(binL,nBins_inclusive+binL)])
outPut.write("\nCMS_eff_j lnN")
# inclusive bins
for b in range(binL,nBins_inclusive+binL): outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1.-(numberOfGGH_dijet/numberOfGGH_incl),1.+(numberOfGGH_dijet/numberOfGGH_incl),\
1.-(numberOfVBF_dijet/numberOfVBF_incl),1.+(numberOfVBF_dijet/numberOfVBF_incl),\
1.-(numberOfWZH_dijet/numberOfWZH_incl),1.+(numberOfWZH_dijet/numberOfWZH_incl),\
1.-(numberOfTTH_dijet/numberOfTTH_incl),1.+(numberOfTTH_dijet/numberOfTTH_incl)))
# exclusive bins - vbf
for b in range(binH-nBins_exclusive,binH-nBins_vh): outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1+PUJetIDEff,1-PUJetIDEff,1+PUJetIDEff,1-PUJetIDEff,1+PUJetIDEff,1-PUJetIDEff,1+PUJetIDEff,1-PUJetIDEff))
# exclusive bins - vh
for b in range(binH-nBins_vh,binH): outPut.write(" - - - - - ")
# Now do UEPSMigration
outPut.write("\nUEPSMigration lnN")
numberOfGGH_loose = gghHist.GetBinContent(binL+nBins_inclusive)*UEPS_Migration_ggH
numberOfVBF_loose = vbfHist.GetBinContent(binL+nBins_inclusive)*UEPS_Migration_qqH
numberOfWZH_loose = wzhHist.GetBinContent(binL+nBins_inclusive)*UEPS_Migration_VH
numberOfTTH_loose = tthHist.GetBinContent(binL+nBins_inclusive)*UEPS_Migration_ttH
numberOfGGH_tight = gghHist.GetBinContent(binH-nBins_vh) if gghHist.GetBinContent(binH-nBins_vh)>0 else 1.e10
numberOfVBF_tight = vbfHist.GetBinContent(binH-nBins_vh) if vbfHist.GetBinContent(binH-nBins_vh)>0 else 1.e10
numberOfWZH_tight = wzhHist.GetBinContent(binH-nBins_vh) if wzhHist.GetBinContent(binH-nBins_vh)>0 else 1.e10
numberOfTTH_tight = tthHist.GetBinContent(binH-nBins_vh) if tthHist.GetBinContent(binH-nBins_vh)>0 else 1.e10
if abs(numberOfGGH_loose/numberOfGGH_tight)>1.: numberOfGGH_loose=0.
if abs(numberOfVBF_loose/numberOfVBF_tight)>1.: numberOfVBF_loose=0.
if abs(numberOfWZH_loose/numberOfWZH_tight)>1.: numberOfWZH_loose=0.
if abs(numberOfTTH_loose/numberOfTTH_tight)>1.: numberOfTTH_loose=0.
for b in range(binL,nBins_inclusive+binL): outPut.write(" - - - - -")
if nBins_vbf>1:
outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1+UEPS_Migration_ggH,1-UEPS_Migration_ggH,1+UEPS_Migration_qqH,1-UEPS_Migration_qqH
,1+UEPS_Migration_VH,1-UEPS_Migration_VH,1+UEPS_Migration_ttH,1-UEPS_Migration_ttH))
for b in Bins_vbf[1:nBins_vbf]:
outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1.-(numberOfGGH_loose/numberOfGGH_tight),1.+(numberOfGGH_loose/numberOfGGH_tight),\
1.-(numberOfVBF_loose/numberOfVBF_tight),1.+(numberOfVBF_loose/numberOfVBF_tight),\
1.-(numberOfWZH_loose/numberOfWZH_tight),1.+(numberOfWZH_loose/numberOfWZH_tight),\
1.-(numberOfTTH_loose/numberOfTTH_tight),1.+(numberOfTTH_loose/numberOfTTH_tight)))
for b in Bins_vh : outPut.write(" - - - - - ")
outPut.write("\n")
# Now do JECMigration
outPut.write("\nJECMigration lnN")
numberOfGGH_loose = gghHist.GetBinContent(binL+nBins_inclusive)*JEC_Migration_ggH
numberOfVBF_loose = vbfHist.GetBinContent(binL+nBins_inclusive)*JEC_Migration_qqH
numberOfWZH_loose = wzhHist.GetBinContent(binL+nBins_inclusive)*JEC_Migration_VH
numberOfTTH_loose = tthHist.GetBinContent(binL+nBins_inclusive)*JEC_Migration_ttH
numberOfGGH_tight = gghHist.GetBinContent(binH-nBins_vh) if gghHist.GetBinContent(binH-nBins_vh)>0 else 1.e10
numberOfVBF_tight = vbfHist.GetBinContent(binH-nBins_vh) if vbfHist.GetBinContent(binH-nBins_vh)>0 else 1.e10
numberOfWZH_tight = wzhHist.GetBinContent(binH-nBins_vh) if wzhHist.GetBinContent(binH-nBins_vh)>0 else 1.e10
numberOfTTH_tight = tthHist.GetBinContent(binH-nBins_vh) if tthHist.GetBinContent(binH-nBins_vh)>0 else 1.e10
if abs(numberOfGGH_loose/numberOfGGH_tight)>1.: numberOfGGH_loose=0.
if abs(numberOfVBF_loose/numberOfVBF_tight)>1.: numberOfVBF_loose=0.
if abs(numberOfWZH_loose/numberOfWZH_tight)>1.: numberOfWZH_loose=0.
if abs(numberOfTTH_loose/numberOfTTH_tight)>1.: numberOfTTH_loose=0.
for b in range(binL,nBins_inclusive+binL): outPut.write(" - - - - -")
if nBins_vbf>1:
outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1+JEC_Migration_ggH,1-JEC_Migration_ggH,1+JEC_Migration_qqH,1-JEC_Migration_qqH
,1+JEC_Migration_VH,1-JEC_Migration_VH,1+JEC_Migration_ttH,1-JEC_Migration_ttH))
for b in Bins_vbf[1:nBins_vbf]:
outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%\
(1.-(numberOfGGH_loose/numberOfGGH_tight),1.+(numberOfGGH_loose/numberOfGGH_tight),\
1.-(numberOfVBF_loose/numberOfVBF_tight),1.+(numberOfVBF_loose/numberOfVBF_tight),\
1.-(numberOfWZH_loose/numberOfWZH_tight),1.+(numberOfWZH_loose/numberOfWZH_tight),\
1.-(numberOfTTH_loose/numberOfTTH_tight),1.+(numberOfTTH_loose/numberOfTTH_tight)))
for b in Bins_vh : outPut.write(" - - - - - ")
outPut.write("\n")
# Now do other exclusive tag systematics
# muon tag
outPut.write("\nCMS_eff_m lnN ")
for b in range(binL,nBins_inclusive+nBins_vbf+binL): outPut.write(" - - - - -")
for b in Bins_vh :
if b in Muon_tags : outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%(1.-muon_tag_eff_ggH,1.+muon_tag_eff_ggH,1.-muon_tag_eff_qqH,1.+muon_tag_eff_qqH,1.-muon_tag_eff_VH,1.+muon_tag_eff_VH,1.-muon_tag_eff_ttH,1.+muon_tag_eff_ttH))
else: outPut.write(" - - - - -")
# electron tag
outPut.write("\nCMS_eff_e lnN ")
for b in range(binL,nBins_inclusive+nBins_vbf+binL+1): outPut.write(" - - - - -")
for b in Bins_vh :
if b in Elec_tags : outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%(1.-elec_tag_eff_ggH,1.+elec_tag_eff_ggH,1.-elec_tag_eff_qqH,1.+elec_tag_eff_qqH,1.-elec_tag_eff_VH,1.+elec_tag_eff_VH,1.-elec_tag_eff_ttH,1.+elec_tag_eff_ttH))
else: outPut.write(" - - - - -")
# MET tag
outPut.write("\nCMS_eff_met lnN ")
for b in range(binL,nBins_inclusive+nBins_vbf+binL+2): outPut.write(" - - - - -")
for b in Bins_vh :
if b in MET_tags : outPut.write(" %.3f/%.3f %.3f/%.3f %.3f/%.3f %.3f/%.3f - "%(1.-met_tag_eff_ggH,1.+met_tag_eff_ggH,1.-met_tag_eff_qqH,1.+met_tag_eff_qqH,1.-met_tag_eff_VH,1.+met_tag_eff_VH,1.-met_tag_eff_ttH,1.+met_tag_eff_ttH))
else: outPut.write(" - - - - -")
outPut.write("\n")
# Now is the very tedious part of the signal shape systematics, for each shape, simply do -/+ sigma
if options.signalSys:
print "Writing Systematics Part (could be slow)"
for sys in systematics:
gghHistU = tfile.Get("th1f_sig_"+runtype+"_ggh_%3.1f_%sUp01_sigma"%(mass,sys))
vbfHistU = tfile.Get("th1f_sig_"+runtype+"_vbf_%3.1f_%sUp01_sigma"%(mass,sys))
wzhHistU = tfile.Get("th1f_sig_"+runtype+"_wzh_%3.1f_%sUp01_sigma"%(mass,sys))
tthHistU = tfile.Get("th1f_sig_"+runtype+"_tth_%3.1f_%sUp01_sigma"%(mass,sys))
gghHistD = tfile.Get("th1f_sig_"+runtype+"_ggh_%3.1f_%sDown01_sigma"%(mass,sys))
vbfHistD = tfile.Get("th1f_sig_"+runtype+"_vbf_%3.1f_%sDown01_sigma"%(mass,sys))
wzhHistD = tfile.Get("th1f_sig_"+runtype+"_wzh_%3.1f_%sDown01_sigma"%(mass,sys))
tthHistD = tfile.Get("th1f_sig_"+runtype+"_tth_%3.1f_%sDown01_sigma"%(mass,sys))
#print gghHistU.GetName(), vbfHistU.GetName(), wzhHistU.GetName(), tthHistU.GetName()
#print gghHistD.GetName(), vbfHistD.GetName(), wzhHistD.GetName(), tthHistD.GetName()
if options.signalyieldsweight > 0:
gghHistU.Scale(signalyieldsweight)
vbfHistU.Scale(signalyieldsweight)
wzhHistU.Scale(signalyieldsweight)
tthHistU.Scale(signalyieldsweight)
gghHistD.Scale(signalyieldsweight)
vbfHistD.Scale(signalyieldsweight)
wzhHistD.Scale(signalyieldsweight)
tthHistD.Scale(signalyieldsweight)
if options.is2011: outPut.write("\n%s lnN "%sys)
else: outPut.write("\n%s lnN "%sys)
for b in range(binL,binH):
outPut.write(" %s %s %s %s - "%(\
py_quadInterpolate(1.,-3.,0.,3.,gghHistD.GetBinContent(b) \
,gghHist.GetBinContent(b) \
,gghHistU.GetBinContent(b)) \
,py_quadInterpolate(1.,-3.,0.,3.,vbfHistD.GetBinContent(b) \
,vbfHist.GetBinContent(b) \
,vbfHistU.GetBinContent(b)) \
,py_quadInterpolate(1.,-3.,0.,3.,wzhHistD.GetBinContent(b) \
,wzhHist.GetBinContent(b) \
,wzhHistU.GetBinContent(b)) \
,py_quadInterpolate(1.,-3.,0.,3.,tthHistD.GetBinContent(b) \
,tthHist.GetBinContent(b) \
,tthHistU.GetBinContent(b)) \
))
outPut.write("\n")
# Finally the background errors, these are realtively simple
if options.is2011: outPut.write("\nbkg_norm lnN ")
else: outPut.write("\nbkg_norm_8TeV lnN ")
for b in range(binL,binH): outPut.write(" - - - - %.3f "%(scaleErr))
## now for the David errors
if options.Bias:
print "Including Mass Bias nuisances (bin-to-bin stat error included)"
# Input Signed Error Matrix from Fit
th2f_errmatrix = tfile.Get("fUncorrErr_%s_%3.1f"%(options.bdtType,mass))
for b in range(1,nBins): # This error matrix is nBins-1 X nBins-1 due to constraint on sum on fractions
if options.is2011: outPut.write("\nmassBias%d lnN"%b)
else: outPut.write("\nmassBias%d_8TeV lnN"%b)
for q in range(binL,binH):
f_errentry = th2f_errmatrix.GetBinContent(b,q)
bkgC = backgroundContents[q-1]/sum(backgroundContents)
bias_nuis = py_quadInterpolate(1.,-1.,0.,1.,bkgC-f_errentry,bkgC,bkgC+f_errentry)
outPut.write(" - - - - %s "%(bias_nuis))
outPut.write("\n")
if options.B2B and (not options.Bias):
# bkg bins will be gmN errors instead
for b in range(binL,binH):
bkgScale = bkgHist.Integral()/bkgHist.GetEntries()
if options.is2011: outPut.write("\nbkg_stat%d gmN %d "%(b,int(backgroundContents[b-1]/bkgScale)))
else: outPut.write("\nbkg_stat%d_8TeV gmN %d "%(b,int(backgroundContents[b-1]/bkgScale)))
for q in range(binL,binH):
if q==b: outPut.write(" - - - - %.3f "%bkgScale)
else: outPut.write(" - - - - - ")
# Finally make a plot of what will go into the limit
if options.makePlot:
print "Plotting Limit Setting inputs to m%3.1f.pdf"%mass
if options.Bias : plotBKG = bkgHistCorr.Clone()
else: plotBKG = bkgHist.Clone()
plotDistributions(mass,dataHist.Clone() \
,[gghHist.Clone(),wzhHist.Clone(),tthHist.Clone(),vbfHist.Clone()]\
,plotBKG \
,[scaleErr-1. for b in range(nBins)])# put VBF at the end for plot option
outPut.write("\n") # done
outPut.close()
def interp1SigmaFrom3Sigma(th1f_nom, th1f_down, th1f_up):
downE = quadInterpolate(-1., -3., 0., 3., th1f_down.Integral(),
th1f_nom.Integral(), th1f_up.Integral())
upE = quadInterpolate(1., -3., 0., 3., th1f_down.Integral(),
th1f_nom.Integral(), th1f_up.Integral())
return [downE, upE]
def interp1SigmaFrom3Sigma(th1f_nom,th1f_down,th1f_up): downE = quadInterpolate(-1.,-3.,0.,3.,th1f_down.Integral(),th1f_nom.Integral(),th1f_up.Integral()) upE = quadInterpolate(1.,-3.,0.,3.,th1f_down.Integral(),th1f_nom.Integral(),th1f_up.Integral()) return [downE,upE]
allSyst = [syst]
for syst in allSyst:
nuis = {}
for cat in range(ncat):
nuis[cat] = {}
for proc in procs:
nominal = file.Get("th1f_sig_%s_mass_m%d_cat%d" %
(proc, mass, cat))
up = file.Get("th1f_sig_%s_mass_m%d_cat%d_%sUp01_sigma" %
(proc, mass, cat, syst))
down = file.Get("th1f_sig_%s_mass_m%d_cat%d_%sDown01_sigma" %
(proc, mass, cat, syst))
if nominal.Integral() != 0:
downE = quadInterpolate(1., -3., 0., 3., down.Integral(),
nominal.Integral(), up.Integral())
upE = quadInterpolate(-1., -3., 0., 1., down.Integral(),
nominal.Integral(), up.Integral())
nuis[cat][proc] = (downE, upE)
else:
nuis[cat][proc] = (1., 1.)
print syst, ' lnN ',
for cat in range(ncat):
for proc in procs:
print "%1.3f/%1.3f " % nuis[cat][proc],
print "- ",
for cat in range(ncat, ntot):
for proc in procs:
print "%1.3f/%1.3f " % (1., 1.),
