Functions
def	bestMatch (object, matchCollection)

def	cleanObjectCollection (objects, masks, deltaRMin)

def	cleanObjectCollection2 (objects, masks, deltaRMin)

def	deltaPhi (p1, p2)

def	deltaR (args)

def	deltaR2 (e1, p1, e2=None, p2=None)

def	inConeCollection (pivot, particles, deltaRMax, deltaRMin=1e-5)

def	matchObjectCollection

def	matchObjectCollection2 (objects, matchCollection, deltaRMax=0.3)

def	matchObjectCollection3

Function Documentation

def deltar.bestMatch	(	object,
		matchCollection
	)

Return the best match to object in matchCollection, which is the closest object in delta R

Definition at line 138 of file deltar.py.

References deltaR2(), and objects.autophobj.float.

Referenced by PrimaryVertexAnalyzer4PUSlimmed.fillResolutionAndPullHistograms(), RecoTauDifferenceAnalyzer.filter(), HLTMuonPlotter.findMatches(), CSCMake2DRecHit.findWireBx(), objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons(), GlobalCosmicMuonTrajectoryBuilder.match(), matchObjectCollection(), and MuonIdTruthInfo.truthMatchMuon().

 def bestMatch( object, matchCollection):
     '''Return the best match to object in matchCollection, which is the closest object in delta R'''
     deltaR2Min = float('+inf')
     bm = None
     for match in matchCollection:
         dR2 = deltaR2( object.eta(), object.phi(),
                        match.eta(), match.phi() )
         if dR2 < deltaR2Min:
             deltaR2Min = dR2
             bm = match
     return bm, deltaR2Min
 
 

def deltar.cleanObjectCollection	(	objects,
		masks,
		deltaRMin
	)

Masks objects using a deltaR cut.

Definition at line 118 of file deltar.py.

References deltaR2().

Referenced by JetAnalyzer.JetAnalyzer.process().

 def cleanObjectCollection( objects, masks, deltaRMin ):
     '''Masks objects using a deltaR cut.'''
     if len(objects)==0 or len(masks)==0:
         return objects, []
     deltaR2Min = deltaRMin*deltaRMin
     cleanObjects = []
     dirtyObjects = []
     for object in objects:
         ok = True 
         for mask in masks:
             dR2 = deltaR2( object.eta(), object.phi(),
                            mask.eta(), mask.phi() )
             if dR2 < deltaR2Min:
                 ok = False
         if ok:
             cleanObjects.append( object )
         else:
             dirtyObjects.append( object )
     return cleanObjects, dirtyObjects
 

def deltar.cleanObjectCollection2	(	objects,
		masks,
		deltaRMin
	)

Masks objects using a deltaR cut, another algorithm (same results).

Definition at line 91 of file deltar.py.

References deltaR2().

 def cleanObjectCollection2( objects, masks, deltaRMin ):
     '''Masks objects using a deltaR cut, another algorithm (same results).'''
     if len(objects)==0:
         return objects
     deltaR2Min = deltaRMin*deltaRMin
     cleanObjects = copy.copy( objects )
     for mask in masks:
         tooClose = []
         for idx, object in enumerate(cleanObjects):
             dR2 = deltaR2( object.eta(), object.phi(),
                            mask.eta(), mask.phi() )
             if dR2 < deltaR2Min:
                 tooClose.append( idx )
         nRemoved = 0
         for idx in tooClose:
             # yes, everytime an object is removed, the list of objects is updated
             # so need to update the index accordingly.
             # example: to remove : ele 1 and 2
             #  first, ele 1 is removed
             #  -> ele 2 is now at index 1
             # one should again remove the element at index 1
             idx -= nRemoved
             del cleanObjects[idx]
             nRemoved += 1 
     return cleanObjects
 
 

def deltar.deltaPhi	(	p1,
		p2
	)

Computes delta phi, handling periodic limit conditions.

Definition at line 20 of file deltar.py.

