MenuComponents.Chain Class Reference

Inheritance diagram for MenuComponents.Chain:

Collaboration diagram for MenuComponents.Chain:

Public Member Functions
def	__init__ (self, name, ChainSteps, L1decisions, nSteps=None, alignmentGroups=None, topoMap=None)
def	append_bjet_steps (self, new_steps)
def	append_step_to_jet (self, new_steps)
def	numberAllSteps (self)
def	insertEmptySteps (self, empty_step_name, n_new_steps, start_position)
def	checkNumberOfLegs (self)
def	addTopo (self, topoPair, step="last")
def	__str__ (self)
def	__repr__ (self)

Public Attributes
	name
	steps
	nSteps
	alignmentGroups
	topoMap
	L1decisions

Static Private Attributes
	__slots__

Detailed Description

Basic class to define the trigger menu 

Definition at line 432 of file MenuComponents.py.

Constructor & Destructor Documentation

__init__()

def MenuComponents.Chain.__init__	(		self,
			name,
			ChainSteps,
			L1decisions,
			nSteps = None,
			alignmentGroups = None,
			topoMap = None
	)

Construct the Chain from the steps
Out of all arguments the ChainSteps & L1Thresholds are most relevant, the chain name is used in debug messages

Definition at line 435 of file MenuComponents.py.

    def __init__(self, name, ChainSteps, L1decisions, nSteps = None, alignmentGroups = None, topoMap=None):
 
        """
        Construct the Chain from the steps
        Out of all arguments the ChainSteps & L1Thresholds are most relevant, the chain name is used in debug messages
        """
        
        # default mutable values must be initialized to None
        if nSteps is None:  nSteps = []  
        if alignmentGroups is None:  alignmentGroups = []
 
        self.name   = name
        self.steps  = ChainSteps
        self.nSteps = nSteps
        self.alignmentGroups = alignmentGroups
       
        
        # The chain holds a map of topo ComboHypoTool configurators
        # This is needed to allow placement of the ComboHypoTool in the right position
        # for multi-leg chains (defaults to last step)
        # Format is {"[step name]" : ([topo config function], [topo descriptor string]), ...}
        # Here, the topo descriptor string would usually be the chain name expression that
        # configures the topo
        self.topoMap = {}
        if topoMap:
            self.topoMap.update(topoMap)
 
        # L1decisions are used to set the seed type (EM, MU,JET), removing the actual threshold
        # in practice it is the HLTSeeding Decision output
        self.L1decisions = L1decisions 
        log.debug("[Chain.__init__] Made Chain %s with seeds: %s ", name, self.L1decisions)
 

Member Function Documentation

__repr__()

def MenuComponents.Chain.__repr__

(

self

)

Definition at line 584 of file MenuComponents.py.

    def __repr__(self):
        return "\n-*- Chain %s -*- \n + Seeds: %s, Steps: %s, AlignmentGroups: %s \n + Steps: \n %s \n"%(\
                    self.name, ' '.join(map(str, self.L1decisions)), self.nSteps, self.alignmentGroups, '\n '.join(map(str, self.steps)))       
        
 
 

__str__()

def MenuComponents.Chain.__str__

(

self

)

Definition at line 580 of file MenuComponents.py.

    def __str__(self):
        return "\n-*- Chain %s -*- \n + Seeds: %s, Steps: %s, AlignmentGroups: %s "%(\
                    self.name, ' '.join(map(str, self.L1decisions)), self.nSteps, self.alignmentGroups)     
 

addTopo()

def MenuComponents.Chain.addTopo	(		self,
			topoPair,
			step = "last"
	)

Definition at line 575 of file MenuComponents.py.

    def addTopo(self,topoPair,step="last"):
        stepname = "last step" if step=="last" else step.name
        log.debug("Adding topo configurator %s for %s to %s", topoPair[0].__qualname__, topoPair[1], "step " + stepname)
        self.topoMap[step] = topoPair
 

append_bjet_steps()

def MenuComponents.Chain.append_bjet_steps	(		self,
			new_steps
	)

Definition at line 467 of file MenuComponents.py.

    def append_bjet_steps(self,new_steps):
        assert len(self.nSteps) == 1, "[Chain.append_bjet_steps] appending already-merged step lists - chain object will be broken. This should only be used to append Bjets to jets!"
        self.steps = self.steps + new_steps
        self.nSteps = [len(self.steps)]
 

append_step_to_jet()

def MenuComponents.Chain.append_step_to_jet	(		self,
			new_steps
	)

Definition at line 472 of file MenuComponents.py.

    def append_step_to_jet(self,new_steps):
        assert len(self.nSteps) == 1, "[Chain.append_step_to_jet] appending already-merged step lists - chain object will be broken. This is used either for appending Beamspot algorithms to jets!"
        self.steps = self.steps + new_steps
        self.nSteps = [len(self.steps)]
 
 

checkNumberOfLegs()

def MenuComponents.Chain.checkNumberOfLegs

(

self

)

return 0 if the chain has unexpected number of step legs 

