python.CFElements Namespace Reference

Classes
class	TestCF
class	TestNest

Functions
def	parAND (name, subs=[])
def	parOR (name, subs=[])
def	seqAND (name, subs=[])
def	seqOR (name, subs=[])
def	getSequenceChildren (comp)
def	getAllSequenceNames (seq, depth=0)
def	checkSequenceConsistency (seq)
def	stepSeq (name, filterAlg, rest)
def	isSequence (obj)
def	findSubSequence (start, nameToLookFor)
def	findOwningSequence (start, nameToLookFor)
def	findAlgorithmByPredicate (startSequence, predicate, depth=1000000)
def	findAlgorithm (startSequence, nameToLookFor, depth=1000000)
def	findAllAlgorithms (sequence, nameToLookFor=None)
def	findAllAlgorithmsByName (sequence, namesToLookFor=None)
def	flatAlgorithmSequences (start)
def	iterSequences (start)

Variables
	AthSequencer = CompFactory.AthSequencer

Function Documentation

checkSequenceConsistency()

def python.CFElements.checkSequenceConsistency

(

seq

)

Enforce rules for sequence graph - identical items can not be added to itself (even indirectly) 

Definition at line 69 of file CFElements.py.

def checkSequenceConsistency( seq ):
    """ Enforce rules for sequence graph - identical items can not be added to itself (even indirectly) """
 
    def __noSubSequenceOfName( s, n, seen = set() ):
        seen = seen.copy()
        seen.add (s)
        for c in getSequenceChildren( s ):
            if c in seen:
                raise RuntimeError(f"Sequence {c.getName()} contains itself")
            if isSequence( c ):
                if c.getName() == n:
                    raise RuntimeError(f"Sequence {n} contains sub-sequence of the same name")
                __noSubSequenceOfName( c, c.getName(), seen ) # check each sequence for repetition as well
                __noSubSequenceOfName( c, n, seen )
 
    __noSubSequenceOfName( seq, seq.getName() )
    for c in getSequenceChildren( seq ):
        checkSequenceConsistency(c)
 
 

findAlgorithm()

def python.CFElements.findAlgorithm	(		startSequence,
			nameToLookFor,
			depth = 1000000
	)

Traverse sequences tree to find the algorithm of given name. The first encountered is returned.

The name() method is used to obtain the algorithm name, that one has to match to the request.

Definition at line 145 of file CFElements.py.

def findAlgorithm( startSequence, nameToLookFor, depth = 1000000 ):
    """ Traverse sequences tree to find the algorithm of given name. The first encountered is returned.
 
    The name() method is used to obtain the algorithm name, that one has to match to the request.
    """
    return findAlgorithmByPredicate( startSequence, lambda alg: alg.getName() == nameToLookFor, depth )
 
 

findAlgorithmByPredicate()

def python.CFElements.findAlgorithmByPredicate	(		startSequence,
			predicate,
			depth = 1000000
	)

Traverse sequences tree to find the first algorithm satisfying given predicate. The first encountered is returned.

Depth of the search can be controlled by the depth parameter.
Typical use is to limit search to the startSequence with depth parameter set to 1

Definition at line 126 of file CFElements.py.

def findAlgorithmByPredicate( startSequence, predicate, depth = 1000000 ):
    """ Traverse sequences tree to find the first algorithm satisfying given predicate. The first encountered is returned.
 
    Depth of the search can be controlled by the depth parameter.
    Typical use is to limit search to the startSequence with depth parameter set to 1
    """
    for c in getSequenceChildren(startSequence):
        if not isSequence(c):
            if predicate(c):
                return c
        else:
            if depth > 1:
                found = findAlgorithmByPredicate( c, predicate, depth-1 )
                if found:
                    return found
 
    return None
 
 

findAllAlgorithms()

def python.CFElements.findAllAlgorithms	(		sequence,
			nameToLookFor = None
	)

Returns flat listof of all algorithm instances in this, and in sub-sequences

Definition at line 153 of file CFElements.py.

def findAllAlgorithms(sequence, nameToLookFor=None):
    """
    Returns flat listof of all algorithm instances in this, and in sub-sequences
    """
    algorithms = []
    for child in getSequenceChildren(sequence):
        if isSequence(child):
            algorithms += findAllAlgorithms(child, nameToLookFor)
        else:
            if nameToLookFor is None or child.getName() == nameToLookFor:
                algorithms.append(child)
    return algorithms
 
 

