HLTSeedingConfig Namespace Reference

Functions
	mapThresholdToL1DecisionCollection (threshold)
	mapThresholdToL1RoICollection (threshold)
	createLegacyCaloRoIUnpackers (flags)
	createCaloRoIUnpackers (flags)
	createLegacyMuonRoIUnpackers (flags)
	createMuonRoIUnpackers (flags)
	createPrescalingTool (flags)
	createKeyWriterTool ()
	L1TriggerResultMakerCfg (flags)
	HLTSeedingCfg (flags, seqName=None)

Variables
	log = logging.getLogger('HLTSeedingConfig')
dict	_mapL1ThresholdToDecisionCollection
dict	_mapL1ThresholdToRoICollection
	flags = initConfigFlags()
	forceEnableAllChains
	Files
	AtlasVersion
	acc = HLTSeedingCfg( flags )

Function Documentation

createCaloRoIUnpackers()

HLTSeedingConfig.createCaloRoIUnpackers

(

flags

)

Definition at line 126 of file HLTSeedingConfig.py.

def createCaloRoIUnpackers(flags):
    from HLTSeeding.HLTSeedingMonitoring import RoIsUnpackingMonitoring
    tools = []
 
    if flags.Trigger.L1.doeFex:
        maxRoICount_eFex = 150  # used for histogram range, 144 is the hardware limit
        eFexEMUnpacker = CompFactory.eFexEMRoIsUnpackingTool(
            Decisions = mapThresholdToL1DecisionCollection("eEM"),
            DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEeEM"),
            OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("eEM")),
            RoIHalfWidthEta = 0.2,
            RoIHalfWidthPhi = 0.2,
            MonTool = RoIsUnpackingMonitoring(flags, prefix="eEM", maxCount=maxRoICount_eFex, maxEta=2.5))
        eFexTauUnpacker = CompFactory.eFexTauRoIsUnpackingTool(
            Decisions = mapThresholdToL1DecisionCollection("eTAU"),
            DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEeTAU"),
            OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("eTAU")),
            RoIHalfWidthEta = 0.4,
            RoIHalfWidthPhi = math.pi/8,
            MonTool = RoIsUnpackingMonitoring(flags, prefix="eTAU", maxCount=maxRoICount_eFex, maxEta=2.5))
        tools += [eFexEMUnpacker, eFexTauUnpacker]
 
    if flags.Trigger.L1.dojFex:
        maxRoICount_jFex = 200  # used for histogram range
        jFexEMUnpacker = CompFactory.jFexFwdElRoIsUnpackingTool(
            Decisions = mapThresholdToL1DecisionCollection("jEM"),
            DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEjEM"),
            OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("jEM")),
            RoIHalfWidthEta = 0.4,
            RoIHalfWidthPhi = math.pi/8,
            MonTool = RoIsUnpackingMonitoring(flags, prefix="jEM", maxCount=maxRoICount_jFex))
        jFexTauUnpacker = CompFactory.jFexTauRoIsUnpackingTool(
            Decisions = mapThresholdToL1DecisionCollection("jTAU"),
            DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEjTAU"),
            OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("jTAU")),
            RoIHalfWidthEta = 0.4,
            RoIHalfWidthPhi = math.pi/8,
            MonTool = RoIsUnpackingMonitoring(flags, prefix="jTAU", maxCount=maxRoICount_jFex))
        jFexSRJetUnpacker = CompFactory.jFexSRJetRoIsUnpackingTool(
            Decisions = mapThresholdToL1DecisionCollection("jJ"),
            OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("jJ")),
            RoIHalfWidthEta = 0.1,
            RoIHalfWidthPhi = 0.1,
            MonTool = RoIsUnpackingMonitoring(flags, prefix="jJ", maxCount=maxRoICount_jFex, maxEta=5))
        jFexLRJetUnpacker = CompFactory.jFexLRJetRoIsUnpackingTool(
            Decisions = mapThresholdToL1DecisionCollection("jLJ"),
            OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("jLJ")),
            RoIHalfWidthEta = 0.1,
            RoIHalfWidthPhi = 0.1,
            MonTool = RoIsUnpackingMonitoring(flags, prefix="jLJ", maxCount=maxRoICount_jFex, maxEta=5))
        tools += [jFexEMUnpacker, jFexTauUnpacker, jFexSRJetUnpacker, jFexLRJetUnpacker]
 
    if flags.Trigger.L1.dogFex:
        maxRoICount_gFex = 100  # used for histogram range
        gFexSRJetUnpacker = CompFactory.gFexSRJetRoIsUnpackingTool(
            Decisions = mapThresholdToL1DecisionCollection("gJ"),
            OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("gJ")),
            RoIHalfWidthEta = 0.1,
            RoIHalfWidthPhi = 0.1,
            MonTool = RoIsUnpackingMonitoring(flags, prefix="gJ", maxCount=maxRoICount_gFex, maxEta=5))
        gFexLRJetUnpacker = CompFactory.gFexLRJetRoIsUnpackingTool(
            Decisions = mapThresholdToL1DecisionCollection("gLJ"),
            OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("gLJ")),
            RoIHalfWidthEta = 0.1,
            RoIHalfWidthPhi = 0.1,
            MonTool = RoIsUnpackingMonitoring(flags, prefix="gLJ", maxCount=maxRoICount_gFex, maxEta=5))
        tools += [gFexSRJetUnpacker, gFexLRJetUnpacker]
 
    # Need both eFex and jFex for cTAU
    if flags.Trigger.L1.doeFex and flags.Trigger.L1.dojFex:
        maxRoICount_eFex = 150  # used for histogram range
        cTauUnpacker = CompFactory.cTauRoIsUnpackingTool(
            Decisions = mapThresholdToL1DecisionCollection("cTAU"),
            DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEcTAU"),
            OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("cTAU")),
            RoIHalfWidthEta = 0.4,
            RoIHalfWidthPhi = math.pi/8,
            MonTool = RoIsUnpackingMonitoring(flags, prefix="cTAU", maxCount=maxRoICount_eFex))
        tools += [cTauUnpacker]
 
    return tools
 

