Inheritance diagram for objects.VertexAnalyzer.VertexAnalyzer:

Public Member Functions
def	__init__ (self, cfg_ana, cfg_comp, looperName)

def	beginLoop (self, setup)

def	declareHandles (self)

def	mindist (self, vertices)

def	process (self, event)

def	testGoodVertex (self, vertex)

def	write (self, setup)

Public Attributes
	allVertices

	count

	doHists

	pileup

Static Public Attributes
	class_object

	fixedWeight

	verbose

	vertexWeight

Detailed Description

selects a list of good primary vertices,
and optionally add a pile-up weight to MC events.

The list of good primary vertices is put in event.goodVertices.
if no good vertex is found, the process function returns False.

The weight is put in event.vertexWeight, and is multiplied to
the global event weight, event.eventWeight. 

Example:

vertexAna = cfg.Analyzer(
  'VertexAnalyzer',
  goodVertices = 'goodPVFilter',
  vertexWeight = 'vertexWeightFall112011AB',
  # uncomment the following line if you want a vertex weight = 1 (no weighting)
  # fixedWeight = 1, 
  verbose = False
  )

If fixedWeight is set to None, the vertex weight is read from the EDM collection with module name
'vertexWeightFall112011AB'.
Otherwise, the weight is set to fixedWeight.

The vertex weight collection was at some point produced in the PAT+CMG step,
and could directly be accessed from the PAT or CMG tuple. 
In the most recent versions of the PAT+CMG tuple, this collection is not present anymore,
and an additional full framework process must be ran to produce this collection,
so that this analyzer can read it. An example cfg to do that can be found here:
http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/UserCode/CMG/CMGTools/H2TauTau/prod/vertexWeight2011_cfg.py?view=markup

Definition at line 10 of file VertexAnalyzer.py.

Constructor & Destructor Documentation

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

Definition at line 45 of file VertexAnalyzer.py.

     def __init__(self, cfg_ana, cfg_comp, looperName):
         super(VertexAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName)
 
         self.doHists=True
         if (hasattr(self.cfg_ana,'makeHists')) and (not self.cfg_ana.makeHists):
             self.doHists=False
         if self.doHists:    
             self.pileup = VertexHistograms('/'.join([self.dirName,
                                                      'pileup.root']))
         
         self.allVertices = self.cfg_ana.allVertices if (hasattr(self.cfg_ana,'allVertices')) else "_AUTO_"
 

Member Function Documentation

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

Definition at line 91 of file VertexAnalyzer.py.

References Average.

     def beginLoop(self, setup):
         super(VertexAnalyzer,self).beginLoop(setup)
         self.averages.add('vertexWeight', Average('vertexWeight') )
         self.counters.addCounter('GoodVertex')
         self.count = self.counters.counter('GoodVertex')
         self.count.register('All Events')
         self.count.register('Events With Good Vertex')
 
         

def objects.VertexAnalyzer.VertexAnalyzer.declareHandles ( self )

Definition at line 57 of file VertexAnalyzer.py.

References core.PileUpAnalyzer.PileUpAnalyzer.allVertices, objects.VertexAnalyzer.VertexAnalyzer.allVertices, analyzer.Analyzer.cfg_ana, objects.VertexAnalyzer.VertexAnalyzer.fixedWeight, core.Analyzer.Analyzer.handles, HTTP.RequestManager.handles, and core.Analyzer.Analyzer.mchandles.

     def declareHandles(self):
         super(VertexAnalyzer, self).declareHandles()
         if self.allVertices == '_AUTO_':
           self.handles['vertices'] =  AutoHandle( "offlineSlimmedPrimaryVertices", 'std::vector<reco::Vertex>', fallbackLabel="offlinePrimaryVertices" )
         else:
           self.handles['vertices'] =  AutoHandle( self.allVertices, 'std::vector<reco::Vertex>' )
         self.fixedWeight = None
         if self.cfg_comp.isMC:
             if hasattr( self.cfg_ana, 'fixedWeight'):
                 self.fixedWeight = self.cfg_ana.fixedWeight
             else:
                 self.mchandles['vertexWeight'] = AutoHandle( self.cfg_ana.vertexWeight,
                                                              'double' )
 
         self.mchandles['pusi'] =  AutoHandle(
             'slimmedAddPileupInfo',
             'std::vector<PileupSummaryInfo>', 
             fallbackLabel='addPileupInfo',
             )        
 
         self.handles['rho'] =  AutoHandle(
             ('fixedGridRhoFastjetAll',''),
             'double' 
             )        
         self.handles['rhoCN'] =  AutoHandle(
             ('fixedGridRhoFastjetCentralNeutral',''),
             'double' 
             )        
         self.handles['sigma'] =  AutoHandle(
             ('fixedGridSigmaFastjetAll',''),
             'double',
             mayFail=True
             )
 

def objects.VertexAnalyzer.VertexAnalyzer.mindist	(	self,
		vertices
	)

Definition at line 159 of file VertexAnalyzer.py.

References funct.abs().

     def mindist(self, vertices):
         mindist = 999999
         for comb in itertools.combinations(vertices, 2):
             dist = abs(comb[0].z() - comb[1].z())
             if dist<mindist:
                 mindist = dist
         return mindist
                                                                  

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

