python.DualUseConfig Namespace Reference

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

Variables
bool	isAthena = False

Function Documentation

addPrivateTool()

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 131 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
    """
 
    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 )
 
        # Now look up the Athena configurable describing this tool:
        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 )
 
 

addPrivateToolInArray()

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 173 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
 
    """
 
    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 )
 
        # Now look up the Athena configurable describing this tool:
        toolClass = CompFactory.getComp(typeName)
 
        # Finally, set up the tool handle property, and return the tool that
        # was just appended (not the whole tool-handle array), so that callers
        # can configure it the same way they do in EventLoop.
        theTool = toolClass( toolNames[ -1 ] )
        getattr( component, toolNames[ -1 ] ).append( theTool )
        return theTool
 
    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 )

createAlgorithm()

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 46 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()

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 12 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
 
    """
 
    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:
        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( f'{typeName}/{instanceName}' )
        component.setComponentType( componentType )
        return component
 
 

createPublicTool()

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 75 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.
    """
 
    if isAthena:
        # Look up the Athena configurable of this tool:
        return CompFactory.getComp( typeName )( 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()

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 PythonConfig instance (with component type
AnaReentrantAlgorithm).

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

Definition at line 60 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 PythonConfig instance (with component type
    AnaReentrantAlgorithm).
 
    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()

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 99 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)
 
    """
 
    if isAthena:
        # Look up the Athena configurable of this serivce:
        return CompFactory.getComp( typeName )( 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
        return service
 
 

Variable Documentation

isAthena

bool isAthena = False

Definition at line 3 of file DualUseConfig.py.