HLTCFConfig Namespace Reference

Functions
	createStepFilterNode (name, seq_list, dump=False)
	matrixDisplay (allCFSeq)
	CORE of Decision Handling.
	sequenceScanner (HLTNode)
	decisionTreeFromChains (flags, HLTNode, chains, allDicts)
	createDataFlow (flags, chains)
	createControlFlow (flags, HLTNode, CFseqList)
	addChainsToDataFlow (flags, CFseq_list, allDicts)
	buildFilter (filter_name, filter_input, empty)

Variables
	log = logging.getLogger( __name__ )

Detailed Description

    ------ Documentation on HLT Tree creation -----

++ Filter creation strategy

++ Connections between InputMaker/HypoAlg/Filter

++ Seeds

++ Combined chain strategy

- The combined chains use duplicates of the single-object-HypoAlg, called HypoAlgName_for_stepName.
  These duplicates are connected to a dedicated ComboHypoAlg (added by the framework), able to count object multiplicity
     -- This is needed for two reasons:
           -- the HypoAlg is designed to have only one input TC (that is already for the single object)
           -- otherwise the HypoAlg would be equipped with differnt HypoTools with the same name (see for example e3_e8)
     -- If the combined chain is symmetric (with multiplicity >1), the Hypo is duplicated only once,
        equipped with a HypoTool configured as single object and followed by one ComboHypoAlg

Function Documentation

addChainsToDataFlow()

HLTCFConfig.addChainsToDataFlow	(		flags,
			CFseq_list,
			allDicts )

Definition at line 342 of file HLTCFConfig.py.

def addChainsToDataFlow(flags, CFseq_list, allDicts):
    for groupsInStep in CFseq_list:
        for cfgroup in groupsInStep:   
            chains = cfgroup.chains            
            CFS = cfgroup.sequenceCA            
            # add chains to the ComboHypo:
            if CFS.step.combo is not None:
                for chain in chains:
                    CFS.step.combo.addChain( [d for d in allDicts if d['chainName'] == chain ][0])
                log.debug("Added chains to ComboHypo: %s",CFS.step.combo.getChains())            
                        
            # add HypoTools to this step (cumulating all same steps)
            cfgroup.createHypoTools(flags)  
 
 
 

buildFilter()

HLTCFConfig.buildFilter	(		filter_name,
			filter_input,
			empty )

 Build the FILTER
 one filter per previous sequence at the start of the sequence: always create a new one
 if the previous hypo has more than one output, try to get all of them
 one filter per previous sequence: 1 input/previous seq, 1 output/next seq

Definition at line 358 of file HLTCFConfig.py.

def buildFilter(filter_name,  filter_input, empty):
    """
     Build the FILTER
     one filter per previous sequence at the start of the sequence: always create a new one
     if the previous hypo has more than one output, try to get all of them
     one filter per previous sequence: 1 input/previous seq, 1 output/next seq
    """
    if empty:
        log.debug("Calling PassFilterNode %s", filter_name)
        sfilter = PassFilterNode(name = filter_name)
        for i in filter_input:
            sfilter.addInput(i)
            sfilter.addOutput(i)
    else:
        sfilter = RoRSequenceFilterNode(name = filter_name)        
        for i in filter_input:
            sfilter.addInput(i)
            sfilter.addOutput(CFNaming.filterOutName(filter_name, i))
 
    log.debug("Added inputs to filter: %s", sfilter.getInputList())
    log.debug("Added outputs to filter: %s", sfilter.getOutputList())
    log.debug("Filter Done: %s", sfilter.Alg.name)
 
    
    return (sfilter)
 
 
 

createControlFlow()

HLTCFConfig.createControlFlow	(		flags,
			HLTNode,
			CFseqList )

Creates Control Flow Tree starting from the CFSequences

Definition at line 279 of file HLTCFConfig.py.

