python.HLT.Tau.TauConfigurationTools Namespace Reference

Functions
list[str]	getMenuAlgs (AthConfigFlags flags, str|None key=None, str|None alt_key=None, dict[str, list[str]]|list[str]|None algs=None, dict[str, list[str]]|list[str]|None mc_algs=None, dict[str, list[str]]|list[str]|None dev_algs=None)
	Global helper functions.
bool	useBuiltInTauJetRNNScore (str tau_id)
tuple[str, str]	getTauIDScoreVariables (str tau_id)
str	getTauIDAlgorithm (AthConfigFlags flags, str selection, tuple[tuple[str, str],...]|None name_mapping=None)
list[str]	getHitZAlgs (AthConfigFlags flags, str precision_sequence, str|None alt_precision_sequence=None)
	CaloHits sequence algorithms.
tuple[str, float]|None	getHitZConfig (AthConfigFlags flags, dict[str, Any] chainPart)
tuple[str, str]	getHitZVariables (str alg)
list[str]	getCaloHitsPreselAlgs (AthConfigFlags flags, str precision_sequence, str|None alt_precision_sequence=None)
str	getChainCaloHitsPreselConfigName (AthConfigFlags flags, dict[str, Any] chainPart)
str|None	getChainCaloHitsSeqName (dict[str, Any] chainPart)
list[str]	getPrecisionSequenceTauIDs (AthConfigFlags flags, str precision_sequence, str|None alt_precision_sequence=None)
	Precision sequence TauIDs.
str	getChainIDConfigName (AthConfigFlags flags, dict[str, Any] chainPart)
str	getChainPrecisionSeqName (dict[str, Any] chainPart, bool include_calohits_seq_name=False)
str	getChainSequenceConfigName (dict[str, Any] chainPart)
	Global Tau menu sequence.

Variables
	log = logging.getLogger(__name__)
list	rnn_wps = ['verylooseRNN', 'looseRNN', 'mediumRNN', 'tightRNN']
list	noid_selections = ['perf', 'idperf']
list	meson_selections = ['kaonpi1', 'kaonpi2', 'dipion1', 'dipion2', 'dipion3', 'dipion4', 'dikaonmass', 'singlepion']

Function Documentation

getCaloHitsPreselAlgs()

list[str] python.HLT.Tau.TauConfigurationTools.getCaloHitsPreselAlgs	(	AthConfigFlags	flags,
		str	precision_sequence,
		str | None	alt_precision_sequence = None )

Get the list of CaloHits preselection TauID inferences to be executed for the CaloHits reco sequence.
The configuration for each algorithm is contained in flags.Trigger.Offline.Tau.<alg>.

Definition at line 132 of file TauConfigurationTools.py.

def getCaloHitsPreselAlgs(flags: AthConfigFlags, precision_sequence: str, alt_precision_sequence: str | None = None) -> list[str]:
    '''
    Get the list of CaloHits preselection TauID inferences to be executed for the CaloHits reco sequence.
    The configuration for each algorithm is contained in flags.Trigger.Offline.Tau.<alg>.
    '''
    return getMenuAlgs(
        flags,
        key=precision_sequence,
        alt_key=alt_precision_sequence,
 
        # Default inferences to run in all menus
        algs=[],
 
        # Additional inferences to run ONLY if we're using the MC (or Dev) menu
        mc_algs=[],
 
        # Additional inferences to run ONLY if we're using the Dev menu
        dev_algs=[],
    )
 
 

getChainCaloHitsPreselConfigName()

str python.HLT.Tau.TauConfigurationTools.getChainCaloHitsPreselConfigName	(	AthConfigFlags	flags,
		dict[str, Any]	chainPart )

Clean the CaloHits preselection configuration for a chainPart dict

Definition at line 153 of file TauConfigurationTools.py.

def getChainCaloHitsPreselConfigName(flags: AthConfigFlags, chainPart: dict[str, Any]) -> str:
    '''Clean the CaloHits preselection configuration for a chainPart dict'''
    sel = chainPart['calohitsPresel']
 
    if not sel or sel == 'idperfCHP': return 'idperf' # No preselection
 
    return getTauIDAlgorithm(
        flags,
        sel,
        name_mapping=(('CHTP', 'GNCaloHitsTauPresel')),
    )
 
 

getChainCaloHitsSeqName()

str | None python.HLT.Tau.TauConfigurationTools.getChainCaloHitsSeqName

(

dict[str, Any]

chainPart

)

