MenuComponents.ChainStep Class Reference

Inheritance diagram for MenuComponents.ChainStep:

Collaboration diagram for MenuComponents.ChainStep:

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

Public Attributes
	name
	sequences
	sequenceGens
	comboHypoCfg
	comboToolConfs
	nLegs
	stepDicts
	isEmpty
	onlyJets
	legIds
	combo

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;
a step can have one leg (single) or more legs (combined);
not-empty steps have one sequence and one ChainDict per leg;
empty steps have zero legs, while chainDict len is not zero; 
legID is taken from the ChainDict;

Definition at line 591 of file MenuComponents.py.

Constructor & Destructor Documentation

__init__()

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

Definition at line 600 of file MenuComponents.py.

    def __init__(self, name,  SequenceGens = None, chainDicts = None, comboHypoCfg = ComboHypoCfg , comboToolConfs = None, isEmpty = False, createsGhostLegs = False):
 
        # default mutable values must be initialized to None
        if SequenceGens is None:  SequenceGens = []
        if comboToolConfs is None: comboToolConfs = []
 
        assert chainDicts is not None,"Error building a ChainStep without chainDicts"
 
        self.name = name
        self.sequences = []
        self.sequenceGens = SequenceGens 
        self.comboHypoCfg = comboHypoCfg
        self.comboToolConfs = list(comboToolConfs)
        self.nLegs = len (self.sequenceGens) 
        self.stepDicts = chainDicts # one dict per leg        
        self.isEmpty = isEmpty                
        
        # sanity check on inputs, excluding empty steps 
        if not self.isEmpty:                     
            log.debug("Building step %s for chain %s: Dict len=%d, nLegs=%i", name, chainDicts[0]['chainName'], len(chainDicts), self.nLegs )             
            if len(chainDicts) != self.nLegs: 
                log.error("[ChainStep] SequenceGens: %s",self.sequenceGens)
                log.error("[ChainStep] chainDicts: %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 dictionaries. These lists must have the same size" % (name, self.nLegs, len(chainDicts)) )
                        
           
        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 len(chainDicts) > 0  and '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.legIds = self.getLegIds() 
        self.makeCombo()
 

Member Function Documentation

__repr__()

def MenuComponents.ChainStep.__repr__

(

self

)

Definition at line 732 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()

def MenuComponents.ChainStep.addComboHypoTools	(		self,
			tool
	)

Definition at line 688 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()

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

Definition at line 718 of file MenuComponents.py.

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

createSequences()

def MenuComponents.ChainStep.createSequences

(

self

)

creation of this step sequences with instantiation of the CAs

Definition at line 649 of file MenuComponents.py.

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

getChainLegs()

def MenuComponents.ChainStep.getChainLegs

(

self

)

This is extrapolating the chain legs from the step dictionaries

Definition at line 722 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()

def MenuComponents.ChainStep.getChainNames

(

self

)

Definition at line 727 of file MenuComponents.py.

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

getComboHypoFncName()

def MenuComponents.ChainStep.getComboHypoFncName

(

self

)

Definition at line 692 of file MenuComponents.py.

    def getComboHypoFncName(self):
        return self.comboHypoCfg.__name__ if isinstance(self.comboHypoCfg, types.FunctionType) else self.comboHypoCfg        
 
 

getLegIds()

def MenuComponents.ChainStep.getLegIds

(

self

)

get the gelId from the step dictionary for multi-leg chains

Definition at line 672 of file MenuComponents.py.

    def getLegIds(self):
        """ get the gelId from the step dictionary for multi-leg chains"""
        if self.nLegs <= 1: # single leg or empty steps
            return [0]
        leg_ids = []
        for istep,step_dict in enumerate(self.stepDicts):
            if step_dict['chainName'][0:3] != 'leg':
                if self.onlyJets:
                    leg_ids += [istep]
                else:
                    log.error("[getLegIds] step %s for chain %s has %i dictionaries but no leg IDs? ",self.name, step_dict['chainName'], self.nLegs)
                    raise Exception("[getLegIds] cannot extract leg IDs, exiting.")
            else:
                leg_ids += [int(step_dict['chainName'][3:6])]
        return leg_ids
 

makeCombo()

def MenuComponents.ChainStep.makeCombo

(

self

)

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

Definition at line 696 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 or self.comboHypoCfg is None:
            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()

def MenuComponents.ChainStep.setChainPartIndices

(

self

)

Definition at line 657 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

Definition at line 698 of file MenuComponents.py.

comboHypoCfg

MenuComponents.ChainStep.comboHypoCfg

Definition at line 611 of file MenuComponents.py.

comboToolConfs

MenuComponents.ChainStep.comboToolConfs

Definition at line 612 of file MenuComponents.py.

isEmpty

MenuComponents.ChainStep.isEmpty

Definition at line 615 of file MenuComponents.py.

legIds

MenuComponents.ChainStep.legIds

Definition at line 646 of file MenuComponents.py.

name

MenuComponents.ChainStep.name

Definition at line 608 of file MenuComponents.py.

nLegs

MenuComponents.ChainStep.nLegs

Definition at line 613 of file MenuComponents.py.

onlyJets

MenuComponents.ChainStep.onlyJets

Definition at line 633 of file MenuComponents.py.

sequenceGens

MenuComponents.ChainStep.sequenceGens

Definition at line 610 of file MenuComponents.py.

sequences

MenuComponents.ChainStep.sequences

Definition at line 609 of file MenuComponents.py.

stepDicts

MenuComponents.ChainStep.stepDicts

Definition at line 614 of file MenuComponents.py.

---

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

• MenuComponents.py