python.AlgSequence.AlgSequence Class Reference

Inheritance diagram for python.AlgSequence.AlgSequence:

Collaboration diagram for python.AlgSequence.AlgSequence:

Public Member Functions
def	__init__ (self, name="AlgSequence")
def	name (self)
def	insert (self, index, algOrSeq)
def	addSelfToJob (self, job)
def	__getitem__ (self, index)
def	__getattr__ (self, name)
def	__delattr__ (self, name)
def	__iter__ (self)
def	__iadd__ (self, algOrSeq, index=None)
def	__eq__ (self, other)
def	__ne__ (self, other)
def	__str__ (self)
def	__len__ (self)

Private Attributes
	_name
	_algsAndSequences

Detailed Description

Standalone algorithm sequence

This is a light-weight emulation of Athena's AthSequencer class,
implementing a simple algorithm sequence for EventLoop jobs.

Definition at line 19 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

Constructor & Destructor Documentation

__init__()

def python.AlgSequence.AlgSequence.__init__	(		self,
			name = "AlgSequence"
	)

Algorithm sequence constructor

Keyword arguments:
  name -- The name of the algorithm sequence (for debugging)

Definition at line 26 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __init__( self, name = "AlgSequence" ):
            """Algorithm sequence constructor
 
            Keyword arguments:
              name -- The name of the algorithm sequence (for debugging)
            """
 
            # Set up the member variables:
            self._name = name
            self._algsAndSequences = []
 
            return
 

Member Function Documentation

__delattr__()

def python.AlgSequence.AlgSequence.__delattr__	(		self,
			name
	)

Remove one algorithm/sequence from this sequence, by name

This is to allow removing algorithms (or even sequences) from this
sequence in case that would be needed.

Keyword arguments:
  name -- The name of the algorithm/sequence to delete from the
          sequence

Definition at line 107 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __delattr__( self, name ):
            """Remove one algorithm/sequence from this sequence, by name
 
            This is to allow removing algorithms (or even sequences) from this
            sequence in case that would be needed.
 
            Keyword arguments:
              name -- The name of the algorithm/sequence to delete from the
                      sequence
            """
 
            # Look up the algorithm by name:
            for algOrSeq in self._algsAndSequences:
                if algOrSeq.name() == name:
                    # If we found it, remove it:
                    self._algsAndSequences.remove( algOrSeq )
                    return
                pass
 
            # If no algorithm/sequence with this name was found, that's a
            # problem:
            raise AttributeError( 'Algorithm/sequence with name "%s" was not ' \
                                      'found' % name )
 

__eq__()

def python.AlgSequence.AlgSequence.__eq__	(		self,
			other
	)

Check for equality with another object

The implementation of this is very simple. We only check that
the name of the sequences would match.

Keyword arguments:
  other -- The object to compare this one against

Definition at line 177 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __eq__( self, other ):
            """Check for equality with another object
 
            The implementation of this is very simple. We only check that
            the name of the sequences would match.
 
            Keyword arguments:
              other -- The object to compare this one against
            """
 
            # First check that the other object is also an AlgSequence one:
            if not isinstance( other, AlgSequence ):
                return False
 
            # Base the equality purely on the name of the sequence. This may
            # need to be made smarter at one point.
            return ( self.name() == other.name() )
 

__getattr__()

def python.AlgSequence.AlgSequence.__getattr__	(		self,
			name
	)

Access one algorithm/sequence in this sequence, by name

This is to allow modifying the properties of algorithms in a
sequence that was set up centrally.

Keyword arguments:
  name -- The name of the algorithm/sequence to look up in the
          sequence

Definition at line 86 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __getattr__( self, name ):
            """Access one algorithm/sequence in this sequence, by name
 
            This is to allow modifying the properties of algorithms in a
            sequence that was set up centrally.
 
            Keyword arguments:
              name -- The name of the algorithm/sequence to look up in the
                      sequence
            """
 
            # Look up the algorithm by name:
            for algOrSeq in self._algsAndSequences:
                if algOrSeq.name() == name:
                    return algOrSeq
                pass
 
            # If no algorithm with this name was found, that's a problem:
            raise AttributeError( 'Algorithm/sequence with name "%s" was not ' \
                                      'found' % name )
 

__getitem__()

def python.AlgSequence.AlgSequence.__getitem__	(		self,
			index
	)

Return one algorithm/sequence from the sequence by index

This is to allow getting the n'th element of an algorithm sequence
(which itself may either be an algorithm or a sequence),
including the n'th element from the back of it if needed.

Keyword arguments:
  index -- The index of the algorithm/sequence to get from the
           sequence

Definition at line 72 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __getitem__( self, index ):
            """Return one algorithm/sequence from the sequence by index
 
            This is to allow getting the n'th element of an algorithm sequence
            (which itself may either be an algorithm or a sequence),
            including the n'th element from the back of it if needed.
 
            Keyword arguments:
              index -- The index of the algorithm/sequence to get from the
                       sequence
            """
 
            return self._algsAndSequences[ index ]
 

__iadd__()

def python.AlgSequence.AlgSequence.__iadd__	(		self,
			algOrSeq,
			index = None
	)

Add one algorithm/sequence to the sequence

This function is used to add one algorithm (or algorithm sequence)
to the sequence object, using the '+=' operator.

Keyword arguments:
  algOrSeq -- The algorithm/sequence to add to the sequence

