Gaudi.Configuration Namespace Reference

Classes
class	GaudiPersistency

Functions
def	_fillConfDict ()
def	importConfiguration
def	configurationDict
def	getConfigurable
def	setCustomMainLoop (runner)

Variables
tuple	log = logging.getLogger(__name__)
	allConfigurables = Configurable.allConfigurables

Function Documentation

def Gaudi.Configuration._fillConfDict ( )

private

Definition at line 20 of file Configuration.py.

def _fillConfDict():
    nFiles = loadConfigurableDb()
    log = logging.getLogger( 'PropertyProxy' )
    log.debug( "Read module info for %d configurables from %d genConfDb files",
              len(cfgDb), nFiles )
    if len(cfgDb.duplicates()) > 0:
        log.warning( "Found %d duplicates among the %d genConfDb files :",
                     len(cfgDb.duplicates()), nFiles )
        log.warning( "--------------------------------------------------" )
        log.warning( "  -%s: %s - %s",
                     "<component name>", "<module>", "[ <duplicates> ]" )
        log.warning( "--------------------------------------------------" )
        dups = cfgDb.duplicates()
        for cfgName in dups.keys():
            log.warning( "  -%s: %s - %s",
                         cfgName,
                         cfgDb[cfgName]['module'],
                         str([ d['module'] for d in dups[cfgName]]) )
            pass
        del dups
        log.warning( "Fix your cmt/requirements file !!" )
        pass
    else:
        log.debug( "No duplicates have been found: that's good !" )
        pass
    return

# fill the configurable dictionary at module load
_fillConfDict()

def Gaudi.Configuration.configurationDict

(

all = False

)

Return a dictionary representing the configuration.
The dictionary contains one entry per configurable which is a dictionary
with one entry per property.
The optional argument "all" is used to decide if to include only values
different from the default or all of them.

Definition at line 55 of file Configuration.py.

def configurationDict(all=False):
    """Return a dictionary representing the configuration.
    The dictionary contains one entry per configurable which is a dictionary
    with one entry per property.
    The optional argument "all" is used to decide if to include only values
    different from the default or all of them.
    """
    from GaudiKernel.Proxy.Configurable import getNeededConfigurables

    catalog = allConfigurables
    keys = getNeededConfigurables() # use only interesting configurables
    conf_dict = {}
    if all:
        for n in keys :
            if n not in conf_dict:
                conf_dict[n] = {}
            for p, v in  catalog[n].getDefaultProperties().items() :
                conf_dict[n][p] = v

    for n in keys :
        if n not in conf_dict:
            conf_dict[n] = {}
        for p, v in catalog[n].getValuedProperties().items() :
            conf_dict[n][p] = v
    # purge empty configurables
    keys = conf_dict.keys()
    for n in keys:
        if not conf_dict[n]:
            del conf_dict[n]
    return conf_dict

def Gaudi.Configuration.getConfigurable	(		name,
			defaultType = None
	)

Helper function to get a configurable with the given name regardless
for the type.
If defaultType can be a class derived from configurable or a string. If not
specified, the tool name is used as type.

Definition at line 86 of file Configuration.py.

def getConfigurable(name, defaultType = None):
    """Helper function to get a configurable with the given name regardless
    for the type.
    If defaultType can be a class derived from configurable or a string. If not
    specified, the tool name is used as type."""
    if name in allConfigurables:
        return allConfigurables[name]
    else:
        # if the configurable is not found, we need to instantiate it
        if defaultType is None:
            # try to use the name of the configurable as default type
            defaultType = name
        if type(defaultType) is str:
            # we need to convert from string to actual class
            if defaultType in globals():
                # We the type is defined in the global namespace
                defaultType = globals()[defaultType]
            else:
                # otherwise we try to get it from the Configurables database
                import Configurables
                defaultType = getattr(Configurables, defaultType)
        return defaultType(name)

def Gaudi.Configuration.importConfiguration	(		conf,
			local = locals()
	)

Definition at line 52 of file Configuration.py.

def importConfiguration(conf, local=locals()) :
    local[conf] = confDbGetConfigurable(conf)

def Gaudi.Configuration.setCustomMainLoop

(

runner

)

Replace the default main execution loop with the specified callable object.

@param runner: a callable that accepts an initialized instance of GaudiPython.AppMgr
               and the number of events to process and returns a StatusCode or a boolean
               (True means success)

Definition at line 109 of file Configuration.py.

def setCustomMainLoop(runner):
    '''
    Replace the default main execution loop with the specified callable object.

    @param runner: a callable that accepts an initialized instance of GaudiPython.AppMgr
                   and the number of events to process and returns a StatusCode or a boolean
                   (True means success)
    '''
    # change the mainLoop function
    from Gaudi.Main import gaudimain
    gaudimain.mainLoop = lambda _self, app, nevt: runner(app, nevt)

Variable Documentation

Gaudi.Configuration.allConfigurables = Configurable.allConfigurables

Definition at line 18 of file Configuration.py.

tuple Gaudi.Configuration.log = logging.getLogger(__name__)

Definition at line 14 of file Configuration.py.