class ttHLepAnalyzerBase( Analyzer ): def __init__(self, cfg_ana, cfg_comp, looperName ): super(ttHLepAnalyzerBase,self).__init__(cfg_ana,cfg_comp,looperName) if self.cfg_ana.doElectronScaleCorrections: tag = "Summer12_DR53X_HCP2012" if cfg_comp.isMC else "Moriond2013"; self.electronEnergyCalibrator = ElectronEnergyCalibrator( tag, ## dataset True, # isAOD cfg_comp.isMC, # isMC True, # updateEnergyError, 999, # applyCorrections (999 = correct and/or smear for SC-based energy estimation) 0.607, # smearing ratio False, False, #verbose, sync TRandom3(0),) # random number generator if hasattr(cfg_comp,'efficiency'): self.efficiency= EfficiencyCorrector(cfg_comp.efficiency) self.relaxId = cfg_ana.relaxId if hasattr(cfg_ana,'relaxId') else False #---------------------------------------- # DECLARATION OF HANDLES OF LEPTONS STUFF #---------------------------------------- def declareHandles(self): super(ttHLepAnalyzerBase, self).declareHandles() #leptons self.handles['muons'] = AutoHandle(self.cfg_ana.muons,"std::vector<cmg::Muon>") self.handles['electrons'] = AutoHandle(self.cfg_ana.electrons,"std::vector<cmg::Electron>") #rho for muons self.handles['rhoMu'] = AutoHandle( (self.cfg_ana.rhoMuon, 'rho'), 'double') #rho for electrons self.handles['rhoEle'] = AutoHandle( (self.cfg_ana.rhoElectron, 'rho'), 'double') #photons (a la hzz4l definition) self.handles['photons'] = AutoHandle( ('cmgPhotonSel',''),'std::vector<cmg::Photon>') def beginLoop(self): super(ttHLepAnalyzerBase,self).beginLoop() #------------------ # MAKE LEPTON LISTS #------------------ # the muons are already corrected with Rochester corrections, are already cleaned with the ghost cleaning # the electrons have already the electron energy regression and calibration applied # the V5_10_0 cmgTuple, have been corrected with Mike's patch for the SIP computation -> cmgMuons have been remade -> # (cvs up -r michalis_sipPatchBranch CMGTools/Common/src/MuonFactory.cc) # nb: the event vertex needs to be defined first -> using the vertex analyzer # nb: in the following dxy and dz are computed with respect to the PV good vertex, sip with respect to the PV 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) #print "Found ",len(event.looseLeptons)," loose leptons" #print "Found ",len(event.selectedLeptons)," good leptons" def makePhotons(self, event): event.allphotons = map( Photon, self.handles['photons'].product() ) event.allphotons.sort(key = lambda l : l.pt(), reverse = True) def process(self, iEvent, event): self.readCollections( iEvent ) eventNumber = iEvent.eventAuxiliary().id().event() #print 'Event ',eventNumber #import pdb; pdb.set_trace() #call the leptons/photons functions self.makeLeptons(event) self.makePhotons(event) ret = False if len(event.selectedLeptons) >= self.cfg_ana.minGoodLeptons: ret = True if hasattr(self.cfg_ana, 'maxGoodLeptons') and len(event.selectedLeptons) > self.cfg_ana.maxGoodLeptons: ret = False #if self.cfg_ana.doSSLeptons and len(event.selectedLeptons) >= 2: # if event.selectedLeptons[0].charge() == event.selectedLeptons[1].charge(): # ret = True return ret
class ttHLepAnalyzerBase(Analyzer): def __init__(self, cfg_ana, cfg_comp, looperName): super(ttHLepAnalyzerBase, self).__init__(cfg_ana, cfg_comp, looperName) if self.cfg_ana.doMuScleFitCorrections and self.cfg_ana.doMuScleFitCorrections != "none": if self.cfg_ana.doMuScleFitCorrections not in [ "none", "prompt", "prompt-sync", "rereco", "rereco-sync" ]: raise RuntimeError, 'doMuScleFitCorrections must be one of "none", "prompt", "prompt-sync", "rereco", "rereco-sync"' rereco = ("prompt" not in self.cfg_ana.doMuScleFitCorrections) sync = ("sync" in self.cfg_ana.doMuScleFitCorrections) self.muscleCorr = MuScleFitCorr(cfg_comp.isMC, rereco, sync) if hasattr(self.cfg_ana, "doRochesterCorrections" ) and self.cfg_ana.doRochesterCorrections: raise RuntimeError, "You can't run both Rochester and MuScleFit corrections!" else: self.cfg_ana.doMuScleFitCorrections = False if self.cfg_ana.doElectronScaleCorrections == "embedded": self.electronEnergyCalibrator = EmbeddedElectronCalibrator() else: self.electronEnergyCalibrator = ElectronCalibrator(cfg_comp.isMC) if hasattr(cfg_comp, 'efficiency'): self.efficiency = EfficiencyCorrector(cfg_comp.efficiency) self.relaxId = cfg_ana.relaxId if hasattr(cfg_ana, 'relaxId') else False #---------------------------------------- # DECLARATION OF HANDLES OF LEPTONS STUFF #---------------------------------------- def declareHandles(self): super(ttHLepAnalyzerBase, self).declareHandles() #leptons self.handles['muons'] = AutoHandle(self.cfg_ana.muons, "std::vector<cmg::Muon>") self.handles['electrons'] = AutoHandle(self.cfg_ana.electrons, "std::vector<cmg::Electron>") #rho for muons self.handles['rhoMu'] = AutoHandle((self.cfg_ana.rhoMuon, 'rho'), 'double') #rho for electrons self.handles['rhoEle'] = AutoHandle((self.cfg_ana.rhoElectron, 'rho'), 'double') #photons (a la hzz4l definition) self.handles['photons'] = AutoHandle(('cmgPhotonSel', ''), 'std::vector<cmg::Photon>') ## dEdX #self.handles['dEdX'] = AutoHandle( ('dedxHarmonic2','','RECO'), 'edm::ValueMap<reco::DeDxData>' ) def beginLoop(self): super(ttHLepAnalyzerBase, self).beginLoop() self.counters.addCounter('events') count = self.counters.counter('events') count.register('all events') count.register('vetoed events') count.register('accepted events') #------------------ # MAKE LEPTON LISTS #------------------ # the muons are already corrected with Rochester corrections, are already cleaned with the ghost cleaning # the electrons have already the electron energy regression and calibration applied # the V5_10_0 cmgTuple, have been corrected with Mike's patch for the SIP computation -> cmgMuons have been remade -> # (cvs up -r michalis_sipPatchBranch CMGTools/Common/src/MuonFactory.cc) # nb: the event vertex needs to be defined first -> using the vertex analyzer # nb: in the following dxy and dz are computed with respect to the PV good vertex, sip with respect to the PV 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) #print "Found ",len(event.looseLeptons)," loose leptons" #print "Found ",len(event.selectedLeptons)," good leptons" def makePhotons(self, event): event.allphotons = map(Photon, self.handles['photons'].product()) event.allphotons.sort(key=lambda l: l.pt(), reverse=True) def process(self, iEvent, event): self.readCollections(iEvent) self.counters.counter('events').inc('all events') eventNumber = iEvent.eventAuxiliary().id().event() #print 'Event ',eventNumber #import pdb; pdb.set_trace() #call the leptons/photons functions self.makeLeptons(event) self.makePhotons(event) ret = False if len(event.selectedLeptons) >= self.cfg_ana.minGoodLeptons: ret = True if hasattr(self.cfg_ana, 'minInclusiveLeptons') and len( event.inclusiveLeptons) < self.cfg_ana.minInclusiveLeptons: if ret: self.counters.counter('events').inc('vetoed events') ret = False if hasattr(self.cfg_ana, 'maxGoodLeptons') and len( event.selectedLeptons) > self.cfg_ana.maxGoodLeptons: if ret: self.counters.counter('events').inc('vetoed events') ret = False #if self.cfg_ana.doSSLeptons and len(event.selectedLeptons) >= 2: # if event.selectedLeptons[0].charge() == event.selectedLeptons[1].charge(): # ret = True if ret: self.counters.counter('events').inc('accepted events') return ret
class ttHLepAnalyzerFR( Analyzer ): def __init__(self, cfg_ana, cfg_comp, looperName ): super(ttHLepAnalyzerFR,self).__init__(cfg_ana,cfg_comp,looperName) if self.cfg_ana.doMuScleFitCorrections and self.cfg_ana.doMuScleFitCorrections != "none": if self.cfg_ana.doMuScleFitCorrections not in [ "none", "prompt", "prompt-sync", "rereco", "rereco-sync" ]: raise RuntimeError, 'doMuScleFitCorrections must be one of "none", "prompt", "prompt-sync", "rereco", "rereco-sync"' rereco = ("prompt" not in self.cfg_ana.doMuScleFitCorrections) sync = ("sync" in self.cfg_ana.doMuScleFitCorrections) self.muscleCorr = MuScleFitCorr(cfg_comp.isMC, rereco, sync) if hasattr(self.cfg_ana, "doRochesterCorrections") and self.cfg_ana.doRochesterCorrections: raise RuntimeError, "You can't run both Rochester and MuScleFit corrections!" else: self.cfg_ana.doMuScleFitCorrections = False if self.cfg_ana.doElectronScaleCorrections == "embedded": self.electronEnergyCalibrator = EmbeddedElectronCalibrator() else: self.electronEnergyCalibrator = ElectronCalibrator(cfg_comp.isMC) if hasattr(cfg_comp,'efficiency'): self.efficiency= EfficiencyCorrector(cfg_comp.efficiency) self.relaxId = cfg_ana.relaxId if hasattr(cfg_ana,'relaxId') else False #---------------------------------------- # DECLARATION OF HANDLES OF LEPTONS STUFF #---------------------------------------- def declareHandles(self): super(ttHLepAnalyzerFR, self).declareHandles() #leptons self.handles['muons'] = AutoHandle(self.cfg_ana.muons,"std::vector<cmg::Muon>") self.handles['electrons'] = AutoHandle(self.cfg_ana.electrons,"std::vector<cmg::Electron>") #rho for muons self.handles['rhoMu'] = AutoHandle( (self.cfg_ana.rhoMuon, 'rho'), 'double') #rho for electrons self.handles['rhoEle'] = AutoHandle( (self.cfg_ana.rhoElectron, 'rho'), 'double') #photons (a la hzz4l definition) self.handles['photons'] = AutoHandle( ('cmgPhotonSel',''),'std::vector<cmg::Photon>') ## dEdX #self.handles['dEdX'] = AutoHandle( ('dedxHarmonic2','','RECO'), 'edm::ValueMap<reco::DeDxData>' ) def beginLoop(self): super(ttHLepAnalyzerFR,self).beginLoop() self.counters.addCounter('events') count = self.counters.counter('events') count.register('all events') count.register('vetoed events') count.register('accepted events') #------------------ # MAKE LEPTON LISTS #------------------ # the muons are already corrected with Rochester corrections, are already cleaned with the ghost cleaning # the electrons have already the electron energy regression and calibration applied # the V5_10_0 cmgTuple, have been corrected with Mike's patch for the SIP computation -> cmgMuons have been remade -> # (cvs up -r michalis_sipPatchBranch CMGTools/Common/src/MuonFactory.cc) # nb: the event vertex needs to be defined first -> using the vertex analyzer # nb: in the following dxy and dz are computed with respect to the PV good vertex, sip with respect to the PV 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) #print "Found ",len(event.looseLeptons)," loose leptons" #print "Found ",len(event.selectedLeptons)," good leptons" def makePhotons(self, event): event.allphotons = map( Photon, self.handles['photons'].product() ) event.allphotons.sort(key = lambda l : l.pt(), reverse = True) def process(self, iEvent, event): self.readCollections( iEvent ) self.counters.counter('events').inc('all events') #import pdb; pdb.set_trace() #call the leptons/photons functions self.makeLeptons(event) self.makePhotons(event) ret = False if len(event.selectedLeptons) >= self.cfg_ana.minGoodLeptons: ret = True if hasattr(self.cfg_ana, 'minInclusiveLeptons') and len(event.inclusiveLeptons) < self.cfg_ana.minInclusiveLeptons: if ret: self.counters.counter('events').inc('vetoed events') ret = False if hasattr(self.cfg_ana, 'maxGoodLeptons') and len(event.selectedLeptons) > self.cfg_ana.maxGoodLeptons: if ret: self.counters.counter('events').inc('vetoed events') ret = False #if self.cfg_ana.doSSLeptons and len(event.selectedLeptons) >= 2: # if event.selectedLeptons[0].charge() == event.selectedLeptons[1].charge(): # ret = True if ret: self.counters.counter('events').inc('accepted events') return ret
class ttHLepAnalyzerBase(Analyzer): def __init__(self, cfg_ana, cfg_comp, looperName): super(ttHLepAnalyzerBase, self).__init__(cfg_ana, cfg_comp, looperName) if self.cfg_ana.doElectronScaleCorrections: tag = "Summer12_DR53X_HCP2012" if cfg_comp.isMC else "Moriond2013" self.electronEnergyCalibrator = ElectronEnergyCalibrator( tag, ## dataset True, # isAOD cfg_comp.isMC, # isMC True, # updateEnergyError, 999, # applyCorrections (999 = correct and/or smear for SC-based energy estimation) 0.607, # smearing ratio False, False, #verbose, sync TRandom3(0), ) # random number generator if hasattr(cfg_comp, 'efficiency'): self.efficiency = EfficiencyCorrector(cfg_comp.efficiency) self.relaxId = cfg_ana.relaxId if hasattr(cfg_ana, 'relaxId') else False #---------------------------------------- # DECLARATION OF HANDLES OF LEPTONS STUFF #---------------------------------------- def declareHandles(self): super(ttHLepAnalyzerBase, self).declareHandles() #leptons self.handles['muons'] = AutoHandle(self.cfg_ana.muons, "std::vector<cmg::Muon>") self.handles['electrons'] = AutoHandle(self.cfg_ana.electrons, "std::vector<cmg::Electron>") #rho for muons self.handles['rhoMu'] = AutoHandle((self.cfg_ana.rhoMuon, 'rho'), 'double') #rho for electrons self.handles['rhoEle'] = AutoHandle((self.cfg_ana.rhoElectron, 'rho'), 'double') #photons (a la hzz4l definition) self.handles['photons'] = AutoHandle(('cmgPhotonSel', ''), 'std::vector<cmg::Photon>') def beginLoop(self): super(ttHLepAnalyzerBase, self).beginLoop() #------------------ # MAKE LEPTON LISTS #------------------ # the muons are already corrected with Rochester corrections, are already cleaned with the ghost cleaning # the electrons have already the electron energy regression and calibration applied # the V5_10_0 cmgTuple, have been corrected with Mike's patch for the SIP computation -> cmgMuons have been remade -> # (cvs up -r michalis_sipPatchBranch CMGTools/Common/src/MuonFactory.cc) # nb: the event vertex needs to be defined first -> using the vertex analyzer # nb: in the following dxy and dz are computed with respect to the PV good vertex, sip with respect to the PV 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) #print "Found ",len(event.looseLeptons)," loose leptons" #print "Found ",len(event.selectedLeptons)," good leptons" def makePhotons(self, event): event.allphotons = map(Photon, self.handles['photons'].product()) event.allphotons.sort(key=lambda l: l.pt(), reverse=True) def process(self, iEvent, event): self.readCollections(iEvent) eventNumber = iEvent.eventAuxiliary().id().event() #print 'Event ',eventNumber #import pdb; pdb.set_trace() #call the leptons/photons functions self.makeLeptons(event) self.makePhotons(event) ret = False if len(event.selectedLeptons) >= self.cfg_ana.minGoodLeptons: ret = True if hasattr(self.cfg_ana, 'maxGoodLeptons') and len( event.selectedLeptons) > self.cfg_ana.maxGoodLeptons: ret = False #if self.cfg_ana.doSSLeptons and len(event.selectedLeptons) >= 2: # if event.selectedLeptons[0].charge() == event.selectedLeptons[1].charge(): # ret = True return ret
class ttHLepAnalyzerFR(Analyzer): def __init__(self, cfg_ana, cfg_comp, looperName): super(ttHLepAnalyzerFR, self).__init__(cfg_ana, cfg_comp, looperName) if self.cfg_ana.doMuScleFitCorrections and self.cfg_ana.doMuScleFitCorrections != "none": if self.cfg_ana.doMuScleFitCorrections not in [ "none", "prompt", "prompt-sync", "rereco", "rereco-sync" ]: raise RuntimeError, 'doMuScleFitCorrections must be one of "none", "prompt", "prompt-sync", "rereco", "rereco-sync"' rereco = ("prompt" not in self.cfg_ana.doMuScleFitCorrections) sync = ("sync" in self.cfg_ana.doMuScleFitCorrections) self.muscleCorr = MuScleFitCorr(cfg_comp.isMC, rereco, sync) if hasattr(self.cfg_ana, "doRochesterCorrections" ) and self.cfg_ana.doRochesterCorrections: raise RuntimeError, "You can't run both Rochester and MuScleFit corrections!" else: self.cfg_ana.doMuScleFitCorrections = False if self.cfg_ana.doElectronScaleCorrections == "embedded": self.electronEnergyCalibrator = EmbeddedElectronCalibrator() else: self.electronEnergyCalibrator = ElectronCalibrator(cfg_comp.isMC) if hasattr(cfg_comp, 'efficiency'): self.efficiency = EfficiencyCorrector(cfg_comp.efficiency) self.relaxId = cfg_ana.relaxId if hasattr(cfg_ana, 'relaxId') else False #---------------------------------------- # DECLARATION OF HANDLES OF LEPTONS STUFF #---------------------------------------- def declareHandles(self): super(ttHLepAnalyzerFR, self).declareHandles() #leptons self.handles['muons'] = AutoHandle(self.cfg_ana.muons, "std::vector<cmg::Muon>") self.handles['electrons'] = AutoHandle(self.cfg_ana.electrons, "std::vector<cmg::Electron>") #rho for muons self.handles['rhoMu'] = AutoHandle((self.cfg_ana.rhoMuon, 'rho'), 'double') #rho for electrons self.handles['rhoEle'] = AutoHandle((self.cfg_ana.rhoElectron, 'rho'), 'double') #photons (a la hzz4l definition) self.handles['photons'] = AutoHandle(('cmgPhotonSel', ''), 'std::vector<cmg::Photon>') ## dEdX #self.handles['dEdX'] = AutoHandle( ('dedxHarmonic2','','RECO'), 'edm::ValueMap<reco::DeDxData>' ) def beginLoop(self): super(ttHLepAnalyzerFR, self).beginLoop() self.counters.addCounter('events') count = self.counters.counter('events') count.register('all events') count.register('vetoed events') count.register('accepted events') #------------------ # MAKE LEPTON LISTS #------------------ # the muons are already corrected with Rochester corrections, are already cleaned with the ghost cleaning # the electrons have already the electron energy regression and calibration applied # the V5_10_0 cmgTuple, have been corrected with Mike's patch for the SIP computation -> cmgMuons have been remade -> # (cvs up -r michalis_sipPatchBranch CMGTools/Common/src/MuonFactory.cc) # nb: the event vertex needs to be defined first -> using the vertex analyzer # nb: in the following dxy and dz are computed with respect to the PV good vertex, sip with respect to the PV 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) #print "Found ",len(event.looseLeptons)," loose leptons" #print "Found ",len(event.selectedLeptons)," good leptons" def makePhotons(self, event): event.allphotons = map(Photon, self.handles['photons'].product()) event.allphotons.sort(key=lambda l: l.pt(), reverse=True) def process(self, iEvent, event): self.readCollections(iEvent) self.counters.counter('events').inc('all events') #import pdb; pdb.set_trace() #call the leptons/photons functions self.makeLeptons(event) self.makePhotons(event) ret = False if len(event.selectedLeptons) >= self.cfg_ana.minGoodLeptons: ret = True if hasattr(self.cfg_ana, 'minInclusiveLeptons') and len( event.inclusiveLeptons) < self.cfg_ana.minInclusiveLeptons: if ret: self.counters.counter('events').inc('vetoed events') ret = False if hasattr(self.cfg_ana, 'maxGoodLeptons') and len( event.selectedLeptons) > self.cfg_ana.maxGoodLeptons: if ret: self.counters.counter('events').inc('vetoed events') ret = False #if self.cfg_ana.doSSLeptons and len(event.selectedLeptons) >= 2: # if event.selectedLeptons[0].charge() == event.selectedLeptons[1].charge(): # ret = True if ret: self.counters.counter('events').inc('accepted events') return ret
class ttHLepAnalyzerSusy(Analyzer): def __init__(self, cfg_ana, cfg_comp, looperName): super(ttHLepAnalyzerSusy, self).__init__(cfg_ana, cfg_comp, looperName) if self.cfg_ana.doMuScleFitCorrections and self.cfg_ana.doMuScleFitCorrections != "none": if self.cfg_ana.doMuScleFitCorrections not in [ "none", "prompt", "prompt-sync", "rereco", "rereco-sync" ]: raise RuntimeError, 'doMuScleFitCorrections must be one of "none", "prompt", "prompt-sync", "rereco", "rereco-sync"' rereco = ("prompt" not in self.cfg_ana.doMuScleFitCorrections) sync = ("sync" in self.cfg_ana.doMuScleFitCorrections) self.muscleCorr = MuScleFitCorr(cfg_comp.isMC, rereco, sync) if hasattr(self.cfg_ana, "doRochesterCorrections" ) and self.cfg_ana.doRochesterCorrections: raise RuntimeError, "You can't run both Rochester and MuScleFit corrections!" else: self.cfg_ana.doMuScleFitCorrections = False if self.cfg_ana.doElectronScaleCorrections == "embedded": self.electronEnergyCalibrator = EmbeddedElectronCalibrator() else: self.electronEnergyCalibrator = ElectronCalibrator(cfg_comp.isMC) if hasattr(cfg_comp, 'efficiency'): self.efficiency = EfficiencyCorrector(cfg_comp.efficiency) #---------------------------------------- # DECLARATION OF HANDLES OF LEPTONS STUFF #---------------------------------------- def declareHandles(self): super(ttHLepAnalyzerSusy, self).declareHandles() #leptons self.handles['muons'] = AutoHandle(self.cfg_ana.muons, "std::vector<cmg::Muon>") self.handles['electrons'] = AutoHandle(self.cfg_ana.electrons, "std::vector<cmg::Electron>") #rho for muons self.handles['rhoMu'] = AutoHandle((self.cfg_ana.rhoMuon, 'rho'), 'double') #rho for electrons self.handles['rhoEle'] = AutoHandle((self.cfg_ana.rhoElectron, 'rho'), 'double') #photons (a la hzz4l definition) self.handles['photons'] = AutoHandle(self.cfg_ana.photons, 'std::vector<cmg::Photon>') def beginLoop(self): super(ttHLepAnalyzerSusy, self).beginLoop() self.counters.addCounter('events') count = self.counters.counter('events') count.register('all events') #------------------ # MAKE LEPTON LISTS #------------------ 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 makePhotons(self, event): event.allphotons = map(Photon, self.handles['photons'].product()) event.allphotons.sort(key=lambda l: l.pt(), reverse=True) def makeAllMuons(self, event): """ make a list of all muons, and apply basic corrections to them """ # Start from all muons allmuons = map(Muon, self.handles['muons'].product()) # Muon scale and resolution corrections (if enabled) 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) # Clean up dulicate muons (note: has no effect unless the muon id is removed) 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 # Attach the vertex to them, for dxy/dz calculation for mu in allmuons: mu.associatedVertex = event.goodVertices[0] # Compute relIso in 0.3 and 0.4 cones for mu in allmuons: mu.absIso03 = ( mu.sourcePtr().pfIsolationR03().sumChargedHadronPt + max( mu.sourcePtr().pfIsolationR03().sumNeutralHadronEt + mu.sourcePtr().pfIsolationR03().sumPhotonEt - mu.sourcePtr().pfIsolationR03().sumPUPt / 2, 0.0)) mu.absIso04 = ( mu.sourcePtr().pfIsolationR04().sumChargedHadronPt + max( mu.sourcePtr().pfIsolationR04().sumNeutralHadronEt + mu.sourcePtr().pfIsolationR04().sumPhotonEt - mu.sourcePtr().pfIsolationR04().sumPUPt / 2, 0.0)) mu.relIso03 = mu.absIso03 / mu.pt() mu.relIso04 = mu.absIso04 / mu.pt() return allmuons def makeAllElectrons(self, event): """ make a list of all electrons, and apply basic corrections to them """ allelectrons = map(Electron, self.handles['electrons'].product()) ## Duplicate removal for fast sim (to be checked if still necessary in latest greatest 5.3.X releases) 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 # 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; # Electron scale calibrations if self.cfg_ana.doElectronScaleCorrections: for ele in allelectrons: self.electronEnergyCalibrator.correct(ele, event.run) # Attach the vertex for ele in allelectrons: ele.associatedVertex = event.goodVertices[0] # Compute relIso with R=0.3 and R=0.4 cones for ele in allelectrons: ele.absIso03 = (ele.chargedHadronIso(0.3) + max( ele.neutralHadronIso(0.3) + ele.photonIso(0.3) - ele.rho * ele.EffectiveArea, 0)) ele.absIso04 = (ele.chargedHadronIso(0.4) + max( ele.neutralHadronIso(0.4) + ele.photonIso(0.4) - ele.rho * ele.EffectiveArea, 0)) ele.relIso03 = ele.absIso03 / ele.pt() ele.relIso04 = ele.absIso04 / ele.pt() # Set tight MVA id for ele in allelectrons: ele.tightIdResult = ele.electronID("POG_MVA_ID_Trig") return allelectrons def process(self, iEvent, event): self.readCollections(iEvent) self.counters.counter('events').inc('all events') #call the leptons/photons functions self.makeLeptons(event) self.makePhotons(event) return True
class ttHLepAnalyzerBase( Analyzer ): def __init__(self, cfg_ana, cfg_comp, looperName ): super(ttHLepAnalyzerBase,self).__init__(cfg_ana,cfg_comp,looperName) if self.cfg_ana.doMuScleFitCorrections and self.cfg_ana.doMuScleFitCorrections != "none": if self.cfg_ana.doMuScleFitCorrections not in [ "none", "prompt", "prompt-sync", "rereco", "rereco-sync" ]: raise RuntimeError, 'doMuScleFitCorrections must be one of "none", "prompt", "prompt-sync", "rereco", "rereco-sync"' rereco = ("prompt" not in self.cfg_ana.doMuScleFitCorrections) sync = ("sync" in self.cfg_ana.doMuScleFitCorrections) self.muscleCorr = MuScleFitCorr(cfg_comp.isMC, rereco, sync) if hasattr(self.cfg_ana, "doRochesterCorrections") and self.cfg_ana.doRochesterCorrections: raise RuntimeError, "You can't run both Rochester and MuScleFit corrections!" else: self.cfg_ana.doMuScleFitCorrections = False if self.cfg_ana.doElectronScaleCorrections == "embedded": self.electronEnergyCalibrator = EmbeddedElectronCalibrator() else: self.electronEnergyCalibrator = ElectronCalibrator(cfg_comp.isMC) if hasattr(cfg_comp,'efficiency'): self.efficiency= EfficiencyCorrector(cfg_comp.efficiency) self.relaxId = cfg_ana.relaxId if hasattr(cfg_ana,'relaxId') else False #---------------------------------------- # DECLARATION OF HANDLES OF LEPTONS STUFF #---------------------------------------- def declareHandles(self): super(ttHLepAnalyzerBase, self).declareHandles() #leptons self.handles['muons'] = AutoHandle(self.cfg_ana.muons,"std::vector<cmg::Muon>") self.handles['electrons'] = AutoHandle(self.cfg_ana.electrons,"std::vector<cmg::Electron>") #rho for muons self.handles['rhoMu'] = AutoHandle( (self.cfg_ana.rhoMuon, 'rho'), 'double') #rho for electrons self.handles['rhoEle'] = AutoHandle( (self.cfg_ana.rhoElectron, 'rho'), 'double') #photons (a la hzz4l definition) self.handles['photons'] = AutoHandle( ('cmgPhotonSel',''),'std::vector<cmg::Photon>') ## dEdX #self.handles['dEdX'] = AutoHandle( ('dedxHarmonic2','','RECO'), 'edm::ValueMap<reco::DeDxData>' ) def beginLoop(self): super(ttHLepAnalyzerBase,self).beginLoop() self.counters.addCounter('events') count = self.counters.counter('events') count.register('all events') count.register('vetoed events') count.register('accepted events') #------------------ # MAKE LEPTON LISTS #------------------ # the muons are already corrected with Rochester corrections, are already cleaned with the ghost cleaning # the electrons have already the electron energy regression and calibration applied # the V5_10_0 cmgTuple, have been corrected with Mike's patch for the SIP computation -> cmgMuons have been remade -> # (cvs up -r michalis_sipPatchBranch CMGTools/Common/src/MuonFactory.cc) # nb: the event vertex needs to be defined first -> using the vertex analyzer # nb: in the following dxy and dz are computed with respect to the PV good vertex, sip with respect to the PV 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) #print "Found ",len(event.looseLeptons)," loose leptons" #print "Found ",len(event.selectedLeptons)," good leptons" def makePhotons(self, event): event.allphotons = map( Photon, self.handles['photons'].product() ) event.allphotons.sort(key = lambda l : l.pt(), reverse = True) def process(self, iEvent, event): self.readCollections( iEvent ) self.counters.counter('events').inc('all events') eventNumber = iEvent.eventAuxiliary().id().event() #print 'Event ',eventNumber #import pdb; pdb.set_trace() #call the leptons/photons functions self.makeLeptons(event) self.makePhotons(event) ret = False if len(event.selectedLeptons) >= self.cfg_ana.minGoodLeptons: ret = True if hasattr(self.cfg_ana, 'minInclusiveLeptons') and len(event.inclusiveLeptons) < self.cfg_ana.minInclusiveLeptons: if ret: self.counters.counter('events').inc('vetoed events') ret = False if hasattr(self.cfg_ana, 'maxGoodLeptons') and len(event.selectedLeptons) > self.cfg_ana.maxGoodLeptons: if ret: self.counters.counter('events').inc('vetoed events') ret = False #if self.cfg_ana.doSSLeptons and len(event.selectedLeptons) >= 2: # if event.selectedLeptons[0].charge() == event.selectedLeptons[1].charge(): # ret = True if ret: self.counters.counter('events').inc('accepted events') return ret