def process(self, iEvent, event):
#if event.eventId in notPassed :
# print 'WEIRD!! I have this event'
# import pdb ; pdb.set_trace()
scale=1.0
def fill( varName, value ):
setattr( self.tree.s, varName, value )
def fParticleVars( pName, particle ):
fill('{pName}Px'.format(pName=pName) , particle.px()*scale )
fill('{pName}Py'.format(pName=pName) , particle.py()*scale )
fill('{pName}Pz'.format(pName=pName) , particle.pz()*scale )
fill('{pName}E'.format(pName=pName) , particle.energy()*scale )
fill('{pName}Pt'.format(pName=pName) , particle.pt()*scale )
fill('{pName}Eta'.format(pName=pName) , particle.eta() )
fill('{pName}Phi'.format(pName=pName) , particle.phi() )
fill('{pName}Charge'.format(pName=pName) , particle.charge() )
fill('{pName}Mass'.format(pName=pName) , particle.mass()*scale )
if not ('diTau' in pName or 'jet' in pName or 'L1' in pName):
fill('{pName}DecayMode'.format(pName=pName) , particle.decayMode() )
fill('{pName}RawDB3HIso'.format(pName=pName) , particle.tauID("byCombinedIsolationDeltaBetaCorrRaw3Hits") )
fill('{pName}LooseDB3HIso'.format(pName=pName) , particle.tauID("byLooseCombinedIsolationDeltaBetaCorr3Hits") )
fill('{pName}MediumDB3HIso'.format(pName=pName) , particle.tauID("byMediumCombinedIsolationDeltaBetaCorr3Hits"))
fill('{pName}TightDB3HIso'.format(pName=pName) , particle.tauID("byTightCombinedIsolationDeltaBetaCorr3Hits") )
fill('{pName}LooseEle'.format(pName=pName) , particle.tauID("againstElectronLoose") )
fill('{pName}MedEle'.format(pName=pName) , particle.tauID("againstElectronMedium") )
fill('{pName}MVAEle'.format(pName=pName) , particle.tauID("againstElectronMVA") )
fill('{pName}LooseMu'.format(pName=pName) , particle.tauID("againstMuonLoose") )
fill('{pName}jetMass'.format(pName=pName) , particle.jetRefp4().mass() )
fill('{pName}jetPt'.format(pName=pName) , particle.jetRefp4().pt() )
fill('{pName}againstElectronMVA3raw'.format(pName=pName) , particle.tauID("againstElectronMVA3raw") )
fill('{pName}againstElectronLooseMVA3'.format(pName=pName) , particle.tauID("againstElectronLooseMVA3") )
fill('{pName}againstElectronMediumMVA3'.format(pName=pName) , particle.tauID("againstElectronMediumMVA3") )
fill('{pName}againstElectronTightMVA3'.format(pName=pName) , particle.tauID("againstElectronTightMVA3") )
fill('{pName}againstElectronVTightMVA3'.format(pName=pName) , particle.tauID("againstElectronVTightMVA3") )
fill('{pName}againstElectronMVA3category'.format(pName=pName), particle.tauID("againstElectronMVA3category") )
fill('{pName}againstElectronNewLooseMVA3'.format(pName=pName), particle.NewLooseAntiEleMVA3 )
fill('{pName}againstMuonLoose2'.format(pName=pName) , particle.tauID("againstMuonLoose2") )
fill('{pName}againstMuonMedium2'.format(pName=pName) , particle.tauID("againstMuonMedium2") )
fill('{pName}againstMuonTight2'.format(pName=pName) , particle.tauID("againstMuonTight2") )
fill('{pName}VertexZ'.format(pName=pName) , particle.tau.vz() )
if hasattr(event,"run"):
fill('run', event.run)
if hasattr(event,"lumi"):
fill('lumi', event.lumi)
if hasattr(event,"eventId"):
fill('event', event.eventId)
if hasattr(event,"isRealTau"):
fill('isRealTau', event.isRealTau)
fill('visMass' , event.diLepton.mass()*scale)
fill('svfitMass', event.diLepton.massSVFit()*scale)
### import pdb ; pdb.set_trace() ## SVFit pT is missingin tautau cmgtuples
### need to hack http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/UserCode/CMG/CMGTools/H2TauTau/interface/DiTauWithSVFitProducer.h?revision=1.11&view=markup
#fill('svfitPt' , event.diLepton.massSVFit()*scale)
fill('pThiggs' , sqrt(pow(event.diLepton.met().px()+event.diLepton.leg1().px()+event.diLepton.leg2().px(),2)+pow(event.diLepton.met().py()+event.diLepton.leg1().py()+event.diLepton.leg2().py(),2))*scale)
#mvametsig = event.diLepton.mvaMetSig.significance()
fill('mvacov00', event.diLepton.metSig().significance()(0,0))
fill('mvacov01', event.diLepton.metSig().significance()(0,1))
fill('mvacov10', event.diLepton.metSig().significance()(1,0))
fill('mvacov11', event.diLepton.metSig().significance()(1,1))
fill('metPhi' , event.diLepton.met().phi()*scale)
fill('mex' , event.diLepton.met().px()*scale)
fill('mey' , event.diLepton.met().py()*scale)
fill('met' , event.diLepton.met().pt()*scale)
fill('rawMET' , event.rawMET[0].pt())
fill('dRtt' , sqrt(pow(deltaPhi(event.diLepton.leg1().phi(),event.diLepton.leg2().phi()),2)+pow(fabs(event.diLepton.leg1().eta()-event.diLepton.leg2().eta()),2)))
fill('dPhitt' , deltaPhi(event.diLepton.leg1().phi(),event.diLepton.leg2().phi()))
fill('dEtatt' , fabs(event.diLepton.leg1().eta()-event.diLepton.leg2().eta()))
if hasattr(event.leg1,"L1particle") and hasattr(event.leg2,"L1particle") :
fill('dRttL1' , sqrt(pow(deltaPhi(event.leg1.L1particle.phi(),event.leg2.L1particle.phi()),2)+pow(fabs(event.leg1.L1particle.eta()-event.leg2.L1particle.eta()),2)))
fill('l1L1Px' , event.leg1.L1particle.px() )
fill('l1L1Py' , event.leg1.L1particle.py() )
fill('l1L1Pz' , event.leg1.L1particle.pz() )
fill('l1L1E' , event.leg1.L1particle.energy())
fill('l1L1Pt' , event.leg1.L1particle.pt() )
fill('l1L1Eta' , event.leg1.L1particle.eta() )
fill('l1L1Phi' , event.leg1.L1particle.phi() )
fill('l1L1Charge', event.leg1.L1particle.charge())
fill('l1L1Mass' , event.leg1.L1particle.mass() )
fill('l2L1Px' , event.leg2.L1particle.px() )
fill('l2L1Py' , event.leg2.L1particle.py() )
fill('l2L1Pz' , event.leg2.L1particle.pz() )
fill('l2L1E' , event.leg2.L1particle.energy())
fill('l2L1Pt' , event.leg2.L1particle.pt() )
fill('l2L1Eta' , event.leg2.L1particle.eta() )
fill('l2L1Phi' , event.leg2.L1particle.phi() )
fill('l2L1Charge', event.leg2.L1particle.charge())
fill('l2L1Mass' , event.leg2.L1particle.mass() )
#fParticleVars('l1L1', event.leg1.L1particle)
#fParticleVars('l2L1', event.leg2.L1particle)
### taus pt hierarchy can be swapped after TauES correction
if event.diLepton.leg1().pt() >= event.diLepton.leg2().pt() :
leg1 = event.diLepton.leg1()
leg2 = event.diLepton.leg2()
fill('mt1', event.diLepton.mTLeg1()*scale)
fill('mt2', event.diLepton.mTLeg2()*scale)
elif event.diLepton.leg1().pt() < event.diLepton.leg2().pt() :
leg2 = event.diLepton.leg1()
leg1 = event.diLepton.leg2()
fill('mt2', event.diLepton.mTLeg1()*scale)
fill('mt1', event.diLepton.mTLeg2()*scale)
## tau1 radius
eta = []
phi = []
for sigCand in event.diLepton.leg1().physObj.signalPFCands() :
eta.append(sigCand.eta())
phi.append(sigCand.phi())
dR = 0.
for i in range(len(eta)) :
if deltaR(leg1.eta(), leg1.phi(), eta[i], phi[i]) > dR :
dR = deltaR(leg1.eta(), leg1.phi(), eta[i], phi[i])
fill('l1Radius', dR)
## tau2 radius
eta = []
phi = []
for sigCand in event.diLepton.leg2().physObj.signalPFCands() :
eta.append(sigCand.eta())
phi.append(sigCand.phi())
dR = 0.
for i in range(len(eta)) :
if deltaR(leg2.eta(), leg2.phi(), eta[i], phi[i]) > dR :
dR = deltaR(leg2.eta(), leg2.phi(), eta[i], phi[i])
fill('l2Radius', dR)
fParticleVars('l1', leg1 )
fParticleVars('l2', leg2 )
l1jet = bestMatch( leg1, event.jets )[0]
l2jet = bestMatch( leg2, event.jets )[0]
if l1jet:
fill('l1jetWidth', l1jet.rms() )
fill('l1jetBtag' , l1jet.btag("combinedSecondaryVertexBJetTags") )
if l2jet:
fill('l2jetWidth', l2jet.rms() )
fill('l2jetBtag' , l1jet.btag("combinedSecondaryVertexBJetTags") )
if hasattr(event,"leg1DeltaR"):
fill('l1match', event.leg1DeltaR )
fill('l2match', event.leg2DeltaR )
else:
fill('l1match', -1 )
fill('l2match', -1 )
if hasattr(event,"genMass"):
fill('genMass', event.genMass )
# from ROOT import TFile,TH1F
# f = TFile("/afs/cern.ch/user/h/hinzmann/workspace/stable2012/CMGTools/CMSSW_5_2_5/src/CMGTools/H2TauTau/python/proto/embeddedWeights.root")
# hEmbed = f.Get("hemb")
# shift=hEmbed.GetRandom()/event.genMass
# fill('genMassSmeared', event.genMass*shift )
# fill('svfitMassSmeared', event.diLepton.massSVFit()*scale*shift )
else:
fill('genMass' , -1 )
fill('genMassSmeared' , -1 )
fill('svfitMassSmeared', -1 )
# trigger matching for diTau trigger present in parked dataset
if hasattr(event,"l1TrigMatched_diTau") and hasattr(event,"l2TrigMatched_diTau") :
fill( 'l1TrigMatched_diTau' , event.l1TrigMatched_diTau )
fill( 'l2TrigMatched_diTau' , event.l2TrigMatched_diTau )
else:
fill( 'l1TrigMatched_diTau' , -1)
fill( 'l2TrigMatched_diTau' , -1)
# trigger matching for diTauJet trigger
if hasattr(event,"l1TrigMatched_diTauJet") and hasattr(event,"l2TrigMatched_diTauJet") and hasattr(event,"jetTrigMatched_diTauJet"):
fill( 'l1TrigMatched_diTauJet' , event.l1TrigMatched_diTauJet )
fill( 'l2TrigMatched_diTauJet' , event.l2TrigMatched_diTauJet )
fill( 'jetTrigMatched_diTauJet', event.jetTrigMatched_diTauJet)
else:
fill( 'l1TrigMatched_diTauJet' , -1)
fill( 'l2TrigMatched_diTauJet' , -1)
fill( 'jetTrigMatched_diTauJet', -1)
if hasattr(event,"triggerWeight_diTauJet") and hasattr(event,"triggerEffMC_diTauJet") and hasattr(event,"triggerEffData_diTauJet"):
fill( 'triggerWeight_diTauJet' ,event.triggerWeight_diTauJet )
fill( 'triggerEffMC_diTauJet' ,event.triggerEffMC_diTauJet )
fill( 'triggerEffData_diTauJet',event.triggerEffData_diTauJet)
else :
fill( 'triggerWeight_diTauJet' ,1)
fill( 'triggerEffMC_diTauJet' ,1)
fill( 'triggerEffData_diTauJet',1)
if hasattr(event,"triggerWeight_diTau") and hasattr(event,"triggerEffMC_diTau") and hasattr(event,"triggerEffData_diTau"):
fill( 'triggerWeight_diTau' ,event.triggerWeight_diTau )
fill( 'triggerEffMC_diTau' ,event.triggerEffMC_diTau )
fill( 'triggerEffData_diTau',event.triggerEffData_diTau)
else :
fill( 'triggerWeight_diTau' ,1)
fill( 'triggerEffMC_diTau' ,1)
fill( 'triggerEffData_diTau',1)
nJets = len(event.cleanJets)
fill('nJets', nJets )
if nJets>=1:
fParticleVars('jet1', event.cleanJets[0] )
fill('jet1Btag' , event.cleanJets[0].btag("combinedSecondaryVertexBJetTags") )
fill('jet1Bmatch' , event.cleanJets[0].matchGenParton )
fill('mttj' , sqrt(pow(event.diLepton.energy()+event.cleanJets[0].energy(),2) - pow(event.diLepton.px()+event.cleanJets[0].px(),2) - pow(event.diLepton.py()+event.cleanJets[0].py(),2) - pow(event.diLepton.pz()+event.cleanJets[0].pz(),2)))
fill('l1JetInvMass' , sqrt(pow(leg1.energy()+event.cleanJets[0].energy(),2) - pow(leg1.px()+event.cleanJets[0].px(),2) - pow(leg1.py()+event.cleanJets[0].py(),2) - pow(leg1.pz()+event.cleanJets[0].pz(),2)))
fill('l2JetInvMass' , sqrt(pow(leg2.energy()+event.cleanJets[0].energy(),2) - pow(leg2.px()+event.cleanJets[0].px(),2) - pow(leg2.py()+event.cleanJets[0].py(),2) - pow(leg2.pz()+event.cleanJets[0].pz(),2)))
if nJets>=2:
fParticleVars('jet2', event.cleanJets[1] )
fill('jet2Btag' , event.cleanJets[1].btag("combinedSecondaryVertexBJetTags") )
fill('jet2Bmatch' , event.cleanJets[1].matchGenParton )
fill('mjj' , event.vbf.mjj)
fill('dEtajj' , event.vbf.deta)
fill('dPhijj' , deltaPhi(event.cleanJets[0].phi(), event.cleanJets[1].phi()))
fill('dEtattjj' , fabs(event.cleanJets[0].eta()+event.cleanJets[1].eta()-event.diLepton.eta()))
fill('dPhittjj' , deltaPhi(event.cleanJets[0].phi()+event.cleanJets[1].phi(),event.diLepton.phi()))
fill('nCentralJets' , len(event.vbf.centralJets))
fill('vbfMVA' , event.vbf.mva)
## Riccardo
sumJetPt = 0.
for j in range(nJets) :
sumJetPt += event.cleanJets[j].pt()
fill('allJetPt', event.cleanJets[j].pt())
if nJets == 0 : sumJetPt = -99.
fill('sumJetPt', sumJetPt)
nbJets = len(event.cleanBJets)
fill('nbJets', nbJets )
if nbJets>=1:
fParticleVars('bjet1', event.cleanBJets[0] )
if nbJets>=2:
fParticleVars('bjet2', event.cleanBJets[1] )
## Riccardo
sumbJetPt = 0.
for j in range(nbJets) :
sumbJetPt += event.cleanBJets[j].pt()
fill('allbJetPt', event.cleanBJets[j].pt())
if nbJets == 0 : sumbJetPt = -99.
fill('sumbJetPt', sumbJetPt)
fill('weight', event.eventWeight)
if hasattr( event, 'vertexWeight'):
fill('vertexWeight', event.vertexWeight )
fill('nVert' , len(event.vertices) )
if hasattr( event, 'embedWeight'):
fill('embedWeight', event.embedWeight)
if hasattr( event, 'triggerWeight'):
fill('triggerWeight', event.triggerWeight)
if hasattr( event, 'triggerEffData'):
fill('triggerEffData', event.triggerEffData)
if hasattr( event, 'triggerEffMC'):
fill('triggerEffMC', event.triggerEffMC)
isFake = 1
if hasattr( event, 'genMatched'):
if event.genMatched == 1:
isFake = 0
fill('isFake', isFake)
if hasattr( event, 'isZtt') and hasattr( event, 'isZee') and hasattr( event, 'isZmm') and hasattr( event, 'isZj') and hasattr( event, 'isZttll') and hasattr( event, 'isZttj') :
fill('isZtt' , event.isZtt )
fill('isZee' , event.isZee )
fill('isZmm' , event.isZmm )
fill('isZj' , event.isZj )
fill('isZttll', event.isZttll )
fill('isZttj' , event.isZttj )
else :
fill('isZtt' , -1 )
fill('isZee' , -1 )
fill('isZmm' , -1 )
fill('isZj' , -1 )
fill('isZttll', -1 )
fill('isZttj' , -1 )
genMatched = 0
if hasattr(event,'genMatched') and event.genMatched > 0: genMatched = event.genMatched
fill('genMatched', genMatched)
isPhoton = 0
if hasattr(event,'isPhoton') and event.isPhoton == 1: isPhoton = 1
fill('isPhoton', isPhoton)
isElectron = 0
if hasattr(event,'isElectron') and event.isElectron > 0: isElectron = event.isElectron
fill('isElectron', isElectron)
isMuon = 0
if hasattr(event,'isMuon') and event.isMuon > 0: isMuon = event.isMuon
fill('isMuon', isMuon)
hasW = 0
if hasattr(event,'hasW') and event.hasW == 1: hasW = 1
fill('hasW', hasW)
hasZ = 0
if hasattr(event,'hasZ') and event.hasZ == 1: hasZ = 1
fill('hasZ', hasZ)
if hasattr(leg1,'genl') :
fill('l1GenPdgId', leg1.genl.pdgId())
fill('l1GenPt' , leg1.genl.pt() )
fill('l1GenEta' , leg1.genl.eta() )
fill('l1GenPhi' , leg1.genl.phi() )
fill('l1GenMass' , leg1.genl.mass() )
else :
fill('l1GenPt' , -1. )
fill('l1GenEta' , -99.)
fill('l1GenPhi' , -99.)
fill('l1GenMass', -1. )
if hasattr(leg2,'genl') :
fill('l2GenPdgId', leg2.genl.pdgId())
fill('l2GenPt' , leg2.genl.pt() )
fill('l2GenEta' , leg2.genl.eta() )
fill('l2GenPhi' , leg2.genl.phi() )
fill('l2GenMass' , leg2.genl.mass())
else :
fill('l2GenPt' , -1. )
fill('l2GenEta' , -99.)
fill('l2GenPhi' , -99.)
fill('l2GenMass', -1. )
if len(event.muons)>0:
fill('muon1Pt' , event.muons[0].pt() )
fill('muon1Eta', event.muons[0].eta() )
fill('muon1Phi', event.muons[0].phi() )
else:
fill('muon1Pt' , -1 )
fill('muon1Eta', -1 )
fill('muon1Phi', -1 )
if len(event.electrons)>0:
fill('electron1Pt' , event.electrons[0].pt() )
fill('electron1Eta', event.electrons[0].eta() )
fill('electron1Phi', event.electrons[0].phi() )
else:
fill('electron1Pt' , -1 )
fill('electron1Eta', -1 )
fill('electron1Phi', -1 )
fill('higgsPtWeightNom' ,event.higgsPtWeightNom )
fill('higgsPtWeightUp' ,event.higgsPtWeightUp )
fill('higgsPtWeightDown',event.higgsPtWeightDown)
####### EMBEDDED WEIGHTS
fill( 'genfilter' , event.genfilter )
fill( 'tauspin' , event.tauspin )
fill( 'zmumusel' , event.zmumusel )
fill( 'muradcorr' , event.muradcorr )
fill( 'genTau2PtVsGenTau1Pt' , event.genTau2PtVsGenTau1Pt )
fill( 'genTau2EtaVsGenTau1Eta' , event.genTau2EtaVsGenTau1Eta )
fill( 'genDiTauMassVsGenDiTauPt', event.genDiTauMassVsGenDiTauPt )
fill('NUP', event.NUP )
for trig in self.triggers:
fill(trig, getattr(event,trig))
self.tree.fill()
def match(jet, objects, name):
bm, dr2 = bestMatch(jet, objects)
if bm:
bm.dr = math.sqrt(dr2)
setattr(jet, name, bm)
def makeLeptons(self, event):
event.looseLeptons = []
event.selectedLeptons = []
event.inclusiveLeptons = []
#muons
allmuons = map( Muon, self.handles['muons'].product() )
if self.cfg_ana.doRecomputeSIP3D:
for mu in allmuons:
if mu.sourcePtr().innerTrack().isNonnull():
## compute the variable and set it
mu._sip3d = abs(signedSip3D(mu, event.goodVertices[0]))
## attach it to the object redefining the sip3D() method
mu.sip3D = types.MethodType(lambda self : self._sip3d, mu, mu.__class__)
if self.cfg_ana.doMuScleFitCorrections:
for mu in allmuons:
self.muscleCorr.correct(mu, event.run)
elif self.cfg_ana.doRochesterCorrections:
for mu in allmuons:
corp4 = rochcor.corrected_p4(mu, event.run)
mu.setP4( corp4 )
if self.cfg_ana.doSegmentBasedMuonCleaning:
isgood = cmgMuonCleanerBySegments.clean( self.handles['muons'].product() )
newmu = []
for i,mu in enumerate(allmuons):
if isgood[i]: newmu.append(mu)
allmuons = newmu
for mu in allmuons:
mu.associatedVertex = event.goodVertices[0]
mu.relIso03= (mu.sourcePtr().pfIsolationR03().sumChargedHadronPt + max( mu.sourcePtr().pfIsolationR03().sumNeutralHadronEt + mu.sourcePtr().pfIsolationR03().sumPhotonEt - mu.sourcePtr().pfIsolationR03().sumPUPt/2,0.0))/mu.pt()
mu.looseFakeId = ((mu.isGlobal() or mu.isTracker() and mu.numberOfMatches()>0) and mu.sourcePtr().userFloat("isPFMuon")>0.5 and mu.pt()>10 and abs(mu.eta())<2.4 and mu.tightId()>0.5 and abs(mu.dxy())<0.2 and abs(mu.dz())<0.2 and mu.relIso03<1.0)
mu.tightFakeId = ((mu.isGlobal() or mu.isTracker() and mu.numberOfMatches()>0) and mu.sourcePtr().userFloat("isPFMuon")>0.5 and mu.pt()>10 and abs(mu.eta())<2.4 and mu.tightId()>0.5 and abs(mu.dxy())<0.01 and abs(mu.dz())<0.2 and mu.relIso03<0.1)
if mu.pt()>5 and abs(mu.eta())<2.4:
if mu.looseFakeId:
event.inclusiveLeptons.append(mu)
event.selectedLeptons.append(mu)
#electrons
allelectrons = map( Electron, self.handles['electrons'].product() )
## duplicate removal for fast sim (to be checked if still necessary in 5_3_12+)
allelenodup = []
for e in allelectrons:
dup = False
for e2 in allelenodup:
if abs(e.pt()-e2.pt()) < 1e-6 and abs(e.eta()-e2.eta()) < 1e-6 and abs(e.phi()-e2.phi()) < 1e-6 and e.charge() == e2.charge():
dup = True
break
if not dup: allelenodup.append(e)
allelectrons = allelenodup
if self.cfg_ana.doRecomputeSIP3D:
for ele in allelectrons:
if ele.sourcePtr().gsfTrack().isNonnull():
## compute the variable and set it
ele._sip3d = abs(signedSip3D(ele, event.goodVertices[0]))
## attach it to the object redefining the sip3D() method
ele.sip3D = types.MethodType(lambda self : self._sip3d, ele, ele.__class__)
# fill EA for rho-corrected isolation
for ele in allelectrons:
ele.rho = float(self.handles['rhoEle'].product()[0])
SCEta = abs(ele.sourcePtr().superCluster().eta())
if (abs(SCEta) >= 0.0 and abs(SCEta) < 1.0 ) : ele.EffectiveArea = 0.13 # 0.130;
if (abs(SCEta) >= 1.0 and abs(SCEta) < 1.479 ) : ele.EffectiveArea = 0.14 # 0.137;
if (abs(SCEta) >= 1.479 and abs(SCEta) < 2.0 ) : ele.EffectiveArea = 0.07 # 0.067;
if (abs(SCEta) >= 2.0 and abs(SCEta) < 2.2 ) : ele.EffectiveArea = 0.09 # 0.089;
if (abs(SCEta) >= 2.2 and abs(SCEta) < 2.3 ) : ele.EffectiveArea = 0.11 # 0.107;
if (abs(SCEta) >= 2.3 and abs(SCEta) < 2.4 ) : ele.EffectiveArea = 0.11 # 0.110;
if (abs(SCEta) >= 2.4) : ele.EffectiveArea = 0.14 # 0.138;
if self.cfg_ana.doElectronScaleCorrections:
for ele in allelectrons:
self.electronEnergyCalibrator.correct(ele, event.run)
muForEleCrossCleaning = []
if self.cfg_ana.doEleMuCrossCleaning:
for mu in event.selectedLeptons + event.looseLeptons:
if abs(mu.pdgId()) == 13 and (mu.isGlobal() or mu.sourcePtr().userFloat("isPFMuon")>0.5):
muForEleCrossCleaning.append(mu)
for ele in allelectrons:
ele.associatedVertex = event.goodVertices[0]
## remove muons if muForEleCrossCleaning is not empty
if bestMatch(ele, muForEleCrossCleaning)[1] < 0.02: continue
## fill POG MVA tight Id
ele.tightIdResult = False
if ele.pt()>7 and abs(ele.eta())<2.5 and abs(ele.dxy())<0.5 and abs(ele.dz())<1. and ele.numberOfHits()<=1:
## fill tightId:
if (ele.pt() > 20):
SCEta = abs(ele.sourcePtr().superCluster().eta())
if SCEta < 0.8: ele.tightIdResult = (ele.mvaTrigV0() > 0.00)
elif SCEta < 1.479: ele.tightIdResult = (ele.mvaTrigV0() > 0.10)
else: ele.tightIdResult = (ele.mvaTrigV0() > 0.62)
elif (ele.pt() > 10):
if SCEta < 0.8: ele.tightIdResult = (ele.mvaTrigV0() > 0.94)
elif SCEta < 1.479: ele.tightIdResult = (ele.mvaTrigV0() > 0.85)
else: ele.tightIdResult = (ele.mvaTrigV0() > 0.92)
# Compute isolation
ele.relIso03 = (ele.chargedHadronIso(0.3) + max(ele.neutralHadronIso(0.3)+ele.photonIso(0.3)-ele.rho*ele.EffectiveArea,0))/ele.pt()
# Compute electron id
dEtaIn = abs(ele.sourcePtr().deltaEtaSuperClusterTrackAtVtx());
dPhiIn = abs(ele.sourcePtr().deltaPhiSuperClusterTrackAtVtx());
sigmaIEtaIEta = abs(ele.sourcePtr().sigmaIetaIeta());
hoe = abs(ele.sourcePtr().hadronicOverEm());
ooemoop = abs(1.0/ele.sourcePtr().ecalEnergy() - ele.sourcePtr().eSuperClusterOverP()/ele.sourcePtr().ecalEnergy());
vtxFitConversion = ele.passConversionVeto();
mHits = ele.numberOfHits();
# Set tight and loose flags
if abs(ele.sourcePtr().superCluster().eta()) < 1.479:
ele.looseFakeId = dEtaIn < 0.004 and dPhiIn < 0.06 and sigmaIEtaIEta < 0.01 and hoe < 0.12 and ooemoop < 0.05
else:
ele.looseFakeId = dEtaIn < 0.007 and dPhiIn < 0.03 and sigmaIEtaIEta < 0.03 and hoe < 0.10 and ooemoop < 0.05
ele.looseFakeId = ele.looseFakeId and vtxFitConversion and mHits <= 1 and abs(ele.dz()) < 0.1 and ele.relIso03 < 0.6
ele.looseFakeId = ele.looseFakeId and mHits <= 1 and ele.sourcePtr().isGsfCtfScPixChargeConsistent()
ele.tightFakeId = ele.looseFakeId and abs(ele.dxy()) < 0.02 and ele.relIso03 < 0.15
#print "ele pt = %.3f eta = %.3f sceta = %.3f detaIn = %.4f dphiIn = %.4f sieie = %.4f h/e = %.4f 1/e-1/p = %.4f dxy = %.4f dz = %.4f losthits = %d conveto = %d relIso = %.4f loose id = %d tight id = %d" % ( ele.pt(),ele.eta(),ele.sourcePtr().superCluster().eta(),dEtaIn,dPhiIn,sigmaIEtaIEta,hoe,ooemoop,abs(ele.dxy()),abs(ele.dz()),mHits,vtxFitConversion,ele.relIso03, ele.looseFakeId, ele.tightFakeId)
# add to the list if needed
if ele.pt()>7 and abs(ele.eta())<2.5:
if ele.looseFakeId:
event.inclusiveLeptons.append(ele)
event.selectedLeptons.append(ele)
event.looseLeptons.sort(key = lambda l : l.pt(), reverse = True)
event.selectedLeptons.sort(key = lambda l : l.pt(), reverse = True)
event.inclusiveLeptons.sort(key = lambda l : l.pt(), reverse = True)
for lepton in event.selectedLeptons:
if hasattr(self,'efficiency'):
self.efficiency.attachToObject(lepton)
def makeLeptons(self, event):
event.looseLeptons = []
event.selectedLeptons = []
#muons
allmuons = map( Muon, self.handles['muons'].product() )
if self.cfg_ana.doRecomputeSIP3D:
for mu in allmuons:
if mu.sourcePtr().innerTrack().isNonnull():
## compute the variable and set it
mu._sip3d = abs(signedSip3D(mu, event.goodVertices[0]))
## attach it to the object redefining the sip3D() method
mu.sip3D = types.MethodType(lambda self : self._sip3d, mu, mu.__class__)
if self.cfg_ana.doRochesterCorrections:
for mu in allmuons:
corp4 = rochcor.corrected_p4(mu, event.run)
mu.setP4( corp4 )
if self.cfg_ana.doSegmentBasedMuonCleaning:
isgood = cmgMuonCleanerBySegments.clean( self.handles['muons'].product() )
newmu = []
for i,mu in enumerate(allmuons):
if isgood[i]: newmu.append(mu)
allmuons = newmu
for mu in allmuons:
mu.associatedVertex = event.goodVertices[0]
if (mu.isGlobal() or mu.isTracker() and mu.numberOfMatches()>0) and mu.pt()>5 and abs(mu.eta())<2.4 and abs(mu.dxy())<0.5 and abs(mu.dz())<1.:
if mu.sourcePtr().userFloat("isPFMuon")>0.5 and (self.relaxId or mu.sip3D()<10) and mu.relIso(dBetaFactor=0.5)<self.cfg_ana.isolationCut:
event.selectedLeptons.append(mu)
else:
event.looseLeptons.append(mu)
#electrons
allelectrons = map( Electron, self.handles['electrons'].product() )
if self.cfg_ana.doRecomputeSIP3D:
for ele in allelectrons:
if ele.sourcePtr().gsfTrack().isNonnull():
## compute the variable and set it
ele._sip3d = abs(signedSip3D(ele, event.goodVertices[0]))
## attach it to the object redefining the sip3D() method
ele.sip3D = types.MethodType(lambda self : self._sip3d, ele, ele.__class__)
for ele in allelectrons:
ele.rho = float(self.handles['rhoEle'].product()[0])
SCEta = abs(ele.sourcePtr().superCluster().eta())
if (abs(SCEta) >= 0.0 and abs(SCEta) < 1.0 ) : ele.EffectiveArea = 0.130;
if (abs(SCEta) >= 1.0 and abs(SCEta) < 1.479 ) : ele.EffectiveArea = 0.137;
if (abs(SCEta) >= 1.479 and abs(SCEta) < 2.0 ) : ele.EffectiveArea = 0.067;
if (abs(SCEta) >= 2.0 and abs(SCEta) < 2.2 ) : ele.EffectiveArea = 0.089;
if (abs(SCEta) >= 2.2 and abs(SCEta) < 2.3 ) : ele.EffectiveArea = 0.107;
if (abs(SCEta) >= 2.3 and abs(SCEta) < 2.4 ) : ele.EffectiveArea = 0.110;
if (abs(SCEta) >= 2.4) : ele.EffectiveArea = 0.138;
if self.cfg_ana.doElectronScaleCorrections:
for ele in allelectrons:
calibratedPatEle = ele.sourcePtr().get()
self.electronEnergyCalibrator.correctLite(calibratedPatEle, calibratedPatEle.r9(), event.run)
ele.setP4(calibratedPatEle.p4(calibratedPatEle.P4_COMBINATION))
muForEleCrossCleaning = []
if self.cfg_ana.doEleMuCrossCleaning:
for mu in event.selectedLeptons + event.looseLeptons:
if abs(mu.pdgId()) == 13 and (mu.isGlobal() or mu.sourcePtr().userFloat("isPFMuon")>0.5):
muForEleCrossCleaning.append(mu)
for ele in allelectrons:
ele.associatedVertex = event.goodVertices[0]
## remove muons if muForEleCrossCleaning is not empty
if bestMatch(ele, muForEleCrossCleaning)[1] < 0.02: continue
## apply selection
if ele.pt()>7 and abs(ele.eta())<2.5 and abs(ele.dxy())<0.5 and abs(ele.dz())<1. and ele.numberOfHits()<=1:
if (self.relaxId or ele.mvaIDZZ() and ele.sip3D()<10) and ele.relIso(dBetaFactor=0.5)<self.cfg_ana.isolationCut:
event.selectedLeptons.append(ele)
else:
event.looseLeptons.append(ele)
event.looseLeptons.sort(key = lambda l : l.pt(), reverse = True)
event.selectedLeptons.sort(key = lambda l : l.pt(), reverse = True)
for lepton in event.selectedLeptons:
if hasattr(self,'efficiency'):
self.efficiency.attachToObject(lepton)
def makeLeptons(self, event):
event.looseLeptons = []
event.selectedLeptons = []
event.inclusiveLeptons = []
#muons
allmuons = map( Muon, self.handles['muons'].product() )
if self.cfg_ana.doRecomputeSIP3D:
for mu in allmuons:
if mu.sourcePtr().innerTrack().isNonnull():
## compute the variable and set it
mu._sip3d = abs(signedSip3D(mu, event.goodVertices[0]))
## attach it to the object redefining the sip3D() method
mu.sip3D = types.MethodType(lambda self : self._sip3d, mu, mu.__class__)
if self.cfg_ana.doMuScleFitCorrections:
for mu in allmuons:
self.muscleCorr.correct(mu, event.run)
elif self.cfg_ana.doRochesterCorrections:
for mu in allmuons:
corp4 = rochcor.corrected_p4(mu, event.run)
mu.setP4( corp4 )
if self.cfg_ana.doSegmentBasedMuonCleaning:
isgood = cmgMuonCleanerBySegments.clean( self.handles['muons'].product() )
newmu = []
for i,mu in enumerate(allmuons):
if isgood[i]: newmu.append(mu)
allmuons = newmu
for mu in allmuons:
mu.associatedVertex = event.goodVertices[0]
if (mu.isGlobal() or mu.isTracker() and mu.numberOfMatches()>0) and mu.pt()>5 and abs(mu.eta())<2.4 and abs(mu.dxy())<0.5 and abs(mu.dz())<1.:
#pid = mu.sourcePtr().originalObject().track().id()
#key = mu.sourcePtr().originalObject().track().key()
#mu.dEdX = self.handles['dEdX'].product().get(pid,key)
if mu.sourcePtr().userFloat("isPFMuon")>0.5 and mu.sip3D() < self.cfg_ana.sip3dCut and mu.relIso(dBetaFactor=0.5)<self.cfg_ana.isolationCut:
event.selectedLeptons.append(mu)
else:
event.looseLeptons.append(mu)
if mu.sourcePtr().userFloat("isPFMuon")>0.5 and mu.sip3D() < self.cfg_ana.sip3dCutVeryLoose:
event.inclusiveLeptons.append(mu)
#electrons
allelectrons = map( Electron, self.handles['electrons'].product() )
## duplicate removal for fast sim (to be checked if still necessary in 5_3_12+)
allelenodup = []
for e in allelectrons:
dup = False
for e2 in allelenodup:
if abs(e.pt()-e2.pt()) < 1e-6 and abs(e.eta()-e2.eta()) < 1e-6 and abs(e.phi()-e2.phi()) < 1e-6 and e.charge() == e2.charge():
dup = True
break
if not dup: allelenodup.append(e)
allelectrons = allelenodup
if self.cfg_ana.doRecomputeSIP3D:
for ele in allelectrons:
if ele.sourcePtr().gsfTrack().isNonnull():
## compute the variable and set it
ele._sip3d = abs(signedSip3D(ele, event.goodVertices[0]))
## attach it to the object redefining the sip3D() method
ele.sip3D = types.MethodType(lambda self : self._sip3d, ele, ele.__class__)
# fill EA for rho-corrected isolation
for ele in allelectrons:
ele.rho = float(self.handles['rhoEle'].product()[0])
SCEta = abs(ele.sourcePtr().superCluster().eta())
if (abs(SCEta) >= 0.0 and abs(SCEta) < 1.0 ) : ele.EffectiveArea = 0.130;
if (abs(SCEta) >= 1.0 and abs(SCEta) < 1.479 ) : ele.EffectiveArea = 0.137;
if (abs(SCEta) >= 1.479 and abs(SCEta) < 2.0 ) : ele.EffectiveArea = 0.067;
if (abs(SCEta) >= 2.0 and abs(SCEta) < 2.2 ) : ele.EffectiveArea = 0.089;
if (abs(SCEta) >= 2.2 and abs(SCEta) < 2.3 ) : ele.EffectiveArea = 0.107;
if (abs(SCEta) >= 2.3 and abs(SCEta) < 2.4 ) : ele.EffectiveArea = 0.110;
if (abs(SCEta) >= 2.4) : ele.EffectiveArea = 0.138;
if self.cfg_ana.doElectronScaleCorrections:
for ele in allelectrons:
self.electronEnergyCalibrator.correct(ele, event.run)
muForEleCrossCleaning = []
if self.cfg_ana.doEleMuCrossCleaning:
for mu in event.selectedLeptons + event.looseLeptons:
if abs(mu.pdgId()) == 13 and (mu.isGlobal() or mu.sourcePtr().userFloat("isPFMuon")>0.5):
muForEleCrossCleaning.append(mu)
for ele in allelectrons:
ele.associatedVertex = event.goodVertices[0]
## remove muons if muForEleCrossCleaning is not empty
if bestMatch(ele, muForEleCrossCleaning)[1] < 0.02: continue
## apply selection
if ele.pt()>7 and abs(ele.eta())<2.5 and abs(ele.dxy())<0.5 and abs(ele.dz())<1. and ele.numberOfHits()<=1:
## fill tightId:
if (ele.pt() > 20):
SCEta = abs(ele.sourcePtr().superCluster().eta())
if SCEta < 0.8: ele.tightIdResult = (ele.mvaTrigV0() > 0.00)
elif SCEta < 1.479: ele.tightIdResult = (ele.mvaTrigV0() > 0.10)
else: ele.tightIdResult = (ele.mvaTrigV0() > 0.62)
elif (ele.pt() > 10):
if SCEta < 0.8: ele.tightIdResult = (ele.mvaTrigV0() > 0.94)
elif SCEta < 1.479: ele.tightIdResult = (ele.mvaTrigV0() > 0.85)
else: ele.tightIdResult = (ele.mvaTrigV0() > 0.92)
else:
ele.tightIdResult = False
if (self.relaxId or ele.mvaIDZZ() and ele.sip3D() < self.cfg_ana.sip3dCut) and ele.relIso(dBetaFactor=0.5)<self.cfg_ana.isolationCut:
event.selectedLeptons.append(ele)
else:
event.looseLeptons.append(ele)
if (self.relaxId or ele.mvaIDZZ()) and ele.sip3D() < self.cfg_ana.sip3dCutVeryLoose:
event.inclusiveLeptons.append(ele)
event.looseLeptons.sort(key = lambda l : l.pt(), reverse = True)
event.selectedLeptons.sort(key = lambda l : l.pt(), reverse = True)
event.inclusiveLeptons.sort(key = lambda l : l.pt(), reverse = True)
for lepton in event.selectedLeptons:
if hasattr(self,'efficiency'):
self.efficiency.attachToObject(lepton)
def selectionSequence(self, event, fillCounter):
if fillCounter: self.counters.counter('WAna').inc('W all events')
# retrieve collections of interest (muons and jets)
event.allMuons = copy.copy(event.muons)
event.selMuons = copy.copy(event.muons)
event.NoTriggeredMuonsLeadingPt = copy.copy(event.muons)
event.allJets = copy.copy(event.jets)
event.selJets = copy.copy(event.jets)
# check if the event is MC and if genp must be saved
event.savegenpW=True
if not (self.cfg_ana.savegenp and self.cfg_comp.isMC):
event.savegenpW=False
# save genp only for signal events
# i.e. only one W is present and daughters are muon plus neutrino
genW_dummy = [ genp for genp in event.genParticles if \
math.fabs(genp.pdgId())==24 ]
if len(genW_dummy)==1:
event.genW = [ genp for genp in genW_dummy if \
( \
( math.fabs(genW_dummy[0].daughter(0).pdgId())==13 ) or \
( math.fabs(genW_dummy[0].daughter(1).pdgId())==13 ) \
) ]
# if the genp event is selected, associate gen muon and neutrino
event.genMu = []
event.genMuStatus1 = []
event.genNu = []
if len(event.genW)==1:
if [ math.fabs(event.genW[0].daughter(0).pdgId())==13 ]:
event.genMu.append(event.genW[0].daughter(0))
event.genNu.append(event.genW[0].daughter(1))
else:
event.genMu.append(event.genW[0].daughter(1))
event.genNu.append(event.genW[0].daughter(0))
if(len(event.genMu) >0):
event.genMuStatus1.append(self.returnMuonDaughterStatus1(event.genMu[0]))
event.genW_mt = self.mT(event.genW[0].daughter(0).p4() , event.genW[0].daughter(1).p4())
event.muGenDeltaRgenP=1e6
else:
# if the genp is not signal, don't save genp but do not exit
# -----> events which will pass the reconstruction but are not signal
# can be considered as background (for example, in W+Jets, from W decaying into electrons, taus)
event.savegenpW=False
else:
event.savegenpW=False
# store event number of muons, MET and jets in all gen events (necessary to make cuts in genp studies...)
# total number of reco muons
event.nMuons=len(event.selMuons)
# clean jets by removing muons
event.selJets = [ jet for jet in event.allJets if ( \
not (bestMatch( jet , event.selMuons ))[1] <0.5 \
and jet.looseJetId() and jet.pt()>30 \
)
]
# reco events must have good reco vertex and trigger fired...
if not (event.passedVertexAnalyzer and event.passedTriggerAnalyzer):
return True
# ...and at lest one reco muon...
if len(event.selMuons) == 0:
return True
if fillCounter: self.counters.counter('WAna').inc('W ev trig, good vertex and >= 1 lepton')
#check if the event is triggered according to cfg_ana
if len(self.cfg_comp.triggers)>0:
# muon object trigger matching
event.selMuons = [lep for lep in event.allMuons if \
self.trigMatched(event, lep)]
# exit if there are no triggered muons
if len(event.selMuons) == 0:
return True, 'trigger matching failed'
else:
if fillCounter: self.counters.counter('WAna').inc('W at least 1 lep trig matched')
# to select W impose only 1 triggering lepton in the event:
# the number of triggering lepton is checked on the whole lepton collection
# before any cut, otherwise could be a Z!!!
if len(event.selMuons) != 1:
return True, 'more than 1 lep trig matched'
else:
if fillCounter: self.counters.counter('WAna').inc('W only 1 lep trig matched')
# store muons that did not fire the trigger
event.NoTriggeredMuonsLeadingPt = [lep for lep in event.allMuons if \
not self.trigMatched(event, lep) ]
# print "len(event.NoTriggeredMuonsLeadingPt)= ",len(event.NoTriggeredMuonsLeadingPt)
# if len(event.NoTriggeredMuonsLeadingPt)>0 : print "event.NoTriggeredMuonsLeadingPt[0].pt() = ",event.NoTriggeredMuonsLeadingPt[0].pt()
if len(event.NoTriggeredMuonsLeadingPt) > 0:
if event.NoTriggeredMuonsLeadingPt[0].pt()>10:
# if (event.NoTriggeredMuonsLeadingPt[0].pt()<10): print "ESISTE UN LEPTONE NON TRIGGERING WITH PT>10, event.NoTriggeredMuonsLeadingPt[0].pt() = ",event.NoTriggeredMuonsLeadingPt[0].pt()
return True, 'rejecting event with non triggering lepton with pT > 10 GeV'
else:
if fillCounter: self.counters.counter('WAna').inc('W non trg leading lepton pT < 10 GeV')
else:
if fillCounter: self.counters.counter('WAna').inc('W non trg leading lepton pT < 10 GeV')
# if the genp are saved, compute dR between gen and reco muon
if event.savegenpW :
event.muGenDeltaRgenP = deltaR( event.selMuons[0].eta(), event.selMuons[0].phi(), event.genMu[0].eta(), event.genMu[0].phi() )
# associate good vertex to muon to compute dxy
event.selMuons[0].associatedVertex = event.goodVertices[0]
# testing offline muon cuts (tight+iso, no kinematical cuts)
event.selMuonIsTightAndIso = self.testLeg( event.selMuons[0] )
event.selMuonIsTight = self.testLegID( event.selMuons[0] )
# START RETRIEVING MVAMET
# INPUT DEFINITIONS AS OF HTT
# mvaMETTauMu = cms.EDProducer(
# "MVAMETProducerTauMu",
# pfmetSrc = cms.InputTag('pfMetForRegression'),
# tkmetSrc = cms.InputTag('tkMet'),
# nopumetSrc = cms.InputTag('nopuMet'),
# pucmetSrc = cms.InputTag('pcMet'),
# pumetSrc = cms.InputTag('puMet'),
# recBosonSrc = cms.InputTag('cmgTauMuSel'),
# jetSrc = cms.InputTag('cmgPFJetSel'),
# leadJetSrc = cms.InputTag('cmgPFBaseJetLead'),
# vertexSrc = cms.InputTag('goodPVFilter'),
# nJetsPtGt1Src = cms.InputTag('nJetsPtGt1'),
# rhoSrc = cms.InputTag('kt6PFJets','rho'),
# enable = cms.bool(True),
# verbose = cms.untracked.bool( False ),
# weights_gbrmet = cms.string(weights_gbrmet),
# weights_gbrmetphi = cms.string(weights_gbrmetphi),
# weights_gbrmetu1cov = cms.string(weights_gbrmetu1cov),
# weights_gbrmetu2cov = cms.string(weights_gbrmetu2cov),
# #COLIN: make delta R a parameter
# )
# self.prepareObjectsForMVAMET(event)
# self.mvamet.getMet(
# event.cleanpfmetForRegression, #iPFMet,
# event.cleantkmet, #iTKMet,
# event.cleannopumet, #iNoPUMet,
# event.pumet, #iPUMet,
# event.cleanpucmet, #iPUCMet,
# event.iLeadJet, #event.iLeadJet,
# event.i2ndJet, #event.i2ndJet,
# event.NJetsGt30, #iNJetsGt30,
# event.nJetsPtGt1Clean, #iNJetsGt1,
# len(event.goodVertices), #iNGoodVtx,
# event.iJets_p4, #iJets,
# event.iJets_mva, #iJets,
# event.iJets_neutFrac, #iJets,
# False, #iPrintDebug,
# event.visObjectP4s_array #visObjectP4s
# )
# event.mvamet = self.mvamet.GetMet_first();
# event.GetMVAMet_second = self.mvamet.GetMet_second();
# print 'AFTER MVAmet_test'
# print 'event.pfmet.pt() ', event.pfmet.pt()
# print 'event.selMuons[0].pt() ',event.selMuons[0].pt(),' event.mvamet.Pt() ',event.mvamet.Pt()
# print ''
# print 'event.GetMVAMet_second ',event.GetMVAMet_second,' event.GetMVAMet_second.significance() ',event.GetMVAMet_second.significance().Print()
# define a W from lepton and MET
event.W4V = event.selMuons[0].p4() + event.pfmet.p4()
event.W4V_mt = self.mT(event.selMuons[0].p4() , event.pfmet.p4())
# Code to study the recoil (not very useful for W...)
metVect = event.pfmet.p4().Vect()
metVect.SetZ(0.) # use only transverse info
WVect = event.W4V.Vect()
WVect.SetZ(0.) # use only transverse info
recoilVect = - copy.deepcopy(metVect) ## FIXED (met sign inverted)
# recoilVect -= WVect
temp_recoil = event.selMuons[0].p4().Vect()
temp_recoil.SetZ(0.) # use only transverse info
recoilVect -= temp_recoil ## FIXED (subtract only lepton for consistent recoil definition)
uWVect = WVect.Unit()
zAxis = type(WVect)(0,0,1)
uWVectPerp = WVect.Cross(zAxis).Unit()
u1 = recoilVect.Dot(uWVect) # recoil parallel to W pt
u2 = - recoilVect.Dot(uWVectPerp) # recoil perpendicular to W pt
event.u1 = u1
event.u2 = u2
if fillCounter:
if event.selMuonIsTightAndIso :
self.counters.counter('WAna').inc('W lep is MuIsTightAndIso')
if self.testLegKine( event.selMuons[0] , 30 , 2.1 ) :
self.counters.counter('WAna').inc('W Mu_eta<2.1 && Mu_pt>30')
if event.pfmet.pt() >25:
self.counters.counter('WAna').inc('W pfmet>25')
if event.W4V.Pt() < 20:
self.counters.counter('WAna').inc('W pt<20')
if len(event.selJets) > 0:
if event.selJets[0].pt()<30:
self.counters.counter('WAna').inc('W Jet_leading_pt<30')
else:
self.counters.counter('WAna').inc('W Jet_leading_pt<30')
# event is fully considered as good
# if fillCounter: self.counters.counter('WAna').inc('W pass')
event.WGoodEvent = True
return True
def process(self, iEvent, event):
self.readCollections( iEvent )
pfmet = self.handles['pfmetraw'].product()[0]
tr = self.tree
tr.reset()
fill( tr, 'run', event.run)
fill( tr, 'lumi',event.lumi)
fill( tr, 'evt', event.eventId)
fill( tr, 'rho', event.rho)
fill( tr, 'nmuon', len(event.muoncand))
fill( tr, 'nelectron', len(event.electroncand))
fill( tr, 'ntau', len(event.taucand))
fill( tr, 'nvmuon', len(event.vetomuoncand))
fill( tr, 'nvelectron', len(event.vetoelectroncand))
fill( tr, 'nvtau', len(event.vetotaucand))
fill( tr, 'pfmet', pfmet.pt())
fill( tr, 'pfmetphi', pfmet.phi())
fill( tr, 'nBJets', len(event.cleanBJets))
fill( tr, 'nJets', len(event.cleanJets))
fill( tr, 'weight', event.eventWeight)
# if self.cfg_comp.isMC:
# nparton = self.mchandles['source'].product().hepeup().NUP
# fill( tr, 'NUP', nparton)
# nJets = len(event.cleanJets)
# if nJets>=1:
# fillJet(tr, 'jet1', event.cleanJets[0] )
# if nJets>=2:
# fillJet(tr, 'jet2', event.cleanJets[1] )
trig_M8E17 = False
trig_M17E8 = False
# for itrig in event.hltPaths:
#
# if itrig.find('Mu8_Ele17')!=-1:
# trig_M8E17 = True
# if itrig.find('Mu17_Ele8')!=-1:
# trig_M17E8 = True
fill( tr, 'trig_type_M8E17', trig_M8E17)
fill( tr, 'trig_type_M17E8', trig_M17E8)
self.tree.tree.Fill()
allJets = self.handles['jets'].product()
maxJets = []
for ijet in allJets:
if ijet.pt() > 12. and abs(ijet.eta()) < 5:
maxJets.append(ijet)
mtr = self.mtree
mtr.reset()
for im in event.muoncand:
fillParticle(mtr, 'muon', im)
fill(mtr, 'muon_id', im.flag_id)
fill(mtr, 'muon_iso', im.flag_iso)
fill(mtr, 'muon_trigmatch', im.trig_match)
fill(mtr, 'muon_MT', self.returnMT(pfmet, im))
fill(mtr, 'muon_trig_weight', muTrigScale_TauMu_2012_53X(im.pt(), im.eta()))
fill(mtr, 'muon_id_weight', muIDscale_TauMu_2012_53X(im.pt(), im.eta()))
fill(mtr, 'muon_mass', im.mass())
fill(mtr, 'muon_reliso', im.relIso(0.5,1))
bm, dr2min = bestMatch(im, maxJets)
if dr2min < 0.25:
fill( mtr, 'muon_jetpt', bm.pt())
fill( mtr, 'muon_njet', len(event.cleanJets))
else:
fill( mtr, 'muon_jetpt', -999)
fill( mtr, 'muon_njet', -999)
self.mtree.tree.Fill()
etr = self.etree
etr.reset()
for ie in event.electroncand:
fillParticle(etr, 'electron', ie)
fill(etr, 'electron_id', ie.flag_id)
fill(etr, 'electron_iso', ie.flag_iso)
fill(etr, 'electron_trigmatch', ie.trig_match)
fill(etr, 'electron_MT', self.returnMT(pfmet, ie))
fill(etr, 'electron_trig_weight', 1.)
fill(etr, 'electron_id_weight', 1.)
fill(etr, 'electron_mass', ie.mass())
fill(etr, 'electron_reliso', ie.relIso(0.5,1))
bm, dr2min = bestMatch(ie, maxJets)
if dr2min < 0.25:
fill( etr, 'electron_jetpt', bm.pt())
fill( etr, 'electron_njet', len(event.cleanJets))
else:
fill( etr, 'electron_jetpt', -999)
fill( etr, 'electron_njet', -999)
self.etree.tree.Fill()
ttr = self.ttree
ttr.reset()
for it in event.taucand:
fillParticle(ttr, 'tau', it)
fill(ttr, 'tau_id', it.flag_id)
fill(ttr, 'tau_iso', it.flag_iso)
fill(ttr, 'tau_MT', self.returnMT(pfmet, it))
fill(ttr, 'tau_mass', it.mass())
fill(ttr, 'tau_decaymode', it.decaymode)
fill(ttr, 'tau_ep', it.ep)
fill(ttr, 'tau_trig_match', it.trig_match)
fill(ttr, 'tau_againstELoose', it.againstELoose)
fill(ttr, 'tau_againstELooseArmin', it.againstELooseArmin)
fill(ttr, 'tau_againstEMedium', it.againstEMedium)
fill(ttr, 'tau_againstETight', it.againstETight)
fill(ttr, 'tau_againstE2Loose', it.againstE2Loose)
fill(ttr, 'tau_againstE2Medium', it.againstE2Medium)
# fill(ttr, 'tau_againstE0Loose', it.againstE0Loose)
# fill(ttr, 'tau_againstE0Medium', it.againstE0Medium)
fill(ttr, 'tau_againstMuLoose', it.againstMuLoose)
fill(ttr, 'tau_againstMuTight', it.againstMuTight)
fill(ttr, 'tau_mvaisolation', it.mvaisolation)
fill(ttr, 'tau_mvaisolation_loose', it.mvaisolation_loose)
fill(ttr, 'tau_againstERaw', it.againstERaw)
fill(ttr, 'tau_againstECat', it.againstECat)
fill(ttr, 'tau_againstE2Raw', it.againstE2Raw)
fill(ttr, 'tau_againstE2Cat', it.againstE2Cat)
fill(ttr, 'tau_againstE0Raw', it.againstE0Raw)
# fill(ttr, 'tau_againstE0Cat', it.againstE0Cat)
fill(ttr, 'dBisolation', it.dBisolation)
self.ttree.tree.Fill()
vmtr = self.vmtree
vmtr.reset()
for im in event.vetomuoncand:
fillParticle(vmtr, 'veto_muon', im)
self.vmtree.tree.Fill()
vetr = self.vetree
vetr.reset()
for ie in event.vetoelectroncand:
fillParticle(vetr, 'veto_electron', ie)
self.vetree.tree.Fill()
vttr = self.vttree
vttr.reset()
for it in event.vetotaucand:
fillParticle(vttr, 'veto_tau', it)
self.vttree.tree.Fill()
btr = self.btree
btr.reset()
for ib in event.cleanBJets:
fill(btr, 'bjet_pt', ib.pt())
fill(btr, 'bjet_eta', ib.eta())
fill(btr, 'bjet_phi', ib.phi())
fill(btr, 'bjet_flav', ib.partonFlavour())
fill(btr, 'bjet_mva', ib.btag('combinedSecondaryVertexBJetTags'))
fill(btr, 'bjet_mass', ib.mass())
self.btree.tree.Fill()
jtr = self.jtree
jtr.reset()
for ij in event.cleanJets:
fillJet(jtr, 'jet', ij)
fill(jtr, 'jet_flav', ij.partonFlavour())
fill(jtr, 'jet_mass', ij.mass())
self.jtree.tree.Fill()
def makeLeptons(self, event):
event.looseLeptons = []
event.selectedLeptons = []
event.inclusiveLeptons = []
#muons
allmuons = map(Muon, self.handles['muons'].product())
if self.cfg_ana.doRecomputeSIP3D:
for mu in allmuons:
if mu.sourcePtr().innerTrack().isNonnull():
## compute the variable and set it
mu._sip3d = abs(signedSip3D(mu, event.goodVertices[0]))
## attach it to the object redefining the sip3D() method
mu.sip3D = types.MethodType(lambda self: self._sip3d, mu,
mu.__class__)
if self.cfg_ana.doMuScleFitCorrections:
for mu in allmuons:
self.muscleCorr.correct(mu, event.run)
elif self.cfg_ana.doRochesterCorrections:
for mu in allmuons:
corp4 = rochcor.corrected_p4(mu, event.run)
mu.setP4(corp4)
if self.cfg_ana.doSegmentBasedMuonCleaning:
isgood = cmgMuonCleanerBySegments.clean(
self.handles['muons'].product())
newmu = []
for i, mu in enumerate(allmuons):
if isgood[i]: newmu.append(mu)
allmuons = newmu
for mu in allmuons:
mu.associatedVertex = event.goodVertices[0]
if (mu.isGlobal() or mu.isTracker() and mu.numberOfMatches() > 0
) and mu.pt() > 5 and abs(mu.eta()) < 2.4 and abs(
mu.dxy()) < 0.5 and abs(mu.dz()) < 1.:
#pid = mu.sourcePtr().originalObject().track().id()
#key = mu.sourcePtr().originalObject().track().key()
#mu.dEdX = self.handles['dEdX'].product().get(pid,key)
if mu.sourcePtr().userFloat("isPFMuon") > 0.5 and mu.sip3D(
) < self.cfg_ana.sip3dCut and mu.relIso(
dBetaFactor=0.5) < self.cfg_ana.isolationCut:
event.selectedLeptons.append(mu)
else:
event.looseLeptons.append(mu)
if mu.sourcePtr().userFloat("isPFMuon") > 0.5 and mu.sip3D(
) < self.cfg_ana.sip3dCutVeryLoose:
event.inclusiveLeptons.append(mu)
#electrons
allelectrons = map(Electron, self.handles['electrons'].product())
## duplicate removal for fast sim (to be checked if still necessary in 5_3_12+)
allelenodup = []
for e in allelectrons:
dup = False
for e2 in allelenodup:
if abs(e.pt() - e2.pt()) < 1e-6 and abs(e.eta() - e2.eta(
)) < 1e-6 and abs(e.phi() - e2.phi()) < 1e-6 and e.charge(
) == e2.charge():
dup = True
break
if not dup: allelenodup.append(e)
allelectrons = allelenodup
if self.cfg_ana.doRecomputeSIP3D:
for ele in allelectrons:
if ele.sourcePtr().gsfTrack().isNonnull():
## compute the variable and set it
ele._sip3d = abs(signedSip3D(ele, event.goodVertices[0]))
## attach it to the object redefining the sip3D() method
ele.sip3D = types.MethodType(lambda self: self._sip3d, ele,
ele.__class__)
# fill EA for rho-corrected isolation
for ele in allelectrons:
ele.rho = float(self.handles['rhoEle'].product()[0])
SCEta = abs(ele.sourcePtr().superCluster().eta())
if (abs(SCEta) >= 0.0 and abs(SCEta) < 1.0):
ele.EffectiveArea = 0.130
if (abs(SCEta) >= 1.0 and abs(SCEta) < 1.479):
ele.EffectiveArea = 0.137
if (abs(SCEta) >= 1.479 and abs(SCEta) < 2.0):
ele.EffectiveArea = 0.067
if (abs(SCEta) >= 2.0 and abs(SCEta) < 2.2):
ele.EffectiveArea = 0.089
if (abs(SCEta) >= 2.2 and abs(SCEta) < 2.3):
ele.EffectiveArea = 0.107
if (abs(SCEta) >= 2.3 and abs(SCEta) < 2.4):
ele.EffectiveArea = 0.110
if (abs(SCEta) >= 2.4): ele.EffectiveArea = 0.138
if self.cfg_ana.doElectronScaleCorrections:
for ele in allelectrons:
self.electronEnergyCalibrator.correct(ele, event.run)
muForEleCrossCleaning = []
if self.cfg_ana.doEleMuCrossCleaning:
for mu in event.selectedLeptons + event.looseLeptons:
if abs(mu.pdgId()) == 13 and (
mu.isGlobal()
or mu.sourcePtr().userFloat("isPFMuon") > 0.5):
muForEleCrossCleaning.append(mu)
for ele in allelectrons:
ele.associatedVertex = event.goodVertices[0]
## remove muons if muForEleCrossCleaning is not empty
if bestMatch(ele, muForEleCrossCleaning)[1] < 0.02: continue
## apply selection
if ele.pt() > 7 and abs(ele.eta()) < 2.5 and abs(
ele.dxy()) < 0.5 and abs(
ele.dz()) < 1. and ele.numberOfHits() <= 1:
## fill tightId:
if (ele.pt() > 20):
SCEta = abs(ele.sourcePtr().superCluster().eta())
if SCEta < 0.8:
ele.tightIdResult = (ele.mvaTrigV0() > 0.00)
elif SCEta < 1.479:
ele.tightIdResult = (ele.mvaTrigV0() > 0.10)
else:
ele.tightIdResult = (ele.mvaTrigV0() > 0.62)
elif (ele.pt() > 10):
if SCEta < 0.8:
ele.tightIdResult = (ele.mvaTrigV0() > 0.94)
elif SCEta < 1.479:
ele.tightIdResult = (ele.mvaTrigV0() > 0.85)
else:
ele.tightIdResult = (ele.mvaTrigV0() > 0.92)
else:
ele.tightIdResult = False
if (self.relaxId or ele.mvaIDZZ() and
ele.sip3D() < self.cfg_ana.sip3dCut) and ele.relIso(
dBetaFactor=0.5) < self.cfg_ana.isolationCut:
event.selectedLeptons.append(ele)
else:
event.looseLeptons.append(ele)
if (self.relaxId or ele.mvaIDZZ()
) and ele.sip3D() < self.cfg_ana.sip3dCutVeryLoose:
event.inclusiveLeptons.append(ele)
event.looseLeptons.sort(key=lambda l: l.pt(), reverse=True)
event.selectedLeptons.sort(key=lambda l: l.pt(), reverse=True)
event.inclusiveLeptons.sort(key=lambda l: l.pt(), reverse=True)
for lepton in event.selectedLeptons:
if hasattr(self, 'efficiency'):
self.efficiency.attachToObject(lepton)
def process(self, iEvent, event):
scale=1.0
def fill( varName, value ):
setattr( self.tree.s, varName, value )
def fParticleVars( pName, particle ):
fill('{pName}Px'.format(pName=pName), particle.px()*scale )
fill('{pName}Py'.format(pName=pName), particle.py()*scale )
fill('{pName}Pz'.format(pName=pName), particle.pz()*scale )
fill('{pName}E'.format(pName=pName), particle.energy()*scale )
fill('{pName}Pt'.format(pName=pName), particle.pt()*scale )
fill('{pName}Eta'.format(pName=pName), particle.eta() )
fill('{pName}Phi'.format(pName=pName), particle.phi() )
fill('{pName}Charge'.format(pName=pName), particle.charge() )
fill('{pName}Mass'.format(pName=pName), particle.mass()*scale )
#if hasattr( particle, 'relIso' ):
# fill('{pName}Iso'.format(pName=pName), particle.relIso(0.5) )
#if abs( particle.pdgId() )==11:
# fill('{pName}Id'.format(pName=pName), particle.mvaDaniele() )
# SKIMMING here:
#if not (event.diLepton.leg1().pt>20 and \
#event.diLepton.leg2().pt>20 and \
#event.diLepton.leg1().tauID("decayModeFinding")>0.5 and \
#event.diLepton.leg2().tauID("decayModeFinding")>0.5 and \
#(event.diLepton.leg1().tauID("byLooseCombinedIsolationDeltaBetaCorr")>0.5 or \
# event.diLepton.leg2().tauID("byLooseCombinedIsolationDeltaBetaCorr")>0.5) and \
#event.diLepton.leg1().tauID("againstElectronLoose")>0.5 and \
#event.diLepton.leg2().tauID("againstElectronLoose")>0.5 and \
#event.diLepton.leg1().tauID("againstMuonLoose")>0.5 and \
#event.diLepton.leg2().tauID("againstMuonLoose")>0.5): return
#if "TTJets" in self.cfg_comp.name and not (event.diLepton.leg1().tauID("byMediumIsoMVA")>0.5 and \
#event.diLepton.leg2().tauID("byMediumIsoMVA")>0.5): return
if hasattr(event,"run"):
fill('run', event.run)
if hasattr(event,"lumi"):
fill('lumi', event.lumi)
if hasattr(event,"eventId"):
fill('event', event.eventId)
fill('visMass', event.diLepton.mass()*scale)
fill('svfitMass', event.diLepton.massSVFit()*scale)
fill('mt1', event.diLepton.mTLeg1()*scale)
fill('mt2', event.diLepton.mTLeg2()*scale)
fill('pThiggs', sqrt(pow(event.diLepton.met().px()+event.diLepton.leg1().px()+event.diLepton.leg2().px(),2)+pow(event.diLepton.met().py()+event.diLepton.leg1().py()+event.diLepton.leg2().py(),2))*scale)
#mvametsig = event.diLepton.mvaMetSig.significance()
#fill( tr, 'mvacov00', mvametsig(0,0))
#fill( tr, 'mvacov01', mvametsig(0,1))
#fill( tr, 'mvacov10', mvametsig(1,0))
#fill( tr, 'mvacov11', mvametsig(1,1))
fill('metPhi', event.diLepton.met().phi()*scale)
fill('mex', event.diLepton.met().px()*scale)
fill('mey', event.diLepton.met().py()*scale)
fill('met', event.diLepton.met().pt()*scale)
fill('rawMET', event.rawMET[0].pt())
fill('dRtt', sqrt(pow(deltaPhi(event.diLepton.leg1().phi(),event.diLepton.leg2().phi()),2)+pow(fabs(event.diLepton.leg1().eta()-event.diLepton.leg2().eta()),2)))
fill('dPhitt', deltaPhi(event.diLepton.leg1().phi(),event.diLepton.leg2().phi()))
fill('dEtatt', fabs(event.diLepton.leg1().eta()-event.diLepton.leg2().eta()))
fParticleVars('diTau', event.diLepton)
#if event.diLepton.leg1().pt()>event.diLepton.leg2().pt():
# leg1=event.diLepton.leg1()
# leg2=event.diLepton.leg2()
#else:
# leg1=event.diLepton.leg2()
# leg2=event.diLepton.leg1()
leg1=event.diLepton.leg1()
leg2=event.diLepton.leg2()
fParticleVars('l1', leg1 )
fParticleVars('l2', leg2 )
l1jet = bestMatch( leg1, event.jets )[0]
l2jet = bestMatch( leg2, event.jets )[0]
fill('l1DecayMode', leg1.decayMode() )
fill('l1LooIso', leg1.tauID("byLooseCombinedIsolationDeltaBetaCorr") )
fill('l1MedIso', leg1.tauID("byMediumCombinedIsolationDeltaBetaCorr") )
fill('l1TigIso', leg1.tauID("byTightCombinedIsolationDeltaBetaCorr") )
fill('l1RawMVAIso', leg1.tauID("byRawIsoMVA") )
fill('l1MedMVAIso', leg1.tauID("byMediumIsoMVA") )
fill('l1TigMVAIso', leg1.tauID("byTightIsoMVA") )
#fill('l1LooseEle', leg1.tauID("againstElectronLoose") )
fill('l1MedEle', leg1.tauID("againstElectronMedium") )
fill('l1MVAEle', leg1.tauID("againstElectronMVA") )
#fill('l1LooseMu', leg1.tauID("againstMuonLoose") )
fill('l1jetMass', leg1.jetRefp4().mass() )
fill('l1jetPt', leg1.jetRefp4().pt() )
if l1jet:
fill('l1jetWidth', l1jet.rms() )
fill('l1jetBtag', l1jet.btag("combinedSecondaryVertexBJetTags") )
fill('l2DecayMode', leg2.decayMode() )
fill('l2LooIso', leg2.tauID("byLooseCombinedIsolationDeltaBetaCorr") )
fill('l2MedIso', leg2.tauID("byMediumCombinedIsolationDeltaBetaCorr") )
fill('l2TigIso', leg2.tauID("byTightCombinedIsolationDeltaBetaCorr") )
fill('l2RawMVAIso', leg2.tauID("byRawIsoMVA") )
fill('l2MedMVAIso', leg2.tauID("byMediumIsoMVA") )
fill('l2TigMVAIso', leg2.tauID("byTightIsoMVA") )
#fill('l2LooseEle', leg2.tauID("againstElectronLoose") )
fill('l2MedEle', leg2.tauID("againstElectronMedium") )
fill('l2MVAEle', leg2.tauID("againstElectronMVA") )
#fill('l2LooseMu', leg2.tauID("againstMuonLoose") )
fill('l2jetMass', leg2.jetRefp4().mass() )
fill('l2jetPt', leg2.jetRefp4().pt() )
if l2jet:
fill('l2jetWidth', l2jet.rms() )
fill('l2jetBtag', l1jet.btag("combinedSecondaryVertexBJetTags") )
fill('l1VertexZ', leg1.tau.vz() )
fill('l2VertexZ', leg2.tau.vz() )
if hasattr(event,"leg1DeltaR"):
fill('l1match', event.leg1DeltaR )
fill('l2match', event.leg2DeltaR )
else:
fill('l1match', -1 )
fill('l2match', -1 )
if hasattr(event,"genMass"):
fill('genMass', event.genMass )
# from ROOT import TFile,TH1F
# f = TFile("/afs/cern.ch/user/h/hinzmann/workspace/stable2012/CMGTools/CMSSW_5_2_5/src/CMGTools/H2TauTau/python/proto/embeddedWeights.root")
# hEmbed = f.Get("hemb")
# shift=hEmbed.GetRandom()/event.genMass
# fill('genMassSmeared', event.genMass*shift )
# fill('svfitMassSmeared', event.diLepton.massSVFit()*scale*shift )
else:
fill('genMass', -1 )
fill('genMassSmeared', -1 )
fill('svfitMassSmeared', -1 )
if hasattr(event,"l1TrigMatched"):
fill('l1TrigMatched', event.l1TrigMatched )
else:
fill('l1TrigMatched', -1 )
if hasattr(event,"l2TrigMatched"):
fill('l2TrigMatched', event.l2TrigMatched )
else:
fill('l2TrigMatched', -1 )
if hasattr(event,"jetTrigMatched"):
fill('jetTrigMatched', event.jetTrigMatched )
else:
fill('jetTrigMatched', -1 )
#if event.diLepton.leg1().genTaup4() and event.diLepton.leg2().genTaup4():
# fill('genTauVisMass', sqrt(
# pow(event.diLepton.leg1().genTaup4().energy()+event.diLepton.leg2().genTaup4().energy(),2)
# -pow(event.diLepton.leg1().genTaup4().px()+event.diLepton.leg2().genTaup4().px(),2)
# -pow(event.diLepton.leg1().genTaup4().py()+event.diLepton.leg2().genTaup4().py(),2)
# -pow(event.diLepton.leg1().genTaup4().pz()+event.diLepton.leg2().genTaup4().pz(),2)
# ))
#if event.diLepton.leg1().genJetp4() and event.diLepton.leg2().genJetp4():
# fill('genJetVisMass', sqrt(
# pow(event.diLepton.leg1().genJetp4().energy()+event.diLepton.leg2().genJetp4().energy(),2)
# -pow(event.diLepton.leg1().genJetp4().px()+event.diLepton.leg2().genJetp4().px(),2)
# -pow(event.diLepton.leg1().genJetp4().py()+event.diLepton.leg2().genJetp4().py(),2)
# -pow(event.diLepton.leg1().genJetp4().pz()+event.diLepton.leg2().genJetp4().pz(),2)
# ))
nJets = len(event.cleanJets)
fill('nJets', nJets )
if nJets>=1:
fParticleVars('jet1', event.cleanJets[0] )
fill('jet1Btag', event.cleanJets[0].btag("combinedSecondaryVertexBJetTags") )
fill('jet1Bmatch', event.cleanJets[0].matchGenParton )
fill('mttj', sqrt(pow(event.diLepton.energy()+event.cleanJets[0].energy(),2) - pow(event.diLepton.px()+event.cleanJets[0].px(),2) - pow(event.diLepton.py()+event.cleanJets[0].py(),2) - pow(event.diLepton.pz()+event.cleanJets[0].pz(),2)))
fill('l1JetInvMass', sqrt(pow(leg1.energy()+event.cleanJets[0].energy(),2) - pow(leg1.px()+event.cleanJets[0].px(),2) - pow(leg1.py()+event.cleanJets[0].py(),2) - pow(leg1.pz()+event.cleanJets[0].pz(),2)))
fill('l2JetInvMass', sqrt(pow(leg2.energy()+event.cleanJets[0].energy(),2) - pow(leg2.px()+event.cleanJets[0].px(),2) - pow(leg2.py()+event.cleanJets[0].py(),2) - pow(leg2.pz()+event.cleanJets[0].pz(),2)))
if nJets>=2:
fParticleVars('jet2', event.cleanJets[1] )
fill('jet2Btag', event.cleanJets[1].btag("combinedSecondaryVertexBJetTags") )
fill('jet2Bmatch', event.cleanJets[1].matchGenParton )
fill('mjj', event.vbf.mjj)
fill('dEtajj', event.vbf.deta)
fill('dPhijj', deltaPhi(event.cleanJets[0].phi(), event.cleanJets[1].phi()))
fill('dEtattjj', fabs(event.cleanJets[0].eta()+event.cleanJets[1].eta()-event.diLepton.eta()))
fill('dPhittjj', deltaPhi(event.cleanJets[0].phi()+event.cleanJets[1].phi(),event.diLepton.phi()))
fill('nCentralJets', len(event.vbf.centralJets))
fill('vbfMVA', event.vbf.mva)
nbJets = len(event.cleanBJets)
fill('nbJets', nbJets )
if nbJets>=1:
fParticleVars('bjet1', event.cleanBJets[0] )
if nbJets>=2:
fParticleVars('bjet2', event.cleanBJets[1] )
fill('weight', event.eventWeight)
if hasattr( event, 'vertexWeight'):
fill('vertexWeight', event.vertexWeight)
fill('nVert', len(event.vertices) )
if hasattr( event, 'embedWeight'):
fill('embedWeight', event.embedWeight)
if hasattr( event, 'triggerWeight'):
fill('triggerWeight', event.triggerWeight)
#if hasattr( event, 'leg1_eff'):
# fill('l1EffData', event.leg1_eff)
# fill('l1EffMC', event.leg1_effMC)
# fill('l1Weight', event.leg1_weight)
#if hasattr( event, 'leg2_eff'):
# fill('l2EffData', event.leg2_eff)
# fill('l2EffMC', event.leg2_effMC)
# fill('l2Weight', event.leg2_weight)
isFake = 1
if hasattr( event, 'genMatched'):
if event.genMatched == 1:
isFake = 0
fill('isFake', isFake)
genMatched = 0
if hasattr(event,'genMatched') and event.genMatched > 0: genMatched = event.genMatched
fill('genMatched', genMatched)
isPhoton = 0
if hasattr(event,'isPhoton') and event.isPhoton == 1: isPhoton = 1
fill('isPhoton', isPhoton)
isElectron = 0
if hasattr(event,'isElectron') and event.isElectron > 0: isElectron = event.isElectron
fill('isElectron', isElectron)
isMuon = 0
if hasattr(event,'isMuon') and event.isMuon > 0: isMuon = event.isMuon
fill('isMuon', isMuon)
hasW = 0
if hasattr(event,'hasW') and event.hasW == 1: hasW = 1
fill('hasW', hasW)
hasZ = 0
if hasattr(event,'hasZ') and event.hasZ == 1: hasZ = 1
fill('hasZ', hasZ)
if len(event.muons)>0:
fill('muon1Pt', event.muons[0].pt() )
fill('muon1Eta', event.muons[0].eta() )
fill('muon1Phi', event.muons[0].phi() )
else:
fill('muon1Pt', -1 )
fill('muon1Eta', -1 )
fill('muon1Phi', -1 )
if len(event.electrons)>0:
fill('electron1Pt', event.electrons[0].pt() )
fill('electron1Eta', event.electrons[0].eta() )
fill('electron1Phi', event.electrons[0].phi() )
else:
fill('electron1Pt', -1 )
fill('electron1Eta', -1 )
fill('electron1Phi', -1 )
fill('NUP', event.NUP )
for trig in self.triggers:
fill(trig, getattr(event,trig))
self.tree.fill()
def makeLeptons(self, event):
event.looseLeptons = []
event.selectedLeptons = []
event.inclusiveLeptons = []
#muons
allmuons = map(Muon, self.handles['muons'].product())
if self.cfg_ana.doRecomputeSIP3D:
for mu in allmuons:
if mu.sourcePtr().innerTrack().isNonnull():
## compute the variable and set it
mu._sip3d = abs(signedSip3D(mu, event.goodVertices[0]))
## attach it to the object redefining the sip3D() method
mu.sip3D = types.MethodType(lambda self: self._sip3d, mu,
mu.__class__)
if self.cfg_ana.doMuScleFitCorrections:
for mu in allmuons:
self.muscleCorr.correct(mu, event.run)
elif self.cfg_ana.doRochesterCorrections:
for mu in allmuons:
corp4 = rochcor.corrected_p4(mu, event.run)
mu.setP4(corp4)
if self.cfg_ana.doSegmentBasedMuonCleaning:
isgood = cmgMuonCleanerBySegments.clean(
self.handles['muons'].product())
newmu = []
for i, mu in enumerate(allmuons):
if isgood[i]: newmu.append(mu)
allmuons = newmu
for mu in allmuons:
mu.associatedVertex = event.goodVertices[0]
mu.relIso03 = (
mu.sourcePtr().pfIsolationR03().sumChargedHadronPt + max(
mu.sourcePtr().pfIsolationR03().sumNeutralHadronEt +
mu.sourcePtr().pfIsolationR03().sumPhotonEt -
mu.sourcePtr().pfIsolationR03().sumPUPt / 2,
0.0)) / mu.pt()
mu.looseFakeId = ((mu.isGlobal()
or mu.isTracker() and mu.numberOfMatches() > 0)
and mu.sourcePtr().userFloat("isPFMuon") > 0.5
and mu.pt() > 10 and abs(mu.eta()) < 2.4
and mu.tightId() > 0.5 and abs(mu.dxy()) < 0.2
and abs(mu.dz()) < 0.2 and mu.relIso03 < 1.0)
mu.tightFakeId = ((mu.isGlobal()
or mu.isTracker() and mu.numberOfMatches() > 0)
and mu.sourcePtr().userFloat("isPFMuon") > 0.5
and mu.pt() > 10 and abs(mu.eta()) < 2.4
and mu.tightId() > 0.5 and abs(mu.dxy()) < 0.01
and abs(mu.dz()) < 0.2 and mu.relIso03 < 0.1)
if mu.pt() > 5 and abs(mu.eta()) < 2.4:
if mu.looseFakeId:
event.inclusiveLeptons.append(mu)
event.selectedLeptons.append(mu)
#electrons
allelectrons = map(Electron, self.handles['electrons'].product())
## duplicate removal for fast sim (to be checked if still necessary in 5_3_12+)
allelenodup = []
for e in allelectrons:
dup = False
for e2 in allelenodup:
if abs(e.pt() - e2.pt()) < 1e-6 and abs(e.eta() - e2.eta(
)) < 1e-6 and abs(e.phi() - e2.phi()) < 1e-6 and e.charge(
) == e2.charge():
dup = True
break
if not dup: allelenodup.append(e)
allelectrons = allelenodup
if self.cfg_ana.doRecomputeSIP3D:
for ele in allelectrons:
if ele.sourcePtr().gsfTrack().isNonnull():
## compute the variable and set it
ele._sip3d = abs(signedSip3D(ele, event.goodVertices[0]))
## attach it to the object redefining the sip3D() method
ele.sip3D = types.MethodType(lambda self: self._sip3d, ele,
ele.__class__)
# fill EA for rho-corrected isolation
for ele in allelectrons:
ele.rho = float(self.handles['rhoEle'].product()[0])
SCEta = abs(ele.sourcePtr().superCluster().eta())
if (abs(SCEta) >= 0.0 and abs(SCEta) < 1.0):
ele.EffectiveArea = 0.13 # 0.130;
if (abs(SCEta) >= 1.0 and abs(SCEta) < 1.479):
ele.EffectiveArea = 0.14 # 0.137;
if (abs(SCEta) >= 1.479 and abs(SCEta) < 2.0):
ele.EffectiveArea = 0.07 # 0.067;
if (abs(SCEta) >= 2.0 and abs(SCEta) < 2.2):
ele.EffectiveArea = 0.09 # 0.089;
if (abs(SCEta) >= 2.2 and abs(SCEta) < 2.3):
ele.EffectiveArea = 0.11 # 0.107;
if (abs(SCEta) >= 2.3 and abs(SCEta) < 2.4):
ele.EffectiveArea = 0.11 # 0.110;
if (abs(SCEta) >= 2.4): ele.EffectiveArea = 0.14 # 0.138;
if self.cfg_ana.doElectronScaleCorrections:
for ele in allelectrons:
self.electronEnergyCalibrator.correct(ele, event.run)
muForEleCrossCleaning = []
if self.cfg_ana.doEleMuCrossCleaning:
for mu in event.selectedLeptons + event.looseLeptons:
if abs(mu.pdgId()) == 13 and (
mu.isGlobal()
or mu.sourcePtr().userFloat("isPFMuon") > 0.5):
muForEleCrossCleaning.append(mu)
for ele in allelectrons:
ele.associatedVertex = event.goodVertices[0]
## remove muons if muForEleCrossCleaning is not empty
if bestMatch(ele, muForEleCrossCleaning)[1] < 0.02: continue
## fill POG MVA tight Id
ele.tightIdResult = False
if ele.pt() > 7 and abs(ele.eta()) < 2.5 and abs(
ele.dxy()) < 0.5 and abs(
ele.dz()) < 1. and ele.numberOfHits() <= 1:
## fill tightId:
if (ele.pt() > 20):
SCEta = abs(ele.sourcePtr().superCluster().eta())
if SCEta < 0.8:
ele.tightIdResult = (ele.mvaTrigV0() > 0.00)
elif SCEta < 1.479:
ele.tightIdResult = (ele.mvaTrigV0() > 0.10)
else:
ele.tightIdResult = (ele.mvaTrigV0() > 0.62)
elif (ele.pt() > 10):
if SCEta < 0.8:
ele.tightIdResult = (ele.mvaTrigV0() > 0.94)
elif SCEta < 1.479:
ele.tightIdResult = (ele.mvaTrigV0() > 0.85)
else:
ele.tightIdResult = (ele.mvaTrigV0() > 0.92)
# Compute isolation
ele.relIso03 = (ele.chargedHadronIso(0.3) + max(
ele.neutralHadronIso(0.3) + ele.photonIso(0.3) -
ele.rho * ele.EffectiveArea, 0)) / ele.pt()
# Compute electron id
dEtaIn = abs(ele.sourcePtr().deltaEtaSuperClusterTrackAtVtx())
dPhiIn = abs(ele.sourcePtr().deltaPhiSuperClusterTrackAtVtx())
sigmaIEtaIEta = abs(ele.sourcePtr().sigmaIetaIeta())
hoe = abs(ele.sourcePtr().hadronicOverEm())
ooemoop = abs(1.0 / ele.sourcePtr().ecalEnergy() -
ele.sourcePtr().eSuperClusterOverP() /
ele.sourcePtr().ecalEnergy())
vtxFitConversion = ele.passConversionVeto()
mHits = ele.numberOfHits()
# Set tight and loose flags
if abs(ele.sourcePtr().superCluster().eta()) < 1.479:
ele.looseFakeId = dEtaIn < 0.004 and dPhiIn < 0.06 and sigmaIEtaIEta < 0.01 and hoe < 0.12 and ooemoop < 0.05
else:
ele.looseFakeId = dEtaIn < 0.007 and dPhiIn < 0.03 and sigmaIEtaIEta < 0.03 and hoe < 0.10 and ooemoop < 0.05
ele.looseFakeId = ele.looseFakeId and vtxFitConversion and mHits <= 1 and abs(
ele.dz()) < 0.1 and ele.relIso03 < 0.6
ele.looseFakeId = ele.looseFakeId and mHits <= 1 and ele.sourcePtr(
).isGsfCtfScPixChargeConsistent()
ele.tightFakeId = ele.looseFakeId and abs(
ele.dxy()) < 0.02 and ele.relIso03 < 0.15
#print "ele pt = %.3f eta = %.3f sceta = %.3f detaIn = %.4f dphiIn = %.4f sieie = %.4f h/e = %.4f 1/e-1/p = %.4f dxy = %.4f dz = %.4f losthits = %d conveto = %d relIso = %.4f loose id = %d tight id = %d" % ( ele.pt(),ele.eta(),ele.sourcePtr().superCluster().eta(),dEtaIn,dPhiIn,sigmaIEtaIEta,hoe,ooemoop,abs(ele.dxy()),abs(ele.dz()),mHits,vtxFitConversion,ele.relIso03, ele.looseFakeId, ele.tightFakeId)
# add to the list if needed
if ele.pt() > 7 and abs(ele.eta()) < 2.5:
if ele.looseFakeId:
event.inclusiveLeptons.append(ele)
event.selectedLeptons.append(ele)
event.looseLeptons.sort(key=lambda l: l.pt(), reverse=True)
event.selectedLeptons.sort(key=lambda l: l.pt(), reverse=True)
event.inclusiveLeptons.sort(key=lambda l: l.pt(), reverse=True)
for lepton in event.selectedLeptons:
if hasattr(self, 'efficiency'):
self.efficiency.attachToObject(lepton)
def selectionSequence(self, event, fillCounter):
if fillCounter: self.counters.counter('WAna').inc('W all events')
if self.cfg_comp.isMC :
if (hasattr(self.cfg_ana,'storeLHE_weight') and self.cfg_ana.storeLHE_weight):
# print event.LHEweights.comments_size()
for i in range(0,event.LHEweights.comments_size()):
# print 'i',i,event.LHEweights.getComment(i).split()[0]
if not "rwgt" in event.LHEweights.getComment(i).split()[0]:
event.LHE_weights.append(float(event.LHEweights.getComment(i).split()[1])/float(event.LHEweights.getComment(206).split()[1])) # CHECK THE 216 FOR THE SAMPLE IN USE !!!
# print len(event.LHE_weights)-1, event.LHEweights.getComment(i).split()[0], float(event.LHEweights.getComment(i).split()[1])/float(event.LHEweights.getComment(206).split()[1]), event.LHEweights.getComment(i).split()[2], event.LHEweights.getComment(i).split()[3], event.LHEweights.getComment(i).split()[4], event.LHEweights.getComment(i).split()[5]
# print len(event.LHE_weights)
##------------------------ Initial declaration of vectors --------------------------------------
event.allMuonsTrgBit=[]
# retrieve collections of interest (muons and jets)
event.allMuons = copy.copy(event.muons)
for i in range(0,len(event.allMuons)):
event.allMuonsTrgBit.append(0)
event.selMuons = []
event.NoTriggeredMuonsLeadingPt = copy.copy(event.muons)
event.allJets = copy.copy(event.jets)
event.selJets = copy.copy(event.jets)
event.selJets = [ jet for jet in event.allJets if ( \
not (bestMatch( jet , event.muons ))[1] <0.5 \
and jet.looseJetId() and jet.pt()>30 \
)
]
##------------------------ HERE MC related stuff --------------------------------------
# check if the event is MC and if genp must be saved
event.savegenpW=False
# for genp in event.genParticles:
# if math.fabs(genp.pdgId())==24 and genp.numberOfDaughters()>1:
# print 'genp.pdgId()=',genp.pdgId(), 'genp.status()=',genp.status(), 'genp.numberOfDaughters()=',genp.numberOfDaughters()
# if(genp.numberOfDaughters()>0):
# print 'genp.daughter(0)',genp.daughter(0).pdgId(),'status',genp.daughter(0).status()
# if(genp.numberOfDaughters()>1):
# print 'genp.daughter(1)',genp.daughter(1).pdgId(),'status',genp.daughter(1).status()
# return False
# save genp only for signal events
# i.e. only one W is present and daughters are muon plus neutrino
genW_dummy = [ genp for genp in event.genParticles if \
(math.fabs(genp.pdgId())==24 and (self.cfg_ana.doMad or genp.status()==62))if \
(( genp.numberOfDaughters()>1 and (\
math.fabs(genp.daughter(0).pdgId())==11 or
math.fabs(genp.daughter(1).pdgId())==11 or
math.fabs(genp.daughter(0).pdgId())==13 or
math.fabs(genp.daughter(1).pdgId())==13 or
math.fabs(genp.daughter(0).pdgId())==15 or
math.fabs(genp.daughter(1).pdgId())==15
) ) or (genp.numberOfDaughters()==1 and \
math.fabs(genp.daughter(0).pdgId())==13
) ) ]
# if the genp event is selected, associate gen muon and neutrino
event.genMu = []
event.genMuStatus1 = []
event.genNu = []
event.genNu_p4 = []
event.genWLept = []
if self.cfg_ana.savegenp and self.cfg_comp.isMC:
if len(genW_dummy)==1:
event.genW = [ genp for genp in genW_dummy if \
( \
( math.fabs(genW_dummy[0].daughter(0).pdgId())==13 ) or \
( genW_dummy[0].numberOfDaughters()>1 and math.fabs(genW_dummy[0].daughter(1).pdgId())==13 ) \
) ]
if len(event.genW)==1:
event.savegenpW=True
event.genNu_p4 = genW_dummy[0].p4() - event.genW[0].daughter(0).p4()
event.genWLept.append(event.genW[0])
if [ math.fabs(event.genW[0].daughter(0).pdgId())==13 ]:
event.genMu.append(event.genW[0].daughter(0))
if event.genW[0].numberOfDaughters()>1:
event.genNu.append(event.genW[0].daughter(1))
elif event.genW[0].numberOfDaughters()>1:
event.genMu.append(event.genW[0].daughter(1))
event.genNu.append(event.genW[0].daughter(0))
if(len(event.genMu) >0):
if(math.fabs(event.genW[0].mother(0).pdgId())!=6):
event.genMuStatus1.append(returnMuonDaughterStatus1(self,event.genMu[0]))
else:
event.genMuStatus1.append(event.genMu[0])
if event.genW[0].numberOfDaughters()>1:
event.genW_mt = mT(self,event.genW[0].daughter(0).p4() , event.genW[0].daughter(1).p4())
else:
event.genW_mt = mT(self,event.genW[0].daughter(0).p4() , event.genNu_p4)
event.muGenDeltaRgenP=1e6
# if len(genW_dummy)>1:
# event.genW = [ genp for genp in genW_dummy if \
# ( \
# ( math.fabs(genW_dummy[0].daughter(0).pdgId())==11 ) or \
# ( math.fabs(genW_dummy[0].daughter(1).pdgId())==11 ) or \
# ( math.fabs(genW_dummy[0].daughter(0).pdgId())==13 ) or \
# ( math.fabs(genW_dummy[0].daughter(1).pdgId())==13 ) or \
# ( math.fabs(genW_dummy[0].daughter(0).pdgId())==15 ) or \
# ( math.fabs(genW_dummy[0].daughter(1).pdgId())==15 ) or \
# ( math.fabs(genW_dummy[1].daughter(0).pdgId())==11 ) or \
# ( math.fabs(genW_dummy[1].daughter(1).pdgId())==11 ) or \
# ( math.fabs(genW_dummy[1].daughter(0).pdgId())==13 ) or \
# ( math.fabs(genW_dummy[1].daughter(1).pdgId())==13 ) or \
# ( math.fabs(genW_dummy[1].daughter(0).pdgId())==15 ) or \
# ( math.fabs(genW_dummy[1].daughter(1).pdgId())==15 ) \
# ) ]
# if len(event.genW)==2:
# if ( math.fabs(event.genW[0].daughter(0).pdgId())==13. or math.fabs(event.genW[0].daughter(0).pdgId())==15. or math.fabs(event.genW[0].daughter(0).pdgId())==11. ):
# # print 'event.savegenpW 2 ',event.savegenpW
# event.savegenpW=False
# # print 'found leptonic W0 a'
# event.genWLept.append(event.genW[0])
# if ( math.fabs(event.genW[0].daughter(0).pdgId())==13 ):
# event.genMu.append(event.genW[0].daughter(0))
# event.genNu.append(event.genW[0].daughter(1))
# event.genW_mt = mT(self,event.genMu[0].p4() , event.genNu[0].p4())
# event.muGenDeltaRgenP=1e6
# if(len(event.genMu) >0):
# event.genMuStatus1.append(returnMuonDaughterStatus1(self,event.genMu[0]))
# event.savegenpW=True
# if ( math.fabs(event.genW[0].daughter(1).pdgId())==13. or math.fabs(event.genW[0].daughter(1).pdgId())==15. or math.fabs(event.genW[0].daughter(1).pdgId())==11. ):
# # print 'event.savegenpW 3 ',event.savegenpW
# event.savegenpW=False
# # print 'found leptonic W0 b'
# event.genWLept.append(event.genW[0])
# if ( math.fabs(event.genW[0].daughter(1).pdgId())==13 ):
# event.genMu.append(event.genW[0].daughter(1))
# event.genNu.append(event.genW[0].daughter(0))
# event.genW_mt = mT(self,event.genMu[0].p4() , event.genNu[0].p4())
# event.muGenDeltaRgenP=1e6
# if(len(event.genMu) >0):
# event.genMuStatus1.append(returnMuonDaughterStatus1(self,event.genMu[0]))
# # print 'event.savegenpW 4 ',event.savegenpW
# event.savegenpW=True
# if ( math.fabs(event.genW[1].daughter(0).pdgId())==13. or math.fabs(event.genW[1].daughter(0).pdgId())==15. or math.fabs(event.genW[1].daughter(0).pdgId())==11. ):
# # print 'event.savegenpW 5 ',event.savegenpW
# event.savegenpW=False
# # print 'found leptonic W1 c'
# event.genWLept.append(event.genW[1])
# if ( math.fabs(event.genW[1].daughter(0).pdgId())==13 ):
# event.genMu.append(event.genW[1].daughter(0))
# event.genNu.append(event.genW[1].daughter(1))
# event.genW_mt = mT(self,event.genMu[0].p4() , event.genNu[0].p4())
# event.muGenDeltaRgenP=1e6
# if(len(event.genMu) >0):
# event.genMuStatus1.append(returnMuonDaughterStatus1(self,event.genMu[0]))
# event.savegenpW=True
# if ( math.fabs(event.genW[1].daughter(1).pdgId())==13. or math.fabs(event.genW[1].daughter(1).pdgId())==15. or math.fabs(event.genW[1].daughter(1).pdgId())==11. ):
# # print 'event.savegenpW 6 ',event.savegenpW
# event.savegenpW=False
# # print 'found leptonic W1 d'
# event.genWLept.append(event.genW[1])
# if ( math.fabs(event.genW[1].daughter(1).pdgId())==13 ):
# event.genMu.append(event.genW[1].daughter(1))
# event.genNu.append(event.genW[1].daughter(0))
# event.genW_mt = mT(self,event.genMu[0].p4() , event.genNu[0].p4())
# event.muGenDeltaRgenP=1e6
# if(len(event.genMu) >0):
# event.genMuStatus1.append(returnMuonDaughterStatus1(self,event.genMu[0]))
# event.savegenpW=True
# if the genp is not signal, don't save genp but do not exit
# -----> events which will pass the reconstruction but are not signal
# can be considered as background (for example, in W+Jets, from W decaying into electrons, taus)
# else:
# ## here put false for fully hadronic WW
# print 'event.savegenpW 7 ',event.savegenpW
# event.savegenpW=False
# print 'genW found ', len(genW_dummy)
# print 'genWLeptonic found ', len(event.genWLept)
##------------------------ HERE THERE is the selection --------------------------------------
keepFailingEvents = True
if not hasattr(self.cfg_ana,'keepFailingEvents') \
or (hasattr(self.cfg_ana,'keepFailingEvents') and not self.cfg_ana.keepFailingEvents):
keepFailingEvents = False
# print 'keepFailingEvents',keepFailingEvents
# if not (event.passedVertexAnalyzer and event.passedTriggerAnalyzer):
##------------
# reco events must have good reco vertex
# if not (event.passedVertexAnalyzer):
if (not event.passedVertexAnalyzer) or (event.vertices[0] != event.goodVertices[0]):
return keepFailingEvents
##------------
# ...and at lest one reco muon...
if len(event.muons) == 0:
return keepFailingEvents
if fillCounter: self.counters.counter('WAna').inc('W ev trig, good vertex and >= 1 lepton')
#check if the event is triggered according to cfg_ana
if hasattr(self.cfg_ana, 'triggerBits'):
for imu in range(0,len(event.allMuons)):
for T, TL in self.cfg_ana.triggerBits.iteritems():
# muon object trigger matching
if trigMatched(self, event, event.allMuons[imu], TL):
# print event.allMuons[imu].pt(), event.allMuons[imu].eta(), TL
event.allMuonsTrgBit[imu]=1
# continue
if(event.allMuonsTrgBit[imu]==1): event.selMuons.append(event.allMuons[imu])
# for T, TL in self.cfg_ana.triggerBits.iteritems():
# # muon object trigger matching
# event.selMuons = [lep for lep in event.allMuons if \
# trigMatched(self, event, lep, TL)]
# print 'len(event.selMuons) = ',len(event.selMuons)
# for i in range(0,len(event.selMuons)):
# print i,event.selMuons[i].pt(), event.selMuons[i].eta()
# exit if there are no triggered muons
##------------
# reco events must have trigger fired...
if len(event.selMuons) == 0:
return keepFailingEvents, 'trigger matching failed'
else:
if fillCounter: self.counters.counter('WAna').inc('W at least 1 lep trig matched')
##------------
# to select W impose only 1 triggering lepton in the event:
# the number of triggering lepton is checked on the whole lepton collection
# before any cut, otherwise could be a Z!!!
if len(event.selMuons) != 1:
return keepFailingEvents, 'more than 1 lep trig matched'
else:
if fillCounter: self.counters.counter('WAna').inc('W only 1 lep trig matched')
if len(event.selMuons)!= 1: print 'BUT CONTINUING!'
# print len(event.selMuons), event.selMuons[0].pt()
if not (event.selMuons[0].pt()>0): return keepFailingEvents
# store muons that did not fire the trigger
if hasattr(self.cfg_ana, 'triggerBits'):
for T, TL in self.cfg_ana.triggerBits.iteritems():
event.NoTriggeredMuonsLeadingPt = [lep for lep in event.allMuons if \
(not trigMatched(self, event, lep, TL) \
and lep.pt()>10)]
# print "len(event.NoTriggeredMuonsLeadingPt)= ",len(event.NoTriggeredMuonsLeadingPt)
# if len(event.NoTriggeredMuonsLeadingPt)>0 : print "event.NoTriggeredMuonsLeadingPt[0].pt() = ",event.NoTriggeredMuonsLeadingPt[0].pt()
if len(event.NoTriggeredMuonsLeadingPt) > 0:
if event.NoTriggeredMuonsLeadingPt[0].pt()>10:
# if (event.NoTriggeredMuonsLeadingPt[0].pt()<10): print "ESISTE UN LEPTONE NON TRIGGERING WITH PT>10, event.NoTriggeredMuonsLeadingPt[0].pt() = ",event.NoTriggeredMuonsLeadingPt[0].pt()
return keepFailingEvents, 'rejecting event with non triggering lepton with pT > 10 GeV'
else:
if fillCounter: self.counters.counter('WAna').inc('W non trg leading lepton pT < 10 GeV')
else:
if fillCounter: self.counters.counter('WAna').inc('W non trg leading lepton pT < 10 GeV')
##------------------------ MAKE THE MUON --------------------------------------
# if the genp are saved, compute dR between gen and reco muon
if (event.savegenpW and len(event.genW)==1):
event.muGenDeltaRgenP = deltaR( event.selMuons[0].eta(), event.selMuons[0].phi(), event.genMu[0].eta(), event.genMu[0].phi() )
# associate good vertex to muon to compute dxy
event.selMuons[0].associatedVertex = event.goodVertices[0]
# testing offline muon cuts (tight+iso, no kinematical cuts)
event.selMuonIsTightAndIso = testLeg(self, event.selMuons[0] )
event.selMuonIsTight = testLegID( self,event.selMuons[0] )
# define a W from lepton and MET
event.W4V = event.selMuons[0].p4() + event.pfmet.p4()
event.W4V_mt = mT(self,event.selMuons[0].p4() , event.pfmet.p4())
event.covMatrixMuon = []
RetrieveMuonMatrixIntoVector(self,event.selMuons[0],event.covMatrixMuon)
# print event.covMatrixMuon
##------------------------ MAKE THE JETS and RECOIL variables --------------------------------------
# Code to study the recoil (not very useful for W...)
metVect = event.pfmet.p4().Vect()
metVect.SetZ(0.) # use only transverse info
WVect = event.W4V.Vect()
WVect.SetZ(0.) # use only transverse info
recoilVect = - copy.deepcopy(metVect) ## FIXED (met sign inverted)
# recoilVect -= WVect
temp_recoil = event.selMuons[0].p4().Vect()
temp_recoil.SetZ(0.) # use only transverse info
recoilVect -= temp_recoil ## FIXED (subtract only lepton for consistent recoil definition)
uWVect = WVect.Unit()
zAxis = type(WVect)(0,0,1)
uWVectPerp = WVect.Cross(zAxis).Unit()
u1 = recoilVect.Dot(uWVect) # recoil parallel to W pt
u2 = - recoilVect.Dot(uWVectPerp) # recoil perpendicular to W pt
event.u1 = u1
event.u2 = u2
##------------------------ FINAL COUNTERS --------------------------------------
if fillCounter:
if event.selMuonIsTightAndIso :
self.counters.counter('WAna').inc('W lep is MuIsTightAndIso')
if testLegKine( self, event.selMuons[0] , 30 , 2.1 ) :
self.counters.counter('WAna').inc('W Mu_eta<2.1 && Mu_pt>30')
if event.pfmet.pt() >25:
self.counters.counter('WAna').inc('W pfmet>25')
if event.W4V.Pt() < 20:
self.counters.counter('WAna').inc('W pt<20')
if len(event.selJets) > 0:
if event.selJets[0].pt()<30:
self.counters.counter('WAna').inc('W Jet_leading_pt<30')
else:
self.counters.counter('WAna').inc('W Jet_leading_pt<30')
# event is fully considered as good
# if fillCounter: self.counters.counter('WAna').inc('W pass')
event.WGoodEvent = True
return (event.WGoodEvent or keepFailingEvents)
def process(self, iEvent, event):
self.readCollections(iEvent)
self.counters.counter('MMT').inc('all events')
event.muoncand = self.buildLooseLeptons (self.handles['muons' ].product(), event)
event.electroncand = self.buildLooseOtherLeptons(self.handles['electrons'].product(), event)
event.taucand = self.buildLooseTau (self.handles['taus' ].product(), event)
cmgJets = self.handles['jets'].product()
# fill the bjet collection
event.CSVjet = []
for cmgJet in cmgJets:
jet = Jet( cmgJet )
if self.testVetoBJet(jet):
event.CSVjet.append(jet)
# clean the electron collection from muons
event.electroncand, dummpy = cleanObjectCollection(event.electroncand,
masks = event.muoncand,
deltaRMin = 0.5)
# CSV veto
electroncand_removebjet = []
muoncand_removebjet = []
# clean the electrons from bjets
for ielectron in event.electroncand:
bm, dr2min = bestMatch(ielectron, event.CSVjet)
if dr2min > 0.25:
electroncand_removebjet.append(ielectron)
# clean the muons from bjets
for imuon in event.muoncand:
bm, dr2min = bestMatch(imuon, event.CSVjet)
if dr2min > 0.25:
muoncand_removebjet.append(imuon)
event.electroncand = electroncand_removebjet
event.muoncand = muoncand_removebjet
for ii in event.electroncand:
ii.flag_id = self.eid(ii)
ii.flag_iso = self.eiso(ii)
ii.trig_match = True # trigger matching temporarily disabled
for ii in event.muoncand:
ii.flag_id = self.muid(ii)
ii.flag_iso = self.muiso(ii)
ii.trig_match = True # trigger matching temporarily disabled
event.loosetau = []
for itau in event.taucand:
itau.decaymode = itau.decayMode()
itau.ep = itau.calcEOverP()
itau.flag_iso = self.tauiso(itau)
itau.flag_id = self.tauid(itau)
itau.againstERaw = itau.tauID('againstElectronMVA3raw')
itau.againstE2Raw = itau.tauID('againstElectronMVA2raw')
itau.againstE0Raw = itau.tauID('againstElectronMVA')
itau.againstECat = int(round(itau.tauID('againstElectronMVA3category')))
itau.againstE2Cat = int(round(itau.tauID('againstElectronMVA2category')))
itau.againstE0Cat = int(round(itau.tauID('againstElectronMVAcategory')))
itau.againstELooseArmin = itau.tauID("againstElectronLoose")
itau.againstETight = itau.tauID("againstElectronTightMVA3")
itau.againstELoose = itau.tauID("againstElectronLooseMVA3")
itau.againstEMedium = itau.tauID("againstElectronMediumMVA3")
itau.againstE2Loose = itau.tauID("againstElectronLooseMVA2")
itau.againstE2Medium = itau.tauID("againstElectronMediumMVA2")
itau.againstE0Loose = itau.tauID("againstElectronLooseMVA")
itau.againstE0Medium = itau.tauID("againstElectronMediumMVA")
itau.againstMuLoose = itau.tauID("againstMuonLoose")
itau.againstMuTight = itau.tauID("againstMuonTight")
itau.dBisolation = itau.tauID("byCombinedIsolationDeltaBetaCorrRaw3Hits")
itau.mvaisolation = itau.tauID("byRawIsoMVA")
itau.mvaisolation_loose = itau.tauID('byLooseIsoMVA')
event.loosetau.append(itau)
event.taucand = event.loosetau
# Additional tau veto
event.vetotaucand = self.buildVetoTau(self.handles['taus'].product(), event)
event.vetomuoncand = self.buildVetoLeptons(self.handles['muons'].product(), event)
event.vetoelectroncand = self.buildVetoOtherLeptons(self.handles['electrons'].product(), event)
flag_sscharge = False
for im in event.muoncand:
for ie in event.electroncand:
if im.charge()*ie.charge()==1:
flag_sscharge = True
self.counters.counter('MMT').inc('step1')
if flag_sscharge==False:
return False
self.counters.counter('MMT').inc('step2')
if not (len(event.muoncand)>=1 and len(event.electroncand)>=1):
return False
self.counters.counter('MMT').inc('step3')
print 'All events passed : ', event.run, event.lumi, event.eventId
return True
def makeLeptons(self, event):
### inclusive leptons = all leptons that could be considered somewhere in the analysis, with minimal requirements (used e.g. to match to MC)
event.inclusiveLeptons = []
### selected leptons = subset of inclusive leptons passing some basic id definition and pt requirement
### other leptons = subset of inclusive leptons failing some basic id definition and pt requirement
event.selectedLeptons = []
event.selectedMuons = []
event.selectedElectrons = []
event.otherLeptons = []
#muons
allmuons = self.makeAllMuons(event)
for mu in allmuons:
# inclusive, very loose, selection
if (mu.sourcePtr().track().isNonnull()
and mu.muonID(self.cfg_ana.inclusive_muon_id)
and mu.pt() > self.cfg_ana.inclusive_muon_pt
and abs(mu.eta()) < self.cfg_ana.inclusive_muon_eta
and abs(mu.dxy()) < self.cfg_ana.inclusive_muon_dxy
and abs(mu.dz()) < self.cfg_ana.inclusive_muon_dz):
event.inclusiveLeptons.append(mu)
# basic selection
if (mu.muonID(self.cfg_ana.loose_muon_id)
and mu.pt() > self.cfg_ana.loose_muon_pt
and abs(mu.eta()) < self.cfg_ana.loose_muon_eta
and abs(mu.dxy()) < self.cfg_ana.loose_muon_dxy
and abs(mu.dz()) < self.cfg_ana.loose_muon_dz
and mu.relIso03 < self.cfg_ana.loose_muon_relIso
and mu.absIso03 <
(self.cfg_ana.loose_muon_absIso if hasattr(
self.cfg_ana, 'loose_muon_absIso') else 9e99)):
mu.looseIdSusy = True
event.selectedLeptons.append(mu)
event.selectedMuons.append(mu)
else:
mu.looseIdSusy = False
event.otherLeptons.append(mu)
#electrons
allelectrons = self.makeAllElectrons(event)
looseMuons = event.selectedLeptons[:]
for ele in allelectrons:
## remove muons if muForEleCrossCleaning is not empty
## apply selection
if (ele.electronID(self.cfg_ana.inclusive_electron_id)
and ele.pt() > self.cfg_ana.inclusive_electron_pt
and abs(ele.eta()) < self.cfg_ana.inclusive_electron_eta
and abs(ele.dxy()) < self.cfg_ana.inclusive_electron_dxy
and abs(ele.dz()) < self.cfg_ana.inclusive_electron_dz
and ele.numberOfHits() <=
self.cfg_ana.inclusive_electron_lostHits):
event.inclusiveLeptons.append(ele)
# basic selection
if (ele.electronID(self.cfg_ana.loose_electron_id)
and ele.pt() > self.cfg_ana.loose_electron_pt
and abs(ele.eta()) < self.cfg_ana.loose_electron_eta
and abs(ele.dxy()) < self.cfg_ana.loose_electron_dxy
and abs(ele.dz()) < self.cfg_ana.loose_electron_dz
and ele.relIso03 <= self.cfg_ana.loose_electron_relIso
and ele.absIso03 <
(self.cfg_ana.loose_electron_absIso if hasattr(
self.cfg_ana, 'loose_electron_absIso') else 9e99)
and ele.numberOfHits() <=
self.cfg_ana.loose_electron_lostHits
and bestMatch(ele, looseMuons)[1] >
self.cfg_ana.min_dr_electron_muon):
event.selectedLeptons.append(ele)
event.selectedElectrons.append(ele)
ele.looseIdSusy = True
else:
event.otherLeptons.append(ele)
ele.looseIdSusy = False
event.otherLeptons.sort(key=lambda l: l.pt(), reverse=True)
event.selectedLeptons.sort(key=lambda l: l.pt(), reverse=True)
event.selectedMuons.sort(key=lambda l: l.pt(), reverse=True)
event.selectedElectrons.sort(key=lambda l: l.pt(), reverse=True)
event.inclusiveLeptons.sort(key=lambda l: l.pt(), reverse=True)
for lepton in event.selectedLeptons:
if hasattr(self, 'efficiency'):
self.efficiency.attachToObject(lepton)
def selectionSequence(self, event, fillCounter):
if fillCounter: self.counters.counter('WAna').inc('W all events')
# retrieve collections of interest (muons and jets)
event.allMuons = copy.copy(event.muons)
event.selMuons = copy.copy(event.muons)
event.NoTriggeredMuonsLeadingPt = copy.copy(event.muons)
event.allJets = copy.copy(event.jets)
event.selJets = copy.copy(event.jets)
# check if the event is MC and if genp must be saved
event.savegenpW = True
if not (self.cfg_ana.savegenp and self.cfg_comp.isMC):
event.savegenpW = False
# save genp only for signal events
# i.e. only one W is present and daughters are muon plus neutrino
genW_dummy = [ genp for genp in event.genParticles if \
math.fabs(genp.pdgId())==24 ]
if len(genW_dummy) == 1:
event.genW = [ genp for genp in genW_dummy if \
( \
( math.fabs(genW_dummy[0].daughter(0).pdgId())==13 ) or \
( math.fabs(genW_dummy[0].daughter(1).pdgId())==13 ) \
) ]
# if the genp event is selected, associate gen muon and neutrino
event.genMu = []
event.genMuStatus1 = []
event.genNu = []
if len(event.genW) == 1:
if [math.fabs(event.genW[0].daughter(0).pdgId()) == 13]:
event.genMu.append(event.genW[0].daughter(0))
event.genNu.append(event.genW[0].daughter(1))
else:
event.genMu.append(event.genW[0].daughter(1))
event.genNu.append(event.genW[0].daughter(0))
if (len(event.genMu) > 0):
event.genMuStatus1.append(
self.returnMuonDaughterStatus1(event.genMu[0]))
event.genW_mt = self.mT(event.genW[0].daughter(0).p4(),
event.genW[0].daughter(1).p4())
event.muGenDeltaRgenP = 1e6
else:
# if the genp is not signal, don't save genp but do not exit
# -----> events which will pass the reconstruction but are not signal
# can be considered as background (for example, in W+Jets, from W decaying into electrons, taus)
event.savegenpW = False
else:
event.savegenpW = False
# store event number of muons, MET and jets in all gen events (necessary to make cuts in genp studies...)
# total number of reco muons
event.nMuons = len(event.selMuons)
# clean jets by removing muons
event.selJets = [ jet for jet in event.allJets if ( \
not (bestMatch( jet , event.selMuons ))[1] <0.5 \
and jet.looseJetId() and jet.pt()>30 \
)
]
# reco events must have good reco vertex and trigger fired...
if not (event.passedVertexAnalyzer and event.passedTriggerAnalyzer):
return True
# ...and at lest one reco muon...
if len(event.selMuons) == 0:
return True
if fillCounter:
self.counters.counter('WAna').inc(
'W ev trig, good vertex and >= 1 lepton')
#check if the event is triggered according to cfg_ana
if len(self.cfg_comp.triggers) > 0:
# muon object trigger matching
event.selMuons = [lep for lep in event.allMuons if \
self.trigMatched(event, lep)]
# exit if there are no triggered muons
if len(event.selMuons) == 0:
return True, 'trigger matching failed'
else:
if fillCounter:
self.counters.counter('WAna').inc(
'W at least 1 lep trig matched')
# to select W impose only 1 triggering lepton in the event:
# the number of triggering lepton is checked on the whole lepton collection
# before any cut, otherwise could be a Z!!!
if len(event.selMuons) != 1:
return True, 'more than 1 lep trig matched'
else:
if fillCounter:
self.counters.counter('WAna').inc('W only 1 lep trig matched')
# store muons that did not fire the trigger
event.NoTriggeredMuonsLeadingPt = [lep for lep in event.allMuons if \
not self.trigMatched(event, lep) ]
# print "len(event.NoTriggeredMuonsLeadingPt)= ",len(event.NoTriggeredMuonsLeadingPt)
# if len(event.NoTriggeredMuonsLeadingPt)>0 : print "event.NoTriggeredMuonsLeadingPt[0].pt() = ",event.NoTriggeredMuonsLeadingPt[0].pt()
if len(event.NoTriggeredMuonsLeadingPt) > 0:
if event.NoTriggeredMuonsLeadingPt[0].pt() > 10:
# if (event.NoTriggeredMuonsLeadingPt[0].pt()<10): print "ESISTE UN LEPTONE NON TRIGGERING WITH PT>10, event.NoTriggeredMuonsLeadingPt[0].pt() = ",event.NoTriggeredMuonsLeadingPt[0].pt()
return True, 'rejecting event with non triggering lepton with pT > 10 GeV'
else:
if fillCounter:
self.counters.counter('WAna').inc(
'W non trg leading lepton pT < 10 GeV')
else:
if fillCounter:
self.counters.counter('WAna').inc(
'W non trg leading lepton pT < 10 GeV')
# if the genp are saved, compute dR between gen and reco muon
if event.savegenpW:
event.muGenDeltaRgenP = deltaR(event.selMuons[0].eta(),
event.selMuons[0].phi(),
event.genMu[0].eta(),
event.genMu[0].phi())
# associate good vertex to muon to compute dxy
event.selMuons[0].associatedVertex = event.goodVertices[0]
# testing offline muon cuts (tight+iso, no kinematical cuts)
event.selMuonIsTightAndIso = self.testLeg(event.selMuons[0])
event.selMuonIsTight = self.testLegID(event.selMuons[0])
# START RETRIEVING MVAMET
# INPUT DEFINITIONS AS OF HTT
# mvaMETTauMu = cms.EDProducer(
# "MVAMETProducerTauMu",
# pfmetSrc = cms.InputTag('pfMetForRegression'),
# tkmetSrc = cms.InputTag('tkMet'),
# nopumetSrc = cms.InputTag('nopuMet'),
# pucmetSrc = cms.InputTag('pcMet'),
# pumetSrc = cms.InputTag('puMet'),
# recBosonSrc = cms.InputTag('cmgTauMuSel'),
# jetSrc = cms.InputTag('cmgPFJetSel'),
# leadJetSrc = cms.InputTag('cmgPFBaseJetLead'),
# vertexSrc = cms.InputTag('goodPVFilter'),
# nJetsPtGt1Src = cms.InputTag('nJetsPtGt1'),
# rhoSrc = cms.InputTag('kt6PFJets','rho'),
# enable = cms.bool(True),
# verbose = cms.untracked.bool( False ),
# weights_gbrmet = cms.string(weights_gbrmet),
# weights_gbrmetphi = cms.string(weights_gbrmetphi),
# weights_gbrmetu1cov = cms.string(weights_gbrmetu1cov),
# weights_gbrmetu2cov = cms.string(weights_gbrmetu2cov),
# #COLIN: make delta R a parameter
# )
# self.prepareObjectsForMVAMET(event)
# self.mvamet.getMet(
# event.cleanpfmetForRegression, #iPFMet,
# event.cleantkmet, #iTKMet,
# event.cleannopumet, #iNoPUMet,
# event.pumet, #iPUMet,
# event.cleanpucmet, #iPUCMet,
# event.iLeadJet, #event.iLeadJet,
# event.i2ndJet, #event.i2ndJet,
# event.NJetsGt30, #iNJetsGt30,
# event.nJetsPtGt1Clean, #iNJetsGt1,
# len(event.goodVertices), #iNGoodVtx,
# event.iJets_p4, #iJets,
# event.iJets_mva, #iJets,
# event.iJets_neutFrac, #iJets,
# False, #iPrintDebug,
# event.visObjectP4s_array #visObjectP4s
# )
# event.mvamet = self.mvamet.GetMet_first();
# event.GetMVAMet_second = self.mvamet.GetMet_second();
# print 'AFTER MVAmet_test'
# print 'event.pfmet.pt() ', event.pfmet.pt()
# print 'event.selMuons[0].pt() ',event.selMuons[0].pt(),' event.mvamet.Pt() ',event.mvamet.Pt()
# print ''
# print 'event.GetMVAMet_second ',event.GetMVAMet_second,' event.GetMVAMet_second.significance() ',event.GetMVAMet_second.significance().Print()
# define a W from lepton and MET
event.W4V = event.selMuons[0].p4() + event.pfmet.p4()
event.W4V_mt = self.mT(event.selMuons[0].p4(), event.pfmet.p4())
# Code to study the recoil (not very useful for W...)
metVect = event.pfmet.p4().Vect()
metVect.SetZ(0.) # use only transverse info
WVect = event.W4V.Vect()
WVect.SetZ(0.) # use only transverse info
recoilVect = -copy.deepcopy(metVect) ## FIXED (met sign inverted)
# recoilVect -= WVect
temp_recoil = event.selMuons[0].p4().Vect()
temp_recoil.SetZ(0.) # use only transverse info
recoilVect -= temp_recoil ## FIXED (subtract only lepton for consistent recoil definition)
uWVect = WVect.Unit()
zAxis = type(WVect)(0, 0, 1)
uWVectPerp = WVect.Cross(zAxis).Unit()
u1 = recoilVect.Dot(uWVect) # recoil parallel to W pt
u2 = -recoilVect.Dot(uWVectPerp) # recoil perpendicular to W pt
event.u1 = u1
event.u2 = u2
if fillCounter:
if event.selMuonIsTightAndIso:
self.counters.counter('WAna').inc('W lep is MuIsTightAndIso')
if self.testLegKine(event.selMuons[0], 30, 2.1):
self.counters.counter('WAna').inc(
'W Mu_eta<2.1 && Mu_pt>30')
if event.pfmet.pt() > 25:
self.counters.counter('WAna').inc('W pfmet>25')
if event.W4V.Pt() < 20:
self.counters.counter('WAna').inc('W pt<20')
if len(event.selJets) > 0:
if event.selJets[0].pt() < 30:
self.counters.counter('WAna').inc(
'W Jet_leading_pt<30')
else:
self.counters.counter('WAna').inc(
'W Jet_leading_pt<30')
# event is fully considered as good
# if fillCounter: self.counters.counter('WAna').inc('W pass')
event.WGoodEvent = True
return True
def makeLeptons(self, event):
event.looseLeptons = []
event.selectedLeptons = []
#muons
allmuons = map(Muon, self.handles['muons'].product())
if self.cfg_ana.doRecomputeSIP3D:
for mu in allmuons:
if mu.sourcePtr().innerTrack().isNonnull():
## compute the variable and set it
mu._sip3d = abs(signedSip3D(mu, event.goodVertices[0]))
## attach it to the object redefining the sip3D() method
mu.sip3D = types.MethodType(lambda self: self._sip3d, mu,
mu.__class__)
if self.cfg_ana.doRochesterCorrections:
for mu in allmuons:
corp4 = rochcor.corrected_p4(mu, event.run)
mu.setP4(corp4)
if self.cfg_ana.doSegmentBasedMuonCleaning:
isgood = cmgMuonCleanerBySegments.clean(
self.handles['muons'].product())
newmu = []
for i, mu in enumerate(allmuons):
if isgood[i]: newmu.append(mu)
allmuons = newmu
for mu in allmuons:
mu.associatedVertex = event.goodVertices[0]
if (mu.isGlobal() or mu.isTracker() and mu.numberOfMatches() > 0
) and mu.pt() > 5 and abs(mu.eta()) < 2.4 and abs(
mu.dxy()) < 0.5 and abs(mu.dz()) < 1.:
if mu.sourcePtr().userFloat("isPFMuon") > 0.5 and (
self.relaxId or mu.sip3D() < 10) and mu.relIso(
dBetaFactor=0.5) < self.cfg_ana.isolationCut:
event.selectedLeptons.append(mu)
else:
event.looseLeptons.append(mu)
#electrons
allelectrons = map(Electron, self.handles['electrons'].product())
if self.cfg_ana.doRecomputeSIP3D:
for ele in allelectrons:
if ele.sourcePtr().gsfTrack().isNonnull():
## compute the variable and set it
ele._sip3d = abs(signedSip3D(ele, event.goodVertices[0]))
## attach it to the object redefining the sip3D() method
ele.sip3D = types.MethodType(lambda self: self._sip3d, ele,
ele.__class__)
for ele in allelectrons:
ele.rho = float(self.handles['rhoEle'].product()[0])
SCEta = abs(ele.sourcePtr().superCluster().eta())
if (abs(SCEta) >= 0.0 and abs(SCEta) < 1.0):
ele.EffectiveArea = 0.130
if (abs(SCEta) >= 1.0 and abs(SCEta) < 1.479):
ele.EffectiveArea = 0.137
if (abs(SCEta) >= 1.479 and abs(SCEta) < 2.0):
ele.EffectiveArea = 0.067
if (abs(SCEta) >= 2.0 and abs(SCEta) < 2.2):
ele.EffectiveArea = 0.089
if (abs(SCEta) >= 2.2 and abs(SCEta) < 2.3):
ele.EffectiveArea = 0.107
if (abs(SCEta) >= 2.3 and abs(SCEta) < 2.4):
ele.EffectiveArea = 0.110
if (abs(SCEta) >= 2.4): ele.EffectiveArea = 0.138
if self.cfg_ana.doElectronScaleCorrections:
for ele in allelectrons:
calibratedPatEle = ele.sourcePtr().get()
self.electronEnergyCalibrator.correctLite(
calibratedPatEle, calibratedPatEle.r9(), event.run)
ele.setP4(calibratedPatEle.p4(calibratedPatEle.P4_COMBINATION))
muForEleCrossCleaning = []
if self.cfg_ana.doEleMuCrossCleaning:
for mu in event.selectedLeptons + event.looseLeptons:
if abs(mu.pdgId()) == 13 and (
mu.isGlobal()
or mu.sourcePtr().userFloat("isPFMuon") > 0.5):
muForEleCrossCleaning.append(mu)
for ele in allelectrons:
ele.associatedVertex = event.goodVertices[0]
## remove muons if muForEleCrossCleaning is not empty
if bestMatch(ele, muForEleCrossCleaning)[1] < 0.02: continue
## apply selection
if ele.pt() > 7 and abs(ele.eta()) < 2.5 and abs(
ele.dxy()) < 0.5 and abs(
ele.dz()) < 1. and ele.numberOfHits() <= 1:
if (self.relaxId
or ele.mvaIDZZ() and ele.sip3D() < 10) and ele.relIso(
dBetaFactor=0.5) < self.cfg_ana.isolationCut:
event.selectedLeptons.append(ele)
else:
event.looseLeptons.append(ele)
event.looseLeptons.sort(key=lambda l: l.pt(), reverse=True)
event.selectedLeptons.sort(key=lambda l: l.pt(), reverse=True)
for lepton in event.selectedLeptons:
if hasattr(self, 'efficiency'):
self.efficiency.attachToObject(lepton)
def match(jet, objects, name):
bm, dr2 = bestMatch(jet, objects)
if bm:
bm.dr = math.sqrt(dr2)
setattr(jet, name, bm)
def process(self, iEvent, event):
scale=1.0
def fill( varName, value ):
setattr( self.tree.s, varName, value )
def fParticleVars( pName, particle ):
fill('{pName}Px'.format(pName=pName) , particle.px()*scale )
fill('{pName}Py'.format(pName=pName) , particle.py()*scale )
fill('{pName}Pz'.format(pName=pName) , particle.pz()*scale )
fill('{pName}E'.format(pName=pName) , particle.energy()*scale )
fill('{pName}Pt'.format(pName=pName) , particle.pt()*scale )
fill('{pName}Eta'.format(pName=pName) , particle.eta() )
fill('{pName}Phi'.format(pName=pName) , particle.phi() )
fill('{pName}Charge'.format(pName=pName), particle.charge() )
fill('{pName}Mass'.format(pName=pName) , particle.mass()*scale )
if hasattr(event,"run"):
fill('run', event.run)
if hasattr(event,"lumi"):
fill('lumi', event.lumi)
if hasattr(event,"eventId"):
fill('event', event.eventId)
fill('visMass' , event.diLepton.mass()*scale)
fill('svfitMass', event.diLepton.massSVFit()*scale)
### import pdb ; pdb.set_trace() ## SVFit pT is missingin tautau cmgtuples
### need to hack http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/UserCode/CMG/CMGTools/H2TauTau/interface/DiTauWithSVFitProducer.h?revision=1.11&view=markup
#fill('svfitPt' , event.diLepton.massSVFit()*scale)
fill('mt1' , event.diLepton.mTLeg1()*scale)
fill('mt2' , event.diLepton.mTLeg2()*scale)
fill('pThiggs' , sqrt(pow(event.diLepton.met().px()+event.diLepton.leg1().px()+event.diLepton.leg2().px(),2)+pow(event.diLepton.met().py()+event.diLepton.leg1().py()+event.diLepton.leg2().py(),2))*scale)
#mvametsig = event.diLepton.mvaMetSig.significance()
#fill( tr, 'mvacov00', mvametsig(0,0))
#fill( tr, 'mvacov01', mvametsig(0,1))
#fill( tr, 'mvacov10', mvametsig(1,0))
#fill( tr, 'mvacov11', mvametsig(1,1))
fill('metPhi', event.diLepton.met().phi()*scale)
fill('mex' , event.diLepton.met().px()*scale)
fill('mey' , event.diLepton.met().py()*scale)
fill('met' , event.diLepton.met().pt()*scale)
fill('rawMET', event.rawMET[0].pt())
fill('dRtt' , sqrt(pow(deltaPhi(event.diLepton.leg1().phi(),event.diLepton.leg2().phi()),2)+pow(fabs(event.diLepton.leg1().eta()-event.diLepton.leg2().eta()),2)))
fill('dPhitt', deltaPhi(event.diLepton.leg1().phi(),event.diLepton.leg2().phi()))
fill('dEtatt', fabs(event.diLepton.leg1().eta()-event.diLepton.leg2().eta()))
fParticleVars('diTau', event.diLepton)
leg1=event.diLepton.leg1()
leg2=event.diLepton.leg2()
fParticleVars('l1', leg1 )
fParticleVars('l2', leg2 )
l1jet = bestMatch( leg1, event.jets )[0]
l2jet = bestMatch( leg2, event.jets )[0]
fill('l1DecayMode', leg1.decayMode() )
fill('l1LooIso' , leg1.tauID("byLooseCombinedIsolationDeltaBetaCorr") )
fill('l1MedIso' , leg1.tauID("byMediumCombinedIsolationDeltaBetaCorr") )
fill('l1TigIso' , leg1.tauID("byTightCombinedIsolationDeltaBetaCorr") )
fill('l1RawMVAIso' , leg1.tauID("byRawIsoMVA") )
fill('l1RawMVA2Iso', leg1.tauID("byIsolationMVA2raw") )
fill('l1RawDB3HIso', leg1.tauID("byCombinedIsolationDeltaBetaCorrRaw3Hits") )
fill('l1MedMVAIso' , leg1.tauID("byMediumIsoMVA") )
fill('l1TigMVAIso' , leg1.tauID("byTightIsoMVA") )
fill('l1LooseDB3HIso' , leg1.tauID("byLooseCombinedIsolationDeltaBetaCorr3Hits"))
fill('l1MediumDB3HIso', leg1.tauID("byMediumCombinedIsolationDeltaBetaCorr3Hits"))
fill('l1TightDB3HIso' , leg1.tauID("byTightCombinedIsolationDeltaBetaCorr3Hits"))
fill('l1LooseEle' , leg1.tauID("againstElectronLoose") )
fill('l1MedEle' , leg1.tauID("againstElectronMedium") )
fill('l1MVAEle' , leg1.tauID("againstElectronMVA") )
fill('l1LooseMu' , leg1.tauID("againstMuonLoose2") )
fill('l1jetMass' , leg1.jetRefp4().mass() )
fill('l1jetPt' , leg1.jetRefp4().pt() )
if l1jet:
fill('l1jetWidth', l1jet.rms() )
fill('l1jetBtag' , l1jet.btag("combinedSecondaryVertexBJetTags") )
fill('l1againstElectronMVA3raw' , leg1.tauID("againstElectronMVA3raw"))
fill('l1againstElectronLooseMVA3' , leg1.tauID("againstElectronLooseMVA3"))
fill('l1againstElectronMediumMVA3', leg1.tauID("againstElectronMediumMVA3"))
fill('l1againstElectronTightMVA3' , leg1.tauID("againstElectronTightMVA3"))
fill('l1againstElectronVTightMVA3', leg1.tauID("againstElectronVTightMVA3"))
fill('l1againstMuonLoose2' , leg1.tauID("againstMuonLoose2"))
fill('l1againstMuonMedium2' , leg1.tauID("againstMuonMedium2"))
fill('l1againstMuonTight2' , leg1.tauID("againstMuonTight2"))
# import pdb ; pdb.set_trace()
fill('l2DecayMode', leg2.decayMode() )
fill('l2LooIso' , leg2.tauID("byLooseCombinedIsolationDeltaBetaCorr") )
fill('l2MedIso' , leg2.tauID("byMediumCombinedIsolationDeltaBetaCorr") )
fill('l2TigIso' , leg2.tauID("byTightCombinedIsolationDeltaBetaCorr") )
fill('l2RawMVAIso' , leg2.tauID("byRawIsoMVA") )
fill('l2RawMVA2Iso' , leg2.tauID("byIsolationMVA2raw") )
fill('l2RawDB3HIso' , leg2.tauID("byCombinedIsolationDeltaBetaCorrRaw3Hits") )
fill('l2MedMVAIso' , leg2.tauID("byMediumIsoMVA") )
fill('l2TigMVAIso' , leg2.tauID("byTightIsoMVA") )
fill('l2LooseDB3HIso' , leg2.tauID("byLooseCombinedIsolationDeltaBetaCorr3Hits"))
fill('l2MediumDB3HIso', leg2.tauID("byMediumCombinedIsolationDeltaBetaCorr3Hits"))
fill('l2TightDB3HIso' , leg2.tauID("byTightCombinedIsolationDeltaBetaCorr3Hits"))
fill('l2LooseEle', leg2.tauID("againstElectronLoose") )
fill('l2MedEle' , leg2.tauID("againstElectronMedium") )
fill('l2MVAEle' , leg2.tauID("againstElectronMVA") )
fill('l2LooseMu' , leg2.tauID("againstMuonLoose2") )
fill('l2jetMass' , leg2.jetRefp4().mass() )
fill('l2jetPt' , leg2.jetRefp4().pt() )
if l2jet:
fill('l2jetWidth', l2jet.rms() )
fill('l2jetBtag' , l1jet.btag("combinedSecondaryVertexBJetTags") )
fill('l2againstElectronMVA3raw' , leg2.tauID("againstElectronMVA3raw"))
fill('l2againstElectronLooseMVA3' , leg2.tauID("againstElectronLooseMVA3"))
fill('l2againstElectronMediumMVA3', leg2.tauID("againstElectronMediumMVA3"))
fill('l2againstElectronTightMVA3' , leg2.tauID("againstElectronTightMVA3"))
fill('l2againstElectronVTightMVA3', leg2.tauID("againstElectronVTightMVA3"))
fill('l2againstMuonLoose2' , leg2.tauID("againstMuonLoose2"))
fill('l2againstMuonMedium2' , leg2.tauID("againstMuonMedium2"))
fill('l2againstMuonTight2' , leg2.tauID("againstMuonTight2"))
fill('l1VertexZ', leg1.tau.vz() )
fill('l2VertexZ', leg2.tau.vz() )
if hasattr(event,"leg1DeltaR"):
fill('l1match', event.leg1DeltaR )
fill('l2match', event.leg2DeltaR )
else:
fill('l1match', -1 )
fill('l2match', -1 )
if hasattr(event,"genMass"):
fill('genMass', event.genMass )
# from ROOT import TFile,TH1F
# f = TFile("/afs/cern.ch/user/h/hinzmann/workspace/stable2012/CMGTools/CMSSW_5_2_5/src/CMGTools/H2TauTau/python/proto/embeddedWeights.root")
# hEmbed = f.Get("hemb")
# shift=hEmbed.GetRandom()/event.genMass
# fill('genMassSmeared', event.genMass*shift )
# fill('svfitMassSmeared', event.diLepton.massSVFit()*scale*shift )
else:
fill('genMass' , -1 )
fill('genMassSmeared' , -1 )
fill('svfitMassSmeared', -1 )
if hasattr(event,"l1TrigMatched"):
fill('l1TrigMatched', event.l1TrigMatched )
else:
fill('l1TrigMatched', -1 )
if hasattr(event,"l2TrigMatched"):
fill('l2TrigMatched', event.l2TrigMatched )
else:
fill('l2TrigMatched', -1 )
if hasattr(event,"jetTrigMatched"):
fill('jetTrigMatched', event.jetTrigMatched )
else:
fill('jetTrigMatched', -1 )
#if event.diLepton.leg1().genTaup4() and event.diLepton.leg2().genTaup4():
# fill('genTauVisMass', sqrt(
# pow(event.diLepton.leg1().genTaup4().energy()+event.diLepton.leg2().genTaup4().energy(),2)
# -pow(event.diLepton.leg1().genTaup4().px()+event.diLepton.leg2().genTaup4().px(),2)
# -pow(event.diLepton.leg1().genTaup4().py()+event.diLepton.leg2().genTaup4().py(),2)
# -pow(event.diLepton.leg1().genTaup4().pz()+event.diLepton.leg2().genTaup4().pz(),2)
# ))
#if event.diLepton.leg1().genJetp4() and event.diLepton.leg2().genJetp4():
# fill('genJetVisMass', sqrt(
# pow(event.diLepton.leg1().genJetp4().energy()+event.diLepton.leg2().genJetp4().energy(),2)
# -pow(event.diLepton.leg1().genJetp4().px()+event.diLepton.leg2().genJetp4().px(),2)
# -pow(event.diLepton.leg1().genJetp4().py()+event.diLepton.leg2().genJetp4().py(),2)
# -pow(event.diLepton.leg1().genJetp4().pz()+event.diLepton.leg2().genJetp4().pz(),2)
# ))
nJets = len(event.cleanJets)
fill('nJets', nJets )
if nJets>=1:
fParticleVars('jet1', event.cleanJets[0] )
fill('jet1Btag' , event.cleanJets[0].btag("combinedSecondaryVertexBJetTags") )
fill('jet1Bmatch' , event.cleanJets[0].matchGenParton )
fill('mttj' , sqrt(pow(event.diLepton.energy()+event.cleanJets[0].energy(),2) - pow(event.diLepton.px()+event.cleanJets[0].px(),2) - pow(event.diLepton.py()+event.cleanJets[0].py(),2) - pow(event.diLepton.pz()+event.cleanJets[0].pz(),2)))
fill('l1JetInvMass' , sqrt(pow(leg1.energy()+event.cleanJets[0].energy(),2) - pow(leg1.px()+event.cleanJets[0].px(),2) - pow(leg1.py()+event.cleanJets[0].py(),2) - pow(leg1.pz()+event.cleanJets[0].pz(),2)))
fill('l2JetInvMass' , sqrt(pow(leg2.energy()+event.cleanJets[0].energy(),2) - pow(leg2.px()+event.cleanJets[0].px(),2) - pow(leg2.py()+event.cleanJets[0].py(),2) - pow(leg2.pz()+event.cleanJets[0].pz(),2)))
if nJets>=2:
fParticleVars('jet2', event.cleanJets[1] )
fill('jet2Btag' , event.cleanJets[1].btag("combinedSecondaryVertexBJetTags") )
fill('jet2Bmatch' , event.cleanJets[1].matchGenParton )
fill('mjj' , event.vbf.mjj)
fill('dEtajj' , event.vbf.deta)
fill('dPhijj' , deltaPhi(event.cleanJets[0].phi(), event.cleanJets[1].phi()))
fill('dEtattjj' , fabs(event.cleanJets[0].eta()+event.cleanJets[1].eta()-event.diLepton.eta()))
fill('dPhittjj' , deltaPhi(event.cleanJets[0].phi()+event.cleanJets[1].phi(),event.diLepton.phi()))
fill('nCentralJets' , len(event.vbf.centralJets))
fill('vbfMVA' , event.vbf.mva)
## Riccardo
sumJetPt = 0.
for j in range(nJets) :
sumJetPt += event.cleanJets[j].pt()
fill('allJetPt', event.cleanJets[j].pt())
if nJets == 0 : sumJetPt = -99.
fill('sumJetPt', sumJetPt)
nbJets = len(event.cleanBJets)
fill('nbJets', nbJets )
if nbJets>=1:
fParticleVars('bjet1', event.cleanBJets[0] )
if nbJets>=2:
fParticleVars('bjet2', event.cleanBJets[1] )
## Riccardo
sumbJetPt = 0.
for j in range(nbJets) :
sumbJetPt += event.cleanBJets[j].pt()
fill('allbJetPt', event.cleanBJets[j].pt())
if nbJets == 0 : sumbJetPt = -99.
fill('sumbJetPt', sumbJetPt)
fill('weight', event.eventWeight)
if hasattr( event, 'vertexWeight'):
fill('vertexWeight', event.vertexWeight )
fill('nVert' , len(event.vertices) )
if hasattr( event, 'embedWeight'):
fill('embedWeight', event.embedWeight)
if hasattr( event, 'triggerWeight'):
fill('triggerWeight', event.triggerWeight)
if hasattr( event, 'triggerEffData'):
fill('triggerEffData', event.triggerEffData)
if hasattr( event, 'triggerEffMC'):
fill('triggerEffMC', event.triggerEffMC)
isFake = 1
if hasattr( event, 'genMatched'):
if event.genMatched == 1:
isFake = 0
fill('isFake', isFake)
genMatched = 0
if hasattr(event,'genMatched') and event.genMatched > 0: genMatched = event.genMatched
fill('genMatched', genMatched)
isPhoton = 0
if hasattr(event,'isPhoton') and event.isPhoton == 1: isPhoton = 1
fill('isPhoton', isPhoton)
isElectron = 0
if hasattr(event,'isElectron') and event.isElectron > 0: isElectron = event.isElectron
fill('isElectron', isElectron)
isMuon = 0
if hasattr(event,'isMuon') and event.isMuon > 0: isMuon = event.isMuon
fill('isMuon', isMuon)
hasW = 0
if hasattr(event,'hasW') and event.hasW == 1: hasW = 1
fill('hasW', hasW)
hasZ = 0
if hasattr(event,'hasZ') and event.hasZ == 1: hasZ = 1
fill('hasZ', hasZ)
if len(event.muons)>0:
fill('muon1Pt' , event.muons[0].pt() )
fill('muon1Eta', event.muons[0].eta() )
fill('muon1Phi', event.muons[0].phi() )
else:
fill('muon1Pt' , -1 )
fill('muon1Eta', -1 )
fill('muon1Phi', -1 )
if len(event.electrons)>0:
fill('electron1Pt' , event.electrons[0].pt() )
fill('electron1Eta', event.electrons[0].eta() )
fill('electron1Phi', event.electrons[0].phi() )
else:
fill('electron1Pt' , -1 )
fill('electron1Eta', -1 )
fill('electron1Phi', -1 )
fill('NUP', event.NUP )
for trig in self.triggers:
fill(trig, getattr(event,trig))
self.tree.fill()
def selectionSequence(self, event, fillCounter):
if fillCounter: self.counters.counter('WAna').inc('W all events')
if self.cfg_comp.isMC :
if (hasattr(self.cfg_ana,'storeLHE_weight') and self.cfg_ana.storeLHE_weight):
# print event.LHEweights.comments_size()
for i in range(0,event.LHEweights.comments_size()):
# print 'i',i,event.LHEweights.getComment(i).split()[0]
if not "rwgt" in event.LHEweights.getComment(i).split()[0]:
event.LHE_weights.append(float(event.LHEweights.getComment(i).split()[1])/float(event.LHEweights.getComment(206).split()[1])) # CHECK THE 216 FOR THE SAMPLE IN USE !!!
# print len(event.LHE_weights)-1, event.LHEweights.getComment(i).split()[0], float(event.LHEweights.getComment(i).split()[1])/float(event.LHEweights.getComment(206).split()[1]), event.LHEweights.getComment(i).split()[2], event.LHEweights.getComment(i).split()[3], event.LHEweights.getComment(i).split()[4], event.LHEweights.getComment(i).split()[5]
# print len(event.LHE_weights)
##------------------------ Initial declaration of vectors --------------------------------------
event.allMuonsTrgBit=[]
# retrieve collections of interest (muons and jets)
event.allMuons = copy.copy(event.muons)
for i in range(0,len(event.allMuons)):
event.allMuonsTrgBit.append(0)
event.selMuons = []
event.NoTriggeredMuonsLeadingPt = copy.copy(event.muons)
event.allJets = copy.copy(event.jets)
event.selJets = copy.copy(event.jets)
event.selJets = [ jet for jet in event.allJets if ( \
not (bestMatch( jet , event.muons ))[1] <0.5 \
and jet.looseJetId() and jet.pt()>30 \
)
]
##------------------------ HERE MC related stuff --------------------------------------
# check if the event is MC and if genp must be saved
event.savegenpW=False
# for genp in event.genParticles:
# if math.fabs(genp.pdgId())==24 and genp.numberOfDaughters()>1:
# print 'genp.pdgId()=',genp.pdgId(), 'genp.status()=',genp.status(), 'genp.numberOfDaughters()=',genp.numberOfDaughters()
# if(genp.numberOfDaughters()>0):
# print 'genp.daughter(0)',genp.daughter(0).pdgId(),'status',genp.daughter(0).status()
# if(genp.numberOfDaughters()>1):
# print 'genp.daughter(1)',genp.daughter(1).pdgId(),'status',genp.daughter(1).status()
# return False
# save genp only for signal events
# i.e. only one W is present and daughters are muon plus neutrino
genW_dummy = [ genp for genp in event.genParticles if \
(math.fabs(genp.pdgId())==24 and (self.cfg_ana.doMad or genp.status()==62))if \
(( genp.numberOfDaughters()>1 and (\
math.fabs(genp.daughter(0).pdgId())==11 or
math.fabs(genp.daughter(1).pdgId())==11 or
math.fabs(genp.daughter(0).pdgId())==13 or
math.fabs(genp.daughter(1).pdgId())==13 or
math.fabs(genp.daughter(0).pdgId())==15 or
math.fabs(genp.daughter(1).pdgId())==15
) ) or (genp.numberOfDaughters()==1 and \
math.fabs(genp.daughter(0).pdgId())==13
) ) ]
# if the genp event is selected, associate gen muon and neutrino
event.genMu = []
event.genMuStatus1 = []
event.genNu = []
event.genNu_p4 = []
event.genWLept = []
if self.cfg_ana.savegenp and self.cfg_comp.isMC:
if len(genW_dummy)==1:
event.genW = [ genp for genp in genW_dummy if \
( \
( math.fabs(genW_dummy[0].daughter(0).pdgId())==13 ) or \
( genW_dummy[0].numberOfDaughters()>1 and math.fabs(genW_dummy[0].daughter(1).pdgId())==13 ) \
) ]
if len(event.genW)==1:
event.savegenpW=True
event.genNu_p4 = genW_dummy[0].p4() - event.genW[0].daughter(0).p4()
event.genWLept.append(event.genW[0])
if [ math.fabs(event.genW[0].daughter(0).pdgId())==13 ]:
event.genMu.append(event.genW[0].daughter(0))
if event.genW[0].numberOfDaughters()>1:
event.genNu.append(event.genW[0].daughter(1))
elif event.genW[0].numberOfDaughters()>1:
event.genMu.append(event.genW[0].daughter(1))
event.genNu.append(event.genW[0].daughter(0))
if(len(event.genMu) >0):
if(math.fabs(event.genW[0].mother(0).pdgId())!=6):
event.genMuStatus1.append(returnMuonDaughterStatus1(self,event.genMu[0]))
else:
event.genMuStatus1.append(event.genMu[0])
if event.genW[0].numberOfDaughters()>1:
event.genW_mt = mT(self,event.genW[0].daughter(0).p4() , event.genW[0].daughter(1).p4())
else:
event.genW_mt = mT(self,event.genW[0].daughter(0).p4() , event.genNu_p4)
event.muGenDeltaRgenP=1e6
# if len(genW_dummy)>1:
# event.genW = [ genp for genp in genW_dummy if \
# ( \
# ( math.fabs(genW_dummy[0].daughter(0).pdgId())==11 ) or \
# ( math.fabs(genW_dummy[0].daughter(1).pdgId())==11 ) or \
# ( math.fabs(genW_dummy[0].daughter(0).pdgId())==13 ) or \
# ( math.fabs(genW_dummy[0].daughter(1).pdgId())==13 ) or \
# ( math.fabs(genW_dummy[0].daughter(0).pdgId())==15 ) or \
# ( math.fabs(genW_dummy[0].daughter(1).pdgId())==15 ) or \
# ( math.fabs(genW_dummy[1].daughter(0).pdgId())==11 ) or \
# ( math.fabs(genW_dummy[1].daughter(1).pdgId())==11 ) or \
# ( math.fabs(genW_dummy[1].daughter(0).pdgId())==13 ) or \
# ( math.fabs(genW_dummy[1].daughter(1).pdgId())==13 ) or \
# ( math.fabs(genW_dummy[1].daughter(0).pdgId())==15 ) or \
# ( math.fabs(genW_dummy[1].daughter(1).pdgId())==15 ) \
# ) ]
# if len(event.genW)==2:
# if ( math.fabs(event.genW[0].daughter(0).pdgId())==13. or math.fabs(event.genW[0].daughter(0).pdgId())==15. or math.fabs(event.genW[0].daughter(0).pdgId())==11. ):
# # print 'event.savegenpW 2 ',event.savegenpW
# event.savegenpW=False
# # print 'found leptonic W0 a'
# event.genWLept.append(event.genW[0])
# if ( math.fabs(event.genW[0].daughter(0).pdgId())==13 ):
# event.genMu.append(event.genW[0].daughter(0))
# event.genNu.append(event.genW[0].daughter(1))
# event.genW_mt = mT(self,event.genMu[0].p4() , event.genNu[0].p4())
# event.muGenDeltaRgenP=1e6
# if(len(event.genMu) >0):
# event.genMuStatus1.append(returnMuonDaughterStatus1(self,event.genMu[0]))
# event.savegenpW=True
# if ( math.fabs(event.genW[0].daughter(1).pdgId())==13. or math.fabs(event.genW[0].daughter(1).pdgId())==15. or math.fabs(event.genW[0].daughter(1).pdgId())==11. ):
# # print 'event.savegenpW 3 ',event.savegenpW
# event.savegenpW=False
# # print 'found leptonic W0 b'
# event.genWLept.append(event.genW[0])
# if ( math.fabs(event.genW[0].daughter(1).pdgId())==13 ):
# event.genMu.append(event.genW[0].daughter(1))
# event.genNu.append(event.genW[0].daughter(0))
# event.genW_mt = mT(self,event.genMu[0].p4() , event.genNu[0].p4())
# event.muGenDeltaRgenP=1e6
# if(len(event.genMu) >0):
# event.genMuStatus1.append(returnMuonDaughterStatus1(self,event.genMu[0]))
# # print 'event.savegenpW 4 ',event.savegenpW
# event.savegenpW=True
# if ( math.fabs(event.genW[1].daughter(0).pdgId())==13. or math.fabs(event.genW[1].daughter(0).pdgId())==15. or math.fabs(event.genW[1].daughter(0).pdgId())==11. ):
# # print 'event.savegenpW 5 ',event.savegenpW
# event.savegenpW=False
# # print 'found leptonic W1 c'
# event.genWLept.append(event.genW[1])
# if ( math.fabs(event.genW[1].daughter(0).pdgId())==13 ):
# event.genMu.append(event.genW[1].daughter(0))
# event.genNu.append(event.genW[1].daughter(1))
# event.genW_mt = mT(self,event.genMu[0].p4() , event.genNu[0].p4())
# event.muGenDeltaRgenP=1e6
# if(len(event.genMu) >0):
# event.genMuStatus1.append(returnMuonDaughterStatus1(self,event.genMu[0]))
# event.savegenpW=True
# if ( math.fabs(event.genW[1].daughter(1).pdgId())==13. or math.fabs(event.genW[1].daughter(1).pdgId())==15. or math.fabs(event.genW[1].daughter(1).pdgId())==11. ):
# # print 'event.savegenpW 6 ',event.savegenpW
# event.savegenpW=False
# # print 'found leptonic W1 d'
# event.genWLept.append(event.genW[1])
# if ( math.fabs(event.genW[1].daughter(1).pdgId())==13 ):
# event.genMu.append(event.genW[1].daughter(1))
# event.genNu.append(event.genW[1].daughter(0))
# event.genW_mt = mT(self,event.genMu[0].p4() , event.genNu[0].p4())
# event.muGenDeltaRgenP=1e6
# if(len(event.genMu) >0):
# event.genMuStatus1.append(returnMuonDaughterStatus1(self,event.genMu[0]))
# event.savegenpW=True
# if the genp is not signal, don't save genp but do not exit
# -----> events which will pass the reconstruction but are not signal
# can be considered as background (for example, in W+Jets, from W decaying into electrons, taus)
# else:
# ## here put false for fully hadronic WW
# print 'event.savegenpW 7 ',event.savegenpW
# event.savegenpW=False
# print 'genW found ', len(genW_dummy)
# print 'genWLeptonic found ', len(event.genWLept)
##------------------------ HERE THERE is the selection --------------------------------------
keepFailingEvents = True
if not hasattr(self.cfg_ana,'keepFailingEvents') \
or (hasattr(self.cfg_ana,'keepFailingEvents') and not self.cfg_ana.keepFailingEvents):
keepFailingEvents = False
# print 'keepFailingEvents',keepFailingEvents
# if not (event.passedVertexAnalyzer and event.passedTriggerAnalyzer):
##------------
# reco events must have good reco vertex
if not (event.passedVertexAnalyzer):
return keepFailingEvents
##------------
# ...and at lest one reco muon...
if len(event.muons) == 0:
return keepFailingEvents
if fillCounter: self.counters.counter('WAna').inc('W ev trig, good vertex and >= 1 lepton')
#check if the event is triggered according to cfg_ana
if hasattr(self.cfg_ana, 'triggerBits'):
for imu in range(0,len(event.allMuons)):
for T, TL in self.cfg_ana.triggerBits.iteritems():
# muon object trigger matching
if trigMatched(self, event, event.allMuons[imu], TL):
# print event.allMuons[imu].pt(), event.allMuons[imu].eta(), TL
event.allMuonsTrgBit[imu]=1
# continue
if(event.allMuonsTrgBit[imu]==1): event.selMuons.append(event.allMuons[imu])
# for T, TL in self.cfg_ana.triggerBits.iteritems():
# # muon object trigger matching
# event.selMuons = [lep for lep in event.allMuons if \
# trigMatched(self, event, lep, TL)]
# print 'len(event.selMuons) = ',len(event.selMuons)
# for i in range(0,len(event.selMuons)):
# print i,event.selMuons[i].pt(), event.selMuons[i].eta()
# exit if there are no triggered muons
##------------
# reco events must have trigger fired...
if len(event.selMuons) == 0:
return keepFailingEvents, 'trigger matching failed'
else:
if fillCounter: self.counters.counter('WAna').inc('W at least 1 lep trig matched')
##------------
# to select W impose only 1 triggering lepton in the event:
# the number of triggering lepton is checked on the whole lepton collection
# before any cut, otherwise could be a Z!!!
if len(event.selMuons) != 1:
return keepFailingEvents, 'more than 1 lep trig matched'
else:
if fillCounter: self.counters.counter('WAna').inc('W only 1 lep trig matched')
if len(event.selMuons)!= 1: print 'BUT CONTINUING!'
# print len(event.selMuons), event.selMuons[0].pt()
if not (event.selMuons[0].pt()>0): return keepFailingEvents
# store muons that did not fire the trigger
if hasattr(self.cfg_ana, 'triggerBits'):
for T, TL in self.cfg_ana.triggerBits.iteritems():
event.NoTriggeredMuonsLeadingPt = [lep for lep in event.allMuons if \
(not trigMatched(self, event, lep, TL) \
and lep.pt()>10)]
# print "len(event.NoTriggeredMuonsLeadingPt)= ",len(event.NoTriggeredMuonsLeadingPt)
# if len(event.NoTriggeredMuonsLeadingPt)>0 : print "event.NoTriggeredMuonsLeadingPt[0].pt() = ",event.NoTriggeredMuonsLeadingPt[0].pt()
if len(event.NoTriggeredMuonsLeadingPt) > 0:
if event.NoTriggeredMuonsLeadingPt[0].pt()>10:
# if (event.NoTriggeredMuonsLeadingPt[0].pt()<10): print "ESISTE UN LEPTONE NON TRIGGERING WITH PT>10, event.NoTriggeredMuonsLeadingPt[0].pt() = ",event.NoTriggeredMuonsLeadingPt[0].pt()
return keepFailingEvents, 'rejecting event with non triggering lepton with pT > 10 GeV'
else:
if fillCounter: self.counters.counter('WAna').inc('W non trg leading lepton pT < 10 GeV')
else:
if fillCounter: self.counters.counter('WAna').inc('W non trg leading lepton pT < 10 GeV')
##------------------------ MAKE THE MUON --------------------------------------
# if the genp are saved, compute dR between gen and reco muon
if (event.savegenpW and len(event.genW)==1):
event.muGenDeltaRgenP = deltaR( event.selMuons[0].eta(), event.selMuons[0].phi(), event.genMu[0].eta(), event.genMu[0].phi() )
# associate good vertex to muon to compute dxy
event.selMuons[0].associatedVertex = event.goodVertices[0]
# testing offline muon cuts (tight+iso, no kinematical cuts)
event.selMuonIsTightAndIso = testLeg(self, event.selMuons[0] )
event.selMuonIsTight = testLegID( self,event.selMuons[0] )
# define a W from lepton and MET
event.W4V = event.selMuons[0].p4() + event.pfmet.p4()
event.W4V_mt = mT(self,event.selMuons[0].p4() , event.pfmet.p4())
event.covMatrixMuon = []
RetrieveMuonMatrixIntoVector(self,event.selMuons[0],event.covMatrixMuon)
# print event.covMatrixMuon
##------------------------ MAKE THE JETS and RECOIL variables --------------------------------------
# Code to study the recoil (not very useful for W...)
metVect = event.pfmet.p4().Vect()
metVect.SetZ(0.) # use only transverse info
WVect = event.W4V.Vect()
WVect.SetZ(0.) # use only transverse info
recoilVect = - copy.deepcopy(metVect) ## FIXED (met sign inverted)
# recoilVect -= WVect
temp_recoil = event.selMuons[0].p4().Vect()
temp_recoil.SetZ(0.) # use only transverse info
recoilVect -= temp_recoil ## FIXED (subtract only lepton for consistent recoil definition)
uWVect = WVect.Unit()
zAxis = type(WVect)(0,0,1)
uWVectPerp = WVect.Cross(zAxis).Unit()
u1 = recoilVect.Dot(uWVect) # recoil parallel to W pt
u2 = - recoilVect.Dot(uWVectPerp) # recoil perpendicular to W pt
event.u1 = u1
event.u2 = u2
##------------------------ FINAL COUNTERS --------------------------------------
if fillCounter:
if event.selMuonIsTightAndIso :
self.counters.counter('WAna').inc('W lep is MuIsTightAndIso')
if testLegKine( self, event.selMuons[0] , 30 , 2.1 ) :
self.counters.counter('WAna').inc('W Mu_eta<2.1 && Mu_pt>30')
if event.pfmet.pt() >25:
self.counters.counter('WAna').inc('W pfmet>25')
if event.W4V.Pt() < 20:
self.counters.counter('WAna').inc('W pt<20')
if len(event.selJets) > 0:
if event.selJets[0].pt()<30:
self.counters.counter('WAna').inc('W Jet_leading_pt<30')
else:
self.counters.counter('WAna').inc('W Jet_leading_pt<30')
# event is fully considered as good
# if fillCounter: self.counters.counter('WAna').inc('W pass')
event.WGoodEvent = True
return (event.WGoodEvent or keepFailingEvents)
def process(self, iEvent, event):
# print 'process ongoing!'
# import pdb; pdb.set_trace()
# import pdb; pdb.set_trace()
self.readCollections(iEvent)
self.counters.counter('EMT').inc('all events')
event.muoncand = self.buildLooseLeptons(self.handles['muons'].product(), event)
event.electroncand = self.buildLooseOtherLeptons(self.handles['electrons'].product(), event)
event.taucand = self.buildLooseTau(self.handles['taus'].product(), event)
cmgJets = self.handles['jets'].product()
event.CSVjet = []
for cmgJet in cmgJets:
jet = Jet( cmgJet )
if self.testVetoBJet(jet):
event.CSVjet.append(jet)
event.electroncand, dummpy = cleanObjectCollection(event.electroncand,
masks = event.muoncand,
deltaRMin = 0.5)
# CSV veto
electroncand_removebjet = []
muoncand_removebjet = []
for ielectron in event.electroncand:
bm, dr2min = bestMatch(ielectron, event.CSVjet)
if dr2min > 0.25:
electroncand_removebjet.append(ielectron)
for imuon in event.muoncand:
bm, dr2min = bestMatch(imuon, event.CSVjet)
if dr2min > 0.25:
muoncand_removebjet.append(imuon)
event.electroncand = electroncand_removebjet
event.muoncand = muoncand_removebjet
# event.flag_trigmatched = False
#
# if not event.flag_trigmatched:
# return False
# event.cleanelectron = []
# event.cleanmuon = []
for ii in event.electroncand:
ii.flag_id = self.eid(ii)
ii.flag_iso = self.eiso(ii)
ii.trig_match = True
# if self.triggerCheck(event, event.hltPaths, ii):
# ii.trig_match = True
#
# for jj in event.muoncand:
# if self.returnMass(jj, ii) > 20. and \
# ii.charge()*jj.charge()==1. and \
# self.returnDR(ii, jj) > 0.5:
#
# flag_add = True
#
# if flag_add:
# ii.flag_id = self.eid(ii)
# ii.flag_iso = self.eiso(ii)
# event.cleanelectron.append(ii)
#
#
#
for ii in event.muoncand:
ii.flag_id = self.muid(ii)
ii.flag_iso = self.muiso(ii)
ii.trig_match = True
# if self.triggerCheck(event, event.hltPaths, ii):
# ii.trig_match = True
# continue
#
# for jj in event.electroncand:
# if self.returnMass(jj, ii) > 20. and \
# ii.charge()*jj.charge()==1. and \
# self.returnDR(ii, jj) > 0.5:
#
# flag_add = True
#
# if flag_add:
# ii.flag_id = self.muid(ii)
# ii.flag_iso = self.muiso(ii)
# event.cleanmuon.append(ii)
# event.electroncand = event.cleanelectron
# event.muoncand = event.cleanmuon
# idiso_electron = [ie for ie in event.electroncand if self.eid(ie) and self.eiso(ie)]
# idiso_muon = [im for im in event.muoncand if self.muid(im) and self.muiso(im)]
# if idiso_electron[0].pt() > idiso_muon[0].pt():
# if not (len(event.muoncand)>=1 and len(event.electroncand)>=1 and len(event.taucand)>=1):
# print 'YCheck : (m,e,t) = ', len(event.muoncand), len(event.electroncand), len(event.taucand)
# return False
# lepton1 = [] # Leading lepton
# lepton2 = [] # 2nd leading lepton
# if not (len(id_electron)>=1 and len(id_muon)>=1):
# return False
# lepton_type = ''
#
# if id_electron[0].pt() > id_muon[0].pt(): #e-mu
# lepton1 = [ie for ie in id_electron if ie.pt() > 20.]
# lepton2 = [im for im in id_muon if im.pt() > 10.]
# lepton_type = 'electron'
# elif id_electron[0].pt() < id_muon[0].pt():
# lepton1 = [im for im in id_muon if im.pt() > 20.]
# lepton2 = [ie for ie in id_electron if ie.pt() > 10.]
# lepton_type = 'muon'
# import pdb; pdb.set_trace()
# if not (len(lepton1)==1 and len(lepton2)==1):
# return False
# self.counters.counter('EMT').inc('1mu + 1e')
#
#
# event.muon = ''
# event.electron = ''
#
# if lepton_type=='muon':
# event.muon = lepton1[0]
# event.electron = lepton2[0]
# elif lepton_type=='electron':
# event.electron = lepton1[0]
# event.muon = lepton2[0]
event.loosetau = []
for itau in event.taucand:
itau.decaymode = itau.decayMode()
itau.ep = itau.calcEOverP()
itau.flag_iso = self.tauiso(itau)
itau.flag_id = self.tauid(itau)
itau.againstERaw = itau.tauID('againstElectronMVA3raw')
itau.againstE2Raw = itau.tauID('againstElectronMVA2raw')
itau.againstE0Raw = itau.tauID('againstElectronMVA')
itau.againstECat = int(round(itau.tauID('againstElectronMVA3category')))
itau.againstE2Cat = int(round(itau.tauID('againstElectronMVA2category')))
# itau.againstE0Cat = int(round(itau.tauID('againstElectronMVAcategory')))
itau.againstELooseArmin = itau.tauID("againstElectronLoose")
itau.againstETight = itau.tauID("againstElectronTightMVA3")
itau.againstELoose = itau.tauID("againstElectronLooseMVA3")
itau.againstEMedium = itau.tauID("againstElectronMediumMVA3")
itau.againstE2Loose = itau.tauID("againstElectronLooseMVA2")
itau.againstE2Medium = itau.tauID("againstElectronMediumMVA2")
# itau.againstE0Loose = itau.tauID("againstElectronLooseMVA")
# itau.againstE0Medium = itau.tauID("againstElectronMediumMVA")
itau.againstMuLoose = itau.tauID("againstMuonLoose")
itau.againstMuTight = itau.tauID("againstMuonTight")
itau.dBisolation = itau.tauID("byCombinedIsolationDeltaBetaCorrRaw3Hits")
itau.mvaisolation = itau.tauID("byRawIsoMVA")
itau.mvaisolation_loose = itau.tauID('byLooseIsoMVA')
# print 'dB, raw, loose', itau.tauID("byCombinedIsolationDeltaBetaCorrRaw3Hits"), itau.tauID("byRawIsoMVA"), itau.tauID('byLooseIsoMVA')
# print 'ID_check', itau.tauID("againstMuonLoose"), itau.tauID("againstElectronLooseMVA3")
# print 'mu_loose, e_loose, e_medium', itau.tauID("againstMuonLoose"), itau.tauID("againstElectronLooseMVA3"), itau.tauID("againstElectronMediumMVA3"), itau.flag_id
# if flag_mu_mass and and \
# ((itau.decayMode()==0 and itau.calcEOverP() > 0.2) or (itau.decayMode()!=0)):
# itau.flag_id = True
#
#
# if flag_e_mass==False and flag_mu_mass==False and self.tauid(itau):
# itau.flag_id = True
# flag_e_overlap = False
# flag_e_mass = False
#
# for ii in idiso_electron:
# mass_et = self.returnMass(ii, itau)
# if mass_et > 71.2 and mass_et < 111.2:
# flag_e_mass = True
#
# if self.returnDR(itau, ii) < 0.5:
# flag_e_overlap = True
#
# if flag_e_overlap:
# continue
#
#
# flag_mu_overlap = False
# flag_mu_mass = False
#
# for ii in idiso_muon:
# mass_mt = self.returnMass(ii, itau)
# if mass_mt > 71.2 and mass_mt < 111.2:
# flag_mu_mass = True
#
# if self.returnDR(itau, ii) < 0.5:
# flag_mu_overlap = True
#
# if flag_mu_overlap:
# continue
# if self.tauiso(itau):
# itau.flag_iso = True
#
#
# if flag_e_mass and itau.tauID("againstElectronMediumMVA3"):
# itau.flag_id = True
#
#
# if flag_mu_mass and itau.tauID("againstMuonTight") and \
# ((itau.decayMode()==0 and itau.calcEOverP() > 0.2) or (itau.decayMode()!=0)):
# itau.flag_id = True
#
#
# if flag_e_mass==False and flag_mu_mass==False and self.tauid(itau):
# itau.flag_id = True
event.loosetau.append(itau)
event.taucand = event.loosetau
# Additional tau veto
event.vetotaucand = self.buildVetoTau(self.handles['taus'].product(), event)
event.vetomuoncand = self.buildVetoLeptons(self.handles['muons'].product(), event)
event.vetoelectroncand = self.buildVetoOtherLeptons(self.handles['electrons'].product(), event)
flag_sscharge = False
for im in event.muoncand:
for ie in event.electroncand:
if im.charge()*ie.charge()==1:
flag_sscharge = True
self.counters.counter('EMT').inc('step1')
if flag_sscharge==False:
return False
self.counters.counter('EMT').inc('step2')
# if not (len(event.taucand)>=1 and len(event.muoncand)>=1 and len(event.electroncand)>=1):
if not (len(event.muoncand)>=1 and len(event.electroncand)>=1):
return False
self.counters.counter('EMT').inc('step3')
# idiso_tau = [it for it in event.taucand if (it.flag_id and it.flag_iso)]
# if not len(idiso_tau)>=1 :
# return False
# if not len(lepton3) == 1:
# return False
# self.counters.counter('EMT').inc('1 e/mu/tau')
# event.tau = lepton3[0]
# event.M_l2t = self.returnMass(lepton2[0], event.tau)
# if self.returnMass(event.muon, event.electron) < 20.:
# return False
# if self.returnMass(lepton2[0], event.tau) < 20.:
# return False
# charge requirement
# SS for two light leptons
# if event.electron.charge()*event.muon.charge()==-1.:
# return False
# if event.tau.charge()*event.muon.charge()!=-1.:
# return False
# dR separation
# if self.returnDR(event.tau, event.muon) < 0.5:
# return False
# if self.returnDR(event.tau, event.electron) < 0.5:
# return False
# if self.returnDR(event.electron, event.muon) < 0.5:
# return False
# event.loosetaucand, dummpy = cleanObjectCollection(event.loosetaucand,
# masks = [event.muon],
## masks = event.muoncand,
# deltaRMin = 0.4)
#
# event.loosetaucand, dummpy = cleanObjectCollection(event.loosetaucand,
# masks = [event.electron],
## masks = event.electroncand,
# deltaRMin = 0.4)
#
# event.loosetaucand, dummpy = cleanObjectCollection(event.loosetaucand,
# masks = [event.tau],
# deltaRMin = 0.4)
#
#
# event.loosemuoncand, dummpy = cleanObjectCollection(event.loosemuoncand,
# masks = [event.muon],
# deltaRMin = 0.4)
#
# event.loosemuoncand, dummpy = cleanObjectCollection(event.loosemuoncand,
# masks = [event.electron],
# deltaRMin = 0.4)
#
# event.loosemuoncand, dummpy = cleanObjectCollection(event.loosemuoncand,
# masks = [event.tau],
# deltaRMin = 0.4)
#
# event.looseelectroncand, dummpy = cleanObjectCollection(event.looseelectroncand,
# masks = [event.muon],
# deltaRMin = 0.4)
#
# event.looseelectroncand, dummpy = cleanObjectCollection(event.looseelectroncand,
# masks = [event.electron],
# deltaRMin = 0.4)
#
# event.looseelectroncand, dummpy = cleanObjectCollection(event.looseelectroncand,
# masks = [event.tau],
# deltaRMin = 0.4)
# NadditionalLepton = len(event.loosetaucand) + len(event.loosemuoncand) + len(event.looseelectroncand)
# if NadditionalLepton>=1:
# return False
print 'All events passed : ', event.run, event.lumi, event.eventId
return True