findAllAlgorithmsByName()

def python.CFElements.findAllAlgorithmsByName	(		sequence,
			namesToLookFor = None
	)

Finds all algorithms in sequence and groups them by name

Resulting dict has a following structure
{"Alg1Name":[(Alg1Instance, parentSequenceA, indexInSequenceA),(Alg1Instance, parentSequenceB, indexInSequenceB)],
 "Alg2Name":(Alg2Instance, parentSequence, indexInThisSequence),
 ....}

Definition at line 167 of file CFElements.py.

def findAllAlgorithmsByName(sequence, namesToLookFor=None):
    """
    Finds all algorithms in sequence and groups them by name
    
    Resulting dict has a following structure
    {"Alg1Name":[(Alg1Instance, parentSequenceA, indexInSequenceA),(Alg1Instance, parentSequenceB, indexInSequenceB)],
     "Alg2Name":(Alg2Instance, parentSequence, indexInThisSequence),
     ....}
    """
    algorithms = collections.defaultdict(list)
    for idx, child in enumerate(getSequenceChildren(sequence)):
        if child.getName() == sequence.getName():
            raise RuntimeError(f"Recursively-nested sequence: {child.getName()} contains itself")
        if isSequence(child):
            childAlgs = findAllAlgorithmsByName(child, namesToLookFor)
            for algName in childAlgs:
                algorithms[algName] += childAlgs[algName]
        else:
            if namesToLookFor is None or child.getName() in namesToLookFor:
                algorithms[child.getName()].append( (child, sequence, idx) )
    return algorithms
 
 

findOwningSequence()

def python.CFElements.findOwningSequence	(		start,
			nameToLookFor
	)

find sequence that owns the sequence nameTooLookFor

Definition at line 114 of file CFElements.py.

def findOwningSequence( start, nameToLookFor ):
    """ find sequence that owns the sequence nameTooLookFor"""
    for c in getSequenceChildren(start):
        if c.getName() == nameToLookFor:
            return start
        if isSequence( c ):
            found = findOwningSequence( c, nameToLookFor )
            if found:
                return found
    return None
 
 

findSubSequence()

def python.CFElements.findSubSequence	(		start,
			nameToLookFor
	)

Traverse sequences tree to find a sequence of a given name. The first one is returned. 

Definition at line 100 of file CFElements.py.

def findSubSequence( start, nameToLookFor ):
    """ Traverse sequences tree to find a sequence of a given name. The first one is returned. """
    if start.getName() == nameToLookFor:
        return start
    for c in getSequenceChildren(start):
        if isSequence( c ):
            if  c.getName() == nameToLookFor:
                return c
            found = findSubSequence( c, nameToLookFor )
            if found:
                return found
    return None
 
 

flatAlgorithmSequences()

def python.CFElements.flatAlgorithmSequences

(

start

)

Converts tree like structure of sequences into dictionary
keyed by top/start sequence name containing lists of of algorithms & sequences.

Definition at line 190 of file CFElements.py.

def flatAlgorithmSequences( start ):
    """ Converts tree like structure of sequences into dictionary
    keyed by top/start sequence name containing lists of of algorithms & sequences."""
 
    def __inner( seq, collector ):
        for c in getSequenceChildren(seq):
            collector[seq.getName()].append( c )
            if isSequence( c ):
                __inner( c, collector )
 
    from collections import defaultdict,OrderedDict
    c = defaultdict(list)
    __inner(start, c)
    return OrderedDict(c)
 
 

getAllSequenceNames()

def python.CFElements.getAllSequenceNames	(		seq,
			depth = 0
	)

Generate a list of sequence names and depths in the graph, e.g.
[('AthAlgSeq', 0), ('seq1', 1), ('seq2', 1), ('seq1', 2)]
represents
\\__ AthAlgSeq (seq: PAR AND)
    \\__ seq1 (seq: SEQ AND)
       \\__ seq2 (seq: SEQ AND)

Definition at line 52 of file CFElements.py.