def createControlFlow(flags, HLTNode, CFseqList):
    """ Creates Control Flow Tree starting from the CFSequences"""    
    HLTNodeName = HLTNode.getName()    
    log.debug("[createControlFlow] on node %s with %d CFsequences",HLTNodeName, len(CFseqList))
 
    acc = ComponentAccumulator()
    acc.addSequence(HLTNode)
 
    for nstep, sequences in enumerate(CFseqList):
        stepSequenceName =  CFNaming.stepName(nstep)
        log.debug("\n******** Create CF Tree %s with %d AthSequencers", stepSequenceName, len(sequences))
 
        # create filter node
        log.debug("[createControlFlow] Create filter step %s with %d filters", stepSequenceName, len(CFseqList[nstep])) 
        stepCFFilter = parOR(stepSequenceName + CFNaming.FILTER_POSTFIX)
        acc.addSequence(stepCFFilter, parentName=HLTNodeName)
 
        filter_list = []
        # add the filter to the node
        for cgroup in sequences:
            filterAlg = cgroup.sequenceCA.filterNode.Alg 
            if filterAlg.getName() not in filter_list:
                log.debug("[createControlFlow] Add  %s to filter node %s", filterAlg.getName(), stepSequenceName)
                filter_list.append(filterAlg.getName())   
                stepCFFilter.Members += [filterAlg]
 
        # create reco step node
        log.debug("[createControlFlow] Create reco step %s with %d sequences", stepSequenceName, len(CFseqList))
        stepCFReco = parOR(stepSequenceName + CFNaming.RECO_POSTFIX)  
        acc.addSequence(stepCFReco, parentName = HLTNodeName)
 
        # add the sequences to the reco node
        addedEmtpy = False
        for cgroup in sequences: 
            cseq=cgroup.sequenceCA  
            if  cseq.step.isEmpty and addedEmtpy:
                cseq.ca.wasMerged()
                continue
            if  cseq.step.isEmpty: # adding Empty only once to avoid merging multiple times the PassSequence
                addedEmtpy= True
            log.debug(" *** Create CF Tree for CFSequence %s", cseq.step.name)
            acc.merge(cseq.ca, sequenceName=stepCFReco.getName())
 
        # add the monitor summary
        stepDecisions = []
        for CFseq in CFseqList[nstep]:
            stepDecisions.extend(CFseq.sequenceCA.decisions)
 
        summaryAlg = TriggerSummaryAlg( flags, CFNaming.stepSummaryName(stepSequenceName),
                                        InputDecision = "HLTSeedingSummary",
                                        FinalDecisions = list(dict.fromkeys(stepDecisions)) )
 
        acc.addEventAlgo(summaryAlg, sequenceName = HLTNode.getName())
 
        if flags.Trigger.generateMenuDiagnostics:
            log.debug("Now Draw Menu Diagnostic dot graphs...")
            stepCF_DataFlow_to_dot( stepCFReco.getName(), CFseqList[nstep] )
            stepCF_ControlFlow_to_dot( stepCFReco )
       
        log.debug("************* End of step %d, %s", nstep+1, stepSequenceName)
 
    return acc
 

createDataFlow()

HLTCFConfig.createDataFlow	(		flags,
			chains )

Creates the filters and connect them to the menu sequences

Definition at line 185 of file HLTCFConfig.py.

