objects.LeptonAnalyzer.LeptonAnalyzer Class Reference

Inheritance diagram for objects.LeptonAnalyzer.LeptonAnalyzer:

Public Member Functions
def	__init__ (self, cfg_ana, cfg_comp, looperName)
def	attachIsoAnnulus04 (self, mu)
def	attachIsolationScan (self, mu)
def	attachMiniIsolation (self, mu)
def	beginLoop (self, setup)
def	declareHandles (self)
def	isFromB (self, particle, bid=5, done={})
def	makeAllElectrons (self, event)
def	makeAllMuons (self, event)
def	makeLeptons (self, event)
def	matchAnyLeptons (self, event)
def	matchLeptons (self, event)
def	matchToPhotons (self, event)
def	process (self, event)

Public Attributes
	muonScaleCorrector

Static Public Attributes
	class_object
	conf
	doIsoAnnulus
	doIsolationScan
	doMatchToPhotons
	doMiniIsolation
	electronEnergyCalibrator
	electrons
	eleEffectiveArea
	Duplicate removal for fast sim (to be checked if still necessary in latest greatest 5.3.X releases) More...
	eleIsoCut
	IsolationComputer
	miniIsolationPUCorr
	miniIsolationVetoLeptons
	inclusive leptons = all leptons that could be considered somewhere in the analysis, with minimal requirements (used e.g. More...
	muEffectiveArea
	muIsoCut
	muons
	rhoElectron
	rhoMuon
	verbose

Detailed Description

Definition at line 23 of file LeptonAnalyzer.py.

Constructor & Destructor Documentation

__init__()

def objects.LeptonAnalyzer.LeptonAnalyzer.__init__	(		self,
			cfg_ana,
			cfg_comp,
			looperName
	)

Definition at line 26 of file LeptonAnalyzer.py.

References analyzer.Analyzer.cfg_ana, analyzer.Analyzer.cfg_comp, and looper.Looper.cfg_comp.

    def __init__(self, cfg_ana, cfg_comp, looperName ):
        super(LeptonAnalyzer,self).__init__(cfg_ana,cfg_comp,looperName)
        if hasattr(self.cfg_ana, 'doMuScleFitCorrections'):
            raise RuntimeError("doMuScleFitCorrections is not supported. Please set instead doMuonScaleCorrections = ( 'MuScleFit', <name> )")
        if hasattr(self.cfg_ana, 'doRochesterCorrections'):
            raise RuntimeError("doRochesterCorrections is not supported. Please set instead doMuonScaleCorrections = ( 'Rochester', <name> )")
        if self.cfg_ana.doMuonScaleCorrections:
            algo, options = self.cfg_ana.doMuonScaleCorrections
            if algo == "Kalman":
                corr = options['MC' if self.cfg_comp.isMC else 'Data']
                self.muonScaleCorrector = KalmanMuonCorrector(corr, 
                                                    self.cfg_comp.isMC,
                                                    options['isSync'] if 'isSync' in options else False,
                                                    options['smearMode'] if 'smearMode' in options else "ebe")
            elif algo == "Rochester":
                print("WARNING: the Rochester correction in heppy is still from Run 1")
                self.muonScaleCorrector = RochesterCorrections()
            elif algo == "MuScleFit":
                print("WARNING: the MuScleFit correction in heppy is still from Run 1 (and probably no longer functional)")
                if options not in [ "prompt", "prompt-sync", "rereco", "rereco-sync" ]:
                    raise RuntimeError('MuScleFit correction name must be one of [ "prompt", "prompt-sync", "rereco", "rereco-sync" ] ')
                    rereco = ("prompt" not in self.cfg_ana.doMuScleFitCorrections)
                    sync   = ("sync"       in self.cfg_ana.doMuScleFitCorrections)
                    self.muonScaleCorrector = MuScleFitCorr(cfg_comp.isMC, rereco, sync)
            else: raise RuntimeError("Unknown muon scale correction algorithm")
        else:
            self.muonScaleCorrector = None

Member Function Documentation

attachIsoAnnulus04()

def objects.LeptonAnalyzer.LeptonAnalyzer.attachIsoAnnulus04	(		self,
			mu
	)

Definition at line 480 of file LeptonAnalyzer.py.

References objects.LeptonAnalyzer.LeptonAnalyzer.IsolationComputer, SiStripPI.max, and SiStripPI.min.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons().

    def attachIsoAnnulus04(self, mu):  # annulus isolation with outer cone of 0.4 and delta beta PU correction
        mu.miniIsoR = 10.0/min(max(mu.pt(), 50),200)
        mu.absIsoAnCharged = self.IsolationComputer.chargedAbsIso      (mu.physObj, 0.4, mu.miniIsoR, 0.0, self.IsolationComputer.selfVetoNone)
        mu.absIsoAnPho     = self.IsolationComputer.photonAbsIsoRaw    (mu.physObj, 0.4, mu.miniIsoR, 0.0, self.IsolationComputer.selfVetoNone) 
        mu.absIsoAnNHad    = self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, 0.4, mu.miniIsoR, 0.0, self.IsolationComputer.selfVetoNone) 
        mu.absIsoAnPU      = self.IsolationComputer.puAbsIso           (mu.physObj, 0.4, mu.miniIsoR, 0.0, self.IsolationComputer.selfVetoNone)
        mu.absIsoAnNeutral = max(0.0, mu.absIsoAnPho + mu.absIsoAnNHad - 0.5*mu.absIsoAnPU)

        mu.absIsoAn04 = mu.absIsoAnCharged + mu.absIsoAnNeutral
        mu.relIsoAn04 = mu.absIsoAn04/mu.pt()

attachIsolationScan()

def objects.LeptonAnalyzer.LeptonAnalyzer.attachIsolationScan	(		self,
			mu
	)

Definition at line 492 of file LeptonAnalyzer.py.

