def _fakesData(self, region, channel, setup, overwrite=False):
param_LsHc = {"photonIso": "highChgIso", "addMisIDSF": addSF}
params_LsHc = copy.deepcopy(setup.parameters)
params_LsHc.update(param_LsHc)
setup_LsHc = setup.sysClone(parameters=params_LsHc)
if self.expected:
# estimate = MCBasedEstimate( name="all_mc_e" if channel == "e" else "all_mc_mu", process=setup.processes["all_mc_e" if channel == "e" else "all_mc_mu"] )
estimate = MCBasedEstimate(name="all_noQCD",
process=setup.processes["all_noQCD"])
else:
estimate = DataObservation(name="Data",
process=setup.processes["Data"])
data_LsHc = estimate.cachedEstimate(region,
channel,
setup_LsHc,
overwrite=overwrite)
# estimate = MCBasedEstimate( name="all_mc_e_prompt" if channel == "e" else "all_mc_mu_prompt", process=setup.processes["all_mc_e_prompt" if channel == "e" else "all_mc_mu_prompt"] )
estimate = MCBasedEstimate(name="all_noQCD_prompt",
process=setup.processes["all_noQCD_prompt"])
mcPrompt_LsHc = estimate.cachedEstimate(region,
channel,
setup_LsHc,
overwrite=overwrite)
print "prompt lshc", mcPrompt_LsHc
dataHad_LsHc = data_LsHc - mcPrompt_LsHc
return dataHad_LsHc if dataHad_LsHc > 0 else u_float(.1, .1)
def _kappaData(self, region, channel, setup, overwrite=False):
# data correction factor for low chgIso -> high chgIso
param_HsLc = {"photonIso": "highSieie", "addMisIDSF": addSF}
param_HsHc = {"photonIso": "highChgIsohighSieie", "addMisIDSF": addSF}
params_HsLc = copy.deepcopy(setup.parameters)
params_HsHc = copy.deepcopy(setup.parameters)
params_HsLc.update(param_HsLc)
params_HsHc.update(param_HsHc)
setup_HsLc = setup.sysClone(parameters=params_HsLc)
setup_HsHc = setup.sysClone(parameters=params_HsHc)
if self.expected:
# estimate = MCBasedEstimate( name="all_mc_e" if channel == "e" else "all_mc_mu", process=setup.processes["all_mc_e" if channel == "e" else "all_mc_mu"] )
estimate = MCBasedEstimate(name="all_noQCD",
process=setup.processes["all_noQCD"])
else:
estimate = DataObservation(name="Data",
process=setup.processes["Data"])
data_HsLc = estimate.cachedEstimate(region,
channel,
setup_HsLc,
overwrite=overwrite)
data_HsHc = estimate.cachedEstimate(region,
channel,
setup_HsHc,
overwrite=overwrite)
# get the MC based Estimate for fakes in the region
# estimate = MCBasedEstimate( name="all_mc_e_prompt" if channel == "e" else "all_mc_mu_prompt", process=setup.processes["all_mc_e_prompt" if channel == "e" else "all_mc_mu_prompt"] )
estimate = MCBasedEstimate(name="all_noQCD_prompt",
process=setup.processes["all_noQCD_prompt"])
mcPrompt_HsLc = estimate.cachedEstimate(region,
channel,
setup_HsLc,
overwrite=overwrite)
print "prompt hslc", mcPrompt_HsLc
mcPrompt_HsHc = estimate.cachedEstimate(region,
channel,
setup_HsHc,
overwrite=overwrite)
print "prompt hshc", mcPrompt_HsHc
dataHad_HsHc = data_HsHc - mcPrompt_HsHc
if dataHad_HsHc <= 0: return u_float(0)
dataHad_HsLc = data_HsLc - mcPrompt_HsLc
if dataHad_HsLc <= 0: dataHad_HsLc = u_float(.1, .1)
return dataHad_HsLc / dataHad_HsHc
ptDict = {str(noPhotonRegionTTG[0]): "all"}
catSel = ["all"]
setup = Setup(year=args.year, photonSelection=False, checkOnly=True)
estimators = EstimatorList(setup)
allProcesses = [
item for item in allProcesses
if not "fakes-DD" in item and not "_had" in item
]
allEstimators = estimators.constructEstimatorList(allProcesses)
mc = list(set([e.name.split("_")[0] for e in allEstimators]))
if not args.noData:
allEstimators += [
DataObservation(name="Data",
process=setup.processes["Data"],
cacheDir=setup.defaultCacheDir())
]
if args.controlRegion:
setup = setup.sysClone(parameters=CR_para)
def wrapper(arg):
r, channel, setup, estimate, cat, est = arg
estimate.initCache(setup.defaultCacheDir())
if estimate.name == "Data" and blind:
res = u_float(0, 0)
else:
res = estimate.cachedEstimate(r,
channel,
photonSelection = not allRegions[args.controlRegion]["noPhotonCR"]
if args.noInclusive:
allPhotonRegions = allRegions[args.controlRegion]["regions"]
else:
allPhotonRegions = allRegions[
args.controlRegion]["inclRegion"] + allRegions[
args.controlRegion]["regions"] if photonSelection else allRegions[
args.controlRegion]["regions"]
setup = Setup(year=args.year,
photonSelection=photonSelection
and not "QCD" in args.selectEstimator,
checkOnly=True) #photonselection always false for qcd estimate
# Select estimate
if args.selectEstimator == "Data":
estimate = DataObservation(name="Data", process=setup.processes["Data"])
estimate.isData = True
else:
estimators = EstimatorList(setup, processes=[args.selectEstimator])
estimate = getattr(estimators, args.selectEstimator)
estimate.isData = False
if not estimate:
logger.warning(args.selectEstimator + " not known")
sys.exit(0)
estimate.initCache(setup.defaultCacheDir())
setup3p = setup.sysClone(parameters=parameters3p)
setup3 = setup.sysClone(parameters=parameters3)
setup4p = setup.sysClone(parameters=parameters4p)
photonSelection = not allRegions[args.controlRegion]["noPhotonCR"]
if args.noInclusive:
allPhotonRegions = allRegions[args.controlRegion]["regions"]
else:
allPhotonRegions = allRegions[
args.controlRegion]["inclRegion"] + allRegions[
args.controlRegion]["regions"] if photonSelection else allRegions[
args.controlRegion]["regions"]
setup = Setup(year=args.year,
photonSelection=photonSelection
and not "QCD" in args.selectEstimator,
checkOnly=True) #photonselection always false for qcd estimate
# Select estimate
if args.selectEstimator == "Data":
estimateFrom = DataObservation(name="Data",
process=setup.processes["Data"])
estimateFrom.isData = True
else:
estimators = EstimatorList(setup, processes=[args.selectEstimator])
estimateFrom = getattr(estimators, args.selectEstimator)
estimateFrom.isData = False
if not estimateFrom:
logger.warning(args.selectEstimator + " not known")
sys.exit(0)
setup = setup.sysClone(parameters=parameters)
def wrapper(arg):
r, channel, setup, addon = arg
def wrapper():
c = cardFileWriter.cardFileWriter()
c.releaseLocation = combineReleaseLocation
cardFileNameTxt = os.path.join(limitDir,
"_".join(regionNames + EFTparams) + ".txt")
cardFileNameShape = cardFileNameTxt.replace(".txt", "_shape.root")
cardFileName = cardFileNameTxt
if (not os.path.exists(cardFileNameTxt)
or (not os.path.exists(cardFileNameShape) and not args.useTxt)):
if args.checkOnly:
print cardFileNameShape
logger.info(
"Combine Card not found. Please run without --checkOnly first!"
)
return
counter = 0
c.reset()
c.setPrecision(3)
shapeString = "lnN" if args.useTxt else "shape"
# experimental
c.addUncertainty("PU", shapeString)
c.addUncertainty("JEC", shapeString)
c.addUncertainty("JER", shapeString)
c.addUncertainty("SFb", shapeString)
c.addUncertainty("SFl", shapeString)
c.addUncertainty("trigger", shapeString)
c.addUncertainty("leptonSF", shapeString)
c.addUncertainty("leptonTrackSF", shapeString)
c.addUncertainty("prefireSF", shapeString)
if with1pCR:
c.addUncertainty("photonSF", shapeString)
c.addUncertainty("eVetoSF", shapeString)
if any(
[name == "DY3" or name == "DY4p" for name in args.useRegions]):
c.addUncertainty("PU_DY", shapeString)
c.addUncertainty("JEC_DY", shapeString)
c.addUncertainty("JER_DY", shapeString)
c.addUncertainty("SFb_DY", shapeString)
c.addUncertainty("SFl_DY", shapeString)
c.addUncertainty("trigger_DY", shapeString)
c.addUncertainty("leptonSF_DY", shapeString)
c.addUncertainty("leptonTrackSF_DY", shapeString)
c.addUncertainty("prefireSF_DY", shapeString)
# theory (PDF, scale, ISR)
if with1pCR:
c.addUncertainty("Tune", shapeString)
c.addUncertainty("erdOn", shapeString)
c.addUncertainty("Scale", shapeString)
c.addUncertainty("PDF", shapeString)
c.addUncertainty("PS", shapeString)
# c.addUncertainty( "ISR", shapeString)
default_QCD_unc = 0.5
if with1pCR:
c.addUncertainty("QCD_1p", shapeString)
# c.addUncertainty( "QCD_TF", shapeString )
if with0pCR:
c.addUncertainty("QCD_0p", shapeString)
# Only if TT CR is used
default_TT_unc = 0.05
if any([name == "TT3" or name == "TT4p"
for name in args.useRegions]) and not args.ttPOI:
c.addFreeParameter('TT', 1, '[0.5,1.5]')
# elif not args.ttPOI:
# c.addUncertainty( "TT_norm", shapeString )
default_HadFakes_unc = 0.05
# c.addUncertainty( "Fakes_norm", shapeString )
default_HadCorr_unc = 0.05
addFakeUnc = False
if any(["fake" in name for name in args.useRegions]):
addFakeUnc = True
c.addUncertainty("fake_highSieie", shapeString)
c.addUncertainty("fake_lowSieie", shapeString)
for i_iso, iso in enumerate(chgIsoRegions):
print i_iso, iso
c.addUncertainty("fake_corr_%i" % i_iso, shapeString)
if with1pCR:
# c.addFreeParameter('ZG', 1, '[0.,2.]')
c.addFreeParameter('WG', 1, '[0.,2.]')
default_WG_unc = 1.00
# c.addUncertainty( "WG_norm", shapeString )
default_ZG_unc = 0.3
c.addUncertainty("ZG_norm", shapeString)
default_PU_unc = 0.15
c.addUncertainty("PU_norm", shapeString)
default_Other_unc = 0.15
c.addUncertainty("Other_norm", shapeString)
c.addUncertainty("Other_0p", shapeString)
default_misID4p_unc = 0.5
if any([
"3" in name and not "4pM3" in name for name in args.useRegions
]) and any(["4p" in name for name in args.useRegions]):
c.addUncertainty("MisID_nJet", shapeString)
default_ZG4p_unc = 0.8
if any([
"3" in name and not "4pM3" in name for name in args.useRegions
]) and any(["4p" in name for name in args.useRegions]):
c.addUncertainty("ZG_nJet", shapeString)
default_DY4p_unc = 0.8
if any([
"3" in name and not "4pM3" in name for name in args.useRegions
]) and any(["4p" in name for name in args.useRegions]):
c.addUncertainty("DY_nJet", shapeString)
default_WG4p_unc = 0.5
if any([
"3" in name and not "4pM3" in name for name in args.useRegions
]) and any(["4p" in name for name in args.useRegions]):
c.addUncertainty("WG_nJet", shapeString)
default_WJets4p_unc = 0.3
# c.addUncertainty( "WJets_nJet", shapeString )
default_TTGpT_unc = 0.1
if not args.inclRegion and with1pCR:
for i in range(len(gammaPT_thresholds) - 1):
c.addUncertainty("TTG_pTBin%i" % i, shapeString)
# Only if WJets CR is used
default_WJets_unc = 0.2
if any([
"WJets3" in name or "WJets4p" in name
for name in args.useRegions
]) and not args.wJetsPOI:
c.addFreeParameter('WJets', 1, '[0.5,1.5]')
elif not args.wJetsPOI:
c.addUncertainty("WJets_norm", shapeString)
default_DY_unc = 0.1
if any([
name in ["DY2", "DY3", "DY4", "DY4p", "DY5"]
for name in args.useRegions
]) and not args.dyPOI:
c.addFreeParameter('DY', 1, '[0.5,1.5]')
elif not args.dyPOI:
c.addUncertainty("DY_norm", shapeString)
if not args.addMisIDSF and not args.misIDPOI and with1pCR:
c.addFreeParameter('misID', 1, '[0,5]')
elif not args.misIDPOI and with1pCR:
c.addFreeParameter('misID', 1, '[0,2]')
for setup in setups:
observation = DataObservation(name="Data",
process=setup.data,
cacheDir=setup.defaultCacheDir())
for pName, pList in setup.processes.items():
if pName == "Data": continue
for e in pList:
e.initCache(setup.defaultCacheDir())
for r in setup.regions:
for i_ch, channel in enumerate(setup.channels):
if args.useChannels and channel not in args.useChannels:
continue
niceName = " ".join([channel, str(r), setup.addon])
binname = "Bin%i" % counter
total_exp_bkg = 0
if args.misIDPOI:
c.addBin(binname, [
pName.replace("signal", "TTG")
for pName in setup.processes.keys()
if not "misID" in pName and pName != "Data"
], niceName)
elif args.dyPOI:
c.addBin(binname, [
pName.replace("signal", "TTG")
for pName in setup.processes.keys()
if not "DY" in pName and pName != "Data"
], niceName)
elif args.ttPOI:
c.addBin(binname, [
pName.replace("signal", "TTG")
for pName in setup.processes.keys()
if not "TT" in pName and pName != "Data"
], niceName)
elif args.wJetsPOI:
c.addBin(binname, [
pName.replace("signal", "TTG")
for pName in setup.processes.keys()
if not "WJets" in pName and pName != "Data"
], niceName)
else:
c.addBin(binname, [
pName for pName in setup.processes.keys()
if pName != "signal" and pName != "Data"
], niceName)
counter += 1
mute = False
sigExp = u_float(0., 0.)
sigUnc = {}
for pName, pList in setup.processes.items():
if pName == "Data": continue
# calculate eft ratio
smyieldkey = (setup.name, str(r), channel,
"ctZ_0_ctZI_0")
if not yieldCache.contains(smyieldkey):
raise Exception("yieldCache does not contain key")
smyield = yieldCache.get(smyieldkey)["val"]
eftyieldkey = (setup.name, str(r), channel, str(eft))
if not yieldCache.contains(eftyieldkey):
raise Exception("yieldCache does not contain key")
eftyield = yieldCache.get(eftyieldkey)["val"]
ratio = eftyield / smyield if smyield > 0 else 1.
misIDPOI = "misID" in pName and args.misIDPOI
dyPOI = "DY" in pName and args.dyPOI
wJetsPOI = "WJets" in pName and args.wJetsPOI
ttPOI = "TT" in pName and not "TTG" in pName and args.ttPOI
newPOI_input = any([
args.misIDPOI, args.dyPOI, args.wJetsPOI,
args.ttPOI
])
newPOI = any([misIDPOI, dyPOI, wJetsPOI, ttPOI])
if newPOI_input and pName == "signal":
pName = "TTG"
signal = True if newPOI else pName == "signal"
expected = u_float(0., 0.)
for e in pList:
exp_yield = e.cachedEstimate(r, channel, setup)
if signal: exp_yield *= ratio
if signal and args.addSSM:
exp_yield *= SSMSF_val[args.year].val
logger.info("Scaling signal by %f" %
(SSMSF_val[args.year].val))
if e.name.count("WJets") and args.addWJetsSF:
exp_yield *= WJetsSF_val[args.year].val
logger.info(
"Scaling WJets background %s by %f" %
(e.name, WJetsSF_val[args.year].val))
if e.name.count("DY") and args.addDYSF:
if "2" in setup.name and not "2p" in setup.name:
exp_yield *= DY2SF_val[args.year].val
logger.info(
"Scaling DY background %s by %f" %
(e.name, DY2SF_val[args.year].val))
elif "3" in setup.name and not "3p" in setup.name:
exp_yield *= DY3SF_val[args.year].val
logger.info(
"Scaling DY background %s by %f" %
(e.name, DY3SF_val[args.year].val))
elif "4" in setup.name and not "4p" in setup.name:
exp_yield *= DY4SF_val[args.year].val
logger.info(
"Scaling DY background %s by %f" %
(e.name, DY4SF_val[args.year].val))
elif "5" in setup.name:
exp_yield *= DY5SF_val[args.year].val
logger.info(
"Scaling DY background %s by %f" %
(e.name, DY5SF_val[args.year].val))
elif "2p" in setup.name:
exp_yield *= DY2pSF_val[args.year].val
logger.info(
"Scaling DY background %s by %f" %
(e.name, DY2pSF_val[args.year].val))
elif "3p" in setup.name:
exp_yield *= DY3pSF_val[args.year].val
logger.info(
"Scaling DY background %s by %f" %
(e.name, DY3pSF_val[args.year].val))
elif "4p" in setup.name:
exp_yield *= DY4pSF_val[args.year].val
logger.info(
"Scaling DY background %s by %f" %
(e.name, DY4pSF_val[args.year].val))
else:
exp_yield *= DYSF_val[args.year].val
logger.info(
"Scaling DY background %s by %f" %
(e.name, DYSF_val[args.year].val))
if e.name.count("WG") and args.addWGSF:
exp_yield *= WGSF_val[args.year].val
logger.info("Scaling WG background %s by %f" %
(e.name, WGSF_val[args.year].val))
if e.name.count("ZG") and args.addZGSF:
exp_yield *= ZGSF_val[args.year].val
logger.info("Scaling ZG background %s by %f" %
(e.name, ZGSF_val[args.year].val))
if e.name.count("misID") and args.addMisIDSF:
exp_yield *= misIDSF_val[args.year].val
logger.info(
"Scaling misID background %s by %f" %
(e.name, misIDSF_val[args.year].val))
if e.name.count("had") and args.addFakeSF:
exp_yield *= fakeSF_val[args.year].val
logger.info(
"Scaling fake background %s by %f" %
(e.name, fakeSF_val[args.year].val))
e.expYield = exp_yield
expected += exp_yield
logger.info("Expectation for process %s: %s", pName,
expected.val)
if newPOI_input and signal:
sigExp += expected
logger.info(
"Adding expectation for process %s to signal. Total signal now: %s",
pName, sigExp)
else:
c.specifyExpectation(
binname, pName,
expected.val if expected.val > 0 else 0.01)
if signal: total_exp_bkg += (expected.val / ratio)
else: total_exp_bkg += expected.val
if signal and expected.val <= 0.01: mute = True
tune, erdOn, pu, jec, jer, sfb, sfl, trigger, lepSF, lepTrSF, phSF, eVetoSF, pfSF = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
ps, scale, pdf, isr = 0, 0, 0, 0
qcdTF3, qcdTF4, wjets4p, wg4p = 0, 0, 0, 0
dyGenUnc, ttGenUnc, vgGenUnc, wjetsGenUnc, otherGenUnc, misIDUnc, lowSieieUnc, highSieieUnc, misIDPtUnc = 0, 0, 0, 0, 0.001, 0, 0.001, 0.001, 0.001
magic, wg, zg, misID4p, dy4p, zg4p, misIDUnc, qcdUnc, vgUnc, wgUnc, zgUnc, dyUnc, ttUnc, wjetsUnc, other0pUnc, otherUnc = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
for i in range(len(gammaPT_thresholds) - 1):
locals()["ttg_bin%i_unc" % i] = 0
def getSFUncertainty(proc_yield, sf):
up = proc_yield * (1 + sf.sigma / sf.val)
down = proc_yield * (1 - sf.sigma / sf.val)
return abs(0.5 * (up - down) /
proc_yield) if proc_yield > 0 else max(
up, down)
fakeCorrUnc = []
for i_iso, iso in enumerate(chgIsoRegions):
fakeCorrUnc.append(0)
if expected.val:
for e in pList:
y_scale = e.expYield.val / expected.val
if e.name.count("QCD"):
qcdUnc += y_scale * default_QCD_unc
qcdTF3 += y_scale * e.expYield.sigma / e.expYield.val
continue # no systematics for data-driven QCD
if e.name.count("DY"):
dyUnc += y_scale * default_DY_unc
if e.name.count("TT_pow") or (args.ttPOI
and signal):
ttUnc += y_scale * default_TT_unc
if e.name.count("WJets") or (args.wJetsPOI
and signal):
wjetsUnc += y_scale * default_WJets_unc
if not args.inclRegion and not newPOI_input and (
(e.name.count("signal")
and setup.signalregion) or counter == 1):
pT_index = max([
i_pt if ptCut.cutString()
in r.cutString() else -1
for i_pt, ptCut in enumerate(
regionsTTG)
])
if pT_index >= 0:
locals(
)["ttg_bin%i_unc" %
pT_index] = y_scale * default_TTGpT_unc
if e.name.count("other"):
otherUnc += y_scale * default_Other_unc
if e.name.count("magic"):
magic += y_scale * default_PU_unc
if any([
"fake" in name
for name in args.useRegions
]):
if "low" in setup.name and e.name.count(
"_had"):
lowSieieUnc += y_scale * default_HadFakes_unc #getSFUncertainty( proc_yield=e.expYield.val, sf=fakeSF_val[args.year] )
if "high" in setup.name and e.name.count(
"_had"):
highSieieUnc += y_scale * default_HadFakes_unc #getSFUncertainty( proc_yield=e.expYield.val, sf=fakeSF_val[args.year] )
# if e.name.count( "_had" ):
# hadFakesUnc += y_scale * default_HadFakes_unc #getSFUncertainty( proc_yield=e.expYield.val, sf=fakeSF_val[args.year] )
for i_iso, iso in enumerate(chgIsoRegions):
if iso.cutString() in r.cutString():
fakeCorrUnc[
i_iso] += y_scale * default_HadCorr_unc
if not "fake" in setup.name and i_iso == 0 and e.name.count(
"_had"):
fakeCorrUnc[
i_iso] += y_scale * default_HadCorr_unc
if e.name.count("ZG"):
zg += y_scale * default_ZG_unc
# if e.name.count( "WG" ):
# wg += y_scale * default_WG_unc
if e.name.count("ZG") and "4" in setup.name:
zg4p += y_scale * default_ZG4p_unc
# elif e.name.count( "ZG" ):
# zg4p += y_scale * 0.001
if e.name.count("DY") and "4" in setup.name:
dy4p += y_scale * default_DY4p_unc
# elif e.name.count( "DY" ):
# dy4p += y_scale * 0.001
if e.name.count("WG") and "4" in setup.name:
wg4p += y_scale * default_WG4p_unc
if e.name.count("WJets") and "4" in setup.name:
wjets4p += y_scale * default_WJets4p_unc
# elif e.name.count( "WJets" ):
# wjets4p += y_scale * 0.001
if e.name.count("misID") and "4" in setup.name:
misID4p += y_scale * default_misID4p_unc
# elif e.name.count( "misID" ):
# misID4p += y_scale * 0.001
if signal and not newPOI_input:
tune += y_scale * e.TuneSystematic(
r, channel, setup).val
erdOn += y_scale * e.ErdOnSystematic(
r, channel, setup).val
scale += y_scale * getScaleUnc(
e.name, r, channel, setup)
pdf += y_scale * getPDFUnc(
e.name, r, channel, setup)
ps += y_scale * getPSUnc(
e.name, r, channel, setup)
pu += y_scale * e.PUSystematic(
r, channel, setup).val
jec += y_scale * e.JECSystematic(
r, channel, setup).val
jer += y_scale * e.JERSystematic(
r, channel, setup).val
sfb += y_scale * e.btaggingSFbSystematic(
r, channel, setup).val
sfl += y_scale * e.btaggingSFlSystematic(
r, channel, setup).val
trigger += y_scale * e.triggerSystematic(
r, channel, setup).val
lepSF += y_scale * e.leptonSFSystematic(
r, channel, setup).val
lepTrSF += y_scale * e.leptonTrackingSFSystematic(
r, channel, setup).val
phSF += y_scale * e.photonSFSystematic(
r, channel, setup).val
eVetoSF += y_scale * e.photonElectronVetoSFSystematic(
r, channel, setup).val
pfSF += y_scale * e.L1PrefireSystematic(
r, channel, setup).val
def addUnc(c, name, binname, pName, unc, unc_yield,
signal):
if newPOI_input and signal:
if name in sigUnc:
sigUnc[name] += u_float(0, unc) * unc_yield
else:
sigUnc[name] = u_float(0, unc) * unc_yield
else:
c.specifyUncertainty(name, binname, pName,
1 + unc)
if with1pCR:
if scale: # and setup.signalregion:
addUnc(c, "Scale", binname, pName, scale,
expected.val, signal)
if pdf: # and setup.signalregion:
addUnc(c, "PDF", binname, pName, pdf,
expected.val, signal)
if erdOn: # and setup.signalregion:
addUnc(c, "erdOn", binname, pName, erdOn,
expected.val, signal)
if tune: # and setup.signalregion:
addUnc(c, "Tune", binname, pName, tune,
expected.val, signal)
if ps: # and setup.signalregion:
addUnc(c, "PS", binname, pName, tune,
expected.val, signal)
if setup.noPhotonCR and with1pCR:
addUnc(c, "JEC_DY", binname, pName, jec,
expected.val, signal)
addUnc(c, "JER_DY", binname, pName, jer,
expected.val, signal)
addUnc(c, "PU_DY", binname, pName, pu,
expected.val, signal)
addUnc(c, "SFb_DY", binname, pName, sfb,
expected.val, signal)
addUnc(c, "SFl_DY", binname, pName, sfl,
expected.val, signal)
addUnc(c, "trigger_DY", binname, pName, trigger,
expected.val, signal)
addUnc(c, "leptonSF_DY", binname, pName, lepSF,
expected.val, signal)
addUnc(c, "leptonTrackSF_DY", binname, pName,
lepTrSF, expected.val, signal)
addUnc(c, "prefireSF_DY", binname, pName, pfSF,
expected.val, signal)
else:
addUnc(c, "JEC", binname, pName, jec, expected.val,
signal)
addUnc(c, "JER", binname, pName, jer, expected.val,
signal)
addUnc(c, "PU", binname, pName, pu, expected.val,
signal)
addUnc(c, "SFb", binname, pName, sfb, expected.val,
signal)
addUnc(c, "SFl", binname, pName, sfl, expected.val,
signal)
addUnc(c, "trigger", binname, pName, trigger,
expected.val, signal)
addUnc(c, "leptonSF", binname, pName, lepSF,
expected.val, signal)
addUnc(c, "leptonTrackSF", binname, pName, lepTrSF,
expected.val, signal)
addUnc(c, "prefireSF", binname, pName, pfSF,
expected.val, signal)
if with1pCR:
addUnc(c, "photonSF", binname, pName, phSF,
expected.val, signal)
addUnc(c, "eVetoSF", binname, pName, eVetoSF,
expected.val, signal)
if qcdUnc and setup.noPhotonCR:
addUnc(c, "QCD_0p", binname, pName, qcdUnc,
expected.val, signal)
if qcdUnc and not setup.noPhotonCR:
addUnc(c, "QCD_1p", binname, pName, qcdUnc,
expected.val, signal)
# if qcdTF3:
# addUnc( c, "QCD_TF", binname, pName, qcdTF3, expected.val, signal )
if not args.inclRegion and with1pCR:
for i in range(len(gammaPT_thresholds) - 1):
if locals()["ttg_bin%i_unc" % i]:
addUnc(c, "TTG_pTBin%i" % i, binname,
pName,
locals()["ttg_bin%i_unc" % i],
expected.val, signal)
elif counter == 1 and not setup.signalregion and signal and not newPOI_input:
addUnc(c, "TTG_pTBin%i" % i, binname,
pName, 0.01, expected.val, signal)
if dyUnc: # and args.addDYSF:
addUnc(c, "DY_norm", binname, pName, dyUnc,
expected.val, signal)
# if ttUnc and not any( [name=="TT3" or name=="TT4p" for name in args.useRegions] ) and not args.ttPOI:
# addUnc( c, "TT_norm", binname, pName, ttUnc, expected.val, signal )
if wjetsUnc and not args.wJetsPOI: # and args.addWJetsSF:
addUnc(c, "WJets_norm", binname, pName, wjetsUnc,
expected.val, signal)
if magic:
addUnc(c, "PU_norm", binname, pName, magic,
expected.val, signal)
if otherUnc and setup.noPhotonCR:
addUnc(c, "Other_0p", binname, pName, otherUnc,
expected.val, signal)
addUnc(c, "Other_norm", binname, pName, 0.001,
expected.val, signal)
if otherUnc and not setup.noPhotonCR:
addUnc(c, "Other_0p", binname, pName, 0.001,
expected.val, signal)
addUnc(c, "Other_norm", binname, pName, otherUnc,
expected.val, signal)
# if otherUnc:
# addUnc( c, "Other_norm", binname, pName, otherUnc, expected.val, signal )
if zg:
addUnc(c, "ZG_norm", binname, pName, zg,
expected.val, signal)
# if wg:
# addUnc( c, "WG_norm", binname, pName, wg, expected.val, signal )
if misID4p:
addUnc(c, "MisID_nJet", binname, pName, misID4p,
expected.val, signal)
if zg4p:
addUnc(c, "ZG_nJet", binname, pName, zg4p,
expected.val, signal)
if dy4p:
addUnc(c, "DY_nJet", binname, pName, dy4p,
expected.val, signal)
if wg4p:
addUnc(c, "WG_nJet", binname, pName, wg4p,
expected.val, signal)
# if wjets4p:
# addUnc( c, "WJets_nJet", binname, pName, zg4p, expected.val, signal )
# if misID4p:
# addUnc( c, "misID4p", binname, pName, misID4p, expected.val, signal )
# if hadFakesUnc: # and args.addFakeSF:
# addUnc( c, "Fakes_norm", binname, pName, hadFakesUnc, expected.val, signal )
if any(["fake" in name for name in args.useRegions]):
if lowSieieUnc:
addUnc(c, "fake_lowSieie", binname, pName,
lowSieieUnc, expected.val, signal)
if highSieieUnc:
addUnc(c, "fake_highSieie", binname, pName,
highSieieUnc, expected.val, signal)
if any(fakeCorrUnc) and addFakeUnc:
for i_iso, iso in enumerate(chgIsoRegions):
addUnc(c, "fake_corr_%i" % i_iso, binname,
pName, fakeCorrUnc[i_iso],
expected.val, signal)
# MC bkg stat (some condition to neglect the smaller ones?)
uname = "Stat_%s_%s" % (binname, pName if not (
newPOI_input and signal) else "signal")
if not (newPOI_input and signal):
c.addUncertainty(uname, "lnN")
addUnc(c, uname, binname, pName,
(expected.sigma /
expected.val) if expected.val > 0 else 0.01,
expected.val, signal)
if newPOI_input:
uname = "Stat_%s_%s" % (binname, "signal")
c.addUncertainty(uname, "lnN")
c.specifyExpectation(binname, "signal", sigExp.val)
if sigExp.val:
for key, val in sigUnc.items():
c.specifyUncertainty(
key, binname, "signal",
1 + val.sigma / sigExp.val)
if args.expected or (args.year in [2017, 2018]
and not args.unblind
and setup.signalregion):
c.specifyObservation(binname,
int(round(total_exp_bkg, 0)))
logger.info("Expected observation: %s",
int(round(total_exp_bkg, 0)))
else:
c.specifyObservation(
binname,
int(
observation.cachedObservation(
r, channel, setup).val))
logger.info(
"Observation: %s",
int(
observation.cachedObservation(
r, channel, setup).val))
if mute and total_exp_bkg <= 0.01:
c.muted[binname] = True
# Flat luminosity uncertainty
c.addUncertainty("Lumi", "lnN")
c.specifyFlatUncertainty("Lumi", 1.026)
cardFileNameTxt = c.writeToFile(cardFileNameTxt)
cardFileNameShape = c.writeToShapeFile(cardFileNameShape)
cardFileName = cardFileNameTxt if args.useTxt else cardFileNameShape
else:
logger.info("File %s found. Reusing." % cardFileName)
cardFileNameShape = cardFileNameShape.replace('.root', 'Card.txt')
cardFileName = cardFileNameTxt if args.useTxt else cardFileNameShape
sConfig = "_".join(configlist)
nll = c.calcNLL(cardFileName)
nll_prefit = nll['nll0']
nll_postfit = nll['nll_abs']
NLL = nll['nll']
if nll_prefit is None or abs(nll_prefit) > 10000 or abs(nll_prefit) < 1e-5:
nll_prefit = 999
if nll_postfit is None or abs(nll_postfit) > 10000 or abs(
nll_postfit) < 1e-5:
nll_postfit = 999
nllCache.add(sConfig, NLL, overwrite=True)
print NLL
allPhotonRegions = allRegions[
args.controlRegion]["inclRegion"] + allRegions[
args.controlRegion]["regions"] if photonSelection else allRegions[
args.controlRegion]["regions"]
allPhotonRegions = allRegions[args.controlRegion]["inclRegion"]
setup = Setup(year=args.year,
photonSelection=photonSelection
and not "QCD" in args.selectEstimator,
checkOnly=args.checkOnly,
runOnLxPlus=args.runOnLxPlus
) #photonselection always false for qcd estimate
# Select estimate
if args.selectEstimator == "Data":
estimate = DataObservation(name="Data",
process=setup.processes["Data"],
cacheDir=setup.defaultCacheDir())
estimate.isData = True
else:
estimators = EstimatorList(setup, processes=[args.selectEstimator])
estimate = getattr(estimators, args.selectEstimator)
estimate.isData = False
if not estimate:
logger.warning(args.selectEstimator + " not known")
sys.exit(0)
setup = setup.sysClone(parameters=parameters)
def wrapper(arg):