MenuComponents.ChainStep Class Reference

Inheritance diagram for MenuComponents.ChainStep:

Collaboration diagram for MenuComponents.ChainStep:

Public Types
typedef HLT::TypeInformation::for_each_type_c< typenameEDMLIST::map, my_functor, my_result<>, my_arg< HLT::TypeInformation::get_cont, CONTAINER > >::type	result

Public Member Functions
	__init__ (self, name, SequenceGens=None, chainDicts=None, comboHypoCfg=None, comboToolConfs=None, isEmpty=False, createsGhostLegs=False)
	createSequences (self)
	setChainPartIndices (self)
	addComboHypoTools (self, tool)
	getComboHypoFncName (self)
	makeCombo (self)
	createComboHypoTools (self, flags, chainName)
	getChainLegs (self)
	getChainNames (self)
	__repr__ (self)

Public Attributes
	name = name
list	sequences = []
	sequenceGens = SequenceGens
	comboHypoCfg = comboHypoCfg
	comboToolConfs = list(comboToolConfs)
	stepDicts = chainDicts
	nLegs = len(self.stepDicts)
	isEmpty = isEmpty
bool	onlyJets = False
	combo = None

Detailed Description

 Class to describe one step of a chain; 
a step is described by a list of ChainDicts and a list of sequence generators;
there is one leg per ChainDict;
a step can have one leg (single) or more legs (combined);
not-empty steps have one sequence per leg;
empty steps have zero sequences, while chainDict len is not zero; 
legID is taken from the ChainDict;

Definition at line 590 of file MenuComponents.py.

Member Typedef Documentation

result

typedef HLT::TypeInformation::for_each_type_c<typenameEDMLIST::map,my_functor,my_result<>,my_arg<HLT::TypeInformation::get_cont,CONTAINER>>::type master_search< typenameEDMLIST::map, HLT::TypeInformation::get_cont, CONTAINER >::result

inherited

Definition at line 90 of file EDM_MasterSearch.h.

Constructor & Destructor Documentation

__init__()

MenuComponents.ChainStep.__init__	(		self,
			name,
			SequenceGens = None,
			chainDicts = None,
			comboHypoCfg = None,
			comboToolConfs = None,
			isEmpty = False,
			createsGhostLegs = False )

Definition at line 600 of file MenuComponents.py.

    def __init__(self, name,  SequenceGens = None, chainDicts = None, comboHypoCfg = None, comboToolConfs = None, isEmpty = False, createsGhostLegs = False):
 
        # default mutable values must be initialized to None
        if SequenceGens is None:  SequenceGens = []
        if comboHypoCfg is None: comboHypoCfg = functools.partial(ComboHypoCfg)
        if comboToolConfs is None: comboToolConfs = []
        assert chainDicts is not None,"Error building a ChainStep without chainDicts"
 
        self.name = name
        self.sequences = []
        self.sequenceGens = SequenceGens 
        if not isinstance(comboHypoCfg, functools.partial):             
            raise RuntimeError("[ChainStep] Tried to configure a ChainStep %s with ComboHypo %s that is not a function" % (name, comboHypoCfg) ) 
        
        self.comboHypoCfg = comboHypoCfg
        self.comboToolConfs = list(comboToolConfs)       
        self.stepDicts = chainDicts # one dict per leg        
        self.nLegs = len(self.stepDicts) # cannot be zero
        self.isEmpty = isEmpty                
        
        # sanity check on inputs, excluding empty steps 
        if not self.isEmpty:                     
            log.debug("Building step %s for chain %s: n.sequences=%d, nLegs=%i", name, chainDicts[0]['chainName'], len (self.sequenceGens) , self.nLegs )             
            if len (self.sequenceGens)  != self.nLegs: 
                log.error("[ChainStep] SequenceGens: %s",self.sequenceGens)
                log.error("[ChainStep] stepDicts: %s",self.stepDicts)
                log.error("[ChainStep] n.legs: %i",self.nLegs)
                raise RuntimeError("[ChainStep] Tried to configure a ChainStep %s with %i legs and %i sequences. These lists must have the same size" % (name, self.nLegs, len (self.sequenceGens) ) )
                        
           
        for iseq, seq in enumerate(self.sequenceGens):              
            if not isinstance(seq, functools.partial):
                log.error("[ChainStep] %s SequenceGens verification failed, sequence %d is not partial function, likely ChainBase.getStep function was not used", self.name, iseq)
                log.error("[ChainStep] It rather seems to be of type %s trying to print it", type(seq))
                raise RuntimeError("Sequence is not packaged in a tuple, see error message above" ) 
                                                 
        self.onlyJets  = False
        sig_set = None
        if 'signature' in chainDicts[0]:             
            sig_set = set([step['signature'] for step in chainDicts])
            if len(sig_set) == 1 and ('Jet' in sig_set or 'Bjet' in sig_set):
                self.onlyJets = True
            if len(sig_set) == 2 and ('Jet' in sig_set and 'Bjet' in sig_set):
                self.onlyJets = True
 
        
        
        if not self.isEmpty:
            self.setChainPartIndices()
        self.makeCombo()
 