References funct.abs(), and objects.LeptonAnalyzer.LeptonAnalyzer.IsolationComputer.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons().

    def attachIsolationScan(self, mu):

        what = "mu" if (abs(mu.pdgId()) == 13) else ("eleB" if mu.isEB() else "eleE")
        vetoreg = {"mu":0.0001,"eleB":0,"eleE":0.015}[what]

        if what=="mu":
            mu.ScanAbsIsoCharged005 = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.05, vetoreg, 0.0)
            mu.ScanAbsIsoCharged01  = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.1, vetoreg, 0.0)
            mu.ScanAbsIsoCharged02  = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.2, vetoreg, 0.0)
            mu.ScanAbsIsoCharged03  = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.3, vetoreg, 0.0)
            mu.ScanAbsIsoCharged04  = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.4, vetoreg, 0.0)
        else:
            mu.ScanAbsIsoCharged005 = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.05, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)
            mu.ScanAbsIsoCharged01  = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.1, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)
            mu.ScanAbsIsoCharged02  = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.2, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)
            mu.ScanAbsIsoCharged03  = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.3, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)
            mu.ScanAbsIsoCharged04  = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.4, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)

        if what=="mu":
            mu.ScanAbsIsoNeutral005 = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, 0.05, 0.01, 0.5)
            mu.ScanAbsIsoNeutral01  = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, 0.1,  0.01, 0.5)
            mu.ScanAbsIsoNeutral02  = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, 0.2,  0.01, 0.5)
            mu.ScanAbsIsoNeutral03  = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, 0.3,  0.01, 0.5)
            mu.ScanAbsIsoNeutral04  = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, 0.4,  0.01, 0.5)
        else:
            vetoreg = {"eleB":0.0,"eleE":0.08}[what]
            mu.ScanAbsIsoNeutral005 = self.IsolationComputer.photonAbsIsoRaw(mu.physObj, 0.05, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)+self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, 0.05, 0.0, 0.0, self.IsolationComputer.selfVetoNone)
            mu.ScanAbsIsoNeutral01 = self.IsolationComputer.photonAbsIsoRaw(mu.physObj, 0.1, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)+self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, 0.1, 0.0, 0.0, self.IsolationComputer.selfVetoNone)
            mu.ScanAbsIsoNeutral02 = self.IsolationComputer.photonAbsIsoRaw(mu.physObj, 0.2, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)+self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, 0.2, 0.0, 0.0, self.IsolationComputer.selfVetoNone)
            mu.ScanAbsIsoNeutral03 = self.IsolationComputer.photonAbsIsoRaw(mu.physObj, 0.3, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)+self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, 0.3, 0.0, 0.0, self.IsolationComputer.selfVetoNone)
            mu.ScanAbsIsoNeutral04 = self.IsolationComputer.photonAbsIsoRaw(mu.physObj, 0.4, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)+self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, 0.4, 0.0, 0.0, self.IsolationComputer.selfVetoNone)

attachMiniIsolation()

def objects.LeptonAnalyzer.LeptonAnalyzer.attachMiniIsolation	(		self,
			mu
	)

Definition at line 435 of file LeptonAnalyzer.py.

References funct.abs(), analyzer.Analyzer.cfg_ana, objects.LeptonAnalyzer.LeptonAnalyzer.IsolationComputer, SiStripPI.max, SiStripPI.min, and objects.LeptonAnalyzer.LeptonAnalyzer.miniIsolationPUCorr.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons().

    def attachMiniIsolation(self, mu):
        mu.miniIsoR = 10.0/min(max(mu.pt(), 50),200) 
        # -- version with increasing cone at low pT, gives slightly better performance for tight cuts and low pt leptons
        # mu.miniIsoR = 10.0/min(max(mu.pt(), 50),200) if mu.pt() > 20 else 4.0/min(max(mu.pt(),10),20) 
        what = "mu" if (abs(mu.pdgId()) == 13) else ("eleB" if mu.isEB() else "eleE")
        if what == "mu":
            mu.miniAbsIsoCharged = self.IsolationComputer.chargedAbsIso(mu.physObj, mu.miniIsoR, {"mu":0.0001,"eleB":0,"eleE":0.015}[what], 0.0);
        else:
            mu.miniAbsIsoCharged = self.IsolationComputer.chargedAbsIso(mu.physObj, mu.miniIsoR, {"mu":0.0001,"eleB":0,"eleE":0.015}[what], 0.0,self.IsolationComputer.selfVetoNone);

        if self.miniIsolationPUCorr == None: puCorr = self.cfg_ana.mu_isoCorr if what=="mu" else self.cfg_ana.ele_isoCorr
        else: puCorr = self.miniIsolationPUCorr

        if puCorr == "weights":
            if what == "mu":
                mu.miniAbsIsoNeutral = self.IsolationComputer.neutralAbsIsoWeighted(mu.physObj, mu.miniIsoR, 0.01, 0.5);
            else:
                mu.miniAbsIsoNeutral = ( self.IsolationComputer.photonAbsIsoWeighted(    mu.physObj, mu.miniIsoR, 0.08 if what == "eleE" else 0.0, 0.0, self.IsolationComputer.selfVetoNone) + 
                                         self.IsolationComputer.neutralHadAbsIsoWeighted(mu.physObj, mu.miniIsoR, 0.0, 0.0, self.IsolationComputer.selfVetoNone) )
        else:
            if what == "mu":
                mu.miniAbsIsoNeutral = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, mu.miniIsoR, 0.01, 0.5);
            else:
                mu.miniAbsIsoPho  = self.IsolationComputer.photonAbsIsoRaw(    mu.physObj, mu.miniIsoR, 0.08 if what == "eleE" else 0.0, 0.0, self.IsolationComputer.selfVetoNone) 
                mu.miniAbsIsoNHad = self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, mu.miniIsoR, 0.0, 0.0, self.IsolationComputer.selfVetoNone) 
                mu.miniAbsIsoNeutral = mu.miniAbsIsoPho + mu.miniAbsIsoNHad  
                # -- version relying on PF candidate vetos; apparently less performant, and the isolation computed at RECO level doesn't have them 
                #mu.miniAbsIsoPhoSV  = self.IsolationComputer.photonAbsIsoRaw(    mu.physObj, mu.miniIsoR, 0.0, 0.0) 
                #mu.miniAbsIsoNHadSV = self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, mu.miniIsoR, 0.0, 0.0) 
                #mu.miniAbsIsoNeutral = mu.miniAbsIsoPhoSV + mu.miniAbsIsoNHadSV  
            if puCorr == "rhoArea":
                mu.miniAbsIsoNeutral = max(0.0, mu.miniAbsIsoNeutral - mu.rho * mu.EffectiveArea03 * (mu.miniIsoR/0.3)**2)
            elif puCorr == "deltaBeta":
                if what == "mu":
                    mu.miniAbsIsoPU = self.IsolationComputer.puAbsIso(mu.physObj, mu.miniIsoR, 0.01, 0.5);
                else:
                    mu.miniAbsIsoPU = self.IsolationComputer.puAbsIso(mu.physObj, mu.miniIsoR, 0.015 if what == "eleE" else 0.0, 0.0,self.IsolationComputer.selfVetoNone);
                mu.miniAbsIsoNeutral = max(0.0, mu.miniAbsIsoNeutral - 0.5*mu.miniAbsIsoPU)
            elif puCorr != 'raw':
                raise RuntimeError("Unsupported miniIsolationCorr name '" + puCorr +  "'! For now only 'rhoArea', 'deltaBeta', 'raw', 'weights' are supported (and 'weights' is not tested).")

        mu.miniAbsIso = mu.miniAbsIsoCharged + mu.miniAbsIsoNeutral
        mu.miniRelIso = mu.miniAbsIso/mu.pt()

