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=None, comboToolConfs=None, isEmpty=False, createsGhostLegs=False)
def	createSequences (self)
def	setChainPartIndices (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
	stepDicts
	nLegs
	isEmpty
	onlyJets
	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;
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.

Constructor & Destructor Documentation

__init__()

def 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__()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def MenuComponents.ChainStep.getComboHypoFncName

(

self

)

Definition at line 680 of file MenuComponents.py.

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

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 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()

def 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

Definition at line 687 of file MenuComponents.py.

comboHypoCfg

MenuComponents.ChainStep.comboHypoCfg

Definition at line 614 of file MenuComponents.py.

comboToolConfs

MenuComponents.ChainStep.comboToolConfs

Definition at line 615 of file MenuComponents.py.

isEmpty

MenuComponents.ChainStep.isEmpty

Definition at line 618 of file MenuComponents.py.

name

MenuComponents.ChainStep.name

Definition at line 608 of file MenuComponents.py.

nLegs

MenuComponents.ChainStep.nLegs

Definition at line 617 of file MenuComponents.py.

onlyJets

MenuComponents.ChainStep.onlyJets

Definition at line 636 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 616 of file MenuComponents.py.

---

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

• MenuComponents.py