Member Function Documentation

__repr__()

MenuComponents.ChainStep.__repr__

(

self

)

Definition at line 721 of file MenuComponents.py.

    def __repr__(self):
        if len(self.sequenceGens) == 0:        
            return "\n--- ChainStep %s ---\n is Empty, ChainDict = %s "%(self.name,  ' '.join(map(str, [dic['chainName'] for dic in self.stepDicts])) )
        
        repr_string= "\n--- ChainStep %s ---\n , nLegs = %s  ChainDict = %s \n + MenuSequenceGens = %s "%\
          (self.name,  self.nLegs, 
             ' '.join(map(str, [dic['chainName'] for dic in self.stepDicts])),
             ' '.join(map(str, [seq.func.__name__ for seq in self.sequenceGens]) ))
             
        if self.combo is not None:
            repr_string += "\n + ComboHypo = %s" % self.combo.Alg.name
            if len(self.comboToolConfs)>0:
                repr_string +=",  ComboHypoTools = %s" %(' '.join(map(str, [tool.__name__ for tool in self.comboToolConfs]))) 
        repr_string += "\n"       
        return repr_string
 
 

addComboHypoTools()

MenuComponents.ChainStep.addComboHypoTools	(		self,
			tool )

Definition at line 676 of file MenuComponents.py.

    def addComboHypoTools(self, tool):
        #this function does not add tools, it just adds one tool. do not pass it a list!
        self.comboToolConfs.append(tool)
 

createComboHypoTools()

MenuComponents.ChainStep.createComboHypoTools	(		self,
			flags,
			chainName )

Definition at line 707 of file MenuComponents.py.

    def createComboHypoTools(self, flags, chainName):
        chainDict = HLTMenuConfig.getChainDictFromChainName(chainName)
        self.combo.createComboHypoTools(flags, chainDict, self.comboToolConfs)
            

createSequences()

MenuComponents.ChainStep.createSequences

(

self

)

creation of this step sequences with instantiation of the CAs

Definition at line 651 of file MenuComponents.py.

    def createSequences(self):
        """ creation of this step sequences with instantiation of the CAs"""        
        log.debug("createSequences: creating %d sequences for step %s", len(self.sequenceGens), self.name)
        for seq in self.sequenceGens:
            log.debug("createSequences: creating sequence %s", seq.func.__name__)
            self.sequences.append(seq()) # create the sequences         
            
    

getChainLegs()

MenuComponents.ChainStep.getChainLegs

(

self

)

This is extrapolating the chain legs from the step dictionaries

Definition at line 711 of file MenuComponents.py.

    def getChainLegs(self):
        """ This is extrapolating the chain legs from the step dictionaries"""       
        legs = [part['chainName'] for part in self.stepDicts]
        return legs
 

getChainNames()

MenuComponents.ChainStep.getChainNames

(

self

)

Definition at line 716 of file MenuComponents.py.

    def getChainNames(self):  
        if self.combo is not None:   
            return list(self.combo.getChains())
        return self.getChainLegs()
 