beginLoop()

def objects.LeptonAnalyzer.LeptonAnalyzer.beginLoop	(		self,
			setup
	)

Definition at line 136 of file LeptonAnalyzer.py.

References CSCSPEvent.counters(), cms::cuda::AtomicPairCounter::Atomic2.counters, NMaxPerLumi.counters, analyzer.Analyzer.counters, HistogramManager.counters, counter.Counters.counters, and cscdqm::ChamberCounterKeyType.counters.

    def beginLoop(self, setup):
        super(LeptonAnalyzer,self).beginLoop(setup)
        self.counters.addCounter('events')
        count = self.counters.counter('events')
        count.register('all events')

declareHandles()

def objects.LeptonAnalyzer.LeptonAnalyzer.declareHandles

(

self

)

Definition at line 115 of file LeptonAnalyzer.py.

References analyzer.Analyzer.cfg_ana, objects.LeptonAnalyzer.LeptonAnalyzer.doIsolationScan, objects.LeptonAnalyzer.LeptonAnalyzer.doMatchToPhotons, objects.LeptonAnalyzer.LeptonAnalyzer.doMiniIsolation, core.AutoHandle.AutoHandle.handles, core.Analyzer.Analyzer.handles, HTTP.RequestManager.handles, and core.Analyzer.Analyzer.mchandles.

    def declareHandles(self):
        super(LeptonAnalyzer, self).declareHandles()

        #leptons
        self.handles['muons'] = AutoHandle(self.cfg_ana.muons,"std::vector<pat::Muon>")            
        self.handles['electrons'] = AutoHandle(self.cfg_ana.electrons,"std::vector<pat::Electron>")            
    
        #rho for muons
        self.handles['rhoMu'] = AutoHandle( self.cfg_ana.rhoMuon, 'double')
        #rho for electrons
        self.handles['rhoEle'] = AutoHandle( self.cfg_ana.rhoElectron, 'double')

        if self.doMiniIsolation or self.doIsolationScan:
            self.handles['packedCandidates'] = AutoHandle( self.cfg_ana.packedCandidates, 'std::vector<pat::PackedCandidate>')

        if self.doMatchToPhotons:
            if self.doMatchToPhotons == "any":
                self.mchandles['genPhotons'] = AutoHandle( 'packedGenParticles', 'std::vector<pat::PackedGenParticle>' )
            else:
                self.mchandles['genPhotons'] = AutoHandle( 'prunedGenParticles', 'std::vector<reco::GenParticle>' )

isFromB()

def objects.LeptonAnalyzer.LeptonAnalyzer.isFromB	(		self,
			particle,
			bid = 5,
			done = {}
	)

Definition at line 546 of file LeptonAnalyzer.py.

References funct.abs(), objects.LeptonAnalyzer.LeptonAnalyzer.isFromB(), and FastTimerService_cff.range.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.isFromB(), and objects.LeptonAnalyzer.LeptonAnalyzer.matchAnyLeptons().

    def isFromB(self,particle,bid=5, done={}):
        for i in range( particle.numberOfMothers() ): 
            mom  = particle.mother(i)
            momid = abs(mom.pdgId())
            if momid / 1000 == bid or momid / 100 == bid or momid == bid: 
                return True
            elif mom.status() == 2 and self.isFromB(mom, done=done, bid=bid):
                return True
        return False

makeAllElectrons()

def objects.LeptonAnalyzer.LeptonAnalyzer.makeAllElectrons	(		self,
			event
	)

       make a list of all electrons, and apply basic corrections to them

Definition at line 320 of file LeptonAnalyzer.py.

