python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction Class Reference

Inheritance diagram for python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction:

Collaboration diagram for python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction:

Public Member Functions
def	__init__ (self, algToolFactory)
def	report (self)
def	mod (self, tree)

Public Attributes
	algToolFactory
	treeMap
	conditionMakers
	conditionMakersVec
	config_tool

Private Member Functions
def	_set_conditions (self, node)
def	_make_el_condition_tools (self, conf_dict)
def	_make_filter_condition_tool (self, node)
def	_make_compound_condition_tools (self, node)
def	_mod_leaf (self, node)
def	_fill_tree_map (self, node, tmap)
def	_fill_conditions_map (self, node, cmap, fmap)
def	_map_2_vec (self, amap)
def	_check_scenarios (self, node)

Detailed Description

Visitor to set instantiated AlgTools to a jet hypo tree

Definition at line 20 of file ConditionsToolSetterFastReduction.py.

Constructor & Destructor Documentation

__init__()

def python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction.__init__	(		self,
			algToolFactory
	)

Definition at line 25 of file ConditionsToolSetterFastReduction.py.

    def __init__(self, algToolFactory):
 
        self.algToolFactory = algToolFactory
 
        # map conaining parent child ids for the node
        self.treeMap = {0: 0}
 
        # map containing the a list of Condition factory AlgTools for scenario
        self.conditionMakers = defaultdict(list)
 

Member Function Documentation

_check_scenarios()

def python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction._check_scenarios (   self,   node  )

private

Definition at line 220 of file ConditionsToolSetterFastReduction.py.

    def _check_scenarios(self, node):
        if not(is_inner(node) or is_leaf(node)):
            raise RuntimeError(
                'ConditionsToolSetter: illegal scenario: %s' % node.scenario)
 
        for cn in node.children:
            self._check_scenarios(cn)
 

_fill_conditions_map()

def python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction._fill_conditions_map (   self,   node,   cmap,   fmap  )

private

Definition at line 190 of file ConditionsToolSetterFastReduction.py.

    def _fill_conditions_map(self, node, cmap, fmap):
        if is_leaf(node):
 
            assert (len(node.compound_condition_tools) == 1)
            cmap[node.node_id] = node.compound_condition_tools[0]
 
            fmap[node.node_id] = node.filter_condition_tool
 
        else:
 
            cmap[node.node_id] = self.algToolFactory('repeated')
            cmap[node.node_id].conditionMakers = [self.algToolFactory('all')]
            cmap[node.node_id].multiplicity = 1
 
            fmap[node.node_id] = self.algToolFactory('repeated')
            fmap[node.node_id].conditionMakers = []
            fmap[node.node_id].multiplicity = 1
 
        
        for cn in node.children:
            self._fill_conditions_map(cn, cmap, fmap)
 
 

_fill_tree_map()

def python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction._fill_tree_map (   self,   node,   tmap  )

private

Definition at line 184 of file ConditionsToolSetterFastReduction.py.

    def _fill_tree_map(self, node, tmap):
        tmap[node.node_id] = node.parent_id
        for cn in node.children:
            self._fill_tree_map(cn, tmap)
 
            

_make_compound_condition_tools()

def python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction._make_compound_condition_tools (   self,   node  )

private

For each element of  node.conf_attrs, construct a 
ConditionContainer. Example for chain HLT_2j80_3j60_L1J15:

First leaf node has 
conf_attrs [1]:
(defaultdict(<class 'dict'>, {
'et': {'min': '80000.0', 'max': 'inf'}, 
'eta': {'min': '0.0', 'max': '3.2'}}), 2)

Second leaf node has 
conf_attrs [1]:
(defaultdict(<class 'dict'>, {'et': {'min': '60000.0', 'max': 'inf'}, 
'eta': {'min': '0.0', 'max': '3.2'}}), 3)