Get the HLT Tau CaloHits sequence name suffix

Definition at line 166 of file TauConfigurationTools.py.

def getChainCaloHitsSeqName(chainPart: dict[str, Any]) -> str | None:
    '''Get the HLT Tau CaloHits sequence name suffix'''
    if not chainPart['hitz'] and not chainPart['calohitsPresel']: return None
 
    parts = []
 
    # HitZ RoI updating selection
    if chainPart['hitz']: parts.append(chainPart['hitz'])
 
    if not parts: parts = ['CaloHitsBase']
    return '_'.join(parts)
 
 
 

getChainIDConfigName()

str python.HLT.Tau.TauConfigurationTools.getChainIDConfigName	(	AthConfigFlags	flags,
		dict[str, Any]	chainPart )

Clean the ID configuration for a chainPart dict

Definition at line 218 of file TauConfigurationTools.py.

def getChainIDConfigName(flags: AthConfigFlags, chainPart: dict[str, Any]) -> str:
    '''Clean the ID configuration for a chainPart dict'''
    sel = chainPart['selection']
 
    # Support for the Legacy trigger names:
    if chainPart['reconstruction'] == 'tracktwoMVA':
        if sel in rnn_wps:
            return 'DeepSet'
        elif sel in meson_selections:
            return 'MesonCuts'
    elif chainPart['reconstruction'] in ['tracktwoLLP', 'trackLRT'] and sel in rnn_wps:
        return 'RNNLLP'
 
    return getTauIDAlgorithm(
        flags,
        sel,
    )
 
    return sel
 
 

getChainPrecisionSeqName()

str python.HLT.Tau.TauConfigurationTools.getChainPrecisionSeqName	(	dict[str, Any]	chainPart,
		bool	include_calohits_seq_name = False )

Get the HLT Tau Precision sequence name suffix.
This is also used for the HLT_TrigTauRecMerged_... and HLT_tautrack_... EDM collection names.

Definition at line 239 of file TauConfigurationTools.py.

def getChainPrecisionSeqName(chainPart: dict[str, Any], include_calohits_seq_name: bool = False) -> str:
    '''
    Get the HLT Tau Precision sequence name suffix.
    This is also used for the HLT_TrigTauRecMerged_... and HLT_tautrack_... EDM collection names.
    '''
    ret = chainPart['reconstruction']
 
    # Support for the Legacy trigger names:
    if ret == 'tracktwoMVA': return 'MVA'
    elif ret == 'tracktwoLLP': return 'LLP'
    elif ret == 'trackLRT': return 'LRT'
 
    if include_calohits_seq_name:
        calohits_seq = getChainCaloHitsSeqName(chainPart)
        ret += f'_{calohits_seq}' if calohits_seq else ''
    
    return ret
 
 
 

getChainSequenceConfigName()

str python.HLT.Tau.TauConfigurationTools.getChainSequenceConfigName

(

dict[str, Any]

chainPart

)

Global Tau menu sequence.

Get the HLT Tau signature global menu sequence name (e.g. ptonly, tracktwo, trackLRT, etc...)

Definition at line 263 of file TauConfigurationTools.py.

def getChainSequenceConfigName(chainPart: dict[str, Any]) -> str:
    '''Get the HLT Tau signature global menu sequence name (e.g. ptonly, tracktwo, trackLRT, etc...)'''
    name = []
 
    if chainPart['hitz'] or chainPart['calohitsPresel']:
        name.append('CaloHits')
 
    name.append(chainPart['reconstruction'])
 
    return '_'.join(name)
 

getHitZAlgs()

list[str] python.HLT.Tau.TauConfigurationTools.getHitZAlgs	(	AthConfigFlags	flags,
		str	precision_sequence,
		str | None	alt_precision_sequence = None )

CaloHits sequence algorithms.

Get the list of HitZ algorithms for the CaloHits reco sequence.
The configuration for each algorithm is contained in flags.Trigger.Offline.Tau.<alg>.

Definition at line 81 of file TauConfigurationTools.py.

def getHitZAlgs(flags: AthConfigFlags, precision_sequence: str, alt_precision_sequence: str | None = None) -> list[str]:
    '''
    Get the list of HitZ algorithms for the CaloHits reco sequence.
    The configuration for each algorithm is contained in flags.Trigger.Offline.Tau.<alg>.
    '''
    return getMenuAlgs(
        flags,
        key=precision_sequence,
        alt_key=alt_precision_sequence,
 
        # Default HitZ algorithms to run in all menus
        algs=['HitZ'],
 
        # Additional HitZ algorithms to run ONLY if we're using the MC (or Dev) menu
        mc_algs={},
 
        # Additional HitZ algorithms to run ONLY if we're using the Dev menu
        dev_algs={},
    )
 
 

