python.DualUseConfig Namespace Reference

Functions
def	createComponent (typeName, instanceName, componentType)
def	createAlgorithm (typeName, instanceName)
def	createReentrantAlgorithm (typeName, instanceName)
def	createPublicTool (typeName, toolName)
def	createService (typeName, serviceName, sequence=None)
def	addPrivateTool (alg, toolName, typeName)
def	addPrivateToolInArray (alg, toolName, typeName)

Variables
bool	useComponentAccumulator = False
bool	isAthena = False

Function Documentation

addPrivateTool()

def python.DualUseConfig.addPrivateTool	(		alg,
			toolName,
			typeName
	)

Helper function for declaring a private tool for a dual-use algorithm

This function is meant to be used in the analysis algorithm sequence
configurations for setting up private tools on the analysis algorithms.
Private tools that could then be configured with a syntax shared between
Athena and EventLoop.

Keyword arguments:
  alg      -- The algorithm to set up the private tool on
  toolName -- The property name with which the tool handle was declared on
              the algorithm. Also the instance name of the tool.
  typeName -- The C++ type name of the private tool

Definition at line 180 of file DualUseConfig.py.

def addPrivateTool( alg, toolName, typeName ):
    """Helper function for declaring a private tool for a dual-use algorithm
 
    This function is meant to be used in the analysis algorithm sequence
    configurations for setting up private tools on the analysis algorithms.
    Private tools that could then be configured with a syntax shared between
    Athena and EventLoop.
 
    Keyword arguments:
      alg      -- The algorithm to set up the private tool on
      toolName -- The property name with which the tool handle was declared on
                  the algorithm. Also the instance name of the tool.
      typeName -- The C++ type name of the private tool
    """
 
    global isAthena
 
    if isAthena:
 
        # First try to set up the private tool in an "Athena way".
 
        # Tokenize the tool's name. In case it is a subtool of a tool, or
        # something possibly even deeper.
        toolNames = toolName.split( '.' )
 
        # Look up the component that we need to set up the private tool on:
        component = alg
        for tname in toolNames[ 0 : -1 ]:
            component = getattr( component, tname )
            pass
 
        # Now look up the Athena configurable describing this tool:
        from AthenaConfiguration.ComponentFactory import CompFactory
        toolClass = CompFactory.getComp(typeName) 
 
        # Finally, set up the tool handle property:
        setattr( component, toolNames[ -1 ], toolClass( toolNames[ -1 ] ) )
 
    else:
 
        # If that failed, then we should be in an EventLoop environment. So
        # let's rely on the standalone specific formalism for setting up the
        # private tool.
        alg.addPrivateTool( toolName, typeName )
        pass
 
    return
 
 

addPrivateToolInArray()

def python.DualUseConfig.addPrivateToolInArray	(		alg,
			toolName,
			typeName
	)

Helper function for declaring a private tool in an array for a
dual-use algorithm

This function is meant to be used in the analysis algorithm
sequence configurations for setting up private tools in arrays on
the analysis algorithms.  Private tools that could then be
configured with a syntax shared between Athena and EventLoop.

Keyword arguments:
  alg      -- The algorithm to set up the private tool on
  toolName -- The property name with which the tool handle was declared on
              the algorithm. Also the instance name of the tool.
  typeName -- The C++ type name of the private tool

Definition at line 229 of file DualUseConfig.py.

def addPrivateToolInArray( alg, toolName, typeName ):
    """Helper function for declaring a private tool in an array for a
    dual-use algorithm
 
    This function is meant to be used in the analysis algorithm
    sequence configurations for setting up private tools in arrays on
    the analysis algorithms.  Private tools that could then be
    configured with a syntax shared between Athena and EventLoop.
 
    Keyword arguments:
      alg      -- The algorithm to set up the private tool on
      toolName -- The property name with which the tool handle was declared on
                  the algorithm. Also the instance name of the tool.
      typeName -- The C++ type name of the private tool
 
    """
 
    global isAthena
 
    if isAthena:
 
        # First try to set up the private tool in an "Athena way".
 
        # Tokenize the tool's name. In case it is a subtool of a tool, or
        # something possibly even deeper.
        toolNames = toolName.split( '.' )
 
        # Look up the component that we need to set up the private tool on:
        component = alg
        for tname in toolNames[ 0 : -1 ]:
            component = getattr( component, tname )
            pass
 
        # Now look up the Athena configurable describing this tool:
        from AthenaConfiguration.ComponentFactory import CompFactory
        toolClass = CompFactory.getComp(typeName)
 
        # Finally, set up the tool handle property:
        getattr( component, toolNames[ -1 ] ).append (toolClass( toolNames[ -1 ] ) )
        return getattr( component, toolNames[ -1 ] )
 
    else:
 
        # If that failed, then we should be in an EventLoop environment. So
        # let's rely on the standalone specific formalism for setting up the
        # private tool.
        return alg.addPrivateToolInArray( toolName, typeName )
 
    return