Referenced by deltaR2().

 def deltaPhi( p1, p2):
     '''Computes delta phi, handling periodic limit conditions.'''
     res = p1 - p2
     while res > math.pi:
         res -= 2*math.pi
     while res < -math.pi:
         res += 2*math.pi
     return res
 
 

def deltar.deltaR ( args )

Definition at line 16 of file deltar.py.

References deltaR2().

 def deltaR( *args ):
     return math.sqrt( deltaR2(*args) )

def deltar.deltaR2	(	e1,
		p1,
		e2 = `None`,
		p2 = `None`
	)

Take either 4 arguments (eta,phi, eta,phi) or two objects that have 'eta', 'phi' methods)

Definition at line 7 of file deltar.py.

References deltaPhi().

Referenced by bestMatch(), cleanObjectCollection(), cleanObjectCollection2(), deltaR(), and inConeCollection().

 def deltaR2( e1, p1, e2=None, p2=None):
     """Take either 4 arguments (eta,phi, eta,phi) or two objects that have 'eta', 'phi' methods)"""
     if (e2 == None and p2 == None):
         return deltaR2(e1.eta(),e1.phi(), p1.eta(), p1.phi())
     de = e1 - e2
     dp = deltaPhi(p1, p2)
     return de*de + dp*dp
 
 

def deltar.inConeCollection	(	pivot,
		particles,
		deltaRMax,
		deltaRMin = `1e-5`
	)

Returns the list of particles that are less than deltaRMax away from pivot.

Definition at line 30 of file deltar.py.

References deltaR2().

 def inConeCollection(pivot, particles, deltaRMax, deltaRMin=1e-5):
     '''Returns the list of particles that are less than deltaRMax away from pivot.'''
     dR2Max = deltaRMax ** 2
     dR2Min = deltaRMin ** 2 if deltaRMin  > 0 else -1
     results = []
     for ptc in particles:
         dR2 = deltaR2(pivot.eta(), pivot.phi(), ptc.eta(), ptc.phi()) 
         if dR2Min < dR2 and dR2 < dR2Max:
             results.append(ptc)
     return results
 

def deltar.matchObjectCollection	(	objects,
		matchCollection,
		deltaR2Max,
		filter = `lambda x`,
		y
	)

Definition at line 151 of file deltar.py.

References bestMatch(), cmsPerfStripChart.dict, ALCARECOTkAlBeamHalo_cff.filter, list(), and ComparisonHelper.zip().

Referenced by SimpleJetAnalyzer.SimpleJetAnalyzer.process(), core.TriggerMatchAnalyzer.TriggerMatchAnalyzer.process(), Matcher.Matcher.process(), and JetAnalyzer.JetAnalyzer.process().

 def matchObjectCollection( objects, matchCollection, deltaR2Max, filter = lambda x,y : True):
     pairs = {}
     if len(objects)==0:
         return pairs
     if len(matchCollection)==0:
         return dict( list(zip(objects, [None]*len(objects))) )
     for object in objects:
         bm, dr2 = bestMatch( object, [mob for mob in matchCollection if list(filter(object,mob))] )
         if dr2<deltaR2Max:
             pairs[object] = bm
         else:
             pairs[object] = None            
     return pairs
 
 

def deltar.matchObjectCollection2	(	objects,
		matchCollection,
		deltaRMax = `0.3`
	)

Univoque association of an element from matchCollection to an element of objects.
Reco and Gen objects get the "matched" attribute, true is they are re part of a matched tulpe.
By default, the matching is true only if delta R is smaller than 0.3.

Definition at line 166 of file deltar.py.

References cmsPerfStripChart.dict, list(), and ComparisonHelper.zip().