createKeyWriterTool()

HLTSeedingConfig.createKeyWriterTool

(

)

Definition at line 235 of file HLTSeedingConfig.py.

def createKeyWriterTool():
    keyWriter = CompFactory.getComp('TrigConf::KeyWriterTool')('KeyWriterToolOnline')
    keyWriter.ConfKeys = 'TrigConfKeysOnline'
    keyWriter.IncludeL1PrescaleKey = False
    keyWriter.IncludeBunchgroupKey = False
    return keyWriter
 

createLegacyCaloRoIUnpackers()

HLTSeedingConfig.createLegacyCaloRoIUnpackers

(

flags

)

Definition at line 103 of file HLTSeedingConfig.py.

def createLegacyCaloRoIUnpackers(flags):
    from HLTSeeding.HLTSeedingMonitoring import RoIsUnpackingMonitoring
    emUnpacker = CompFactory.EMRoIsUnpackingTool(Decisions = mapThresholdToL1DecisionCollection("EM"),
                                                 DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEEM"),
                                                 OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("EM")),
                                                 MonTool = RoIsUnpackingMonitoring( flags, prefix="EM", maxCount=30, etaOffset=0.05, phiOffset=math.pi/64., maxEta=2.5 ))
 
    metUnpacker = CompFactory.METRoIsUnpackingTool(Decisions = mapThresholdToL1DecisionCollection("XE"))
 
 
    tauUnpacker = CompFactory.TAURoIsUnpackingTool(Decisions = mapThresholdToL1DecisionCollection("TAU"),
                                                   DecisionsProbe = mapThresholdToL1DecisionCollection("PROBETAU"),
                                                   OutputTrigRoIs = recordable("HLT_TAURoI"))
 
    tauUnpacker.MonTool = RoIsUnpackingMonitoring( flags, prefix="TAU", maxCount=30, etaOffset=0.05, phiOffset=math.pi/64., maxEta=2.5  )
 
    jUnpacker = CompFactory.JRoIsUnpackingTool(Decisions = mapThresholdToL1DecisionCollection("J"),
                                               OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("J")) )
 
    jUnpacker.MonTool = RoIsUnpackingMonitoring( flags, prefix="J", maxCount=30, maxEta=5 )
 
    return [emUnpacker, metUnpacker, tauUnpacker, jUnpacker ]
 