getComboHypoFncName()

MenuComponents.ChainStep.getComboHypoFncName

(

self

)

Definition at line 680 of file MenuComponents.py.

    def getComboHypoFncName(self):
        return self.comboHypoCfg.func.__name__ 
 
 
 

makeCombo()

MenuComponents.ChainStep.makeCombo

(

self

)

Configure the Combo Hypo Alg and generate the corresponding function, without instantiation which is done in createSequences() 

Definition at line 685 of file MenuComponents.py.

    def makeCombo(self):
        """ Configure the Combo Hypo Alg and generate the corresponding function, without instantiation which is done in createSequences() """ 
        self.combo = None
        if self.isEmpty:
            return        
        comboNameFromStep = CFNaming.comboHypoName(self.name) # name expected from the step name
        funcName = self.getComboHypoFncName() # name of the function generator
        key = hash((comboNameFromStep, funcName))
        if key not in _ComboHypoPool:            
            tmpCombo = ComboHypoNode(comboNameFromStep, self.comboHypoCfg) 
            CHname = tmpCombo.name[:-4]   # remove 'Node'
            # exceptions for BLS chains that re-use the same custom CH in differnt steps
            # this breaks the run-one-CH-per-step, but the BLS CH are able to handle decisions internally
            if comboNameFromStep != CHname:
                log.debug("Created ComboHypo with name %s, expected from the step is instead %s. This is accepted only for allowed custom ComboHypos", CHname, comboNameFromStep)
                _CustomComboHypoAllowed.add(CHname)
                key = hash((CHname, funcName))
            _ComboHypoPool[key] = tmpCombo
        self.combo = _ComboHypoPool[key] 
        log.debug("Created combo %s with name %s, step comboName %s, key %s", funcName, self.combo.name, comboNameFromStep,key)
 
 

setChainPartIndices()

MenuComponents.ChainStep.setChainPartIndices

(

self

)

Definition at line 660 of file MenuComponents.py.

    def setChainPartIndices(self):    
        leg_counter = 0
        lists_of_chainPartNames = []
        for step_dict in self.stepDicts:
            if len(lists_of_chainPartNames) == 0:
                lists_of_chainPartNames += [[cp['chainPartName'] for cp in step_dict['chainParts']]]
            else:
                new_list_of_chainPartNames = [cp['chainPartName'] for cp in step_dict['chainParts']]
                if new_list_of_chainPartNames == lists_of_chainPartNames[-1]:
                    leg_counter -= len(new_list_of_chainPartNames)
            for chainPart in step_dict['chainParts']:
                chainPart['chainPartIndex'] =  leg_counter
                leg_counter += 1
        return
 
 

Member Data Documentation

combo

MenuComponents.ChainStep.combo = None

Definition at line 687 of file MenuComponents.py.

comboHypoCfg

MenuComponents.ChainStep.comboHypoCfg = comboHypoCfg

Definition at line 614 of file MenuComponents.py.

comboToolConfs

MenuComponents.ChainStep.comboToolConfs = list(comboToolConfs)

Definition at line 615 of file MenuComponents.py.

isEmpty

MenuComponents.ChainStep.isEmpty = isEmpty

Definition at line 618 of file MenuComponents.py.

name

MenuComponents.ChainStep.name = name

Definition at line 608 of file MenuComponents.py.

nLegs

MenuComponents.ChainStep.nLegs = len(self.stepDicts)

Definition at line 617 of file MenuComponents.py.

onlyJets

bool MenuComponents.ChainStep.onlyJets = False

Definition at line 636 of file MenuComponents.py.

sequenceGens

MenuComponents.ChainStep.sequenceGens = SequenceGens

Definition at line 610 of file MenuComponents.py.

sequences

list MenuComponents.ChainStep.sequences = []

Definition at line 609 of file MenuComponents.py.

stepDicts

MenuComponents.ChainStep.stepDicts = chainDicts

Definition at line 616 of file MenuComponents.py.

---

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

• MenuComponents.py