MenuPrescaleSet.AutoPrescaleSetGen Class Reference

Collaboration diagram for MenuPrescaleSet.AutoPrescaleSetGen:

Public Member Functions
def	__post_init__ (self)
AutoPrescaleSet	generate (self, flags, bool store=False)

Static Public Member Functions
AutoPrescaleSet	disable_unused_l1 (AutoPrescaleSet ps_set, dict[str, dict[str, Any]] chain_dicts)
def	store_json_files (flags, AutoPrescaleSet ps_set)

Public Attributes
	enable_chains
	disable_chains
	enable_groups
	disable_groups
	enable_l1_triggers
	disable_l1_triggers

Static Public Attributes
	default_factory
	bool

Detailed Description

This is an extremely basic prescale set generator. No "smart" optimizations (e.g. prescaling 
all HLT chains for an L1 trigger -> prescale L1 trigger by lowest prescale) are applied.

The prescales are set based on the following priority: disable_* >> *_prescales >> enable_*.
Also, HLT chain >> group (i.e. a group can be disabled while a single chain in that group is enables).
If the enable_chains/groups/l1_triggers list is not set, all triggers in that category will be enabled by default.

This is NOT meant to be used in data-taking, only for development tests and standard reprocessings/MC productions.

For any more complex prescale sets, refer to the `TrigMenuRulebook` (used to create PS sets
for data-taking), located at: https://gitlab.cern.ch/atlas-trigger-menu/TrigMenuRulebook/

Definition at line 17 of file MenuPrescaleSet.py.

Member Function Documentation

__post_init__()

def MenuPrescaleSet.AutoPrescaleSetGen.__post_init__

(

self

)

Definition at line 47 of file MenuPrescaleSet.py.

    def __post_init__(self):
        if self.enable_chains is not None: self.enable_chains = set(self.enable_chains)
        self.disable_chains = set(self.disable_chains)
 
        if self.enable_groups is not None: self.enable_groups = set(self.enable_groups)
        self.disable_groups = set(self.disable_groups)
 
        if self.enable_l1_triggers is not None: self.enable_l1_triggers = set(self.enable_l1_triggers)
        self.disable_l1_triggers = set(self.disable_l1_triggers)
 
 

disable_unused_l1()

AutoPrescaleSet MenuPrescaleSet.AutoPrescaleSetGen.disable_unused_l1 ( AutoPrescaleSet  ps_set, dict[str, dict[str, Any]]  chain_dicts  )

static

Disable unused L1 triggers

Definition at line 59 of file MenuPrescaleSet.py.

    def disable_unused_l1(ps_set: AutoPrescaleSet, chain_dicts: dict[str, dict[str, Any]]) -> AutoPrescaleSet:
        '''Disable unused L1 triggers'''
        enabled_l1_triggers = set()
        
        for chain in ps_set.hlt_prescales:
            l1 = chain_dicts[chain]['L1item']
            if ps_set.hlt_prescales[chain] > 0 and l1: # Skip L1_All
                enabled_l1_triggers |= {l1} if isinstance(l1, str) else set(l1)
 
        for l1_trigger in ps_set.l1_prescales:
            if l1_trigger not in enabled_l1_triggers:
                ps_set.l1_prescales[l1_trigger] = -1
 
        return ps_set
 
 

generate()

AutoPrescaleSet MenuPrescaleSet.AutoPrescaleSetGen.generate	(		self,
			flags,
		bool	store = False
	)