createLegacyMuonRoIUnpackers()

HLTSeedingConfig.createLegacyMuonRoIUnpackers

(

flags

)

Definition at line 208 of file HLTSeedingConfig.py.

def createLegacyMuonRoIUnpackers(flags):
    from HLTSeeding.HLTSeedingMonitoring import RoIsUnpackingMonitoring
    muUnpacker = CompFactory.MURoIsUnpackingTool(
        Decisions = mapThresholdToL1DecisionCollection("MU"),
        DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEMU"),
        OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("MU")),
        MonTool = RoIsUnpackingMonitoring(flags, prefix="MU", maxCount=20))
 
    return [muUnpacker]
 

createMuonRoIUnpackers()

HLTSeedingConfig.createMuonRoIUnpackers

(

flags

)

Definition at line 218 of file HLTSeedingConfig.py.

def createMuonRoIUnpackers(flags):
    from HLTSeeding.HLTSeedingMonitoring import RoIsUnpackingMonitoring
    muUnpacker = CompFactory.MuonRoIsUnpackingTool(
        Decisions = mapThresholdToL1DecisionCollection("MU"),
        DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEMU"),
        OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("MU")),
        RoIHalfWidthEta = 0.1,
        RoIHalfWidthPhi = 0.1,
        MonTool = RoIsUnpackingMonitoring(flags, prefix="MU", maxCount=20))
    return [muUnpacker]
 

createPrescalingTool()

HLTSeedingConfig.createPrescalingTool

(

flags

)

Definition at line 229 of file HLTSeedingConfig.py.

def createPrescalingTool(flags):
    from HLTSeeding.HLTSeedingMonitoring import PrescalingMonitoring
 
    prescaler = CompFactory.PrescalingTool(MonTool = PrescalingMonitoring(flags))
    return prescaler
 

HLTSeedingCfg()

HLTSeedingConfig.HLTSeedingCfg	(		flags,
			seqName = None )

Definition at line 316 of file HLTSeedingConfig.py.

