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, setup, overwrite=False, checkOnly=True)
if args.removeNegative and res < 0: res = u_float(0,0)
return est, str(r), cat, channel, res.tuple()
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)
def _kappaMC(self, region, channel, setup, overwrite=False):
param_LsLc = {"addMisIDSF": addSF}
param_LsHc = {"photonIso": "highChgIso", "addMisIDSF": addSF}
param_HsLc = {"photonIso": "highSieie", "addMisIDSF": addSF}
param_HsHc = {"photonIso": "highChgIsohighSieie", "addMisIDSF": addSF}
params_LsLc = copy.deepcopy(setup.parameters)
params_LsHc = copy.deepcopy(setup.parameters)
params_HsLc = copy.deepcopy(setup.parameters)
params_HsHc = copy.deepcopy(setup.parameters)
params_LsLc.update(param_LsLc)
params_LsHc.update(param_LsHc)
params_HsLc.update(param_HsLc)
params_HsHc.update(param_HsHc)
setup_LsLc = setup.sysClone(parameters=params_LsLc)
setup_LsHc = setup.sysClone(parameters=params_LsHc)
setup_HsLc = setup.sysClone(parameters=params_HsLc)
setup_HsHc = setup.sysClone(parameters=params_HsHc)
# estimate = MCBasedEstimate( name="all_mc_e_had" if channel == "e" else "all_mc_mu_had", process=setup.processes["all_mc_e_had" if channel == "e" else "all_mc_mu_had"] )
estimate = MCBasedEstimate(name="all_noQCD_had",
process=setup.processes["all_noQCD_had"])
mcHad_LsLc = estimate.cachedEstimate(region,
channel,
setup_LsLc,
overwrite=overwrite)
mcHad_LsHc = estimate.cachedEstimate(region,
channel,
setup_LsHc,
overwrite=overwrite)
mcHad_HsLc = estimate.cachedEstimate(region,
channel,
setup_HsLc,
overwrite=overwrite)
mcHad_HsHc = estimate.cachedEstimate(region,
channel,
setup_HsHc,
overwrite=overwrite)
print "had", mcHad_LsLc, mcHad_LsHc, mcHad_HsLc, mcHad_HsHc
# no shape correction if any component is 0
if mcHad_LsLc <= 0: return u_float(1)
if mcHad_LsHc <= 0: return u_float(1)
if mcHad_HsLc <= 0: return u_float(1)
if mcHad_HsHc <= 0: return u_float(1)
# create the data-driven factor
mcRatio_Ls = mcHad_LsLc / mcHad_LsHc
mcRatio_Hs = mcHad_HsLc / mcHad_HsHc
return mcRatio_Ls / mcRatio_Hs
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
def JECSystematic(self, region, channel, setup, jes="Total"):
ref = self.cachedEstimate(region, channel, setup)
if ref == 0: return u_float(0,0)
up = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"jes%sUp"%jes}))
down = self.cachedEstimate(region, channel, setup.sysClone({"selectionModifier":"jes%sDown"%jes}))
unc = abs(0.5*(up-down)/ref)
if unc.val == 0:
uncUp = abs((ref-up)/ref)
uncDown = abs((ref-down)/ref)
unc = uncUp if uncUp.val >= uncDown.val else uncDown
if unc.val == 0: return u_float(0,0)
return unc
def writeToCache(self, region, channel, setup, value, signalAddon=None, save=True, overwrite=False, checkOnly=False):
key = self.uniqueKey(region, channel, setup, signalAddon=signalAddon)
if (self.cache and self.cache.contains(key)) and not overwrite:
res = self.cache.get(key)
# if res.val != value.val: print "Warning, caches estimate not equal to input value: have %s, got %s"%(res, value)
# logger.debug( "Loading cached %s result for %r : %r"%(self.name, key, res) )
elif self.cache and not checkOnly:
_res = self.cache.add( key, value, overwrite=True )
res = value
logger.debug( "Adding cached %s result for %r : %r" %(self.name, key, res) )
else:
res = u_float(-1,0)
return res if res >= 0 or checkOnly else u_float(0,0)
def convertLine(line):
# inclusive & 4134.95 $\pm$ 77.81 & \textbf{592.30 $\pm$ 27.19} & \textbf{587.32 $\pm$ 12.50}
# & 6494.72 $\pm$ 96.86 & \textbf{926.98 $\pm$ 34.25} & \textbf{951.09 $\pm$ 16.20}
l = line.replace(" ", "").split("&")
header = l[0] if l[0] else None
norm = u_float(float(l[1].split("$")[0]), float(l[1].split("$")[2]))
dd = l[2].split("{")[1].split("}")[0]
ddfakes = u_float(float(dd.split("$")[0]), float(dd.split("$")[2]))
mc = l[3].split("{")[1].split("}")[0]
mcfakes = u_float(float(mc.split("$")[0]), float(mc.split("$")[2]))
return header, norm, ddfakes, mcfakes
def cachedEstimate(self, region, channel, setup, signalAddon=None, save=True, overwrite=False, checkOnly=False):
key = self.uniqueKey(region, channel, setup, signalAddon=signalAddon)
if (self.cache and self.cache.contains(key)) and not overwrite:
res = self.cache.get(key)
logger.debug( "Loading cached %s result for %r : %r"%(self.name, key, res) )
elif self.cache and not checkOnly:
logger.debug( "Calculating %s result for %r"%(self.name, key) )
res = self._estimate( region, channel, setup, signalAddon=signalAddon, overwrite=overwrite )
_res = self.cache.add( key, res, overwrite=True )
logger.debug( "Adding cached %s result for %r : %r" %(self.name, key, res) )
elif not checkOnly:
res = self._estimate( region, channel, setup, signalAddon=signalAddon, overwrite=overwrite)
else:
res = u_float(-1,0)
return res if res >= 0 or checkOnly else u_float(0,0)
def cachedFakeFactor(self, region, channel, setup, overwrite=False, checkOnly=False):
key = self.uniqueKey(region, channel, setup)
if (self.helperCache and self.helperCache.contains(key)) and not overwrite:
res = self.helperCache.get(key)
logger.debug( "Loading cached %s result for %r : %r"%(self.name, key, res) )
elif self.helperCache and not checkOnly:
logger.debug( "Calculating %s result for %r"%(self.name, key) )
res = self._dataDrivenFakeCorrectionFactor( region, channel, setup, overwrite=overwrite )
_res = self.helperCache.add( key, res, overwrite=True )
logger.debug( "Adding cached transfer factor for %r : %r" %(key, res) )
elif not checkOnly:
res = self._dataDrivenFakeCorrectionFactor( region, channel, setup, overwrite=overwrite )
else:
res = u_float(-1,0)
return res if res > 0 or checkOnly else u_float(0,0)
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 observation(self, region, channel, setup, overwrite):
if setup.nJet == "3p":
setup4p = setup.sysClone(parameters={"nJet": (4, -1)})
setup3 = setup.sysClone(parameters={"nJet": (3, 3)})
return sum([
self.cachedEstimate(region, channel, s, overwrite=overwrite)
for s in [setup3, setup4p]
])
if channel == "all":
return sum([
self.cachedEstimate(region, c, setup, overwrite=overwrite)
for c in lepChannels
])
elif channel == "SFtight":
return sum([
self.cachedEstimate(region, c, setup, overwrite=overwrite)
for c in dilepChannels
])
else:
preSelection = setup.preselection("Data", channel=channel)
# cut = "&&".join([region.cutString(setup.sys['selectionModifier']), preSelection['cut']])
cut = "&&".join([region.cutString(), preSelection['cut']])
logger.debug("Using cut %s" % cut)
weight = preSelection['weightStr']
if hasattr(setup, "blinding") and setup.blinding:
weight += "*" + setup.blinding
return u_float(**self.process.getYieldFromDraw(
selectionString=cut, weightString=weight))
def getEstimateFromCard(cardFile, estimateName, binName, postfix=''):
res = u_float(0)
uncName = 'Stat_' + binName + '_' + estimateName+postfix
with open(cardFile) as f:
binList = False
estimateList = False
for line in f:
if len(line.split())==0: continue
if line.split()[0] == "bin":
if not binList: binList = True
else: binList = line.split()[1:]
if line.split()[0] == "process":
if not estimateList: estimateList = line.split()[1:]
if line.split()[0] == "rate":
for i in range(len(binList)):
if binList[i] == binName and estimateList[i]==estimateName:
try: res.val = float(line.split()[1:][i])
except: res.val = 0
#return float(line.split()[1:][i])
if line.split()[0] != uncName: continue
for i in range(len(binList)):
if binList[i] == binName and estimateList[i]==estimateName:
try: res.sigma = (float(line.split()[2:][i])-1)*res.val
except: res.sigma = 0.
return res
def xsec( self, modified_couplings=None, overwrite=False, skip=False ):
key = self.getKey( modified_couplings )
# Do we have the x-sec?
if self.xsecDB.contains(key) and not overwrite:
logger.debug( "Found x-sec %s for key %r. Do nothing.", self.xsecDB.get(key), key )
return self.xsecDB.get(key)
elif skip:
return u_float(0)
else:
print "Trying to get xsec"
self.__initialize( modified_couplings )
logger.info( "Calculating x-sec" )
# rerun MG to obtain the correct x-sec (with more events)
with open( os.path.join( self.processTmpDir, 'Cards/run_card.dat' ), 'a' ) as f:
f.write( ".false. = gridpack\n" )
logger.info( "Calculate x-sec: Calling bin/generate_events" )
output = subprocess.check_output( [ os.path.join( self.processTmpDir, 'bin/generate_events' ) , '-f' ] )
for i in range(10):
try:
output = subprocess.check_output( [ os.path.join( self.processTmpDir, 'bin/generate_events' ) , '-f' ] )
m = re.search( "Cross-section :\s*(.*) \pb", output )
logger.info( "x-sec: {} pb".format(m.group(1)) )
break
except ValueError:
logger.info("Encountered problem during the MG run. Restarting.")
xsec_ = u_float.fromString(m.group(1))
self.xsecDB.add( key, xsec_, overwrite=True )
logger.info( "Done!" )
return xsec_
def yieldFromCache(self, setup, process, c, selectionString, weightString, overwrite=False):
s = (process, c, selectionString, weightString)
if self.helperCache and self.helperCache.contains(s) and not overwrite:
return self.helperCache.get(s)
else:
yieldFromDraw = u_float(**setup.processes[process].getYieldFromDraw(selectionString, weightString))
if self.helperCache: self.helperCache.add(s, yieldFromDraw, overwrite=True)
return yieldFromDraw
def mult(self, l):
if len(l) > 0:
res = l[0]
for i in l[1:]:
res = res * i
else:
res = u_float(1)
return res
def cachedQCDMCTransferFactor(self, channel, setup, qcdUpdates=None, save=True, overwrite=False, checkOnly=False):
key = self.uniqueKey("regionQCDMC", channel, setup, qcdUpdates=qcdUpdates)
if (self.tfCache and self.tfCache.contains(key)) and not overwrite:
res = self.tfCache.get(key)
logger.debug( "Loading cached %s result for %r : %r"%(self.name, key, res) )
elif self.tfCache and not checkOnly:
logger.debug( "Calculating %s result for %r"%(self.name, key) )
# res = self._dataDrivenTransferFactor( channel, setup, qcdUpdates=qcdUpdates, overwrite=overwrite )
res = self._transferFactor( channel, setup, qcdUpdates=qcdUpdates, overwrite=overwrite )
_res = self.tfCache.add( key, res, overwrite=True )
logger.debug( "Adding cached transfer factor for %r : %r" %(key, res) )
elif not checkOnly:
# res = self._dataDrivenTransferFactor( channel, setup, qcdUpdates=qcdUpdates, overwrite=overwrite )
res = self._transferFactor( channel, setup, qcdUpdates=qcdUpdates, overwrite=overwrite )
else:
res = u_float(-1,0)
return res if res > 0 or checkOnly else u_float(0,0)
def _dataDrivenFakes(self, region, channel, setup, overwrite=False):
dataFakes = self._fakesData(region,
channel,
setup,
overwrite=overwrite)
if dataFakes <= 0: return u_float(0)
kappaData = self._kappaData(region,
channel,
setup,
overwrite=overwrite)
if kappaData <= 0: return u_float(0)
# no shape correction if 0
kappaMC = self._kappaMC(region, channel, setup, overwrite=overwrite)
if kappaMC <= 0: kappaMC = u_float(1)
return dataFakes * kappaData * kappaMC
def cachedObservation(self,
region,
channel,
setup,
save=True,
overwrite=False,
checkOnly=False):
key = self.uniqueKey(region, channel, setup)
if (self.cache and self.cache.contains(key)) and not overwrite:
res = self.cache.get(key)
logger.debug("Loading cached %s result for %r : %r" %
(self.name, key, res))
elif self.cache and not checkOnly:
res = self.observation(region, channel, setup, overwrite)
_res = self.cache.add(key, res, overwrite=True)
logger.debug("Adding cached %s result for %r" % (self.name, key))
elif not checkOnly:
res = self.observation(region, channel, setup, overwrite)
else:
res = u_float(-1, 0)
return res if res >= 0 or checkOnly else u_float(0, 0)
def wrapper(arg):
r, channel, setup, (ctZ, ctZI, ctW, ctWI) = arg
EFTparams = ["ctZ", str(ctZ), "ctZI",
str(ctZI)] #, "ctW", str(ctW), "ctWI", str(ctWI) ]
params = {"ctZ": ctZ, "ctZI": ctZI} #, "ctW":ctW, "ctWI":ctWI }
key = (args.controlRegion, str(r), channel, "_".join(EFTparams))
keymu = (args.controlRegion.replace("All",
""), str(r), "e", "_".join(EFTparams))
keye = (args.controlRegion.replace("All",
""), str(r), "mu", "_".join(EFTparams))
print key
print keymu
print keye
print cache.contains(key), cache.contains(keymu), cache.contains(keye)
if cache.contains(key) and not args.overwrite:
res = cache.get(key)
elif not cache.contains(key) and args.checkOnly:
res = {"val": -1, "sigma": 0}
else:
if channel == "all" and cache.contains(keye) and cache.contains(
keymu) and not args.overwrite:
res = u_float(cache.get(keye))
print "e", res
resmu = u_float(cache.get(keymu))
print "mu", resmu
res += u_float(cache.get(keymu))
else:
selection = setup.genSelection("MC",
channel=channel,
**setup.defaultParameters())["cut"]
selection = "&&".join([selection, r.cutString()])
weightString = "ref_weight*(" + get_weight_string(params) + ")"
print selection
print weightString
res = eftSample.getYieldFromDraw(selectionString=selection,
weightString=weightString)
print key, res
cache.add(key, res, overwrite=True)
# print "done", res
return (key, res)
def getObservationFromCard(cardFile, binName):
res = u_float(0)
with open(cardFile) as f:
binList = False
estimateList = False
for line in f:
if len(line.split())==0: continue
if line.split()[0] == "bin":
binList = line.split()[1:]
if line.split()[0] == "observation":
for i in range(len(binList)):
if binList[i] == binName:# and estimateList[i]==estimateName:
try: res.val = float(line.split()[1:][i])
except: res.val = 0
return res
def wrapper(arg):
# INFO: fakeFactor = fakesData / fakesMC * kappaData * kappaMC
key, subkey, r, channel, setup = arg
logger.info(
"Running estimate for region %s, channel %s in setup %s" %
(r, channel, args.controlRegion if args.controlRegion else "None"))
# fakeFactor = estimate.cachedFakeFactor(r, channel, setup, checkOnly=True).val
kappaData = estimate._kappaData(r, channel, setup)
kappaMC = estimate._kappaMC(r, channel, setup)
fakesData = estimate._fakesData(r, channel, setup)
fakesMC = estimate._fakesMC(r, channel, setup)
ddfakes = fakesData * kappaMC * kappaData
sf = ddfakes / fakesMC if fakesMC.val > 0 else u_float(0)
return (key, subkey, channel, fakesData.tuple(), kappaData.tuple(),
kappaMC.tuple(), ddfakes.tuple(), fakesMC.tuple(), sf.tuple())
def _dataDrivenFakeCorrectionFactor(self,
region,
channel,
setup,
overwrite=False):
# not used anymore, gives some kind of fake SF which could be compared to Nabin
# factor to multiply with non-prompt mc yield for data-driven estimation
mcFakes = self._fakesMC(region, channel, setup, overwrite=overwrite)
if mcFakes <= 0: return u_float(0)
ddFakes = self._dataDrivenFakes(region,
channel,
setup,
overwrite=overwrite)
return ddFakes / mcFakes
def getPartialSF( self, effMap, pt, eta, effMap_unc=None ):
if self.year == 2016:
bin = effMap.FindBin(eta,pt)
elif self.year == 2017:
bin = 1 if abs(eta) < 1.479 else 4
elif self.year == 2018:
bin = effMap.FindBin(pt,eta)
sf = effMap.GetBinContent( bin )
if self.year == 2018:
err = effMap_unc.GetBinContent( bin )
else:
err = effMap.GetBinError( bin )
return u_float(sf, err)
def getTotalPostFitUncertainty(cardFile, binName):
with open(cardFile) as f:
binList = False
estimateList = False
ind = []
uncertainties = False
uncDict = {}
totalUnc = {}
for line in f:
if len(line.split())==0: continue
if line.split()[0] == "bin":
if not binList: binList = True
else:
binList = line.split()[1:]
for i,b in enumerate(binList):
if b == binName:
ind.append(i)
if line.split()[0] == "process":
if not estimateList:
estimateList = line.split()[1:]
estimateList = estimateList[ind[1]:ind[-1]+1]
if line.split()[0] == "rate":
estimates = line.split()[1:]
estimates = [float(a) for a in estimates[ind[1]:ind[-1]+1]]
if line.split()[0] == 'PU': uncertainties = True
if uncertainties:
uncDict[line.split()[0]] = [ 0 if a =='-' else float(a)-1 for a in line.split()[2:][ind[1]:ind[-1]+1] ]
nuisanceFile = cardFile.replace('.txt','_nuisances_full.txt')
for unc in uncDict.keys():
totalUnc[unc] = 0
for i in range(len(estimates)):
#totalUnc[unc] += uncDict[unc][i] * estimates[i] * ( 1 + getPull(nuisanceFile,unc)*uncDict[unc][i] ) #* getConstrain(nuisanceFile, unc)
totalUnc[unc] += uncDict[unc][i] * estimates[i] * math.exp( getPull(nuisanceFile,unc)*uncDict[unc][i] )
#totalUnc[unc] += (uncDict[unc][i] * estimates[i] * math.exp( getPull(nuisanceFile,unc)*uncDict[unc][i] ))**2
#totalUnc[unc] = math.sqrt(totalUnc[unc])
total = 0
for unc in totalUnc.keys():
total += totalUnc[unc]**2
estimatesPostFit = []
for e in estimateList:
res = getEstimateFromCard(cardFile, e, binName)
res = applyAllNuisances(cardFile, e, res, binName)
estimatesPostFit.append(res.val)
estimatePostFit = sum(estimatesPostFit)
return u_float(estimatePostFit,math.sqrt(total))
def getSF(self, pdgId, pt, eta, sigma=0):
if abs(pdgId) not in [11, 13]:
raise Exception("Lepton SF for PdgId %i not known" % pdgId)
if self.year == 2016 and abs(pdgId) == 13:
if pt >= 120: pt = 119
if pt <= 20: pt = 21
if eta >= 2.4: eta = 2.39
elif eta <= -2.4: eta = -2.39
sf_BCDEF = self.mult([
self.getPartialSF(effMap, pt, eta) for effMap in self.mu_BCDEF
]).val
sf_GH = self.mult([
self.getPartialSF(effMap, pt, eta) for effMap in self.mu_GH
]).val
sf = (sf_BCDEF * lumiRatio2016_BCDEF) + (sf_GH * lumiRatio2016_GH
) # Scale SF by lumiRatio
sigma = 0.03 # Recommendation for Moriond17
sf = u_float(sf, sigma)
else:
if abs(pdgId) == 13:
absEta = abs(eta)
if pt >= 120: pt = 119
if pt <= 20: pt = 21
if absEta >= 2.4: absEta = 2.39
sf = self.mult([
self.getPartialSF(effMap, pt, absEta, reversed=True)
for effMap in self.mu
])
elif abs(pdgId) == 11:
if pt >= 500: pt = 499
if pt <= 10: pt = 11
if eta >= 2.5: eta = 2.49
elif eta <= -2.5: eta = -2.49
sf = self.mult([
self.getPartialSF(effMap, pt, eta) for effMap in self.ele
])
return (1 + sf.sigma * sigma) * sf.val
def _fakesMC(self, region, channel, setup, overwrite=False):
param_LsLc = {"addMisIDSF": addSF}
params_LsLc = copy.deepcopy(setup.parameters)
params_LsLc.update(param_LsLc)
setup_LsLc = setup.sysClone(parameters=params_LsLc)
estimate = MCBasedEstimate(
name="all_mc_e_had" if channel == "e" else "all_mc_mu_had",
process=setup.processes["all_mc_e_had" if channel ==
"e" else "all_mc_mu_had"])
# estimate = MCBasedEstimate( name="all_noQCD_had", process=setup.processes["all_noQCD_had"] )
mcHad_LsLc = estimate.cachedEstimate(region,
channel,
setup_LsLc,
overwrite=overwrite)
if mcHad_LsLc <= 0: return u_float(0)
return mcHad_LsLc
def getValFrom1BinnedHistOrGraph( hist ):
"""
if input is AsymTGraph, the average of errors is given
"""
if type(hist) in [ ROOT.TH1F , ROOT.TH1D ]:
v = hist.GetBinContent(1)
e = hist.GetBinError(1)
if type(hist) in [ ROOT.TH2F , ROOT.TH2D ]:
v = hist.GetBinContent(1,1)
e = hist.GetBinError(1,1)
if type(hist) in [ROOT.TGraphAsymmErrors]:
v = hist.GetY()[0]
el = hist.GetEYlow()[0]
eh = hist.GetEYhigh()[0]
if el and eh:
e = sum( [abs(el), abs(eh)] )/2.
else:
e = max(abs(el),abs(eh))
#print hist , (v,el,eh)
#return (v, el, eh )
return u_float(v,e)
# create dictionary structure
yields = {}
signal = {}
for estName in [e.name for e in allEstimators] + [
"MC", "MC_gen", "MC_misID", "MC_np", "MC_PU", "MC_fake", "MC_hp"
]:
est = estName.split("_")[0]
yields[est] = {}
for i_region, region in enumerate(allPhotonRegions):
yields[est][ptDict[str(region)]] = {}
signal[ptDict[str(region)]] = {}
for i_cat, cat in enumerate(
["gen", "misID", "np", "PU", "fake", "hp", "all"]):
yields[est][ptDict[str(region)]][cat] = {}
for i_mode, mode in enumerate(channels + [allMode]):
yields[est][ptDict[str(region)]][cat][mode] = u_float(0)
signal[ptDict[str(region)]][mode] = u_float(0)
jobs = []
for estimator in allEstimators:
cat = estimator.name.split("_")[-1] if estimator.name.split("_")[-1] in [
"gen", "misID", "np", "hp", "fake", "PU"
] else "all"
est = estimator.name.split("_")[0]
for i_region, region in enumerate(allPhotonRegions):
for i_mode, mode in enumerate(channels):
jobs.append((region, mode, setup, estimator, cat, est))
if args.cores > 1:
from multiprocessing import Pool
pool = Pool(processes=args.cores)
def getPartialSF(self, effMap, pt, eta, reversed=False):
x = eta if not reversed else pt
y = pt if not reversed else eta
sf = effMap.GetBinContent(effMap.FindBin(x, y))
err = effMap.GetBinError(effMap.FindBin(x, y))
return u_float(sf, err)
def _estimate(self,
region,
channel,
setup,
signalAddon=None,
overwrite=False):
''' Concrete implementation of abstract method 'estimate' as defined in Systematic
'''
logger.debug("MC prediction for %s channel %s" % (self.name, channel))
if setup.nJet == "3p":
setup4p = setup.sysClone(parameters={"nJet": (4, -1)})
setup3 = setup.sysClone(parameters={"nJet": (3, 3)})
return sum([
self.cachedEstimate(region,
channel,
s,
signalAddon=signalAddon,
overwrite=overwrite)
for s in [setup3, setup4p]
])
if channel == 'all':
# 'all' is the total of all contributions
return sum([
self.cachedEstimate(region,
c,
setup,
signalAddon=signalAddon,
overwrite=overwrite) for c in lepChannels
])
elif channel == 'SFtight':
# 'SFtight' is the total of mumutight and eetight contributions
return sum([
self.cachedEstimate(region,
c,
setup,
signalAddon=signalAddon,
overwrite=overwrite) for c in dilepChannels
])
else:
# change the sample processed if there is a signal addon like TuneUp
if signalAddon:
if self.name.split("_")[-1] in [
"gen", "misID", "had", "hp", "fake", "PU"
]:
name = "_".join(
self.name.split("_")[:-1] +
[signalAddon, self.name.split("_")[-1]])
else:
name = "_".join([self.name, signalAddon])
setattr(self, "process" + signalAddon, setup.processes[name])
# preSelection = setup.preselection('MC' if not signalAddon else "MCpTincl", channel=channel, processCut=self.processCut)
preSelection = setup.preselection('MC',
channel=channel,
processCut=self.processCut)
cuts = [
region.cutString(setup.sys['selectionModifier']),
preSelection['cut']
]
# if setup.parameters["photonIso"] and setup.parameters["photonIso"] != "lowChgIsolowSieie":
# self.processCut = self.processCut.replace("photoncat", "photonhadcat")
# if self.processCut:
# cuts.append( cutInterpreter.cutString(self.processCut) )
# logger.info( "Adding process specific cut %s"%self.processCut )
cut = "&&".join(cuts)
weight = preSelection['weightStr']
logger.debug("Using cut %s and weight %s" % (cut, weight))
# return setup.lumi/1000.*u_float(**getattr(self,"".join(["process",signalAddon if signalAddon else ""])).getYieldFromDraw(selectionString = cut, weightString = weight) )
# print cut, weight
return u_float(**getattr(
self, "".join(["process", signalAddon if signalAddon else ""])
).getYieldFromDraw(selectionString=cut, weightString=weight))