createAlgorithm()

def python.DualUseConfig.createAlgorithm	(		typeName,
			instanceName
	)

Create an algorithm configurable

This function is used to create an algorithm "configurable" in a dual-use
way, either returning an actual Athena configurable, or an appropriately
configured EL::AnaAlgorithmConfig instance.

Keyword arguments:
  typeName     -- The C++ type name of the algorithm
  instanceName -- The instance name of the algorithm to create

Definition at line 56 of file DualUseConfig.py.

def createAlgorithm( typeName, instanceName ):
    """Create an algorithm configurable
 
    This function is used to create an algorithm "configurable" in a dual-use
    way, either returning an actual Athena configurable, or an appropriately
    configured EL::AnaAlgorithmConfig instance.
 
    Keyword arguments:
      typeName     -- The C++ type name of the algorithm
      instanceName -- The instance name of the algorithm to create
    """
    return createComponent( typeName, instanceName, 'AnaAlgorithm' )
 
 

createComponent()

def python.DualUseConfig.createComponent	(		typeName,
			instanceName,
			componentType
	)

Create a generic configurable

This function is used to create an component "configurable" in a
dual-use way, either returning an actual Athena configurable, or
an appropriately configured PythonConfig instance.

Keyword arguments:
  typeName      -- The C++ type name of the component
  instanceName  -- The instance name of the component to create
  componentType -- The type of component in AnalysisBase

Definition at line 16 of file DualUseConfig.py.

def createComponent( typeName, instanceName, componentType ):
    """Create a generic configurable
 
    This function is used to create an component "configurable" in a
    dual-use way, either returning an actual Athena configurable, or
    an appropriately configured PythonConfig instance.
 
    Keyword arguments:
      typeName      -- The C++ type name of the component
      instanceName  -- The instance name of the component to create
      componentType -- The type of component in AnalysisBase
 
    """
 
    global isAthena
    global useComponentAccumulator
 
    if isAthena:
        # Try to get a configurable for this C++ class "from Athena".
        # If this succeeds, we're obviously in an Athena environment.
 
        # Look up the Athena configurable of this component:
        from AthenaConfiguration.ComponentFactory import CompFactory
        componentClass = CompFactory.getComp(typeName)
 
        # Return the object:
        return componentClass( instanceName )
 
    else:
        # If that didn't work, then apparently we're in an EventLoop
        # environment, so we need to use PythonConfig as the base class
        # for the user's class.
        from AnaAlgorithm.PythonConfig import PythonConfig
        component = PythonConfig( '%s/%s' % ( typeName, instanceName ) )
        component.setComponentType( componentType )
        return component
 
    pass
 
 

createPublicTool()

def python.DualUseConfig.createPublicTool	(		typeName,
			toolName
	)

Helper function for setting up a public tool for a dual-use algorithm

This function is meant to be used in the analysis algorithm sequence
configurations for setting up public tools on the analysis algorithms.
Public tools that could then be configured with a syntax shared between
Athena and EventLoop.

Keyword arguments:
  typeName -- The C++ type name of the private tool
  toolName -- The property name with which the tool handle was declared on
              the algorithm. Also the instance name of the tool.

Definition at line 84 of file DualUseConfig.py.

def createPublicTool( typeName, toolName ):
    """Helper function for setting up a public tool for a dual-use algorithm
 
    This function is meant to be used in the analysis algorithm sequence
    configurations for setting up public tools on the analysis algorithms.
    Public tools that could then be configured with a syntax shared between
    Athena and EventLoop.
 
    Keyword arguments:
      typeName -- The C++ type name of the private tool
      toolName -- The property name with which the tool handle was declared on
                  the algorithm. Also the instance name of the tool.
    """
 
    global isAthena
    global useComponentAccumulator
 
    if isAthena:
        # Look up the Athena configurable of this tool:
        from AthenaConfiguration.ComponentFactory import CompFactory
        toolClass = CompFactory.getComp( typeName )
 
        if useComponentAccumulator:
            # ComponentAccumulator will add the tool to ToolSvc
            # Avoid importing AthenaCommon.AppMgr in a CA Athena job
            # as it modifies Gaudi behaviour
            return toolClass( toolName )
        else:
            # Add an instance of the tool to the ToolSvc:
            from AthenaCommon.AppMgr import ToolSvc
            if not hasattr( ToolSvc, toolName ):
                ToolSvc += toolClass( toolName )
                pass
 
            # Return the member on the ToolSvc:
            return getattr( ToolSvc, toolName )
 
    else:
        # If that didn't work, then apparently we're in an EventLoop
        # environment, so let's use the EventLoop specific formalism.
        return createComponent( typeName, toolName, 'AsgTool' )
 
 