getHitZConfig()

tuple[str, float] | None python.HLT.Tau.TauConfigurationTools.getHitZConfig	(	AthConfigFlags	flags,
		dict[str, Any]	chainPart )

Get the HLT HitZ configuration tuple: (algorithm name, sigma cut value in mm)

Definition at line 102 of file TauConfigurationTools.py.

def getHitZConfig(flags: AthConfigFlags, chainPart: dict[str, Any]) -> tuple[str, float] | None:
    '''
    Get the HLT HitZ configuration tuple: (algorithm name, sigma cut value in mm)
    '''
    if not chainPart['hitz']: return None
 
    import re
    # Match strings of the form: '10mmX5mmHitZ', '5mmHitZ', 'HitZ', etc...
    match = re.match(r'((?P<sigma>(\d|p)+)mm)?(X(\d|p)+mm)?(?P<alg>.+)', chainPart['hitz'])
    if match:
        alg = match.group('alg')
 
        alg_flags = getattr(flags.Trigger.Offline.Tau, alg, None)
        if alg_flags is None:
            raise ValueError(f'HitZ algorithm "{alg}" configuration not found in flags.Trigger.Offline.Tau.{alg}')
 
        sigma = match.group('sigma')
        if sigma is None: sigma = alg_flags.DefaultMaxZ0Sigma # mm (default value)
        else: sigma = float(sigma.replace('p', '.')) # mm
 
        return (alg, sigma)
    
    raise ValueError(f'Invalid HitZ configuration string: {chainPart["hitz"]}')
 
 

getHitZVariables()

tuple[str, str] python.HLT.Tau.TauConfigurationTools.getHitZVariables

(

str

alg

)

Return the (z, sigma) variable name pair for a given HitZ algorithm

Definition at line 127 of file TauConfigurationTools.py.

def getHitZVariables(alg: str) -> tuple[str, str]:
    '''Return the (z, sigma) variable name pair for a given HitZ algorithm'''
    return (f'{alg}_z0', f'{alg}_z0_sigma')
 
 

getMenuAlgs()

list[str] python.HLT.Tau.TauConfigurationTools.getMenuAlgs	(	AthConfigFlags	flags,
		str | None	key = None,
		str | None	alt_key = None,
		dict[str, list[str]] | list[str] | None	algs = None,
		dict[str, list[str]] | list[str] | None	mc_algs = None,
		dict[str, list[str]] | list[str] | None	dev_algs = None )

Global helper functions.

Get the list of algorithms for a specific menu key; if not found, the alternate key will be tried if provided.

Definition at line 16 of file TauConfigurationTools.py.

) -> list[str]:
    '''Get the list of algorithms for a specific menu key; if not found, the alternate key will be tried if provided.'''
    def _getAlgs(key: str | None):
        if algs is None: ret = None
        elif isinstance(algs, dict): ret = algs[key] if key in algs else None
        else: ret = algs # list
        if any(pfx in flags.Trigger.triggerMenuSetup for pfx in ['MC_', 'Dev_']) and mc_algs and (isinstance(mc_algs, list) or key in mc_algs):
            if ret is None: ret = []
            ret += mc_algs[key] if isinstance(mc_algs, dict) else mc_algs
        if 'Dev_' in flags.Trigger.triggerMenuSetup and dev_algs and (isinstance(dev_algs, list) or key in dev_algs):
            if ret is None: ret = []
            ret += dev_algs[key] if isinstance(dev_algs, dict) else dev_algs
        return ret
 
    ret_algs = _getAlgs(key)
    if ret_algs is None and alt_key is not None:
        ret_algs = _getAlgs(alt_key)
    return ret_algs
    
 
 

getPrecisionSequenceTauIDs()

list[str] python.HLT.Tau.TauConfigurationTools.getPrecisionSequenceTauIDs	(	AthConfigFlags	flags,
		str	precision_sequence,
		str | None	alt_precision_sequence = None )

Precision sequence TauIDs.

Get the list of precision TauID inferences to be executed for each HLT tau trigger reco sequence
The configuration for each algorithm is contained in flags.Trigger.Offline.Tau.<alg>.

Definition at line 184 of file TauConfigurationTools.py.

