python.hypoConfigBuilder Namespace Reference

Functions
def	make_root_repcondconfig ()
def	buildHypoHelperConfigTool (params)
def	process_simple (chain_parts)
def	process_dipz (scenario, chainPartInd)
def	process_ht (scenario, chainPartInd)
def	process_htdipz (scenario, chainPartInd)
def	process_mult (scenario, chainPartInd)
def	process_dijet (scenario, chainPartInd)
def	process_fbdjshared (scenario, chainPartInd)
def	process_fbdjnoshared (scenario, chainPartInd)
def	process_nonsimple (scenario, chainPartInd)
def	make_fastreduction_configurers (chain_dict)
def	make_prefilter_configurers (chain_dict)
def	getLabelIndices (chain_dict)
def	hypotool_from_chaindict (chain_dict, visit_debug=False)

Variables
	logger
	aliasesDict
	cd

Function Documentation

buildHypoHelperConfigTool()

def python.hypoConfigBuilder.buildHypoHelperConfigTool

(

params

)

the parameter object passed in is built in the modules handling
scenarios. It contains the information needed to build the
configuration AlgTool that intialiases a hypo helper AlgTool

Definition at line 88 of file hypoConfigBuilder.py.

def buildHypoHelperConfigTool(params):
    """the parameter object passed in is built in the modules handling
    scenarios. It contains the information needed to build the
    configuration AlgTool that intialiases a hypo helper AlgTool"""
 
    # check that each Condition has a Filter index.
    # the index is -1 for no Condition filtering.
    assert len(params.repcondargs) == len(params.filterparam_inds)
    assert len(params.filterparam_inds) >= len(params.filterparams)
    
    # FastReducer root node
    repcondobjs = [make_root_repcondconfig()]
    for ra in params.repcondargs:
        repcondobjs.append(make_repeatedCondCfgFromParams(ra))
 
 
    # filter for FastReducer root node (use position 0)
    filtConditionMakers = []
    filtConditionMakerInds = [-1] # no condition filtering for root
 
    for ra_ind in params.filterparam_inds:
        if ra_ind != -1:
            ra = params.filterparams[ra_ind]
            filtConditionMakers.append(makeConditionFilterConfigurer(ra))
            filtConditionMakerInds.append(len(filtConditionMakers)-1)
        else:
            filtConditionMakerInds.append(-1)
 
    toolclass, name = toolfactory('HelperToolConfigTool')
                           
    vals = {'name': name,
            'conditionMakers': repcondobjs,
            'filterMakers': filtConditionMakers,
            'filterMakerInds': filtConditionMakerInds,
            'treeVector': params.treevec,
            'leafVector': params.leafvec,
            }
                           
    return toolclass(**vals)
 
 

getLabelIndices()

def python.hypoConfigBuilder.getLabelIndices

(

chain_dict

)

Definition at line 384 of file hypoConfigBuilder.py.

def getLabelIndices(chain_dict):
 
    start_index = 0
    if isLegId(chain_dict['chainName']):
        start_index = getLegIndexInt(chain_dict['chainName'])
 
    end_index = start_index + len(chain_dict['chainParts'])
 
    return start_index, end_index
 
 

hypotool_from_chaindict()

def python.hypoConfigBuilder.hypotool_from_chaindict	(		chain_dict,
			visit_debug = False
	)

Definition at line 395 of file hypoConfigBuilder.py.

def  hypotool_from_chaindict(chain_dict, visit_debug=False):
 
    toolfactory.reset()
 
    if visit_debug:
        fn = chain_dict['chainName'] + '_chaindict.log'
        from pprint import pprint
        with open(fn, 'w') as fh:
            pprint(chain_dict, fh)
        
                        
    helperToolConfigTools =  make_fastreduction_configurers(chain_dict)
 
    prefilterMakers = make_prefilter_configurers(chain_dict)
 
    toolclass, name = toolfactory('helper_tool')
    args = {'name': name,
            'HypoConfigurers': helperToolConfigTools,
            'prefilterMakers': prefilterMakers
            }
    
    helper_tool = toolclass(**args)
 
    toolclass, name =  toolfactory('hypo_tool')
    
    startLabelIndex, endLabelIndex = getLabelIndices(chain_dict)
    
    args = {'name': chain_dict['chainName'],
            # for reporting passing jets:
            'visit_debug': visit_debug,
            'helper_tool': helper_tool,
            'chain_name': chain_dict['chainName'],
            'startLabelIndex': startLabelIndex,
            'endLabelIndex': endLabelIndex,
            }
    
    hypo_tool = toolclass(**args)
    hypo_tool.visit_debug = visit_debug
 
    if (visit_debug):
        hypoToolDisplay(hypo_tool,
                        do_dot=True)
        
    return hypo_tool
 