Definition at line 107 of file ConditionsToolSetterFastReduction.py.

    def _make_compound_condition_tools(self, node):
        """For each element of  node.conf_attrs, construct a 
        ConditionContainer. Example for chain HLT_2j80_3j60_L1J15:
 
        First leaf node has 
        conf_attrs [1]:
        (defaultdict(<class 'dict'>, {
        'et': {'min': '80000.0', 'max': 'inf'}, 
        'eta': {'min': '0.0', 'max': '3.2'}}), 2)
 
        Second leaf node has 
        conf_attrs [1]:
        (defaultdict(<class 'dict'>, {'et': {'min': '60000.0', 'max': 'inf'}, 
        'eta': {'min': '0.0', 'max': '3.2'}}), 3)
        """
 
        #  compound_condition_tools:
        # elemental condition maker AlgToolshelper by the compound condition
        # AlgTool
        outer_condition_tools = []
 
        # loop  over elements of node.conf_attrs. The elements are (dict, int)
        # int is multiplicity, dict holds Condition parameters.
 
        assert len(node.conf_attrs) == 1
        mult = node.multiplicity
        for i in range(len(node.conf_attrs)):
            c = node.conf_attrs[i]
            cpi = ''
 
            if node.chainpartinds:
                cpi = node.chainpartinds[i]
 
            el_condition_tools = self._make_el_condition_tools(c)
 
            # create condition from elemental conditions
            condition_tool =self.algToolFactory('repeated')
 
            if cpi:
 
                # convert label from string to int for more efficient
                # processing in C++ land.
                condition_tool.chainPartInd = int(cpi[len('leg'):])
            
            condition_tool.conditionMakers = el_condition_tools
            condition_tool.multiplicity = mult
            # add condition container to list
            outer_condition_tools.append(condition_tool)
            
        return outer_condition_tools
 
    

_make_el_condition_tools()

def python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction._make_el_condition_tools (   self,   conf_dict  )

private

conf_dict: a dict containing names of elemental conditions 
and min, max valies. These will be used to instantiate
conditon building AlgTools, one for eac conditon 

for 2j80_2j60, the dictionaries are:
{'et': {'min': '80000.0', 'max': 'inf'}, 
'eta': {'min': '0.0', 'max': '3.2'}}

and 


{'et': {'min': '60000.0', 'max': 'inf'}, 
'eta': {'min': '0.0', 'max': '3.2'}})

Definition at line 44 of file ConditionsToolSetterFastReduction.py.

    def _make_el_condition_tools(self, conf_dict):
        """conf_dict: a dict containing names of elemental conditions 
        and min, max valies. These will be used to instantiate
        conditon building AlgTools, one for eac conditon 
 
        for 2j80_2j60, the dictionaries are:
        {'et': {'min': '80000.0', 'max': 'inf'}, 
        'eta': {'min': '0.0', 'max': '3.2'}}
 
        and 
 
 
        {'et': {'min': '60000.0', 'max': 'inf'}, 
        'eta': {'min': '0.0', 'max': '3.2'}})
        
        """
 
        condition_tools = [] # a list of AlgTools that build elemental Conds.
        
        for k, v in conf_dict.items(): # loop over elemental conditions
            # k in the condition name, v contains its min, max values.
 
            # create the AlgTool that will build the elemental condition
            condition_tool = self.algToolFactory(k) 
            for lim, val in v.items():  # lim: min, max
                setattr(condition_tool, lim, val)
 
            # SPECIAL CASE: Moment tool needs the name of the
            # moment as well as the min. max cuts:
            if (k.startswith ('mom')):
                moment = k[len('mom'):]
                if moment in self.JetMoments:
                    condition_tool.moment = self.JetMoments[moment]
                else: raise RuntimeError('%s not supported' % (moment))
 
            # END SPECIAL CASE
 
            condition_tools.append(condition_tool)
 
        return condition_tools
 
 

_make_filter_condition_tool()

def python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction._make_filter_condition_tool (   self,   node  )

private

Condition filters use a list of CompoundCondition containing
single jet elemental conditions  select a subset of the reco
jets to send to the a Condition

Definition at line 86 of file ConditionsToolSetterFastReduction.py.

    def _make_filter_condition_tool(self, node):
 
        """Condition filters use a list of CompoundCondition containing
        single jet elemental conditions  select a subset of the reco
        jets to send to the a Condition"""
        
        el_condition_tools = []
 
        for fc in node.filter_dicts:
            
            assert len(fc) == 1  # 1 elemental condition
            el_condition_tools.extend(self._make_el_condition_tools(fc))
 
        condition_tool = self.algToolFactory('repeated')
 
        condition_tool.conditionMakers = el_condition_tools
        condition_tool.multiplicity = 1
        
        return condition_tool
 
    

_map_2_vec()

def python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction._map_2_vec (   self,   amap  )

private

