GenerateMenuMT.GenerateMenuMT Class Reference

Inheritance diagram for GenerateMenuMT.GenerateMenuMT:

Collaboration diagram for GenerateMenuMT.GenerateMenuMT:

Public Member Functions
def	__init__ (self)
def	getRequiredSignatures (theslice)
def	setChainFilter (self, f)
def	getChainDicts (self, flags)
def	importSignaturesToGenerate (self)
def	generateChains (self, flags)
def	generateAllChainConfigs (self, flags)
def	getChainsFromMenu (self, flags)
def	resolveEmptySteps (self, chainConfigs)
def	generatePrescales (self, flags, Optional[str] prescale_set='__auto__')
def	__call__ (cls, *args, **kwargs)
def	clear (cls)

Public Attributes
	chainsInMenu
	allChainsForAlignment
	chainDicts
	combinationsInMenu
	alignmentGroupsToAlign
	configLengthDict
	signaturesOverwritten
	L1Prescales
	HLTPrescales
	chainFilter
	availableSignatures
	sigDicts
	chainDefModule
	base_menu_name

Private Member Functions
def	__generateChainConfig (self, flags, mainChainDict)

Static Private Attributes
	_instances

Detailed Description

Singleton class for the Trigger Menu

Definition at line 63 of file GenerateMenuMT.py.

Constructor & Destructor Documentation

__init__()

def GenerateMenuMT.GenerateMenuMT.__init__

(

self

)

Definition at line 65 of file GenerateMenuMT.py.

    def __init__(self):
        self.base_menu_name: str = ''
 
        self.chainsInMenu = {}  # signature : [chains]
 
        self.allChainsForAlignment = []
        self.chainDicts = []
        self.combinationsInMenu = []
        self.alignmentGroupsToAlign = set()
        self.configLengthDict = {}
        
        self.signaturesOverwritten = False
        self.L1Prescales = None
        self.HLTPrescales = None
 
        self.chainFilter = None
        self.availableSignatures = []
 
        self.sigDicts = {}
 
        self.chainDefModule = {}   # Generate[SIG]ChainDefs module for each SIGnature
 
 

Member Function Documentation

__call__()

def GenerateMenuMT.Singleton.__call__ (   cls, *  args, **  kwargs  )

inherited

Definition at line 54 of file GenerateMenuMT.py.

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]
 

__generateChainConfig()

def GenerateMenuMT.GenerateMenuMT.__generateChainConfig (   self,   flags,   mainChainDict  )

private

# Assembles the chain configuration and returns a chain object with (name, L1see and list of ChainSteps)