def createDataFlow(flags, chains):
    """ Creates the filters and connect them to the menu sequences"""
   
    # find tot nsteps
    chainWithMaxSteps = max(chains, key = lambda chain: len(chain.steps))
    NSTEPS = len(chainWithMaxSteps.steps)
    log.info("[createDataFlow] creating DF for %d chains and total %d steps", len(chains), NSTEPS)
 
    # initialize arrays for monitor
    finalDecisions = [ [] for n in range(NSTEPS) ]
    CFseqList = [ [] for n in range(NSTEPS) ]
    CFSeqByFilterName = [ {} for n in range(NSTEPS) ] # CFSeqeunces keyed by filter name (speedup)
 
    # loop over chains
    for chain in chains:
        log.debug("\n Configuring chain %s with %d steps: \n   - %s ", chain.name,len(chain.steps),'\n   - '.join(map(str, [{step.name:step.nLegs} for step in chain.steps])))
 
        lastCFgroup = None
        lastDecisions = []
        for nstep, chainStep in enumerate( chain.steps ):
            if not flags.Trigger.fastMenuGeneration:
                #create all sequences CA in all steps to allow data flow connections
                chainStep.createSequences()
            log.debug("\n************* Start connecting step %d %s for chain %s", nstep+1, chainStep.name, chain.name)           
            if nstep == 0:             
                filterInput = chain.L1decisions
            else:
                filterInput = lastDecisions
            if len(filterInput) == 0 :
                log.error("[createDataFlow] Filter for step %s has %d inputs! At least one is expected", chainStep.name, len(filterInput))
                raise Exception("[createDataFlow] Cannot proceed, exiting.")
            
            log.debug("Set Filter input: %s while setting the chain: %s", filterInput, chain.name)
 
            # make one filter per step:
            sequenceFilter = None            
            filterName = CFNaming.filterName(chainStep.name)
            if chainStep.isEmpty:
                filterOutput = filterInput
            else:
                filterOutput = [CFNaming.filterOutName(filterName, inputName) for inputName in filterInput ]
 
            # TODO: Check sequence consistency if skipping, to avoid issues like https://its.cern.ch/jira/browse/ATR-28617
            foundCFgroup = CFSeqByFilterName[nstep].get(filterName, None)
            log.debug("%s CF sequences with filter name %s",  "Not found" if foundCFgroup is None else "Found", filterName)
            if foundCFgroup is None:
                sequenceFilter = buildFilter(filterName, filterInput, chainStep.isEmpty)                
                if flags.Trigger.fastMenuGeneration:
                    #create the sequences CA of this step in fast mode
                    chainStep.createSequences()
                # add the step to a new group
                CFgroup = CFGroup( ChainStep = chainStep, FilterAlg = sequenceFilter)
                CFgroup.connect(filterOutput)
                CFSeqByFilterName[nstep][sequenceFilter.Alg.getName()] = CFgroup
                CFseqList[nstep].append(CFgroup)
                lastCFgroup = CFgroup
            else:                
                lastCFgroup = foundCFgroup                               
                sequenceFilter = lastCFgroup.sequenceCA.filterNode
                if len(list(set(sequenceFilter.getInputList()).intersection(filterInput))) != len(list(set(filterInput))):
                    [ sequenceFilter.addInput(inputName) for inputName in filterInput ]
                    [ sequenceFilter.addOutput(outputName) for outputName in  filterOutput ]
                    lastCFgroup.connect(filterOutput)
 
            lastDecisions = lastCFgroup.sequenceCA.decisions
                                            
            # add chains to the filter:
            chainLegs = chainStep.getChainLegs()
            if len(chainLegs) != len(filterInput): 
                log.error("[createDataFlow] lengths of chainlegs = %s differ from inputs = %s", str(chainLegs), str(filterInput))
                raise Exception("[createDataFlow] Cannot proceed, exiting.")
            for finput, leg in zip(filterInput, chainLegs):
                log.debug("Adding chain %s to input %s of %s", leg, finput, sequenceFilter.Alg.name)
                sequenceFilter.addChain(leg, finput)
                
            log.debug("Now Filter has chains: %s", sequenceFilter.getChains())
            log.debug("Now Filter has chains/input: %s", sequenceFilter.getChainsPerInput())
            # store legs in the CFGroup
            lastCFgroup.addStepLeg(chainStep, chain.name)                                  
 
            if len(chain.steps) == nstep+1:
                log.debug("Adding finalDecisions for chain %s at step %d:", chain.name, nstep+1)
                for dec in lastDecisions:
                    finalDecisions[nstep].append(dec)
                    log.debug(dec)
                    
        #end of loop over steps
        log.debug("\n Built CD for chain %s with %d steps: \n   - %s ", chain.name,len(chain.steps),'\n   - '.join(map(str, [{step.name:step.nLegs} for step in chain.steps])))
    #end of loop over chains
 
    log.debug("End of createDataFlow for %d chains and total %d steps", len(chains), NSTEPS)
    return (finalDecisions, CFseqList)
 
 