Definition at line 213 of file ConditionsToolSetterFastReduction.py.

    def _map_2_vec(self, amap):
 
        vec = [0 for i in range(len(amap))]
        for nid, value in amap.items():
            vec[nid] = value
        return vec
 

_mod_leaf()

def python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction._mod_leaf (   self,   node  )

private

Add Condition tools to For a leaf node.

Definition at line 159 of file ConditionsToolSetterFastReduction.py.

    def _mod_leaf(self, node):
        """ Add Condition tools to For a leaf node."""
 
        if not is_leaf(node):
            return
 
        # parameters: (10et,0eta320)(20et)
        # conf_attrs: [2]: (is a list of length 2)
        # defaultdict(<type 'dict'>, {'et': {'max': 'inf', 'min': '10000.0'},
        #                             'eta': {'max': '3.2', 'min': '0.0'}})
        # defaultdict(<type 'dict'>, {'et': {'max': 'inf', 'min': '20000.0'}})
 
 
        # make a config tool and provide it with condition makers
 
 
        node.compound_condition_tools = self._make_compound_condition_tools(
            node)
 
        node.filter_condition_tool = self._make_filter_condition_tool(
            node)
            

_set_conditions()

def python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction._set_conditions (   self,   node  )

private

attach Conditions to leaf nodes

Definition at line 35 of file ConditionsToolSetterFastReduction.py.

    def _set_conditions(self, node):
        """attach Conditions to leaf nodes"""
 
        self._mod_leaf(node)
        
        for cn in node.children:
            self._set_conditions(cn)
 
 

mod()

def python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction.mod	(		self,
			tree
	)

Entry point for this module. 
Modifies a  (usually compound) hypo tree node to 
reduce it to form from whuch the treevector, and conditionsVector
These will be used to initialise FastReductionMatcher.

In particular: all leaf nodes will have a single ConmpoundCondition
All other nodes will be assigned an AcceptAll condition.

Definition at line 228 of file ConditionsToolSetterFastReduction.py.

    def mod(self, tree):
        """Entry point for this module. 
        Modifies a  (usually compound) hypo tree node to 
        reduce it to form from whuch the treevector, and conditionsVector
        These will be used to initialise FastReductionMatcher.
 
        In particular: all leaf nodes will have a single ConmpoundCondition
        All other nodes will be assigned an AcceptAll condition.
        """
 
        # navigate the tree filling in node-parent and node- Condtion factory
        # relations
 
        self._check_scenarios(tree)
        
        # add Condition builders to leaf nodes.
        self._set_conditions(tree)
  
 
        tree_map = {}  # tree of node indices
        self._fill_tree_map(tree, tree_map)
 
        treeVec = self._map_2_vec(tree_map)
 
        conditionsMap = {}
        filterConditionsMap = {}
 
        self._fill_conditions_map(tree, conditionsMap, filterConditionsMap)
 
        # conditionVec is an attribute as it will be used directly
        # to make prefilter tools, so hold onto it here
        self.conditionMakersVec = self._map_2_vec(conditionsMap)
        filterConditionsVec = self._map_2_vec(filterConditionsMap)
               
        # make a config tool and provide it with condition makers
        config_tool = self.algToolFactory('fastreduction')
 
 
        config_tool.conditionMakers = self.conditionMakersVec
        config_tool.filtConditionsMakers = filterConditionsVec
        config_tool.treeVector = treeVec
        self.config_tool = config_tool
        

report()

def python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction.report

(

self

)

Definition at line 181 of file ConditionsToolSetterFastReduction.py.

    def report(self):
        return str(self.algToolFactory)
   

Member Data Documentation

algToolFactory

python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction.algToolFactory

Definition at line 27 of file ConditionsToolSetterFastReduction.py.

conditionMakers

python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction.conditionMakers

Definition at line 33 of file ConditionsToolSetterFastReduction.py.

conditionMakersVec

python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction.conditionMakersVec

Definition at line 259 of file ConditionsToolSetterFastReduction.py.

config_tool

python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction.config_tool

Definition at line 269 of file ConditionsToolSetterFastReduction.py.

treeMap

python.ConditionsToolSetterFastReduction.ConditionsToolSetterFastReduction.treeMap

Definition at line 30 of file ConditionsToolSetterFastReduction.py.

---

The documentation for this class was generated from the following file:

• ConditionsToolSetterFastReduction.py