Definition at line 371 of file GenerateMenuMT.py.

    def __generateChainConfig(self, flags, mainChainDict):
        """
        # Assembles the chain configuration and returns a chain object with (name, L1see and list of ChainSteps)
        """
 
        from TriggerMenuMT.HLT.Config.Utility.ChainDictTools import splitInterSignatureChainDict
        from TriggerMenuMT.HLT.Config.Utility.ComboHypoHandling import addTopoInfo, comboConfigurator, topoLegIndices, anomdetWPIndices
        from TriggerMenuMT.HLT.Config.Utility.ChainMerging import mergeChainDefs
        from TriggerMenuMT.HLT.CommonSequences import EventBuildingSequences, TLABuildingSequences
 
        # split the the chainDictionaries for each chain and print them in a pretty way
        chainDicts = splitInterSignatureChainDict(mainChainDict)
 
        if log.isEnabledFor(logging.DEBUG):
            import pprint
            pp = pprint.PrettyPrinter(indent=4, depth=8)
            log.debug('dictionary is: %s', pp.pformat(chainDicts))
 
        # Loop over all chainDicts and send them off to their respective assembly code
        listOfChainConfigs = []
        perSig_lengthOfChainConfigs = []
 
        for chainPartDict in chainDicts:
            chainPartConfig = None
            currentSig = chainPartDict['signature']
            currentAlignGroup = None
            if len(chainPartDict['chainParts']) == 1:
                currentAlignGroup = chainPartDict['chainParts'][0]['alignmentGroup']
            
            chainName = chainPartDict['chainName']
            log.debug('Checking chainDict for chain %s in signature %s, alignment group %s' , chainName, currentSig, currentAlignGroup)
 
            if currentSig in self.availableSignatures:
                try:
                    log.debug("[__generateChainConfigs] Trying to get chain config for %s", currentSig)
                    if currentSig in ['Electron', 'Photon', 'Muon', 'Tau', 'Bphysics'] :
                        chainPartConfig, perSig_lengthOfChainConfigs = self.chainDefModule[currentSig].generateChainConfigs(flags, chainPartDict, perSig_lengthOfChainConfigs)
                    else:
                        chainPartConfig = self.chainDefModule[currentSig].generateChainConfigs(flags, chainPartDict)
                        if currentSig == 'Test' and isinstance(chainPartConfig, tuple):
                            chainPartConfig = chainPartConfig[0]
                except Exception:
                    log.error('[__generateChainConfigs] Problems creating ChainDef for chain %s ', chainName)
                    log.error('[__generateChainConfigs] I am in chain part\n %s ', chainPartDict)
                    log.exception('[__generateChainConfigs] Full chain dictionary is\n %s ', mainChainDict)
                    raise Exception('[__generateChainConfigs] Stopping menu generation. Please investigate the exception shown above.')
            else:
                log.error('Chain %s cannot be generated - Signature "%s" not available', chainPartDict['chainName'], currentSig)
                log.error('Available signature(s): %s', self.availableSignatures)
                raise Exception('Stopping the execution. Please correct the configuration.')
 
            log.debug("Chain %s \n chain config: %s",chainPartDict['chainName'],chainPartConfig)
 
            listOfChainConfigs.append(chainPartConfig)
            log.debug("[__generateChainConfigs] adding to the perSig_lengthOfChainConfigs list (%s, %s)",chainPartConfig.nSteps,chainPartConfig.alignmentGroups)
            perSig_lengthOfChainConfigs.append((chainPartConfig.nSteps,chainPartConfig.alignmentGroups))
                
        # this will be a list of lists for inter-sig combined chains and a list with one 
        # multi-element list for intra-sig combined chains
        # here, we flatten it accordingly (works for both cases!)
        lengthOfChainConfigs = []
        for nSteps, aGrps in perSig_lengthOfChainConfigs:
            if len(nSteps) != len(aGrps):
                log.error("Chain part has %s steps and %s alignment groups - these don't match!",nSteps,aGrps)
            else:
                for a,b in zip(nSteps,aGrps):
                    lengthOfChainConfigs.append((a,b))
            
       
        # This part is to deal with combined chains between different signatures
        try:
            if len(listOfChainConfigs) == 0:
                raise Exception('[__generateChainConfigs] No Chain Configuration found for {0}'.format(mainChainDict['chainName']))                    
            else:
                if len(listOfChainConfigs)>1:
                    log.debug("Merging strategy from dictionary: %s", mainChainDict["mergingStrategy"])
                    theChainConfig, perSig_lengthOfChainConfigs = mergeChainDefs(listOfChainConfigs, mainChainDict, perSig_lengthOfChainConfigs)
                    lengthOfChainConfigs = []
                    for nSteps, aGrps in perSig_lengthOfChainConfigs:
                        if len(nSteps) != len(aGrps):
                            log.error("Post-merged chain part has %s steps and %s alignment groups - these don't match!",nSteps,aGrps)
                        else:
                            for a,b in zip(nSteps,aGrps):
                                lengthOfChainConfigs.append((a,b))
                else:
                    theChainConfig = listOfChainConfigs[0]
                
                for topoID in range(len(mainChainDict['extraComboHypos'])):
                    thetopo = mainChainDict['extraComboHypos'][topoID].strip(string.digits).rstrip(topoLegIndices)  
                    
                    
                    if "anomdet" in thetopo:
                        thetopo = thetopo.rstrip(anomdetWPIndices)
                                      
                    theChainConfig.addTopo((comboConfigurator[thetopo],thetopo))
                                    
                # Now we know where the topos should go, we can insert them in the right steps
                if len(theChainConfig.topoMap) > 0:                    
                    log.debug("Trying to add extra ComboHypoTool for %s",mainChainDict['extraComboHypos'])
                    addTopoInfo(theChainConfig,mainChainDict,listOfChainConfigs,lengthOfChainConfigs)
        except RuntimeError:
            log.error('[__generateChainConfigs] Problems creating ChainDef for chain %s ', chainName)
            log.error('[__generateChainConfigs] I am in the extraComboHypos section, for %s ', mainChainDict['extraComboHypos'])
            log.exception('[__generateChainConfigs] Full chain dictionary is\n %s ', mainChainDict)
            raise Exception('[__generateChainConfigs] Stopping menu generation. Please investigate the exception shown above.')
        except AttributeError:                    
            raise Exception('[__generateChainConfigs] Stopping menu generation. Please investigate the exception shown above.')
 
        # Configure event building strategy
        eventBuildType = mainChainDict['eventBuildType']
        if eventBuildType:
            try:
                if 'PhysicsTLA' in eventBuildType:
                    log.debug("Adding TLA Step for chain %s", mainChainDict['chainName'])
                    TLABuildingSequences.addTLAStep(flags, theChainConfig, mainChainDict)
                log.debug('Configuring event building sequence %s for chain %s', eventBuildType, mainChainDict['chainName'])
                EventBuildingSequences.addEventBuildingSequence(flags, theChainConfig, eventBuildType, mainChainDict)
            except TypeError as ex:
                    log.error(ex)
                    raise Exception('[__generateChainConfigs] Stopping menu generation for EventBuilding/TLA sequences. Please investigate the exception shown above.')
 
        log.debug('[__generateChainConfigs] lengthOfChainConfigs %s, ChainConfigs  %s ', lengthOfChainConfigs, theChainConfig)
        return theChainConfig,lengthOfChainConfigs
 
    

