def process(self, event):
'''
'''
self.readCollections(event.input)
self.tree.reset()
# output of reco analysis
self.fillEvent(self.tree, event)
self.fillCheckHNLReco(self.tree, event)
self.fillHNLReco(self.tree, event)
if hasattr(event, 'dimuonChi2'):
self.fillDiMuon(self.tree, 'dimuonChi2', event.dimuonChi2)
self.fillDisplacedMuon(self.tree, 'dMu1Chi2', event.dMu1Chi2)
self.fillDisplacedMuon(self.tree, 'dMu2Chi2', event.dMu2Chi2)
self.fillDiMuon(self.tree, 'dimuonDxy', event.dimuonDxy)
self.fillDisplacedMuon(self.tree, 'dMu1Dxy', event.dMu1Dxy)
self.fillDisplacedMuon(self.tree, 'dMu2Dxy', event.dMu2Dxy)
self.fillDiMuon(self.tree, 'dimuonMaxPt', event.dimuonMaxPt)
self.fillDisplacedMuon(self.tree, 'dMu1MaxPt', event.dMu1MaxPt)
self.fillDisplacedMuon(self.tree, 'dMu2MaxPt', event.dMu2MaxPt)
self.fillDiMuon(self.tree, 'dimuonMinDr12', event.dimuonMinDr12)
self.fillDisplacedMuon(self.tree, 'dMu1MinDr12', event.dMu1MinDr12)
self.fillDisplacedMuon(self.tree, 'dMu2MinDr12', event.dMu2MinDr12)
self.fillDiMuon(self.tree, 'dimuonMaxDr0a12',
event.dimuonMaxDr0a12)
self.fillDisplacedMuon(self.tree, 'dMu1MaxDr0a12',
event.dMu1MaxDr0a12)
self.fillDisplacedMuon(self.tree, 'dMu2MaxDr0a12',
event.dMu2MaxDr0a12)
# output of MC analysis
self.fillHNL(self.tree, 'hnl', event.the_hnl)
# the prompt lepton
self.fillParticle(self.tree, 'l0', event.the_hnl.l0())
if hasattr(event.the_hnl.l0(), 'bestelectron'):
self.fillEle(self.tree, 'l0_matched_electron',
event.the_hnl.l0().bestelectron)
if hasattr(event.the_hnl.l0(), 'bestphoton'):
self.fillPhoton(self.tree, 'l0_matched_photon',
event.the_hnl.l0().bestphoton)
if hasattr(event.the_hnl.l0(), 'bestmuon'):
self.fillMuon(self.tree, 'l0_matched_muon',
event.the_hnl.l0().bestmuon)
self.fillMuonTrack(self.tree, 'l0_matched_muon_track',
event.the_hnl.l0().bestmuon.bestTrack())
if hasattr(event.the_hnl.l0(), 'besttau'):
self.fillTau(self.tree, 'l0_matched_tau',
event.the_hnl.l0().besttau)
if hasattr(event.the_hnl.l0(), 'bestdsmuon'):
self.fillParticle(self.tree, 'l0_matched_dsmuon',
event.the_hnl.l0().bestdsmuon)
self.fillMuonTrack(self.tree, 'l0_matched_dsmuon_track',
event.the_hnl.l0().bestdsmuon)
if hasattr(event.the_hnl.l0(), 'bestdgmuon'):
self.fillParticle(self.tree, 'l0_matched_dgmuon',
event.the_hnl.l0().bestdgmuon)
self.fillMuonTrack(self.tree, 'l0_matched_dgmuon_track',
event.the_hnl.l0().bestdgmuon)
if event.the_hnl.l0().bestmatch != None:
self.fillParticle(self.tree, 'l0_bestmatch',
event.the_hnl.l0().bestmatch)
self.fill(self.tree, 'l0_bestmatchtype',
event.the_hnl.l0().bestmatchtype)
# displaced leptons (from the HN)
self.fillParticle(self.tree, 'l1', event.the_hnl.l1())
if hasattr(event.the_hnl.l1(), 'bestelectron'):
self.fillEle(self.tree, 'l1_matched_electron',
event.the_hnl.l1().bestelectron)
if hasattr(event.the_hnl.l1(), 'bestphoton'):
self.fillPhoton(self.tree, 'l1_matched_photon',
event.the_hnl.l1().bestphoton)
if hasattr(event.the_hnl.l1(), 'bestmuon'):
self.fillMuon(self.tree, 'l1_matched_muon',
event.the_hnl.l1().bestmuon)
self.fillMuonTrack(self.tree, 'l1_matched_muon_track',
event.the_hnl.l1().bestmuon.bestTrack())
if hasattr(event.the_hnl.l1(), 'besttau'):
self.fillTau(self.tree, 'l1_matched_tau',
event.the_hnl.l1().besttau)
if hasattr(event.the_hnl.l1(), 'bestdsmuon'):
self.fillParticle(self.tree, 'l1_matched_dsmuon',
event.the_hnl.l1().bestdsmuon)
self.fillMuonTrack(self.tree, 'l1_matched_dsmuon_track',
event.the_hnl.l1().bestdsmuon)
if hasattr(event.the_hnl.l1(), 'bestdgmuon'):
self.fillParticle(self.tree, 'l1_matched_dgmuon',
event.the_hnl.l1().bestdgmuon)
self.fillMuonTrack(self.tree, 'l1_matched_dgmuon_track',
event.the_hnl.l1().bestdgmuon)
if event.the_hnl.l1().bestmatch != None:
self.fillParticle(self.tree, 'l1_bestmatch',
event.the_hnl.l1().bestmatch)
self.fill(self.tree, 'l1_bestmatchtype',
event.the_hnl.l1().bestmatchtype)
self.fillParticle(self.tree, 'l2', event.the_hnl.l2())
if hasattr(event.the_hnl.l2(), 'bestelectron'):
self.fillEle(self.tree, 'l2_matched_electron',
event.the_hnl.l2().bestelectron)
if hasattr(event.the_hnl.l2(), 'bestphoton'):
self.fillPhoton(self.tree, 'l2_matched_photon',
event.the_hnl.l2().bestphoton)
if hasattr(event.the_hnl.l2(), 'bestmuon'):
self.fillMuon(self.tree, 'l2_matched_muon',
event.the_hnl.l2().bestmuon)
self.fillMuonTrack(self.tree, 'l2_matched_muon_track',
event.the_hnl.l2().bestmuon.bestTrack())
if hasattr(event.the_hnl.l2(), 'besttau'):
self.fillTau(self.tree, 'l2_matched_tau',
event.the_hnl.l2().besttau)
if hasattr(event.the_hnl.l2(), 'bestdsmuon'):
self.fillParticle(self.tree, 'l2_matched_dsmuon',
event.the_hnl.l2().bestdsmuon)
self.fillMuonTrack(self.tree, 'l2_matched_dsmuon_track',
event.the_hnl.l2().bestdsmuon)
if hasattr(event.the_hnl.l2(), 'bestdgmuon'):
self.fillParticle(self.tree, 'l2_matched_dgmuon',
event.the_hnl.l2().bestdgmuon)
self.fillMuonTrack(self.tree, 'l2_matched_dgmuon_track',
event.the_hnl.l2().bestdgmuon)
if event.the_hnl.l2().bestmatch != None:
self.fillParticle(self.tree, 'l2_bestmatch',
event.the_hnl.l2().bestmatch)
self.fill(self.tree, 'l2_bestmatchtype',
event.the_hnl.l2().bestmatchtype)
# final neutrino
self.fillGenParticle(self.tree, 'n', event.the_hnl.met())
# true primary vertex
self.fill(self.tree, 'pv_x', event.the_hn.vx())
self.fill(self.tree, 'pv_y', event.the_hn.vy())
self.fill(self.tree, 'pv_z', event.the_hn.vz())
# true HN decay vertex
self.fill(self.tree, 'sv_x',
event.the_hn.lep1.vertex().x()
) # don't use the final lepton to get the vertex from!
self.fill(self.tree, 'sv_y',
event.the_hn.lep1.vertex().y()
) # don't use the final lepton to get the vertex from!
self.fill(self.tree, 'sv_z',
event.the_hn.lep1.vertex().z()
) # don't use the final lepton to get the vertex from!
# displacements
self.fill(self.tree, 'hnl_2d_disp',
displacement2D(event.the_hn.lep1, event.the_hn))
self.fill(self.tree, 'hnl_3d_disp',
displacement3D(event.the_hn.lep1, event.the_hn))
# reco secondary vertex and displacement
if event.recoSv:
self.fill(self.tree, 'sv_reco_x', event.recoSv.x())
self.fill(self.tree, 'sv_reco_y', event.recoSv.y())
self.fill(self.tree, 'sv_reco_z', event.recoSv.z())
self.fill(self.tree, 'sv_reco_xe', event.recoSv.xError())
self.fill(self.tree, 'sv_reco_ye', event.recoSv.yError())
self.fill(self.tree, 'sv_reco_ze', event.recoSv.zError())
self.fill(self.tree, 'sv_reco_prob', event.recoSv.prob)
self.fill(self.tree, 'sv_reco_cos', event.recoSv.disp2DFromBS_cos)
self.fill(self.tree, 'hnl_2d_reco_disp',
event.recoSv.disp2DFromBS.value()) # from beamspot
self.fill(self.tree, 'hnl_3d_reco_disp',
event.recoSv.disp3DFromBS.value()) # from PV
self.fill(self.tree, 'hnl_2d_reco_disp_sig',
event.recoSv.disp2DFromBS_sig) # from beamspot
self.fill(self.tree, 'hnl_3d_reco_disp_sig',
event.recoSv.disp3DFromBS_sig) # from PV
# flag if the event is in CMS acceptance |eta|<2.4 (general CMS is 2.5, but the muon system is 2.4)
is_in_acc = abs(event.the_hnl.l0().eta())<2.4 and \
abs(event.the_hnl.l1().eta())<2.4 and \
abs(event.the_hnl.l2().eta())<2.4
self.fill(self.tree, 'is_in_acc', is_in_acc)
self.fillTree(event)
def process(self, event):
'''
'''
self.readCollections(event.input)
self.tree.reset()
# import pdb;pdb.set_trace() #zhud: debug
if not eval(self.skimFunction):
return False
self.fillEvent(self.tree, event)
self.fillHNL(self.tree, 'hnl', event.the_hnl)
# the prompt lepton
self.fillGenParticle(self.tree, 'l0', event.the_hnl.l0())
if hasattr(event.the_hnl.l0(), 'bestelectron'):
self.fillEle(self.tree, 'l0_matched_electron',
event.the_hnl.l0().bestelectron)
if hasattr(event.the_hnl.l0(), 'bestphoton'):
self.fillPhoton(self.tree, 'l0_matched_photon',
event.the_hnl.l0().bestphoton)
if hasattr(event.the_hnl.l0(), 'bestmuon'):
self.fillMuon(self.tree, 'l0_matched_muon',
event.the_hnl.l0().bestmuon)
self.fillMuonTrack(self.tree, 'l0_matched_muon_track',
event.the_hnl.l0().bestmuon.bestTrack())
if hasattr(event.the_hnl.l0(), 'besttau'):
self.fillTau(self.tree, 'l0_matched_tau',
event.the_hnl.l0().besttau)
if hasattr(event.the_hnl.l0(), 'bestdsmuon'):
self.fillParticle(self.tree, 'l0_matched_dsmuon',
event.the_hnl.l0().bestdsmuon)
self.fillMuonTrack(self.tree, 'l0_matched_dsmuon_track',
event.the_hnl.l0().bestdsmuon)
if hasattr(event.the_hnl.l0(), 'bestdgmuon'):
self.fillParticle(self.tree, 'l0_matched_dgmuon',
event.the_hnl.l0().bestdgmuon)
self.fillMuonTrack(self.tree, 'l0_matched_dgmuon_track',
event.the_hnl.l0().bestdgmuon)
# displaced leptons (from the HN)
self.fillGenParticle(self.tree, 'l1', event.the_hnl.l1())
if hasattr(event.the_hnl.l1(), 'bestelectron'):
self.fillEle(self.tree, 'l1_matched_electron',
event.the_hnl.l1().bestelectron)
if hasattr(event.the_hnl.l1(), 'bestphoton'):
self.fillPhoton(self.tree, 'l1_matched_photon',
event.the_hnl.l1().bestphoton)
if hasattr(event.the_hnl.l1(), 'bestmuon'):
self.fillMuon(self.tree, 'l1_matched_muon',
event.the_hnl.l1().bestmuon)
self.fillMuonTrack(self.tree, 'l1_matched_muon_track',
event.the_hnl.l1().bestmuon.bestTrack())
if hasattr(event.the_hnl.l1(), 'besttau'):
self.fillTau(self.tree, 'l1_matched_tau',
event.the_hnl.l1().besttau)
if hasattr(event.the_hnl.l1(), 'bestdsmuon'):
self.fillParticle(self.tree, 'l1_matched_dsmuon',
event.the_hnl.l1().bestdsmuon)
self.fillMuonTrack(self.tree, 'l1_matched_dsmuon_track',
event.the_hnl.l1().bestdsmuon)
if hasattr(event.the_hnl.l1(), 'bestdgmuon'):
self.fillParticle(self.tree, 'l1_matched_dgmuon',
event.the_hnl.l1().bestdgmuon)
self.fillMuonTrack(self.tree, 'l1_matched_dgmuon_track',
event.the_hnl.l1().bestdgmuon)
self.fillGenParticle(self.tree, 'l2', event.the_hnl.l2())
if hasattr(event.the_hnl.l2(), 'bestelectron'):
self.fillEle(self.tree, 'l2_matched_electron',
event.the_hnl.l2().bestelectron)
if hasattr(event.the_hnl.l2(), 'bestphoton'):
self.fillPhoton(self.tree, 'l2_matched_photon',
event.the_hnl.l2().bestphoton)
if hasattr(event.the_hnl.l2(), 'bestmuon'):
self.fillMuon(self.tree, 'l2_matched_muon',
event.the_hnl.l2().bestmuon)
self.fillMuonTrack(self.tree, 'l2_matched_muon_track',
event.the_hnl.l2().bestmuon.bestTrack())
if hasattr(event.the_hnl.l2(), 'besttau'):
self.fillTau(self.tree, 'l2_matched_tau',
event.the_hnl.l2().besttau)
if hasattr(event.the_hnl.l2(), 'bestdsmuon'):
self.fillParticle(self.tree, 'l2_matched_dsmuon',
event.the_hnl.l2().bestdsmuon)
self.fillMuonTrack(self.tree, 'l2_matched_dsmuon_track',
event.the_hnl.l2().bestdsmuon)
if hasattr(event.the_hnl.l2(), 'bestdgmuon'):
self.fillParticle(self.tree, 'l2_matched_dgmuon',
event.the_hnl.l2().bestdgmuon)
self.fillMuonTrack(self.tree, 'l2_matched_dgmuon_track',
event.the_hnl.l2().bestdgmuon)
# final neutrino
self.fillGenParticle(self.tree, 'n', event.the_hnl.met())
# true primary vertex
self.fill(self.tree, 'pv_x', event.the_hn.vx())
self.fill(self.tree, 'pv_y', event.the_hn.vy())
self.fill(self.tree, 'pv_z', event.the_hn.vz())
# true HN decay vertex
self.fill(self.tree, 'sv_x',
event.the_hn.lep1.vertex().x()
) # don't use the final lepton to get the vertex from!
self.fill(self.tree, 'sv_y',
event.the_hn.lep1.vertex().y()
) # don't use the final lepton to get the vertex from!
self.fill(self.tree, 'sv_z',
event.the_hn.lep1.vertex().z()
) # don't use the final lepton to get the vertex from!
# displacements
self.fill(self.tree, 'hnl_2d_disp',
displacement2D(event.the_hn.lep1, event.the_hn))
self.fill(self.tree, 'hnl_3d_disp',
displacement3D(event.the_hn.lep1, event.the_hn))
# reco secondary vertex and displacement
if event.recoSv:
self.fill(self.tree, 'sv_reco_x', event.recoSv.x())
self.fill(self.tree, 'sv_reco_y', event.recoSv.y())
self.fill(self.tree, 'sv_reco_z', event.recoSv.z())
self.fill(self.tree, 'sv_reco_xe', event.recoSv.xError())
self.fill(self.tree, 'sv_reco_ye', event.recoSv.yError())
self.fill(self.tree, 'sv_reco_ze', event.recoSv.zError())
self.fill(self.tree, 'sv_reco_prob', event.recoSv.prob)
self.fill(self.tree, 'sv_reco_cos', event.recoSv.disp2DFromBS_cos)
self.fill(self.tree, 'hnl_2d_reco_disp',
event.recoSv.disp2DFromBS.value()) # from beamspot
self.fill(self.tree, 'hnl_3d_reco_disp',
event.recoSv.disp3DFromBS.value()) # from PV
self.fill(self.tree, 'hnl_2d_reco_disp_sig',
event.recoSv.disp2DFromBS_sig) # from beamspot
self.fill(self.tree, 'hnl_3d_reco_disp_sig',
event.recoSv.disp3DFromBS_sig) # from PV
# flag if the event is in CMS acceptance |eta|<2.5
is_in_acc = abs(event.the_hnl.l0().eta())<2.5 and \
abs(event.the_hnl.l1().eta())<2.5 and \
abs(event.the_hnl.l2().eta())<2.5
self.fill(self.tree, 'is_in_acc', is_in_acc)
self.fillTree(event)
def process(self, event):
'''
'''
self.readCollections(event.input)
self.tree.reset()
# output of reco analysis
self.fillEvent(self.tree, event)
self.fill(self.tree, 'n_cands', len(event.dimuonsvtx))
# different candidates
if len(event.dimuonsvtx):
# self.fillHNCandidate(self.tree, 'hnl_minchi2' , event.hnl_minchi2 )
# self.fillHNCandidate(self.tree, 'hnl_maxpt' , event.hnl_maxpt )
# self.fillHNCandidate(self.tree, 'hnl_mindr' , event.hnl_mindr )
# self.fillHNCandidate(self.tree, 'hnl_maxdphi' , event.hnl_maxdphi )
# self.fillHNCandidate(self.tree, 'hnl_mindeta' , event.hnl_mindeta )
# self.fillHNCandidate(self.tree, 'hnl_maxdisp2dbs', event.hnl_maxdisp2dbs)
# self.fillHNCandidate(self.tree, 'hnl_maxdisp2dpv', event.hnl_maxdisp2dpv)
# self.fillHNCandidate(self.tree, 'hnl_maxdisp3dpv', event.hnl_maxdisp3dpv)
# self.fillHNCandidate(self.tree, 'hnl_maxdls2dbs' , event.hnl_maxdls2dbs )
# self.fillHNCandidate(self.tree, 'hnl_maxdls2dpv' , event.hnl_maxdls2dpv )
# self.fillHNCandidate(self.tree, 'hnl_maxdls3dpv' , event.hnl_maxdls3dpv )
self.fillHNCandidate(self.tree, 'hnl_maxcos', event.hnl_maxcos)
self.fillParticle(self.tree, 'mu1', event.hnl_maxcos.lep1())
self.fill(self.tree, 'mu1_type', event.hnl_maxcos.lep1().type)
self.fillParticle(self.tree, 'mu2', event.hnl_maxcos.lep2())
self.fill(self.tree, 'mu2_type', event.hnl_maxcos.lep2().type)
# output of MC analysis
self.fillHNL(self.tree, 'hnl', event.the_hnl)
# the prompt lepton
self.fillParticle(self.tree, 'l0', event.the_hnl.l0())
if hasattr(event.the_hnl.l0(), 'bestelectron'):
self.fillEle(self.tree, 'l0_matched_electron',
event.the_hnl.l0().bestelectron)
if hasattr(event.the_hnl.l0(), 'bestphoton'):
self.fillPhoton(self.tree, 'l0_matched_photon',
event.the_hnl.l0().bestphoton)
if hasattr(event.the_hnl.l0(), 'bestmuon'):
self.fillMuon(self.tree, 'l0_matched_muon',
event.the_hnl.l0().bestmuon)
self.fillMuonTrack(self.tree, 'l0_matched_muon_track',
event.the_hnl.l0().bestmuon.bestTrack())
if hasattr(event.the_hnl.l0(), 'besttau'):
self.fillTau(self.tree, 'l0_matched_tau',
event.the_hnl.l0().besttau)
if hasattr(event.the_hnl.l0(), 'bestdsmuon'):
self.fillParticle(self.tree, 'l0_matched_dsmuon',
event.the_hnl.l0().bestdsmuon)
self.fillMuonTrack(self.tree, 'l0_matched_dsmuon_track',
event.the_hnl.l0().bestdsmuon)
if hasattr(event.the_hnl.l0(), 'bestdgmuon'):
self.fillParticle(self.tree, 'l0_matched_dgmuon',
event.the_hnl.l0().bestdgmuon)
self.fillMuonTrack(self.tree, 'l0_matched_dgmuon_track',
event.the_hnl.l0().bestdgmuon)
if event.the_hnl.l0().bestmatch != None:
self.fillParticle(self.tree, 'l0_bestmatch',
event.the_hnl.l0().bestmatch)
self.fill(self.tree, 'l0_bestmatch_type',
event.the_hnl.l0().bestmatchtype)
# displaced leptons (from the HN)
self.fillParticle(self.tree, 'l1', event.the_hnl.l1())
if hasattr(event.the_hnl.l1(), 'bestelectron'):
self.fillEle(self.tree, 'l1_matched_electron',
event.the_hnl.l1().bestelectron)
if hasattr(event.the_hnl.l1(), 'bestphoton'):
self.fillPhoton(self.tree, 'l1_matched_photon',
event.the_hnl.l1().bestphoton)
if hasattr(event.the_hnl.l1(), 'bestmuon'):
self.fillMuon(self.tree, 'l1_matched_muon',
event.the_hnl.l1().bestmuon)
self.fillMuonTrack(self.tree, 'l1_matched_muon_track',
event.the_hnl.l1().bestmuon.bestTrack())
if hasattr(event.the_hnl.l1(), 'besttau'):
self.fillTau(self.tree, 'l1_matched_tau',
event.the_hnl.l1().besttau)
if hasattr(event.the_hnl.l1(), 'bestdsmuon'):
self.fillParticle(self.tree, 'l1_matched_dsmuon',
event.the_hnl.l1().bestdsmuon)
self.fillMuonTrack(self.tree, 'l1_matched_dsmuon_track',
event.the_hnl.l1().bestdsmuon)
if hasattr(event.the_hnl.l1(), 'bestdgmuon'):
self.fillParticle(self.tree, 'l1_matched_dgmuon',
event.the_hnl.l1().bestdgmuon)
self.fillMuonTrack(self.tree, 'l1_matched_dgmuon_track',
event.the_hnl.l1().bestdgmuon)
if event.the_hnl.l1().bestmatch != None:
self.fillParticle(self.tree, 'l1_bestmatch',
event.the_hnl.l1().bestmatch)
self.fill(self.tree, 'l1_bestmatch_type',
event.the_hnl.l1().bestmatchtype)
self.fillParticle(self.tree, 'l2', event.the_hnl.l2())
if hasattr(event.the_hnl.l2(), 'bestelectron'):
self.fillEle(self.tree, 'l2_matched_electron',
event.the_hnl.l2().bestelectron)
if hasattr(event.the_hnl.l2(), 'bestphoton'):
self.fillPhoton(self.tree, 'l2_matched_photon',
event.the_hnl.l2().bestphoton)
if hasattr(event.the_hnl.l2(), 'bestmuon'):
self.fillMuon(self.tree, 'l2_matched_muon',
event.the_hnl.l2().bestmuon)
self.fillMuonTrack(self.tree, 'l2_matched_muon_track',
event.the_hnl.l2().bestmuon.bestTrack())
if hasattr(event.the_hnl.l2(), 'besttau'):
self.fillTau(self.tree, 'l2_matched_tau',
event.the_hnl.l2().besttau)
if hasattr(event.the_hnl.l2(), 'bestdsmuon'):
self.fillParticle(self.tree, 'l2_matched_dsmuon',
event.the_hnl.l2().bestdsmuon)
self.fillMuonTrack(self.tree, 'l2_matched_dsmuon_track',
event.the_hnl.l2().bestdsmuon)
if hasattr(event.the_hnl.l2(), 'bestdgmuon'):
self.fillParticle(self.tree, 'l2_matched_dgmuon',
event.the_hnl.l2().bestdgmuon)
self.fillMuonTrack(self.tree, 'l2_matched_dgmuon_track',
event.the_hnl.l2().bestdgmuon)
if event.the_hnl.l2().bestmatch != None:
self.fillParticle(self.tree, 'l2_bestmatch',
event.the_hnl.l2().bestmatch)
self.fill(self.tree, 'l2_bestmatch_type',
event.the_hnl.l2().bestmatchtype)
# final neutrino
self.fillGenParticle(self.tree, 'n', event.the_hnl.met())
# true primary vertex
self.fill(self.tree, 'pv_x', event.the_hn.vx())
self.fill(self.tree, 'pv_y', event.the_hn.vy())
self.fill(self.tree, 'pv_z', event.the_hn.vz())
# true HN decay vertex
self.fill(self.tree, 'sv_x',
event.the_hn.lep1.vertex().x()
) # don't use the final lepton to get the vertex from!
self.fill(self.tree, 'sv_y',
event.the_hn.lep1.vertex().y()
) # don't use the final lepton to get the vertex from!
self.fill(self.tree, 'sv_z',
event.the_hn.lep1.vertex().z()
) # don't use the final lepton to get the vertex from!
# displacements
self.fill(self.tree, 'hnl_2d_disp',
displacement2D(event.the_hn.lep1, event.the_hn))
self.fill(self.tree, 'hnl_3d_disp',
displacement3D(event.the_hn.lep1, event.the_hn))
# reco secondary vertex and displacement
if event.recoSv:
self.fill(self.tree, 'sv_reco_x', event.recoSv.x())
self.fill(self.tree, 'sv_reco_y', event.recoSv.y())
self.fill(self.tree, 'sv_reco_z', event.recoSv.z())
self.fill(self.tree, 'sv_reco_xe', event.recoSv.xError())
self.fill(self.tree, 'sv_reco_ye', event.recoSv.yError())
self.fill(self.tree, 'sv_reco_ze', event.recoSv.zError())
self.fill(self.tree, 'sv_reco_prob', event.recoSv.prob)
self.fill(self.tree, 'sv_reco_cos', event.recoSv.disp2DFromBS_cos)
self.fill(self.tree, 'hnl_2d_reco_disp',
event.recoSv.disp2DFromBS.value()) # from beamspot
self.fill(self.tree, 'hnl_3d_reco_disp',
event.recoSv.disp3DFromBS.value()) # from PV
self.fill(self.tree, 'hnl_2d_reco_disp_sig',
event.recoSv.disp2DFromBS_sig) # from beamspot
self.fill(self.tree, 'hnl_3d_reco_disp_sig',
event.recoSv.disp3DFromBS_sig) # from PV
# flag if the event is in CMS acceptance |eta|<2.4 (general CMS is 2.5, but the muon system is 2.4)
is_in_acc = abs(event.the_hnl.l0().eta())<2.4 and \
abs(event.the_hnl.l1().eta())<2.4 and \
abs(event.the_hnl.l2().eta())<2.4
self.fill(self.tree, 'is_in_acc', is_in_acc)
self.fillTree(event)
def process(self, event):
'''
'''
self.readCollections(event.input)
self.tree.reset()
self.event = event
# event variables
self.fillEvent(self.tree, event)
self.fill(self.tree, 'n_cands', len(event.dimuonsvtx))
self.fill(self.tree, 'rho', event.rho)
# reco HNL
self.fillHNL(self.tree, 'hnl', event.the_3lep_cand)
self.fill(self.tree, 'hnl_iso03_abs_rhoArea',
event.the_3lep_cand.abs_tot_iso03_rhoArea)
self.fill(self.tree, 'hnl_iso04_abs_rhoArea',
event.the_3lep_cand.abs_tot_iso04_rhoArea)
self.fill(self.tree, 'hnl_iso05_abs_rhoArea',
event.the_3lep_cand.abs_tot_iso05_rhoArea)
self.fill(self.tree, 'hnl_iso03_abs_deltaBeta',
event.the_3lep_cand.abs_tot_iso03_deltaBeta)
self.fill(self.tree, 'hnl_iso04_abs_deltaBeta',
event.the_3lep_cand.abs_tot_iso04_deltaBeta)
self.fill(self.tree, 'hnl_iso05_abs_deltaBeta',
event.the_3lep_cand.abs_tot_iso05_deltaBeta)
# self.fill (self.tree, 'hnl_iso_abs_met' , event.the_3lep_cand.abs_ch_iso_met )
self.fill(self.tree, 'hnl_iso03_rel_rhoArea',
event.the_3lep_cand.rel_tot_iso03_rhoArea)
self.fill(self.tree, 'hnl_iso04_rel_rhoArea',
event.the_3lep_cand.rel_tot_iso04_rhoArea)
self.fill(self.tree, 'hnl_iso05_rel_rhoArea',
event.the_3lep_cand.rel_tot_iso05_rhoArea)
self.fill(self.tree, 'hnl_iso03_rel_deltaBeta',
event.the_3lep_cand.rel_tot_iso03_deltaBeta)
self.fill(self.tree, 'hnl_iso04_rel_deltaBeta',
event.the_3lep_cand.rel_tot_iso04_deltaBeta)
self.fill(self.tree, 'hnl_iso05_rel_deltaBeta',
event.the_3lep_cand.rel_tot_iso05_deltaBeta)
# self.fill (self.tree, 'hnl_iso_rel_met' , event.the_3lep_cand.rel_ch_iso_met )
self.fillMuon(self.tree, 'l1', event.the_3lep_cand.l1())
self.fillMuon(self.tree, 'l2', event.the_3lep_cand.l2())
if self.cfg_ana.promptLepType == 'ele':
self.fillEle(self.tree, 'l0', event.the_3lep_cand.l0())
if self.cfg_ana.promptLepType == 'mu':
self.fillMuon(self.tree, 'l0', event.the_3lep_cand.l0())
# output of MC analysis ONLY FOR SIGNAL
if hasattr(event, 'the_hnl'):
self.fillHNL(self.tree, 'hnl_gen', event.the_hnl)
self.fillParticle(self.tree, 'l0_gen', event.the_hnl.l0())
self.fillParticle(self.tree, 'l1_gen', event.the_hnl.l1())
self.fillParticle(self.tree, 'l2_gen', event.the_hnl.l2())
self.fillParticle(self.tree, 'n_gen', event.the_hnl.met())
# reco primary vertex
pv = event.goodVertices[0]
self.fill(self.tree, 'pv_x', pv.x())
self.fill(self.tree, 'pv_y', pv.y())
self.fill(self.tree, 'pv_z', pv.z())
self.fill(self.tree, 'pv_xe', pv.xError())
self.fill(self.tree, 'pv_ye', pv.yError())
self.fill(self.tree, 'pv_ze', pv.zError())
# true primary vertex
if hasattr(event, 'the_hnl'):
self.fill(self.tree, 'pv_gen_x', event.the_hn.vx())
self.fill(self.tree, 'pv_gen_y', event.the_hn.vy())
self.fill(self.tree, 'pv_gen_z', event.the_hn.vz())
# beamspot
self.fill(self.tree, 'bs_x', event.beamspot.x0())
self.fill(self.tree, 'bs_y', event.beamspot.y0())
self.fill(self.tree, 'bs_z', event.beamspot.z0())
self.fill(self.tree, 'bs_sigma_x', event.beamspot.BeamWidthX())
self.fill(self.tree, 'bs_sigma_y', event.beamspot.BeamWidthY())
self.fill(self.tree, 'bs_sigma_z', event.beamspot.sigmaZ())
self.fill(self.tree, 'bs_dxdz', event.beamspot.dxdz())
self.fill(self.tree, 'bs_dydz', event.beamspot.dydz())
# true HN decay vertex
if hasattr(event, 'the_hn'):
self.fill(self.tree, 'sv_gen_x',
event.the_hn.lep1.vertex().x()
) # don't use the final lepton to get the vertex from!
self.fill(self.tree, 'sv_gen_y',
event.the_hn.lep1.vertex().y()
) # don't use the final lepton to get the vertex from!
self.fill(self.tree, 'sv_gen_z',
event.the_hn.lep1.vertex().z()
) # don't use the final lepton to get the vertex from!
# displacements
self.fill(self.tree, 'hnl_2d_gen_disp',
displacement2D(event.the_hn.lep1, event.the_hn))
self.fill(self.tree, 'hnl_3d_gen_disp',
displacement3D(event.the_hn.lep1, event.the_hn))
# HLT bits & matches
trig_list = [trig.name for trig in event.trigger_infos if trig.fired]
if self.cfg_ana.promptLepType == 'ele':
self.fill(
self.tree, 'hlt_Ele27_WPTight_Gsf',
any('HLT_Ele27_WPTight_Gsf' in name for name in trig_list))
self.fill(
self.tree, 'hlt_Ele32_WPTight_Gsf',
any('HLT_Ele32_WPTight_Gsf' in name for name in trig_list))
self.fill(
self.tree, 'hlt_Ele35_WPTight_Gsf',
any('HLT_Ele35_WPTight_Gsf' in name for name in trig_list))
self.fill(
self.tree, 'hlt_Ele115_CaloIdVT_GsfTrkIdT',
any('HLT_Ele115_CaloIdVT_GsfTrkIdT' in name
for name in trig_list))
self.fill(
self.tree, 'hlt_Ele135_CaloIdVT_GsfTrkIdT',
any('HLT_Ele135_CaloIdVT_GsfTrkIdT' in name
for name in trig_list))
if self.cfg_ana.promptLepType == 'mu':
self.fill(self.tree, 'hlt_soMu24',
any('HLT_IsoMu24' in name for name in trig_list))
self.fill(self.tree, 'hlt_soMu27',
any('HLT_IsoMu27' in name for name in trig_list))
self.fill(self.tree, 'hlt_u50',
any('HLT_Mu50' in name for name in trig_list))
# reco secondary vertex and displacement
self.fill(self.tree, 'sv_x', event.recoSv.x())
self.fill(self.tree, 'sv_y', event.recoSv.y())
self.fill(self.tree, 'sv_z', event.recoSv.z())
self.fill(self.tree, 'sv_xe', event.recoSv.xError())
self.fill(self.tree, 'sv_ye', event.recoSv.yError())
self.fill(self.tree, 'sv_ze', event.recoSv.zError())
self.fill(self.tree, 'sv_prob', event.recoSv.prob)
self.fill(self.tree, 'sv_cos', event.recoSv.disp2DFromBS_cos)
self.fill(self.tree, 'hnl_2d_disp',
event.recoSv.disp2DFromBS.value()) # from beamspot
self.fill(self.tree, 'hnl_3d_disp',
event.recoSv.disp3DFromBS.value()) # from PV
self.fill(self.tree, 'hnl_2d_disp_sig',
event.recoSv.disp2DFromBS_sig) # from beamspot
self.fill(self.tree, 'hnl_3d_disp_sig',
event.recoSv.disp3DFromBS_sig) # from PV
# jet/met variables
self.fillExtraMetInfo(self.tree, event)
# set_trace()
# met filter flags
self.fill(self.tree, 'Flag_goodVertices', event.Flag_goodVertices)
self.fill(self.tree, 'Flag_globalSuperTightHalo2016Filter',
event.Flag_globalSuperTightHalo2016Filter)
self.fill(self.tree, 'Flag_HBHENoiseFilter',
event.Flag_HBHENoiseFilter)
self.fill(self.tree, 'Flag_HBHENoiseIsoFilter',
event.Flag_HBHENoiseIsoFilter)
self.fill(self.tree, 'Flag_EcalDeadCellTriggerPrimitiveFilter',
event.Flag_EcalDeadCellTriggerPrimitiveFilter)
self.fill(self.tree, 'Flag_BadPFMuonFilter',
event.Flag_BadPFMuonFilter)
self.fill(self.tree, 'Flag_BadChargedCandidateFilter',
event.Flag_BadChargedCandidateFilter)
self.fill(self.tree, 'Flag_eeBadScFilter', event.Flag_eeBadScFilter)
self.fill(self.tree, 'Flag_ecalBadCalibFilter',
event.Flag_ecalBadCalibFilter)
# self.fill(self.tree, 'Flag_any_met_filters', event.Flag_goodVertices or event.Flag_globalSuperTightHalo2016Filter or event.Flag_HBHENoiseFilter or event.Flag_HBHENoiseIsoFilter or event.Flag_EcalDeadCellTriggerPrimitiveFilter or event.Flag_BadPFMuonFilter or event.Flag_BadChargedCandidateFilter or event.Flag_eeBadScFilter or event.Flag_ecalBadCalibFilter)
if len(event.cleanJets) > 0:
self.fillJet(self.tree, 'j1', event.cleanJets[0], fill_extra=False)
if len(event.cleanJets) > 1:
self.fillJet(self.tree, 'j2', event.cleanJets[1], fill_extra=False)
if len(event.cleanBJets) > 0:
self.fillJet(self.tree,
'bj1',
event.cleanBJets[0],
fill_extra=False)
if len(event.cleanBJets) > 1:
self.fillJet(self.tree,
'bj2',
event.cleanBJets[1],
fill_extra=False)
self.fill(self.tree, 'htj', event.HT_cleanJets)
self.fill(self.tree, 'htbj', event.HT_bJets)
self.fill(self.tree, 'nj', len(event.cleanJets))
self.fill(self.tree, 'nbj', len(event.cleanBJets))
# gen match
if self.cfg_comp.isMC == True:
stable_genp = [
pp for pp in event.genParticles
if ((pp.status() == 23 or pp.status() == 1) and (
pp.vertex().z() != 0))
]
stable_genp += [
pp for pp in event.genp_packed
if ((pp.status() == 23 or pp.status() == 1) and (
pp.vertex().z() != 0))
]
# particle status: http://home.thep.lu.se/~torbjorn/pythia81html/ParticleProperties.html
# 1 ... stable; 23 ... from hardest scattering subprocess
tomatch = [(event.the_3lep_cand.l0(), 0.05 * 0.05),
(event.the_3lep_cand.l1(), 0.2 * 0.2),
(event.the_3lep_cand.l2(), 0.2 * 0.2)]
for ilep, idr2 in tomatch:
bestmatch, dr2 = bestMatch(ilep, stable_genp)
if (dr2 < idr2 and abs(
(ilep.pt() - bestmatch.pt()) / ilep.pt()) < 0.2):
ilep.bestmatch = bestmatch
# relevant for signal: check if reco matched with gen, save a bool
if hasattr(event.the_3lep_cand.l0(), 'bestmatch'):
self.fillSimpleGenParticle(self.tree, 'l0_gen_match',
event.the_3lep_cand.l0().bestmatch)
if hasattr(event.the_3lep_cand.l1(), 'bestmatch'):
self.fillSimpleGenParticle(self.tree, 'l1_gen_match',
event.the_3lep_cand.l1().bestmatch)
if hasattr(event.the_3lep_cand.l2(), 'bestmatch'):
self.fillSimpleGenParticle(self.tree, 'l2_gen_match',
event.the_3lep_cand.l2().bestmatch)
# FIXME! matching by pointer does not work, so let's trick it with deltaR
if hasattr(event, 'the_hnl'):
if hasattr(event.the_3lep_cand.l0(), 'bestmatch'):
self.fill(
self.tree, 'l0_is_real',
deltaR(event.the_3lep_cand.l0().bestmatch,
event.the_hnl.l0()) < 0.01)
if hasattr(event.the_3lep_cand.l1(), 'bestmatch'):
self.fill(
self.tree, 'l1_is_real',
deltaR(event.the_3lep_cand.l1().bestmatch,
event.the_hnl.l1()) < 0.05)
if hasattr(event.the_3lep_cand.l2(), 'bestmatch'):
self.fill(
self.tree, 'l2_is_real',
deltaR(event.the_3lep_cand.l2().bestmatch,
event.the_hnl.l2()) < 0.05)
# extra lepton veto
self.fill(self.tree, 'pass_e_veto', len(event.veto_eles) == 0)
self.fill(self.tree, 'pass_m_veto', len(event.veto_mus) == 0)
# save vetoing lepton invariant masses
if len(event.veto_eles):
self.fillEle(self.tree, 'veto_ele', event.veto_save_ele)
self.fill(self.tree, 'hnl_m_0Vele',
(event.veto_save_ele.p4() +
event.the_3lep_cand.l0().p4()).mass())
self.fill(self.tree, 'hnl_m_1Vele',
(event.veto_save_ele.p4() +
event.the_3lep_cand.l1().p4()).mass())
self.fill(self.tree, 'hnl_m_2Vele',
(event.veto_save_ele.p4() +
event.the_3lep_cand.l2().p4()).mass())
if len(event.veto_mus):
self.fillMuon(self.tree, 'veto_mu', event.veto_save_mu)
self.fill(self.tree, 'hnl_m_0Vmu',
(event.veto_save_mu.p4() +
event.the_3lep_cand.l0().p4()).mass())
self.fill(self.tree, 'hnl_m_1Vmu',
(event.veto_save_mu.p4() +
event.the_3lep_cand.l1().p4()).mass())
self.fill(self.tree, 'hnl_m_2Vmu',
(event.veto_save_mu.p4() +
event.the_3lep_cand.l2().p4()).mass())
# LHE weight
self.fill(self.tree, 'lhe_weight',
np.sign(getattr(event, 'LHE_originalWeight', 1.)))
self.fillTree(event)
def process(self, event, fill=True):
'''
'''
self.readCollections(event.input)
self.tree.reset()
self.counters.counter('HNLTreeProducer').inc('all events')
# save the event only if it is in the correct final state
if not eval(self.finalStateFilter):
return True
self.counters.counter('HNLTreeProducer').inc('pass final state')
# get ahold of the objects to save
final_state = self.cfg_ana.promptLepType + self.cfg_ana.L1L2LeptonType
dileptonsvtx = event.dileptonsvtx_dict[final_state]
the_3lep_cand = event.the_3lep_cand_dict[final_state]
recoSv = event.recoSv_dict[final_state]
# save the event only if it passes the skim selection (if it exists)
# import pdb ; pdb.set_trace()
if not eval(self.skimFilter):
return True
self.counters.counter('HNLTreeProducer').inc('pass skim')
# also cleaned jet collections depend on the final state
cleanJets = event.cleanJets[final_state]
cleanBJets = event.cleanBJets[final_state]
cleanJets30 = event.cleanJets30[final_state]
# adjust the weights, according to the final state
event.eventWeight = getattr(event, 'puWeight', 1.) * \
getattr(event, 'LHE_originalWeight', 1.) * \
getattr(event, 'weight_%s' %final_state, 1.)
the_3lep_cand.l0().weight = getattr(the_3lep_cand.l0(),
'weight_%s' % final_state, 1.)
the_3lep_cand.l0().weight_id = getattr(the_3lep_cand.l0(),
'weight_%s_id' % final_state,
1.)
the_3lep_cand.l0().weight_iso = getattr(the_3lep_cand.l0(),
'weight_%s_iso' % final_state,
1.)
the_3lep_cand.l0().weight_reco = getattr(
the_3lep_cand.l0(), 'weight_%s_reco' % final_state, 1.)
the_3lep_cand.l0().weight_idiso = getattr(
the_3lep_cand.l0(), 'weight_%s_idiso' % final_state, 1.)
the_3lep_cand.l0().weight_trigger = getattr(
the_3lep_cand.l0(), 'weight_%s_trigger' % final_state, 1.)
the_3lep_cand.l0().weight_tracking = getattr(
the_3lep_cand.l0(), 'weight_%s_tracking' % final_state, 1.)
the_3lep_cand.l1().weight = getattr(the_3lep_cand.l1(),
'weight_%s' % final_state, 1.)
the_3lep_cand.l1().weight_id = getattr(the_3lep_cand.l1(),
'weight_%s_id' % final_state,
1.)
the_3lep_cand.l1().weight_iso = getattr(the_3lep_cand.l1(),
'weight_%s_iso' % final_state,
1.)
the_3lep_cand.l1().weight_reco = getattr(
the_3lep_cand.l1(), 'weight_%s_reco' % final_state, 1.)
the_3lep_cand.l1().weight_idiso = getattr(
the_3lep_cand.l1(), 'weight_%s_idiso' % final_state, 1.)
the_3lep_cand.l1().weight_trigger = getattr(
the_3lep_cand.l1(), 'weight_%s_trigger' % final_state, 1.)
the_3lep_cand.l1().weight_tracking = getattr(
the_3lep_cand.l1(), 'weight_%s_tracking' % final_state, 1.)
the_3lep_cand.l2().weight = getattr(the_3lep_cand.l2(),
'weight_%s' % final_state, 1.)
the_3lep_cand.l2().weight_id = getattr(the_3lep_cand.l2(),
'weight_%s_id' % final_state,
1.)
the_3lep_cand.l2().weight_iso = getattr(the_3lep_cand.l2(),
'weight_%s_iso' % final_state,
1.)
the_3lep_cand.l2().weight_reco = getattr(
the_3lep_cand.l2(), 'weight_%s_reco' % final_state, 1.)
the_3lep_cand.l2().weight_idiso = getattr(
the_3lep_cand.l2(), 'weight_%s_idiso' % final_state, 1.)
the_3lep_cand.l2().weight_trigger = getattr(
the_3lep_cand.l2(), 'weight_%s_trigger' % final_state, 1.)
the_3lep_cand.l2().weight_tracking = getattr(
the_3lep_cand.l2(), 'weight_%s_tracking' % final_state, 1.)
# event variables
self.fillEvent(self.tree, event)
self.fill(self.tree, 'n_cands', len(dileptonsvtx))
# these are PRESELECTED leptons according to the preselection given via cfg
# reco HNL
self.fillHNL(self.tree, 'hnl', the_3lep_cand)
if self.cfg_ana.L1L2LeptonType == 'mm':
self.fillMuon(self.tree, 'l1', the_3lep_cand.l1())
self.fillMuon(self.tree, 'l2', the_3lep_cand.l2())
if self.cfg_ana.L1L2LeptonType == 'ee':
self.fillEle(self.tree, 'l1', the_3lep_cand.l1())
self.fillEle(self.tree, 'l2', the_3lep_cand.l2())
if self.cfg_ana.L1L2LeptonType == 'em':
self.fillEle(self.tree, 'l1', the_3lep_cand.l1())
self.fillMuon(self.tree, 'l2', the_3lep_cand.l2())
if self.cfg_ana.promptLepType == 'e':
self.fillEle(self.tree, 'l0', the_3lep_cand.l0())
if self.cfg_ana.promptLepType == 'm':
self.fillMuon(self.tree, 'l0', the_3lep_cand.l0())
# output of MC analysis ONLY FOR SIGNAL
if hasattr(event, 'the_hnl'):
self.fillHNL(self.tree, 'hnl_gen', event.the_hnl)
self.fillParticle(self.tree, 'l0_gen', event.the_hnl.l0())
self.fillParticle(self.tree, 'l1_gen', event.the_hnl.l1())
self.fillParticle(self.tree, 'l2_gen', event.the_hnl.l2())
self.fillParticle(self.tree, 'n_gen', event.the_hnl.met())
# reco primary vertex
pv = event.goodVertices[0]
self.fill(self.tree, 'pv_x', pv.x())
self.fill(self.tree, 'pv_y', pv.y())
self.fill(self.tree, 'pv_z', pv.z())
self.fill(self.tree, 'pv_xe', pv.xError())
self.fill(self.tree, 'pv_ye', pv.yError())
self.fill(self.tree, 'pv_ze', pv.zError())
# true primary vertex
if hasattr(event, 'the_hnl'):
self.fill(self.tree, 'pv_gen_x', event.the_hn.vx())
self.fill(self.tree, 'pv_gen_y', event.the_hn.vy())
self.fill(self.tree, 'pv_gen_z', event.the_hn.vz())
# beamspot
self.fill(self.tree, 'bs_x', event.beamspot.x0())
self.fill(self.tree, 'bs_y', event.beamspot.y0())
self.fill(self.tree, 'bs_z', event.beamspot.z0())
self.fill(self.tree, 'bs_sigma_x', event.beamspot.BeamWidthX())
self.fill(self.tree, 'bs_sigma_y', event.beamspot.BeamWidthY())
self.fill(self.tree, 'bs_sigma_z', event.beamspot.sigmaZ())
self.fill(self.tree, 'bs_dxdz', event.beamspot.dxdz())
self.fill(self.tree, 'bs_dydz', event.beamspot.dydz())
# true HN decay vertex
if hasattr(event, 'the_hn'):
self.fill(self.tree, 'sv_gen_x',
event.the_hn.lep1.vertex().x()
) # don't use the final lepton to get the vertex from!
self.fill(self.tree, 'sv_gen_y',
event.the_hn.lep1.vertex().y()
) # don't use the final lepton to get the vertex from!
self.fill(self.tree, 'sv_gen_z',
event.the_hn.lep1.vertex().z()
) # don't use the final lepton to get the vertex from!
# displacements
self.fill(self.tree, 'hnl_2d_gen_disp',
displacement2D(event.the_hn.lep1, event.the_hn))
self.fill(self.tree, 'hnl_3d_gen_disp',
displacement3D(event.the_hn.lep1, event.the_hn))
# HLT bits & matches
trig_list = [trig.name for trig in event.trigger_infos if trig.fired]
if self.cfg_ana.promptLepType == 'e':
self.fill(
self.tree, 'hlt_Ele25_eta2p1_WPTight_Gsf',
any('HLT_Ele25_eta2p1_WPTight_Gsf' in name
for name in trig_list))
self.fill(
self.tree, 'hlt_Ele27_WPTight_Gsf',
any('HLT_Ele27_WPTight_Gsf' in name for name in trig_list))
self.fill(
self.tree, 'hlt_Ele32_WPTight_Gsf',
any('HLT_Ele32_WPTight_Gsf' in name for name in trig_list))
self.fill(
self.tree, 'hlt_Ele35_WPTight_Gsf',
any('HLT_Ele35_WPTight_Gsf' in name for name in trig_list))
self.fill(
self.tree, 'hlt_Ele115_CaloIdVT_GsfTrkIdT',
any('HLT_Ele115_CaloIdVT_GsfTrkIdT' in name
for name in trig_list))
self.fill(
self.tree, 'hlt_Ele135_CaloIdVT_GsfTrkIdT',
any('HLT_Ele135_CaloIdVT_GsfTrkIdT' in name
for name in trig_list))
if self.cfg_ana.promptLepType == 'm':
self.fill(self.tree, 'hlt_IsoMu22',
any('HLT_IsoMu22' in name for name in trig_list))
self.fill(self.tree, 'hlt_IsoTkMu22',
any('HLT_IsoTkMu22' in name for name in trig_list))
self.fill(self.tree, 'hlt_IsoMu22_eta2p1',
any('HLT_IsoMu22_eta2p1' in name for name in trig_list))
self.fill(
self.tree, 'hlt_IsoTkMu22_eta2p1',
any('HLT_IsoTkMu22_eta2p1' in name for name in trig_list))
self.fill(self.tree, 'hlt_IsoMu24',
any('HLT_IsoMu24' in name for name in trig_list))
self.fill(self.tree, 'hlt_IsoTkMu24',
any('HLT_IsoTkMu24' in name for name in trig_list))
self.fill(self.tree, 'hlt_IsoMu27',
any('HLT_IsoMu27' in name for name in trig_list))
self.fill(self.tree, 'hlt_IsoTkMu27',
any('HLT_IsoTkMu27' in name for name in trig_list))
self.fill(self.tree, 'hlt_Mu50',
any('HLT_Mu50' in name for name in trig_list))
self.fill(self.tree, 'hlt_TkMu50',
any('HLT_TkMu50' in name for name in trig_list))
# reco secondary vertex and displacement
self.fillVertex(self.tree, 'sv', recoSv)
self.fill(self.tree, 'hnl_2d_disp',
recoSv.disp2DFromBS.value()) # from beamspot
self.fill(self.tree, 'hnl_3d_disp',
recoSv.disp3DFromBS.value()) # from PV
self.fill(self.tree, 'hnl_2d_disp_sig',
recoSv.disp2DFromBS_sig) # from beamspot
self.fill(self.tree, 'hnl_3d_disp_sig',
recoSv.disp3DFromBS_sig) # from PV
# jet/met variables
self.fillExtraMetInfo(self.tree, event)
# met filter flags
self.fill(self.tree, 'pass_met_filters', event.pass_met_filters)
if len(cleanJets) > 0:
self.fillJet(self.tree, 'j1', cleanJets[0], fill_extra=False)
if len(cleanJets) > 1:
self.fillJet(self.tree, 'j2', cleanJets[1], fill_extra=False)
if len(cleanBJets) > 0:
self.fillJet(self.tree, 'bj1', cleanBJets[0], fill_extra=False)
if len(cleanBJets) > 1:
self.fillJet(self.tree, 'bj2', cleanBJets[1], fill_extra=False)
self.fill(self.tree, 'nj', len(cleanJets))
self.fill(self.tree, 'nj30', len(cleanJets30))
self.fill(self.tree, 'nbj', len(cleanBJets))
# FIXME! RM what is this?
# gen match
if self.cfg_comp.isMC == True and hasattr(event, 'genParticles'):
stable_genp = [
pp for pp in event.genParticles if pp.status() == 1
] # and pp.vertex().z()!=0)]
stable_genp += [
pp for pp in event.genp_packed if pp.status() == 1
] # and pp.vertex().z()!=0)]
# particle status: http://home.thep.lu.se/~torbjorn/pythia81html/ParticleProperties.html
# 1 ... stable; 23 ... from hardest scattering subprocess
# stable_genp += [pp for pp in event.genParticles if (pp.status()==23 and pp.vertex().z()!=0)]
# stable_genp += [pp for pp in event.genp_packed if (pp.status()==23 and pp.vertex().z()!=0)]
tomatch = [(the_3lep_cand.l0(), 0.05 * 0.05),
(the_3lep_cand.l1(), 0.2 * 0.2),
(the_3lep_cand.l2(), 0.2 * 0.2)]
for ilep, idr2 in tomatch:
bestmatch, dr2 = bestMatch(ilep, stable_genp)
if (dr2 < idr2 and abs(
(ilep.pt() - bestmatch.pt()) / ilep.pt()) < 0.2):
ilep.bestmatch = bestmatch
# relevant for mc: check if reco matched with gen, save a float
if hasattr(the_3lep_cand.l0(), 'bestmatch'):
LEP0 = the_3lep_cand.l0()
self.fillSimpleGenParticle(self.tree, 'l0_gen_match',
LEP0.bestmatch)
self.fill(self.tree, 'l0_good_match',
deltaR(LEP0.bestmatch, LEP0))
# if deltaR(LEP0.bestmatch, LEP0) < 0.04 and LEP0.pdgId() == LEP0.bestmatch.pdgId():
# self.fill(self.tree, 'l0_good_match', 1)
if hasattr(the_3lep_cand.l1(), 'bestmatch'):
LEP1 = the_3lep_cand.l1()
self.fillSimpleGenParticle(self.tree, 'l1_gen_match',
LEP1.bestmatch)
self.fill(self.tree, 'l1_good_match',
deltaR(LEP1.bestmatch, LEP1))
# if deltaR(LEP1.bestmatch, LEP1) < 0.04 and LEP1.pdgId() == LEP1.bestmatch.pdgId():
# self.fill(self.tree, 'l1_good_match', 1)
if hasattr(the_3lep_cand.l2(), 'bestmatch'):
LEP2 = the_3lep_cand.l2()
self.fillSimpleGenParticle(self.tree, 'l2_gen_match',
LEP2.bestmatch)
self.fill(self.tree, 'l2_good_match',
deltaR(LEP2.bestmatch, LEP2))
# if deltaR(LEP2.bestmatch, LEP2) < 0.04 and LEP2.pdgId() == LEP2.bestmatch.pdgId():
# self.fill(self.tree, 'l2_good_match', 1)
# matching by pointer does not work, so let's trick it with deltaR
if hasattr(event, 'the_hnl'):
if hasattr(the_3lep_cand.l0(), 'bestmatch'):
self.fill(
self.tree, 'l0_is_real',
deltaR(the_3lep_cand.l0().bestmatch,
event.the_hnl.l0()) < 0.01)
if hasattr(the_3lep_cand.l1(), 'bestmatch'):
self.fill(
self.tree, 'l1_is_real',
deltaR(the_3lep_cand.l1().bestmatch,
event.the_hnl.l1()) < 0.05)
if hasattr(the_3lep_cand.l2(), 'bestmatch'):
self.fill(
self.tree, 'l2_is_real',
deltaR(the_3lep_cand.l2().bestmatch,
event.the_hnl.l2()) < 0.05)
# print('event:', event.eventId, 'lumi:', event.lumi)
# extra lepton veto
self.fill(self.tree, 'pass_e_veto', len(event.veto_eles) == 0)
self.fill(self.tree, 'pass_m_veto', len(event.veto_mus) == 0)
# LHE weight
self.fill(self.tree, 'lhe_weight',
np.sign(getattr(event, 'LHE_originalWeight', 1.)))
# weights for ctau reweighing (only for signal!)
if 'HN3L' in self.cfg_comp.name:
for iv2 in new_v2s:
# 'stringify' the coupling
# reduce precision to avoid nasty numbers e.g. 6.000000000000001e-05
iv2_name = np.format_float_scientific(iv2,
unique=False,
precision=1,
exp_digits=2)
iv2_name = iv2_name.replace('-', 'm')
self.fill(self.tree, 'ctau_w_v2_%s' % iv2_name,
event.ctau_weights[iv2]['ctau_weight'])
self.fill(self.tree, 'xs_w_v2_%s' % iv2_name,
event.ctau_weights[iv2]['xs_weight'])
if event.the_gen_w is not None:
self.fillParticle(self.tree, 'w_gen', event.the_gen_w)
self.fill(self.tree, 'pass_mmm', getattr(event, 'pass_mmm', -1.))
self.fill(self.tree, 'pass_mem', getattr(event, 'pass_mem', -1.))
self.fill(self.tree, 'pass_eee', getattr(event, 'pass_eee', -1.))
self.fill(self.tree, 'pass_eem', getattr(event, 'pass_eem', -1.))
# import pdb ; pdb.set_trace()
if fill:
self.fillTree(event)