createStepFilterNode()

HLTCFConfig.createStepFilterNode	(		name,
			seq_list,
			dump = False )

Elementary HLT filter step: OR node containing all Filters of the sequences. The node gates execution of next reco step 

Definition at line 44 of file HLTCFConfig.py.

def createStepFilterNode(name, seq_list, dump=False):
    """ Elementary HLT filter step: OR node containing all Filters of the sequences. The node gates execution of next reco step """
 
    log.debug("Create filter step %s with %d filters", name, len(seq_list))
    stepCF = parOR(name + CFNaming.FILTER_POSTFIX)
    filter_list=[]
    for seq in seq_list:
        filterAlg = seq.filter.Alg        
        log.debug("createStepFilterNode: Add  %s to filter node %s", filterAlg.getName(), name)
        if filterAlg not in filter_list:
            filter_list.append(filterAlg)
 
    stepCF = parOR(name + CFNaming.FILTER_POSTFIX, subs=filter_list)
    if dump:
        dumpSequence (stepCF, indent=0)
    return stepCF
 
 
 

decisionTreeFromChains()

HLTCFConfig.decisionTreeFromChains	(		flags,
			HLTNode,
			chains,
			allDicts )

Creates the decision tree, given the starting node and the chains containing the sequences  

Definition at line 157 of file HLTCFConfig.py.

def decisionTreeFromChains(flags, HLTNode, chains, allDicts):
    """ Creates the decision tree, given the starting node and the chains containing the sequences  """
    log.info("[decisionTreeFromChains] Run decisionTreeFromChains on %s", HLTNode.getName())    
    HLTNodeName = HLTNode.getName()
    acc = ComponentAccumulator()
 
    if len(chains) == 0:
        log.info("[decisionTreeFromChains] Configuring empty decisionTree")
        acc.addSequence(HLTNode)
        return ([], [], acc)
        
    ( finalDecisions, CFseq_list) = createDataFlow(flags, chains)        
    addChainsToDataFlow(flags, CFseq_list, allDicts) 
    # now connect all algorithms and creates the CAs  
    cfAcc = createControlFlow(flags, HLTNode, CFseq_list)
    acc.merge(cfAcc)
 
    # create dot graphs
    log.debug("finalDecisions: %s", finalDecisions)
    if flags.Trigger.generateMenuDiagnostics:
        all_DataFlow_to_dot(HLTNodeName, CFseq_list)
    
    # matrix display
    # uncomment for serious debugging
    # matrixDisplay( CFseq_list )
 
    return (finalDecisions,CFseq_list, acc)
 

matrixDisplay()

HLTCFConfig.matrixDisplay

(

allCFSeq

)

CORE of Decision Handling.

Definition at line 67 of file HLTCFConfig.py.

def matrixDisplay( allCFSeq ):
 
    def __getHyposOfStep( step ):
        if len(step.sequences):
            step.getChainNames()           
        return []
   
    # fill dictionary to cumulate chains on same sequences, in steps (dict with composite keys)
    mx = defaultdict(list)
 
    for stepNumber,cfseq_list in enumerate(allCFSeq, 1):
        for cfseq in cfseq_list:
            chains = __getHyposOfStep(cfseq.step)
            for seq in cfseq.step.sequences:
                if seq.name == "Empty":
                    mx[stepNumber, "Empty"].extend(chains)
                else:
                    mx[stepNumber, seq.sequence.Alg.getName()].extend(chains)
 
    # sort dictionary by fist key=step
    sorted_mx = dict(sorted( list(mx.items()), key= lambda k: k[0]))
 
    log.debug( "" )
    log.debug( "="*90 )
    log.debug( "Cumulative Summary of steps")
    log.debug( "="*90 )
    for (step, seq), chains in list(sorted_mx.items()):
        log.debug( "(step, sequence)  ==> (%d, %s) is in chains: ",  step, seq)
        for chain in chains:
            log.debug( "              %s",chain)
 
    log.debug( "="*90 )
 
 

