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	relabelLegIdsForJets (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
	stepDicts
	isEmpty
	multiplicity
	onlyJets
	legIds
	combo

Detailed Description

Class to describe one step of a chain; if multiplicity is greater than 1, the step is combo/combined.  Set one multiplicity value per sequence

Definition at line 634 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 637 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 a chainDicts"
 
        self.name = name
        self.sequences = []
        self.sequenceGens = SequenceGens 
        self.comboHypoCfg = comboHypoCfg
        self.comboToolConfs = list(comboToolConfs)
        self.stepDicts = chainDicts # one dict per leg
 
        self.isEmpty = isEmpty        
        if self.isEmpty:
            self.multiplicity = []
        else:
            self.multiplicity = [1 for seq in self.sequenceGens]                    
            log.debug("Building step %s for chain %s: len=%d multiplicty=%s",  name, chainDicts[0]['chainName'], len(chainDicts), ' '.join(map(str,[mult for mult in self.multiplicity])))           
            # sanity check on inputs, excluding empty steps
            if len(chainDicts) != len(self.multiplicity) and 'Jet' not in chainDicts[0]['signatures']:
                log.error("[ChainStep] SequenceGens: %s",self.sequenceGens)
                log.error("[ChainStep] chainDicts: %s",chainDicts)
                log.error("[ChainStep] multiplicity: %s",self.multiplicity)
                raise RuntimeError("[ChainStep] Tried to configure a ChainStep %s with %i multiplicity and %i dictionaries. These lists must have the same size" % (name, len(self.multiplicity), 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]: 
            leg_signatures = [step['signature'] for step in chainDicts if step['signature'] != 'Bjet']
            if (len(self.multiplicity) > 0 and leg_signatures.count('Jet') == 1) and (len(set(leg_signatures)) > 1 and chainDicts[0]['signatures'].count('Jet') > 1) and (len(leg_signatures) != 2 or leg_signatures.count('MET') == 0):
                index_jetLeg = leg_signatures.index('Jet')
                self.multiplicity[index_jetLeg:index_jetLeg] = [1] * (len(chainDicts[0]['chainMultiplicities']) - len(self.multiplicity))
            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.relabelLegIdsForJets()
            self.setChainPartIndices()
        self.legIds = self.getLegIds() 
        self.makeCombo()
 

Member Function Documentation

__repr__()

def MenuComponents.ChainStep.__repr__

(

self

)

Definition at line 817 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 , multiplicity = %s  ChainDict = %s \n + MenuSequenceGens = %s "%\
          (self.name,  ' '.join(map(str,[mult for mult in self.multiplicity])),
             ' '.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 773 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 803 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 693 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 807 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 812 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 777 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 757 of file MenuComponents.py.

    def getLegIds(self):
        """ get the gelId from the step dictionary for multi-leg chains"""
        if len(self.multiplicity) <= 1: # single leg step
            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] chain %s has multiplicities %s but no legs? ",step_dict['chainName'], self.multiplicity)
                    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 781 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)
 
 

relabelLegIdsForJets()

def MenuComponents.ChainStep.relabelLegIdsForJets

(

self

)

Definition at line 699 of file MenuComponents.py.

    def relabelLegIdsForJets(self):
        has_jets = False
        leg_counter = []    
 
        for step_dict in self.stepDicts:
            if 'Jet' in step_dict['signatures'] or 'Bjet' in step_dict['signatures']:
                has_jets = True
                leg_counter += [len(step_dict['chainParts'])]
            elif len(step_dict['chainParts']) > 1:
                log.error("[relabelLegIdsForJets] this should only happen for jet chains, but the signatures are %s",step_dict['signatures'])
                raise Exception("[relabelLegIdsForJets] leg labelling is probably wrong...")
            else:
                leg_counter +=[1]
 
        self.onlyJets = False
        if len(leg_counter) == len(self.multiplicity):
            self.onlyJets = True
 
        log.debug("[relabelLegIdsForJets] leg_counter: %s , onlyjets: %s, multiplicity: %s...",leg_counter, self.onlyJets, self.multiplicity) 
 
        if not has_jets or len(leg_counter) == len(self.multiplicity): #also don't relabel only jets since no offset needed
            return
 
        if len(leg_counter) == 1 or (len(set(leg_counter)) == 1 and leg_counter[0] == 1):
            #all legs are already length 1, or there's only one jet blocks nothing to do
            return
        elif len(set(leg_counter[:-1])) == 1 and leg_counter[0] == 1:
            #it's the last leg that's not length one, so we don't need to relabel any end legs
            return
        else:
            nLegs = 0
            for i,nLegParts in enumerate(leg_counter):
                oldLegName = self.stepDicts[i]['chainName']
                if re.search('^leg[0-9]{3}_',oldLegName):
                    oldLegName = oldLegName[7:]
                else:
                    log.error("[relabelLegIdsForJets] you told me to relabel the legs for %s",self.stepDicts)
                    raise Exception("[relabelLegIdsForJets] you told me to relabel the legs but this leg doesn't have a legXXX_ name!")
                self.stepDicts[i]['chainName'] = legName(oldLegName,nLegs)
                nLegs += nLegParts
        return
    

setChainPartIndices()

def MenuComponents.ChainStep.setChainPartIndices

(

self

)

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

comboHypoCfg

MenuComponents.ChainStep.comboHypoCfg

Definition at line 648 of file MenuComponents.py.

comboToolConfs

MenuComponents.ChainStep.comboToolConfs

Definition at line 649 of file MenuComponents.py.

isEmpty

MenuComponents.ChainStep.isEmpty

Definition at line 652 of file MenuComponents.py.

legIds

MenuComponents.ChainStep.legIds

Definition at line 690 of file MenuComponents.py.

multiplicity

MenuComponents.ChainStep.multiplicity

Definition at line 654 of file MenuComponents.py.

name

MenuComponents.ChainStep.name

Definition at line 645 of file MenuComponents.py.

onlyJets

MenuComponents.ChainStep.onlyJets

Definition at line 672 of file MenuComponents.py.

sequenceGens

MenuComponents.ChainStep.sequenceGens

Definition at line 647 of file MenuComponents.py.

sequences

MenuComponents.ChainStep.sequences

Definition at line 646 of file MenuComponents.py.

stepDicts

MenuComponents.ChainStep.stepDicts

Definition at line 650 of file MenuComponents.py.

---

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

• MenuComponents.py