def validateMomenta(self, jet, tolerance=.01): """ Checks if the jetmomentum is the sum of the constituent momenta. """ v = TLorentzVector(0, 0, 0, 0) for comp in jet.constituents.values(): for ptc in comp: v += ptc.p4() ret = True if abs(jet.pt() - v.Pt()) > tolerance: print 'pt unequal: ', jet.pt() - v.Pt() ret = False if abs(jet.theta() - v.Theta()) > tolerance: print 'theta unequal: ', jet.theta() - v.Theta() ret = False if abs(jet.eta() - v.Eta()) > tolerance: print 'eta unequal', jet.eta() - v.Eta() ret = False if abs(jet.phi() - v.Phi()) > tolerance: print 'phi unequal: ', jet.phi() - v.Phi() ret = False if abs(jet.m() - v.M()) > tolerance: print 'mass unequal: ', jet.m() - v.M() ret = False return ret
def getGenVpt(event): GenVpt = 0. VPt = -1. idx_V = -1 LepP = TLorentzVector() LepM = TLorentzVector() particle_masses = {11 : 0.000511, 12 : 0., 13 : 0.10566, 14 : 0., 15 : 1.77686, 16 : 0.} for idx_gen in range(event.nGenPart): if event.GenPart_pdgId[idx_gen] == 23 or event.GenPart_pdgId[idx_gen] == 24: if VPt<=0.: VPt = event.GenPart_pt[idx_gen] idx_V = idx_gen else: if event.GenPart_genPartIdxMother[idx_gen]==idx_V: VPt = event.GenPart_pt[idx_gen] idx_V = idx_gen elif (event.GenPart_status[idx_gen]==1 and event.GenPart_pdgId[idx_gen] >= +11 and event.GenPart_pdgId[idx_gen] <= +16) or (event.GenPart_pdgId[idx_gen]== +15 and event.GenPart_status[idx_gen]==2): if event.GenPart_pt[idx_gen]>LepP.Pt(): particle_mass = particle_masses[abs(event.GenPart_pdgId[idx_gen])] LepP.SetPtEtaPhiM(event.GenPart_pt[idx_gen],event.GenPart_eta[idx_gen],event.GenPart_phi[idx_gen],particle_mass) elif (event.GenPart_status[idx_gen]==1 and event.GenPart_pdgId[idx_gen] >= -16 and event.GenPart_pdgId[idx_gen] <= -11) or (event.GenPart_pdgId[idx_gen]== -15 and event.GenPart_status[idx_gen]==2): if event.GenPart_pt[idx_gen]>LepM.Pt(): particle_mass = particle_masses[abs(event.GenPart_pdgId[idx_gen])] LepM.SetPtEtaPhiM(event.GenPart_pt[idx_gen],event.GenPart_eta[idx_gen],event.GenPart_phi[idx_gen],particle_mass) if VPt > 0.: GenVpt = VPt elif LepP.Pt() > 0. and LepM.Pt() > 0.: GenVpt = (LepP+LepM).Pt() return GenVpt
def computeProcessedFeatures(muon1_p4, muon2_p4, unpairedMuon_p4, jpsi_p4, bc_p4): if ( bc_p4.M() != 0): bcPtCorrected = (bcPdgMass * bc_p4.Pt())/ bc_p4.M() else: bcPtCorrected = bc_p4.Pt() muonsSystem_p4 = muon1_p4 + muon2_p4 + unpairedMuon_p4 bcCorrected_p4 = TLorentzVector() bcCorrected_p4.SetPtEtaPhiM(bcPtCorrected, muonsSystem_p4.Eta(), muonsSystem_p4.Phi(), #bc_p4.M()) bcPdgMass) boostToBcCorrectedRestFrame = -bcCorrected_p4.BoostVector() #boostToJpsiRestFrame = -(muon1_p4+muon2_p4).BoostVector() boostToJpsiRestFrame = -jpsi_p4.BoostVector() unpairedMuonBoostedToBcCorrectedRestFrame_p4 = TLorentzVector() unpairedMuonBoostedToBcCorrectedRestFrame_p4.SetPtEtaPhiM(unpairedMuon_p4.Pt(), unpairedMuon_p4.Eta(), unpairedMuon_p4.Phi(), unpairedMuon_p4.M()) unpairedMuonBoostedToBcCorrectedRestFrame_p4.Boost(boostToBcCorrectedRestFrame) unpairedMuonBoostedToJpsiRestFrame_p4 = TLorentzVector() unpairedMuonBoostedToJpsiRestFrame_p4.SetPtEtaPhiM(unpairedMuon_p4.Pt(), unpairedMuon_p4.Eta(), unpairedMuon_p4.Phi(), unpairedMuon_p4.M()) unpairedMuonBoostedToJpsiRestFrame_p4.Boost(boostToJpsiRestFrame) nn_energyBcRestFrame = unpairedMuonBoostedToBcCorrectedRestFrame_p4.E() #nn_missMass2 = (bcCorrected_p4 - muon1_p4 - muon2_p4 - unpairedMuon_p4).M2() nn_missMass2 = (bcCorrected_p4 - jpsi_p4 - unpairedMuon_p4).M2() #nn_q2 = (bc_p4 - muon1_p4 - muon2_p4).M2() nn_q2 = (bcCorrected_p4 - jpsi_p4).M2() #nn_missPt = bcCorrected_p4.Pt() - muon1_p4.Pt() - muon2_p4.Pt() - unpairedMuon_p4.Pt() nn_missPt = bcCorrected_p4.Pt() - jpsi_p4.Pt() - unpairedMuon_p4.Pt() nn_energyJpsiRestFrame = unpairedMuonBoostedToJpsiRestFrame_p4.E() #nn_varPt = (muon1_p4 + muon2_p4).Pt() - unpairedMuon_p4.Pt() nn_varPt = jpsi_p4.Pt() - unpairedMuon_p4.Pt() nn_deltaRMu1Mu2 = muon1_p4.DeltaR(muon2_p4) nn_unpairedMuPhi = unpairedMuon_p4.Phi() nn_unpairedMuPt = unpairedMuon_p4.Pt() nn_unpairedMuEta = unpairedMuon_p4.Eta() featuresEntry = np.array([ [bcCorrected_p4.Pt()], [bcCorrected_p4.Px()], [bcCorrected_p4.Py()], [bcCorrected_p4.Pz()], [bcCorrected_p4.E()], [nn_energyBcRestFrame], [nn_missMass2], [nn_q2], [nn_missPt], [nn_energyJpsiRestFrame], [nn_varPt], [nn_deltaRMu1Mu2], [nn_unpairedMuPhi], [nn_unpairedMuPt], [nn_unpairedMuEta]], dtype=np.double) return featuresEntry
class particle: def __init__(self, tree=None, i=None, original=None): if tree: #Build particle instance from TTree self.PID = tree.Particle[i].PID self.mom = tree.Particle[i].Mother1 self.daughters = [] self.m = tree.Particle[i].M self.e = tree.Particle[i].E self.p = TLorentzVector() self.p.SetPxPyPzE(tree.Particle[i].Px, tree.Particle[i].Py, tree.Particle[i].Pz, tree.Particle[i].E) self.pt = self.p.Pt() self.eta = self.p.Eta() self.phi = self.p.Phi() self.SF = 1 self.smear = None self.res = None elif original: #Make a resolution smeared version of the original self.PID = copy(original.PID) self.mom = copy(original.mom) self.daughters = copy(original.daughters) self.res = jetEnergyResolution(original.p.E()) self.smearE = -1 while self.smearE < 0: self.smearE = np.random.normal(0.985, self.res) # self.offsetM = -1 # while self.offsetM+original.p.M() < 5: self.offsetM = np.random.normal(5, 5) # self.smearM = -1 # while self.smearM < 0.5: self.smearM = np.random.normal(1, 1) self.p = TLorentzVector() self.p.SetPtEtaPhiM(original.p.Pt() * self.smearE, original.p.Eta(), original.p.Phi(), 0) # self.p.SetPtEtaPhiM( original.p.Pt() * self.smearE, # original.p.Eta(), # original.p.Phi(), # (original.p.M()+self.offsetM) * self.smearM) self.pt = self.p.Pt() self.eta = self.p.Eta() self.phi = self.p.Phi() self.m = self.p.M() self.e = self.p.E() self.SF = 1 def getDump(self): out = "PID " + str(self.PID).rjust(3) + " | mom " + str( self.mom).rjust(3) + " | mass " + str(self.m).ljust( 12) + " | pt " + str(self.pt).ljust(20) + " | eta " + str( self.eta).ljust(20) + " | phi " + str(self.phi).ljust(20) if self.res: out += " | res " + str(self.res).ljust(20) + " | smear " + str( self.smear).ljust(20) return out def dump(self): print(self.getDump())
def selection(event): vect = TLorentzVector() vect.SetPxPyPzE(event.GenJet[0], event.GenJet[1], event.GenJet[2], event.GenJet[3]) if abs(vect.Eta()) > 0.5 or vect.Pt() < 50 or vect.Pt() > 70: return False vect.SetPxPyPzE(event.Jet[0], event.Jet[1], event.Jet[2], event.Jet[3]) if abs(vect.Eta()) > 0.5 or vect.Pt() < 50: return False else: return True
def PT_miss(Energy,parts): # here parts is visible parts #p=parts[0].p4-parts[0].p4 p=TLorentzVector(0,0,0,Energy) for part in parts: p=p-part.P4() return p.Pt()
def costheta_CS(pt1, eta1, phi1, pt2, eta2, phi2, l1id): mu1 = TLorentzVector() mu2 = TLorentzVector() Q = TLorentzVector() if (l1id < 0): mu1.SetPtEtaPhiM(pt1, eta1, phi1, 0) mu2.SetPtEtaPhiM(pt2, eta2, phi2, 0) else: mu1.SetPtEtaPhiM(pt2, eta2, phi2, 0) mu2.SetPtEtaPhiM(pt1, eta1, phi1, 0) Q = mu1 + mu2 mu1plus = ((2.0)**(-0.5)) * (mu1.E() + mu1.Pz()) mu1minus = ((2.0)**(-0.5)) * (mu1.E() - mu1.Pz()) mu2plus = ((2.0)**(-0.5)) * (mu2.E() + mu2.Pz()) mu2minus = ((2.0)**(-0.5)) * (mu2.E() - mu2.Pz()) costheta = ((2.0 / Q.Mag()) / ((Q.Mag()**2.0 + Q.Pt()**2.0)**(0.5))) * (mu1plus * mu2minus - mu1minus * mu2plus) return costheta
def main(): #Aufgabenteil b) # initialisiere TLorentzVector-Objekt und setze Pt, eta, phi und M. Damit ist der Vierervektor vollstaendig bestimmt c_ = TLorentzVector() c_.SetPtEtaPhiM(99.83, 0.332, -2.45, 0) s = TLorentzVector() s.SetPtEtaPhiM(22.08, 0.137, 2.215, 0) ny = TLorentzVector() ny.SetPtEtaPhiM(44.73, 0, -2.472, 0) mu = TLorentzVector() mu.SetPtEtaPhiM(65.58, 1.08, -0.851, 0) wp = ny + mu # Addiere zwei Vierervektoren wm = c_ + s b = TLorentzVector() b_ = TLorentzVector() b_.SetPtEtaPhiM(74.01, 1.379, 0.494, 0) b.SetPtEtaPhiM(65.34, -0.228, 1.340, 0) t_ = wm + b_ t = wp + b # Ausgabe der invarianten Masse eines Vierervektors print("Masse Anti-Top: " + str(t_.M())) print("Masse Top: " + str(t.M())) print(t_) # Aufgabenteil c) s = t + t_ rapidity = 1 / 2 * math.log((s.E() + s.Pt()) / (s.E() - s.Pt())) print(s.M()) print(s.Pt()) print(s.E()) print(rapidity)
def LHEinfo(event): if event.lheParticles is None: out = { "isZ": -1, "nLep": -1, "llpt": -1, "HT": -1, "nj": -1, "nb": -1, "nc": -1, } return out hepeup = event.lheParticles.hepeup() pup = hepeup.PUP idup = hepeup.IDUP istup = hepeup.ISTUP nup = hepeup.NUP isZ = False lep = [] partons = [] nj = 0 nb = 0 nc = 0 HT = 0 for index, p in enumerate(pup): if idup[index] == 23: isZ = True if abs(idup[index]) in [11, 13, 15]: lep.append(index) if istup[index] == 1 and abs(idup[index]) in [1, 2, 3, 4, 5, 21]: nj += 1 partons.append(p) if istup[index] == 1 and abs(idup[index]) == 5: nb += 1 if istup[index] == 1 and abs(idup[index]) == 4: nc += 1 #print "status ", istup[index], "PID ", idup[index] if len(lep) > 1: if len(lep) > 2: print "Error, too much lhe leptons : ", len(lep) if not (idup[lep[0]] + idup[lep[1]]) == 0: "Error, lhe leptons have same charge" l1 = TLorentzVector(pup[lep[0]][0], pup[lep[0]][1], pup[lep[0]][2], pup[lep[0]][3]) l2 = TLorentzVector(pup[lep[1]][0], pup[lep[1]][1], pup[lep[1]][2], pup[lep[1]][3]) zcand = l1 + l2 llpt = zcand.Pt() else: llpt = -1 for j in partons: j_tlv = TLorentzVector(j[0], j[1], j[2], j[3]) HT += j_tlv.Pt() out = { "isZ": isZ, "nLep": len(lep), "llpt": llpt, "HT": HT, "nj": nj, "nb": nb, "nc": nc, } return out
def TagVars(collections): results=[]; Et_ratio=[]; Dphi=[]; projB=[]; DzTagMuK=[]; DzTagMuL1=[]; DzTagMuL2=[]; tracks=collections[0] Bcands=collections[2] trgmuons=(collections[1]) trgmuon_vec=TLorentzVector() trgmuon_vec.SetPtEtaPhiM(0,0,0,0) trgmuon_vz=-99 for trgmuon in trgmuons: if not getattr(trgmuon,"isTriggering"): continue; trgmuon_vec.SetPtEtaPhiM(getattr(trgmuon,"pt"),getattr(trgmuon,"eta"),getattr(trgmuon,"phi"),0.105) trgmuon_vz=getattr(trgmuon,"vz") break if trgmuon_vec.M()==0: result=[[0], [0], [0], [0], [0], [0]] return result sum_track_vec=trgmuon_vec; sum_track=trgmuon_vec.Pt(); for track in tracks: track_vec=TLorentzVector(); track_vec.SetPtEtaPhiM(getattr(track,"pt"),getattr(track,"eta"),getattr(track,"phi"),0.139) if trgmuon_vec.DrEtaPhi(track_vec)>0.4: continue sum_track_vec=sum_track_vec+track_vec; sum_track+=track_vec.Pt() for Bcand in Bcands: Bcand_vec=TLorentzVector(); Bcand_vec.SetPtEtaPhiM(getattr(Bcand,"fit_pt"),getattr(Bcand,"fit_eta"),getattr(Bcand,"fit_phi"),getattr(Bcand,"fit_mass")) if sum_track>0: Et_ratio.append(Bcand_vec.Et()/sum_track) else: Et_ratio.append(0) Dphi.append(Bcand_vec.DeltaPhi(sum_track_vec)) projB.append(Bcand_vec*sum_track_vec) DzTagMuK.append( abs(trgmuon_vz-getattr(Bcand,"kVz")) ) DzTagMuL1.append( abs(trgmuon_vz-getattr(Bcand,"l1Vz")) ) DzTagMuL2.append( abs(trgmuon_vz-getattr(Bcand,"l2Vz")) ) result=[Et_ratio, Dphi, projB, DzTagMuL1, DzTagMuL2, DzTagMuK] return result
def TagVarsMC(collections): results=[]; Et_ratio=-99.; Dphi=-99.; projB=-99. tracks=collections[0] trgmuons=collections[1] recoB_pt=collections[2] recoB_eta=collections[3] recoB_phi=collections[4] recoB_mass=collections[5] recoE1_vz=collections[6] recoE2_vz=collections[7] recoK_vz=collections[8] trgmuon_vec=TLorentzVector() trgmuon_vec.SetPtEtaPhiM(0,0,0,0) for trgmuon in trgmuons: if getattr(trgmuon,"isTriggering")==0: continue trgmuon_vec.SetPtEtaPhiM(getattr(trgmuon,"pt"),getattr(trgmuon,"eta"),getattr(trgmuon,"phi"),0.105) break if trgmuon_vec.M()==0: result=[-99.,-99.,-99.,-99.,-99.,-99.] return result sum_track_vec=trgmuon_vec; sum_track=trgmuon_vec.Pt(); trgmuon_vz=getattr(trgmuon,"vz") for track in tracks: track_vec=TLorentzVector(); track_vec.SetPtEtaPhiM(getattr(track,"pt"),getattr(track,"eta"),getattr(track,"phi"),0.139) if trgmuon_vec.DrEtaPhi(track_vec)>0.4: continue sum_track_vec=sum_track_vec+track_vec; sum_track+=track_vec.Pt() recoB_vec=TLorentzVector(); recoB_vec.SetPtEtaPhiM(recoB_pt,recoB_eta,recoB_phi,recoB_mass) if sum_track>0: Et_ratio=recoB_vec.Et()/sum_track else: Et_ratio=0 Dphi=recoB_vec.DeltaPhi(sum_track_vec) projB=recoB_vec*sum_track_vec result=[Et_ratio,Dphi,projB,abs(trgmuon_vz-recoE1_vz),abs(trgmuon_vz-recoE2_vz),abs(trgmuon_vz-recoK_vz)] return result
def corrected_p4(self, mu, run): p4 = TLorentzVector(mu.px(), mu.py(), mu.pz(), mu.energy()) if self.isMC: self.corr.applyPtCorrection(p4, mu.charge()) self.corr.applyPtSmearing(p4, mu.charge(), self.isSync) else: corr = self.corrD if run >= 203773 else self.corrABC corr.applyPtCorrection(p4, mu.charge()) ## convert to the proper C++ class (but preserve the mass!) return ROOT.reco.Muon.PolarLorentzVector(p4.Pt(), p4.Eta(), p4.Phi(), mu.mass())
def read(self, iev): #read a given event if iev >= self.nev: return False self.tree.GetEntry(iev) #initialize event variables self.epos = 0. self.eneg = 0. self.npos = 0 self.nneg = 0 self.is_XnXn = False self.is_Cen = True vec = TLorentzVector() #particle loop for imc in xrange(self.particles.GetEntriesFast()): part = self.particles.At(imc) #central electron and positron if TMath.Abs(part.GetPdgCode()) == 11: if TMath.Abs(part.Eta()) > self.aeta_max: self.is_Cen = False #if part.P() < self.p_min: self.is_Cen = False pv = TLorentzVector() part.Momentum(pv) vec += pv #select the neutrons if part.GetPdgCode() != 2112: continue #energy at positive and negative rapidity if part.Eta() > 0: self.epos += part.Energy() self.npos += 1 else: self.eneg += part.Energy() self.nneg += 1 #particle loop #flag for XnXn event if self.npos > 0 and self.nneg > 0: self.is_XnXn = True #J/psi kinematics self.pT = vec.Pt() self.y = vec.Rapidity() self.m = vec.M() return True
def D0VarsMC(collections): L1charge=collections[0] L1Pt=collections[1] L1Eta=collections[2] L1Phi=collections[3] L2charge=collections[4] L2Pt=collections[5] L2Eta=collections[6] L2Phi=collections[7] Kcharge=collections[8] KPt=collections[9] KEta=collections[10] KPhi=collections[11] trk_opp_l_kpi_mass=-99 trk_opp_l_mumu_mass=-99 if (L1charge<-1 or L2charge<-1 or Kcharge<-1): return [trk_opp_l_kpi_mass,trk_opp_l_mumu_mass] vK=TLorentzVector() vL=TLorentzVector() if L1charge != Kcharge: vL.SetPtEtaPhiM(L1Pt,L1Eta,L1Phi,0.493) else: vL.SetPtEtaPhiM(L2Pt,L2Eta,L2Phi,0.493) vK.SetPtEtaPhiM(KPt,KEta,KPhi,0.139) # getattr(Bcand,"fit_k_pt"), getattr(Bcand,"fit_k_eta"), getattr(Bcand,"fit_k_phi"),0.139) trk_opp_l_kpi_mass= (vL+vK).M() vL.SetPtEtaPhiM(vL.Pt(),vL.Eta(),vL.Phi(),0.139) vK.SetPtEtaPhiM(vK.Pt(),vK.Eta(),vK.Phi(),0.493) if trk_opp_l_kpi_mass>(vL+vK).M(): trk_opp_l_kpi_mass=(vL+vK).M() vK.SetPtEtaPhiM(vK.Pt(),vK.Eta(),vK.Phi(),0.105) vL.SetPtEtaPhiM(vL.Pt(),vL.Eta(),vL.Phi(),0.105) trk_opp_l_mumu_mass=(vL+vK).M() return [trk_opp_l_kpi_mass,trk_opp_l_mumu_mass]
def TagVarsMC(collections): results = [] Et_ratio = [] Dphi = [] projB = [] tracks = collections[0] trgmuons = collections[1] recoB_pt = collections[2] recoB_eta = collections[3] recoB_phi = collections[4] recoB_mass = collections[5] if len(trgmuons) == 0: default = [-99., -99., -99.] return default trgmuon = trgmuons[0] trgmuon_vec = TLorentzVector() trgmuon_vec.SetPtEtaPhiM(getattr(trgmuon, "pt"), getattr(trgmuon, "eta"), getattr(trgmuon, "phi"), 0.105) sum_track_vec = trgmuon_vec sum_track = trgmuon_vec.Pt() for track in tracks: track_vec = TLorentzVector() track_vec.SetPtEtaPhiM(getattr(track, "pt"), getattr(track, "eta"), getattr(track, "phi"), 0.139) if trgmuon_vec.DrEtaPhi(track_vec) > 0.4: continue sum_track_vec = sum_track_vec + track_vec sum_track += track_vec.Pt() recoB_vec = TLorentzVector() recoB_vec.SetPtEtaPhiM(recoB_pt, recoB_eta, recoB_phi, recoB_mass) if sum_track > 0: Et_ratio = recoB_vec.Et() / sum_track else: Et_ratio = 0 Dphi = recoB_vec.DeltaPhi(sum_track_vec) projB = recoB_vec * sum_track_vec result = [Et_ratio, Dphi, projB] return result
def TagVars(collections): results = [] Et_ratio = [] Dphi = [] projB = [] tracks = collections[0] Bcands = collections[2] trgmuon = (collections[1])[0] trgmuon_vec = TLorentzVector() trgmuon_vec.SetPtEtaPhiM(getattr(trgmuon, "pt"), getattr(trgmuon, "eta"), getattr(trgmuon, "phi"), 0.105) sum_track_vec = trgmuon_vec sum_track = trgmuon_vec.Pt() for track in tracks: track_vec = TLorentzVector() track_vec.SetPtEtaPhiM(getattr(track, "pt"), getattr(track, "eta"), getattr(track, "phi"), 0.139) if trgmuon_vec.DrEtaPhi(track_vec) > 0.4: continue sum_track_vec = sum_track_vec + track_vec sum_track += track_vec.Pt() for Bcand in Bcands: Bcand_vec = TLorentzVector() Bcand_vec.SetPtEtaPhiM(getattr(Bcand, "fit_pt"), getattr(Bcand, "fit_eta"), getattr(Bcand, "fit_phi"), getattr(Bcand, "fit_mass")) if sum_track > 0: Et_ratio.append(Bcand_vec.Et() / sum_track) else: Et_ratio.append(0) Dphi.append(Bcand_vec.DeltaPhi(sum_track_vec)) projB.append(Bcand_vec * sum_track_vec) result = [Et_ratio, Dphi, projB] return result
def insideLoop(self,t): # Simple analysis: lets draw the invariant mass of two muons # Lets require medium Id for the muons selMuon = []; for i in range(t.nJet): p = TLorentzVector() p.SetPtEtaPhiM(t.Jet_pt[i], t.Jet_eta[i], t.Jet_phi[i], t.Jet_mass[i]) csv = t.Jet_btagCSVV2[i]; deepcsv = t.Jet_btagDeepB[i]; dflav = t.Jet_btagDeepFlavB[i] jindex = i jid = t.Jet_jetId[i] flav = t.Jet_hadronFlavour[i] if not self.isData else -99; # Jet ID > 1, tight Id pt = p.Pt(); eta = abs(p.Eta()) if not jid >= 1: continue if eta > 2.4 or pt < 20: continue if flav == 5: # is a b!! tip = 'B' for year in self.years: for tag, tval in zip([self.CSVtag, self.deepCSVtag, self.dflavtag], [csv, deepcsv, dflav]): nameS = '%s%s_%s'%(tag,tip,year) self.obj[nameS].Fill(tval) self.GetHisto(year, tag, 'D', tip).Fill(pt, eta) for wp in self.wptag: val = self.wps[year][tag][wp] if tval > val: self.GetHisto(year, tag, wp, tip).Fill(pt,eta) elif flav == 4: # is a c!! tip = 'C' for year in self.years: for tag, tval in zip([self.CSVtag, self.deepCSVtag, self.dflavtag], [csv, deepcsv, dflav]): nameS = '%s%s_%s'%(tag,tip,year) self.obj[nameS].Fill(tval) self.GetHisto(year, tag, 'D', tip).Fill(pt, eta) for wp in self.wptag: val = self.wps[year][tag][wp] if tval > val: self.GetHisto(year, tag, wp, tip).Fill(pt,eta) else: # light tip = 'L' for year in self.years: for tag, tval in zip([self.CSVtag, self.deepCSVtag, self.dflavtag], [csv, deepcsv, dflav]): nameS = '%s%s_%s'%(tag,tip,year) self.obj[nameS].Fill(tval) self.GetHisto(year, tag, 'D', tip).Fill(pt, eta) for wp in self.wptag: val = self.wps[year][tag][wp] if tval > val: self.GetHisto(year, tag, wp, tip).Fill(pt,eta)
def shiftMET(): """Test function to see how one can apply a shift to the MET.""" print ">>> create TLVs..." shift = 1.05 # 5% jet1 = TLorentzVector() jet2 = TLorentzVector() met = TLorentzVector() jet1.SetPtEtaPhiM(40.0, 1.5, 0.0, 4.0) jet2.SetPtEtaPhiM(30.0, -2.5, 1.5, 10.0) met.SetPtEtaPhiM(45.0, 0.0, -2.3, 0.0) printTLV(jet1, jet2, met, names=["tlv1", "tlv2", "met"], header=True) # SHIFT JET ENERGY jet1_shift = TLorentzVector() jet1_shift.SetPtEtaPhiM(shift * jet1.Pt(), jet1.Eta(), jet1.Phi(), shift * jet1.M()) jet2_shift = TLorentzVector() jet2_shift.SetPtEtaPhiM(shift * jet2.Pt(), jet2.Eta(), jet2.Phi(), shift * jet2.M()) #jet1_shift2 = shift*jet1 #jet2_shift2 = shift*jet2 printTLV(jet1_shift, jet2_shift, names=["jet1_shift", "jet2_shift"]) # SHIFT MET dtlv = TLorentzVector() dtlv += (jet1 - jet1_shift) dtlv += (jet2 - jet2_shift) printTLV(dtlv, names=["dtlv"]) met_shift1 = met - dtlv met_shift2 = TLorentzVector() met_shift2.SetPtEtaPhiM(met_shift1.Pt(), 0, met_shift1.Phi(), 0) printTLV(met_shift1, met_shift2, names=["met_shift1", "met_shift2"])
def D0Vars(collections): Bcands=collections[0] trk_opp_l_kpi_mass=[] trk_opp_l_mumu_mass=[] for Bcand in Bcands: vK=TLorentzVector() vL=TLorentzVector() kcharge=getattr(Bcand,"k_charge") if getattr(Bcand,"l1_charge") == getattr(Bcand,"l2_charge"): if getattr(Bcand,"l1_charge") == getattr(Bcand,"k_charge"): trk_opp_l_kpi_mass.append(-1) trk_opp_l_mumu_mass.append(-1) continue; else: vL.SetPtEtaPhiM( getattr(Bcand,"fit_l1_pt"), getattr(Bcand,"fit_l1_eta"), getattr(Bcand,"fit_l1_phi"),0.493) else: if getattr(Bcand,"l1_charge") != kcharge: vL.SetPtEtaPhiM( getattr(Bcand,"fit_l1_pt"), getattr(Bcand,"fit_l1_eta"), getattr(Bcand,"fit_l1_phi"),0.493) else: vL.SetPtEtaPhiM( getattr(Bcand,"fit_l2_pt"), getattr(Bcand,"fit_l2_eta"), getattr(Bcand,"fit_l2_phi"),0.493) vK.SetPtEtaPhiM( getattr(Bcand,"fit_k_pt"), getattr(Bcand,"fit_k_eta"), getattr(Bcand,"fit_k_phi"),0.139) k_l_mass_hypoth1=(vL+vK).M() vL.SetPtEtaPhiM( vL.Pt(),vL.Eta(),vL.Phi(),0.139) vK.SetPtEtaPhiM( vK.Pt(),vK.Eta(),vK.Phi(),0.493) if k_l_mass_hypoth1> (vL+vK).M(): trk_opp_l_kpi_mass.append((vL+vK).M()) else: trk_opp_l_kpi_mass.append(k_l_mass_hypoth1) vL.SetPtEtaPhiM( vL.Pt(),vL.Eta(),vL.Phi(),0.105) vK.SetPtEtaPhiM( vK.Pt(),vK.Eta(),vK.Phi(),0.105) trk_opp_l_mumu_mass.append((vL+vK).M()) return [trk_opp_l_kpi_mass,trk_opp_l_mumu_mass]
def add_obj(mem, typ, **kwargs): if kwargs.has_key("p4s"): pt, eta, phi, mass = kwargs.pop("p4s") v = TLorentzVector() v.SetPtEtaPhiM(pt, eta, phi, mass) elif kwargs.has_key("p4c"): v = TLorentzVector(*kwargs.pop("p4c")) obsdict = kwargs.pop("obsdict", {}) o = MEM.Object(v, typ) if typ == MEM.ObjectType.Jet: tb, tl = attach_jet_transfer_function(v.Pt(), v.Eta()) o.addTransferFunction(MEM.TFType.qReco, tl) o.addTransferFunction(MEM.TFType.bReco, tb) for k, v in obsdict.items(): o.addObs(k, v) mem.push_back_object(o)
def analyze(self, event): #print ">>> ExampleAnalysis.analyze" electrons = Collection(event, "Electron") muons = Collection(event, "Muon") jets = Collection(event, "Jet") eventSum = TLorentzVector() # select events with at least 2 muons if len(muons) >= 2: for lep in muons: #loop on muons eventSum += lep.p4() for lep in electrons: #loop on electrons eventSum += lep.p4() for j in jets: #loop on jets eventSum += j.p4() #self.h_vpt.Fill(eventSum.Pt()) #fill histogram self.out.fillBranch("sumpt", eventSum.Pt()) # fill branch return True
def Transform(Px, Py, Pz, E): N = Px.shape[0] Pt = np.zeros(N) Eta = np.zeros(N) Phi = np.zeros(N) M = np.zeros(N) LV = TLorentzVector() print('\tStarting Transformation') for i in range(0, N): sys.stdout.write('\r') sys.stdout.write('\tCurrent process : %0.2f%%' % (i % N / N * 100)) sys.stdout.flush() LV.SetPx(Px[i]) LV.SetPy(Py[i]) LV.SetPz(Pz[i]) LV.SetE(E[i]) Pt[i] = LV.Pt() Eta[i] = LV.Eta() Phi[i] = LV.Phi() M[i] = LV.M() print() return Pt, Eta, Phi, M
e3 = float(b[0].split()[9]) p3 = TLorentzVector(px3, py3, pz3, e3) if bbar: px4 = float(bbar[0].split()[6]) py4 = float(bbar[0].split()[7]) pz4 = float(bbar[0].split()[8]) e4 = float(bbar[0].split()[9]) p4 = TLorentzVector(px4, py4, pz4, e4) HggP4 = p1 + p2 HbbP4 = p3 + p4 m_H1.append(HggP4.M()) m_H2.append(HbbP4.M()) b_pT.append(p3.Pt()) b_eta.append(p3.Eta()) b_phi.append(p3.Phi()) bbar_pT.append(p4.Pt()) bbar_eta.append(p4.Eta()) bbar_phi.append(p4.Phi()) a_pT.append(p1.Pt()) a_eta.append(p1.Eta()) a_phi.append(p1.Phi()) for i in m_H1: h_m_H1.Fill(i) hists1.append(h_m_H1)
num_part = int(event_header.split()[0].strip()) phi = [s for s in lines if s.split()[0] == '55'] chi = [s for s in lines if s.split()[0] == '52'] chibar = [s for s in lines if s.split()[0] == '-52'] b = [s for s in lines if s.split()[0] == '5'] bbar = [s for s in lines if s.split()[0] == '-5'] if phi: px = float(phi[0].split()[6]) py = float(phi[0].split()[7]) pz = float(phi[0].split()[8]) e = float(phi[0].split()[9]) p = TLorentzVector(px, py, pz, e) pt_phi1.append(p.Pt()) px1 = float(chi[0].split()[6]) py1 = float(chi[0].split()[7]) pz1 = float(chi[0].split()[8]) e1 = float(chi[0].split()[9]) px2 = float(chibar[0].split()[6]) py2 = float(chibar[0].split()[7]) pz2 = float(chibar[0].split()[8]) e2 = float(chibar[0].split()[9]) p1 = TLorentzVector(px1, py1, pz1, e1) p2 = TLorentzVector(px2, py2, pz2, e2) pi = p1 + p2
def main(): # parse options from command line parser = OptionParser(usage="usage: %prog arguments", version="%prog") parser.add_option("-f", "--input", dest="infile", help="Input File (default: %default)") parser.add_option("-o", "--outdir", dest="outdir", help="Out Directory (default: %default)") parser.add_option("-c", "--configfile", dest="configfile", help="files to be analysed (default: %default)") parser.add_option( "-p", "--process", dest="process", help="process to be converted in images (default: %default)") parser.add_option( "-n", "--nevents", dest="nevents", type="int", help="Number of events to be converted (default: %default)") parser.add_option( "-m", "--mltop", dest="mltop", action="store_true", help="If mlb circumferences are included or not (default: %default)") parser.add_option( "-s", "--sfactor", dest="sfactor", type="float", help="Size factor to manipulate the circles size (default: %default)") parser.add_option( "-r", "--random", dest="rand", action="store_true", help="Select the events randomly from the csv file (default: %default)" ) parser.add_option("-v", "--verbose", dest="verbose", action="store_true", help="print more information (default: %default)") parser.set_defaults(verbose=True, infile="", outdir="", configfile="DarkConfiguration.py") (options, args) = parser.parse_args() # The .csv path is built using ./DarkConfiguration.py configModuleName = options.configfile.replace(".py", "") configuration = importlib.import_module(configModuleName) # Reading set-up information from configfile. But priority is given to the parser options. # (default: %default) makes non-specified option variables to store as a None by default. process = options.process if options.process != None else configuration.SetUp[ "Process"] Nevents = options.nevents if options.nevents != None else configuration.SetUp[ "Nevents"] mltop = options.mltop if options.mltop != None else configuration.SetUp[ "mltop"] sfactor = options.sfactor if options.sfactor != None else configuration.SetUp[ "sf"] random = options.rand if options.rand != None else configuration.SetUp[ "random"] # According to the process specified, the corresponding .csv and the output directory are indicated if process != None: infile = options.infile if options.infile != "" else configuration.Directories[ "InputCSVdirectory"] + "/" + configuration.Processes[process] outdir = options.outdir if options.outdir != "" else configuration.Directories[ "OutputDirectory"] + "/" + process if not os.path.exists(outdir): os.makedirs(outdir) else: print("No process was specified") sys.exit() Save = True positive = 0 # To count how many + and - charged leptons are in the selected data negative = 0 try: InputFile = open(infile, 'r') lines = InputFile.readlines() if len(lines) - 1 < Nevents: Nevents = len(lines) - 1 #Display image conversion set up print( "//////////////////////////////////////////////////////////////////////////////////" ) print("// Reading from %s and saving into %s " % (configuration.Processes[process], outdir)) print("// This file contains %d %s events" % (len(lines) - 1, process)) print("// Converting %d %s events into images %s" % (Nevents, process, "randomly" if random else "")) print("// These images consist in filled circles %s" % ("with mlb circumfereces included" if mltop else " ")) print( "//////////////////////////////////////////////////////////////////////////////////" ) count = 0 # It counts every completed iteration attempt = 0 # It counts every tried iteration seed(1) cache = [] while Save: if not lines: break if random: #Random choice of lines, without repeating rnd = randint(0, len(lines) - 1) if rnd in cache: continue else: cache.append(rnd) eventline = rnd else: #Reading every line in order eventline = attempt attempt += 1 line = lines[eventline] # print(eventline) line = line.strip() objects = line.split(";") # Objects nBJets = [] nLep = [] nJets = [] lepton = "" # print(eventline) # MET met = TLorentzVector() met.SetPtEtaPhiM( float(objects[3]) / 1000., 0, float(objects[4]), 0) # print(met.Pt()) # print(eventline) # Check Particles (leptons, jets and bjets) for obj in objects: if len(obj.split(",")) == 5: part = obj.split(",") if part[0] == 'b': bjet = TLorentzVector() bjet.SetPtEtaPhiE( float(part[2]) / 1000., float(part[3]), float(part[4]), float(part[1]) / 1000.) nBJets.append(bjet) if part[0] == 'j': jet = TLorentzVector() jet.SetPtEtaPhiE( float(part[2]) / 1000., float(part[3]), float(part[4]), float(part[1]) / 1000.) nJets.append(jet) if (part[0][0] == 'e' or part[0][0] == "m"): lepton = part[0] lep = TLorentzVector() lep.SetPtEtaPhiE( float(part[2]) / 1000., float(part[3]), float(part[4]), float(part[1]) / 1000.) nLep.append(lep) # print(eventline) # Number of Leptons if len(nLep) != 1: continue # print(eventline) # Transverse Mass Cut if not MTW(nLep[0], met) > 30: continue # print(eventline) # H_T > 100 GeV cut if not HT(nJets, nBJets) > 100: continue if met.Pt() < 30: print("MET =" + str(met.Pt())) # Number of positive and negative charge lepton for t-channel and Wt single top processes if lepton[1] == '-': negative += 1 else: positive += 1 # print(eventline) # Labeling every image eventNumber = int(objects[0]) * 1000000 + eventline # print("%s %d" % (objects[0],eventline)) createCanvas(eventNumber, nJets, nBJets, nLep, met, outdir, mltop, sfactor) count += 1 #Display the progress if float(count) / 5000. - int(float(count) / 5000.) == 0: print("Images already generated: " + str(count)) if count >= Nevents - 1 or attempt >= Nevents - 1: Save = False except IOError: errmsg = " File %s does not exist!" % infile print(bcolors.FAIL + errmsg + bcolors.ENDC) sys.exit() print("A total of %d events were converted into images" % count) print("There are %d positive leptons and %d negative ones" % (positive, negative))
for event in events: # if count>10:break tau_mad = TLorentzVector(0,0,0,0) neu_mad = TLorentzVector(0,0,0,0) count = count+1 event.getByLabel(labelPruned, handlePruned) pruned = handlePruned.product() event.getByLabel(geninfoLabel,geninfo) info_pruned = geninfo.product() weight_mad = info_pruned.weight()/abs(info_pruned.weight()) if count%100==0: print "count = ", count, 'weight: ', weight_mad for i in range(pruned.hepeup().NUP): if abs(pruned.hepeup().IDUP[i])==15: tau_mad.SetPxPyPzE(pruned.hepeup().PUP[i][0],pruned.hepeup().PUP[i][1],pruned.hepeup().PUP[i][2],pruned.hepeup().PUP[i][3]) lphi_mad.Fill(tau_mad.Phi(),weight_mad) lpt_mad.Fill(tau_mad.Pt(),weight_mad) leta_mad.Fill(tau_mad.Eta(),weight_mad) if abs(pruned.hepeup().IDUP[i])==16: neu_mad.SetPxPyPzE(pruned.hepeup().PUP[i][0],pruned.hepeup().PUP[i][1],pruned.hepeup().PUP[i][2],pruned.hepeup().PUP[i][3]) neuphi_mad.Fill(neu_mad.Phi(),weight_mad) neupt_mad.Fill(neu_mad.Pt(),weight_mad) neueta_mad.Fill(neu_mad.Eta(),weight_mad) lphi_mad.Scale(1./lphi_mad.Integral()) lpt_mad.Scale(1./lpt_mad.Integral()) leta_mad.Scale(1./leta_mad.Integral()) neuphi_mad.Scale(1./neuphi_mad.Integral()) neupt_mad.Scale(1./neupt_mad.Integral()) neueta_mad.Scale(1./neueta_mad.Integral()) lphi_mad.SetMaximum(1.4*lphi_mad.GetMaximum()) lpt_mad.SetMaximum(1.4*lpt_mad.GetMaximum()) leta_mad.SetMaximum(1.4*leta_mad.GetMaximum())
def analyze(self, event): """Process event, return True (go to next module) or False (fail, go to next event).""" if self.isMC: PUWeight = 1. #self.puTool.getWeight(event.Pileup_nTrueInt) GenWeight = 1. if 'signal' in self.name.lower(): jetIds = [ ] for ijet in range(event.nJet): if event.Jet_pt[ijet] < 30: continue if abs(event.Jet_eta[ijet]) > 2.5: continue if event.Jet_jetId[ijet]<6: continue #if event.Jet_chEmEF[ijet]>0.9: continue ##FIXME #if (self.year==2017 or self.year==2018) and event.Jet_chEmEF[ijet]>0.8:continue jetIds.append(ijet) BTagAK4Weight_deepJet = self.btagToolAK4_deepJet.getWeight(event,jetIds, "central") BTagAK4Weight_deepJet_up = self.btagToolAK4_deepJet_up.getWeight(event,jetIds, "up") BTagAK4Weight_deepJet_down = self.btagToolAK4_deepJet_down.getWeight(event,jetIds, "down") self.out.events.Fill(0., BTagAK4Weight_deepJet) else: GenWeight = -1. if event.genWeight<0 else 1. self.out.events.Fill(0., GenWeight) try: LHEWeight = event.LHEWeight_originalXWGTUP self.out.original.Fill(0.,LHEWeight) except: self.out.original.Fill(0.,-1.) self.out.pileup.Fill(event.Pileup_nTrueInt) ## Event filter preselection passedMETFilters = False try: if event.Flag_goodVertices and event.Flag_globalSuperTightHalo2016Filter and event.Flag_BadPFMuonFilter and event.Flag_EcalDeadCellTriggerPrimitiveFilter and event.Flag_HBHENoiseFilter and event.Flag_HBHENoiseIsoFilter and (self.isMC or event.Flag_eeBadScFilter) and event.Flag_ecalBadCalibFilter: passedMETFilters = True except: passedMETFilters = False if not passedMETFilters: return False ## jet order check if event.nJet < 2: return False if event.Jet_pt[0]>event.Jet_pt[1]: leading1 = 0 leading2 = 1 else: leading1 = 1 leading2 = 0 for ijet in range(event.nJet)[2:]: if event.Jet_pt[ijet] > event.Jet_pt[leading1]: leading2=leading1 leading1=ijet elif event.Jet_pt[ijet] > event.Jet_pt[leading2]: leading2=ijet ## Loop over Jets jetIds = [ ] jetHT = 0. jetBTagLoose, jetBTagMedium, jetBTagTight = 0, 0, 0 for ijet in range(event.nJet): if event.Jet_pt[ijet] < 30: continue if abs(event.Jet_eta[ijet]) > 2.5: continue if event.Jet_jetId[ijet]<6: continue #if event.Jet_chEmEF[ijet]>0.9: continue ## FIXME #if (self.year==2017 or self.year==2018) and event.Jet_chEmEF[ijet]>0.8:continue jetIds.append(ijet) jetHT += event.Jet_pt[ijet] if event.Jet_btagDeepFlavB[ijet] >= self.btagLoose: jetBTagLoose += 1 if event.Jet_btagDeepFlavB[ijet] >= self.btagMedium: jetBTagMedium += 1 if event.Jet_btagDeepFlavB[ijet] >= self.btagTight: jetBTagTight += 1 ## Jet-based event selections if len(jetIds)<2: return False #if event.Jet_jetId[jetIds[0]] < 2: return False #if event.Jet_jetId[jetIds[1]] < 2: return False #if event.MET_pt/jetHT > 0.5: return False ### evaluate BTag weights ## put in beginning of analyze in order to get the weight into the normalization #if 'signal' in self.name.lower(): # BTagAK4Weight_deepJet = self.btagToolAK4_deepJet.getWeight(event,jetIds) # BTagAK4Weight_deepJet_up = self.btagToolAK4_deepJet_up.getWeight(event,jetIds) # BTagAK4Weight_deepJet_down = self.btagToolAK4_deepJet_down.getWeight(event,jetIds) ## Compute dijet quantities j1_p4 = TLorentzVector() j1_p4.SetPtEtaPhiM(event.Jet_pt[jetIds[0]], event.Jet_eta[jetIds[0]], event.Jet_phi[jetIds[0]], event.Jet_mass[jetIds[0]]) j2_p4 = TLorentzVector() j2_p4.SetPtEtaPhiM(event.Jet_pt[jetIds[1]], event.Jet_eta[jetIds[1]], event.Jet_phi[jetIds[1]], event.Jet_mass[jetIds[1]]) self.out.jj_mass[0] = (j1_p4+j2_p4).M() self.out.jj_deltaEta[0] = abs(event.Jet_eta[jetIds[0]]-event.Jet_eta[jetIds[1]]) self.out.jj_deltaPhi[0] = abs(j1_p4.DeltaPhi(j2_p4)) #abs(event.Jet_phi[jetIds[0]]-event.Jet_phi[jetIds[1]]) this does not account for phi jump from 2pi to 0 ## Dijet-based event selections if self.out.jj_mass[0] < 800: return False # will need to change this when deriving the trigger efficiency j1_p4_lepcorr = j1_p4 * (1. + event.Jet_chEmEF[jetIds[0]]+event.Jet_muEF[jetIds[0]]) j2_p4_lepcorr = j2_p4 * (1. + event.Jet_chEmEF[jetIds[1]]+event.Jet_muEF[jetIds[1]]) self.out.jj_mass_lepcorr[0] = (j1_p4_lepcorr+j2_p4_lepcorr).M() met_p4 = TLorentzVector() met_p4.SetPtEtaPhiM(event.MET_pt, 0., event.MET_phi, 0.) j1_p4_metcorr = j1_p4 * (1. + event.MET_pt/j1_p4.Pt() * math.cos(j1_p4.DeltaPhi(met_p4)+3.1415)) j2_p4_metcorr = j2_p4 * (1. + event.MET_pt/j2_p4.Pt() * math.cos(j2_p4.DeltaPhi(met_p4)+3.1415)) self.out.jj_mass_metcorr[0] = (j1_p4_metcorr+j2_p4_metcorr).M() wj1_p4 = j1_p4 wj2_p4 = j2_p4 for ijet in range(event.nJet): if ijet == jetIds[0] or ijet == jetIds[1]: continue if event.Jet_pt[ijet] < 30 or abs(event.Jet_eta[ijet]) > 2.5: continue if event.Jet_jetId[ijet]<6: continue #if event.Jet_chEmEF[ijet]>0.9: continue ## FIXME #if (self.year==2017 or self.year==2018) and event.Jet_chEmEF[ijet]>0.8:continue j_p4 = TLorentzVector() j_p4.SetPtEtaPhiM(event.Jet_pt[ijet], event.Jet_eta[ijet], event.Jet_phi[ijet], event.Jet_mass[ijet]) if j1_p4.DeltaR(j_p4) < 1.1: wj1_p4 += j_p4 if j2_p4.DeltaR(j_p4) < 1.1: wj2_p4 += j_p4 self.out.jj_mass_widejet[0] = (wj1_p4+wj2_p4).M() self.out.jj_deltaEta_widejet[0] = abs(wj1_p4.Eta() - wj2_p4.Eta()) nIsoElectrons = 0. for iel in range(event.nElectron): if event.Electron_pt[iel] > 50. and abs(event.Electron_eta[iel]) < 2.5 and event.Electron_cutBased[iel] >= 2: nIsoElectrons += 1 nIsoMuons = 0. for imu in range(event.nMuon): if event.Muon_pt[imu] > 50. and abs(event.Muon_eta[imu]) < 2.4 and event.Muon_highPtId[imu]>=2 and event.Muon_tkRelIso[imu]<0.1: nIsoMuons += 1 if self.isMC: nGenMuons_1 = 0 nGenMuons_2 = 0 genMuon_pt_1 = 0. genMuon_pt_2 = 0. for igen in range(event.nGenPart): if abs(event.GenPart_pdgId[igen]) == 13: if ( (event.GenPart_eta[igen] - event.Jet_eta[jetIds[0]])**2 + (event.GenPart_phi[igen] - event.Jet_phi[jetIds[0]])**2 )**0.5 < 0.4: if event.GenPart_pt[igen]>genMuon_pt_1: genMuon_pt_1 = event.GenPart_pt[igen] nGenMuons_1 += 1 if ( (event.GenPart_eta[igen] - event.Jet_eta[jetIds[1]])**2 + (event.GenPart_phi[igen] - event.Jet_phi[jetIds[1]])**2 )**0.5 < 0.4: if event.GenPart_pt[igen]>genMuon_pt_2: genMuon_pt_2 = event.GenPart_pt[igen] nGenMuons_2 += 1 nLooseMuons1, nLooseMuons2 = 0, 0 ptMuons1, ptMuons2 = 0., 0. MuonWeight_central_1, MuonWeight_central_2 = 1., 1. MuonWeight_up_1, MuonWeight_up_2 = 1., 1. MuonWeight_down_1, MuonWeight_down_2 = 1., 1. ################################################################################ n_gen_matched_muons_1, n_gen_matched_muons_2 = 0, 0 gen_matched_muon_pt_1, gen_matched_muon_pt_2 = 0., 0. smallest_muon_dR_gen_reco_1, smallest_muon_dR_gen_reco_2 = 100., 100. ################################################################################ if event.Jet_muonIdx1[jetIds[0]] >=0 and event.Muon_looseId[event.Jet_muonIdx1[jetIds[0]]] and event.Muon_nStations[event.Jet_muonIdx1[jetIds[0]]] >=3: nLooseMuons1 += 1 ptMuons1 += event.Muon_pt[event.Jet_muonIdx1[jetIds[0]]] MuonWeight_central_1 = 1. + (event.Muon_pt[event.Jet_muonIdx1[jetIds[0]]] / 13000.)*(-7) MuonWeight_up_1 = 1. + (event.Muon_pt[event.Jet_muonIdx1[jetIds[0]]] / 13000.)*(-7 + 28) MuonWeight_down_1 = 1. + (event.Muon_pt[event.Jet_muonIdx1[jetIds[0]]] / 13000.)*(-7 - 28) ################################################################################ if self.isMC: for igen in range(event.nGenPart): if abs(event.GenPart_pdgId[igen]) == 13: dR_gen_reco = ( (event.GenPart_eta[igen] - event.Muon_eta[event.Jet_muonIdx1[jetIds[0]]])**2 + (event.GenPart_phi[igen] - event.Muon_phi[event.Jet_muonIdx1[jetIds[0]]])**2 )**0.5 if dR_gen_reco < smallest_muon_dR_gen_reco_1: smallest_muon_dR_gen_reco_1 = dR_gen_reco if dR_gen_reco < 0.05: n_gen_matched_muons_1 += 1 gen_matched_muon_pt_1 += event.Muon_pt[event.Jet_muonIdx1[jetIds[0]]] ################################################################################ if event.Jet_muonIdx2[jetIds[0]] >=0 and event.Muon_looseId[event.Jet_muonIdx2[jetIds[0]]] and event.Muon_nStations[event.Jet_muonIdx2[jetIds[0]]] >=3: nLooseMuons1 += 1 ptMuons1 += event.Muon_pt[event.Jet_muonIdx2[jetIds[0]]] ################################################################################ if self.isMC: for igen in range(event.nGenPart): if abs(event.GenPart_pdgId[igen]) == 13: dR_gen_reco = ( (event.GenPart_eta[igen] - event.Muon_eta[event.Jet_muonIdx2[jetIds[0]]])**2 + (event.GenPart_phi[igen] - event.Muon_phi[event.Jet_muonIdx2[jetIds[0]]])**2 )**0.5 if dR_gen_reco < smallest_muon_dR_gen_reco_1: smallest_muon_dR_gen_reco_1 = dR_gen_reco if dR_gen_reco < 0.05: n_gen_matched_muons_1 += 1 gen_matched_muon_pt_1 += event.Muon_pt[event.Jet_muonIdx2[jetIds[0]]] ################################################################################ if event.Jet_muonIdx1[jetIds[1]] >=0 and event.Muon_looseId[event.Jet_muonIdx1[jetIds[1]]] and event.Muon_nStations[event.Jet_muonIdx1[jetIds[1]]] >=3: nLooseMuons2 += 1 ptMuons2 += event.Muon_pt[event.Jet_muonIdx1[jetIds[1]]] MuonWeight_central_2 = 1. + (event.Muon_pt[event.Jet_muonIdx1[jetIds[1]]] / 13000.)*(-7) MuonWeight_up_2 = 1. + (event.Muon_pt[event.Jet_muonIdx1[jetIds[1]]] / 13000.)*(-7 + 28) MuonWeight_down_2 = 1. + (event.Muon_pt[event.Jet_muonIdx1[jetIds[1]]] / 13000.)*(-7 - 28) ################################################################################ if self.isMC: for igen in range(event.nGenPart): if abs(event.GenPart_pdgId[igen]) == 13: dR_gen_reco = ( (event.GenPart_eta[igen] - event.Muon_eta[event.Jet_muonIdx1[jetIds[1]]])**2 + (event.GenPart_phi[igen] - event.Muon_phi[event.Jet_muonIdx1[jetIds[1]]])**2 )**0.5 if dR_gen_reco < smallest_muon_dR_gen_reco_2: smallest_muon_dR_gen_reco_2 = dR_gen_reco if dR_gen_reco < 0.05: n_gen_matched_muons_2 += 1 gen_matched_muon_pt_2 += event.Muon_pt[event.Jet_muonIdx1[jetIds[1]]] ################################################################################ if event.Jet_muonIdx2[jetIds[1]] >=0 and event.Muon_looseId[event.Jet_muonIdx2[jetIds[1]]] and event.Muon_nStations[event.Jet_muonIdx2[jetIds[1]]] >=3: nLooseMuons2 += 1 ptMuons2 += event.Muon_pt[event.Jet_muonIdx2[jetIds[1]]] ################################################################################ if self.isMC: for igen in range(event.nGenPart): if abs(event.GenPart_pdgId[igen]) == 13: dR_gen_reco = ( (event.GenPart_eta[igen] - event.Muon_eta[event.Jet_muonIdx2[jetIds[1]]])**2 + (event.GenPart_phi[igen] - event.Muon_phi[event.Jet_muonIdx2[jetIds[1]]])**2 )**0.5 if dR_gen_reco < smallest_muon_dR_gen_reco_2: smallest_muon_dR_gen_reco_2 = dR_gen_reco if dR_gen_reco < 0.05: n_gen_matched_muons_2 += 1 gen_matched_muon_pt_2 += event.Muon_pt[event.Jet_muonIdx2[jetIds[1]]] ################################################################################ nMediumMuons1, nMediumMuons2 = 0, 0 if event.Jet_muonIdx1[jetIds[0]] >=0 and event.Muon_mediumId[event.Jet_muonIdx1[jetIds[0]]] and event.Muon_nStations[event.Jet_muonIdx1[jetIds[0]]] >=3: nMediumMuons1 += 1 if event.Jet_muonIdx2[jetIds[0]] >=0 and event.Muon_mediumId[event.Jet_muonIdx2[jetIds[0]]] and event.Muon_nStations[event.Jet_muonIdx2[jetIds[0]]] >=3: nMediumMuons1 += 1 if event.Jet_muonIdx1[jetIds[1]] >=0 and event.Muon_mediumId[event.Jet_muonIdx1[jetIds[1]]] and event.Muon_nStations[event.Jet_muonIdx1[jetIds[1]]] >=3: nMediumMuons2 += 1 if event.Jet_muonIdx2[jetIds[1]] >=0 and event.Muon_mediumId[event.Jet_muonIdx2[jetIds[1]]] and event.Muon_nStations[event.Jet_muonIdx2[jetIds[1]]] >=3: nMediumMuons2 += 1 ptRel1, ptRel2 = 0., 0. if event.Jet_muonIdx1[jetIds[0]] >=0: ptRel1 = event.Muon_jetPtRelv2[event.Jet_muonIdx1[jetIds[0]]] if event.Jet_muonIdx1[jetIds[1]] >=0: ptRel2 = event.Muon_jetPtRelv2[event.Jet_muonIdx1[jetIds[1]]] ## Fill jet branches self.out.njets[0] = len(jetIds) self.out.jpt_1[0] = event.Jet_pt[jetIds[0]] self.out.jeta_1[0] = event.Jet_eta[jetIds[0]] self.out.jphi_1[0] = event.Jet_phi[jetIds[0]] self.out.jmass_1[0] = event.Jet_mass[jetIds[0]] self.out.jCSV_1[0] = event.Jet_btagCSVV2[jetIds[0]] self.out.jdeepCSV_1[0] = event.Jet_btagDeepB[jetIds[0]] self.out.jdeepFlavour_1[0] = event.Jet_btagDeepFlavB[jetIds[0]] self.out.jnconst_1[0] = event.Jet_nConstituents[jetIds[0]] self.out.jchf_1[0] = event.Jet_chHEF[jetIds[0]] self.out.jnhf_1[0] = event.Jet_neHEF[jetIds[0]] self.out.jcef_1[0] = event.Jet_chEmEF[jetIds[0]] self.out.jnef_1[0] = event.Jet_neEmEF[jetIds[0]] self.out.jmuf_1[0] = event.Jet_muEF[jetIds[0]] self.out.jmuonpt_1[0] = ptMuons1 self.out.jptRel_1[0] = ptRel1 self.out.jnelectrons_1[0] = event.Jet_nElectrons[jetIds[0]] self.out.jnmuons_1[0] = event.Jet_nMuons[jetIds[0]] self.out.jnmuons_loose_1[0] = nLooseMuons1 self.out.jnmuons_medium_1[0] = nMediumMuons1 if self.isMC: self.out.jnmuons_gen_1[0] = nGenMuons_1 self.out.jnmuons_gen_pt_1[0] = genMuon_pt_1 self.out.jnmuons_loose_genmatched_1[0] = n_gen_matched_muons_1 self.out.jmuonpt_genmatched_1[0] = gen_matched_muon_pt_1 self.out.jflavour_1[0] = event.Jet_hadronFlavour[jetIds[0]] else: self.out.jflavour_1[0] = -1 self.out.jmask_1[0] = event.Jet_cleanmask[jetIds[0]] self.out.jid_1[0] = event.Jet_jetId[jetIds[0]] self.out.jpt_2[0] = event.Jet_pt[jetIds[1]] self.out.jeta_2[0] = event.Jet_eta[jetIds[1]] self.out.jphi_2[0] = event.Jet_phi[jetIds[1]] self.out.jmass_2[0] = event.Jet_mass[jetIds[1]] self.out.jCSV_2[0] = event.Jet_btagCSVV2[jetIds[1]] self.out.jdeepCSV_2[0] = event.Jet_btagDeepB[jetIds[1]] self.out.jdeepFlavour_2[0] = event.Jet_btagDeepFlavB[jetIds[1]] self.out.jnconst_2[0] = event.Jet_nConstituents[jetIds[1]] self.out.jchf_2[0] = event.Jet_chHEF[jetIds[1]] self.out.jnhf_2[0] = event.Jet_neHEF[jetIds[1]] self.out.jcef_2[0] = event.Jet_chEmEF[jetIds[1]] self.out.jnef_2[0] = event.Jet_neEmEF[jetIds[1]] self.out.jmuf_2[0] = event.Jet_muEF[jetIds[1]] self.out.jmuonpt_2[0] = ptMuons2 self.out.jptRel_2[0] = ptRel2 self.out.jnelectrons_2[0] = event.Jet_nElectrons[jetIds[1]] self.out.jnmuons_2[0] = event.Jet_nMuons[jetIds[1]] self.out.jnmuons_loose_2[0] = nLooseMuons2 self.out.jnmuons_medium_2[0] = nMediumMuons2 if self.isMC: self.out.jnmuons_gen_2[0] = nGenMuons_2 self.out.jnmuons_gen_pt_2[0] = genMuon_pt_2 self.out.jnmuons_loose_genmatched_2[0] = n_gen_matched_muons_2 self.out.jmuonpt_genmatched_2[0] = gen_matched_muon_pt_2 self.out.jflavour_2[0] = event.Jet_hadronFlavour[jetIds[1]] self.out.jmuon_gen_reco_dR_1[0] = smallest_muon_dR_gen_reco_1 self.out.jmuon_gen_reco_dR_2[0] = smallest_muon_dR_gen_reco_2 else: self.out.jflavour_2[0] = -1 self.out.jmask_2[0] = event.Jet_cleanmask[jetIds[1]] self.out.jid_2[0] = event.Jet_jetId[jetIds[1]] self.out.jsorted[0] = 0 if leading1==0 and leading2==1: self.out.jsorted[0] = 1 #self.out.MET_over_SumEt[0] = event.MET_pt/jetHT if event.nFatJet >= 1 and event.FatJet_pt[0] > 200.: self.out.fatjetmass_1[0] = event.FatJet_msoftdrop[0] self.out.fatjettau21_1[0] = (event.FatJet_tau2[0]/event.FatJet_tau1[0]) if event.FatJet_tau1[0] > 0. else -1. self.out.fatjettau21ddt_1[0] = self.out.fatjettau21_1[0] + 0.082*ROOT.TMath.Log(event.FatJet_msoftdrop[0]**2/event.FatJet_pt[0]) self.out.fatjetHbbvsQCD_1[0] = event.FatJet_deepTagMD_HbbvsQCD[0] self.out.fatjetWvsQCD_1[0] = event.FatJet_deepTagMD_WvsQCD[0] self.out.fatjetZHbbvsQCD_1[0] = event.FatJet_deepTagMD_ZHbbvsQCD[0] self.out.fatjetZbbvsQCD_1[0] = event.FatJet_deepTagMD_ZbbvsQCD[0] self.out.fatjetZvsQCD_1[0] = event.FatJet_deepTagMD_ZvsQCD[0] self.out.fatjetbbvsLight_1[0] = event.FatJet_deepTagMD_bbvsLight[0] if event.nFatJet >= 2 and event.FatJet_pt[1] > 200.: self.out.fatjetmass_2[0] = event.FatJet_msoftdrop[1] self.out.fatjettau21_2[0] = (event.FatJet_tau2[1]/event.FatJet_tau1[1]) if event.FatJet_tau1[1] > 0. else -1. self.out.fatjettau21ddt_2[0] = self.out.fatjettau21_2[0] + 0.082*ROOT.TMath.Log(event.FatJet_msoftdrop[1]**2/event.FatJet_pt[1]) self.out.fatjetHbbvsQCD_2[0] = event.FatJet_deepTagMD_HbbvsQCD[1] self.out.fatjetWvsQCD_2[0] = event.FatJet_deepTagMD_WvsQCD[1] self.out.fatjetZHbbvsQCD_2[0] = event.FatJet_deepTagMD_ZHbbvsQCD[1] self.out.fatjetZbbvsQCD_2[0] = event.FatJet_deepTagMD_ZbbvsQCD[1] self.out.fatjetZvsQCD_2[0] = event.FatJet_deepTagMD_ZvsQCD[1] self.out.fatjetbbvsLight_2[0] = event.FatJet_deepTagMD_bbvsLight[1] self.out.ptBalance[0] = (event.Jet_pt[jetIds[0]] - event.Jet_pt[jetIds[1]])/(event.Jet_pt[jetIds[0]] + event.Jet_pt[jetIds[1]]) self.out.HT[0] = jetHT self.out.MET[0] = event.MET_pt self.out.nelectrons[0] = nIsoElectrons self.out.nmuons[0] = nIsoMuons self.out.nbtagLoose[0] = jetBTagLoose self.out.nbtagMedium[0] = jetBTagMedium self.out.nbtagTight[0] = jetBTagTight ## writing the b-tag category directly into the n-tuple. 0:untagged, 1:loose, 2:medium, 3:tight self.out.jbtag_WP_1[0] = 0 if event.Jet_btagDeepFlavB[jetIds[0]] > self.btagTight: self.out.jbtag_WP_1[0] = 3 elif event.Jet_btagDeepFlavB[jetIds[0]] > self.btagMedium: self.out.jbtag_WP_1[0] = 2 elif event.Jet_btagDeepFlavB[jetIds[0]] > self.btagLoose: self.out.jbtag_WP_1[0] = 1 self.out.jbtag_WP_2[0] = 0 if event.Jet_btagDeepFlavB[jetIds[1]] > self.btagTight: self.out.jbtag_WP_2[0] = 3 elif event.Jet_btagDeepFlavB[jetIds[1]] > self.btagMedium: self.out.jbtag_WP_2[0] = 2 elif event.Jet_btagDeepFlavB[jetIds[1]] > self.btagLoose: self.out.jbtag_WP_2[0] = 1 ## fill trigger branches (different years have different triggers 500<->550, 900<->1050) try: self.out.HLT_AK8PFJet500[0] = event.HLT_AK8PFJet500 except: self.out.HLT_AK8PFJet500[0] = -1 try: self.out.HLT_PFJet500[0] = event.HLT_PFJet500 except: self.out.HLT_PFJet500[0] = -1 try: self.out.HLT_CaloJet500_NoJetID[0] = event.HLT_CaloJet500_NoJetID except: self.out.HLT_CaloJet500_NoJetID[0] = -1 try: self.out.HLT_PFHT900[0] = event.HLT_PFHT900 except: self.out.HLT_PFHT900[0] = -1 try: self.out.HLT_AK8PFJet550[0] = event.HLT_AK8PFJet550 except: self.out.HLT_AK8PFJet550[0] = -1 try: self.out.HLT_PFJet550[0] = event.HLT_PFJet550 except: self.out.HLT_PFJet550[0] = -1 try: self.out.HLT_CaloJet550_NoJetID[0] = event.HLT_CaloJet550_NoJetID except: self.out.HLT_CaloJet550_NoJetID[0] = -1 try: self.out.HLT_PFHT1050[0] = event.HLT_PFHT1050 except: self.out.HLT_PFHT1050[0] = -1 try: self.out.HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[0] = event.HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71 except: self.out.HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[0] = -1 try: self.out.HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[0] = event.HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71 except: self.out.HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[0] = -1 try: self.out.HLT_DoublePFJets40_CaloBTagDeepCSV_p71[0] = event.HLT_DoublePFJets40_CaloBTagDeepCSV_p71 except: self.out.HLT_DoublePFJets40_CaloBTagDeepCSV_p71[0] = -1 try: self.out.HLT_DoublePFJets100_CaloBTagDeepCSV_p71[0] = event.HLT_DoublePFJets100_CaloBTagDeepCSV_p71 except: self.out.HLT_DoublePFJets100_CaloBTagDeepCSV_p71[0] = -1 try: self.out.HLT_DoublePFJets200_CaloBTagDeepCSV_p71[0] = event.HLT_DoublePFJets200_CaloBTagDeepCSV_p71 except: self.out.HLT_DoublePFJets200_CaloBTagDeepCSV_p71[0] = -1 try: self.out.HLT_DoublePFJets350_CaloBTagDeepCSV_p71[0] = event.HLT_DoublePFJets350_CaloBTagDeepCSV_p71 except: self.out.HLT_DoublePFJets350_CaloBTagDeepCSV_p71[0] = -1 ## add weights try: self.out.btagWeight_DeepCSVB[0] = event.btagWeight_DeepCSVB except: self.out.btagWeight_DeepCSVB[0] = -100. try: self.out.LHEWeight_originalXWGTUP[0] = event.LHEWeight_originalXWGTUP except: self.out.LHEWeight_originalXWGTUP[0] = -100. try: self.out.LHEReweightingWeight[0] = event.LHEReweightingWeight except: self.out.LHEReweightingWeight[0] = -100. try: self.out.LHEScaleWeight[0] = event.LHEScaleWeight except: self.out.LHEScaleWeight[0] = -100. try: self.out.PSWeight[0] = event.PSWeight except: self.out.PSWeight[0] = -100. #try: # self.out.genWeight[0] = event.genWeight #except: # self.out.genWeight[0] = -100. if self.isMC: self.out.GenWeight[0] = GenWeight self.out.PUWeight[0] = PUWeight else: self.out.GenWeight[0] = 1. self.out.PUWeight[0] = 1. if 'signal' in self.name.lower(): self.out.BTagAK4Weight_deepJet[0] = BTagAK4Weight_deepJet self.out.BTagAK4Weight_deepJet_up[0] = BTagAK4Weight_deepJet_up self.out.BTagAK4Weight_deepJet_down[0] = BTagAK4Weight_deepJet_down self.out.MuonWeight[0] = MuonWeight_central_1 * MuonWeight_central_2 self.out.MuonWeight_up[0] = MuonWeight_up_1 * MuonWeight_up_2 self.out.MuonWeight_down[0] = MuonWeight_down_1 * MuonWeight_down_2 ## event weight lumi #eventweightlumi = 1. #if self.isMC: # eventweightlumi = self.Leq #minimalist approach, store the things to be multiplied later separately into nTuple # #eventweightlumi = self.Leq * event.LHEWeight_originalXWGTUP # #eventweightlumi = self.Leq * event.lheweight * event.btagweight #event.puweight #self.out.eventweightlumi[0] = eventweightlumi self.out.isMC[0] = int(self.isMC) self.out.tree.Fill() return True
def analyze( dstFileName, genCollName, jetCollName, output, minPt=0.5 ): jetCone=0.5 #parse the number #if jetCollName=="JetOut": jetCone=0.75 #else : # jetCone = float( (re.findall(r'[0-9]+', jetCollName))[0] )/10 # if jetCone==7.5 : jetCone=0.75 print 'Using %s jet collection with matching R=%f'%(jetCollName,jetCone) #open root file to store the histograms rootFile=TFile(output,'recreate') histos={} histos['sel'] = TH1F('sel', ';Selection;Events', 4,0,4) histos['sel'].GetXaxis().SetBinLabel(1,'Total') histos['sel'].GetXaxis().SetBinLabel(2,'Gen V') histos['sel'].GetXaxis().SetBinLabel(3,'Gen V#rightarrowqq') histos['sel'].GetXaxis().SetBinLabel(4,'Reco V#rightarrowqq') histos['nvtx'] = TH1F('nvtx', ';Vertices;Events',20,0,20) histos['pfsumpt'] = TH1F('pfsumpt', ';Scalar transverse momentum sum [GeV];Events', 50,0,500) histos['pfmet'] = TH1F('pfmet', ';Raw PF MET [GeV];Events', 50,0,100) histos['pfmetoversumpt'] = TH1F('pfmetoversumpt', ';MET/#Sigma p_{T};Events', 50,0,0.5) kin=['','30to40','40to50','50to75','75to100','100toInf'] reg=['','barrel','endcap'] for k in kin: for r in reg: histos['jden'+k+r] = TH1F('den'+k+r, ';#DeltaE/E;Jets', 100,-2,2) histos['jdpt'+k+r] = TH1F('dpt'+k+r, ';#Deltap_{T}/p_{T};Jets', 100,-2,2) histos['jdphi'+k+r] = TH1F('dphi'+k+r, ';|#Delta#phi| [rad];Jets', 25,0,0.5) histos['jdeta'+k+r] = TH1F('deta'+k+r, ';|#Delta#eta|;Jets', 25,0,0.5) histos['jdr'+k+r] = TH1F('dr'+k+r, ';#DeltaR(jet,q);Jets', 25,0,0.5) bos=['','h','w','z'] kin=['','50','100'] reg=['','bb','ee','eb'] for ib in bos: histos[ib+'mqq'] = TH1F(ib+'mqq', ';Diquark mass [GeV];Events', 250,0,250) histos[ib+'qpt'] = TH1F(ib+'qpt', ';Quark transverse momentum [GeV];Events', 250,0,250) histos[ib+'qeta'] = TH1F(ib+'qeta', ';Quark pseudo-rapidity;Events', 50,0,3.0) for k in kin: for r in reg: histos[ib+'mjj'+k+r] = TH1F(ib+'mjj'+k+r, ';Dijet mass [GeV];Events', 400,0,200) histos[ib+'dmjj'+k+r] = TH1F(ib+'dmjj'+k+r, ';#Delta m/m;Events', 100,-2.02,1.98) for key in histos: histos[key].Sumw2() histos[key].SetMarkerStyle(20) histos[key].SetMarkerColor(1) histos[key].SetLineColor(1) if key[0]=='v': histos[key].SetFillStyle(3002) histos[key].SetFillColor(32) # create the LCReader and open the input file lcReader = IOIMPL.LCFactory.getInstance().createLCReader() lcReader.open(dstFileName) # filling the tree #print 'Generated \t\t Reconstructed \t\t\t Delta' ievent=0 for event in lcReader: ievent=ievent+1 print 'Event %d'%ievent genHandle=None jetHandle=None pfHandle=None pfClusterHandle=None pvHandle=None for collectionName, collection in event: if collectionName == genCollName : genHandle=collection if collectionName == jetCollName : jetHandle=collection if collectionName == "PandoraPFOs" : pfHandle=collection if collectionName == "PrimaryVertex" : pvHandle=collection if jetHandle is None : continue histos['nvtx'].Fill(len(pvHandle)) pfsumpt=0. pfmet=TLorentzVector(0,0,0,0) for pf in pfHandle: pfmet = pfmet + pf.getLorentzVec() pfsumpt = pfsumpt+pf.getLorentzVec().Pt() histos['pfsumpt'].Fill(pfsumpt) histos['pfmet'].Fill(pfmet.Pt()) histos['pfmetoversumpt'].Fill(pfmet.Pt()/pfsumpt) #Hard process: status 3 particles #save only after at least one boson was found, otherwise incoming partons will be considered genBosons=[] promptQuarks=[] for p in genHandle: if p.getGeneratorStatus()!=3 : continue if math.fabs(p.getPDG())==23 or math.fabs(p.getPDG())==24 or math.fabs(p.getPDG())==25: genBosons.append(p) if len(genBosons)==0: continue #if math.fabs(p.getPDG())>6 : continue if math.fabs(p.getPDG())>4 : continue promptQuarks.append( p ) #if none found, check if from ILD official production (status is different) if len(genBosons)==0 : for p in genHandle: #if math.fabs(p.getPDG())!=23 and math.fabs(p.getPDG())!=24 and math.fabs(p.getPDG())!=25: continue if math.fabs(p.getPDG())!=25 : continue if p.getGeneratorStatus()!=2 : continue genBosons.append(p) for d in p.getDaughters() : if math.fabs(d.getPDG())>6 : continue promptQuarks.append(d) #if still not found may be the quark/gluon gun: take all quarks status 2 if len(genBosons)==0 : for p in genHandle: if not(math.fabs(p.getPDG())<4 or math.fabs(p.getPDG())==21) : continue if p.getGeneratorStatus()!=2 : continue histos['qpt'].Fill( p.getLorentzVec().Pt() ) histos['qeta'].Fill( math.fabs( p.getLorentzVec().Eta() ) ) if math.fabs( p.getLorentzVec().Eta() ) > 2.5 : continue jet=findRecoMatch(p,jetHandle,jetCone)[1] if jet is None: continue pt=p.getLorentzVec().Pt() eta=math.fabs(p.getLorentzVec().Eta()) if pt<20 or eta>2.5 : continue jetKin=[''] if pt<40 : jetKin.append('30to40') elif pt<50 : jetKin.append('40to50') elif pt<75 : jetKin.append('50to75') elif pt<100 : jetKin.append('75to100') else : jetKin.append('100toInf') jetReg=[''] if eta<1.5 : jetReg.append('barrel') else : jetReg.append('endcap') for k in jetKin: for r in jetReg: histos['jden'+k+r].Fill(jet.getLorentzVec().E()/p.getLorentzVec().E()-1) histos['jdpt'+k+r].Fill(jet.getLorentzVec().Pt()/p.getLorentzVec().Pt()-1) histos['jdr'+k+r].Fill(p.getLorentzVec().DeltaR(jet.getLorentzVec())) histos['jdeta'+k+r].Fill(math.fabs(p.getLorentzVec().Eta()-jet.getLorentzVec().Eta())) histos['jdphi'+k+r].Fill(math.fabs(p.getLorentzVec().DeltaPhi(jet.getLorentzVec()))) #match di-quarks to bosons, match- each quark to a reco jet (if available) bosonDecays=[] bosonRecoDecays=[] goodBosonRecoFound=False nPromptQuarks=len(promptQuarks) matchedPromptQuarksIdx=[] for b in genBosons: requireSameFlavor=( math.fabs(b.getPDG())==23 or math.fabs(b.getPDG())==25 ) bosonCharge=b.getCharge() bosonMass=b.getLorentzVec().M() for i in xrange(0,nPromptQuarks): if i in matchedPromptQuarksIdx : continue for j in xrange(i+1,nPromptQuarks): if j in matchedPromptQuarksIdx : continue #di-quark qqCharge=promptQuarks[i].getCharge()+promptQuarks[j].getCharge() qq=promptQuarks[i].getLorentzVec()+promptQuarks[j].getLorentzVec() drqq2b=qq.DeltaR(b.getLorentzVec()) qqMass=qq.M() dm=math.fabs(qqMass-bosonMass) qqFlavor=math.fabs(promptQuarks[i].getPDG()+promptQuarks[j].getPDG()) #total charge if int(qqCharge) != int(bosonCharge) : continue #check if both have the same flavor (Z/H do not mix different weak isospin components) if requireSameFlavor : if qqFlavor!=0 : continue #match direction if drqq2b>0.1 : continue bosName=[''] if math.fabs(b.getPDG())==25 : bosName.append('h') if math.fabs(b.getPDG())==23 : bosName.append('z') if math.fabs(b.getPDG())==24 : bosName.append('w') for ibname in bosName : histos[ibname+'mqq'].Fill(qq.M()) #match mass within 5 GeV if dm>2.5 : continue #acceptance cuts for individual quarks for ibname in bosName : histos[ib+'qpt'].Fill( promptQuarks[i].getLorentzVec().Pt() ) histos[ib+'qpt'].Fill( promptQuarks[j].getLorentzVec().Pt() ) histos[ib+'qeta'].Fill( math.fabs( promptQuarks[i].getLorentzVec().Eta() ) ) histos[ib+'qeta'].Fill( math.fabs( promptQuarks[j].getLorentzVec().Eta() ) ) if promptQuarks[i].getLorentzVec().Pt()<20 : continue if promptQuarks[j].getLorentzVec().Pt()<20 : continue if math.fabs( promptQuarks[i].getLorentzVec().Eta() ) > 2.5 : continue if math.fabs( promptQuarks[j].getLorentzVec().Eta() ) > 2.5 : continue #ok to analyze this one bosonDecays.append([b,promptQuarks[i],promptQuarks[j]]) j1=findRecoMatch(promptQuarks[i],jetHandle,jetCone)[1] j2=findRecoMatch(promptQuarks[j],jetHandle,jetCone)[1] if j1 is not None and j2 is not None: goodBosonRecoFound=True bosonRecoDecays.append([b,j1,j2]) matchedPromptQuarksIdx.append(i) matchedPromptQuarksIdx.append(j) break #event selection histos['sel'].Fill(0) if len(genBosons)==0 : continue histos['sel'].Fill(1) if len(bosonDecays)==0: continue histos['sel'].Fill(2) if goodBosonRecoFound==True: histos['sel'].Fill(3) #match the generated decays at reconstruction level for i in xrange(0,len(bosonDecays)): b=bosonDecays[i][0] q1=bosonDecays[i][1] q2=bosonDecays[i][2] j1=bosonRecoDecays[i][1] j2=bosonRecoDecays[i][2] if j1 is None: continue if j2 is None: continue dijet=j1.getLorentzVec()+j2.getLorentzVec() dRjj=j1.getLorentzVec().DeltaR( j2.getLorentzVec() ) if dRjj < jetCone: print 'Merged jets are not considered...' continue inMwindow = (math.fabs(dijet.M()-b.getLorentzVec().M())<15) pt1=j1.getLorentzVec().Pt() eta1=math.fabs(j1.getLorentzVec().Eta()) pt2=j2.getLorentzVec().Pt() eta2=math.fabs(j2.getLorentzVec().Eta()) jjKin=[''] if pt1>50 or pt2>50 : jjKin.append('50') if pt1>100 or pt2>100 : jjKin.append('100') jjReg='b' if eta1>1.5: jjReg='e' if eta2<=1.5: jjReg='b'+jjReg if eta2>1.5: jjReg='e'+jjReg if jjReg=='be' : jjReg='eb' jjRegs=['',jjReg] bosNames=[''] if math.fabs(b.getPDG())==25 : bosNames.append('h') if math.fabs(b.getPDG())==23 : bosNames.append('z') if math.fabs(b.getPDG())==24 : bosNames.append('w') for ib in bosNames: for k in jjKin: for r in jjRegs: histos[ib+'mjj'+k+r].Fill(dijet.M()) histos[ib+'dmjj'+k+r].Fill(dijet.M()/b.getLorentzVec().M()-1) #individual jet resolutions for qj in [[q1,j1],[q2,j2]]: quark=qj[0] jet=qj[1] pt=quark.getLorentzVec().Pt() eta=math.fabs(quark.getLorentzVec().Eta()) if pt<20 or eta>2.5 : continue jetKin=[''] if pt<40 : jetKin.append('30to40') elif pt<50 : jetKin.append('40to50') elif pt<75 : jetKin.append('50to75') elif pt<100 : jetKin.append('75to100') else : jetKin.append('100toInf') jetReg=[''] if eta<1.5 : jetReg.append('barrel') else : jetReg.append('endcap') for k in jetKin: for r in jetReg: histos['jden'+k+r].Fill(jet.getLorentzVec().E()/quark.getLorentzVec().E()-1) histos['jdpt'+k+r].Fill(jet.getLorentzVec().Pt()/quark.getLorentzVec().Pt()-1) histos['jdr'+k+r].Fill(quark.getLorentzVec().DeltaR(jet.getLorentzVec())) histos['jdeta'+k+r].Fill(math.fabs(quark.getLorentzVec().Eta()-jet.getLorentzVec().Eta())) histos['jdphi'+k+r].Fill(math.fabs(quark.getLorentzVec().DeltaPhi(jet.getLorentzVec()))) # write and close the file rootFile.Write() rootFile.Close()
class JetCand: def __init__(self, px, py, pz, en, area, toRawSF): self.p4 = TLorentzVector(px, py, pz, en) self.area = area self.genP4 = TLorentzVector(0, 0, 0, 0) self.partonId = 0 self.flavId = 0 self.corrSF = [toRawSF] def genMatch(self, px, py, pz, en, partonId, flavId): self.genP4 = TLorentzVector(px, py, pz, en) self.partonId = partonId self.flavId = flavId def getCorrectedJet(self, type=''): if type == '': return self.p4 elif type == 'raw': return self.p4 * self.corrSF[0] elif type == 'jesup': return self.p4 * self.corrSF[1] elif type == 'jesdown': return self.p4 * self.corrSF[2] elif type == 'jerup': return self.p4 * self.corrSF[3] elif type == 'jerdown': return self.p4 * self.corrSF[4] def updateJEC(self, jecCorrector, jecUncertainty, rho, nvtx): eta = math.fabs(self.p4.Eta()) #update the JEC newJECSF = self.corrSF[0] rawJet = self.getCorrectedJet('raw') if jecCorrector is not None: jecCorrector.setJetPt(rawJet.Pt()) jecCorrector.setJetEta(eta) jecCorrector.setJetA(self.area) jecCorrector.setRho(rho) jecCorrector.setNPV(nvtx) newJECSF = jecCorrector.getCorrection() #check if resolution needs smearing (MC only) jerSFs = [1.0, 1.0, 1.0] genPt = self.genP4.Pt() if genPt > 0: ptSF = 1.0 ptSF_err = 0.06 if eta < 0.5: ptSF = 1.052 ptSF_err = math.sqrt( pow(0.012, 2) + pow(0.5 * (0.062 + 0.061), 2)) elif eta >= 0.5 and eta < 1.1: ptSF = 1.057 ptSF_err = math.sqrt( pow(0.012, 2) + pow(0.5 * (0.056 + 0.055), 2)) elif eta >= 1.1 and eta < 1.7: ptSF = 1.096 ptSF_err = math.sqrt( pow(0.017, 2) + pow(0.5 * (0.063 + 0.062), 2)) elif eta >= 1.7 and eta < 2.3: ptSF = 1.134 ptSF_err = math.sqrt( pow(0.035, 2) + pow(0.5 * (0.087 + 0.085), 2)) elif eta >= 2.3 and eta < 5.0: ptSF = 1.288 ptSF_err = math.sqrt( pow(0.127, 2) + pow(0.5 * (0.155 + 0.153), 2)) recPt = newJECSF * self.p4.Pt() jerSFs[0] = max(0., (genPt + ptSF * (recPt - genPt))) / recPt jerSFs[1] = max(0., (genPt + (ptSF + ptSF_err) * (recPt - genPt))) / recPt jerSFs[2] = max(0., (genPt + (ptSF - ptSF_err) * (recPt - genPt))) / recPt if newJECSF == 0 or jerSFs[0] == 0: print 'Will not correct JER @ eta=%f SF_JEC=%f SF_JER=%f pT(gen)=%f pT(rec)=%f' % ( eta, newJECSF, jerSFs[0], genPt, recPt) jerSFs[0] = 1 jerSFs[1] = 1 jerSFs[2] = 1 #JES uncertainties jecUncShift = 0 if jecUncertainty is not None: jecUncertainty.setJetPt(self.p4.Pt()) jecUncertainty.setJetEta(eta) jecUncShift = math.fabs(jecUncertainty.getUncertainty(True)) # the new corrected jet newJECSF = newJECSF * jerSFs[0] rawJet *= newJECSF self.p4.SetPxPyPzE(rawJet.Px(), rawJet.Py(), rawJet.Pz(), rawJet.E()) self.corrSF[0] = 1. / newJECSF self.corrSF.append(1 + jecUncShift) #+JES self.corrSF.append(1 - jecUncShift) #-JES self.corrSF.append(jerSFs[1] / jerSFs[0]) #+JER self.corrSF.append(jerSFs[2] / jerSFs[0]) #-JER
p4 = TLorentzVector(px4, py4, pz4, e4) #from gamma HggP4 = p1 + p2 #from b bar HbbP4 = p3 + p4 #props #m_H1 props[1].append(HggP4.M()) #m_H2 props[2].append(HbbP4.M()) #b_pT props[3].append(p3.Pt()) #b_eta props[4].append(p3.Eta()) #b_phi props[5].append(p3.Phi()) #bbar_pT props[6].append(p4.Pt()) #bbar_eta props[7].append(p4.Eta()) #bbar_phi props[8].append(p4.Phi()) #a_pT props[9].append(p1.Pt()) #a_eta