Definition at line 142 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __iadd__( self, algOrSeq, index = None ):
            """Add one algorithm/sequence to the sequence
 
            This function is used to add one algorithm (or algorithm sequence)
            to the sequence object, using the '+=' operator.
 
            Keyword arguments:
              algOrSeq -- The algorithm/sequence to add to the sequence
            """
 
            # Check that the received object is of the right type:
            if not isinstance( algOrSeq, AnaAlgorithmConfig ) and \
               not isinstance( algOrSeq, PythonConfig ) and \
               not isinstance( algOrSeq, AlgSequence ):
                raise TypeError( 'The received object is not of type ' \
                                 'AnaAlgorithmConfig or PythonConfig or AlgSequence' )
                pass
 
            # Now check if an equivalent algorithm/sequence is already in the
            # list. As that's also an error.
            if algOrSeq in self:
                raise RuntimeError( 'Algorithm/sequence %s is already in ' \
                                    'this sequence' % algOrSeq.name() )
                pass
 
            # Add the algorithm/sequence to the internal list:
            if not index:
                self._algsAndSequences.append( algOrSeq )
            else:
                self._algsAndSequences.insert( index, algOrSeq )
                pass
 
            # Return the modified object:
            return self
 

__iter__()

def python.AlgSequence.AlgSequence.__iter__

(

self

)

Create an iterator over all the algorithms of this sequence

This is to allow for a Python-like iteration over all algorithms
that are part of the sequence. This includes iterating over the
algorithms that may be in sub-sequences of this sequence.

Definition at line 131 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __iter__( self ):
            """Create an iterator over all the algorithms of this sequence
 
            This is to allow for a Python-like iteration over all algorithms
            that are part of the sequence. This includes iterating over the
            algorithms that may be in sub-sequences of this sequence.
            """
 
            # Create the iterator to process the internal list of algorithms:
            return AlgSequenceIterator( self._algsAndSequences )
 

__len__()

def python.AlgSequence.AlgSequence.__len__

(

self

)

Return the size/length of the algorithm sequence

Just returning the number of algorithms and sequences that are in
this sequence. So this is not a recursive count.

Definition at line 223 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __len__( self ):
            """Return the size/length of the algorithm sequence
 
            Just returning the number of algorithms and sequences that are in
            this sequence. So this is not a recursive count.
            """
 
            return len( self._algsAndSequences )
 

__ne__()

def python.AlgSequence.AlgSequence.__ne__	(		self,
			other
	)

Check for an inequality with another object

This is just defined to make the '!=' operator of Python behave
consistently with the '==' operator for such objects.

Keyword arguments:
  other -- The object to compare this one against

Definition at line 195 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __ne__( self, other ):
            """Check for an inequality with another object
 
            This is just defined to make the '!=' operator of Python behave
            consistently with the '==' operator for such objects.
 
            Keyword arguments:
              other -- The object to compare this one against
            """
            return not self.__eq__( other )
 

__str__()

def python.AlgSequence.AlgSequence.__str__

(

self

)

Print the algorithm sequence in a user-friendly way

This function takes care of printing the full configuration of every
algorithm in the sequence.

Definition at line 206 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __str__( self ):
            """Print the algorithm sequence in a user-friendly way
 
            This function takes care of printing the full configuration of every
            algorithm in the sequence.
            """
 
            result = AnaAlgorithmConfig._printHeader( 'AlgSequence/%s' %
                                                      self.name() )
            result += '\n'
            for algOrSeq in self._algsAndSequences:
                result += '| %s\n' % indentBy( str( algOrSeq ), '| ' )
                pass
            result += AnaAlgorithmConfig._printFooter( 'AlgSequence/%s' %
                                                       self.name() )
            return result
 

addSelfToJob()

def python.AlgSequence.AlgSequence.addSelfToJob	(		self,
			job
	)

add a copy of this config to the EventLoop job object

Keyword arguments:
  job      -- The job object to add ourself to

Definition at line 61 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def addSelfToJob( self, job ):
            """add a copy of this config to the EventLoop job object
 
            Keyword arguments:
              job      -- The job object to add ourself to
            """
            for alg in self:
                alg.addSelfToJob (job)
                pass
            pass
 

insert()

def python.AlgSequence.AlgSequence.insert	(		self,
			index,
			algOrSeq
	)

Insert one algorithm/sequence into this sequence

This allows us to extend existing sequences with a greater
flexibility.

Keyword arguments:
  index    -- The index to insert the algorithm/sequence under
  algOrSeq -- The object to insert

Definition at line 48 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def insert( self, index, algOrSeq ):
            """Insert one algorithm/sequence into this sequence
 
            This allows us to extend existing sequences with a greater
            flexibility.
 
            Keyword arguments:
              index    -- The index to insert the algorithm/sequence under
              algOrSeq -- The object to insert
            """
 
            return self.__iadd__( algOrSeq, index = index )
 

name()

def python.AlgSequence.AlgSequence.name

(

self

)

Return the name of this sequence

Mainly for debugging purposes, and for when we are embedding
one sequence into another one.

Definition at line 39 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def name( self ):
            """Return the name of this sequence
 
            Mainly for debugging purposes, and for when we are embedding
            one sequence into another one.
            """
 
            return self._name
 

Member Data Documentation

_algsAndSequences

python.AlgSequence.AlgSequence._algsAndSequences

private

Definition at line 35 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

_name

python.AlgSequence.AlgSequence._name

private

Definition at line 34 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

---

The documentation for this class was generated from the following file:

• PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py