objects.PhotonAnalyzer.PhotonAnalyzer Class Reference

Inheritance diagram for objects.PhotonAnalyzer.PhotonAnalyzer:

Public Member Functions
def	__init__ (self, cfg_ana, cfg_comp, looperName)
def	attachFootprintRemovedIsolation (self, gamma)
def	beginLoop (self, setup)
def	checkMatch (self, eta, phi, particles, deltar)
def	computeRandomCone (self, event, eta, phi, deltarmax, charged, jets, photons)
def	declareHandles (self)
def	makePhotons (self, event)
def	matchPhotons (self, event)
def	printInfo (self, event)
def	process (self, event)
def	randomCone (self, event)

Public Attributes
	etaCentral
	IsolationComputer

Static Public Attributes
	class_object
	conf
	conversionSafe_eleVeto
	do_mc_match
	do_randomCone
	doFootprintRemovedIsolation
	doPhotonScaleCorrections
	etaMax
	footprintRemovedIsolationPUCorr
	gamma_isoCorr
	gammaID
	packedCandidates
	photonEnergyCalibrator
	photons
	ptMin
	rhoPhoton

Detailed Description

Definition at line 23 of file PhotonAnalyzer.py.

Constructor & Destructor Documentation

__init__()

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

Definition at line 26 of file PhotonAnalyzer.py.

    def __init__(self, cfg_ana, cfg_comp, looperName ):
        super(PhotonAnalyzer,self).__init__(cfg_ana,cfg_comp,looperName)
        self.etaCentral = self.cfg_ana.etaCentral  if hasattr(self.cfg_ana, 'etaCentral') else 9999
        # footprint removed isolation
        self.doFootprintRemovedIsolation = getattr(cfg_ana, 'doFootprintRemovedIsolation', False)
        if self.doFootprintRemovedIsolation:
            self.footprintRemovedIsolationPUCorr =  self.cfg_ana.footprintRemovedIsolationPUCorr
            self.IsolationComputer = heppy.IsolationComputer()

Member Function Documentation

attachFootprintRemovedIsolation()

def objects.PhotonAnalyzer.PhotonAnalyzer.attachFootprintRemovedIsolation	(		self,
			gamma
	)

Definition at line 301 of file PhotonAnalyzer.py.

    def attachFootprintRemovedIsolation(self, gamma):
        # cone deltar=0.3
        gamma.ftprAbsIsoCharged03 = self.IsolationComputer.chargedAbsIso(gamma.physObj, 0.3, 0, 0.0);
        gamma.ftprAbsIsoPho03     = self.IsolationComputer.photonAbsIsoRaw( gamma.physObj, 0.3, 0, 0.0);
        gamma.ftprAbsIsoNHad03    = self.IsolationComputer.neutralHadAbsIsoRaw( gamma.physObj, 0.3, 0, 0.0);
        gamma.ftprAbsIso03 = gamma.ftprAbsIsoCharged03 + gamma.ftprAbsIsoPho03 + gamma.ftprAbsIsoNHad03
        if self.cfg_ana.gamma_isoCorr == "rhoArea":
            gamma.ftprAbsIso03 = (max(gamma.ftprAbsIsoCharged03-gamma.rho*gamma.EffectiveArea03[0],0) + max(gamma.ftprAbsIsoPho03-gamma.rho*gamma.EffectiveArea03[1],0) + max(gamma.ftprAbsIsoNHad03 - gamma.rho*gamma.EffectiveArea03[2],0))
        elif self.cfg_ana.gamma_isoCorr != 'raw':
            raise RuntimeError("Unsupported gamma_isoCorr name '" + str(self.cfg_ana.gamma_isoCorr) +  "'! For now only 'rhoArea', 'raw' are supported.")
        gamma.ftprRelIso03 = gamma.ftprAbsIso03/gamma.pt()
 

References analyzer.Analyzer.cfg_ana, objects.PhotonAnalyzer.PhotonAnalyzer.IsolationComputer, objects.LeptonAnalyzer.LeptonAnalyzer.IsolationComputer, SiStripPI.max, and str.

Referenced by objects.PhotonAnalyzer.PhotonAnalyzer.makePhotons().

beginLoop()

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

Definition at line 59 of file PhotonAnalyzer.py.

    def beginLoop(self, setup):
        super(PhotonAnalyzer,self).beginLoop(setup)
        self.counters.addCounter('events')
        count = self.counters.counter('events')
        count.register('all events')
        count.register('has >=1 gamma at preselection')
        count.register('has >=1 selected gamma')
 

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