References funct.abs(), analyzer.Analyzer.cfg_ana, objects.LeptonAnalyzer.LeptonAnalyzer.electronEnergyCalibrator, objects.LeptonAnalyzer.LeptonAnalyzer.eleEffectiveArea, PVValHelper.eta, dqmMemoryStats.float, core.AutoHandle.AutoHandle.handles, core.Analyzer.Analyzer.handles, HTTP.RequestManager.handles, genParticles_cff.map, SiStripPI.max, and str.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons().

    def makeAllElectrons(self, event):
        """
               make a list of all electrons, and apply basic corrections to them
        """
        allelectrons = map( Electron, self.handles['electrons'].product() )

        
        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])
          if self.eleEffectiveArea == "Data2012":
              # https://twiki.cern.ch/twiki/bin/viewauth/CMS/EgammaEARhoCorrection?rev=14
              SCEta = abs(ele.superCluster().eta())
              if   SCEta < 1.0  : ele.EffectiveArea03 = 0.13 # 0.130;
              elif SCEta < 1.479: ele.EffectiveArea03 = 0.14 # 0.137;
              elif SCEta < 2.0  : ele.EffectiveArea03 = 0.07 # 0.067;
              elif SCEta < 2.2  : ele.EffectiveArea03 = 0.09 # 0.089;
              elif SCEta < 2.3  : ele.EffectiveArea03 = 0.11 # 0.107;
              elif SCEta < 2.4  : ele.EffectiveArea03 = 0.11 # 0.110;
              else              : ele.EffectiveArea03 = 0.14 # 0.138;
              if   SCEta < 1.0  : ele.EffectiveArea04 = 0.208;
              elif SCEta < 1.479: ele.EffectiveArea04 = 0.209;
              elif SCEta < 2.0  : ele.EffectiveArea04 = 0.115;
              elif SCEta < 2.2  : ele.EffectiveArea04 = 0.143;
              elif SCEta < 2.3  : ele.EffectiveArea04 = 0.183;
              elif SCEta < 2.4  : ele.EffectiveArea04 = 0.194;
              else              : ele.EffectiveArea04 = 0.261;
          elif self.eleEffectiveArea == "Phys14_25ns_v1":
              aeta = abs(ele.eta())
              if   aeta < 0.800: ele.EffectiveArea03 = 0.1013
              elif aeta < 1.300: ele.EffectiveArea03 = 0.0988
              elif aeta < 2.000: ele.EffectiveArea03 = 0.0572
              elif aeta < 2.200: ele.EffectiveArea03 = 0.0842
              else:              ele.EffectiveArea03 = 0.1530
              if   aeta < 0.800: ele.EffectiveArea04 = 0.1830 
              elif aeta < 1.300: ele.EffectiveArea04 = 0.1734 
              elif aeta < 2.000: ele.EffectiveArea04 = 0.1077 
              elif aeta < 2.200: ele.EffectiveArea04 = 0.1565 
              else:              ele.EffectiveArea04 = 0.2680
          elif self.eleEffectiveArea == "Spring15_50ns_v1":
              SCEta = abs(ele.superCluster().eta())
              
              if   SCEta < 0.800: ele.EffectiveArea03 = 0.0973
              elif SCEta < 1.300: ele.EffectiveArea03 = 0.0954
              elif SCEta < 2.000: ele.EffectiveArea03 = 0.0632
              elif SCEta < 2.200: ele.EffectiveArea03 = 0.0727
              else:              ele.EffectiveArea03 = 0.1337
              # warning: EAs not computed for cone DR=0.4 yet. Do not correct
              ele.EffectiveArea04 = 0.0
          elif self.eleEffectiveArea == "Spring15_25ns_v1":
              SCEta = abs(ele.superCluster().eta())
              
              if   SCEta < 1.000: ele.EffectiveArea03 = 0.1752
              elif SCEta < 1.479: ele.EffectiveArea03 = 0.1862
              elif SCEta < 2.000: ele.EffectiveArea03 = 0.1411
              elif SCEta < 2.200: ele.EffectiveArea03 = 0.1534
              elif SCEta < 2.300: ele.EffectiveArea03 = 0.1903
              elif SCEta < 2.400: ele.EffectiveArea03 = 0.2243
              else:              ele.EffectiveArea03 = 0.2687
              # warning: EAs not computed for cone DR=0.4 yet. Do not correct
              ele.EffectiveArea04 = 0.0
          else: raise RuntimeError("Unsupported value for ele_effectiveAreas: can only use Data2012 (rho: ?), Phys14_v1 and Spring15_v1 (rho: fixedGridRhoFastjetAll)")

        # 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] if len(event.goodVertices)>0 else event.vertices[0]

        # Compute relIso with R=0.3 and R=0.4 cones
        for ele in allelectrons:
            if self.cfg_ana.ele_isoCorr=="rhoArea" :
                 ele.absIso03 = (ele.chargedHadronIsoR(0.3) + max(ele.neutralHadronIsoR(0.3)+ele.photonIsoR(0.3)-ele.rho*ele.EffectiveArea03,0))
                 ele.absIso04 = (ele.chargedHadronIsoR(0.4) + max(ele.neutralHadronIsoR(0.4)+ele.photonIsoR(0.4)-ele.rho*ele.EffectiveArea04,0))
            elif self.cfg_ana.ele_isoCorr=="deltaBeta" :
                 ele.absIso03 = (ele.chargedHadronIsoR(0.3) + max( ele.neutralHadronIsoR(0.3)+ele.photonIsoR(0.3) - ele.puChargedHadronIsoR(0.3)/2, 0.0))
                 ele.absIso04 = (ele.chargedHadronIsoR(0.4) + max( ele.neutralHadronIsoR(0.4)+ele.photonIsoR(0.4) - ele.puChargedHadronIsoR(0.4)/2, 0.0))
            else :
                 raise RuntimeError("Unsupported ele_isoCorr name '" + str(self.cfg_ana.ele_isoCorr) +  "'! For now only 'rhoArea' and 'deltaBeta' are supported.")
            ele.relIso03 = ele.absIso03/ele.pt()
            ele.relIso04 = ele.absIso04/ele.pt()

        # Set tight MVA id
        for ele in allelectrons:
            if self.cfg_ana.ele_tightId=="MVA" :
                 ele.tightIdResult = ele.electronID("POG_MVA_ID_Trig_full5x5")
            elif self.cfg_ana.ele_tightId=="Cuts_2012" :
                 ele.tightIdResult = -1 + 1*ele.electronID("POG_Cuts_ID_2012_Veto_full5x5") + 1*ele.electronID("POG_Cuts_ID_2012_Loose_full5x5") + 1*ele.electronID("POG_Cuts_ID_2012_Medium_full5x5") + 1*ele.electronID("POG_Cuts_ID_2012_Tight_full5x5")
            elif self.cfg_ana.ele_tightId=="Cuts_PHYS14_25ns_v1_ConvVetoDxyDz" :
                 ele.tightIdResult = -1 + 1*ele.electronID("POG_Cuts_ID_PHYS14_25ns_v1_ConvVetoDxyDz_Veto_full5x5") + 1*ele.electronID("POG_Cuts_ID_PHYS14_25ns_v1_ConvVetoDxyDz_Loose_full5x5") + 1*ele.electronID("POG_Cuts_ID_PHYS14_25ns_v1_ConvVetoDxyDz_Medium_full5x5") + 1*ele.electronID("POG_Cuts_ID_PHYS14_25ns_v1_ConvVetoDxyDz_Tight_full5x5")
            elif self.cfg_ana.ele_tightId=="Cuts_SPRING15_25ns_v1_ConvVetoDxyDz" :
                 ele.tightIdResult = -1 + 1*ele.electronID("POG_Cuts_ID_SPRING15_25ns_v1_ConvVetoDxyDz_Veto_full5x5") + 1*ele.electronID("POG_Cuts_ID_SPRING15_25ns_v1_ConvVetoDxyDz_Loose_full5x5") + 1*ele.electronID("POG_Cuts_ID_SPRING15_25ns_v1_ConvVetoDxyDz_Medium_full5x5") + 1*ele.electronID("POG_Cuts_ID_SPRING15_25ns_v1_ConvVetoDxyDz_Tight_full5x5")

            else :
                 try:
                     ele.tightIdResult = ele.electronID(self.cfg_ana.ele_tightId)
                 except RuntimeError:
                     raise RuntimeError("Unsupported ele_tightId name '" + str(self.cfg_ana.ele_tightId) +  "'! For now only 'MVA' and 'Cuts_2012' are supported, in addition to what provided in Electron.py.")

        
        return allelectrons 