clear()

def GenerateMenuMT.Singleton.clear (   cls )

inherited

Definition at line 59 of file GenerateMenuMT.py.

    def clear(cls):
        cls._instances.clear()
 
 

generateAllChainConfigs()

def GenerateMenuMT.GenerateMenuMT.generateAllChainConfigs	(		self,
			flags
	)

== Obtains chain configs for all chains in menu

Definition at line 227 of file GenerateMenuMT.py.

    def generateAllChainConfigs(self, flags):
        """
        == Obtains chain configs for all chains in menu
        """
 
        from TriggerMenuMT.HLT.Config.Utility.MenuAlignmentTools import MenuAlignment
        from TriggerMenuMT.HLT.CommonSequences import EventBuildingSequences, TLABuildingSequences
 
        # get all chain names from menu
        log.info("Will now get chains from the menu")
        self.getChainsFromMenu(flags)
 
        # decoding of the chain name
        log.info("Will now get chain dictionaries for each chain")
        self.getChainDicts(flags)
 
        if flags.Trigger.disableCPS:
            log.warning('Removing all CPS group because the flag Trigger.disableCPS is set')
            for chainDict in self.chainDicts:
                chainDict['groups'] = [g for g in chainDict['groups'] if not g.startswith('RATE:CPS_')]
 
        #import the necessary signatures
        log.debug("Importing the necessary signatures")
        self.importSignaturesToGenerate()
 
        log.info("Will now generate the chain configuration for each chain")
        self.generateChains(flags)
 
        log.info("Will now calculate the alignment parameters")
        #dict of signature: set it belongs to
        #e.g. {'Electron': ['Electron','Muon','Photon']}        
        menuAlignment = MenuAlignment(self.combinationsInMenu,
                                      self.alignmentGroupsToAlign,
                                      self.configLengthDict)
        menuAlignment.analyse_combinations()
 
        # alignmentGroups_to_align = menuAlignment.groupsToAlign
        # lengthOfChainConfigs = self.configLengthDict
        # combinationsInMenu = menuAlignment.combinationsInMenu
        # alignmentGroup_sets_to_align = menuAlignment.setsToAlign
 
        log.info('Aligning the following signatures: %s',sorted(menuAlignment.sets_to_align))
        log.debug('Length of each of the alignment groups: %s',self.configLengthDict)
 
        chainConfigs = []
 
        for chainDict,chainConfig,lengthOfChainConfigs in self.allChainsForAlignment:
 
              # start by ordering electron, photon, muon by having e+mu, g+mu, e+g chains
              # desired ordering: electron, photon, muon, tau, jet, met, b-jet
              
              # lengthOfChainConfigs is something like this: [(4, 'Photon'), (5, 'Muon')]
              # needs to match up with the maximum number of steps in a signature in the menu (length_of_configs)
              # start with electron! Only need to add post-steps for combined electron chains if the max length in a combined chain
              # is greater than the number of electron steps combined chain. Assume that the max length of an electron chain occurs 
              # in a combined chain.
 
              log.debug("[generateAllChainConfigs] chain %s has config lengths %s and alignment groups %s", chainDict['chainName'], lengthOfChainConfigs, chainDict['alignmentGroups'])
 
              alignmentGroups = chainDict['alignmentGroups']
            
              #parallel-merged single-signature chains or single signature chains. Anything that needs no splitting!
              if len(set(alignmentGroups)) == 1: 
                  alignedChainConfig = menuAlignment.single_align(chainDict, chainConfig)
                  HLTMenuConfig.registerChain( chainDict )
                  chainConfigs.append( alignedChainConfig )
 
              elif len(alignmentGroups) >= 2:
                  alignedChainConfig = menuAlignment.multi_align(chainDict, chainConfig, lengthOfChainConfigs)
                  HLTMenuConfig.registerChain( chainDict )
                  chainConfigs.append( alignedChainConfig )
 
              else: 
                  log.error("Menu can't deal with combined chains with more than two alignmentGroups at the moment. oops...")
                  raise NotImplementedError("more than three alignment groups still needs implementing in ChainMerging.py, ATR-22206")
 
              if not HLTMenuConfig.isChainRegistered(chainDict['chainName']):
                log.error("Chain %s has not been registered in the menu!", chainDict['chainName'])
                import pprint
                pp = pprint.PrettyPrinter(indent=4, depth=8)
                log.error('The chain dictionary is: %s', pp.pformat(chainDict))
                raise Exception("Please fix the menu or the chain.")
 
        # align event building sequences
        log.info("[generateAllChainConfigs] general alignment complete, will now align TLA chains")
        TLABuildingSequences.alignTLASteps(chainConfigs, HLTMenuConfig.dicts())
        log.info("[generateAllChainConfigs] general and TLA alignment complete, will now align PEB chains")
        EventBuildingSequences.alignEventBuildingSteps(chainConfigs, HLTMenuConfig.dicts())
 
        log.info("[generateAllChainConfigs] all chain configurations have been generated.")
        return chainConfigs
 
 