Referenced by objects.JetAnalyzer.JetAnalyzer.matchJets().

 def matchObjectCollection2 ( objects, matchCollection, deltaRMax = 0.3 ):
     '''Univoque association of an element from matchCollection to an element of objects.
     Reco and Gen objects get the "matched" attribute, true is they are re part of a matched tulpe.
     By default, the matching is true only if delta R is smaller than 0.3.
     '''
     
     pairs = {}
     if len(objects)==0:
             return pairs
     if len(matchCollection)==0:
             return dict( list(zip(objects, [None]*len(objects))) )
     # build all possible combinations
     allPairs = sorted([(deltaR2 (object.eta(), object.phi(), match.eta(), match.phi()), (object, match)) for object in objects for match in matchCollection])
 
     # to flag already matched objects
     # FIXME this variable remains appended to the object, I do not like it
     for object in objects:
         object.matched = False
     for match in matchCollection:
         match.matched = False
     
     deltaR2Max = deltaRMax * deltaRMax
     for dR2, (object, match) in allPairs:
     if dR2 > deltaR2Max:
         break
         if dR2 < deltaR2Max and object.matched == False and match.matched == False:
             object.matched = True
             match.matched = True
             pairs[object] = match
     
     for object in objects:
        if object.matched == False:
        pairs[object] = None
 
     return pairs
     # by now, the matched attribute remains in the objects, for future usage
     # one could remove it with delattr (object, attrname)
 
 
 

def deltar.matchObjectCollection3	(	objects,
		matchCollection,
		deltaRMax = `0.3`,
		filter = `lambda x`,
		y
	)

Definition at line 41 of file deltar.py.

References funct.abs(), cmsPerfStripChart.dict, ALCARECOTkAlBeamHalo_cff.filter, list(), and ComparisonHelper.zip().

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.matchAnyLeptons(), objects.IsoTrackAnalyzer.matchIsoTrack(), objects.LeptonAnalyzer.LeptonAnalyzer.matchLeptons(), objects.PhotonAnalyzer.PhotonAnalyzer.matchPhotons(), objects.TauAnalyzer.TauAnalyzer.matchTaus(), objects.LeptonAnalyzer.LeptonAnalyzer.matchToPhotons(), and core.TriggerMatchAnalyzer.TriggerMatchAnalyzer.process().

 def matchObjectCollection3 ( objects, matchCollection, deltaRMax = 0.3, filter = lambda x,y : True ):
     '''Univoque association of an element from matchCollection to an element of objects.
     Reco and Gen objects get the "matched" attribute, true is they are re part of a matched tulpe.
     By default, the matching is true only if delta R is smaller than 0.3. 
     '''
     #
                                                                                                                                                                                                                                        
     pairs = {}
     if len(objects)==0:
             return pairs
     if len(matchCollection)==0:
             return dict( list(zip(objects, [None]*len(objects))) )
     # build all possible combinations
 
     objectCoords = [ (o.eta(),o.phi(),o) for o in objects ]
     matchdCoords = [ (o.eta(),o.phi(),o) for o in matchCollection ]
     allPairs = sorted([(deltaR2 (oeta, ophi, meta, mphi), (object, match)) for (oeta,ophi,object) in objectCoords for (meta,mphi,match) in matchdCoords if abs(oeta-meta)<=deltaRMax and list(filter(object,match)) ])
     #allPairs = [(deltaR2 (object.eta(), object.phi(), match.eta(), match.phi()), (object, match)) for object in objects for match in matchCollection if filter(object,match) ]
     #
     # to flag already matched objects
     # FIXME this variable remains appended to the object, I do not like it
 
     for object in objects:
         object.matched = False
     for match in matchCollection:
         match.matched = False
     #
 
     deltaR2Max = deltaRMax * deltaRMax
     for dR2, (object, match) in allPairs:
         if dR2 > deltaR2Max:
             break
         if dR2 < deltaR2Max and object.matched == False and match.matched == False:
             object.matched = True
             match.matched = True
             pairs[object] = match
     #
 
     for object in objects:
        if object.matched == False:
            pairs[object] = None
     #
 
     return pairs
     # by now, the matched attribute remains in the objects, for future usage
     # one could remove it with delattr (object, attrname)
 
 
 
 

Functions

Function Documentation