make_fastreduction_configurers()

def python.hypoConfigBuilder.make_fastreduction_configurers

(

chain_dict

)

Create HelperToolConfigTool  instances. Each instance
configures a FastReduction tree. Chain parts with the 'simple' scenario
are used to form a single HelperToolConfigTool. The information 
may be spread over a number of chain parts. 

There is at most one chain part with a non-simple scenario. 
This may give rise to > 1 HelperToolConfigTool instance - as this
is how jet sharing among Conditions is handled.

If there are both simple and non-simple scenarios, there will be
n HelperToolConfigTool instances, where n >=2: one for the simple 
scenario chain parts, and n-1 for the non-simple scenario.

Definition at line 276 of file hypoConfigBuilder.py.

def make_fastreduction_configurers(chain_dict):
    """Create HelperToolConfigTool  instances. Each instance
    configures a FastReduction tree. Chain parts with the 'simple' scenario
    are used to form a single HelperToolConfigTool. The information 
    may be spread over a number of chain parts. 
 
    There is at most one chain part with a non-simple scenario. 
    This may give rise to > 1 HelperToolConfigTool instance - as this
    is how jet sharing among Conditions is handled.
 
    If there are both simple and non-simple scenarios, there will be
    n HelperToolConfigTool instances, where n >=2: one for the simple 
    scenario chain parts, and n-1 for the non-simple scenario.
    """
    
    chain_parts = chain_dict['chainParts']
 
    simple_chainparts = [
        cp for cp in chain_parts if cp['hypoScenario'] == 'simple']
    simple_cpis = [cp['chainPartIndex'] for cp in simple_chainparts]
    # check that all the simple scenario parts occur before 
    # non-simple scenario chain parts
 
    if simple_cpis:
        assert simple_cpis == sorted(simple_cpis), "disordered chain parts" 
        assert simple_cpis[-1] - simple_cpis[0] == len(simple_cpis) - 1, "nonsequential chainParts"
    helperToolConfigTools = []
 
    # check for SHARED markers (chainPart['tboundary'] = 'SHARED')
    # in the list of simple chain parts.
    # Get a tree configuration each time SHARED == 1 is encountered.
    if simple_chainparts:
 
        assert simple_chainparts[-1]['tboundary'] == ''
 
        tree_cps = []
        for cp in simple_chainparts:
            tree_cps.append(cp)
            if cp['tboundary'] == 'SHARED':
                helperToolConfigTools.extend(process_simple(tree_cps))
                tree_cps = []
 
        # tree_cps  cannot be empty here
        assert tree_cps
        helperToolConfigTools.extend(process_simple(tree_cps))
 
    scenario_chainparts =[
        cp for cp in chain_parts if cp['hypoScenario'] != 'simple']
           
    if scenario_chainparts:
        for scenario_chainpart in scenario_chainparts:
            # scenario_chainpart = scenario_chainparts[0]
            
            # We only allow threshold != 0 for the simple scenario.
            assert scenario_chainpart['threshold'] == '0'
        
            scenario = scenario_chainpart['hypoScenario']
            # find the chain part index for a non-simple scenario.
            # assume simple is processed before non-simple, and that
            # there is at most one non-simple chainpart.
            # chainPartInd is needed to report passing jets to the
            # trigger framework.
            chainPartInd = scenario_chainpart['chainPartIndex']
            
            helperToolConfigTools.extend(process_nonsimple(scenario,
                                                           chainPartInd))
        
    return helperToolConfigTools
 
 

make_prefilter_configurers()

def python.hypoConfigBuilder.make_prefilter_configurers

(

chain_dict

)

Set up the prefilters fo the chain.

Definition at line 346 of file hypoConfigBuilder.py.

def make_prefilter_configurers(chain_dict):
    """Set up the prefilters fo the chain."""
    
    pf_strings = []
    chain_parts = [cp for cp in chain_dict['chainParts'] if
                   cp['signature'] == 'Jet' and 'prefilters' in cp]
 
    [pf_strings.extend(cp['prefilters']) for cp in chain_parts]
    
    # if not pre filter strings (pf_strings) are found in the chainDict,
    # a PassThroughFilter configurer is made.
 
    if not pf_strings:
        return []
 
    # route the prefilter strings to the appropriate handler
    prefilter_router = {
        'MASK': prefilter_mask,
        'PTRANGE': prefilter_ptrange,
        'MAXMULT': prefilter_maxmult,
        'CLEAN': prefilter_clean,
    }
 
    pattern = r'(?P<stub>[A-Z]*)'
    rgx     = re.compile(pattern)
 
    filters = []
    for pf_string in pf_strings:
        # get prefilter stub and make sure is correct
        m = rgx.match(pf_string)
        assert m is not None,'No prefilter stub was found'
        groupdict = m.groupdict()
        assert groupdict['stub'] in prefilter_router,'prefilter stub ({}) not recognized'.format(groupdict['stub'])
        filters.append(prefilter_router[groupdict['stub']](pf_string))
        
    return filters
 
 