generateChains()

def GenerateMenuMT.GenerateMenuMT.generateChains	(		self,
			flags
	)

Definition at line 187 of file GenerateMenuMT.py.

    def generateChains(self, flags):       
        all_chains = []
        combinations_in_menu = []
        alignmentGroups_to_align = set()
        length_of_configs = {}
        
        nchainDicts = len(self.chainDicts)
        notify_increment = max(int(nchainDicts / 10),1)
        for ichainDict, chainDict in enumerate(self.chainDicts):
            log.debug("Next: getting chain configuration for chain %s ", chainDict['chainName'])
            if ichainDict % notify_increment==0:
                log.info("Generating HLT chain %d / %d", ichainDict+1, nchainDicts)
            chainConfig,lengthOfChainConfigs = self.__generateChainConfig(flags, chainDict)
            all_chains += [(chainDict,chainConfig,lengthOfChainConfigs)]
            
            #update the alignment group length dictionary if we have a longer number of steps
            #or the signature isn't registered in the dictionary yet
            for config_length, config_grp in lengthOfChainConfigs:
                if config_grp in length_of_configs:
                    if config_length > length_of_configs[config_grp]:
                        length_of_configs[config_grp] = config_length
                else:
                    length_of_configs[config_grp] = config_length
 
            # find the chains that contain more than one alignment group, to keep track
            # of what combinations do we need to deal with.
            # we're using sets here so we don't end up with duplicates
            if len(set(chainDict['alignmentGroups'])) > 1:  
                combinations_in_menu += [list(set(chainDict['alignmentGroups']))]
                for align_group in list(set(chainDict['alignmentGroups'])):
                    alignmentGroups_to_align.update([align_group])
                    
        self.allChainsForAlignment = all_chains
        self.combinationsInMenu = combinations_in_menu
        self.alignmentGroupsToAlign = alignmentGroups_to_align
        self.configLengthDict = length_of_configs
 
        return 
 
 

generatePrescales()