checkMatch()

def objects.PhotonAnalyzer.PhotonAnalyzer.checkMatch	(		self,
			eta,
			phi,
			particles,
			deltar
	)

Definition at line 232 of file PhotonAnalyzer.py.

    def checkMatch( self, eta, phi, particles, deltar ):
 
      for part in particles:
        if deltaR(eta, phi, part.eta(), part.phi()) < deltar:
          return True
 
      return False
 
 
 
 
 

References PbPb_ZMuSkimMuonDPG_cff.deltaR.

Referenced by objects.PhotonAnalyzer.PhotonAnalyzer.computeRandomCone().

computeRandomCone()

def objects.PhotonAnalyzer.PhotonAnalyzer.computeRandomCone	(		self,
			event,
			eta,
			phi,
			deltarmax,
			charged,
			jets,
			photons
	)

Definition at line 244 of file PhotonAnalyzer.py.

    def computeRandomCone( self, event, eta, phi, deltarmax, charged, jets, photons ):
 
      if self.checkMatch( eta, phi, jets, 2.*deltarmax ): 
        return -1.
    
      if self.checkMatch( eta, phi, photons, 2.*deltarmax ): 
        return -1.
    
      if self.checkMatch( eta, phi, event.selectedLeptons, deltarmax ): 
        return -1.
 
      iso = 0.
 
      for part in charged:
        if deltaR(eta, phi, part.eta(), part.phi()) > deltarmax : continue
        #if deltaR(eta, phi, part.eta(), part.phi()) < 0.02: continue
        iso += part.pt()
 
      return iso
 
 
 
 
            
 

References objects.PhotonAnalyzer.PhotonAnalyzer.checkMatch(), and PbPb_ZMuSkimMuonDPG_cff.deltaR.

Referenced by objects.PhotonAnalyzer.PhotonAnalyzer.randomCone().

declareHandles()

def objects.PhotonAnalyzer.PhotonAnalyzer.declareHandles

(

self

)

Definition at line 43 of file PhotonAnalyzer.py.

    def declareHandles(self):
        super(PhotonAnalyzer, self).declareHandles()
        self.handles['rhoPhoton'] = AutoHandle( self.cfg_ana.rhoPhoton, 'double')
 

References analyzer.Analyzer.cfg_ana, core.AutoHandle.AutoHandle.handles, core.Analyzer.Analyzer.handles, HTTP.RequestManager.handles, and core.Analyzer.Analyzer.mchandles.

makePhotons()

def objects.PhotonAnalyzer.PhotonAnalyzer.makePhotons	(		self,
			event
	)