make_root_repcondconfig()

def python.hypoConfigBuilder.make_root_repcondconfig

(

)

make a repeated condition configurer for the fast reduction
root node. This will will have a single accapt all internal node.

Definition at line 73 of file hypoConfigBuilder.py.

def make_root_repcondconfig():
    """make a repeated condition configurer for the fast reduction
    root node. This will will have a single accapt all internal node."""
    
    toolclass, name =  toolfactory('all')
    args = {'name':  name}
    conditionMakers = [toolclass(**args)]
 
    configurer = make_repeatedCond(tree_id=0,
                                   tree_pid=0,
                                   clique=-1,
                                   conditionMakers=conditionMakers)
    
    return configurer
 

process_dijet()

def python.hypoConfigBuilder.process_dijet	(		scenario,
			chainPartInd
	)

Obtain the paramters needed to build an AlgTool
to initialise a jet hypo HelperAlgTool

Definition at line 202 of file hypoConfigBuilder.py.

def process_dijet(scenario, chainPartInd):
    """Obtain the paramters needed to build an AlgTool
    to initialise a jet hypo HelperAlgTool"""
 
    # obtain a list of parameter objects that will be used
    # to build a helper config AlgTools
    helper_params = scenario_dijet(scenario, chainPartInd)
 
    # build the helper config AlgTools
    helperconfigobjs = [buildHypoHelperConfigTool(params) for params in
                        helper_params]
                           
    return helperconfigobjs
 
 

process_dipz()

def python.hypoConfigBuilder.process_dipz	(		scenario,
			chainPartInd
	)

Obtain the paramters needed to build an AlgTool
to initialise a jet hypo HelperAlgTool

Definition at line 144 of file hypoConfigBuilder.py.

def process_dipz(scenario, chainPartInd):
    """Obtain the paramters needed to build an AlgTool
    to initialise a jet hypo HelperAlgTool"""
 
    # obtain a list of parameter objects that will be used
    # to build a helper config AlgTools
    helper_params = scenario_dipz(scenario, chainPartInd)
 
    # build the helper config AlgTools
    helperconfigobjs = [buildHypoHelperConfigTool(params) for params in
                        helper_params]
                           
    return helperconfigobjs
 

process_fbdjnoshared()

def python.hypoConfigBuilder.process_fbdjnoshared	(		scenario,
			chainPartInd
	)

Obtain the paramters needed to build an AlgTool
to initialise a jet hypo HelperAlgTool

Definition at line 232 of file hypoConfigBuilder.py.

def process_fbdjnoshared(scenario, chainPartInd):
    """Obtain the paramters needed to build an AlgTool
    to initialise a jet hypo HelperAlgTool"""
 
    # obtain a list of parameter objects that will be used
    # to build a helper config AlgTools
    helper_params = scenario_fbdjnoshared(scenario, chainPartInd)
 
    # build the helper config AlgTools
    helperconfigobjs = [buildHypoHelperConfigTool(params) for params in
                        helper_params]
                           
    return helperconfigobjs
 
 

process_fbdjshared()

def python.hypoConfigBuilder.process_fbdjshared	(		scenario,
			chainPartInd
	)

Obtain the paramters needed to build an AlgTool
to initialise a jet hypo HelperAlgTool

Definition at line 217 of file hypoConfigBuilder.py.

def process_fbdjshared(scenario, chainPartInd):
    """Obtain the paramters needed to build an AlgTool
    to initialise a jet hypo HelperAlgTool"""
 
    # obtain a list of parameter objects that will be used
    # to build a helper config AlgTools
    helper_params = scenario_fbdjshared(scenario, chainPartInd)
 
    # build the helper config AlgTools
    helperconfigobjs = [buildHypoHelperConfigTool(params) for params in
                        helper_params]
                           
    return helperconfigobjs
 
 

process_ht()

def python.hypoConfigBuilder.process_ht	(		scenario,
			chainPartInd
	)

Obtain the paramters needed to build an AlgTool
to initialise a jet hypo HelperAlgTool