def getPrecisionSequenceTauIDs(flags: AthConfigFlags, precision_sequence: str, alt_precision_sequence: str | None = None) -> list[str]:
    '''
    Get the list of precision TauID inferences to be executed for each HLT tau trigger reco sequence
    The configuration for each algorithm is contained in flags.Trigger.Offline.Tau.<alg>.
    '''
    return getMenuAlgs(
        flags,
        key=precision_sequence,
        alt_key=alt_precision_sequence,
 
        # Default Tau ID algorithms to run in all menus
        algs={
            'MVA': ['GNTau', 'MesonCuts', 'GNTauDev1'],
            'LLP': ['RNNLLP'],
            'LRT': ['RNNLLP'],
        },
 
        # Additional Tau ID algorithms to run ONLY if we're using the MC (or Dev) menu
        mc_algs={
            'MVA': ['DeepSet'],
        },
 
        # Additional Tau ID algorithms to run ONLY if we're using the Dev menu
        dev_algs={
        }
    )
 
 
# The following functions are only required while  we still have triggers
# with the RNN/DeepSet naming scheme in the Menu (e.g. mediumRNN_tracktwoMVA/LLP)

getTauIDAlgorithm()

str python.HLT.Tau.TauConfigurationTools.getTauIDAlgorithm	(	AthConfigFlags	flags,
		str	selection,
		tuple[tuple[str, str], ...] | None	name_mapping = None )

Definition at line 59 of file TauConfigurationTools.py.

                      name_mapping: tuple[tuple[str, str], ...] | None = None) -> str:
 
    # Sort ID names from longest to shortest, to check for a full match
    tau_ids = sorted(flags.Trigger.Offline.Tau, key=len, reverse=True)
    for tau_id in tau_ids:
        if selection.endswith(tau_id): return tau_id
 
    # Remap names (e.g. DS -> DeepSet)
    if name_mapping:
        name_mapping = sorted(name_mapping, key=lambda p: len(p[0]), reverse=True)
        for short_name, long_name in name_mapping:
            if selection.endswith(short_name): return long_name
    
    return selection
 
 
 

getTauIDScoreVariables()

tuple[str, str] python.HLT.Tau.TauConfigurationTools.getTauIDScoreVariables

(

str

tau_id

)

Return the (score, score_sig_trans) variable name pair for a given TauID/Sequence configuration

Definition at line 50 of file TauConfigurationTools.py.

def getTauIDScoreVariables(tau_id: str) -> tuple[str, str]:
    '''Return the (score, score_sig_trans) variable name pair for a given TauID/Sequence configuration'''
    # Support for "legacy" algorithms, where the scores are stored in the built-in TauJet aux variables
    if useBuiltInTauJetRNNScore(tau_id): return ('RNNJetScore', 'RNNJetScoreSigTrans')
 
    return (f'{tau_id}_Score', f'{tau_id}_ScoreSigTrans')
 
 
@AccumulatorCache  # called many times and looping over flags is slow

useBuiltInTauJetRNNScore()

bool python.HLT.Tau.TauConfigurationTools.useBuiltInTauJetRNNScore

(

str

tau_id

)

Check if the TauJet's built-in RNN score and WP variables have to be used, instead of the decorator-based variables

Definition at line 44 of file TauConfigurationTools.py.

def useBuiltInTauJetRNNScore(tau_id: str) -> bool:
    '''Check if the TauJet's built-in RNN score and WP variables have to be used, instead of the decorator-based variables'''
    # Support for "legacy" algorithms, where the scores are stored in the built-in TauJet aux variables
    return tau_id in ['DeepSet', 'RNNLLP']
 
 

Variable Documentation

log

python.HLT.Tau.TauConfigurationTools.log = logging.getLogger(__name__)

Definition at line 8 of file TauConfigurationTools.py.

meson_selections

list python.HLT.Tau.TauConfigurationTools.meson_selections = ['kaonpi1', 'kaonpi2', 'dipion1', 'dipion2', 'dipion3', 'dipion4', 'dikaonmass', 'singlepion']

Definition at line 216 of file TauConfigurationTools.py.

noid_selections

list python.HLT.Tau.TauConfigurationTools.noid_selections = ['perf', 'idperf']

Definition at line 215 of file TauConfigurationTools.py.

rnn_wps

list python.HLT.Tau.TauConfigurationTools.rnn_wps = ['verylooseRNN', 'looseRNN', 'mediumRNN', 'tightRNN']

Definition at line 214 of file TauConfigurationTools.py.