def getAllSequenceNames(seq, depth=0):
    """ Generate a list of sequence names and depths in the graph, e.g.
    [('AthAlgSeq', 0), ('seq1', 1), ('seq2', 1), ('seq1', 2)]
    represents
    \\__ AthAlgSeq (seq: PAR AND)
        \\__ seq1 (seq: SEQ AND)
           \\__ seq2 (seq: SEQ AND)
    """
 
    seqNameList = [(seq.getName(), depth)]
    for c in getSequenceChildren(seq):
      if isSequence(c):
        seqNameList +=  getAllSequenceNames(c, depth+1)
 
    return seqNameList
 
 

getSequenceChildren()

def python.CFElements.getSequenceChildren

(

comp

)

Return sequence children (empty if comp is not a sequence)

Definition at line 44 of file CFElements.py.

def getSequenceChildren(comp):
    """Return sequence children (empty if comp is not a sequence)"""
    try:
        return comp.Members
    except AttributeError:
        return []
 
 

isSequence()

def python.CFElements.isSequence

(

obj

)

Definition at line 96 of file CFElements.py.

def isSequence( obj ):
    return isinstance(obj, AthSequencer)
 
 

iterSequences()

def python.CFElements.iterSequences

(

start

)

Iterator of sequences and their algorithms from (and including) the `start`
sequence object. Do start from a sequence name use findSubSequence.

Definition at line 206 of file CFElements.py.

def iterSequences( start ):
    """Iterator of sequences and their algorithms from (and including) the `start`
    sequence object. Do start from a sequence name use findSubSequence."""
    def __inner( seq ):
        for c in getSequenceChildren(seq):
            yield c
            if isSequence(c):
                yield from __inner(c)
    yield start
    yield from __inner(start)
 
 
 
# self test

parAND()

def python.CFElements.parAND	(		name,
			subs = []
	)

parallel AND sequencer

Definition at line 7 of file CFElements.py.

def parAND(name, subs=[]):
    """parallel AND sequencer"""
    return AthSequencer( name,
                         ModeOR = False,
                         Sequential = False,
                         StopOverride = True,
                         Members = subs.copy() )
 

parOR()

def python.CFElements.parOR	(		name,
			subs = []
	)

parallel OR sequencer
This is the default sequencer and lets the DataFlow govern the execution entirely.

Definition at line 15 of file CFElements.py.

def parOR(name, subs=[]):
    """parallel OR sequencer
    This is the default sequencer and lets the DataFlow govern the execution entirely.
    """
    return AthSequencer( name,
                         ModeOR = True,
                         Sequential = False,
                         StopOverride = True,
                         Members = subs.copy() )
 

seqAND()

def python.CFElements.seqAND	(		name,
			subs = []
	)

sequential AND sequencer

Definition at line 25 of file CFElements.py.

def seqAND(name, subs=[]):
    """sequential AND sequencer"""
    return AthSequencer( name,
                         ModeOR = False,
                         Sequential = True,
                         StopOverride = False,
                         Members = subs.copy() )
 

seqOR()

def python.CFElements.seqOR	(		name,
			subs = []
	)

sequential OR sequencer
Used when a barrier needs to be set by all subs reached irrespective of the decision

Definition at line 33 of file CFElements.py.

def seqOR(name, subs=[]):
    """sequential OR sequencer
    Used when a barrier needs to be set by all subs reached irrespective of the decision
    """
    return AthSequencer( name,
                         ModeOR = True,
                         Sequential = True,
                         StopOverride = True,
                         Members = subs.copy() )
 
 

stepSeq()

def python.CFElements.stepSeq	(		name,
			filterAlg,
			rest
	)

elementary HLT step sequencer, filterAlg is gating, rest is anything that needs to happen within the step 

Definition at line 89 of file CFElements.py.

def stepSeq(name, filterAlg, rest):
    """ elementary HLT step sequencer, filterAlg is gating, rest is anything that needs to happen within the step """
    stepReco = parOR(name+"_reco", rest)
    stepAnd = seqAND(name, [ filterAlg, stepReco ])
    return stepAnd
 
 

Variable Documentation

AthSequencer

python.CFElements.AthSequencer = CompFactory.AthSequencer

Definition at line 5 of file CFElements.py.