def HLTSeedingCfg(flags, seqName = None):
    if seqName:
        from AthenaCommon.CFElements import parOR
        acc = ComponentAccumulator(sequence=parOR(seqName)) # TODO - once rec-ex-common JO are phased out this can also be dropped
    else:
        acc = ComponentAccumulator()
 
    from HLTSeeding.HLTSeedingMonitoring import CTPUnpackingMonitoring, L1DataConsistencyMonitoring
    decoderAlg = CompFactory.HLTSeeding(
        RoIBResult = "RoIBResult", # Not yet ready to disable, see ATR-29954
        L1TriggerResult = "L1TriggerResult" if flags.Trigger.enableL1MuonPhase1 or flags.Trigger.enableL1CaloPhase1 else "",
        HLTSeedingSummaryKey = "HLTSeedingSummary", # Transient, consumed by DecisionSummaryMakerAlg
        ctpUnpacker = CompFactory.CTPUnpackingTool( ForceEnableAllChains = flags.Trigger.forceEnableAllChains,
                                                    MonTool = CTPUnpackingMonitoring(flags, 512, 400),
                                                    UseEDMxAOD = flags.Trigger.CTP.UseEDMxAOD )
    )
 
    # Add L1DataConsistencyChecker unless we forceEnableAllChains which always results in missing TOBs
    if not (flags.Trigger.forceEnableAllChains or flags.Trigger.disableL1ConsistencyChecker):
        def checkConsistency(thrName):
            '''Filter out threshold types for which HLT doesn't read TOBs from L1 readout'''
            return thrName not in ['FSNOSEED','TE','XE','XS'] and not thrName.startswith('PROBE')
 
        decoderAlg.L1DataConsistencyChecker = CompFactory.L1DataConsistencyChecker(
            ThresholdToDecisionMap = dict([(k,v) for k,v in _mapL1ThresholdToDecisionCollection.items() if checkConsistency(k)]),
            MonTool = L1DataConsistencyMonitoring(flags),
            ErrorOnMissingTOB = flags.Trigger.L1.errorOnMissingTOB )
 
    #Transient bytestream
    from AthenaConfiguration.Enums import Format
    if flags.Input.Format is Format.POOL:
        transTypeKey = ("TransientBSOutType","StoreGateSvc+TransientBSOutKey")
        decoderAlg.ExtraInputs.add(transTypeKey)
 
    decoderAlg.RoIBRoIUnpackers += [
        CompFactory.FSRoIsUnpackingTool("FSRoIsUnpackingTool", Decisions=mapThresholdToL1DecisionCollection("FSNOSEED"),
                                        OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("FSNOSEED")) ) ]
 
    if flags.Trigger.L1.doCalo:
        if flags.Trigger.enableL1CaloPhase1:
            decoderAlg.xAODRoIUnpackers += createCaloRoIUnpackers(flags)
        if flags.Trigger.enableL1CaloLegacy:
            decoderAlg.RoIBRoIUnpackers += createLegacyCaloRoIUnpackers(flags)
 
    if flags.Trigger.L1.doMuon:
        if flags.Trigger.enableL1MuonPhase1:
            decoderAlg.xAODRoIUnpackers += createMuonRoIUnpackers(flags)
        else:
            decoderAlg.RoIBRoIUnpackers += createLegacyMuonRoIUnpackers(flags)
 
    decoderAlg.prescaler = createPrescalingTool(flags)
    decoderAlg.KeyWriterTool = createKeyWriterTool()
    decoderAlg.DoCostMonitoring = flags.Trigger.CostMonitoring.doCostMonitoring
    decoderAlg.CostMonitoringChain = flags.Trigger.CostMonitoring.chain
    decoderAlg.RoiZedWidthDefault = flags.Trigger.InDetTracking.RoiZedWidthDefault
 
    if flags.Input.Format is Format.BS and not flags.Trigger.doLVL1:
        # Add the algorithm decoding ByteStream into xAOD (Run-3 L1) and/or RoIBResult (legacy L1)
        from TrigT1ResultByteStream.TrigT1ResultByteStreamConfig import L1TriggerByteStreamDecoderCfg
        acc.merge( L1TriggerByteStreamDecoderCfg(flags), sequenceName = seqName )
 
    # Add the algorithm creating L1TriggerResult which is the input to HLTSeeding (Run-3 L1)
    if flags.Trigger.enableL1MuonPhase1 or flags.Trigger.enableL1CaloPhase1 or flags.Trigger.CTP.UseEDMxAOD:
        acc.merge( L1TriggerResultMakerCfg(flags), sequenceName = seqName )
 
    acc.addEventAlgo( decoderAlg, sequenceName = seqName )
 
    from TrigConfigSvc.TrigConfigSvcCfg import TrigConfigSvcCfg, HLTPrescaleCondAlgCfg
    acc.merge( TrigConfigSvcCfg( flags ) )
    acc.merge( HLTPrescaleCondAlgCfg( flags ) )
 
    # Configure ROB prefetching from initial RoIs
    from TriggerJobOpts.TriggerConfigFlags import ROBPrefetching
    if ROBPrefetching.InitialRoI in flags.Trigger.ROBPrefetchingOptions:
        allDecisionsSet = set()
        for roiUnpacker in decoderAlg.RoIBRoIUnpackers + decoderAlg.xAODRoIUnpackers:
            dec = str(roiUnpacker.Decisions)
            if dec:
                allDecisionsSet.add(dec)
        allDecisions = sorted(list(allDecisionsSet))
        from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Si, ROBPrefetchingAlgCfg_Calo, ROBPrefetchingAlgCfg_Muon
        acc.merge(ROBPrefetchingAlgCfg_Si(flags, "initialRoI", RoILinkName="initialRoI", ROBPrefetchingInputDecisions=allDecisions), sequenceName=seqName)
        acc.merge(ROBPrefetchingAlgCfg_Calo(flags,"initialRoI", RoILinkName="initialRoI", ROBPrefetchingInputDecisions=allDecisions), sequenceName=seqName)
        acc.merge(ROBPrefetchingAlgCfg_Muon(flags,"initialRoI", RoILinkName="initialRoI", ROBPrefetchingInputDecisions=allDecisions), sequenceName=seqName)
 
    return acc
 
 