Definition at line 67 of file PhotonAnalyzer.py.

    def makePhotons(self, event):
        event.allphotons = map( Photon, self.handles['photons'].product() )
        event.allphotons.sort(key = lambda l : l.pt(), reverse = True)
 
        event.selectedPhotons = []
        event.selectedPhotonsCentral = []
 
        if self.doFootprintRemovedIsolation:
            # values are taken from EGamma implementation: https://github.com/cms-sw/cmssw/blob/CMSSW_7_6_X/RecoEgamma/PhotonIdentification/plugins/PhotonIDValueMapProducer.cc#L198-L199
            self.IsolationComputer.setPackedCandidates(self.handles['packedCandidates'].product(), -1, 0.1, 0.2)
 
        # Photon scale calibrations
        if self.cfg_ana.doPhotonScaleCorrections:
            for gamma in event.allphotons:
                self.photonEnergyCalibrator.correct(gamma, event.run)
 
        foundPhoton = False
        for gamma in event.allphotons:
            if gamma.pt() < self.cfg_ana.ptMin: continue
            if abs(gamma.eta()) > self.cfg_ana.etaMax: continue
            foundPhoton = True
 
            gamma.rho = float(self.handles['rhoPhoton'].product()[0])
            # https://twiki.cern.ch/twiki/bin/view/CMS/CutBasedPhotonIdentificationRun2#Selection_implementation_details
            if   abs(gamma.eta()) < 1.0:   gamma.EffectiveArea03 = [ 0.0234, 0.0053, 0.078  ]
            elif abs(gamma.eta()) < 1.479: gamma.EffectiveArea03 = [ 0.0189, 0.0103, 0.0629 ]
            elif abs(gamma.eta()) < 2.0:   gamma.EffectiveArea03 = [ 0.0171, 0.0057, 0.0264 ]
            elif abs(gamma.eta()) < 2.2:   gamma.EffectiveArea03 = [ 0.0129, 0.0070, 0.0462 ]
            elif abs(gamma.eta()) < 2.3:   gamma.EffectiveArea03 = [ 0.0110, 0.0152, 0.0740 ]
            elif abs(gamma.eta()) < 2.4:   gamma.EffectiveArea03 = [ 0.0074, 0.0232, 0.0924 ]
            else:                          gamma.EffectiveArea03 = [ 0.0035, 0.1709, 0.1484 ]
 
            if self.doFootprintRemovedIsolation:
                self.attachFootprintRemovedIsolation(gamma)
 
            gamma.relIso = (max(gamma.chargedHadronIso()-gamma.rho*gamma.EffectiveArea03[0],0) + max(gamma.neutralHadronIso()-gamma.rho*gamma.EffectiveArea03[1],0) + max(gamma.photonIso() - gamma.rho*gamma.EffectiveArea03[2],0))/gamma.pt()
 
            def idWP(gamma,X):
                """Create an integer equal to 1-2-3 for (loose,medium,tight)"""
 
                id=0
                if gamma.photonID(X%"Loose"):
                    id=1
                #if gamma.photonID(X%"Medium"):
                #    id=2 
                if gamma.photonID(X%"Tight"):
                    id=3
                return id
 
            gamma.idCutBased = idWP(gamma, "PhotonCutBasedID%s")
 
 
            keepThisPhoton = True
 
            if self.cfg_ana.gammaID=="PhotonCutBasedIDLoose_CSA14" or self.cfg_ana.gammaID=="PhotonCutBasedIDLoose_PHYS14" :
                gamma.idCutBased = gamma.photonIDCSA14(self.cfg_ana.gammaID) 
                # we're keeing sigmaietaieta sidebands:
                keepThisPhoton   = gamma.photonIDCSA14(self.cfg_ana.gammaID, True) 
 
                if gamma.hasPixelSeed():
                    keepThisPhoton = False
                    gamma.idCutBased = 0
            elif "NoIso" in self.cfg_ana.gammaID:
                idName = re.split('_NoIso',self.cfg_ana.gammaID)
                keepThisPhoton = gamma.passPhotonID(idName[0],self.cfg_ana.conversionSafe_eleVeto)
                basenameID = re.split('_looseSieie',idName[0])
                gamma.idCutBased = gamma.passPhotonID(basenameID[0],self.cfg_ana.conversionSafe_eleVeto)
            else:
                # Reading from miniAOD directly
                #keepThisPhoton = gamma.photonID(self.cfg_ana.gammaID)
 
                # implement cut based ID with CMGTools
                keepThisPhoton = gamma.passPhotonID(self.cfg_ana.gammaID,self.cfg_ana.conversionSafe_eleVeto) and gamma.passPhotonIso(self.cfg_ana.gammaID,self.cfg_ana.gamma_isoCorr)
 
            if keepThisPhoton:
                event.selectedPhotons.append(gamma)
 
            if keepThisPhoton and abs(gamma.eta()) < self.etaCentral:
                event.selectedPhotonsCentral.append(gamma)
 
        event.selectedPhotons.sort(key = lambda l : l.pt(), reverse = True)
        event.selectedPhotonsCentral.sort(key = lambda l : l.pt(), reverse = True)
 
        self.counters.counter('events').inc('all events')
        if foundPhoton: self.counters.counter('events').inc('has >=1 gamma at preselection')
        if len(event.selectedPhotons): self.counters.counter('events').inc('has >=1 selected gamma')
       

References funct.abs(), objects.PhotonAnalyzer.PhotonAnalyzer.attachFootprintRemovedIsolation(), analyzer.Analyzer.cfg_ana, CSCSPEvent.counters(), cms::cuda::AtomicPairCounter::Atomic2.counters, NMaxPerLumi.counters, analyzer.Analyzer.counters, HistogramManager.counters, counter.Counters.counters, cscdqm::ChamberCounterKeyType.counters, objects.PhotonAnalyzer.PhotonAnalyzer.doFootprintRemovedIsolation, objects.PhotonAnalyzer.PhotonAnalyzer.etaCentral, dqmMemoryStats.float, core.AutoHandle.AutoHandle.handles, core.Analyzer.Analyzer.handles, HTTP.RequestManager.handles, objects.PhotonAnalyzer.PhotonAnalyzer.IsolationComputer, objects.LeptonAnalyzer.LeptonAnalyzer.IsolationComputer, genParticles_cff.map, SiStripPI.max, and objects.PhotonAnalyzer.PhotonAnalyzer.photonEnergyCalibrator.

