コード例 #1
0
  def generatePyCode(self, algos):
    #create python code to be executed
    alglist = "["
    for i in algos:
      #self.__algos__.append(i)
      algline = self._item_line(i[0], i[1])
      alglist += algline+',' 
    alglist += "]"

    #this should be avoided by a higher level steering
    #    modify the sequence acoording to triggerflags
    from TriggerJobOpts.TriggerFlags  import TriggerFlags

    if not ( TriggerFlags.doEF() or TriggerFlags.doHLT() ) or not TriggerFlags.doFEX():
      from TrigSteeringTest.TrigSteeringTestConf import PESA__dummyAlgo as dummyAlgo_disabledByTriggerFlags_EFID
      dummyAlgEFID = dummyAlgo_disabledByTriggerFlags_EFID("doEF_or_doFEX_False_no_EFID")
      alglist = '[dummyAlgEFID]'

    algseq = []
    try:
      algseq = eval (alglist)
    except:
      from sys import exc_info
      (a,reason,c) = exc_info()
      print (reason)
      log.error("Cannot create ID tracking sequence %s, leaving empty" % alglist)
      import traceback
      traceback.print_exc()

      #raise Exception

    log.debug('%s ' % algseq)  

    self.__sequence__.append(algseq)
    pass
コード例 #2
0
    def __init__(self, seqName="Tau", type="tau", seqType="InsideOut"):
        """
    @param[in] seqName  which enters into the sequence name inbetween
    algorithmName_seqName_EFID can be freely modified
    
    @param[in] type     which is a slice name and is used to set up slice
    specific variables
    
    @param[in] seqType  the type of sequence - it can be one of InsideOut,
    OutsideIn, TRTOnly, Combined,....
    """
        #print "TrigEFIDSequence  seqName=%s type=%s seqType=%s" % (seqName,type,seqType)
        algos = []

        from TrigInDetConf.TrigInDetSequence import vertexXAODCnvNeeded
        runvtxxaodcnv = vertexXAODCnvNeeded()

        if seqType == "InsideOut":
            algos = [
                ("PixelClustering", ""),
                ("SCTClustering", ""),
                ("TRTDriftCircleMaker", ""),
                ("InDetTrigPRD_MultiTruthMaker", ""),
                ("SiTrigSpacePointFinder", ""),
                ("SiTrigTrackFinder", ""),
                ("TrigAmbiguitySolver", ""),
                ("TRTTrackExtAlg", ""),
                ("TrigExtProcessor", ""),
                ("InDetTrigTrackSlimmer", ""),
                ("InDetTrigTrackingxAODCnv", ""),
                #               ("InDetTrigDetailedTrackTruthMaker",""),
                ("TrigVxPrimary", ""),
                #               ("InDetTrigParticleCreation",""),
                #               ("InDetTrigTrackParticleTruthMaker",""),
            ]

            if runvtxxaodcnv:
                algos += [("InDetTrigVertexxAODCnv", "")]

            if type == "minBias" or type == "minBias400":
                algos = [
                    ("PixelClustering", ""),
                    ("SCTClustering", ""),
                    ("InDetTrigPRD_MultiTruthMaker", ""),
                    ("SiTrigSpacePointFinder", ""),
                    ("SiTrigTrackFinder", ""),
                    ("TrigAmbiguitySolver", ""),
                    ("InDetTrigTrackSlimmer", ""),
                    ("InDetTrigTrackingxAODCnv", ""),
                    ("TrigVxPrimary", ""),
                    #                 ("InDetTrigParticleCreation",""),
                ]
                if runvtxxaodcnv:
                    algos += [("InDetTrigVertexxAODCnv", "")]

            elif type == "bjet":
                #from InDetTrigVxSecondary.InDetTrigVxSecondary_LoadTools import TrigVxSecondary_EF
                #algos += [("TrigVxSecondary","")]
                algos = [
                    ("PixelClustering", ""),
                    ("SCTClustering", ""),
                    ("TRTDriftCircleMaker", ""),
                    ("InDetTrigPRD_MultiTruthMaker", ""),
                    ("SiTrigSpacePointFinder", ""),
                    ("SiTrigTrackFinder", ""),
                    ("TrigAmbiguitySolver", ""),
                    ("TRTTrackExtAlg", ""),
                    ("TrigExtProcessor", ""),
                    ("InDetTrigTrackSlimmer", ""),
                    ("InDetTrigTrackingxAODCnv", ""),
                    ("InDetTrigDetailedTrackTruthMaker", ""),
                    ("TrigVxPrimary", ""),
                    #                 ("InDetTrigParticleCreation",""),
                    ("InDetTrigTrackParticleTruthMaker", "")
                ]
                if runvtxxaodcnv:
                    algos += [("InDetTrigVertexxAODCnv", "")]

        elif seqType == "InsideOutTrk":
            algos = [("PixelClustering", ""), ("SCTClustering", ""),
                     ("TRTDriftCircleMaker", ""),
                     ("InDetTrigPRD_MultiTruthMaker", ""),
                     ("SiTrigSpacePointFinder", ""), ("SiTrigTrackFinder", ""),
                     ("TrigAmbiguitySolver", ""), ("TRTTrackExtAlg", ""),
                     ("TrigExtProcessor", ""), ("InDetTrigTrackSlimmer", ""),
                     ("InDetTrigTrackingxAODCnv", ""),
                     ("InDetTrigDetailedTrackTruthMaker", "")]

        elif seqType == "Vtx":
            algos = [("TrigVxPrimary", "")]
            if type == "bjet":
                algos = [("TrigVxPrimaryAllTE", "")]
                if runvtxxaodcnv:
                    algos += [("InDetTrigVertexxAODCnv", "")]

        elif seqType == "InsideOutPost":
            algos = [
                #("InDetTrigParticleCreation",""),
                ("InDetTrigTrackingxAODCnv", ""),
                ("InDetTrigTrackParticleTruthMaker", "")
            ]

        elif seqType == "InsideOutNoTRT":
            a1 = [
                ("PixelClustering", ""),
                ("SCTClustering", ""),
                ("InDetTrigPRD_MultiTruthMaker", ""),
                ("SiTrigSpacePointFinder", ""),
                ("SiTrigTrackFinder", ""),
                ("TrigAmbiguitySolver", ""),
                ("InDetTrigTrackSlimmer", ""),
                ("InDetTrigTrackingxAODCnv", ""),
                ("InDetTrigDetailedTrackTruthMaker", ""),
            ]
            av = [("TrigVxPrimary", "")]
            if runvtxxaodcnv:
                av += [("InDetTrigVertexxAODCnv", "")]

            a2 = [
                #("InDetTrigParticleCreation",""),
                ("InDetTrigTrackParticleTruthMaker", "")
            ]
            if type == "heavyIon" or type == "heavyIonFS":
                algos = a1 + a2
            else:
                algos = a1 + av + a2

        elif seqType == "InsideOutLowPt":
            algos = [
                ("PixelClustering", ""),
                ("SCTClustering", ""),
                ("InDetTrigPRD_MultiTruthMaker", ""),
                ("SiTrigSpacePointFinder", ""),
                ("SiTrigTrackFinder", ""),
                ("TrigAmbiguitySolver", ""),
                ("InDetTrigTrackPRD_Association", ""),
                ("SiTrigSpacePointFinderLowPt", ""),
                ("SiTrigTrackFinderLowPt", ""),
                ("TrigAmbiguitySolverLowPt", ""),
                ("SimpleTrigTrackCollMerger", ""),
                ("InDetTrigTrackSlimmer", ""),
                ("InDetTrigTrackingxAODCnv", ""),
                ("TrigVxPrimary", ""),
                #("InDetTrigParticleCreation",""),
            ]
            if runvtxxaodcnv:
                algos += [("InDetTrigVertexxAODCnv", "")]

        elif seqType == "OutsideIn":
            algos = [
                ("PixelClustering", ""),
                ("SCTClustering", ""),
                ("TRTDriftCircleMaker", ""),
                ("InDetTrigPRD_MultiTruthMaker", ""),
                ("SiTrigSpacePointFinder", ""),
                ("TRT_TrigTrackSegmentsFinder",
                 "InDetTrigTRT_TrackSegmentsFinder_%s_EFID"),
                ("TRT_TrigSeededTrackFinder",
                 "InDetTrigTRT_SeededTrackFinder_%s_EFID"),
                ("TRTSeededTrigAmbiguitySolver", ""),
                ("InDetTrigTrackSlimmer", ""),
                ("InDetTrigTrackingxAODCnv", ""),
                ("InDetTrigDetailedTrackTruthMaker", ""),
                #("InDetTrigParticleCreation",""),
                ("InDetTrigTrackParticleTruthMaker", "")
            ]

        elif seqType == "TRTOnly":
            algos = [
                ("TRTDriftCircleMaker", ""),
                ("InDetTrigPRD_MultiTruthMaker", ""),
                ("TRT_TrigTrackSegmentsFinder",
                 "InDetTrigTRT_TrackSegmentsFinder_%s_EFID"),
                ("InDetTrigTrackPRD_Association",
                 "InDetTrigTRTStandalonePRD_Association_%s_EFID"),
                ("TRT_TrigStandaloneTrackFinder",
                 "InDetTrigTRT_StandaloneTrackFinder_%s_EFID"),
                ("InDetTrigTrackSlimmer",
                 "InDetTrigTrackSlimmerTRTOnly_%s_EFID"),
                ("InDetTrigTrackingxAODCnv",
                 "InDetTrigTrackingxAODCnvTRTOnly_%s_EFID"),
                ("InDetTrigDetailedTrackTruthMaker",
                 "InDetTrigDetailedTrackTruthMakerTRTOnly_%s_EFID"),
                ("TrigVxPrimary", "TrigVxPrimaryTRTOnly_%s_EFID"),
                #("InDetTrigParticleCreation",        "InDetTrigParticleCreationTRTOnly_%s_EFID"),
                ("InDetTrigTrackParticleTruthMaker",
                 "InDetTrigTrackParticleTruthMakerTRTOnly_%s_EFID")
            ]
            if runvtxxaodcnv:
                algos += [("InDetTrigVertexxAODCnv",
                           "InDetTrigVertexxAODCnvTRTOnly_%s_EFID")]

        elif seqType == "Combined":
            algos = [
                ("PixelClustering", ""),
                ("SCTClustering", ""),
                ("TRTDriftCircleMaker", ""),
                ("InDetTrigPRD_MultiTruthMaker", ""),
                ("SiTrigSpacePointFinder", ""),
                ("SiTrigTrackFinder", ""),
                ("TrigAmbiguitySolver", ""),
                ("TRTTrackExtAlg", ""),
                ("TrigExtProcessor", ""),
                ("InDetTrigTrackPRD_Association",
                 "InDetTrigSegmentPRD_Association_%s_EFID"),
                ("TRT_TrigTrackSegmentsFinder",
                 "InDetTrigTRT_TrackSegmentsFinderCombined_%s_EFID"),
                ("TRT_TrigSeededTrackFinder",
                 "InDetTrigTRT_SeededTrackFinder_%s_EFID"),
                ("TRTSeededTrigAmbiguitySolver",
                 "TRTSeededTrigAmbiguitySolver_%s_EFID"),
                ("InDetTrigTrackPRD_Association",
                 "InDetTrigTRTOnlyPRD_Association_%s_EFID"),
                ("TRT_TrigStandaloneTrackFinder",
                 "InDetTrigTRT_StandaloneTrackFinderCombined_%s_EFID"),
                ("TrkTrigTrackCollectionMerger",
                 "TrigTrackCollectionMerger_%s_EFID"),
                ("InDetTrigTrackSlimmer",
                 "InDetTrigTrackSlimmerCombined_%s_EFID"),
                ("InDetTrigTrackingxAODCnv",
                 "InDetTrigTrackingxAODCnvCombined_%s_EFID"),
                ("InDetTrigDetailedTrackTruthMaker",
                 "InDetTrigDetailedTrackTruthMakerCombined_%s_EFID"),
                #("InDetTrigParticleCreation",      "InDetTrigParticleCreationCombined_%s_EFID"),
                ("InDetTrigTrackParticleTruthMaker",
                 "InDetTrigTrackParticleTruthMakerCombined_%s_EFID")
            ]

        elif seqType == "CombinedWithConversions":
            algos = [
                ("PixelClustering", ""),
                ("SCTClustering", ""),
                ("TRTDriftCircleMaker", ""),
                ("InDetTrigPRD_MultiTruthMaker", ""),
                ("SiTrigSpacePointFinder", ""),
                ("SiTrigTrackFinder", ""),
                ("TrigAmbiguitySolver", ""),
                ("TRTTrackExtAlg", ""),
                ("TrigExtProcessor", ""),
                ("InDetTrigTrackPRD_Association",
                 "InDetTrigSegmentPRD_Association_%s_EFID"),
                ("TRT_TrigTrackSegmentsFinder",
                 "InDetTrigTRT_TrackSegmentsFinderCombined_%s_EFID"),
                ("TRT_TrigSeededTrackFinder",
                 "InDetTrigTRT_SeededTrackFinder_%s_EFID"),
                ("TRTSeededTrigAmbiguitySolver",
                 "TRTSeededTrigAmbiguitySolver_%s_EFID"),
                ("InDetTrigTrackPRD_Association",
                 "InDetTrigTRTOnlyPRD_Association_%s_EFID"),
                ("TRT_TrigStandaloneTrackFinder",
                 "InDetTrigTRT_StandaloneTrackFinderCombined_%s_EFID"),
                ("TrkTrigTrackCollectionMerger",
                 "TrigTrackCollectionMerger_%s_EFID"),
                ("InDetTrigTrackSlimmer",
                 "InDetTrigTrackSlimmerCombined_%s_EFID"),
                ("InDetTrigTrackingxAODCnv",
                 "InDetTrigTrackingxAODCnvCombined_%s_EFID"),
                ("InDetTrigDetailedTrackTruthMaker",
                 "InDetTrigDetailedTrackTruthMakerCombined_%s_EFID"),
                #("InDetTrigParticleCreation",      "InDetTrigParticleCreationCombined_%s_EFID"),
                ("InDetTrigTrackParticleTruthMaker",
                 "InDetTrigTrackParticleTruthMakerCombined_%s_EFID"),
                ("InDetTrigConversionFinder",
                 "InDetTrigConversionFinderCombined_%s_EFID")
            ]

        elif seqType == "InsideOutAndTRTOnly":
            algos = [
                ("PixelClustering", ""),
                ("SCTClustering", ""),
                ("TRTDriftCircleMaker", ""),
                ("InDetTrigPRD_MultiTruthMaker", ""),
                ("SiTrigSpacePointFinder", ""),
                ("SiTrigTrackFinder", ""),
                ("TrigAmbiguitySolver", ""),
                ("TRTTrackExtAlg", ""),
                ("TrigExtProcessor", ""),
                ("InDetTrigTrackParticleTruthMaker", ""),
                ("TRT_TrigTrackSegmentsFinder",
                 "InDetTrigTRT_TrackSegmentsFinder_%s_EFID"),
                ("TRT_TrigStandaloneTrackFinder",
                 "InDetTrigTRT_StandaloneTrackFinder_%s_EFID"),
                ("TrkTrigTrackCollectionMerger",
                 "TrigTrackCollectionMergerIOTRT_%s_EFID"),
                ("InDetTrigTrackSlimmer",
                 "InDetTrigTrackSlimmerIOTRT_%s_EFID"),
                ("InDetTrigTrackingxAODCnv",
                 "InDetTrigTrackingxAODCnvIOTRT_%s_EFID"),
                ("InDetTrigDetailedTrackTruthMaker",
                 "InDetTrigDetailedTrackTruthMakerIOTRT_%s_EFID"),
                #("InDetTrigParticleCreation",        "InDetTrigParticleCreationIOTRT_%s_EFID"),
                ("InDetTrigTrackParticleTruthMaker",
                 "InDetTrigTrackParticleTruthMakerIOTRT_%s_EFID"),
                ("TrigVxPrimary", ""),
            ]
            if runvtxxaodcnv:
                algos += [("InDetTrigVertexxAODCnv",
                           "InDetTrigVertexxAODCnvIOTRT_%s_EFID")]

        elif seqType == "DataPrep":
            algos = [
                ("PixelClustering", "PixelClustering_%s_IDTrig"),
                ("SCTClustering", "SCTClustering_%s_IDTrig"),
                #("TRTDriftCircleMaker",""),
                ("SiTrigSpacePointFinder", "SiTrigSpacePointFinder_%s_IDTrig"),
            ]
        elif seqType == "SimpleTrackFinder":
            algos = [
                #("SiTrigTrackFinder",""),
                ("SiTrigSimpleTrackFinder", ""),
            ]
        elif seqType == "InsideOutMerged":
            algos = [
                #("SiTrigTrackSeededFinder",""),
                ("TrigAmbiguitySolver", ""),
                ("TRTDriftCircleMaker", ""),
                ("InDetTrigPRD_MultiTruthMaker", ""),
                ("TRTTrackExtAlg", ""),
                ("TrigExtProcessor", ""),
                ("InDetTrigTrackSlimmer", ""),
                ("InDetTrigTrackingxAODCnv", ""),
                ("InDetTrigDetailedTrackTruthMaker", ""),
                ("TrigVxPrimary", ""),
                #("InDetTrigParticleCreation",""),
                ("InDetTrigTrackParticleTruthMaker", ""),
            ]
            if runvtxxaodcnv:
                algos += [("InDetTrigVertexxAODCnv", "")]

        elif seqType == "StandAloneVtxAllTE":
            algos = [
                ("TrigVxPrimaryAllTESG", ""),
            ]
            if runvtxxaodcnv:
                algos += [("InDetTrigVertexxAODCnv", "")]

        #remove truth algorithms
        if not InDetTrigFlags.doTruth():
            import re
            for i in algos:
                if re.search('Truth', i[0]):
                    algos.remove((i[0], i[1]))

        #create python code to be executed
        alglist = "algseq = ["
        for i in algos:
            #self.__algos__.append(i)
            algline = self._item_line(i[0], i[1], seqName, type, seqType)
            alglist += algline + ','
        alglist += "]"

        #this should be avoided by a higher level steering
        #    modify the sequence acoording to triggerflags
        from TriggerJobOpts.TriggerFlags import TriggerFlags

        if not (TriggerFlags.doEF()
                or TriggerFlags.doHLT()) or not TriggerFlags.doFEX():
            from TrigSteeringTest.TrigSteeringTestConf import PESA__dummyAlgo as dummyAlgo_disabledByTriggerFlags_EFID
            dummyAlgEFID = dummyAlgo_disabledByTriggerFlags_EFID(
                "doEF_or_doFEX_False_no_EFID")
            alglist = 'algseq = [dummyAlgEFID]'

        algseq = []
        try:
            exec alglist
        except:
            from sys import exc_info
            (a, reason, c) = exc_info()
            print reason
            log.error("Cannot create EFID sequence %s, leaving empty" %
                      alglist)
            import traceback
            print traceback.format_exc()

            #raise Exception

        self.__sequence__ = algseq