def GenerateMenuMT.GenerateMenuMT.generatePrescales	(		self,
			flags,
		Optional[str]	prescale_set = '__auto__'
	)

Add prescales for disabling items (e.g. MC production)

Definition at line 535 of file GenerateMenuMT.py.

    def generatePrescales(self, flags, prescale_set: Optional[str] = '__auto__'):
        '''Add prescales for disabling items (e.g. MC production)'''
 
        menu_name = flags.Trigger.triggerMenuSetup
        if prescale_set == '__auto__':
            if menu_name.endswith('_prescale'):
                # Get the prescale set name from the Menu
                prescale_set = menu_name.removeprefix(f'{self.base_menu_name}_').removesuffix('_prescale')
            else:
                prescale_set = None
 
        if prescale_set:
            from TriggerMenuMT.HLT.Menu.MenuPrescaleConfig import menu_prescale_set_gens
            if prescale_set not in menu_prescale_set_gens:
                raise RuntimeError(f'Unknown menu prescale set for menu {flags.Trigger.triggerMenuSetup}')
 
            gen = menu_prescale_set_gens[prescale_set]
        else:
            from TriggerMenuMT.HLT.Config.Utility.MenuPrescaleSet import AutoPrescaleSetGen
            gen = AutoPrescaleSetGen()
 
        # Generate prescale set
        log.info(f'Generating automatic prescale set: {prescale_set}')
        ps_set = gen.generate(flags, store=True)
        self.L1Prescales = ps_set.l1_prescales
        self.HLTPrescales = ps_set.hlt_prescales
 
 
 

getChainDicts()

def GenerateMenuMT.GenerateMenuMT.getChainDicts	(		self,
			flags
	)

Definition at line 125 of file GenerateMenuMT.py.

    def getChainDicts(self, flags):
 
        def validSignature(currentSig, chainSig):
            """Check if chain is assigned to the correct signature"""
            reqd = GenerateMenuMT.getRequiredSignatures(currentSig)
            isValid = chainSig.issubset( reqd )
            log.debug("Chain signatures: %s, required signatures: %s",chainSig,reqd)
            if not isValid:
                log.error("Chain signatures %s not a subset of required signatures %s",set(chainSig),reqd)
            return isValid
 
        from TriggerMenuMT.HLT.Config.Utility.DictFromChainName import dictFromChainName
 
        chainCounter = 0
        invalid = False
        for sig, chains in self.chainsInMenu.items():
            for chain in chains:
                log.debug("Now processing chain: %s from signature %s", chain, sig)
                chainCounter += 1
                chainDict = dictFromChainName(flags, chain)
                chainDict['chainCounter'] = chainCounter
                chainDict['prescale'] = 1  # set default chain prescale
 
                # Pick out the folder and subsignature directories to import
                for sigfo, subsig in chainDict['sigDicts'].items():
                    if sigfo not in self.sigDicts:
                        self.sigDicts[sigfo] = subsig
                    else:
                        for ss in subsig:
                            if ss not in self.sigDicts[sigfo]:
                                self.sigDicts[sigfo].append(ss)
 
                self.chainDicts.append(chainDict)
 
                if not validSignature(sig, set(chainDict['signatures'])):
                    invalid=True
                    log.error('Chain %s assigned to signature %s but creates %s',
                              chainDict['chainName'], sig, set(chainDict['signatures']))
        if invalid:
            raise RuntimeError('Incorrect assignment of chains to slices -- see preceding messages.')
 

getChainsFromMenu()

def GenerateMenuMT.GenerateMenuMT.getChainsFromMenu	(		self,
			flags
	)

== Returns the list of chain names that are in the menu