Referenced by objects.PhotonAnalyzer.PhotonAnalyzer.process().

matchPhotons()

def objects.PhotonAnalyzer.PhotonAnalyzer.matchPhotons	(		self,
			event
	)

Definition at line 154 of file PhotonAnalyzer.py.

    def matchPhotons(self, event):
        event.genPhotons = [ x for x in event.genParticles if x.status() == 1 and abs(x.pdgId()) == 22 ]
        event.genPhotonsWithMom = [ x for x in event.genPhotons if x.numberOfMothers()>0 ]
        event.genPhotonsWithoutMom = [ x for x in event.genPhotons if x.numberOfMothers()==0 ]
        event.genPhotonsMatched = [ x for x in event.genPhotonsWithMom if abs(x.mother(0).pdgId())<23 or x.mother(0).pdgId()==2212 ]
        match = matchObjectCollection3(event.allphotons, event.genPhotonsMatched, deltaRMax = 0.1)
        matchNoMom = matchObjectCollection3(event.allphotons, event.genPhotonsWithoutMom, deltaRMax = 0.1)
        packedGenParts = [ p for p in self.mchandles['packedGen'].product() if abs(p.eta()) < 3.1 ]
        partons = [ p for p in self.mchandles['prunedGen'].product() if (p.status()==23 or p.status()==22) and abs(p.pdgId())<22 ]
        for gamma in event.allphotons:
          gen = match[gamma]
          gamma.mcGamma = gen
          if gen and gen.pt()>=0.5*gamma.pt() and gen.pt()<=2.*gamma.pt():
            gamma.mcMatchId = 22
            sumPt03 = 0.;
            sumPt04 = 0.;
            for part in packedGenParts:
              if abs(part.pdgId())==12: continue # exclude neutrinos
              if abs(part.pdgId())==14: continue
              if abs(part.pdgId())==16: continue
              if abs(part.pdgId())==18: continue
              deltar = deltaR(gen.eta(), gen.phi(), part.eta(), part.phi())
              if deltar <= 0.3:
                sumPt03 += part.pt()
              if deltar <= 0.4:
                sumPt04 += part.pt()
            sumPt03 -= gen.pt()
            sumPt04 -= gen.pt()
            if sumPt03<0. : sumPt03=0.
            if sumPt04<0. : sumPt04=0.
            gamma.genIso03 = sumPt03
            gamma.genIso04 = sumPt04
            # match to parton
            deltaRmin = 999.
            for p in partons:
              deltar = deltaR(gen.eta(), gen.phi(), p.eta(), p.phi())
              if deltar < deltaRmin:
                deltaRmin = deltar
            gamma.drMinParton = deltaRmin
          else:
            genNoMom = matchNoMom[gamma]
            if genNoMom:
              gamma.mcMatchId = 7
              sumPt03 = 0.;
              sumPt04 = 0.;
              for part in packedGenParts:
                if abs(part.pdgId())==12: continue # exclude neutrinos
                if abs(part.pdgId())==14: continue
                if abs(part.pdgId())==16: continue
                if abs(part.pdgId())==18: continue
                deltar = deltaR(genNoMom.eta(), genNoMom.phi(), part.eta(), part.phi())
                if deltar <= 0.3:
                  sumPt03 += part.pt()
                if deltar <= 0.4:
                  sumPt04 += part.pt()
              sumPt03 -= genNoMom.pt()
              sumPt04 -= genNoMom.pt()
              if sumPt03<0. : sumPt03=0.
              if sumPt04<0. : sumPt04=0.
              gamma.genIso03 = sumPt03
              gamma.genIso04 = sumPt04
              # match to parton
              deltaRmin = 999.
              for p in partons:
                deltar = deltaR(genNoMom.eta(), genNoMom.phi(), p.eta(), p.phi())
                if deltar < deltaRmin:
                  deltaRmin = deltar
              gamma.drMinParton = deltaRmin
            else:
              gamma.mcMatchId = 0
              gamma.genIso03 = -1.
              gamma.genIso04 = -1.
              gamma.drMinParton = -1.
 
 
 
 
 