Definition at line 100 of file VertexAnalyzer.py.

References PVValHelper.add(), analyzer.Analyzer.averages, analyzer.Analyzer.cfg_ana, core.PileUpAnalyzer.PileUpAnalyzer.doHists, objects.VertexAnalyzer.VertexAnalyzer.doHists, ALCARECOTkAlBeamHalo_cff.filter, objects.VertexAnalyzer.VertexAnalyzer.fixedWeight, core.Analyzer.Analyzer.handles, HTTP.RequestManager.handles, genParticles_cff.map, core.Analyzer.Analyzer.mchandles, core.Analyzer.Analyzer.readCollections(), objects.VertexAnalyzer.VertexAnalyzer.testGoodVertex(), core.SkimAnalyzerCount.SkimAnalyzerCount.verbose, VisualizationOptions.verbose, CSCTFanalyzer.verbose, L1TdeStage2EMTF.verbose, heppy::Davismt2.verbose, L1TStage2uGMTMuon.verbose, CalibratedPatElectronProducer.verbose, DQMGenericTnPClient.verbose, L1TStage2EMTF.verbose, dqmTnP::AbstractFitter.verbose, L1TStage2uGMT.verbose, L1TStage2MuonComp.verbose, L1TStage2RegionalMuonCandComp.verbose, CalibratedElectronProducer.verbose, confdbOfflineConverter.OfflineConverter.verbose, L1TStage2OMTF.verbose, MuonMillepedeAlgorithm.verbose, DeviationsFromFileSensor2D.verbose, L1TStage2BMTF.verbose, core.TriggerMatchAnalyzer.TriggerMatchAnalyzer.verbose, L1TCaloLayer1.verbose, L1TCaloLayer1RawToDigi.verbose, HIPAlignmentAlgorithm.verbose, L1TCaloLayer1Validator.verbose, FFTJetLookupTableESProducer< CT >.verbose, FFTJetCorrectionESProducer< CT >.verbose, o2olib.O2OJobMgr.verbose, objects.VertexAnalyzer.VertexAnalyzer.verbose, L1TStage2uGTCaloLayer2Comp.verbose, OpticalObject.verbose, L1TdeStage2CaloLayer2.verbose, objects.LeptonAnalyzer.LeptonAnalyzer.verbose, and HltDiff.verbose.

     def process(self,  event):
         self.readCollections(event.input )
         event.rho = self.handles['rho'].product()[0]
         event.rhoCN = self.handles['rhoCN'].product()[0]
         event.sigma = self.handles['sigma'].product()[0] if self.handles['sigma'].isValid() else -999
         event.vertices = self.handles['vertices'].product()
         event.goodVertices = filter(self.testGoodVertex,event.vertices)
 
 
         self.count.inc('All Events')
 
         
         event.vertexWeight = 1
         if self.cfg_comp.isMC:
             event.pileUpInfo = map( PileUpSummaryInfo,
                                     self.mchandles['pusi'].product() )
             if self.fixedWeight is None:
                 event.vertexWeight = self.mchandles['vertexWeight'].product()[0]
             else:
                 event.vertexWeight = self.fixedWeight
         event.eventWeight *= event.vertexWeight
             
         self.averages['vertexWeight'].add( event.vertexWeight )
         if self.verbose:
             print 'VertexAnalyzer: #vert = ', len(event.vertices), \
                   ', weight = ', event.vertexWeight
 
         # Check if events needs to be skipped if no good vertex is found (useful for generator level studies)
         keepFailingEvents = False
         if hasattr( self.cfg_ana, 'keepFailingEvents'):
             keepFailingEvents = self.cfg_ana.keepFailingEvents
         if len(event.goodVertices)==0:
             event.passedVertexAnalyzer=False
             if not keepFailingEvents:
                 return False
         else:
             event.passedVertexAnalyzer=True
 
         if self.doHists:
             self.pileup.hist.Fill( len(event.goodVertices) )
 #A.R. mindist is one of the slowest functions, default commented
 #           self.pileup.mindist.Fill( self.mindist(event.goodVertices) )
 
         self.count.inc('Events With Good Vertex')
         return True
 
 

def objects.VertexAnalyzer.VertexAnalyzer.testGoodVertex	(	self,
		vertex
	)

Definition at line 147 of file VertexAnalyzer.py.

References funct.abs().

Referenced by objects.VertexAnalyzer.VertexAnalyzer.process().

     def testGoodVertex(self,vertex):
         if vertex.isFake():
             return False
         if vertex.ndof()<=4:
             return False
         if abs(vertex.z())>24:
             return False
         if vertex.position().Rho()>2:
             return False
      
         return True
 

def objects.VertexAnalyzer.VertexAnalyzer.write	(	self,
		setup
	)

Definition at line 167 of file VertexAnalyzer.py.

References core.PileUpAnalyzer.PileUpAnalyzer.doHists, and objects.VertexAnalyzer.VertexAnalyzer.doHists.

     def write(self, setup):
         super(VertexAnalyzer, self).write(setup)
         if self.doHists:
             self.pileup.write()
 
 setattr(VertexAnalyzer,"defaultConfig",cfg.Analyzer(