Definition at line 320 of file GenerateMenuMT.py.

    def getChainsFromMenu(self, flags):
        """
        == Returns the list of chain names that are in the menu
        """
 
        self.base_menu_name = re.match(r'\w*_v\d*', flags.Trigger.triggerMenuSetup).group(0)
        log.info(f'Menu name: {flags.Trigger.triggerMenuSetup}')
        log.debug('Base menu name: %s', self.base_menu_name)
        
        # Generate the list of chains from the basic menu (terminated in a version number)
        try:
            menu_module = importlib.import_module(f'TriggerMenuMT.HLT.Menu.{self.base_menu_name}')
        except Exception as e:
            log.fatal(f'Failed to import menu module "{self.base_menu_name}" inferred from menu "{flags.Trigger.triggerMenuSetup}"')
            raise e
 
        # Load Menu
        self.chainsInMenu = menu_module.setupMenu()
 
        # Filter chains if requested
        if self.chainFilter is not None:
            self.signaturesOverwritten = True
 
            # Verify that if the chain filter has lists of chains
            # they are all in the menu
            chainsToCheck = []
            if hasattr(self.chainFilter,'selectChains'):
                chainsToCheck += self.chainFilter.selectChains
            if hasattr(self.chainFilter,'disableChains'):
                chainsToCheck += self.chainFilter.disableChains
            for chain in chainsToCheck:
                inMenu = False
                for signame in self.chainsInMenu:
                    if chain in [c.name for c in self.chainsInMenu[signame]]:
                        inMenu = True
                        break
                if not inMenu:
                    raise RuntimeError(f'Request to enable/disable chain {chain} that is not in menu')
 
            for signame in self.chainsInMenu:
                self.chainsInMenu[signame] = [c for c in self.chainsInMenu[signame]
                                              if self.chainFilter(signame, c.name)]
 
        if not self.chainsInMenu:
            log.warning("There seem to be no chains in the menu - please check")
        elif log.isEnabledFor(logging.DEBUG):
            import pprint
            log.debug("The following chains were found in the menu:")
            pprint.pprint(self.chainsInMenu)
 
 

getRequiredSignatures()

def GenerateMenuMT.GenerateMenuMT.getRequiredSignatures

(

theslice

)

Definition at line 89 of file GenerateMenuMT.py.

    def getRequiredSignatures(theslice):
        allSigs = allSignatures()
        signatureDeps = {sig:[sig] for sig in allSigs}
        # Special cases
        signatureDeps.update({
            # Bjet always requires jet
            'Bjet': ['Bjet','Jet'],
            # Egamma contains two signatures
            'Egamma': ['Electron','Photon'],
            'Combined': combinedSignatures(),
        })
        return set(signatureDeps[theslice]+defaultSignatures()) # always allow streamers
 
 

importSignaturesToGenerate()

def GenerateMenuMT.GenerateMenuMT.importSignaturesToGenerate

(

self

)

check if all the signature files can be imported and then import them

Definition at line 166 of file GenerateMenuMT.py.

    def importSignaturesToGenerate(self):
        """check if all the signature files can be imported and then import them"""
 
        for sig, subSigs in self.sigDicts.items():
            try:
                for ss in subSigs:
                    import_module = 'TriggerMenuMT.HLT.' + sig +'.Generate' + ss + 'ChainDefs'
                    self.chainDefModule[ss] = importlib.import_module(import_module)
 
                    if ss not in self.availableSignatures:
                        self.availableSignatures.append(ss)
 
            except ImportError:
                log.exception('Problems when importing ChainDef generating code for %s', sig)
                import traceback
                traceback.print_exc()
 
        log.info('Available signature(s) for chain generation: %s', self.availableSignatures)
 
        return
 

resolveEmptySteps()

def GenerateMenuMT.GenerateMenuMT.resolveEmptySteps	(		self,
			chainConfigs
	)

Definition at line 496 of file GenerateMenuMT.py.

    def resolveEmptySteps(self,chainConfigs):
        max_steps = max([len(cc.steps) for cc in chainConfigs], default=0)    
        steps_are_empty = [True for i in range(0,max_steps)]
        emptySteps = []
        for cc in chainConfigs:
            for istep, the_step in enumerate(cc.steps):
                if not the_step.isEmpty:
                    steps_are_empty[istep] = False
                else: 
                    emptySteps.append(the_step)
                            
        log.debug("Are there any fully empty steps? %s", steps_are_empty)
        log.debug("The empty step(s) and associated chain(s) are: %s", emptySteps)
        empty_step_indices = [i for i,is_empty in enumerate(steps_are_empty) if is_empty]
        
        if len(empty_step_indices) == 0:
            return chainConfigs
        
        special_test_menu = self.chainFilter and (  getattr(self.chainFilter, "selectChains", False) or \
                                                    getattr(self.chainFilter, "disableChains", False) or \
                                                    getattr(self.chainFilter, "disabledSignatures", False) or \
                                                    getattr(self.chainFilter, "enabledSignatures", False) )
                                                
        
        if len(self.availableSignatures) != 1 and not special_test_menu:                
            raise Exception("[resolveEmptySteps] Please find the reason for this empty step and resolve it / remove it from the menu: %s", emptySteps)  
 
        log.info("Will now delete steps %s (indexed from zero)",empty_step_indices)
        
        for cc in chainConfigs:
            new_steps = []
            #only add non-empty steps to the new steps list!
            for istep,step in enumerate(cc.steps):
                if istep not in empty_step_indices:
                    new_steps += [step]
            cc.steps = new_steps
 
        return chainConfigs 
 