Definition at line 158 of file hypoConfigBuilder.py.

def process_ht(scenario, chainPartInd):
    """Obtain the paramters needed to build an AlgTool
    to initialise a jet hypo HelperAlgTool"""
 
    # obtain a list of parameter objects that will be used
    # to build a helper config AlgTools
    helper_params = scenario_ht(scenario, chainPartInd)
 
    # build the helper config AlgTools
    helperconfigobjs = [buildHypoHelperConfigTool(params) for params in
                        helper_params]
                           
    return helperconfigobjs
 

process_htdipz()

def python.hypoConfigBuilder.process_htdipz	(		scenario,
			chainPartInd
	)

Obtain the paramters needed to build an AlgTool
to initialise a jet hypo HelperAlgTool

Definition at line 172 of file hypoConfigBuilder.py.

def process_htdipz(scenario, chainPartInd):
    """Obtain the paramters needed to build an AlgTool
    to initialise a jet hypo HelperAlgTool"""
 
    # obtain a list of parameter objects that will be used
    # to build a helper config AlgTools
    helper_params = scenario_htdipz(scenario, chainPartInd)
 
    # build the helper config AlgTools
    helperconfigobjs = [buildHypoHelperConfigTool(params) for params in
                        helper_params]
                           
    return helperconfigobjs
 
 

process_mult()

def python.hypoConfigBuilder.process_mult	(		scenario,
			chainPartInd
	)

Obtain the paramters needed to build an AlgTool
to initialise a jet hypo HelperAlgTool

Definition at line 187 of file hypoConfigBuilder.py.

def process_mult(scenario, chainPartInd):
    """Obtain the paramters needed to build an AlgTool
    to initialise a jet hypo HelperAlgTool"""
 
    # obtain a list of parameter objects that will be used
    # to build a helper config AlgTools
    helper_params = scenario_mult(scenario, chainPartInd)
 
    # build the helper config AlgTools
    helperconfigobjs = [buildHypoHelperConfigTool(params) for params in
                        helper_params]
                           
    return helperconfigobjs
 
 

process_nonsimple()

def python.hypoConfigBuilder.process_nonsimple	(		scenario,
			chainPartInd
	)

Maker a list of helper tool config tool for a non-simple scenario.
Note:  a non-simple scenario will  produce more than HelperToolConfigTool
if jet sharing among Conditions is required.

Definition at line 247 of file hypoConfigBuilder.py.

def process_nonsimple(scenario, chainPartInd):
    """Maker a list of helper tool config tool for a non-simple scenario.
    Note:  a non-simple scenario will  produce more than HelperToolConfigTool
    if jet sharing among Conditions is required."""
    
    # interpret scenario aliases
    if scenario in aliasesDict.keys(): scenario = aliasesDict[scenario]
 
    router = {
        'Z': process_dipz,
        'HTZ': process_htdipz,
        'HT': process_ht,
        'MULT': process_mult,
        'DIJET': process_dijet,
        'FBDJSHARED': process_fbdjshared,
        'FBDJNOSHARED': process_fbdjnoshared,
    }
 
    # get scenario stub and make sure is correct
    pattern = r'^(?P<stub>[A-Z]+)'
    rgx     = re.compile(pattern)
    m       = rgx.match(scenario)
    assert m is not None,'No scenario stub was found'
    groupdict = m.groupdict()
    assert groupdict['stub'] in router,'scenario stub ({}) not recognized'.format(groupdict['stub'])
 
    return router[groupdict['stub']](scenario, chainPartInd)  # list of HelperToolConfigTool
 
 

process_simple()

def python.hypoConfigBuilder.process_simple

(

chain_parts

)

Obtain the paramters needed to build an AlgTool
to initialise a jet hypo HelperAlgTool

Definition at line 129 of file hypoConfigBuilder.py.

def process_simple(chain_parts):
    """Obtain the paramters needed to build an AlgTool
    to initialise a jet hypo HelperAlgTool"""
 
    # obtain a list of parameter objects that will be used
    # to build a helper config AlgTools
    helper_params = scenario_simple(chain_parts)
 
    # build the helper config AlgTools
    helperconfigobjs = [buildHypoHelperConfigTool(params) for params in
                        helper_params]
    
    return helperconfigobjs
 
 

Variable Documentation

aliasesDict

python.hypoConfigBuilder.aliasesDict

Definition at line 45 of file hypoConfigBuilder.py.

cd

python.hypoConfigBuilder.cd

Definition at line 441 of file hypoConfigBuilder.py.

logger

python.hypoConfigBuilder.logger

Definition at line 41 of file hypoConfigBuilder.py.