References funct.abs(), PbPb_ZMuSkimMuonDPG_cff.deltaR, deltar.matchObjectCollection3(), core.Analyzer.Analyzer.mchandles, and EgammaValidation_cff.pdgId.

Referenced by objects.PhotonAnalyzer.PhotonAnalyzer.process().

printInfo()

def objects.PhotonAnalyzer.PhotonAnalyzer.printInfo	(		self,
			event
	)

Definition at line 313 of file PhotonAnalyzer.py.

    def printInfo(self, event):
        print('----------------')
        if len(event.selectedPhotons)>0:
            print('lenght: ',len(event.selectedPhotons))
            print('gamma candidate pt: ',event.selectedPhotons[0].pt())
            print('gamma candidate eta: ',event.selectedPhotons[0].eta())
            print('gamma candidate phi: ',event.selectedPhotons[0].phi())
            print('gamma candidate mass: ',event.selectedPhotons[0].mass())
            print('gamma candidate HoE: ',event.selectedPhotons[0].hOVERe())
            print('gamma candidate r9: ',event.selectedPhotons[0].full5x5_r9())
            print('gamma candidate sigmaIetaIeta: ',event.selectedPhotons[0].full5x5_sigmaIetaIeta())
            print('gamma candidate had iso: ',event.selectedPhotons[0].chargedHadronIso())
            print('gamma candidate neu iso: ',event.selectedPhotons[0].neutralHadronIso())
            print('gamma candidate gamma iso: ',event.selectedPhotons[0].photonIso())
            print('gamma idCutBased',event.selectedPhotons[0].idCutBased)
 
 

References gedPhotonSequence_cff.chargedHadronIso, PVValHelper.eta, HLT_2018_cff.full5x5_sigmaIetaIeta, EgHLTOffHistBins_cfi.mass, gedPhotonSequence_cff.neutralHadronIso, gedPhotonSequence_cff.photonIso, edm.print(), and DiDispStaMuonMonitor_cfi.pt.

process()

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

Definition at line 330 of file PhotonAnalyzer.py.

    def process(self, event):
        self.readCollections( event.input )
        self.makePhotons(event)
#        self.printInfo(event)   
 
        if self.cfg_ana.do_randomCone:
            self.randomCone(event)
 
        if not self.cfg_comp.isMC:
            return True
 
        if self.cfg_ana.do_mc_match and hasattr(event, 'genParticles'):
            self.matchPhotons(event)
 
 
        return True
 
 
