def cachedTemplate(self, selection, weight='(1)', save=True, overwrite=False): key = { "selection": selection, "weight": weight, "source": self.source_sample.name } if (self.cache and self.cache.contains(key)) and not overwrite: result = self.cache.get(key) logger.info("Loaded MC PU profile from %s" % (self.cache.database_file)) logger.debug("Key used: %s result: %r" % (key, result)) elif self.cache: logger.info("Obtain PU profile for %s" % (key, )) result = self.makeTemplate(selection=selection, weight=weight) if result: result = self.cache.addData(key, result, overwrite=save) logger.info("Adding PU profile to cache for %s : %r" % (key, result)) else: logger.warning( "Couldn't create PU profile to cache for %s : %r" % (key, result)) else: result = self.makeTemplate(selection=selection, weight=weight) return result
def makeUniquePath(): ''' Create unique path in tmp directory ''' from TTGammaEFT.Tools.user import tmp_directory import uuid while True: uniqueDir = uuid.uuid4().hex uniquePath = os.path.join(tmp_directory, uniqueDir) if not os.path.isdir(uniquePath): break logger.warning("Path exists, waiting 0.1 sec.") time.sleep(0.1) return uniquePath
def filler(event): event.run, event.luminosity, event.evt = reader.evt event.weight = lumiweight if reader.position % 100 == 0: logger.info("At event %i/%i", reader.position, reader.nEvents) # EFT weights if options.addReweights: event.nrw = weightInfo.nid lhe_weights = reader.products["lhe"].weights() weights = [] param_points = [] # hyperPoly.initialized = False for weight in lhe_weights: # Store nominal weight (First position!) if weight.id == "rwgt_1": event.rw_nominal = weight.wgt if not weight.id in weightInfo.id: continue pos = weightInfo.data[weight.id] event.rw_w[pos] = weight.wgt weights += [weight.wgt] interpreted_weight = interpret_weight(weight.id) for var in weightInfo.variables: getattr(event, "rw_" + var)[pos] = interpreted_weight[var] # weight data for interpolation if not hyperPoly.initialized: param_points += [ tuple(interpreted_weight[var] for var in weightInfo.variables) ] # get list of values of ref point in specific order ref_point_coordinates = [ weightInfo.ref_point_coordinates[var] for var in weightInfo.variables ] # Initialize with Reference Point if not hyperPoly.initialized: hyperPoly.initialize(param_points, ref_point_coordinates) coeff = hyperPoly.get_parametrization(weights) event.np = hyperPoly.ndof event.chi2_ndof = hyperPoly.chi2_ndof(coeff, weights) if event.chi2_ndof > 10**-6: logger.warning("chi2_ndof is large: %f", event.chi2_ndof) for n in xrange(hyperPoly.ndof): event.p_C[n] = coeff[n] # lumi weight / w0 event.ref_weight = event.weight / coeff[0] ############################################## ############################################## ############################################## # GEN Particles genPart = reader.products["gp"] # for searching search = GenSearch(genPart) # MET GenMET = { "pt": reader.products["genMET"][0].pt(), "phi": reader.products["genMET"][0].phi() } event.GenMET_pt = GenMET["pt"] event.GenMET_phi = GenMET["phi"] # reco naming event.MET_pt = GenMET["pt"] event.MET_phi = GenMET["phi"] # find heavy objects before they decay GenT = filter(lambda p: abs(p.pdgId()) == 6 and search.isLast(p), genPart) GenTopLep = [] GenWLep = [] GenTopHad = [] GenWHad = [] GenBLep = [] GenBHad = [] GenWs = [] for top in GenT: GenW = [ search.descend(w) for w in search.daughters(top) if abs(w.pdgId()) == 24 ] GenB = [ search.descend(w) for w in search.daughters(top) if abs(w.pdgId()) == 5 ] if GenW: GenW = GenW[0] GenWs.append(GenW) wDecays = [abs(l.pdgId()) for l in search.daughters(GenW)] if 11 in wDecays or 13 in wDecays or 15 in wDecays: GenWLep.append(GenW) if GenB: GenBLep.append(GenB[0]) GenTopLep.append(top) else: GenWHad.append(GenW) if GenB: GenBHad.append(GenB[0]) GenTopHad.append(top) GenTops = map(lambda t: {var: getattr(t, var)() for var in genTopVars}, GenT) GenTops.sort(key=lambda p: -p["pt"]) fill_vector_collection(event, "GenTop", genTopVars, GenTops) GenTopLep = map(lambda t: {var: getattr(t, var)() for var in genTopVars}, GenTopLep) GenTopLep.sort(key=lambda p: -p["pt"]) fill_vector_collection(event, "GenTopLep", genTopVars, GenTopLep) GenTopHad = map(lambda t: {var: getattr(t, var)() for var in genTopVars}, GenTopHad) GenTopHad.sort(key=lambda p: -p["pt"]) fill_vector_collection(event, "GenTopHad", genTopVars, GenTopHad) GenWs = map(lambda t: {var: getattr(t, var)() for var in genWVars}, GenWs) GenWs.sort(key=lambda p: -p["pt"]) fill_vector_collection(event, "GenW", genWVars, GenWs) GenWLep = map(lambda t: {var: getattr(t, var)() for var in genWVars}, GenWLep) GenWLep.sort(key=lambda p: -p["pt"]) fill_vector_collection(event, "GenWLep", genWVars, GenWLep) GenWHad = map(lambda t: {var: getattr(t, var)() for var in genWVars}, GenWHad) GenWHad.sort(key=lambda p: -p["pt"]) fill_vector_collection(event, "GenWHad", genWVars, GenWHad) GenBLep = map(lambda t: {var: getattr(t, var)() for var in genWVars}, GenBLep) GenBLep.sort(key=lambda p: -p["pt"]) fill_vector_collection(event, "GenBLep", genWVars, GenBLep) GenBHad = map(lambda t: {var: getattr(t, var)() for var in genWVars}, GenBHad) GenBHad.sort(key=lambda p: -p["pt"]) fill_vector_collection(event, "GenBHad", genWVars, GenBHad) bPartonsFromTop = [ b for b in filter( lambda p: abs(p.pdgId()) == 5 and p.numberOfMothers() == 1 and abs( p.mother(0).pdgId()) == 6, genPart) ] # genParticles for isolation GenParticlesIso = [ l for l in filter( lambda p: abs(p.pdgId()) not in [12, 14, 16] and p.pt() > 5 and p. status() == 1, genPart) ] GenParticlesIso.sort(key=lambda p: -p.pt()) GenParticlesIso = [{var: getattr(l, var)() for var in genParticleVarsRead} for l in GenParticlesIso] # genLeptons GenLeptonAll = [(search.ascend(l), l) for l in filter( lambda p: abs(p.pdgId()) in [11, 13] and search.isLast(p) and p.status( ) == 1, genPart)] GenLeptonAll.sort(key=lambda p: -p[1].pt()) GenLepton = [] for first, last in GenLeptonAll: mother = first.mother(0) if first.numberOfMothers() > 0 else None grandmother_pdgId = -999 mother_pdgId = -999 if mother: mother_pdgId = mother.pdgId() mother_ascend = search.ascend(mother) grandmother = mother_ascend.mother( 0) if mother.numberOfMothers() > 0 else None if grandmother: grandmother_pdgId = grandmother.pdgId() genLep = {var: getattr(last, var)() for var in genLeptonVarsRead} genLep["motherPdgId"] = mother_pdgId genLep["grandmotherPdgId"] = grandmother_pdgId GenLepton.append(genLep) # Gen photons: particle-level isolated gen photons GenPhotonAll = [(search.ascend(l), l) for l in filter( lambda p: abs(p.pdgId()) == 22 and p.pt() > 1 and search.isLast(p), genPart)] # GenPhotonAll = [ ( search.ascend(l), l ) for l in filter( lambda p: abs( p.pdgId() ) == 22 and search.isLast(p), genPart ) ] GenPhotonAll.sort(key=lambda p: -p[1].pt()) GenPhoton = [] for first, last in GenPhotonAll: mother = first.mother(0) if first.numberOfMothers() > 0 else None grandmother_pdgId = -999 mother_pdgId = -999 if mother: mother_pdgId = mother.pdgId() mother_ascend = search.ascend(mother) grandmother = mother_ascend.mother( 0) if mother.numberOfMothers() > 0 else None if grandmother: grandmother_pdgId = grandmother.pdgId() GenP = {var: getattr(last, var)() for var in genPhotonVarsRead} GenP["motherPdgId"] = mother_pdgId GenP["grandmotherPdgId"] = grandmother_pdgId GenP["status"] = last.status() close_particles = filter( lambda p: p != last and deltaR2( { "phi": last.phi(), "eta": last.eta() }, { "phi": p.phi(), "eta": p.eta() }) < 0.16, search.final_state_particles_no_neutrinos) GenP["relIso04_all"] = sum([p.pt() for p in close_particles], 0) / last.pt() close_particles = filter( lambda p: p != last and deltaR2( { "phi": last.phi(), "eta": last.eta() }, { "phi": p.phi(), "eta": p.eta() }) < 0.09, search.final_state_particles_no_neutrinos) GenP["relIso03_all"] = sum([p.pt() for p in close_particles], 0) / last.pt() GenPhoton.append(GenP) # Jets GenJetAll = list(filter(genJetId, reader.products["genJets"])) GenJetAll.sort(key=lambda p: -p.pt()) # Filter genJets GenJet = map(lambda t: {var: getattr(t, var)() for var in genJetVarsRead}, GenJetAll) # BJets GenBJet = [b for b in filter(lambda p: abs(p.pdgId()) == 5, genPart)] for GenJ in GenJet: GenJ["isBJet"] = min( [999] + [deltaR2(GenJ, { "eta": b.eta(), "phi": b.phi() }) for b in GenBJet]) < 0.16 # GenJ["parton"] = [ p.pdgId() for p in filter( lambda x: abs( x.pdgId() ) not in [12,14,16] and x.status() == 1, genPart ) if deltaR2( GenJ, {"eta":p.eta(), "phi":p.phi() } ) < 0.16 ] # GenJ["parton"] = [ p.pdgId() for p in filter( lambda x: abs( x.pdgId() ) not in [12,14,16], genPart ) if deltaR2( GenJ, {"eta":p.eta(), "phi":p.phi() } ) < 0.16 ] # print GenJ["parton"] # gen b jets GenBJet = list(filter(lambda j: j["isBJet"], GenJet)) # store minimum DR to jets for GenP in GenPhoton: GenP["photonJetdR"] = min([999] + [deltaR(GenP, j) for j in GenJet]) GenP["photonLepdR"] = min([999] + [deltaR(GenP, j) for j in GenLepton]) GenP["photonAlldR"] = min([999] + [ deltaR(GenP, j) for j in GenParticlesIso if abs(GenP["pt"] - j["pt"]) > 0.01 and j["pdgId"] != 22 ]) fill_vector_collection(event, "GenPhoton", genPhotonVars, filter(lambda p: p["pt"] >= 5, GenPhoton)) fill_vector_collection(event, "GenLepton", genLeptonVars, GenLepton) fill_vector_collection(event, "GenJet", genJetVars, GenJet) fill_vector_collection(event, "GenBJet", genJetVars, GenBJet) event.nGenElectron = len(filter(lambda l: abs(l["pdgId"]) == 11, GenLepton)) event.nGenMuon = len(filter(lambda l: abs(l["pdgId"]) == 13, GenLepton)) event.nGenLepton = len(GenLepton) event.nGenPhoton = len(filter(lambda p: p["pt"] >= 5, GenPhoton)) event.nGenBJet = len(GenBJet) event.nGenJets = len(GenJet) event.nGenBJet = len(GenBJet) ############################################## ############################################## ############################################## # Analysis specific variables for il, genL in enumerate(GenLepton): if abs(genL["motherPdgId"]) not in [11, 13, 15, 23, 24, 25]: continue for genP in GenPhoton: if deltaR(genL, genP) < 0.1: dressedL = get4DVec(GenLepton[il]) + get4DVec(genP) GenLepton[il]["pt"] = dressedL.Pt() GenLepton[il]["eta"] = dressedL.Eta() GenLepton[il]["phi"] = dressedL.Phi() # no meson mother GenLeptonCMSUnfold = list( filter( lambda l: abs(l["motherPdgId"]) in [11, 13, 15, 23, 24, 25] and genLeptonSel_CMSUnfold(l), GenLepton)) GenLeptonATLASUnfold = list( filter( lambda l: abs(l["motherPdgId"]) in [11, 13, 15, 23, 24, 25] and genLeptonSel_ATLASUnfold(l), GenLepton)) GenPhotonCMSUnfold = list( filter(lambda p: genPhotonSel_CMSUnfold(p) and p["status"] == 1, GenPhoton)) GenPhotonEECMSUnfold = list( filter(lambda p: genPhotonEESel_CMSUnfold(p) and p["status"] == 1, GenPhoton)) GenPhotonATLASUnfold = list( filter(lambda p: genPhotonSel_ATLASUnfold(p) and p["status"] == 1, GenPhoton)) GenJetCMSUnfold = list(filter(lambda j: genJetSel_CMSUnfold(j), GenJet)) GenJetATLASUnfold = list(filter(lambda j: genJetSel_ATLASUnfold(j), GenJet)) GenBJetCMSUnfold = list(filter(lambda j: genJetSel_CMSUnfold(j), GenBJet)) GenBJetATLASUnfold = list( filter(lambda j: genJetSel_ATLASUnfold(j), GenBJet)) for GenP in GenPhotonCMSUnfold: GenP["photonJetdR"] = min([999] + [deltaR(GenP, j) for j in GenJetCMSUnfold]) GenP["photonLepdR"] = min( [999] + [deltaR(GenP, j) for j in GenLeptonCMSUnfold]) GenP["photonAlldR"] = min([999] + [ deltaR(GenP, j) for j in GenParticlesIso if abs(GenP["pt"] - j["pt"]) > 0.01 and j["pdgId"] != 22 ]) for GenP in GenPhotonEECMSUnfold: GenP["photonJetdR"] = min([999] + [deltaR(GenP, j) for j in GenJetCMSUnfold]) GenP["photonLepdR"] = min( [999] + [deltaR(GenP, j) for j in GenLeptonCMSUnfold]) GenP["photonAlldR"] = min([999] + [ deltaR(GenP, j) for j in GenParticlesIso if abs(GenP["pt"] - j["pt"]) > 0.01 and j["pdgId"] != 22 ]) for GenP in GenPhotonATLASUnfold: GenP["photonJetdR"] = min([999] + [deltaR(GenP, j) for j in GenJetATLASUnfold]) GenP["photonLepdR"] = min( [999] + [deltaR(GenP, j) for j in GenLeptonATLASUnfold]) GenP["photonAlldR"] = min([999] + [ deltaR(GenP, j) for j in GenParticlesIso if abs(GenP["pt"] - j["pt"]) > 0.01 and j["pdgId"] != 22 ]) # Isolated GenPhotonCMSUnfold = filter(lambda g: g["photonAlldR"] > 0.1, GenPhotonCMSUnfold) GenPhotonCMSUnfold = filter( lambda g: abs(g["grandmotherPdgId"]) in range(37) + [2212] and abs(g[ "motherPdgId"]) in range(37) + [2212], GenPhotonCMSUnfold) GenPhotonEECMSUnfold = filter(lambda g: g["photonAlldR"] > 0.1, GenPhotonEECMSUnfold) GenPhotonEECMSUnfold = filter( lambda g: abs(g["grandmotherPdgId"]) in range(37) + [2212] and abs(g[ "motherPdgId"]) in range(37) + [2212], GenPhotonEECMSUnfold) GenPhotonATLASUnfold = filter(lambda g: g["relIso03_all"] < 0.1, GenPhotonATLASUnfold) GenPhotonATLASUnfold = filter( lambda g: abs(g["grandmotherPdgId"]) in range(37) + [2212] and abs(g[ "motherPdgId"]) in range(37) + [2212], GenPhotonATLASUnfold) for GenJ in GenJetATLASUnfold: GenJ["jetPhotondR"] = min( [999] + [deltaR(GenJ, p) for p in GenPhotonATLASUnfold]) GenJ["jetLepdR"] = min([999] + [deltaR(GenJ, p) for p in GenLeptonATLASUnfold]) for GenJ in GenBJetATLASUnfold: GenJ["jetPhotondR"] = min( [999] + [deltaR(GenJ, p) for p in GenPhotonATLASUnfold]) GenJ["jetLepdR"] = min([999] + [deltaR(GenJ, p) for p in GenLeptonATLASUnfold]) for i_j, GenJ in enumerate(GenJetCMSUnfold): GenJ["jetPhotondR"] = min( [999] + [deltaR(GenJ, p) for p in GenPhotonCMSUnfold]) GenJ["jetLepdR"] = min([999] + [deltaR(GenJ, p) for p in GenLeptonCMSUnfold]) # GenJ["jetJetdR"] = min( [999] + [ deltaR( GenJ, p ) for i_p, p in enumerate(GenJetCMSUnfold) if i_p != i_j ] ) # print GenJ["jetJetdR"] for GenJ in GenBJetCMSUnfold: GenJ["jetPhotondR"] = min( [999] + [deltaR(GenJ, p) for p in GenPhotonCMSUnfold]) GenJ["jetLepdR"] = min([999] + [deltaR(GenJ, p) for p in GenLeptonCMSUnfold]) GenJetEECMSUnfold = copy.deepcopy(GenJetCMSUnfold) for GenJ in GenJetEECMSUnfold: GenJ["jetPhotondR"] = min( [999] + [deltaR(GenJ, p) for p in GenPhotonEECMSUnfold]) GenBJetEECMSUnfold = copy.deepcopy(GenBJetCMSUnfold) for GenJ in GenBJetEECMSUnfold: GenJ["jetPhotondR"] = min( [999] + [deltaR(GenJ, p) for p in GenPhotonEECMSUnfold]) # CMS Unfolding cleaning GenPhotonCMSUnfold = filter(lambda g: g["photonLepdR"] > 0.4, GenPhotonCMSUnfold) GenJetCMSUnfold = filter(lambda g: g["jetPhotondR"] > 0.1, GenJetCMSUnfold) GenBJetCMSUnfold = filter(lambda g: g["jetPhotondR"] > 0.1, GenBJetCMSUnfold) GenJetCMSUnfold = filter(lambda g: g["jetLepdR"] > 0.4, GenJetCMSUnfold) GenBJetCMSUnfold = filter(lambda g: g["jetLepdR"] > 0.4, GenBJetCMSUnfold) GenPhotonEECMSUnfold = filter(lambda g: g["photonLepdR"] > 0.1, GenPhotonEECMSUnfold) GenJetEECMSUnfold = filter(lambda g: g["jetPhotondR"] > 0.1, GenJetEECMSUnfold) GenBJetEECMSUnfold = filter(lambda g: g["jetPhotondR"] > 0.1, GenBJetEECMSUnfold) GenJetEECMSUnfold = filter(lambda g: g["jetLepdR"] > 0.4, GenJetEECMSUnfold) GenBJetEECMSUnfold = filter(lambda g: g["jetLepdR"] > 0.4, GenBJetEECMSUnfold) # ATLAS Unfolding cleaning GenPhotonATLASUnfold = filter(lambda g: g["photonLepdR"] > 1.0, GenPhotonATLASUnfold) GenJetATLASUnfold = filter(lambda g: g["jetPhotondR"] > 0.4, GenJetATLASUnfold) GenBJetATLASUnfold = filter(lambda g: g["jetPhotondR"] > 0.4, GenBJetATLASUnfold) GenJetATLASUnfold = filter(lambda g: g["jetLepdR"] > 0.4, GenJetATLASUnfold) GenBJetATLASUnfold = filter(lambda g: g["jetLepdR"] > 0.4, GenBJetATLASUnfold) GenPhotonCMSUnfold.sort(key=lambda p: -p["pt"]) genP0 = (GenPhotonCMSUnfold[:1] + [None])[0] if genP0: fill_vector(event, "GenPhotonCMSUnfold0", genPhotonVars, genP0) if genP0: fill_vector(event, "PhotonGood0", genPhotonVars, genP0) if genP0: fill_vector(event, "PhotonNoChgIsoNoSieie0", genPhotonVars, genP0) GenPhotonEECMSUnfold.sort(key=lambda p: -p["pt"]) genP0 = (GenPhotonEECMSUnfold[:1] + [None])[0] if genP0: fill_vector(event, "PhotonEEGood0", genPhotonVars, genP0) GenPhotonATLASUnfold.sort(key=lambda p: -p["pt"]) genP0 = (GenPhotonATLASUnfold[:1] + [None])[0] if genP0: fill_vector(event, "GenPhotonATLASUnfold0", genPhotonVars, genP0) GenLeptonCMSUnfold.sort(key=lambda p: -p["pt"]) genL0 = (GenLeptonCMSUnfold[:1] + [None])[0] if genL0: fill_vector(event, "GenLeptonCMSUnfold0", genLeptonVars, genL0) if genL0: fill_vector(event, "LeptonTight0", genLeptonVars, genL0) GenJetCMSUnfold.sort(key=lambda p: -p["pt"]) genJ0, genJ1, genJ2 = (GenJetCMSUnfold[:3] + [None, None, None])[:3] if genJ0: fill_vector(event, "GenJetsCMSUnfold0", genJetVars, genJ0) if genJ1: fill_vector(event, "GenJetsCMSUnfold1", genJetVars, genJ1) if genJ2: fill_vector(event, "GenJetsCMSUnfold2", genJetVars, genJ2) GenBJetCMSUnfold.sort(key=lambda p: -p["pt"]) genB0, genB1 = (GenBJetCMSUnfold[:2] + [None, None])[:2] if genB0: fill_vector(event, "GenBJetCMSUnfold0", genJetVars, genB0) if genB1: fill_vector(event, "GenBJetCMSUnfold1", genJetVars, genB1) event.nGenElectronCMSUnfold = len( filter(lambda l: abs(l["pdgId"]) == 11, GenLeptonCMSUnfold)) event.nGenMuonCMSUnfold = len( filter(lambda l: abs(l["pdgId"]) == 13, GenLeptonCMSUnfold)) event.nGenLeptonCMSUnfold = len(GenLeptonCMSUnfold) event.nGenPhotonCMSUnfold = len(GenPhotonCMSUnfold) event.nGenBJetCMSUnfold = len(GenBJetCMSUnfold) event.nGenJetsCMSUnfold = len(GenJetCMSUnfold) event.nPhotonEEGood = len(GenPhotonEECMSUnfold) event.nGenBJetEECMSUnfold = len(GenBJetEECMSUnfold) event.nGenJetsEECMSUnfold = len(GenJetEECMSUnfold) # use reco naming for easier handling event.nLeptonTight = event.nGenLeptonCMSUnfold event.nElectronTight = event.nGenElectronCMSUnfold event.nMuonTight = event.nGenMuonCMSUnfold event.nLeptonVetoIsoCorr = event.nGenLeptonCMSUnfold event.nJetGood = event.nGenJetsCMSUnfold event.nBTagGood = event.nGenBJetCMSUnfold event.nPhotonGood = event.nGenPhotonCMSUnfold event.nPhotonNoChgIsoNoSieie = event.nGenPhotonCMSUnfold event.nGenElectronATLASUnfold = len( filter(lambda l: abs(l["pdgId"]) == 11, GenLeptonATLASUnfold)) event.nGenMuonATLASUnfold = len( filter(lambda l: abs(l["pdgId"]) == 13, GenLeptonATLASUnfold)) event.nGenLeptonATLASUnfold = len(GenLeptonATLASUnfold) event.nGenPhotonATLASUnfold = len(GenPhotonATLASUnfold) event.nGenBJetATLASUnfold = len(GenBJetATLASUnfold) event.nGenJetsATLASUnfold = len(GenJetATLASUnfold) ############################################## ############################################## ############################################## if GenPhotonCMSUnfold: if GenLeptonCMSUnfold: event.dPhiLepGamma = deltaPhi(GenPhotonCMSUnfold[0]["phi"], GenLeptonCMSUnfold[0]["phi"]) event.dRLepGamma = deltaR(GenPhotonCMSUnfold[0], GenLeptonCMSUnfold[0]) if GenTopHad: event.dPhiTopHadGamma = deltaPhi(GenPhotonCMSUnfold[0]["phi"], GenTopHad[0]["phi"]) event.dRTopHadGamma = deltaR(GenPhotonCMSUnfold[0], GenTopHad[0]) if GenWHad: event.dPhiWHadGamma = deltaPhi(GenPhotonCMSUnfold[0]["phi"], GenWHad[0]["phi"]) event.dRWHadGamma = deltaR(GenPhotonCMSUnfold[0], GenWHad[0]) if GenTopLep: event.dPhiTopLepGamma = deltaPhi(GenPhotonCMSUnfold[0]["phi"], GenTopLep[0]["phi"]) event.dRTopLepGamma = deltaR(GenPhotonCMSUnfold[0], GenTopLep[0]) if GenWLep: event.dPhiWLepGamma = deltaPhi(GenPhotonCMSUnfold[0]["phi"], GenWLep[0]["phi"]) event.dRWLepGamma = deltaR(GenPhotonCMSUnfold[0], GenWLep[0]) if GenBHad: event.dPhiBHadGamma = deltaPhi(GenPhotonCMSUnfold[0]["phi"], GenBHad[0]["phi"]) event.dRBHadGamma = deltaR(GenPhotonCMSUnfold[0], GenBHad[0]) if GenBLep: event.dPhiBLepGamma = deltaPhi(GenPhotonCMSUnfold[0]["phi"], GenBLep[0]["phi"]) event.dRBLepGamma = deltaR(GenPhotonCMSUnfold[0], GenBLep[0]) if GenBLep: if GenWLep: event.dPhiBLepWLep = deltaPhi(GenBLep[0]["phi"], GenWLep[0]["phi"]) event.dRBLepWLep = deltaR(GenBLep[0], GenWLep[0]) if GenBHad: event.dPhiBLepBHad = deltaPhi(GenBLep[0]["phi"], GenBHad[0]["phi"]) event.dRBLepBHad = deltaR(GenBLep[0], GenBHad[0]) if GenWHad: if GenBHad: event.dPhiBHadWHad = deltaPhi(GenBHad[0]["phi"], GenWHad[0]["phi"]) event.dRBHadWHad = deltaR(GenBHad[0], GenWHad[0]) if GenWLep: event.dPhiWLepWHad = deltaPhi(GenWLep[0]["phi"], GenWHad[0]["phi"]) event.dRWLepWHad = deltaR(GenWLep[0], GenWHad[0]) if GenTopLep and GenTopHad: event.dPhiTopLepTopHad = deltaPhi(GenTopLep[0]["phi"], GenTopHad[0]["phi"]) event.dRTopLepTopHad = deltaR(GenTopLep[0], GenTopHad[0]) if GenLeptonCMSUnfold: event.dPhiLepMET = deltaPhi(GenLeptonCMSUnfold[0]["phi"], GenMET["phi"]) event.ht = -999 event.m3 = -999 event.mT = -999 event.mLtight0Gamma = -999 if GenJetCMSUnfold: event.ht = sum([j["pt"] for j in GenJetCMSUnfold]) event.m3 = m3(GenJetCMSUnfold)[0] if GenLeptonCMSUnfold: event.mT = mT(GenLeptonCMSUnfold[0], GenMET) if GenPhotonCMSUnfold: event.mLtight0Gamma = (get4DVec(GenLeptonCMSUnfold[0]) + get4DVec(GenPhotonCMSUnfold[0])).M()
str(uuid.uuid4())) targetPath = os.path.join(directory, "gen" + postfix, sample.name) # Single file post processing if options.nJobs > 1: n_files_before = len(sample.files) sample = sample.split(options.nJobs)[options.job] n_files_after = len(sample.files) print "Running job %i/%i over %i files from a total of %i." % ( options.job, options.nJobs, n_files_after, n_files_before) logger.info("Running job %i/%i over %i files from a total of %i.", options.job, options.nJobs, n_files_after, n_files_before) if os.path.exists(targetPath) and options.overwrite: if options.nJobs > 1: logger.warning("NOT removing directory %s because nJobs = %i", targetPath, options.nJobs) else: logger.info("Output directory %s exists. Deleting.", targetPath) shutil.rmtree(targetPath, ignore_errors=True) if not os.path.exists(targetPath): try: os.makedirs(targetPath) logger.info("Created output directory %s.", targetPath) except: logger.info("Directory %s already exists.", targetPath) pass if not os.path.exists(output_directory): try: os.makedirs(output_directory)
if f.endswith('.root'): full_filename = os.path.join(dirName, f) if not '_reHadd_' in f: to_skip = False for skip in options.skip: if skip in f: logger.info( "Found skip string %s in %s. Skipping.", skip, f ) to_skip = True break if to_skip: continue isOK = checkRootFile( full_filename, checkForObjects = [options.treeName]) \ if options.treeName is not None else checkRootFile( full_filename ) if isOK: rootFiles.append( f ) else: logger.warning( "File %s does not look OK. Checked for tree: %r", full_filename, options.treeName ) else: logger.info( "Found '_reHadd_' in file %s in %s. Skipping.", full_filename, dirName ) job = [] jobsize = 0 for fname in rootFiles: filename, file_extension = os.path.splitext(fname) n_str = filename.split('_')[-1] if n_str.isdigit(): full_filename = os.path.join(dirName, fname) jobsize += os.path.getsize( full_filename ) job.append( full_filename ) if jobsize>1024**3*options.sizeGB: jobs.append(job) job = [] jobsize = 0
type=str, help="Which sample to plot") args = argParser.parse_args() # Logger import Analysis.Tools.logger as logger import RootTools.core.logger as logger_rt logger = logger.get_logger(args.logLevel, logFile=None) logger_rt = logger_rt.get_logger(args.logLevel, logFile=None) logger.debug("Start run_estimate.py") if args.checkOnly: args.overwrite = False if not args.controlRegion: logger.warning("ControlRegion not known") sys.exit(0) # load and define the EFT sample from TTGammaEFT.Samples.genTuples_TTGamma_EFT_postProcessed import * eftSample = eval(args.sample) #settings for eft reweighting w = WeightInfo(eftSample.reweight_pkl) w.set_order(args.order) variables = w.variables def get_weight_string(parameters): return w.get_weight_string(**parameters)
def __init__(self, model_name, MG260=False): self.model_name = model_name self.__isPreInitialized = False # Load model model_file = os.path.expandvars( "$CMSSW_BASE/python/TTGammaEFT/Generation/parameters.py") logger.info("Loading model %s from file %s", model_name, model_file) try: tmp_module = imp.load_source(model_name, os.path.expandvars(model_file)) self.model = getattr(tmp_module, model_name) except: logger.error("Failed to import model %s from %s", model_name, model_file) raise # make work directory self.uniquePath = makeUniquePath() logger.info("Using temporary directory %s", self.uniquePath) # MG file locations self.data_path = os.path.expandvars( '$CMSSW_BASE/src/TTGammaEFT/Generation/data') # MG5 directories if self.model_name == 'dim6top_LO' or self.model_name == 'dim6top_LO_v2' or MG260: logger.warning("Model dim6top_LO: Using MG 2.6.0!") self.MG5_tarball = '/afs/hephy.at/data/rschoefbeck02/MG/MG5_aMC_v2.6.0.tar.gz' # From MG webpage --> WARNING: No matching PDFs for pattern: Ct10nlo.LHgrid self.MG5_tmpdir = os.path.join(self.uniquePath, 'MG5_aMC_v2_6_0') else: self.MG5_tarball = '/afs/hephy.at/data/dspitzbart01/MG5_aMC_v2.3.3.tar.gz' self.MG5_tmpdir = os.path.join(self.uniquePath, 'MG5_aMC_v2_3_3') logger.info("Will use MG5 from %s", self.MG5_tarball) # GridPack directories self.GP_tarball = "/cvmfs/cms.cern.ch/phys_generator/gridpacks/slc6_amd64_gcc481/13TeV/madgraph/V5_2.3.3/ttZ01j_5f_MLM/v1/ttZ01j_5f_tarball.tar.xz" self.GP_tmpdir = os.path.join(self.uniquePath, 'centralGridpack') logger.info("Will use gridpack from %s", self.GP_tarball) # restriction file self.restrictCardTemplate = os.path.join( self.data_path, 'template', 'template_restrict_no_b_mass_' + model_name + '.dat') self.restrictCard = os.path.join(self.MG5_tmpdir, 'models', self.model_name, 'restrict_no_b_mass.dat') # Consistency check of the model: Check that couplings are unique self.all_model_couplings = [c[0] for c in sum(self.model.values(), [])] seen = set() uniq = [ x for x in self.all_model_couplings if x not in seen and not seen.add(x) ] if len(seen) != len(self.all_model_couplings): logger.error( "Apparently, list of couplings for model %s is not unique: %s. Check model file %s.", self.model_name, ",".join(self.all_model_couplings), model_file) raise RuntimeError # Get default values for model self.default_model_couplings = {} for param_set in self.model.values(): for param, val in param_set: self.default_model_couplings[param] = val
help="Run only job i") args = argParser.parse_args() if args.year != "RunII": args.year = int(args.year) if args.checkOnly: args.overwrite = False # Logging import Analysis.Tools.logger as logger logger = logger.get_logger(args.logLevel, logFile=None) import RootTools.core.logger as logger_rt logger_rt = logger_rt.get_logger(args.logLevel, logFile=None) logger.debug("Start run_estimate.py") if not args.controlRegion: logger.warning("ControlRegion not known") sys.exit(0) if not "3p" in args.controlRegion: print "Need the 3p region as input! Got %s" % args.controlRegion sys.exit(0) print "Combining caches from %s and %s to %s" % (args.controlRegion.replace( "3p", "3"), args.controlRegion.replace("3p", "4p"), args.controlRegion) parameters3p = allRegions[args.controlRegion]["parameters"] parameters3 = allRegions[args.controlRegion.replace("3p", "3")]["parameters"] parameters4p = allRegions[args.controlRegion.replace("3p", "4p")]["parameters"] channels = allRegions[args.controlRegion]["channels"] photonSelection = not allRegions[args.controlRegion]["noPhotonCR"] if args.noInclusive:
def filler(event): event.run, event.luminosity, event.evt = reader.evt event.weight = lumiweight if reader.position % 100 == 0: logger.info("At event %i/%i", reader.position, reader.nEvents) # EFT weights if options.addReweights: event.nrw = weightInfo.nid lhe_weights = reader.products['lhe'].weights() weights = [] param_points = [] for weight in lhe_weights: # Store nominal weight (First position!) if weight.id == 'rwgt_1': event.rw_nominal = weight.wgt if not weight.id in weightInfo.id: continue pos = weightInfo.data[weight.id] event.rw_w[pos] = weight.wgt weights += [weight.wgt] interpreted_weight = interpret_weight(weight.id) for var in weightInfo.variables: getattr(event, "rw_" + var)[pos] = interpreted_weight[var] # weight data for interpolation if not hyperPoly.initialized: param_points += [ tuple(interpreted_weight[var] for var in weightInfo.variables) ] # get list of values of ref point in specific order ref_point_coordinates = [ weightInfo.ref_point_coordinates[var] for var in weightInfo.variables ] # Initialize with Reference Point if not hyperPoly.initialized: hyperPoly.initialize(param_points, ref_point_coordinates) coeff = hyperPoly.get_parametrization(weights) event.np = hyperPoly.ndof event.chi2_ndof = hyperPoly.chi2_ndof(coeff, weights) if event.chi2_ndof > 10**-6: logger.warning("chi2_ndof is large: %f", event.chi2_ndof) for n in xrange(hyperPoly.ndof): event.p_C[n] = coeff[n] # lumi weight / w0 event.ref_weight = event.weight / coeff[0] # GEN Particles genPart = reader.products['gp'] # for searching search = GenSearch(genPart) # MET GenMET = { 'pt': reader.products['genMET'][0].pt(), 'phi': reader.products['genMET'][0].phi() } event.GenMET_pt = GenMET['pt'] event.GenMET_phi = GenMET['phi'] # find heavy objects before they decay GenTops = map( lambda t: {var: getattr(t, var)() for var in genTopVars}, filter(lambda p: abs(p.pdgId()) == 6 and search.isLast(p), genPart)) GenTops.sort(key=lambda p: -p['pt']) fill_vector_collection(event, "GenTop", genTopVars, GenTops) # genLeptons: prompt gen-leptons # GenLeptonsAll = [ (search.ascend(l), l) for l in filter( lambda p: abs( p.pdgId() ) in [11,13] and search.isLast(p) and p.status() == 1, genPart ) ] GenLeptonsAll = [(search.ascend(l), l) for l in filter( lambda p: abs(p.pdgId()) in [11, 13] and search.isLast(p), genPart)] GenPromptLeptons = [] GenAllLeptons = [] for first, last in GenLeptonsAll: mother = first.mother(0) if first.numberOfMothers() > 0 else None mother_pdgId = -999 grandmother_pdgId = -999 if mother: mother_pdgId = mother.pdgId() mother_ascend = search.ascend(mother) grandmother = mother_ascend.mother( 0) if mother.numberOfMothers() > 0 else None grandmother_pdgId = grandmother.pdgId() if grandmother else -999 genLep = {var: getattr(last, var)() for var in genLeptonVarsRead} genLep['motherPdgId'] = mother_pdgId genLep['grandmotherPdgId'] = grandmother_pdgId GenAllLeptons.append(genLep) if abs(mother_pdgId) in [11, 13, 15, 23, 24, 25 ] and isGoodGenLepton(genLep): GenPromptLeptons.append(genLep) # Filter gen leptons GenAllLeptons.sort(key=lambda p: -p['pt']) fill_vector_collection(event, "GenAllLepton", genLeptonVars, GenAllLeptons) GenPromptLeptons.sort(key=lambda p: -p['pt']) if GenPromptLeptons: GenPromptLeptons[0]["clean"] = 1 #dont clean the high pT photons for i, GenPromptLepton in enumerate(GenPromptLeptons[::-1][:-1]): GenPromptLepton['clean'] = min([999] + [ deltaR2(GenPromptLepton, p) for p in GenPromptLeptons[::-1][i + 1:] ]) > 0.16 GenPromptLeptons = list(filter(lambda j: j["clean"], GenPromptLeptons)) GenPromptElectrons = list( filter(lambda l: abs(l['pdgId']) == 11, GenPromptLeptons)) GenPromptMuons = list( filter(lambda l: abs(l['pdgId']) == 13, GenPromptLeptons)) event.nGenElectron = len(GenPromptElectrons) event.nGenMuon = len(GenPromptMuons) # Gen photons: particle-level isolated gen photons GenPhotonsAll = [(search.ascend(l), l) for l in filter( lambda p: abs(p.pdgId()) == 22 and p.pt() > 5 and search.isLast(p), genPart)] GenPhotonsAll.sort(key=lambda p: -p[1].pt()) GenPhotons = [] GenAllPhotons = [] GenMGPhotons = [] GenMGAllPhotons = [] for first, last in GenPhotonsAll: mother_pdgId = first.mother( 0).pdgId() if first.numberOfMothers() > 0 else -999 GenPhoton = {var: getattr(last, var)() for var in genPhotonVarsRead} GenMGPhoton = {var: getattr(first, var)() for var in genPhotonVarsRead} GenPhoton['motherPdgId'] = mother_pdgId GenPhoton['status'] = last.status() GenMGPhoton['motherPdgId'] = mother_pdgId GenMGPhoton['status'] = first.status() mother_ascend = search.ascend(first.mother(0)) grandmother = mother_ascend.mother( 0) if first.mother(0).numberOfMothers() > 0 else None grandmother_pdgId = grandmother.pdgId() if grandmother else 0 close_particles = filter( lambda p: p != last and deltaR2( { 'phi': last.phi(), 'eta': last.eta() }, { 'phi': p.phi(), 'eta': p.eta() }) < 0.16, search.final_state_particles_no_neutrinos) GenPhoton['relIso04_all'] = sum([p.pt() for p in close_particles], 0) / last.pt() GenPhoton['photonJetdR'] = 999 GenPhoton['photonLepdR'] = 999 GenAllPhotons.append(GenPhoton) if isGoodGenPhoton(GenPhoton): GenPhotons.append(GenPhoton) close_particles = filter( lambda p: p != first and deltaR2( { 'phi': first.phi(), 'eta': first.eta() }, { 'phi': p.phi(), 'eta': p.eta() }) < 0.16, search.final_state_particles_no_neutrinos) GenMGPhoton['relIso04_all'] = sum([p.pt() for p in close_particles], 0) / first.pt() GenMGPhoton['photonJetdR'] = 999 GenMGPhoton['photonLepdR'] = 999 GenMGAllPhotons.append(GenMGPhoton) if isGoodGenPhoton(GenMGPhoton): GenMGPhotons.append(GenMGPhoton) fill_vector_collection(event, "GenAllPhoton", genPhotonVars, GenAllPhotons) fill_vector_collection(event, "GenMGAllPhoton", genPhotonVars, GenMGAllPhotons) if not options.noCleaning: # deltaR cleaning to photons as in run card GenPhotons = list( filter( lambda p: min( [999] + [deltaR2(p, l) for l in GenPromptLeptons]) > 0.04, GenPhotons)) GenMGPhotons = list( filter( lambda p: min( [999] + [deltaR2(p, l) for l in GenPromptLeptons]) > 0.04, GenMGPhotons)) # Jets GenJetsAll = list(filter(genJetId, reader.products['genJets'])) GenJetsAll.sort(key=lambda p: -p.pt()) # Filter genJets GenAllJets = map( lambda t: {var: getattr(t, var)() for var in genJetVarsRead}, GenJetsAll) bPartons = [b for b in filter(lambda p: abs(p.pdgId()) == 5, genPart)] for GenJet in GenAllJets: GenJet['matchBParton'] = min([999] + [ deltaR2(GenJet, { 'eta': b.eta(), 'phi': b.phi() }) for b in bPartons ]) < 0.04 # store if gen-jet is DR matched to a B parton in cone of 0.2 GenJets = list(filter(lambda j: isGoodGenJet(j), GenAllJets)) trueAllNonBjets = list(filter(lambda j: not j['matchBParton'], GenAllJets)) trueAllBjets = list(filter(lambda j: j['matchBParton'], GenAllJets)) fill_vector_collection(event, "GenAllJet", genJetVars, GenAllJets) fill_vector_collection(event, "GenAllBJet", genJetVars, trueAllBjets) if not options.noCleaning: GenJets = list( filter( lambda j: min([999] + [deltaR2(j, p) for p in GenPhotons]) > 0.04, GenJets)) # gen b jets trueBjets = list(filter(lambda j: j['matchBParton'], GenJets)) trueNonBjets = list(filter(lambda j: not j['matchBParton'], GenJets)) # Mimick b reconstruction ( if the trailing b fails acceptance, we supplement with the leading non-b jet ) GenBj0, GenBj1 = (trueBjets + [None, None])[:2] if GenBj0: fill_vector(event, "GenBj0", genJetVars, GenBj0) if GenBj1: fill_vector(event, "GenBj1", genJetVars, GenBj1) # store minimum DR to jets for GenPhoton in GenPhotons + GenMGPhotons: GenPhoton['photonJetdR'] = min([999] + [deltaR(GenPhoton, j) for j in GenJets]) GenPhoton['photonLepdR'] = min( [999] + [deltaR(GenPhoton, j) for j in GenPromptLeptons]) fill_vector_collection(event, "GenPhoton", genPhotonVars, GenPhotons) fill_vector_collection(event, "GenMGPhoton", genPhotonVars, GenMGPhotons) fill_vector_collection(event, "GenLepton", genLeptonVars, GenPromptLeptons) fill_vector_collection(event, "GenJet", genJetVars, GenJets) event.nGenBJet = len(trueBjets) event.m3 = m3(GenJets)[0] if len(GenPhotons) > 0: event.m3gamma = m3(GenJets, photon=GenPhotons[0])[0] # Ovservables if len(GenPromptLeptons) > 1: event.mll = (get4DVec(GenPromptLeptons[0]) + get4DVec(GenPromptLeptons[1])).M() if len(GenPhotons) > 0: event.mllgamma = (get4DVec(GenPromptLeptons[0]) + get4DVec(GenPromptLeptons[1]) + get4DVec(GenPhotons[0])).M() event.minDRjj = min([ deltaR(j1, j2) for i, j1 in enumerate(trueNonBjets[:-1]) for j2 in trueNonBjets[i + 1:] ] + [999]) event.minDRbb = min([ deltaR(b1, b2) for i, b1 in enumerate(trueBjets[:-1]) for b2 in trueBjets[i + 1:] ] + [999]) event.minDRll = min([ deltaR(l1, l2) for i, l1 in enumerate(GenPromptLeptons[:-1]) for l2 in GenPromptLeptons[i + 1:] ] + [999]) event.minDRaa = min([ deltaR(g1, g2) for i, g1 in enumerate(GenPhotons[:-1]) for g2 in GenPhotons[i + 1:] ] + [999]) event.minDRbj = min( [deltaR(b, j) for b in trueBjets for j in trueNonBjets] + [999]) event.minDRaj = min( [deltaR(a, j) for a in GenPhotons for j in trueNonBjets] + [999]) event.minDRjl = min( [deltaR(l, j) for l in GenPromptLeptons for j in trueNonBjets] + [999]) event.minDRab = min([deltaR(a, b) for a in GenPhotons for b in trueBjets] + [999]) event.minDRbl = min( [deltaR(l, b) for l in GenPromptLeptons for b in trueBjets] + [999]) event.minDRal = min( [deltaR(l, a) for l in GenPromptLeptons for a in GenPhotons] + [999])
directory = os.path.join(options.targetDir, options.processingEra) postfix = '_small' if options.small else '' output_directory = os.path.join(directory, "gen" + postfix, sample.name) # Single file post processing if options.nJobs > 1: n_files_before = len(sample.files) sample = sample.split(options.nJobs)[options.job] n_files_after = len(sample.files) logger.info("Running job %i/%i over %i files from a total of %i.", options.job, options.nJobs, n_files_after, n_files_before) if os.path.exists(output_directory) and options.overwrite: if options.nJobs > 1: logger.warning("NOT removing directory %s because nJobs = %i", output_directory, options.nJobs) else: logger.info("Output directory %s exists. Deleting.", output_directory) shutil.rmtree(output_directory, ignore_errors=True) if not os.path.exists(output_directory): try: os.makedirs(output_directory) logger.info("Created output directory %s.", output_directory) except: logger.info("Directory %s already exists.", output_directory) pass # Load reweight pickle file if supposed to keep weights. reweight_variables = [] if options.addReweights:
str(ppEntry["year"]), ppEntry["skim"], sample + postfix) # find all root files in subdirectory allFiles = os.listdir(dirPath) if os.path.exists(dirPath) else [] allRootFiles = filter( lambda f: f.endswith('.root') and not f.startswith('nanoAOD'), allFiles) nanoAODFiles = filter( lambda f: f.endswith('.root') and f.startswith('nanoAOD'), allFiles) prefix = '' nanoAOD_list = [] if len(nanoAODFiles) > 0: logger.warning("Found nanoAODFiles. Shouldn't be here: %s", ",".join(nanoAODFiles)) try: nanoAOD_list = list( set([ int(f.rstrip('.root').split('_')[-2]) for f in nanoAODFiles ])) except ValueError: #possibly 'SPLIT1' nanoAOD_list = [0] if len(allRootFiles) > 0: rootFiles = [ os.path.join(dirPath, filename) for filename in allRootFiles ] if args.check != 'None': if args.check == 'deep':
def _dataDrivenTransferFactor(self, channel, setup, qcdUpdates=None, overwrite=False): print("Calculating data-driven QCD transfer factor") selection_MC_CR = setup.selection( "MC", channel=channel, **setup.defaultParameters(update=qcdUpdates["CR"] if qcdUpdates else QCDTF_updates["CR"])) selection_Data_CR = setup.selection( "Data", channel=channel, **setup.defaultParameters(update=qcdUpdates["CR"] if qcdUpdates else QCDTF_updates["CR"])) selection_MC_SR = setup.selection( "MC", channel=channel, **setup.defaultParameters(update=qcdUpdates["SR"] if qcdUpdates else QCDTF_updates["SR"])) selection_Data_SR = setup.selection( "Data", channel=channel, **setup.defaultParameters(update=qcdUpdates["SR"] if qcdUpdates else QCDTF_updates["SR"])) # selection_Data_full = setup.selection("Data", channel=channel, **setup.defaultParameters( update=QCDTF_updates["SRDenom"] )) # selection_Data_part = setup.selection("Data", channel=channel, **setup.defaultParameters()) weight_MC_CR = selection_MC_CR["weightStr"] # w/ misID SF weight_Data_CR = selection_Data_CR["weightStr"] weight_MC_SR = selection_MC_SR["weightStr"] # w/ misID SF weight_Data_SR = selection_Data_SR["weightStr"] print("Using QCD TF CR weightstring MC %s" % (weight_MC_CR)) print("Using QCD TF CR weightstring Data %s" % (weight_Data_CR)) print("Using QCD TF SR weightstring MC %s" % (weight_MC_SR)) print("Using QCD TF SR weightstring Data %s" % (weight_Data_SR)) cut_MC_CR = selection_MC_CR["cut"] cut_Data_CR = selection_Data_CR["cut"] cut_MC_SR = selection_MC_SR["cut"] cut_Data_SR = selection_Data_SR["cut"] print("Using QCD TF CR MC total cut %s" % (cut_MC_CR)) print("Using QCD TF CR Data total cut %s" % (cut_Data_CR)) print("Using QCD TF SR MC total cut %s" % (cut_MC_SR)) print("Using QCD TF SR Data total cut %s" % (cut_Data_SR)) # Calculate yields for Data yield_data_SR = self.yieldFromCache(setup, "Data", channel, cut_Data_SR, weight_Data_SR, overwrite=overwrite) if yield_data_SR <= 0: logger.warning("SR data yield for QCD TF is 0!") return u_float(0, 0) yield_data_CR = self.yieldFromCache(setup, "Data", channel, cut_Data_CR, weight_Data_CR, overwrite=overwrite) if yield_data_CR <= 0: logger.warning("CR data yield for QCD TF is 0!") return u_float(0, 0) # Calculate yields for MC (normalized to data lumi) if addSF: if setup.nJet == "2": DYSF_val = DY2SF_val WGSF_val = WG2SF_val ZGSF_val = ZG2SF_val elif setup.nJet == "3": DYSF_val = DY3SF_val WGSF_val = WG3SF_val ZGSF_val = ZG3SF_val elif setup.nJet == "4": DYSF_val = DY4SF_val WGSF_val = WG4SF_val ZGSF_val = ZG4SF_val elif setup.nJet == "5": DYSF_val = DY5SF_val WGSF_val = WG5SF_val ZGSF_val = ZG5SF_val elif setup.nJet == "2p": DYSF_val = DY2pSF_val WGSF_val = WG2pSF_val ZGSF_val = ZG2pSF_val elif setup.nJet == "3p": DYSF_val = DY3pSF_val WGSF_val = WG3pSF_val ZGSF_val = ZG3pSF_val elif setup.nJet == "4p": DYSF_val = DY4pSF_val WGSF_val = WG4pSF_val ZGSF_val = ZG4pSF_val yield_other_CR = 0 yield_other_SR = 0 for s in default_sampleList: if s in ["QCD-DD", "QCD", "QCD_e", "QCD_mu", "GJets", "Data"]: continue print s y_CR = self.yieldFromCache(setup, s, channel, cut_MC_CR, weight_MC_CR, overwrite=overwrite) y_SR = self.yieldFromCache(setup, s, channel, cut_MC_SR, weight_MC_SR, overwrite=overwrite) print "without SF", s, "CR", y_CR, "SR", y_SR if addSF: if "DY_LO" in s: y_CR *= DYSF_val[setup.year] #add DY SF y_SR *= DYSF_val[setup.year] #add DY SF elif "WJets" in s: y_CR *= WJetsSF_val[setup.year] #add WJets SF y_SR *= WJetsSF_val[setup.year] #add WJets SF elif "TTG" in s: y_CR *= SSMSF_val[setup.year] #add TTG SF y_SR *= SSMSF_val[setup.year] #add TTG SF elif "ZG" in s: y_CR *= ZGSF_val[setup.year] #add ZGamma SF y_SR *= ZGSF_val[setup.year] #add ZGamma SF elif "WG" in s: y_CR *= WGSF_val[setup.year] #add WGamma SF y_SR *= WGSF_val[setup.year] #add WGamma SF print "with SF", s, "CR", y_CR, "SR", y_SR yield_other_CR += y_CR yield_other_SR += y_SR qcd_est_CR = yield_data_CR - yield_other_CR qcd_est_SR = yield_data_SR - yield_other_SR # TF from full QCD CR to full SR transRatio = qcd_est_SR / qcd_est_CR if qcd_est_CR > 0 else u_float( 0, 0) # scale the TF for subregions in e.g. m(l,gamma) or m3 (region cuts) transferFac = transRatio # * fractionalSR print("Calculating data-driven QCD TF normalization in channel " + channel + " using lumi " + str(setup.dataLumi) + ":") print("TF CR yield data: " + str(yield_data_CR)) print("TF CR yield other: " + str(yield_other_CR)) print("TF CR yield (data-other): " + str(qcd_est_CR)) print("TF SR yield data: " + str(yield_data_SR)) print("TF SR yield other: " + str(yield_other_SR)) print("TF SR yield (data-other): " + str(qcd_est_SR)) print("transfer factor: " + str(transferFac)) if transferFac <= 0: logger.warning("TF is 0!") return u_float(0, 0) if qcd_est_CR <= 0 and yield_data_CR > 0: logger.warning("Negative QCD TF CR estimate yield!") return u_float(0, 0) if qcd_est_SR <= 0 and yield_data_SR > 0: logger.warning("Negative QCD TF SR estimate yield!") return u_float(0, 0) return transferFac if transferFac > 0 else u_float(0, 0)