Inheritance diagram for MenuComponents.Chain:

Collaboration diagram for MenuComponents.Chain:

Public Types
typedef HLT::TypeInformation::for_each_type_c< typenameEDMLIST::map, my_functor, my_result<>, my_arg< HLT::TypeInformation::get_cont, CONTAINER > >::type	result

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

Public Attributes
	name = name
	steps = ChainSteps
list	nSteps = nSteps
	alignmentGroups = alignmentGroups
dict	topoMap = {}
	L1decisions = L1decisions

Static Private Attributes
str	__slots__ = 'name','steps','nSteps','alignmentGroups','L1decisions', 'topoMap'

Detailed Description

Basic class to define the trigger menu

Definition at line 432 of file MenuComponents.py.

Member Typedef Documentation

◆ result

typedef HLT::TypeInformation::for_each_type_c<typenameEDMLIST::map,my_functor,my_result<>,my_arg<HLT::TypeInformation::get_cont,CONTAINER>>::type master_search< typenameEDMLIST::map, HLT::TypeInformation::get_cont, CONTAINER >::result

inherited

Definition at line 90 of file EDM_MasterSearch.h.

Constructor & Destructor Documentation

◆ init()

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

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

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

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

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

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

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

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

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

str MenuComponents.Chain.__slots__ = 'name','steps','nSteps','alignmentGroups','L1decisions', 'topoMap'

staticprivate

Definition at line 434 of file MenuComponents.py.

◆ alignmentGroups

MenuComponents.Chain.alignmentGroups = alignmentGroups

Definition at line 449 of file MenuComponents.py.

◆ L1decisions

MenuComponents.Chain.L1decisions = L1decisions

Definition at line 464 of file MenuComponents.py.

◆ name

MenuComponents.Chain.name = name

Definition at line 446 of file MenuComponents.py.

◆ nSteps

MenuComponents.Chain.nSteps = nSteps

Definition at line 448 of file MenuComponents.py.

◆ steps

MenuComponents.Chain.steps = ChainSteps

Definition at line 447 of file MenuComponents.py.

◆ topoMap

dict MenuComponents.Chain.topoMap = {}

Definition at line 458 of file MenuComponents.py.

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

MenuComponents.py

Public Types

Public Member Functions

Public Attributes

Static Private Attributes