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	checkMultiplicity (self)
def	addTopo (self, topoPair, step="last")
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 472 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 475 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 606 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)))       
        
 
# next:  can we remove multiplicity array, if it can be retrieved from the ChainDict?
# next: can we describe emtpy steps with isEmpty flag only (not via multiplicity and setting comboHypoCfg=None)?

addTopo()

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

Definition at line 601 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 507 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 512 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)]
 
 

checkMultiplicity()

def MenuComponents.Chain.checkMultiplicity

(

self

)

Definition at line 579 of file MenuComponents.py.

    def checkMultiplicity(self):
        #TODO: Not used anymore, can we delete it?
        if len(self.steps) == 0:
            return 0
        mult=[sum(step.multiplicity) for step in self.steps] # on mult per step
        not_empty_mult = [m for m in mult if m!=0]
        if len(not_empty_mult) == 0: #empty chain?
            log.error("checkMultiplicity: Chain %s has all steps with multiplicity =0: what to do?", self.name)
            return 0
        if not_empty_mult.count(not_empty_mult[0]) != len(not_empty_mult):
            log.error("checkMultiplicity: Chain %s has steps with differnt multiplicities: %s", self.name, ' '.join(mult))
            return 0
 
        if not_empty_mult[0] != len(self.L1decisions):
            log.error("checkMultiplicity: Chain %s has %d multiplicity 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 532 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("Configuring empty step %s", new_step_name)
            steps_to_add += [ChainStep(new_step_name, chainDicts=prev_chain_dict, comboHypoCfg=ComboHypoCfg, 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 518 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
        return
 
 

Member Data Documentation

__slots__

MenuComponents.Chain.__slots__

staticprivate

Definition at line 474 of file MenuComponents.py.

alignmentGroups

MenuComponents.Chain.alignmentGroups

Definition at line 489 of file MenuComponents.py.

L1decisions

MenuComponents.Chain.L1decisions

Definition at line 504 of file MenuComponents.py.

name

MenuComponents.Chain.name

Definition at line 486 of file MenuComponents.py.

nSteps

MenuComponents.Chain.nSteps

Definition at line 488 of file MenuComponents.py.

steps

MenuComponents.Chain.steps

Definition at line 487 of file MenuComponents.py.

topoMap

MenuComponents.Chain.topoMap

Definition at line 498 of file MenuComponents.py.

---

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

• MenuComponents.py