makeAllMuons()

def objects.LeptonAnalyzer.LeptonAnalyzer.makeAllMuons	(		self,
			event
	)

       make a list of all muons, and apply basic corrections to them

Definition at line 240 of file LeptonAnalyzer.py.

References funct.abs(), analyzer.Analyzer.cfg_ana, dqmMemoryStats.float, core.AutoHandle.AutoHandle.handles, core.Analyzer.Analyzer.handles, HTTP.RequestManager.handles, genParticles_cff.map, SiStripPI.max, objects.LeptonAnalyzer.LeptonAnalyzer.muEffectiveArea, objects.LeptonAnalyzer.LeptonAnalyzer.muonScaleCorrector, and str.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons().

    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.muonScaleCorrector:
            self.muonScaleCorrector.correct_all(allmuons, event.run)

        # 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 EAs for isolation:
        for mu in allmuons:
          mu.rho = float(self.handles['rhoMu'].product()[0])
          if self.muEffectiveArea == "Data2012":
              if   aeta < 1.0  : mu.EffectiveArea03 = 0.382;
              elif aeta < 1.47 : mu.EffectiveArea03 = 0.317;
              elif aeta < 2.0  : mu.EffectiveArea03 = 0.242;
              elif aeta < 2.2  : mu.EffectiveArea03 = 0.326;
              elif aeta < 2.3  : mu.EffectiveArea03 = 0.462;
              else             : mu.EffectiveArea03 = 0.372;
              if   aeta < 1.0  : mu.EffectiveArea04 = 0.674;
              elif aeta < 1.47 : mu.EffectiveArea04 = 0.565;
              elif aeta < 2.0  : mu.EffectiveArea04 = 0.442;
              elif aeta < 2.2  : mu.EffectiveArea04 = 0.515;
              elif aeta < 2.3  : mu.EffectiveArea04 = 0.821;
              else             : mu.EffectiveArea04 = 0.660;
          elif self.muEffectiveArea == "Phys14_25ns_v1":
              aeta = abs(mu.eta())
              if   aeta < 0.800: mu.EffectiveArea03 = 0.0913
              elif aeta < 1.300: mu.EffectiveArea03 = 0.0765
              elif aeta < 2.000: mu.EffectiveArea03 = 0.0546
              elif aeta < 2.200: mu.EffectiveArea03 = 0.0728
              else:              mu.EffectiveArea03 = 0.1177
              if   aeta < 0.800: mu.EffectiveArea04 = 0.1564
              elif aeta < 1.300: mu.EffectiveArea04 = 0.1325
              elif aeta < 2.000: mu.EffectiveArea04 = 0.0913
              elif aeta < 2.200: mu.EffectiveArea04 = 0.1212
              else:              mu.EffectiveArea04 = 0.2085
          elif self.muEffectiveArea == "Spring15_25ns_v1":
              aeta = abs(mu.eta())
              if   aeta < 0.800: mu.EffectiveArea03 = 0.0735
              elif aeta < 1.300: mu.EffectiveArea03 = 0.0619
              elif aeta < 2.000: mu.EffectiveArea03 = 0.0465
              elif aeta < 2.200: mu.EffectiveArea03 = 0.0433
              else:              mu.EffectiveArea03 = 0.0577
              mu.EffectiveArea04 = 0 # not computed
          else: raise RuntimeError("Unsupported value for mu_effectiveAreas: can only use Data2012 (rho: ?) and Phys14_25ns_v1 or Spring15_25ns_v1 (rho: fixedGridRhoFastjetAll)")
        # Attach the vertex to them, for dxy/dz calculation
        for mu in allmuons:
            mu.associatedVertex = event.goodVertices[0] if len(event.goodVertices)>0 else event.vertices[0]
            mu.setTrackForDxyDz(self.cfg_ana.muon_dxydz_track)

        # Set tight id if specified
        if hasattr(self.cfg_ana, "mu_tightId"):
            for mu in allmuons:
               mu.tightIdResult = mu.muonID(self.cfg_ana.mu_tightId)
 
        # Compute relIso in 0.3 and 0.4 cones
        for mu in allmuons:
            if self.cfg_ana.mu_isoCorr=="rhoArea" :
                mu.absIso03 = (mu.pfIsolationR03().sumChargedHadronPt + max( mu.pfIsolationR03().sumNeutralHadronEt +  mu.pfIsolationR03().sumPhotonEt - mu.rho * mu.EffectiveArea03,0.0))
                mu.absIso04 = (mu.pfIsolationR04().sumChargedHadronPt + max( mu.pfIsolationR04().sumNeutralHadronEt +  mu.pfIsolationR04().sumPhotonEt - mu.rho * mu.EffectiveArea04,0.0))
            elif self.cfg_ana.mu_isoCorr=="deltaBeta" :
                mu.absIso03 = (mu.pfIsolationR03().sumChargedHadronPt + max( mu.pfIsolationR03().sumNeutralHadronEt +  mu.pfIsolationR03().sumPhotonEt -  mu.pfIsolationR03().sumPUPt/2,0.0))
                mu.absIso04 = (mu.pfIsolationR04().sumChargedHadronPt + max( mu.pfIsolationR04().sumNeutralHadronEt +  mu.pfIsolationR04().sumPhotonEt -  mu.pfIsolationR04().sumPUPt/2,0.0))
            else :
                raise RuntimeError("Unsupported mu_isoCorr name '" + str(self.cfg_ana.mu_isoCorr) +  "'! For now only 'rhoArea' and 'deltaBeta' are supported.")
            mu.relIso03 = mu.absIso03/mu.pt()
            mu.relIso04 = mu.absIso04/mu.pt()
        return allmuons