L1TriggerResultMakerCfg()

HLTSeedingConfig.L1TriggerResultMakerCfg

(

flags

)

Definition at line 242 of file HLTSeedingConfig.py.

def L1TriggerResultMakerCfg(flags):
    acc = ComponentAccumulator()
 
    # Reset properties to empty by default and fill based on flags below
    l1trMaker = CompFactory.L1TriggerResultMaker(
        MuRoIKeys = [],
        eFexEMRoIKeys = [],
        eFexTauRoIKeys = [],
        jFexFwdElRoIKeys = [],
        jFexTauRoIKeys = [],
        jFexSRJetRoIKeys = [],
        jFexLRJetRoIKeys = [],
        gFexSRJetRoIKeys = [],
        gFexLRJetRoIKeys = [],
        cTauRoIKey = "",
        cjTauLinkKey = "",
        CTPKey = "",
        ThresholdPatternTools = [] )
 
    # CTPResult
    if flags.Trigger.L1.doCTP and flags.Trigger.CTP.UseEDMxAOD:
        l1trMaker.CTPKey = "CTPResult"
 
    # Muon RoIs
    if flags.Trigger.L1.doMuon and flags.Trigger.enableL1MuonPhase1:
        l1trMaker.MuRoIKeys = ["LVL1MuonRoIs"]
        from TrigT1MuctpiPhase1.TrigT1MuctpiPhase1Config import TrigThresholdDecisionToolCfg
        l1trMaker.ThresholdPatternTools += [acc.popToolsAndMerge(TrigThresholdDecisionToolCfg(flags))]
    elif flags.Trigger.L1.doMuon and flags.Trigger.enableL0Muon:   # Run-4+
        l1trMaker.MuRoIKey = "LVL1MuonRoIs"
        l1trMaker.ThresholdPatternTools += [CompFactory.MURoIThresholdsTool()]
 
    # L1Calo RoIs
    if flags.Trigger.L1.doCalo and flags.Trigger.enableL1CaloPhase1:
        if flags.Trigger.L1.doeFex:
            l1trMaker.eFexEMRoIKeys = ["L1_eEMRoI"]
            l1trMaker.eFexTauRoIKeys = ["L1_eTauRoI"]
            l1trMaker.ThresholdPatternTools += [
                CompFactory.eFexEMRoIThresholdsTool(),
                CompFactory.eFexTauRoIThresholdsTool(),
            ]
        if flags.Trigger.L1.dojFex:
            l1trMaker.jFexFwdElRoIKeys = ["L1_jFexFwdElRoI"]
            l1trMaker.jFexTauRoIKeys = ["L1_jFexTauRoI"]
            l1trMaker.jFexSRJetRoIKeys = ["L1_jFexSRJetRoI"]
            l1trMaker.jFexLRJetRoIKeys = ["L1_jFexLRJetRoI"]
            l1trMaker.ThresholdPatternTools += [
                CompFactory.jFexFwdElRoIThresholdsTool(),
                CompFactory.jFexTauRoIThresholdsTool(),
                CompFactory.jFexSRJetRoIThresholdsTool(),
                CompFactory.jFexLRJetRoIThresholdsTool(),
            ]
        if flags.Trigger.L1.dogFex:
            l1trMaker.gFexSRJetRoIKeys = ["L1_gFexSRJetRoI"]
            l1trMaker.gFexLRJetRoIKeys = ["L1_gFexLRJetRoI"]
            l1trMaker.ThresholdPatternTools += [
                CompFactory.gFexSRJetRoIThresholdsTool(),
                CompFactory.gFexLRJetRoIThresholdsTool(),
            ]
        # Need both eFex and jFex for cTAU
        if flags.Trigger.L1.doeFex and flags.Trigger.L1.dojFex:
            l1trMaker.cTauRoIKey = "L1_cTauRoI"  # Note: WriteHandle
            l1trMaker.cjTauLinkKey = "L1_cTauRoI.jTauLink"  # Note: WriteDecorHandle
            l1trMaker.ThresholdPatternTools += [
                CompFactory.cTauRoIThresholdsTool(),
            ]
 
    # Placeholder for other L1 xAOD outputs:
    # - L1Topo result
 
    acc.addEventAlgo(l1trMaker, primary=True)
    return acc
 
 

