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
