python.CFElements Namespace Reference

Classes
class	TestCF
class	TestNest

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

Variables
	AthSequencer = CompFactory.AthSequencer

Function Documentation

checkSequenceConsistency()

checkSequenceConsistency

(

seq

)

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

Definition at line 56 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() )
 
 

findAlgorithm()

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

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

findAllAlgorithms	(		sequence,
			nameToLookFor = None )

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

Definition at line 136 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()

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

findOwningSequence	(		start,
			nameToLookFor )

find sequence that owns the sequence nameTooLookFor

Definition at line 97 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()

findSubSequence	(		start,
			nameToLookFor )

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

Definition at line 78 of file CFElements.py.

def findSubSequence( start, nameToLookFor ):
    """ Traverse sequences tree to find a sequence of a given name. The first one is returned. """
    # Implemented as an iterative Depth-First search, which is faster than recursion in Python.
 
    stack = [start]
    while stack:
        current = stack.pop()
 
        if current.getName() == nameToLookFor:
            return current
 
        # Collect child sequences (plain loop is faster than generator expression)
        for c in getSequenceChildren(current):
            if isSequence(c):
                stack.append(c)
 
    return None
 
 

flatAlgorithmSequences()

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 173 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)
 
 

getSequenceChildren()

getSequenceChildren

(

comp

)

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

Definition at line 48 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()

isSequence

(

obj

)

Definition at line 74 of file CFElements.py.

def isSequence( obj ):
    return type(obj) is AthSequencer  # faster than isinstance and we do not care about inheritance
 
 

iterSequences()

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

parAND	(		name,
			subs = [],
			invert = False )

parallel AND sequencer

Definition at line 7 of file CFElements.py.

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

parOR()

parOR	(		name,
			subs = [],
			invert = False )

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

Definition at line 16 of file CFElements.py.

def parOR(name, subs=[], invert=False):
    """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,
                         Invert = invert,
                         Members = subs.copy() )
 

seqAND()

seqAND	(		name,
			subs = [],
			invert = False )

sequential AND sequencer

Definition at line 27 of file CFElements.py.

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

seqOR()

seqOR	(		name,
			subs = [],
			invert = False )

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

Definition at line 36 of file CFElements.py.

def seqOR(name, subs=[], invert=False):
    """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,
                         Invert = invert,
                         Members = subs.copy() )
 
 

Variable Documentation

AthSequencer

python.CFElements.AthSequencer = CompFactory.AthSequencer

Definition at line 5 of file CFElements.py.