makeLeptons()

def objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons	(		self,
			event
	)

Definition at line 147 of file LeptonAnalyzer.py.

References funct.abs(), objects.LeptonAnalyzer.LeptonAnalyzer.attachIsoAnnulus04(), objects.LeptonAnalyzer.LeptonAnalyzer.attachIsolationScan(), objects.LeptonAnalyzer.LeptonAnalyzer.attachMiniIsolation(), deltar.bestMatch(), analyzer.Analyzer.cfg_ana, objects.IsoTrackAnalyzer.IsoTrackAnalyzer.doIsoAnnulus, objects.LeptonAnalyzer.LeptonAnalyzer.doIsoAnnulus, objects.LeptonAnalyzer.LeptonAnalyzer.doIsolationScan, objects.LeptonAnalyzer.LeptonAnalyzer.doMiniIsolation, RPCDQMObject::DQMObjectItem.efficiency, dqmTnP::AbstractFitter.efficiency, DQMGenericClient.efficiency, CSCChamberSpecs.efficiency(), pat::PATObject< reco::MET >.efficiency(), pat::PATObject< ObjectType >.efficiency(), pat::PATObject< reco::GsfElectron >.efficiency(), pat::PATObject< reco::LeafCandidate >.efficiency(), pat::PATObject< reco::Muon >.efficiency(), Lepton< LeptonType >.efficiency(), pat::PATObject< reco::BaseTau >.efficiency(), pat::PATObject< reco::CompositeCandidate >.efficiency(), pat::PATObject< reco::RecoCandidate >.efficiency(), pat::PATObject< reco::PFCandidate >.efficiency(), pat::PATObject< reco::Jet >.efficiency(), pat::PATObject< LeptonType >.efficiency(), pat::PATObject< reco::Photon >.efficiency(), objects.LeptonAnalyzer.LeptonAnalyzer.eleIsoCut, core.AutoHandle.AutoHandle.handles, core.Analyzer.Analyzer.handles, HTTP.RequestManager.handles, objects.LeptonAnalyzer.LeptonAnalyzer.IsolationComputer, objects.LeptonAnalyzer.LeptonAnalyzer.makeAllElectrons(), objects.LeptonAnalyzer.LeptonAnalyzer.makeAllMuons(), objects.LeptonAnalyzer.LeptonAnalyzer.miniIsolationVetoLeptons, and objects.LeptonAnalyzer.LeptonAnalyzer.muIsoCut.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.process().

    def makeLeptons(self, event):
        
        event.inclusiveLeptons = []
        
        event.selectedLeptons = []
        event.selectedMuons = []
        event.selectedElectrons = []
        event.otherLeptons = []

        if self.doMiniIsolation or self.doIsolationScan:
            self.IsolationComputer.setPackedCandidates(self.handles['packedCandidates'].product())
        if self.doMiniIsolation:
            if self.miniIsolationVetoLeptons == "any":
                for lep in self.handles['muons'].product(): 
                    self.IsolationComputer.addVetos(lep)
                for lep in self.handles['electrons'].product(): 
                    self.IsolationComputer.addVetos(lep)

        #muons
        allmuons = self.makeAllMuons(event)

        #electrons        
        allelectrons = self.makeAllElectrons(event)

        #make inclusive leptons
        inclusiveMuons = []
        inclusiveElectrons = []
        for mu in allmuons:
            if (mu.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):
                inclusiveMuons.append(mu)
        for ele in allelectrons:
            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.lostInner()<=self.cfg_ana.inclusive_electron_lostHits ):
                inclusiveElectrons.append(ele)
        event.inclusiveLeptons = inclusiveMuons + inclusiveElectrons
 
        if self.doMiniIsolation:
            if self.miniIsolationVetoLeptons == "inclusive":
                for lep in event.inclusiveLeptons: 
                    self.IsolationComputer.addVetos(lep.physObj)
            for lep in event.inclusiveLeptons:
                self.attachMiniIsolation(lep)
        
        if self.doIsoAnnulus:
            for lep in event.inclusiveLeptons:
                self.attachIsoAnnulus04(lep)

        if self.doIsolationScan:
            for lep in event.inclusiveLeptons:
                self.attachIsolationScan(lep)

        # make loose leptons (basic selection)
        for mu in inclusiveMuons:
                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
                        self.muIsoCut(mu)):
                    mu.looseIdSusy = True
                    event.selectedLeptons.append(mu)
                    event.selectedMuons.append(mu)
                else:
                    mu.looseIdSusy = False
                    event.otherLeptons.append(mu)
        looseMuons = event.selectedLeptons[:]
        for ele in inclusiveElectrons:
               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 
                         self.eleIsoCut(ele) and 
                         ele.lostInner() <= self.cfg_ana.loose_electron_lostHits and
                         ( True if getattr(self.cfg_ana,'notCleaningElectrons',False) else (bestMatch(ele, looseMuons)[1] > (self.cfg_ana.min_dr_electron_muon**2)) )):
                    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)

