Пример #1
0
def handleX10X20X10NLGen(event, weight):
    partSize = event.GenParticles.size()
    nL = 0
    l1 = None
    l2 = None
    for ipart in range(partSize):
        part = event.GenParticles[ipart]
        if event.GenParticles_Status[ipart] == 1 and (
                abs(event.GenParticles_PdgId[ipart]) == 11
                or abs(event.GenParticles_PdgId[ipart]) == 13):
            nL += 1
            minR = minDeltaR(ipart, event)
            if minR is not None:
                utils.fillHistWithCuts("DeltaRLepMatchCand", minR, histList,
                                       cutsDef, "ntuples", event, weight)
                if minR <= 0.1:
                    utils.fillHistWithCuts("MatchLep", 1, histList, cutsDef,
                                           "ntuples", event, weight)
                else:
                    utils.fillHistWithCuts("MatchLep", 0, histList, cutsDef,
                                           "ntuples", event, weight)
            else:
                #print "No minR"
                utils.fillHistWithCuts("MatchLep", 0, histList, cutsDef,
                                       "ntuples", event, weight)
            if l1 is None:
                l1 = ipart
            else:
                l2 = ipart
    utils.fillHistWithCuts("NLGen", nL, histList, cutsDef, "ntuples", event,
                           weight)
    if nL == 2 and abs(event.GenParticles_PdgId[l1]) == abs(
            event.GenParticles_PdgId[l2]
    ) and (event.GenParticles_PdgId[l1] * event.GenParticles_PdgId[l2] < 0):
        handleX10X20X10GenDiLepton(event, l1, l2, weight)
Пример #2
0
def handleX10X20X10Jets(event, weight):
    jetsNum = 0
    for ijet in range(event.Jets.size()):
        jet = event.Jets[ijet]
        if jet.Pt() >= 30 and abs(jet.Eta()) <= 2.4:
            jetsNum += 1
    utils.fillHistWithCuts("NJ", jetsNum, histList, cutsDef, "ntuples", event,
                           weight)
    return jetsNum
Пример #3
0
def handleX10X20X10NLGen(genParticles, event):
    particles = genParticles.product()
    nL = 0
    l1 = None
    l2 = None
    for i, part in enumerate(particles):
        if part.isPromptFinalState() and part.isLastCopy() and (abs(
                part.pdgId()) == 11 or abs(part.pdgId()) == 13):
            nL += 1
            minR, minCan = minDeltaR(part, event)
            utils.fillHistWithCuts("DeltaRLepMatchCand", minR, histList,
                                   cutsDef, "aod", event)
            if minCan.pdgId() == part.pdgId():
                utils.fillHistWithCuts("MatchLep", 1, histList, cutsDef, "aod",
                                       event)
            else:
                utils.fillHistWithCuts("MatchLep", 0, histList, cutsDef, "aod",
                                       event)
                #print minCan.pdgId(), " ", part.pdgId()
            if l1 is None:
                l1 = part
            else:
                l2 = part
    utils.fillHistWithCuts("NLGen", nL, histList, cutsDef, "aod", event)
    if nL == 2 and abs(l1.pdgId()) == abs(
            l2.pdgId()) and l1.pdgId() * l2.pdgId() < 0:
        handleX10X20X10GenDiLepton(l1, l2, event)