sequenceScanner()

HLTCFConfig.sequenceScanner

(

HLTNode

)

Checks the alignement of sequences and steps in the tree

Definition at line 101 of file HLTCFConfig.py.

def sequenceScanner( HLTNode ):
    """ Checks the alignement of sequences and steps in the tree"""
    # +-- AthSequencer/HLTAllSteps
    #   +-- AthSequencer/Step1_filter
    #   +-- AthSequencer/Step1_reco
    
    _seqMapInStep = defaultdict(set)
    _status = True
    def _mapSequencesInSteps(seq, stepIndex, childInView):
        """ Recursively finds the steps in which sequences are used"""
        if not isSequence(seq):
            return stepIndex
        match=re.search('^Step([0-9]+)_filter',seq.name)
        if match:
            stepIndex = match.group(1)
            log.debug("sequenceScanner: This is another step: %s %s", seq.name, stepIndex)
        inViewSequence = ""
        inView = False
        for c in seq.Members:
            if isSequence(c):
                # Detect whether this is the view sequence pointed to
                # by the EV creator alg, or if it is in such a sequence
                inView = c.getName()==inViewSequence or childInView
                stepIndex = _mapSequencesInSteps(c, stepIndex, childInView=inView)
                _seqMapInStep[c.name].add((stepIndex,inView))
                log.verbose("sequenceScanner: Child %s of sequence %s is in view? %s --> '%s'", c.name, seq.name, inView, inViewSequence)
            else:
                if isinstance(c, CompFactory.EventViewCreatorAlgorithm):
                    inViewSequence = c.ViewNodeName
                    log.verbose("sequenceScanner: EventViewCreatorAlg %s is child of sequence %s with ViewNodeName %s", c.name, seq.name, c.ViewNodeName)
        log.debug("sequenceScanner: Sequence %s is in view? %s --> '%s'", seq.name, inView, inViewSequence)
        return stepIndex
 
    # do the job:
    final_step=_mapSequencesInSteps(HLTNode, 0, childInView=False)
 
    for alg, steps in _seqMapInStep.items():
        if 'PassSequence' in alg or 'HLTCaloClusterMakerFSRecoSequence' in alg \
            or 'HLTCaloCellMakerFSRecoSequence' in alg: # do not count PassSequences, which is used many times. Harcoding HLTCaloClusterMakerFSRecoSequence and HLTCaloCellMakerFSRecoSequence when using FullScanTopoCluster building for photon triggers with RoI='' (also for Jets and MET) following discussion in ATR-24722. To be fixed
            continue
        # Sequences in views can be in multiple steps
        nonViewSteps = sum([0 if isInViews else 1 for (stepIndex,isInViews) in steps])
        if nonViewSteps > 1:
            steplist = [stepIndex for stepIndex,inViewSequence in steps]
            log.error("sequenceScanner: Sequence %s is expected outside of a view in more than one step: %s", alg, steplist)
            match=re.search('Step([0-9]+)',alg)
            if match:
                candidateStep=match.group(1)
                log.error("sequenceScanner:         ---> candidate good step is %s", candidateStep)
            _status=False
            raise RuntimeError(f"Duplicated event-scope sequence {alg} in steps {steplist}")
 
    log.debug("sequenceScanner: scanned %s steps with status %d", final_step, _status)
    return _status
   
 

Variable Documentation

log

HLTCFConfig.log = logging.getLogger( __name__ )

Definition at line 41 of file HLTCFConfig.py.