setChainFilter()

def GenerateMenuMT.GenerateMenuMT.setChainFilter	(		self,
			f
	)

Set chain filter for menu generation.

   This can be any callable object taking two
   arguments for signature and chain name and returning a boolean.
   E.g. to only generate Egamma chains:
menu.setChainFilter(lambda slice,chain : slice=='Egamma').

   In the special case that f is a functor with the list attributes
   selectChains and/or disableChains, the contents will be explicitly
   checked to be in the menu.

Definition at line 103 of file GenerateMenuMT.py.

    def setChainFilter(self, f):
        """Set chain filter for menu generation.
 
           This can be any callable object taking two
           arguments for signature and chain name and returning a boolean.
           E.g. to only generate Egamma chains:
                menu.setChainFilter(lambda slice,chain : slice=='Egamma').
 
           In the special case that f is a functor with the list attributes
           selectChains and/or disableChains, the contents will be explicitly
           checked to be in the menu.
        """
        fname = f.__class__.__name__ if isinstance(f,object) else f.__name__
        import inspect
        if len(inspect.signature(f).parameters)!=2:
            log.error('%s is not a valid chain filter. Function/callable needs take two arguments '
                      'for signature and chain name and return a boolean', fname)
        else:
            log.info('Setting chain filter to: %s', f)
            self.chainFilter = f
 
 

Member Data Documentation

_instances

GenerateMenuMT.Singleton._instances

staticprivateinherited

Definition at line 53 of file GenerateMenuMT.py.

alignmentGroupsToAlign

GenerateMenuMT.GenerateMenuMT.alignmentGroupsToAlign

Definition at line 73 of file GenerateMenuMT.py.

allChainsForAlignment

GenerateMenuMT.GenerateMenuMT.allChainsForAlignment

Definition at line 70 of file GenerateMenuMT.py.

availableSignatures

GenerateMenuMT.GenerateMenuMT.availableSignatures

Definition at line 81 of file GenerateMenuMT.py.

base_menu_name

GenerateMenuMT.GenerateMenuMT.base_menu_name

Definition at line 325 of file GenerateMenuMT.py.

chainDefModule

GenerateMenuMT.GenerateMenuMT.chainDefModule

Definition at line 85 of file GenerateMenuMT.py.

chainDicts

GenerateMenuMT.GenerateMenuMT.chainDicts

Definition at line 71 of file GenerateMenuMT.py.

chainFilter

GenerateMenuMT.GenerateMenuMT.chainFilter

Definition at line 80 of file GenerateMenuMT.py.

chainsInMenu

GenerateMenuMT.GenerateMenuMT.chainsInMenu

Definition at line 68 of file GenerateMenuMT.py.

combinationsInMenu

GenerateMenuMT.GenerateMenuMT.combinationsInMenu

Definition at line 72 of file GenerateMenuMT.py.

configLengthDict

GenerateMenuMT.GenerateMenuMT.configLengthDict

Definition at line 74 of file GenerateMenuMT.py.

HLTPrescales

GenerateMenuMT.GenerateMenuMT.HLTPrescales

Definition at line 78 of file GenerateMenuMT.py.

L1Prescales

GenerateMenuMT.GenerateMenuMT.L1Prescales

Definition at line 77 of file GenerateMenuMT.py.

sigDicts

GenerateMenuMT.GenerateMenuMT.sigDicts

Definition at line 83 of file GenerateMenuMT.py.

signaturesOverwritten

GenerateMenuMT.GenerateMenuMT.signaturesOverwritten

Definition at line 76 of file GenerateMenuMT.py.

---

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

• GenerateMenuMT.py