python.JetAnalysisCommon Namespace Reference

Classes
class	ComponentAccumulatorMockUp
class	ConfArray
class	Configured
class	ConfNameSpace

Functions
def	stringPropValue (value)
def	generateConfigured (classname, cppclass, prefix="")
def	propertyType (p)
def	parOR (name)
def	addManyAlgs (job, algList)
def	mock_JetRecTools ()
def	JetRecCfg_reorder (jetdef, flags, returnFinalJetDef=False)

Variables
	CompFactory = ConfNameSpace()
	ComponentFactory = ModuleType("ComponentFactory")
	isComponentAccumulatorCfg
	CFElements = ModuleType("CFElements")
	parOR
	ComponentAccumulator = ModuleType("ComponentAccumulator")
	JetAnalysisCommon = sys.modules[__name__]
	JetRecCfg_original

Function Documentation

addManyAlgs()

def python.JetAnalysisCommon.addManyAlgs	(		job,
			algList
	)

a little configuration function added from the python module JetAnalysisCommon.py to easily schedule
# a list of Configured algs as defined by this module.

Definition at line 350 of file JetAnalysisCommon.py.

def addManyAlgs(job, algList):
    """a little configuration function added from the python module JetAnalysisCommon.py to easily schedule
    # a list of Configured algs as defined by this module."""
    for alg in algList:
        job.algsAdd( alg.asAnaAlg() )
 
ROOT.EL.Job.addManyAlgs = addManyAlgs        
 
 
#*******************************************************************
# hack the list of modules in sys so that the Athena config modules are found and redirected
# to what we have defined in this module 

generateConfigured()

def python.JetAnalysisCommon.generateConfigured	(		classname,
			cppclass,
			prefix = ""
	)

Definition at line 212 of file JetAnalysisCommon.py.

def generateConfigured(classname, cppclass, prefix=""):
    import cppyy
 
    # get an instance of the class :
    if issubclass(cppclass, cppyy.gbl.asg.IAsgTool):
        dummy = cppclass('dummy')
    else: # then it's an Algorithm
        dummy = cppclass('dummy', 0)
 
    # find all the properties of the Tool/Algorithm
    pm = dummy.getPropertyMgr()
    propkeys  = [str(k) for k,p in  pm.getProperties() ]
    propTypes = dict( (k,propertyType(pm.getProperty(k)) ) for k in propkeys)
    allowedProp = Configured._allowed + [k for k in propkeys]
    # generate the class derived from Configured for this Tool/Alg
    klass=type(classname+'Conf', (Configured,), dict(_allowed=allowedProp, _propTypes=propTypes,
                                                              type=prefix+classname,_cppclass=cppclass) )
 
    return klass
 

JetRecCfg_reorder()

def python.JetAnalysisCommon.JetRecCfg_reorder	(		jetdef,
			flags,
			returnFinalJetDef = False
	)

Builds the algs with JetRecConfig.JetRecCfg and then make sure
they are in proper order.
Re-ordering is done manually, according to various input alg type.

Definition at line 391 of file JetAnalysisCommon.py.

def JetRecCfg_reorder(jetdef, flags, returnFinalJetDef=False):
    """Builds the algs with JetRecConfig.JetRecCfg and then make sure
    they are in proper order.
    Re-ordering is done manually, according to various input alg type.
    """
    res = JetRecConfig.JetRecCfg_original(flags, jetdef , returnFinalJetDef)
 
    acc , _ = res if returnFinalJetDef else (res,None)
    algs = acc.algs
 
    # ************
    # reorder EventDensity and PseudoJetAlg 
    if not hasattr(ROOT, 'EventDensityAthAlg'):
        return res 
    evtDensityAlgs = [ (i,alg) for (i,alg) in enumerate(algs) if alg._cppclass == ROOT.EventDensityAthAlg ]
    pjAlgs = [ (i,alg) for (i,alg) in enumerate(algs) if alg._cppclass == ROOT.PseudoJetAlgorithm ]
    pairsToswap = []
    for i,edalg in evtDensityAlgs:
        edInput = edalg.EventDensityTool.InputContainer
        for j,pjalg in pjAlgs:
            if j<i: continue 
            if edInput == pjalg.OutputContainer:
                pairsToswap.append( (i,j) )
    for (i,j) in pairsToswap:
        algs[i], algs[j] = algs[j], algs[i]
 
    # ************
    # if there were other types of alg which need re-rordering
    # we could add the specific re-ordering code below ...
    
    return res
 
JetRecConfig.JetRecCfg = JetRecCfg_reorder

mock_JetRecTools()

def python.JetAnalysisCommon.mock_JetRecTools

(

)

Allows to ignore JetRecTools in case this package is not checked out on top of AnalysisBase

Definition at line 371 of file JetAnalysisCommon.py.

def mock_JetRecTools():
    """Allows to ignore JetRecTools in case this package is not checked out on top of AnalysisBase"""
    sys.modules['JetRecTools'] = ModuleType('JetRecTools')
    sys.modules['JetRecTools.JetRecToolsConfig'] = ModuleType('JetRecToolsConfig')
 
 
    
#*******************************************************************
# hacks specific to jets
 

parOR()

def python.JetAnalysisCommon.parOR

(

name

)

Definition at line 308 of file JetAnalysisCommon.py.

def parOR(name):
    pass

propertyType()

def python.JetAnalysisCommon.propertyType

(

p

)

Guess the type of the TProperty p.
p is a C++ instance of a TProperty.

This simply interpret the cpp name as set by cppyy...

Definition at line 232 of file JetAnalysisCommon.py.

def propertyType(p):
    """Guess the type of the TProperty p.
    p is a C++ instance of a TProperty.
 
    This simply interpret the cpp name as set by cppyy...
    """
    clsname = p.__class__.__cpp_name__
    # clsname is in the form : 'TProperty<vector<double> >'
    typ = clsname[10:-1].strip()
    if 'Handle' in typ:
        typ='string'
    return typ
 
 

stringPropValue()

def python.JetAnalysisCommon.stringPropValue

(

value

)

Helper function producing a string property value

Definition at line 48 of file JetAnalysisCommon.py.

def stringPropValue( value ):    
    """Helper function producing a string property value"""
    
    stringValue = str( value )
    if isinstance( value, bool ):
        stringValue = str( int( value ) )
        pass
    return stringValue
 
 

Variable Documentation

CFElements

python.JetAnalysisCommon.CFElements = ModuleType("CFElements")

Definition at line 310 of file JetAnalysisCommon.py.

CompFactory

python.JetAnalysisCommon.CompFactory = ConfNameSpace()

Definition at line 295 of file JetAnalysisCommon.py.

ComponentAccumulator

python.JetAnalysisCommon.ComponentAccumulator = ModuleType("ComponentAccumulator")

Definition at line 342 of file JetAnalysisCommon.py.

ComponentFactory

python.JetAnalysisCommon.ComponentFactory = ModuleType("ComponentFactory")

Definition at line 300 of file JetAnalysisCommon.py.

isComponentAccumulatorCfg

python.JetAnalysisCommon.isComponentAccumulatorCfg

Definition at line 303 of file JetAnalysisCommon.py.

JetAnalysisCommon

python.JetAnalysisCommon.JetAnalysisCommon = sys.modules[__name__]

Definition at line 363 of file JetAnalysisCommon.py.

JetRecCfg_original

python.JetAnalysisCommon.JetRecCfg_original

Definition at line 390 of file JetAnalysisCommon.py.

parOR

python.JetAnalysisCommon.parOR

Definition at line 311 of file JetAnalysisCommon.py.