setattr(PhotonAnalyzer,"defaultConfig",cfg.Analyzer(

References analyzer.Analyzer.cfg_ana, analyzer.Analyzer.cfg_comp, looper.Looper.cfg_comp, objects.PhotonAnalyzer.PhotonAnalyzer.makePhotons(), objects.PhotonAnalyzer.PhotonAnalyzer.matchPhotons(), objects.PhotonAnalyzer.PhotonAnalyzer.randomCone(), and core.Analyzer.Analyzer.readCollections().

randomCone()

def objects.PhotonAnalyzer.PhotonAnalyzer.randomCone	(		self,
			event
	)

Definition at line 269 of file PhotonAnalyzer.py.

    def randomCone( self, event ):
 
        patcands  = self.handles['packedCandidates'].product()
        jets  = self.handles['jets'].product()
 
        charged   = [ p for p in patcands if ( p.charge() != 0 and abs(p.pdgId())>20 and abs(p.dz())<=0.1 and p.fromPV()>1 and p.trackHighPurity() ) ]
        photons10 = [ p for p in patcands if ( p.pdgId() == 22 and p.pt()>10. ) ]
        jets20 = [ j for j in jets if j.pt() > 20 and abs(j.eta())<2.5 ]
 
        for gamma in event.allphotons:
 
          etaPhot = gamma.eta()
          phiPhot = gamma.eta()
          pi = 3.14159
          phiRC = phiPhot + 0.5*pi
          while phiRC>pi:
            phiRC -= 2.*pi
 
 
          gamma.chHadIsoRC03 = self.computeRandomCone( event, etaPhot, phiRC, 0.3, charged, jets20, photons10 )
          gamma.chHadIsoRC04 = self.computeRandomCone( event, etaPhot, phiRC, 0.4, charged, jets20, photons10 )
          
          
          #try other side
          phiRC = phiPhot - 0.5*pi
          while phiRC<-pi:
            phiRC += 2.*pi
          
          if gamma.chHadIsoRC03<0. : gamma.chHadIsoRC03 = self.computeRandomCone( event, etaPhot, phiRC, 0.3, charged, jets20, photons10 )
          if gamma.chHadIsoRC04<0. : gamma.chHadIsoRC04 = self.computeRandomCone( event, etaPhot, phiRC, 0.4, charged, jets20, photons10 )
 
 

References funct.abs(), objects.PhotonAnalyzer.PhotonAnalyzer.computeRandomCone(), core.AutoHandle.AutoHandle.handles, core.Analyzer.Analyzer.handles, and HTTP.RequestManager.handles.

Referenced by objects.PhotonAnalyzer.PhotonAnalyzer.process().

Member Data Documentation

class_object

objects.PhotonAnalyzer.PhotonAnalyzer.class_object

static

Definition at line 349 of file PhotonAnalyzer.py.

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

conf

objects.PhotonAnalyzer.PhotonAnalyzer.conf

static

Definition at line 36 of file PhotonAnalyzer.py.

conversionSafe_eleVeto

objects.PhotonAnalyzer.PhotonAnalyzer.conversionSafe_eleVeto

static

Definition at line 362 of file PhotonAnalyzer.py.

do_mc_match

objects.PhotonAnalyzer.PhotonAnalyzer.do_mc_match

static

Definition at line 363 of file PhotonAnalyzer.py.

do_randomCone

objects.PhotonAnalyzer.PhotonAnalyzer.do_randomCone

static

Definition at line 364 of file PhotonAnalyzer.py.

doFootprintRemovedIsolation

objects.PhotonAnalyzer.PhotonAnalyzer.doFootprintRemovedIsolation

static

Definition at line 359 of file PhotonAnalyzer.py.

Referenced by objects.PhotonAnalyzer.PhotonAnalyzer.makePhotons().

doPhotonScaleCorrections

objects.PhotonAnalyzer.PhotonAnalyzer.doPhotonScaleCorrections

static

Definition at line 354 of file PhotonAnalyzer.py.

etaCentral

objects.PhotonAnalyzer.PhotonAnalyzer.etaCentral

Definition at line 28 of file PhotonAnalyzer.py.

Referenced by objects.PhotonAnalyzer.PhotonAnalyzer.makePhotons().

etaMax

objects.PhotonAnalyzer.PhotonAnalyzer.etaMax

static

Definition at line 352 of file PhotonAnalyzer.py.

footprintRemovedIsolationPUCorr

objects.PhotonAnalyzer.PhotonAnalyzer.footprintRemovedIsolationPUCorr

static

Definition at line 361 of file PhotonAnalyzer.py.

gamma_isoCorr

objects.PhotonAnalyzer.PhotonAnalyzer.gamma_isoCorr

static

Definition at line 357 of file PhotonAnalyzer.py.

gammaID

objects.PhotonAnalyzer.PhotonAnalyzer.gammaID

static

Definition at line 355 of file PhotonAnalyzer.py.

IsolationComputer

objects.PhotonAnalyzer.PhotonAnalyzer.IsolationComputer

Definition at line 33 of file PhotonAnalyzer.py.

Referenced by objects.PhotonAnalyzer.PhotonAnalyzer.attachFootprintRemovedIsolation(), and objects.PhotonAnalyzer.PhotonAnalyzer.makePhotons().

packedCandidates

objects.PhotonAnalyzer.PhotonAnalyzer.packedCandidates

static

Definition at line 360 of file PhotonAnalyzer.py.

photonEnergyCalibrator

objects.PhotonAnalyzer.PhotonAnalyzer.photonEnergyCalibrator

static

Definition at line 37 of file PhotonAnalyzer.py.

Referenced by objects.PhotonAnalyzer.PhotonAnalyzer.makePhotons().

photons

objects.PhotonAnalyzer.PhotonAnalyzer.photons

static

Definition at line 350 of file PhotonAnalyzer.py.

ptMin

objects.PhotonAnalyzer.PhotonAnalyzer.ptMin

static

Definition at line 351 of file PhotonAnalyzer.py.

rhoPhoton

objects.PhotonAnalyzer.PhotonAnalyzer.rhoPhoton

static

Definition at line 356 of file PhotonAnalyzer.py.