matchAnyLeptons()

def objects.LeptonAnalyzer.LeptonAnalyzer.matchAnyLeptons	(		self,
			event
	)

Definition at line 556 of file LeptonAnalyzer.py.

References funct.abs(), objects.LeptonAnalyzer.LeptonAnalyzer.isFromB(), genutils.isPromptLepton(), and deltar.matchObjectCollection3().

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.process().

    def matchAnyLeptons(self, event): 
        event.anyLeptons = [ x for x in event.genParticles if x.status() == 1 and abs(x.pdgId()) in [11,13] ]
        leps = event.inclusiveLeptons if hasattr(event, 'inclusiveLeptons') else event.selectedLeptons
        match = matchObjectCollection3(leps, event.anyLeptons, deltaRMax = 0.3, filter = lambda x,y : abs(x.pdgId()) == abs(y.pdgId()))
        for lep in leps:
            gen = match[lep]
            lep.mcMatchAny_gp = gen
            if gen:
                if   self.isFromB(gen):       lep.mcMatchAny = 5 # B (inclusive of B->D)
                elif self.isFromB(gen,bid=4): lep.mcMatchAny = 4 # Charm
                else: lep.mcMatchAny = 1
                if not getattr(lep, 'mcLep', None): lep.mcLep = gen
            else: 
                if not getattr(lep, 'mcLep', None): lep.mcLep = None
                lep.mcMatchAny = 0
            # fix case where the matching with the only prompt leptons failed, but we still ended up with a prompt match
            if gen != None and hasattr(lep,'mcMatchId') and lep.mcMatchId == 0:
                if isPromptLepton(gen, False) or (gen.isPromptFinalState() or gen.isDirectPromptTauDecayProductFinalState()): 
                    lep.mcMatchId = 100
                    lep.mcLep = gen
            elif not hasattr(lep,'mcMatchId'):
                lep.mcMatchId = 0
            if not hasattr(lep,'mcMatchTau'): lep.mcMatchTau = 0

matchLeptons()

def objects.LeptonAnalyzer.LeptonAnalyzer.matchLeptons	(		self,
			event
	)

Definition at line 525 of file LeptonAnalyzer.py.

References funct.abs(), analyzer.Analyzer.cfg_ana, PbPb_ZMuSkimMuonDPG_cff.deltaR, deltar.matchObjectCollection3(), SiStripPI.max, and SiStripPI.min.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.process().

    def matchLeptons(self, event):
        def plausible(rec,gen):
            if abs(rec.pdgId()) == 11 and abs(gen.pdgId()) != 11:   return False
            if abs(rec.pdgId()) == 13 and abs(gen.pdgId()) != 13:   return False
            dr = deltaR(rec.eta(),rec.phi(),gen.eta(),gen.phi())
            if dr < 0.3: return True
            if rec.pt() < 10 and abs(rec.pdgId()) == 13 and gen.pdgId() != rec.pdgId(): return False
            if dr < 0.7: return True
            if min(rec.pt(),gen.pt())/max(rec.pt(),gen.pt()) < 0.3: return False
            return True

        leps = event.inclusiveLeptons if self.cfg_ana.match_inclusiveLeptons else event.selectedLeptons
        match = matchObjectCollection3(leps, 
                                       event.genleps + event.gentauleps, 
                                       deltaRMax = 1.2, filter = plausible)
        for lep in leps:
            gen = match[lep]
            lep.mcMatchId  = (gen.sourceId if gen != None else  0)
            lep.mcMatchTau = (gen in event.gentauleps if gen else -99)
            lep.mcLep=gen

matchToPhotons()

def objects.LeptonAnalyzer.LeptonAnalyzer.matchToPhotons	(		self,
			event
	)

Definition at line 580 of file LeptonAnalyzer.py.

References funct.abs(), PbPb_ZMuSkimMuonDPG_cff.deltaR, HLT_2022v12_cff.distance, deltar.matchObjectCollection3(), core.Analyzer.Analyzer.mchandles, and SiStripPI.min.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.process().

    def matchToPhotons(self, event): 
        event.anyPho = [ x for x in self.mchandles['genPhotons'].product() if x.status() == 1 and x.pdgId() == 22 and x.pt() > 1.0 ]
        leps = event.inclusiveLeptons if hasattr(event, 'inclusiveLeptons') else event.selectedLeptons
        leps = [ l for l in leps if abs(l.pdgId()) == 11 ]
        plausible = lambda rec, gen : 0.3*gen.pt() < rec.pt() and rec.pt() < 1.5*gen.pt()
        match = matchObjectCollection3(leps, event.anyPho, deltaRMax = 0.3, filter = plausible)
        for lep in leps:
            gen = match[lep]
            lep.mcPho = gen
            if lep.mcPho and lep.mcLep:
                # I have both, I should keep the best one
                def distance(rec,gen): 
                    dr = deltaR(rec.eta(),rec.phi(),gen.eta(),gen.phi())
                    dptRel = abs(rec.pt()-gen.pt())/gen.pt()
                    return dr + 0.2*dptRel
                dpho = distance(lep,lep.mcPho)
                dlep = distance(lep,lep.mcLep)
                if getattr(lep,'mcMatchAny_gp',None) and lep.mcMatchAny_gp != lep.mcLep:
                    dlep = min(dlep, distance(lep,lep.mcMatchAny_gp))
                if dlep <= dpho: lep.mcPho = None

process()