Definition at line 86 of file MenuPrescaleSet.py.

    def generate(self, flags, store: bool = False) -> AutoPrescaleSet:
        # Get list of HLT chain dicts
        from TriggerMenuMT.HLT.Config.Utility.HLTMenuConfig import HLTMenuConfig
 
        # Get list of L1 triggers
        from TrigConfigSvc.TriggerConfigAccess import getL1MenuAccess
        l1_triggers = getL1MenuAccess(flags).itemNames()
 
        group_prescales_set = set(self.group_prescales.keys())
 
        def match(s1: set, s2: set) -> bool: return not s1.isdisjoint(s2)
 
        # Return PS set
        ps_set = AutoPrescaleSet()
 
        # Generate HLT prescales first
        for chain, chain_dict in HLTMenuConfig.dicts().items():
            ps = 1
 
            if chain in self.disable_chains: ps = -1
            elif self.enable_chains is not None and chain not in self.enable_chains: ps = -1
            elif chain in self.chain_prescales: ps = self.chain_prescales[chain]
            elif match(self.disable_groups, chain_dict['groups']): ps = -1
            elif self.enable_groups is not None and not match(self.enable_groups, chain_dict['groups']): ps = -1
            elif match(group_prescales_set, chain_dict['groups']):
                # Apply the PS of the last matched group
                for group in reversed(chain_dict['groups']):
                    if group in self.group_prescales:
                        ps = self.group_prescales[group]
                        break
            elif chain_dict['L1item']: # Skips the L1_All trigger (set to '')
                l1s = {chain_dict['L1item']} if isinstance(chain_dict['L1item'], str) else set(chain_dict['L1item'])
            
                if l1s.issubset(self.disable_l1_triggers): ps = -1
                elif self.enable_l1_triggers is not None and not l1s & self.enable_l1_triggers: ps = -1
            
            if ps <= 0: ps = -1
 
            ps_set.hlt_prescales[chain] = ps
 
        # Now generate L1 prescales
        for l1_trigger in l1_triggers:
            ps = 1
            if l1_trigger in self.disable_l1_triggers: ps = -1
            elif self.enable_l1_triggers is not None and l1_trigger not in self.enable_l1_triggers: ps = -1
            elif l1_trigger in self.l1_trigger_prescales: ps = self.l1_trigger_prescales[l1_trigger]
 
            if ps <= 0: ps = -1
 
            ps_set.l1_prescales[l1_trigger] = ps
 
        if self.disable_unused_l1_triggers:
            ps_set = self.disable_unused_l1(ps_set, HLTMenuConfig.dicts())
 
        # Apply any custom rules, if required
        if self.custom_rules:
            ps_set = self.custom_rules(ps_set, HLTMenuConfig.dicts())
 
 
        # Apply HLT prescales to the HLTMenuConfig
        for chain, ps in ps_set.hlt_prescales.items():
            if ps != 1: log.info(f'Applying HLTPS to the chain {chain}: {ps}')
            HLTMenuConfig.dicts()[chain]['prescale'] = ps
 
        # Store the prescale JSON files
        if store: self.store_json_files(flags, ps_set)
 
        return ps_set
 

store_json_files()

def MenuPrescaleSet.AutoPrescaleSetGen.store_json_files (   flags, AutoPrescaleSet  ps_set  )

static

Definition at line 76 of file MenuPrescaleSet.py.

    def store_json_files(flags, ps_set: AutoPrescaleSet):
        # Store the L1/HLTPrescale json files
        from TrigConfigSvc.TrigConfigSvcCfg import createL1PrescalesFileFromMenu
        createL1PrescalesFileFromMenu(flags, ps_set.l1_prescales)
 
        from TriggerMenuMT.HLT.Config.Utility.HLTMenuConfig import HLTMenuConfig
        from TriggerMenuMT.HLT.Config.JSON.HLTPrescaleJSON import generatePrescaleJSON
        generatePrescaleJSON(flags, HLTMenuConfig.dictsList())
 
 

Member Data Documentation

bool

MenuPrescaleSet.AutoPrescaleSetGen.bool

static

Definition at line 43 of file MenuPrescaleSet.py.

default_factory

MenuPrescaleSet.AutoPrescaleSetGen.default_factory

static

Definition at line 33 of file MenuPrescaleSet.py.

disable_chains

MenuPrescaleSet.AutoPrescaleSetGen.disable_chains

Definition at line 49 of file MenuPrescaleSet.py.

disable_groups

MenuPrescaleSet.AutoPrescaleSetGen.disable_groups

Definition at line 52 of file MenuPrescaleSet.py.

disable_l1_triggers

MenuPrescaleSet.AutoPrescaleSetGen.disable_l1_triggers

Definition at line 55 of file MenuPrescaleSet.py.

enable_chains

MenuPrescaleSet.AutoPrescaleSetGen.enable_chains

Definition at line 48 of file MenuPrescaleSet.py.

enable_groups

MenuPrescaleSet.AutoPrescaleSetGen.enable_groups

Definition at line 51 of file MenuPrescaleSet.py.

enable_l1_triggers

MenuPrescaleSet.AutoPrescaleSetGen.enable_l1_triggers

Definition at line 54 of file MenuPrescaleSet.py.

---

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

• MenuPrescaleSet.py