createReentrantAlgorithm()

def python.DualUseConfig.createReentrantAlgorithm	(		typeName,
			instanceName
	)

Create a reentrant algorithm configurable

This function is used to create an algorithm "configurable" in a dual-use
way, either returning an actual Athena configurable, or an appropriately
configured EL::AnaAlgorithmConfig instance.

Keyword arguments:
  typeName     -- The C++ type name of the algorithm
  instanceName -- The instance name of the algorithm to create

Definition at line 70 of file DualUseConfig.py.

def createReentrantAlgorithm( typeName, instanceName ):
    """Create a reentrant algorithm configurable
 
    This function is used to create an algorithm "configurable" in a dual-use
    way, either returning an actual Athena configurable, or an appropriately
    configured EL::AnaAlgorithmConfig instance.
 
    Keyword arguments:
      typeName     -- The C++ type name of the algorithm
      instanceName -- The instance name of the algorithm to create
    """
    return createComponent( typeName, instanceName, 'AnaReentrantAlgorithm' )
 
 

createService()

def python.DualUseConfig.createService	(		typeName,
			serviceName,
			sequence = None
	)

Helper function for setting up a service for a dual-use algorithm

This function is meant to be used to set up services in a dual-use
manner, particularly for the common CP algorithms.  This allows to
use the same syntax in EventLoop and Athena, hiding the
differences internally.  Since in EventLoop the service gets added
to a sequence (but in Athena does not), that sequence needs to be
passed into this function.

Keyword arguments:
  typeName -- The C++ type name of the service
  serviceName -- The name with which the service handle was configured on
                the algorithm. Also the instance name of the service.
  sequence -- an optional argument of an algorithm sequence to add it to
              in EventLoop (ignored in Athena)

Definition at line 127 of file DualUseConfig.py.

def createService( typeName, serviceName, sequence=None ):
    """Helper function for setting up a service for a dual-use algorithm
 
    This function is meant to be used to set up services in a dual-use
    manner, particularly for the common CP algorithms.  This allows to
    use the same syntax in EventLoop and Athena, hiding the
    differences internally.  Since in EventLoop the service gets added
    to a sequence (but in Athena does not), that sequence needs to be
    passed into this function.
 
    Keyword arguments:
      typeName -- The C++ type name of the service
      serviceName -- The name with which the service handle was configured on
                    the algorithm. Also the instance name of the service.
      sequence -- an optional argument of an algorithm sequence to add it to
                  in EventLoop (ignored in Athena)
 
    """
 
    global isAthena
    global useComponentAccumulator
 
    if isAthena:
 
        # Look up the Athena configurable of this tool:
        from AthenaConfiguration.ComponentFactory import CompFactory
        serviceClass = CompFactory.getComp( typeName )
 
        if useComponentAccumulator:
            # ComponentAccumulator will add the tool to ToolSvc
            # Avoid importing AthenaCommon.AppMgr in a CA Athena job
            # as it modifies Gaudi behaviour
            return serviceClass( serviceName )
        else:
            # Add an instance of the service to the ServiceMgr:
            from AthenaCommon.AppMgr import ServiceMgr
            if not hasattr( ServiceMgr, serviceName ):
                ServiceMgr += serviceClass( serviceName )
                pass
 
            # Return the member on the ServiceMgr:
            return getattr( ServiceMgr, serviceName )
 
    else:
        # If that didn't work, then apparently we're in an EventLoop
        # environment, so let's use the EventLoop specific formalism.
        service = createComponent( typeName, serviceName, 'AsgService' )
        if sequence is not None :
            sequence += service
            pass
        return service
 
 

Variable Documentation

isAthena

bool python.DualUseConfig.isAthena = False

Definition at line 4 of file DualUseConfig.py.

useComponentAccumulator

python.DualUseConfig.useComponentAccumulator = False

Definition at line 3 of file DualUseConfig.py.