def handleX10X20X10GenDiLepton(event, l1, l2, weight, params):
	l1v = event.GenParticles[l1]
	l2v = event.GenParticles[l2]
	deltaPhi = l1v.DeltaPhi(l2v)
	deltaR = l1v.DeltaR(l2v)
	deltaEta = abs(l1v.Eta() - l2v.Eta())
	utils.fillHistWithCuts("DeltaPhiGen", deltaPhi, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts("DeltaRGen", deltaR, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts("DeltaEtaGen", deltaEta, histList, cutsDef, "ntuples", event, weight, params)	
Пример #5
0
def handleX10X20X10MET(event, nj):
    pfMET, pfMETLabel = Handle("vector<reco::PFMET>"), "pfMet"
    event.getByLabel(pfMETLabel, pfMET)
    met = pfMET.product().front().pt()
    utils.fillHistWithCuts("MET", met, histList, cutsDef, "aod", event)
    if nj == 1:
        utils.fillHistWithCuts("MET1J", met, histList, cutsDef, "aod", event)
    elif nj == 2:
        utils.fillHistWithCuts("MET2J", met, histList, cutsDef, "aod", event)
Пример #6
0
def handleX10X20X10MET(event, nj, weight):
    met = event.MET
    utils.fillHistWithCuts("MET", met, histList, cutsDef, "ntuples", event,
                           weight)
    if nj == 1:
        utils.fillHistWithCuts("MET1J", met, histList, cutsDef, "ntuples",
                               event, weight)
    elif nj == 2:
        utils.fillHistWithCuts("MET2J", met, histList, cutsDef, "ntuples",
                               event, weight)
Пример #7
0
def handleX10X20X10GenDiLepton(l1, l2, event):
    l1v = TLorentzVector(l1.px(), l1.py(), l1.pz(), l1.energy())
    l2v = TLorentzVector(l2.px(), l2.py(), l2.pz(), l2.energy())
    deltaPhi = l1v.DeltaPhi(l2v)
    deltaEta = abs(l1v.Eta() - l2v.Eta())
    utils.fillHistWithCuts("DeltaPhiGen", deltaPhi, histList, cutsDef, "aod",
                           event)
    utils.fillHistWithCuts("DeltaRGen", l1v.DeltaR(l2v), histList, cutsDef,
                           "aod", event)
    utils.fillHistWithCuts("DeltaEtaGen", deltaEta, histList, cutsDef, "aod",
                           event)
Пример #8
0
def handleX10X20X10Jets(event, onlyForCrossSection):
    ak4PFJets, ak4PFJetsLabel = Handle("vector<reco::PFJet>"), "ak4PFJetsCHS"
    event.getByLabel(ak4PFJetsLabel, ak4PFJets)
    jetsNum = 0
    jets = ak4PFJets.product()
    pt = 0
    for i, jet in enumerate(jets):
        if jet.pt() >= 30 and abs(jet.eta()) <= 2.4:
            jetsNum += 1
            pt += jet.pt()

    histList["HT"].Fill(pt)

    if onlyForCrossSection:
        return

    utils.fillHistWithCuts("NJ", jetsNum, histList, cutsDef, "aod", event)
    utils.fillHistWithCuts("HTWeight", pt, histList, cutsDef, "aod", event)
    if jetsNum == 1:
        utils.fillHistWithCuts("HT1J", pt, histList, cutsDef, "aod", event)
    elif jetsNum == 2:
        utils.fillHistWithCuts("HT2J", pt, histList, cutsDef, "aod", event)
    return jetsNum
Пример #9
0
def handleX10X20X10Gen(x20, x10, event):
    utils.fillHistWithCuts("X1PT", x10.pt(), histList, cutsDef, "aod", event)
    utils.fillHistWithCuts("X2PT", x20.pt(), histList, cutsDef, "aod", event)

    # We know that x20 has three daughters
    p1 = None
    p2 = None
    for i in range(x20.numberOfDaughters()):
        if x20.daughter(i).pdgId() != 1000022:
            if p1 is None:
                p1 = trimTree(x20.daughter(i))
            else:
                p2 = trimTree(x20.daughter(i))
    p1v = TLorentzVector(p1.px(), p1.py(), p1.pz(), p1.energy())
    p2v = TLorentzVector(p2.px(), p2.py(), p2.pz(), p2.energy())
    invMass = (p1v + p2v).M()
    #print "invMass=" + str(invMass) + "(" + str(p1.pdgId())+","+str(p2.pdgId())+")" +"(" + str(p1.isElectron())+","+str(p2.isMuon())+")"
    utils.fillHistWithCuts("InvMassGen", invMass, histList, cutsDef, "aod",
                           event)
Пример #10
0
def handleX10X20X10Cand(event, nj, weight):
    nL = event.Electrons.size() + event.Muons.size()
    ht = event.HT
    histList["HT"].Fill(ht)
    utils.fillHistWithCuts("HTWeight", ht, histList, cutsDef, "ntuples", event,
                           weight)
    if nj == 1:
        utils.fillHistWithCuts("HT1J", ht, histList, cutsDef, "ntuples", event,
                               weight)
    elif nj == 2:
        utils.fillHistWithCuts("HT2J", ht, histList, cutsDef, "ntuples", event,
                               weight)
    utils.fillHistWithCuts("NLCan", nL, histList, cutsDef, "ntuples", event,
                           weight)

    for lep in event.Electrons:
        utils.fillHistWithCuts("LPT", lep.Pt(), histList, cutsDef, "ntuples",
                               event, weight)
        utils.fillHistWithCuts("LEta", lep.Eta(), histList, cutsDef, "ntuples",
                               event, weight)
        utils.fillHistWithCuts("LPhi", lep.Phi(), histList, cutsDef, "ntuples",
                               event, weight)
        if nj == 1:
            utils.fillHistWithCuts("LPT1J", lep.Pt(), histList, cutsDef,
                                   "ntuples", event, weight)
            utils.fillHistWithCuts("LEta1J", lep.Eta(), histList, cutsDef,
                                   "ntuples", event, weight)
            utils.fillHistWithCuts("LPhi1J", lep.Phi(), histList, cutsDef,
                                   "ntuples", event, weight)
        elif nj == 2:
            utils.fillHistWithCuts("LPT2J", lep.Pt(), histList, cutsDef,
                                   "ntuples", event, weight)
            utils.fillHistWithCuts("LEta2J", lep.Eta(), histList, cutsDef,
                                   "ntuples", event, weight)
            utils.fillHistWithCuts("LPhi2J", lep.Phi(), histList, cutsDef,
                                   "ntuples", event, weight)

    if nL == 2:
        if event.Electrons.size(
        ) == 2 and event.Electrons_charge[0] * event.Electrons_charge[1] < 0:
            handleX10X20X10DiLepton(event.Electrons[0], event.Electrons[1],
                                    event, nj, weight)
        elif event.Muons.size(
        ) == 2 and event.Muons_charge[0] * event.Muons_charge[1] < 0:
            handleX10X20X10DiLepton(event.Muons[0], event.Muons[1], event, nj,
                                    weight)
Пример #11
0
def handleX10X20X10DiLepton(l1, l2, event, nj, weight):
    invMass = (l1 + l2).M()
    deltaPhi = l1.DeltaPhi(l2)
    deltaEta = abs(l1.Eta() - l2.Eta())
    deltaR = l1.DeltaR(l2)
    utils.fillHistWithCuts("DuoLepCanInvMass", invMass, histList, cutsDef,
                           "ntuples", event, weight)
    utils.fillHistWithCuts("DeltaRCan", deltaR, histList, cutsDef, "ntuples",
                           event, weight)
    utils.fillHistWithCuts("DeltaEtaCan", deltaEta, histList, cutsDef,
                           "ntuples", event, weight)
    utils.fillHistWithCuts("DeltaPhiCan", deltaPhi, histList, cutsDef,
                           "ntuples", event, weight)
    if nj == 1:
        utils.fillHistWithCuts("DuoLepCanInvMass1J", invMass, histList,
                               cutsDef, "ntuples", event, weight)
        utils.fillHistWithCuts("DeltaRCan1J", deltaR, histList, cutsDef,
                               "ntuples", event, weight)
        utils.fillHistWithCuts("DeltaEtaCan1J", deltaEta, histList, cutsDef,
                               "ntuples", event, weight)
        utils.fillHistWithCuts("DeltaPhiCan1J", deltaPhi, histList, cutsDef,
                               "ntuples", event, weight)
    elif nj == 2:
        utils.fillHistWithCuts("DuoLepCanInvMass2J", invMass, histList,
                               cutsDef, "ntuples", event, weight)
        utils.fillHistWithCuts("DeltaRCan2J", deltaR, histList, cutsDef,
                               "ntuples", event, weight)
        utils.fillHistWithCuts("DeltaEtaCan2J", deltaEta, histList, cutsDef,
                               "ntuples", event, weight)
        utils.fillHistWithCuts("DeltaPhiCan2J", deltaPhi, histList, cutsDef,
                               "ntuples", event, weight)
def handleX10X20X10NLGen(event, weight, params, nj):
	partSize = event.GenParticles.size()
	nL = 0
	l1 = None
	l2 = None
	t1 = None
	t2 = None
	
	duoTao = analysis_ntuples.isDuoTauEvent(event)
	
	neutrinos = []
	
	for ipart in range(partSize):
		if event.GenParticles_Status[ipart] == 1 and (abs(event.GenParticles_PdgId[ipart]) == 11 or abs(event.GenParticles_PdgId[ipart]) == 13):
			nL += 1
			minR = minDeltaR(ipart, event)
			if minR is not None:
				utils.fillHistWithCuts("DeltaRLepMatchCand", minR, histList, cutsDef, "ntuples", event, weight, params)
				if minR <= 0.1:
					utils.fillHistWithCuts("MatchLep", 1, histList, cutsDef, "ntuples", event, weight, params)
				else:
					utils.fillHistWithCuts("MatchLep", 0, histList, cutsDef, "ntuples", event, weight, params)
			else:
				#print "No minR"
				utils.fillHistWithCuts("MatchLep", 0, histList, cutsDef, "ntuples", event, weight, params)
			if l1 is None:
				l1 = ipart
			else:
				l2 = ipart
		if duoTao and abs(event.GenParticles_PdgId[ipart]) == 15:
			if t1 is None:
				t1 = ipart
			else:
				t2 = ipart
		
		if duoTao and abs(event.GenParticles_PdgId[ipart]) == 12 or abs(event.GenParticles_PdgId[ipart]) == 14 or abs(event.GenParticles_PdgId[ipart]) == 16:
			neutrinos.append(ipart)
			
			
	utils.fillHistWithCuts("NLGen", nL, histList, cutsDef, "ntuples", event, weight, params)
	
	if duoTao and nL == 2 and nj >= 1 and abs(event.GenParticles_PdgId[l1]) == abs(event.GenParticles_PdgId[l2]) and (event.GenParticles_PdgId[l1] * event.GenParticles_PdgId[l2] < 0):
		t1v = event.GenParticles[t1]
		t2v = event.GenParticles[t2]
		l1v = event.GenParticles[l1]
		l2v = event.GenParticles[l2]
	
		if len(neutrinos) == 4 and abs(event.GenParticles_ParentId[l1]) == 15 and abs(event.GenParticles_ParentId[l2]) == 15:
			pt = TLorentzVector()
			pt.SetPtEtaPhiE(event.GenMET,0,event.GenMETPhi,event.GenMET)
			mttgenrec = analysis_tools.Mtautau(pt, event.GenParticles[l1], event.GenParticles[l2])
			utils.fillHistWithCuts("MTauTauGenLep", mttgenrec, histList, cutsDef, "ntuples", event, weight, params)
			sum = event.GenParticles[l1] + event.GenParticles[l2]
			n1 = TLorentzVector()
			n2 = TLorentzVector()
			for i in range(len(neutrinos)):
				nv = event.GenParticles[neutrinos[i]]
				if abs(event.GenParticles_PdgId[neutrinos[i]]) == 16:
					if event.GenParticles_PdgId[neutrinos[i]] * event.GenParticles_PdgId[t1] > 0:
						n1 += nv
					else:
						n2 += nv
				else:
					if event.GenParticles_PdgId[neutrinos[i]] * event.GenParticles_PdgId[t1] < 0:
						n1 += nv
					else:
						n2 += nv
				sum += nv
			utils.fillHistWithCuts("MTauTauGenLepNeu", sum.M(), histList, cutsDef, "ntuples", event, weight, params)
def handleX10X20X10Cand(event, weight, params, cutFlow = False):
	#JETS
	nj, btags, ljet = analysis_ntuples.numberOfJets25Pt2_4Eta_Loose2(event)
	params["nj"] = nj
	params["BTags"] = btags
	params["ljet"] = ljet
	
	#MET
	met = event.MET
	params["met"] = met
	#LEPTONS
	nL = event.Electrons.size() + event.Muons.size()
	params["nL"] = nL
	#HT
	ht = event.HT
	params["ht"] = ht
	#METDHT
	metDHt = 9999999
	if ht != 0:
		metDHt = met / ht
	params["metDHt"] = metDHt
	
	#Dilepton
	dilepton = False
	params["dilepton"] = False
	if nL == 2:
		#REMOVE COMMENTS!
		#HT
		dilepHt = analysis_ntuples.htJet25(event)
		params["dilepHt"] = dilepHt
		if event.Electrons.size() == 2:# and event.Electrons_charge[0] * event.Electrons_charge[1] < 0:
			dilepton = True
			params["dilepton"] = True
			params["oppositeSign"] = event.Electrons_charge[0] * event.Electrons_charge[1] < 0
			if event.Electrons[0].Pt() > event.Electrons[1].Pt():
				params["leptons"] = event.Electrons
			else:
				params["leptons"] = [event.Electrons[1], event.Electrons[0]]
			params["leptonsType"] = "E"
			handleX10X20X10DiLepton(event.Electrons[0], event.Electrons[1], event, nj, weight, params, "E", cutFlow)
		if event.Muons.size() == 2:# and event.Muons_charge[0] * event.Muons_charge[1] < 0:
			dilepton = True
			params["dilepton"] = True
			params["oppositeSign"] = event.Muons_charge[0] * event.Muons_charge[1] < 0
			if event.Muons[0].Pt() > event.Muons[1].Pt():
				params["leptons"] = event.Muons
			else:
				params["leptons"] = [event.Muons[1], event.Muons[0]]
			params["leptonsType"] = "M"
			handleX10X20X10DiLepton(event.Muons[0], event.Muons[1], event, nj, weight, params, "M", cutFlow)
	
	if cutFlow:
		return nj
	
	utils.fillHistWithCuts("NJ", nj, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts("MET", met, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts("METDHT", metDHt, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts("HTWeight", ht, histList, cutsDef, "ntuples", event, weight, params)
	
	if nj == 1:
		utils.fillHistWithCuts("MET1J", met, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("METDHT1J", metDHt, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("HT1J", ht, histList, cutsDef, "ntuples", event, weight, params)
	elif nj ==2:
		utils.fillHistWithCuts("MET2J", met, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("METDHT2J", metDHt, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("HT2J", ht, histList, cutsDef, "ntuples", event, weight, params)
	if nj >= 1:
		utils.fillHistWithCuts("METGT1J", met, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("METDHTGT1J", metDHt, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("HTGT1J", ht, histList, cutsDef, "ntuples", event, weight, params)
		
	utils.fillHistWithCuts("NLCan", nL, histList, cutsDef, "ntuples", event, weight, params)
	
	leptons = {"E" : event.Electrons, "M" : event.Muons}
	
	for kind, leps in leptons.items():
		for lep in leps:
			utils.fillHistWithCuts("LPT", lep.Pt(), histList, cutsDef, "ntuples", event, weight, params)
			utils.fillHistWithCuts("LEta", lep.Eta(), histList, cutsDef, "ntuples", event, weight, params)
			utils.fillHistWithCuts("LPhi", lep.Phi(), histList, cutsDef, "ntuples", event, weight, params)
			utils.fillHistWithCuts(kind + "PT", lep.Pt(), histList, cutsDef, "ntuples", event, weight, params)
			utils.fillHistWithCuts(kind + "Eta", lep.Eta(), histList, cutsDef, "ntuples", event, weight, params)
			utils.fillHistWithCuts(kind + "Phi", lep.Phi(), histList, cutsDef, "ntuples", event, weight, params)
			if nj == 1:
				utils.fillHistWithCuts("LPT1J", lep.Pt(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts("LEta1J", lep.Eta(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts("LPhi1J", lep.Phi(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts(kind + "PT1J", lep.Pt(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts(kind + "Eta1J", lep.Eta(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts(kind + "Phi1J", lep.Phi(), histList, cutsDef, "ntuples", event, weight, params)
			elif nj == 2: 
				utils.fillHistWithCuts("LPT2J", lep.Pt(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts("LEta2J", lep.Eta(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts("LPhi2J", lep.Phi(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts(kind + "PT2J", lep.Pt(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts(kind + "Eta2J", lep.Eta(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts(kind + "Phi2J", lep.Phi(), histList, cutsDef, "ntuples", event, weight, params)
			if nj >= 1:
				utils.fillHistWithCuts("LPTGT1J", lep.Pt(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts("LEtaGT1J", lep.Eta(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts("LPhiGT1J", lep.Phi(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts(kind + "PTGT1J", lep.Pt(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts(kind + "EtaGT1J", lep.Eta(), histList, cutsDef, "ntuples", event, weight, params)
				utils.fillHistWithCuts(kind + "PhiGT1J", lep.Phi(), histList, cutsDef, "ntuples", event, weight, params)
	
	return nj
def handleX10X20X10DiLepton(l1, l2, event, nj, weight, params, type, cutFlow):
	invMass = (l1 + l2).M()
	params["invMass"] = invMass
	dileptonPt = abs((l1 + l2).Pt())
	params["dileptonPt"] = dileptonPt
	deltaPhi = abs(l1.DeltaPhi(l2))
	params["deltaPhi"] = deltaPhi
	deltaEta = abs(l1.Eta() - l2.Eta())
	params["deltaEta"] = deltaEta
	deltaR = abs(l1.DeltaR(l2))
	params["deltaR"] = deltaR
	
	params["pt3"] = analysis_tools.pt3(l1.Pt(),l1.Phi(),l2.Pt(),l2.Phi(),event.MET,event.METPhi)
	
	deltaEtaLeadingJetDilepton = None
	params["deltaEtaLeadingJetDilepton"] = None
	leadingJetPartonFlavor = None
	params["leadingJetPartonFlavor"] = None
	leadingJetQgLikelihood = None
	params["leadingJetQgLikelihood"] = None
	
	pt = TLorentzVector()
	pt.SetPtEtaPhiE(event.MET,0,event.METPhi,event.MET)
	
	params["mt1"] = analysis_tools.MT2(event.MET, event.METPhi, l1)
	params["mt2"] = analysis_tools.MT2(event.MET, event.METPhi, l2)
	
	mtautau = analysis_tools.PreciseMtautau(event.MET, event.METPhi, l1, l2)
	params["mtautau"] = mtautau
	
	if cutFlow:
		return
	
	if nj > 0:
		deltaEtaLeadingJetDilepton = abs((l1 + l2).Eta() - event.Jets[params["ljet"]].Eta())
		params["deltaEtaLeadingJetDilepton"] = deltaEtaLeadingJetDilepton
		leadingJetPartonFlavor = event.Jets_partonFlavor[params["ljet"]]
		params["leadingJetPartonFlavor"] = leadingJetPartonFlavor
		leadingJetQgLikelihood = event.Jets_qgLikelihood[params["ljet"]]
		params["leadingJetQgLikelihood"] = leadingJetQgLikelihood
		 
		utils.fillHistWithCuts("DeltaEtaLeadingJet", deltaEtaLeadingJetDilepton, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("LeadingJetPartonFlavor", leadingJetPartonFlavor, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("LeadingJetQgLikelihood", leadingJetQgLikelihood, histList, cutsDef, "ntuples", event, weight, params)
	
	utils.fillHistWithCuts("MTauTau", mtautau, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts("MT", params["mt1"], histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts("MT", params["mt2"], histList, cutsDef, "ntuples", event, weight, params)
	
	utils.fillHistWithCuts("DuoLepPt", dileptonPt, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts("DuoLepCanInvMass", invMass, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts("DeltaRCan", deltaR, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts("DeltaEtaCan", deltaEta, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts("DeltaPhiCan", deltaPhi, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts(type + "DuoLepCanInvMass", invMass, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts(type + "DeltaRCan", deltaR, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts(type + "DeltaEtaCan", deltaEta, histList, cutsDef, "ntuples", event, weight, params)
	utils.fillHistWithCuts(type + "DeltaPhiCan", deltaPhi, histList, cutsDef, "ntuples", event, weight, params)
	
	if deltaEtaLeadingJetDilepton is not None:
		utils.fillHistWithCuts("MTauTau", mtautau, histList, cutsDef, "ntuples", event, weight, params)
	
	if params["met"] >= 125 and params["met"] <= 200:
		utils.fillHistWithCuts("DuoLepCanInvMassMET125-200", invMass, histList, cutsDef, "ntuples", event, weight, params)
		if params["pt3"] >= 125 and params["pt3"] <= 200:
			utils.fillHistWithCuts("DuoLepCanInvMassMET125-200Pt3", invMass, histList, cutsDef, "ntuples", event, weight, params)
	elif params["met"] >= 200 and params["met"] <= 250:
		utils.fillHistWithCuts("DuoLepCanInvMassMET200-250", invMass, histList, cutsDef, "ntuples", event, weight, params)
		if params["pt3"] >= 200 and params["pt3"] <= 250:
			utils.fillHistWithCuts("DuoLepCanInvMassMET200-250Pt3", invMass, histList, cutsDef, "ntuples", event, weight, params)
	elif params["met"] >= 250:
		utils.fillHistWithCuts("DuoLepCanInvMassMET250", invMass, histList, cutsDef, "ntuples", event, weight, params)
		if params["pt3"] >= 250:
			utils.fillHistWithCuts("DuoLepCanInvMassMET250Pt3", invMass, histList, cutsDef, "ntuples", event, weight, params)
	
	if nj == 1:
		utils.fillHistWithCuts("MTauTau1J", mtautau, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("MT1J", params["mt1"], histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("MT1J", params["mt2"], histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DuoLepPt1J", dileptonPt, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DuoLepCanInvMass1J", invMass, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DeltaRCan1J", deltaR, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DeltaEtaCan1J", deltaEta, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DeltaPhiCan1J", deltaPhi, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts(type + "DuoLepCanInvMass1J", invMass, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts(type + "DeltaRCan1J", deltaR, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts(type + "DeltaEtaCan1J", deltaEta, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts(type + "DeltaPhiCan1J", deltaPhi, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DeltaEtaLeadingJet1J", deltaEtaLeadingJetDilepton, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("LeadingJetPartonFlavor1J", leadingJetPartonFlavor, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("LeadingJetQgLikelihood1J", leadingJetQgLikelihood, histList, cutsDef, "ntuples", event, weight, params)
		
		if params["met"] >= 125 and params["met"] <= 200:
			utils.fillHistWithCuts("DuoLepCanInvMass1JMET125-200", invMass, histList, cutsDef, "ntuples", event, weight, params)
			if params["pt3"] >= 125 and params["pt3"] <= 200:
				utils.fillHistWithCuts("DuoLepCanInvMass1JMET125-200Pt3", invMass, histList, cutsDef, "ntuples", event, weight, params)
		elif params["met"] >= 200 and params["met"] <= 250:
			utils.fillHistWithCuts("DuoLepCanInvMass1JMET200-250", invMass, histList, cutsDef, "ntuples", event, weight, params)
			if params["pt3"] >= 200 and params["pt3"] <= 250:
				utils.fillHistWithCuts("DuoLepCanInvMass1JMET200-250Pt3", invMass, histList, cutsDef, "ntuples", event, weight, params)
		elif params["met"] >= 250:
			utils.fillHistWithCuts("DuoLepCanInvMass1JMET250", invMass, histList, cutsDef, "ntuples", event, weight, params)
			if params["pt3"] >= 250:
				utils.fillHistWithCuts("DuoLepCanInvMass1JMET250Pt3", invMass, histList, cutsDef, "ntuples", event, weight, params)
		
	elif nj ==2:
		utils.fillHistWithCuts("MTauTau2J", mtautau, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("MT2J", params["mt1"], histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("MT2J", params["mt2"], histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DuoLepPt2J", dileptonPt, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DuoLepCanInvMass2J", invMass, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DeltaRCan2J", deltaR, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DeltaEtaCan2J", deltaEta, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DeltaPhiCan2J", deltaPhi, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts(type + "DuoLepCanInvMass2J", invMass, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts(type + "DeltaRCan2J", deltaR, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts(type + "DeltaEtaCan2J", deltaEta, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts(type + "DeltaPhiCan2J", deltaPhi, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DeltaEtaLeadingJet2J", deltaEtaLeadingJetDilepton, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("LeadingJetPartonFlavor2J", leadingJetPartonFlavor, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("LeadingJetQgLikelihood2J", leadingJetQgLikelihood, histList, cutsDef, "ntuples", event, weight, params)
		
		if params["met"] >= 125 and params["met"] <= 200:
			utils.fillHistWithCuts("DuoLepCanInvMass2JMET125-200", invMass, histList, cutsDef, "ntuples", event, weight, params)
			if params["pt3"] >= 125 and params["pt3"] <= 200:
				utils.fillHistWithCuts("DuoLepCanInvMass2JMET125-200Pt3", invMass, histList, cutsDef, "ntuples", event, weight, params)
		elif params["met"] >= 200 and params["met"] <= 250:
			utils.fillHistWithCuts("DuoLepCanInvMass2JMET200-250", invMass, histList, cutsDef, "ntuples", event, weight, params)
			if params["pt3"] >= 200 and params["pt3"] <= 250:
				utils.fillHistWithCuts("DuoLepCanInvMass2JMET200-250Pt3", invMass, histList, cutsDef, "ntuples", event, weight, params)
		elif params["met"] >= 250:
			utils.fillHistWithCuts("DuoLepCanInvMass2JMET250", invMass, histList, cutsDef, "ntuples", event, weight, params)
			if params["pt3"] >= 250:
				utils.fillHistWithCuts("DuoLepCanInvMass2JMET250Pt3", invMass, histList, cutsDef, "ntuples", event, weight, params)
	if nj >= 1:
		utils.fillHistWithCuts("MTauTauGT1J", mtautau, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("MTGT1J", params["mt1"], histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("MTGT1J", params["mt2"], histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DuoLepPtGT1J", dileptonPt, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DuoLepCanInvMassGT1J", invMass, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DeltaRCanGT1J", deltaR, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DeltaEtaCanGT1J", deltaEta, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DeltaPhiCanGT1J", deltaPhi, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts(type + "DuoLepCanInvMassGT1J", invMass, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts(type + "DeltaRCanGT1J", deltaR, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts(type + "DeltaEtaCanGT1J", deltaEta, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts(type + "DeltaPhiCanGT1J", deltaPhi, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("DeltaEtaLeadingJetGT1J", deltaEtaLeadingJetDilepton, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("LeadingJetPartonFlavorGT1J", leadingJetPartonFlavor, histList, cutsDef, "ntuples", event, weight, params)
		utils.fillHistWithCuts("LeadingJetQgLikelihoodGT1J", leadingJetQgLikelihood, histList, cutsDef, "ntuples", event, weight, params)
		
		if params["met"] >= 125 and params["met"] <= 200:
			utils.fillHistWithCuts("DuoLepCanInvMassGT1JMET125-200", invMass, histList, cutsDef, "ntuples", event, weight, params)
			if params["pt3"] >= 125 and params["pt3"] <= 200:
				utils.fillHistWithCuts("DuoLepCanInvMassGT1JMET125-200Pt3", invMass, histList, cutsDef, "ntuples", event, weight, params)
		elif params["met"] >= 200 and params["met"] <= 250:
			utils.fillHistWithCuts("DuoLepCanInvMassGT1JMET200-250", invMass, histList, cutsDef, "ntuples", event, weight, params)
			if params["pt3"] >= 200 and params["pt3"] <= 250:
				utils.fillHistWithCuts("DuoLepCanInvMassGT1JMET200-250Pt3", invMass, histList, cutsDef, "ntuples", event, weight, params)
		elif params["met"] >= 250:
			utils.fillHistWithCuts("DuoLepCanInvMassGT1JMET250", invMass, histList, cutsDef, "ntuples", event, weight, params)
			if params["pt3"] >= 250:
				utils.fillHistWithCuts("DuoLepCanInvMassGT1JMET250Pt3", invMass, histList, cutsDef, "ntuples", event, weight, params)
Пример #15
0
def handleX10X20X10Cand(event, nj):
    pfCandidates, pfCandidatesLabel = Handle(
        "vector<reco::PFCandidate>"), "particleFlow"
    event.getByLabel(pfCandidatesLabel, pfCandidates)
    candidates = pfCandidates.product()
    nL = 0
    l1 = None
    l2 = None
    for i, cand in enumerate(candidates):
        if (abs(cand.pdgId()) == 11
                or abs(cand.pdgId()) == 13) and cand.pt() >= 5:
            nL += 1
            utils.fillHistWithCuts("LPT", cand.pt(), histList, cutsDef, "aod",
                                   event)
            utils.fillHistWithCuts("LEta", cand.eta(), histList, cutsDef,
                                   "aod", event)
            utils.fillHistWithCuts("LPhi", cand.phi(), histList, cutsDef,
                                   "aod", event)

            if nj == 1:
                utils.fillHistWithCuts("LPT1J", cand.pt(), histList, cutsDef,
                                       "aod", event)
                utils.fillHistWithCuts("LEta1J", cand.eta(), histList, cutsDef,
                                       "aod", event)
                utils.fillHistWithCuts("LPhi1J", cand.phi(), histList, cutsDef,
                                       "aod", event)
            elif nj == 2:
                utils.fillHistWithCuts("LPT2J", cand.pt(), histList, cutsDef,
                                       "aod", event)
                utils.fillHistWithCuts("LEta2J", cand.eta(), histList, cutsDef,
                                       "aod", event)
                utils.fillHistWithCuts("LPhi2J", cand.phi(), histList, cutsDef,
                                       "aod", event)
            if l1 is None:
                l1 = cand
            else:
                l2 = cand
    utils.fillHistWithCuts("NLCan", nL, histList, cutsDef, "aod", event)
    if nL == 2 and abs(l1.pdgId()) == abs(
            l2.pdgId()) and l1.pdgId() * l2.pdgId() < 0:
        handleX10X20X10DiLepton(l1, l2, event, nj)
Пример #16
0
def handleX10X20X10DiLepton(l1, l2, event, nj):
    invMass = (l1.p4() + l2.p4()).M()

    l1v = TLorentzVector()
    l2v = TLorentzVector()
    l1v.SetPxPyPzE(l1.p4().px(), l1.p4().py(), l1.p4().pz(), l1.p4().e())
    l2v.SetPxPyPzE(l2.p4().px(), l2.p4().py(), l2.p4().pz(), l2.p4().e())

    deltaPhi = l1v.DeltaPhi(l2v)
    deltaEta = abs(l1v.Eta() - l2v.Eta())
    utils.fillHistWithCuts("DeltaPhiCan", deltaPhi, histList, cutsDef, "aod",
                           event)
    utils.fillHistWithCuts("DeltaRCan", l1v.DeltaR(l2v), histList, cutsDef,
                           "aod", event)
    utils.fillHistWithCuts("DeltaEtaCan", deltaEta, histList, cutsDef, "aod",
                           event)
    utils.fillHistWithCuts("DuoLepCanInvMass", invMass, histList, cutsDef,
                           "aod", event)
    if nj == 1:
        utils.fillHistWithCuts("DuoLepCanInvMass1J", invMass, histList,
                               cutsDef, "aod", event)
        utils.fillHistWithCuts("DeltaPhiCan1J", deltaPhi, histList, cutsDef,
                               "aod", event)
        utils.fillHistWithCuts("DeltaRCan1J", l1v.DeltaR(l2v), histList,
                               cutsDef, "aod", event)
        utils.fillHistWithCuts("DeltaEtaCan1J", deltaEta, histList, cutsDef,
                               "aod", event)
    elif nj == 2:
        utils.fillHistWithCuts("DuoLepCanInvMass2J", invMass, histList,
                               cutsDef, "aod", event)
        utils.fillHistWithCuts("DeltaPhiCan2J", deltaPhi, histList, cutsDef,
                               "aod", event)
        utils.fillHistWithCuts("DeltaRCan2J", l1v.DeltaR(l2v), histList,
                               cutsDef, "aod", event)
        utils.fillHistWithCuts("DeltaEtaCan2J", deltaEta, histList, cutsDef,
                               "aod", event)