mapThresholdToL1DecisionCollection()

HLTSeedingConfig.mapThresholdToL1DecisionCollection

(

threshold

)

Translates L1 threshold  name of the DecisionsContainer name in the HLTSeeding unpacking tools

Definition at line 79 of file HLTSeedingConfig.py.

def mapThresholdToL1DecisionCollection(threshold):
    """
    Translates L1 threshold  name of the DecisionsContainer name in the HLTSeeding unpacking tools
    """
    # remove actual threshold value from L1 threshold string
    for (thresholdType, l1Collection) in _mapL1ThresholdToDecisionCollection.items():
        if threshold.startswith( thresholdType ):
            return l1Collection
 
    log.error("Threshold \""+ threshold + "\" not mapped to any Decision collection! Available are: " + str(_mapL1ThresholdToDecisionCollection.values()))
 
 

mapThresholdToL1RoICollection()

HLTSeedingConfig.mapThresholdToL1RoICollection

(

threshold

)

Translates L1 threshold  name of the RoIDescriptor name in the HLTSeeding unpacking tools

Definition at line 91 of file HLTSeedingConfig.py.

def mapThresholdToL1RoICollection(threshold):
    """
    Translates L1 threshold  name of the RoIDescriptor name in the HLTSeeding unpacking tools
    """
    # remove actual threshold value from L1 threshold string
    for (thresholdType, l1Collection) in _mapL1ThresholdToRoICollection.items():
        if threshold.startswith( thresholdType ):
            return l1Collection
 
    log.error("Threshold \""+ threshold + "\" not mapped to any ROI collection! Available are: " + str(_mapL1ThresholdToRoICollection.values()))
 
 

Variable Documentation

_mapL1ThresholdToDecisionCollection

dict HLTSeedingConfig._mapL1ThresholdToDecisionCollection

protected

Definition at line 14 of file HLTSeedingConfig.py.

_mapL1ThresholdToRoICollection

dict HLTSeedingConfig._mapL1ThresholdToRoICollection

protected

Definition at line 46 of file HLTSeedingConfig.py.

acc

HLTSeedingConfig.acc = HLTSeedingCfg( flags )

Definition at line 413 of file HLTSeedingConfig.py.

AtlasVersion

HLTSeedingConfig.AtlasVersion

Definition at line 411 of file HLTSeedingConfig.py.

Files

HLTSeedingConfig.Files

Definition at line 410 of file HLTSeedingConfig.py.

flags

HLTSeedingConfig.flags = initConfigFlags()

Definition at line 408 of file HLTSeedingConfig.py.

forceEnableAllChains

HLTSeedingConfig.forceEnableAllChains

Definition at line 409 of file HLTSeedingConfig.py.

log

HLTSeedingConfig.log = logging.getLogger('HLTSeedingConfig')

Definition at line 12 of file HLTSeedingConfig.py.