def objects.LeptonAnalyzer.LeptonAnalyzer.process	(		self,
			event
	)

Definition at line 601 of file LeptonAnalyzer.py.

References analyzer.Analyzer.cfg_ana, analyzer.Analyzer.cfg_comp, looper.Looper.cfg_comp, CSCSPEvent.counters(), cms::cuda::AtomicPairCounter::Atomic2.counters, NMaxPerLumi.counters, analyzer.Analyzer.counters, HistogramManager.counters, counter.Counters.counters, cscdqm::ChamberCounterKeyType.counters, objects.LeptonAnalyzer.LeptonAnalyzer.doMatchToPhotons, objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons(), objects.LeptonAnalyzer.LeptonAnalyzer.matchAnyLeptons(), objects.LeptonAnalyzer.LeptonAnalyzer.matchLeptons(), objects.LeptonAnalyzer.LeptonAnalyzer.matchToPhotons(), and core.Analyzer.Analyzer.readCollections().

    def process(self, event):
        self.readCollections( event.input )
        self.counters.counter('events').inc('all events')

        #call the leptons functions
        self.makeLeptons(event)

        if self.cfg_comp.isMC and self.cfg_ana.do_mc_match:
            self.matchLeptons(event)
            self.matchAnyLeptons(event)
            if self.doMatchToPhotons:
                self.matchToPhotons(event)
            
        return True

#A default config
setattr(LeptonAnalyzer,"defaultConfig",cfg.Analyzer(

Member Data Documentation

class_object

objects.LeptonAnalyzer.LeptonAnalyzer.class_object

static

Definition at line 619 of file LeptonAnalyzer.py.

Referenced by config.Analyzer.build_name(), and config.Service.build_name().

conf

objects.LeptonAnalyzer.LeptonAnalyzer.conf

static

Definition at line 55 of file LeptonAnalyzer.py.

doIsoAnnulus

objects.LeptonAnalyzer.LeptonAnalyzer.doIsoAnnulus

static

Definition at line 94 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons().

doIsolationScan

objects.LeptonAnalyzer.LeptonAnalyzer.doIsolationScan

static

Definition at line 99 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.declareHandles(), and objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons().

doMatchToPhotons

objects.LeptonAnalyzer.LeptonAnalyzer.doMatchToPhotons

static

Definition at line 108 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.declareHandles(), and objects.LeptonAnalyzer.LeptonAnalyzer.process().

doMiniIsolation

objects.LeptonAnalyzer.LeptonAnalyzer.doMiniIsolation

static

Definition at line 83 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.declareHandles(), and objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons().

electronEnergyCalibrator

objects.LeptonAnalyzer.LeptonAnalyzer.electronEnergyCalibrator

static

Definition at line 56 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeAllElectrons().

electrons

objects.LeptonAnalyzer.LeptonAnalyzer.electrons

static

Definition at line 622 of file LeptonAnalyzer.py.

eleEffectiveArea

objects.LeptonAnalyzer.LeptonAnalyzer.eleEffectiveArea

static

Duplicate removal for fast sim (to be checked if still necessary in latest greatest 5.3.X releases)

--— https://github.com/ikrav/cmssw/blob/egm_id_747_v2/RecoEgamma/ElectronIdentification/data/Spring15/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_50ns.txt

Definition at line 80 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeAllElectrons().

eleIsoCut

objects.LeptonAnalyzer.LeptonAnalyzer.eleIsoCut

static

Definition at line 66 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons().

IsolationComputer

objects.LeptonAnalyzer.LeptonAnalyzer.IsolationComputer

static

Definition at line 90 of file LeptonAnalyzer.py.

Referenced by objects.PhotonAnalyzer.PhotonAnalyzer.attachFootprintRemovedIsolation(), objects.LeptonAnalyzer.LeptonAnalyzer.attachIsoAnnulus04(), objects.LeptonAnalyzer.LeptonAnalyzer.attachIsolationScan(), objects.LeptonAnalyzer.LeptonAnalyzer.attachMiniIsolation(), objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons(), and objects.PhotonAnalyzer.PhotonAnalyzer.makePhotons().

miniIsolationPUCorr

objects.LeptonAnalyzer.LeptonAnalyzer.miniIsolationPUCorr

static

Definition at line 85 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.attachMiniIsolation().

miniIsolationVetoLeptons

objects.LeptonAnalyzer.LeptonAnalyzer.miniIsolationVetoLeptons

static

inclusive leptons = all leptons that could be considered somewhere in the analysis, with minimal requirements (used e.g.

to match to MC) 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

Definition at line 86 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons().

muEffectiveArea

objects.LeptonAnalyzer.LeptonAnalyzer.muEffectiveArea

static

Definition at line 81 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeAllMuons().

muIsoCut

objects.LeptonAnalyzer.LeptonAnalyzer.muIsoCut

static

Definition at line 72 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons().

muons

objects.LeptonAnalyzer.LeptonAnalyzer.muons

static

Definition at line 621 of file LeptonAnalyzer.py.

muonScaleCorrector

objects.LeptonAnalyzer.LeptonAnalyzer.muonScaleCorrector

Definition at line 36 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeAllMuons().

rhoElectron

objects.LeptonAnalyzer.LeptonAnalyzer.rhoElectron

static

Definition at line 624 of file LeptonAnalyzer.py.

rhoMuon

objects.LeptonAnalyzer.LeptonAnalyzer.rhoMuon

static

Definition at line 623 of file LeptonAnalyzer.py.

verbose

objects.LeptonAnalyzer.LeptonAnalyzer.verbose

static

Definition at line 618 of file LeptonAnalyzer.py.

Referenced by python.diff_provenance.difference.list_diff(), python.diffProv.difference.list_diff(), python.diff_provenance.difference.module_diff(), python.diffProv.difference.module_diff(), python.diff_provenance.difference.onefilemodules(), python.diffProv.difference.onefilemodules(), and objects.VertexAnalyzer.VertexAnalyzer.process().