コード例 #3
0
 def __init__(self):
     # tell the Configured machinery that we do not care about the objects already there
     if not TF.doFEX() and TF.doHypo():
         Configured.__init__(self, ignoreExistingDataObject=True)
     else:
         Configured.__init__(self, ignoreExistingDataObject=False)
コード例 #4
0
    def configure(self):

        log = logging.getLogger("HLTTriggergetter.py")

        from AthenaCommon.AlgSequence import AlgSequence
        topSequence = AlgSequence()

        # If no xAOD::EventInfo is found in a POOL file, schedule conversion from old EventInfo
        from AthenaCommon.GlobalFlags import globalflags
        if globalflags.InputFormat.is_pool():
            from RecExConfig.ObjKeyStore import objKeyStore
            from PyUtils.MetaReaderPeeker import convert_itemList
            objKeyStore.addManyTypesInputFile(convert_itemList(layout='#join'))
            from AthenaCommon.AlgSequence import AthSequencer
            condSeq = AthSequencer("AthCondSeq")
            if (not objKeyStore.isInInput("xAOD::EventInfo")) and (not hasattr(
                    condSeq, "xAODMaker::EventInfoCnvAlg")):
                from xAODEventInfoCnv.xAODEventInfoCnvAlgDefault import xAODEventInfoCnvAlgDefault
                xAODEventInfoCnvAlgDefault(sequence=condSeq)

        if jobproperties.Global.InputFormat() == 'bytestream':
            # Decode ROIB::RoIBResult from ByteStream
            from TrigT1ResultByteStream.TrigT1ResultByteStreamConfig import L1ByteStreamDecodersRecExSetup
            L1ByteStreamDecodersRecExSetup()

        log.info("Loading RegionSelector")
        from AthenaCommon.AppMgr import ServiceMgr
        from RegionSelector.RegSelSvcDefault import RegSelSvcDefault
        ServiceMgr += RegSelSvcDefault()

        # Configure the Data Preparation for Calo
        if TriggerFlags.doCalo():
            try:
                from TrigT2CaloCommon.TrigT2CaloCommonConfig import TrigDataAccess
                ServiceMgr.ToolSvc += TrigDataAccess()
            except ImportError:
                include('TrigT2CaloCommon/TrigDataAccessConfigured.py')

        if TriggerFlags.doFTK():
            # FTK algorithm inclusions
            # TrigFTK_DataProviderSvc moved to TrigFTK_RecExample
            pass

        if TriggerFlags.doHLT():
            log.info("configuring HLT Steering")

            from TrigSteering.TrigSteeringConfig import TrigSteer_HLT, ReruningTrigSteer_HLT
            if TriggerFlags.doFEX():

                # schedule the conversion of the L1Calo ROIB data to topo simulation input

                # this ROIB converter should only be scheduled if
                # - we run on data
                # - L1Calo simulation has not been scheduled
                # - and ROIB converter has not been scheduled yet before
                if globalflags.DataSource()=='data' \
                       and not hasattr( topSequence, 'CPCMX' ) \
                       and not hasattr( topSequence, 'RoiB2TopoInputDataCnv' ):
                    log.info("Setting up RoiB2TopoInputDataCnv")
                    from L1TopoSimulation.L1TopoSimulationConfig import RoiB2TopoInputDataCnv
                    roib2Topo = RoiB2TopoInputDataCnv()
                    topSequence += roib2Topo

                log.info(
                    "configuring HLT merged system, for normal running (FEX + Hypo)"
                )
                TrigSteer_HLT = TrigSteer_HLT(
                    'TrigSteer_HLT',
                    hltFile=TriggerFlags.inputHLTconfigFile(),
                    lvl1File=TriggerFlags.inputLVL1configFile())
                TrigSteer_HLT.doHypo = TriggerFlags.doHypo()

            if not TriggerFlags.doFEX() and TriggerFlags.doHypo():
                log.info("configuring merged HLT for re-running (Hypo only)")
                TrigSteer_HLT = ReruningTrigSteer_HLT(
                    'TrigSteer_HLT',
                    hltFile=TriggerFlags.inputHLTconfigFile(),
                    lvl1File=TriggerFlags.inputLVL1configFile())

            # TrigSteer_HLT.doL1TopoSimulation = TriggerFlags.doL1Topo() # this later needs to be extented to also run when we take data with L1Topo
            TrigSteer_HLT.doL1TopoSimulation = True  # always needs to run if the HLT is simulated
            if hasattr(TrigSteer_HLT.LvlTopoConverter, 'MuonInputProvider'):

                try:  # this is temporary until TrigT1Muctpi-00-06-29 is in the release
                    from TrigT1Muctpi.TrigT1MuctpiConfig import L1MuctpiTool
                    from AthenaCommon.AppMgr import ToolSvc
                    ToolSvc += L1MuctpiTool()
                    TrigSteer_HLT.LvlTopoConverter.MuonInputProvider.MuctpiSimTool = L1MuctpiTool(
                    )
                except ImportError:
                    pass

                from AthenaCommon.GlobalFlags import globalflags
                if globalflags.DataSource() != 'data':
                    log.info(
                        "Muon eta/phi encoding with reduced granularity for MC (L1Topo emulation for HLT seeding)"
                    )
                    TrigSteer_HLT.LvlTopoConverter.MuonInputProvider.MuonEncoding = 1  # reduced granularity muon input
                else:
                    log.info(
                        "Muon eta/phi encoding with full granularity for data (L1Topo emulation for HLT seeding) - should be faced out"
                    )
                    TrigSteer_HLT.LvlTopoConverter.MuonInputProvider.MuonEncoding = 0  # full granularity muon input - should be faced out

            from TrigEDMConfig.TriggerEDM import getHLTPreregistrationList, getEDMLibraries
            TrigSteer_HLT.Navigation.ClassesToPreregister = getHLTPreregistrationList(
            )

            TrigSteer_HLT.Navigation.Dlls = getEDMLibraries()

            monitoringTools(TrigSteer_HLT)
            topSequence += TrigSteer_HLT

        if TriggerFlags.writeBS():
            # declare objects to go to BS (from the lists above)
            ## if TriggerFlags.doLVL2():
            ##     from TrigEDMConfig.TriggerEDM import getL2BSList
            ##     TrigSteer_L2.Navigation.ClassesToPayload = getL2BSList()
            ##     TrigSteer_L2.Navigation.ClassesToPreregister = []
            ##
            ## if TriggerFlags.doEF():
            ##     from TrigEDMConfig.TriggerEDM import getEFBSList
            ##     TrigSteer_EF.Navigation.ClassesToPayload = getEFBSList()
            ##     TrigSteer_EF.Navigation.ClassesToPreregister = []
            ##     try:
            ##         from TrigEDMConfig.TriggerEDM import getEFDSList
            ##         TrigSteer_EF.Navigation.ClassesToPayload_DSonly = getEFDSList()
            ##     except ImportError:
            ##         log.warning("DataScouting not available in this release")

            if TriggerFlags.doHLT():
                from TrigEDMConfig.TriggerEDM import getHLTBSList
                TrigSteer_HLT.Navigation.ClassesToPayload = getHLTBSList()
                TrigSteer_HLT.Navigation.ClassesToPreregister = []
                try:
                    from TrigEDMConfig.TriggerEDM import getHLTDSList
                    TrigSteer_HLT.Navigation.ClassesToPayload_DSonly = getHLTDSList(
                    )
                except ImportError:
                    log.warning("DataScouting not available in this release")

            #configure tools for serialization
            from TrigSerializeTP.TrigSerializeTPConf import TrigSerTPTool
            TrigSerToolTP = TrigSerTPTool('TrigSerTPTool')
            from TrigEDMConfig.TriggerEDM import getTPList
            TrigSerToolTP.TPMap = getTPList(TriggerFlags.doHLT())
            from AthenaCommon.AppMgr import ToolSvc
            ToolSvc += TrigSerToolTP

            from TrigSerializeCnvSvc.TrigSerializeCnvSvcConf import TrigSerializeConvHelper
            TrigSerializeConvHelper = TrigSerializeConvHelper(doTP=True)
            ToolSvc += TrigSerializeConvHelper

            #do not activate T/P of EF classes at L2
            ## if TriggerFlags.doLVL2():
            ##     from TrigEDMConfig.TriggerEDM import getL2BSTypeList
            ##     TrigSerToolTP.ActiveClasses = getL2BSTypeList()
            ## if TriggerFlags.doEF():
            ##     from TrigEDMConfig.TriggerEDM import getL2BSTypeList, getEFBSTypeList
            ##     TrigSerToolTP.ActiveClasses = getL2BSTypeList() + getEFBSTypeList()

            if TriggerFlags.doHLT():
                from TrigEDMConfig.TriggerEDM import getHLTBSTypeList
                TrigSerToolTP.ActiveClasses = getHLTBSTypeList()

        from TriggerJobOpts.HLTTriggerResultGetter import HLTTriggerResultGetter
        result = HLTTriggerResultGetter()  # noqa: F841
        return True