Definition at line 548 of file MenuComponents.py.

    def checkNumberOfLegs(self):
        """ return 0 if the chain has unexpected number of step legs """
        if len(self.steps) == 0: # skip if it's noAlg chains            
            return 1
 
        mult=[step.nLegs for step in self.steps] # one nLegs per step
        not_empty_mult = [m for m in mult if m!=0]
        # cannot accept chains with all empty steps 
        if len(not_empty_mult) == 0: 
            log.error("checkNumberOfLegs: Chain %s has all steps with nLegs =0: what to do?", self.name)
            return 0
 
        # cannot accept chains with steps with different number of legs
        if not_empty_mult.count(not_empty_mult[0]) != len(not_empty_mult):
            log.error("checkNumberOfLegs: Chain %s has steps with differnt number of legs: %s", self.name, ' '.join(mult))
            return 0
 
        # check that the chain number of legs is the same as the number of L1 seeds
        if not_empty_mult[0] != len(self.L1decisions):
            log.error("checkNumberOfLegs: Chain %s has %i legs per step, and %d L1Decisions", self.name, mult, len(self.L1decisions))            
            return 0
        return not_empty_mult[0]
    
    

insertEmptySteps()

def MenuComponents.Chain.insertEmptySteps	(		self,
			empty_step_name,
			n_new_steps,
			start_position
	)

Definition at line 501 of file MenuComponents.py.

    def insertEmptySteps(self, empty_step_name, n_new_steps, start_position):
        #start position indexed from 0. if start position is 3 and length is 2, it works like:
        # [old1,old2,old3,old4,old5,old6] ==> [old1,old2,old3,empty1,empty2,old4,old5,old6]
 
        if len(self.steps) == 0 :
            log.error("I can't insert empty steps because the chain doesn't have any steps yet!")
 
        if len(self.steps) < start_position :
            log.error("I can't insert empty steps at step %d because the chain doesn't have that many steps!", start_position)
 
        
        chain_steps_pre_split = self.steps[:start_position]
        chain_steps_post_split = self.steps[start_position:]
 
        next_step_name = ''
        prev_step_name = ''
        # copy the same dictionary as the last step, which else?
        prev_chain_dict = []
        if start_position == 0:
            next_step_name = chain_steps_post_split[0].name
            if re.search('^Step[0-9]_',next_step_name):
                next_step_name = next_step_name[6:]
            elif re.search('^Step[0-9]{2}_', next_step_name):
                next_step_name = next_step_name[7:]
 
            prev_step_name = 'empty_'+str(len(self.L1decisions))+'L1in'
            prev_chain_dict = chain_steps_post_split[0].stepDicts
        else:
            if len(chain_steps_post_split) == 0:
                log.error("Adding empty steps to the end of a chain (%s)- why would you do this?",self.name)
            else:
                prev_step_name = chain_steps_pre_split[-1].name
                next_step_name = chain_steps_post_split[0].name
            prev_chain_dict = chain_steps_pre_split[-1].stepDicts
 
 
        steps_to_add = []
        for stepID in range(1,n_new_steps+1):
            new_step_name =  prev_step_name+'_'+empty_step_name+'%d_'%stepID+next_step_name
 
            log.debug("Adding empty step %s", new_step_name)
            steps_to_add += [ChainStep(new_step_name, chainDicts=prev_chain_dict, isEmpty=True)]
        
        self.steps = chain_steps_pre_split + steps_to_add + chain_steps_post_split
 
        return
 

numberAllSteps()

def MenuComponents.Chain.numberAllSteps

(

self

)

Definition at line 478 of file MenuComponents.py.

    def numberAllSteps(self):
        if len(self.steps)==0:
            return
        else:
            for stepID,step in enumerate(self.steps):
                step_name = step.name
                if re.search('^Step[0-9]_',step_name):
                    step_name = step_name[6:]
                elif re.search('^Step[0-9]{2}_', step_name):
                    step_name = step_name[7:]   
                step.name = 'Step%d_'%(stepID+1)+step_name
                # also modify the empty sequence names to follow the step name change
                for iseq, seq in enumerate(step.sequenceGens):
                    if isEmptySequenceCfg(seq): 
                        name = seq.func.__name__ 
                        if re.search('Seq[0-9]_',name):
                            newname = re.sub('Seq[0-9]_', 'Seq%d_'%(stepID+1), name)
                            #replace the empty sequence        
                            thisEmpty = createEmptyMenuSequenceCfg(flags=None, name=newname)                
                            step.sequenceGens[iseq]=functools.partial(thisEmpty, flags=None, name=newname)
        return
 
 

Member Data Documentation

__slots__

MenuComponents.Chain.__slots__

staticprivate

Definition at line 434 of file MenuComponents.py.

alignmentGroups

MenuComponents.Chain.alignmentGroups

Definition at line 449 of file MenuComponents.py.

L1decisions

MenuComponents.Chain.L1decisions

Definition at line 464 of file MenuComponents.py.

name

MenuComponents.Chain.name

Definition at line 446 of file MenuComponents.py.

nSteps

MenuComponents.Chain.nSteps

Definition at line 448 of file MenuComponents.py.

steps

MenuComponents.Chain.steps

Definition at line 447 of file MenuComponents.py.

topoMap

MenuComponents.Chain.topoMap

Definition at line 458 of file MenuComponents.py.

---

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

• MenuComponents.py