l1MenuGraph Namespace Reference

Classes
class	AlgData

Functions
def	l1MenuGraph (flags, do_dot=False, verbose=False)

Variables
	logger
	do_dot
	True
	verbose

Function Documentation

l1MenuGraph()

def l1MenuGraph.l1MenuGraph	(		flags,
			do_dot = False,
			verbose = False
	)

Find the L1Topo call graph. For each node, provide a AlgData
object. These objects carry information needed to configure
Athena components.

Definition at line 51 of file l1MenuGraph.py.

def l1MenuGraph(flags, do_dot=False, verbose=False):
    """Find the L1Topo call graph. For each node, provide a AlgData
    object. These objects carry information needed to configure
    Athena components."""
 
    L1Menu = getMenu(flags)
 
    logger.debug('menu object')
    logger.debug(L1Menu.printSummary())
 
    alg_data_list = []
 
    sn = 1  # node number. 0 is reserved for root
    for algType in ("TOPO", "MULTTOPO"):
        algs = L1Menu.topoAlgorithms(algType) # map: algName: alg details
 
        for alg_key in algs.keys():
            keyed_algs = algs[alg_key]
            for name, value in keyed_algs.items():
                
                ad = AlgData()
                ad.name = name
                ad.klass = value['klass']
                ad.l1AlgType = algType
                if algType == 'MULTTOPO':
                    ad.globalL1AlgType = 'COUNT'
                    try:
                        threshold_name = value['threshold']
                        ad.threshold = L1Menu.thresholds()[threshold_name]['value']
                        ad.threshold_flavour = value['flavour']
                    except KeyError:
                        logger.info('No threshold data for COUNT alg '+name)
 
                inputs = value['input']
                if isinstance(inputs, list):
                    ad.inputs = inputs
                else:
                    ad.inputs = [inputs]
 
                outputs = value['output']
                if isinstance(outputs, list):
                    ad.outputs = outputs
                else:
                    ad.outputs = [outputs]
 
                ad.sn = sn
                ad.menu = value
 
                sn += 1
                alg_data_list.append(ad)
 
 
    # make lists with no duplicates in a manner that avoids
    # non-fatal but unpleasant changes in odering if set() is naively used.
    all_inputs = []
    [all_inputs.extend(ad.inputs) for ad in alg_data_list]
    all_inputs = {}.fromkeys(all_inputs)
    all_inputs = all_inputs.keys()
    
    all_outputs = []
    [all_outputs.extend(ad.outputs) for ad in alg_data_list]
    all_outputs = {}.fromkeys(all_outputs)
    all_outputs = all_outputs.keys()
 
 
    missing_inputs = []
    for k in all_inputs:
        if k not in all_outputs:
            missing_inputs.append(k)
 
    logger.debug('input algs to be added ['+ str(len(missing_inputs))+']')
    for io in missing_inputs:
        logger.debug('input alg: ' + io)
        ad = AlgData()
        # the class string must match the name with which the
        # class appears in the AlRegister
        # 
        klass = 'TopoEventInputAlg' 
        ad.name = klass + '_' + io
        ad.klass =  klass
        ad.outputs = [io]
        ad.globalL1AlgType = 'INPUT'
        ad.sn = sn
        sn += 1
        alg_data_list.append(ad)
 
    # identify the SORT and DECISION algorithms
    for ad in alg_data_list:
        if ad.globalL1AlgType is not None: continue
        isSortAlg = ad.inputs[0] in missing_inputs
        if isSortAlg:
            if len(ad.inputs) != 1:
                raise RuntimeError('AlgData with > 1 inputs '
                                   'at least 1 from input alg')
 
            ad.globalL1AlgType = 'SORT'
        else:
            for inp in ad.inputs:
                if inp in missing_inputs:
                    raise RuntimeError('AlgData with >1 inputs'
                                       'at least 1 from input alg')
                
            ad.globalL1AlgType = 'DECISION'
 
        
    alg2inputs = {}
    output2alg = {}
    for ad in alg_data_list:
        algname = ad.name
        assert algname not in alg2inputs
 
        alg2inputs[algname] = ad.inputs
 
        for outp in ad.outputs:
            assert outp not in output2alg
            output2alg[outp] = algname
        
    logger.verbose('\nalg2inputs')
    logger.verbose(pprint.pformat(alg2inputs, indent=4))
    
    logger.verbose('\noutput2alg')
    logger.verbose(pprint.pformat(output2alg, indent=4))
 
 
    # ensure alg names are unique
    alg_names = [ad.name for ad in alg_data_list]
    assert len(alg_names) == len(set(alg_names))
 
    # ensure output names are not shared by more than one algorithm
    outputs = []
    [outputs.extend(ad.outputs) for ad in alg_data_list]
    assert len(outputs) == len(set(outputs))
 
    # algorithm C  is the child of algorithm P if C has an output
    # which is an input to P
 
    output2sn = {}
    for a in alg_data_list:
        for o in a.outputs:
            output2sn[o] = a.sn
 
    # from input names, fill in input sns:
    for ad in alg_data_list:
        ad.input_sns = [output2sn[inp] for inp in ad.inputs]
 
       
    logger.verbose('\nalg data:')
    for ad in alg_data_list:
        logger.verbose(pprint.pformat(str(ad), indent=4))
 
    adj_table = {}
    V = sn  # no. of vertices. 0 reserved for root. sn has already been bumped
    for v in range(V):  # need V locations
        adj_table[v] = []
 
    for a in alg_data_list:
        for i in a.inputs:
            if i in output2sn:
                adj_table[a.sn].append(output2sn[i])
 
    G = Digraph(V)
    for v in adj_table:
        for w in adj_table[v]:
            G.addEdge(v, w)
 
    if do_dot:
        dot(G, 'G.dot')
 
    return G, alg_data_list
 

Variable Documentation

do_dot

l1MenuGraph.do_dot

Definition at line 222 of file l1MenuGraph.py.

logger

l1MenuGraph.logger

Definition at line 15 of file l1MenuGraph.py.

True

l1MenuGraph.True

Definition at line 222 of file l1MenuGraph.py.

verbose

l1MenuGraph.verbose

Definition at line 222 of file l1MenuGraph.py.