Example #1
0
def JetTrackingSequence(dummyFlags, trkopt, RoIs):
    jetTrkSeq = parOR("JetTrackingSeq_" + trkopt, [])
    tracksname = ""
    verticesname = ""

    if trkopt == "ftf":
        from TrigInDetConfig.InDetSetup import makeInDetAlgsNoView
        # Guess FS rather than making it jet-specific?
        viewAlgs = makeInDetAlgsNoView("JetFS", "FS", rois=recordable(RoIs))
        jetTrkSeq += viewAlgs
        tracksname = recordable("HLT_IDTrack_FS_FTF")
        verticesname = recordable("HLT_IDVertex_FS")

    from TrigInDetConfig.TrigInDetPriVtxConfig import makeVertices
    vtxAlgs = makeVertices("jet", tracksname, verticesname)
    prmVtx = vtxAlgs[-1]
    jetTrkSeq += prmVtx

    tvaname = "JetTrackVtxAssoc_" + trkopt
    trkcolls = {
        "Tracks": tracksname,
        "Vertices": verticesname,
        "TVA": tvaname,
    }

    from JetRecTools.JetRecToolsConfig import trackcollectionmap
    if trkopt not in trackcollectionmap.keys():
        trackcollectionmap[trkopt] = trkcolls

    # Jet track selection
    jettrackselloose = getTrackSelTool(trkopt, doWriteTracks=True)
    jettracksname = jettrackselloose.OutputContainer
    jettvassoc = getTrackVertexAssocTool(trkopt)

    trackcollectionmap[trkopt]["JetTracks"] = jettracksname
    trackcollectionmap[trkopt]["TVA"] = tvaname

    jettrkprepalg = CompFactory.JetAlgorithm("jetalg_TrackPrep")
    jettrkprepalg.Tools = [jettrackselloose, jettvassoc]
    jetTrkSeq += conf2toConfigurable(jettrkprepalg)

    label = "GhostTrack_{}".format(trkopt)
    ghosttracksname = "PseudoJet{}".format(label)

    trackcollectionmap[trkopt]["GhostTracks"] = ghosttracksname
    trackcollectionmap[trkopt]["GhostTracksLabel"] = label

    pjgalg = CompFactory.PseudoJetAlgorithm("pjgalg_" + label,
                                            InputContainer=tracksname,
                                            OutputContainer=ghosttracksname,
                                            Label=label,
                                            SkipNegativeEnergy=True)
    jetTrkSeq += conf2toConfigurable(pjgalg)

    return jetTrkSeq, trkcolls
Example #2
0
def make_l1_seq(options=default_options):
    from AthenaCommon.CFElements import seqOR
    l1_seq = seqOR('l1Seq')

    # Configure L1 decoding flags
    ConfigFlags.Trigger.enableL1Phase1 = options.EnableL1Phase1
    ConfigFlags.Trigger.enableL1CaloLegacy = options.EnableL1CaloLegacy

    # Create inputs for L1Decoder from ByteStream
    from TrigT1ResultByteStream.TrigT1ResultByteStreamConfig import L1TriggerByteStreamDecoderCfg
    acc = L1TriggerByteStreamDecoderCfg(ConfigFlags)
    l1_seq += conf2toConfigurable(acc.getPrimary())
    acc.wasMerged()

    if ConfigFlags.Trigger.enableL1Phase1:
        from L1Decoder.L1DecoderConfig import getL1TriggerResultMaker
        l1_seq += conf2toConfigurable(getL1TriggerResultMaker())

    # Set menu for L1ConfigSvc
    from TriggerJobOpts.TriggerFlags import TriggerFlags
    TriggerFlags.triggerMenuSetup = "LS2_v1"

    # Ensure LVL1ConfigSvc is initialised before L1Decoder handles BeginRun incident
    # This should be done by the L1Decoder configuration in new-style job options (with component accumulator)
    from TrigConfigSvc.TrigConfigSvcCfg import getL1ConfigSvc
    from AthenaCommon.AppMgr import ServiceMgr as svcMgr
    svcMgr += getL1ConfigSvc(ConfigFlags)

    # Initialise L1 decoding tools
    from L1Decoder.L1DecoderConf import CTPUnpackingTool
    ctpUnpacker = CTPUnpackingTool(ForceEnableAllChains=True)
    # Can add other tools here if needed

    from L1Decoder.L1DecoderConf import PrescalingEmulationTool
    psEmulation = PrescalingEmulationTool()

    # Schedule the L1Decoder algo with the above tools
    from L1Decoder.L1DecoderConf import L1Decoder
    l1decoder = L1Decoder()
    l1decoder.ctpUnpacker = ctpUnpacker
    l1decoder.prescaler = psEmulation
    l1decoder.RoIBResult = "RoIBResult" if ConfigFlags.Trigger.enableL1CaloLegacy or not ConfigFlags.Trigger.enableL1Phase1 else ""
    l1decoder.L1TriggerResult = "L1TriggerResult" if ConfigFlags.Trigger.enableL1Phase1 else ""
    l1_seq += l1decoder

    return l1_seq
Example #3
0
    def getTimeBurnerStep(self):
        # Input maker - required by the framework, but inputs don't matter for TimeBurner
        inputMaker = InputMakerForRoI("IM_TimeBurner")
        inputMaker.RoITool = ViewCreatorInitialROITool()
        inputMaker.RoIs = "TimeBurnerInputRoIs"
        inputMakerSeq = seqAND("TimeBurnerSequence", [inputMaker])

        # TimeBurner alg works as a reject-all hypo
        hypoAlg = conf2toConfigurable(TimeBurnerCfg())
        hypoAlg.SleepTimeMillisec = 200

        seq = MenuSequence(Sequence=inputMakerSeq,
                           Maker=inputMaker,
                           Hypo=hypoAlg,
                           HypoToolGen=TimeBurnerHypoToolGen)

        return ChainStep(name='Step1_TimeBurner', Sequences=[seq])
Example #4
0
def jetAthSequence(dummyFlags, **jetRecoDict):
    from TrigT2CaloCommon.CaloDef import clusterFSInputMaker
    InputMakerAlg = conf2toConfigurable(clusterFSInputMaker())

    # Does nothing now, but may need to use this to toggle Insitu calib step
    # in which case it should be deduced from input flags
    dataSource = "data"  # or mc

    (recoSequence,
     sequenceOut) = RecoFragmentsPool.retrieve(jetRecoSequence,
                                               None,
                                               dataSource=dataSource,
                                               **jetRecoDict)

    jetDefString = jetRecoDictToString(jetRecoDict)
    JetAthSequence = seqAND("jetAthSequence_" + jetDefString,
                            [InputMakerAlg, recoSequence])
    return (JetAthSequence, InputMakerAlg, sequenceOut)
Example #5
0
def makeHLTTree(newJO=False, triggerConfigHLT=None):
    """ creates the full HLT tree"""

    # Check if triggerConfigHLT exits, if yes, derive information from this
    # this will be in use once TrigUpgrade test has migrated to TriggerMenuMT completely

    # get topSequnece
    from AthenaCommon.AlgSequence import AlgSequence
    topSequence = AlgSequence()

    # find main HLT top sequence (already set up in runHLT_standalone)
    from AthenaCommon.CFElements import findSubSequence, findAlgorithm
    l1decoder = findAlgorithm(topSequence, "L1Decoder")

    # add the HLT steps Node
    steps = seqAND("HLTAllSteps")
    hltTop = findSubSequence(topSequence, "HLTTop")
    hltTop += steps

    hltEndSeq = parOR("HLTEndSeq")
    hltTop += hltEndSeq

    hltFinalizeSeq = seqAND("HLTFinalizeSeq")

    # make DF and CF tree from chains
    finalDecisions = decisionTreeFromChains(steps,
                                            triggerConfigHLT.configsList(),
                                            triggerConfigHLT.dictsList(),
                                            newJO)

    flatDecisions = []
    for step in finalDecisions:
        flatDecisions.extend(step)

    summary = makeSummary("Final", flatDecisions)
    hltEndSeq += summary

    # TODO - check we are not running things twice. Once here and once in TriggerConfig.py

    from TriggerJobOpts.TriggerConfig import collectHypos, collectFilters, collectViewMakers, collectDecisionObjects,\
        triggerMonitoringCfg, triggerSummaryCfg, triggerMergeViewsAndAddMissingEDMCfg, collectHypoDecisionObjects
    from AthenaConfiguration.AllConfigFlags import ConfigFlags

    from AthenaConfiguration.ComponentAccumulator import conf2toConfigurable, appendCAtoAthena

    # Collections required to configure the algs below
    hypos = collectHypos(steps)
    filters = collectFilters(steps)
    viewMakers = collectViewMakers(steps)

    Configurable.configurableRun3Behavior = 1
    summaryAcc, summaryAlg = triggerSummaryCfg(ConfigFlags, hypos)
    Configurable.configurableRun3Behavior = 0
    # A) First we check if any chain accepted the event
    hltFinalizeSeq += conf2toConfigurable(summaryAlg)
    appendCAtoAthena(summaryAcc)

    # B) Then (if true), we run the accepted event algorithms.
    # Add any required algs to hltFinalizeSeq here

    # More collections required to configure the algs below
    decObj = collectDecisionObjects(hypos, filters, l1decoder, summaryAlg)
    decObjHypoOut = collectHypoDecisionObjects(hypos,
                                               inputs=False,
                                               outputs=True)

    Configurable.configurableRun3Behavior = 1
    monAcc, monAlg = triggerMonitoringCfg(ConfigFlags, hypos, filters,
                                          l1decoder)
    Configurable.configurableRun3Behavior = 0
    hltEndSeq += conf2toConfigurable(monAlg)
    appendCAtoAthena(monAcc)

    Configurable.configurableRun3Behavior = 1
    edmAlg = triggerMergeViewsAndAddMissingEDMCfg(['AOD', 'ESD'], hypos,
                                                  viewMakers, decObj,
                                                  decObjHypoOut)
    Configurable.configurableRun3Behavior = 0
    # C) Finally, we create the EDM output
    hltFinalizeSeq += conf2toConfigurable(edmAlg)

    hltEndSeq += hltFinalizeSeq

    # Test the configuration
    from TriggerMenuMT.HLTMenuConfig.Menu.CFValidation import testHLTTree
    testHLTTree(hltTop)
Example #6
0
def Lvl1SimulationSequence(flags=None):
    """ 
    Configure L1 simulation for Athena MT jobs

    The code is structure in a way that should be easier to change once New JO system with ComponentAccumulators will be in use
    """
    # for the New JO migration
    #    from AthenaCommon.ComponentAccumulator import ComponentAccumulator
    #    acc = ComponentAccumulator()
    # all tools then should be added to the acc, cond folders as well.
    # L1ConfigSvc CA has to be imported and merged
    # at the end the sequence added to the CA
    #
    from AthenaCommon.Logging import logging
    log = logging.getLogger('TriggerJobOpts.Lvl1Simulation')
    from AthenaConfiguration.ComponentAccumulator import conf2toConfigurable
    from AthenaCommon.CFElements import seqAND
    from AthenaCommon.AppMgr import ServiceMgr as svcMgr
    from AthenaCommon.AlgSequence import AthSequencer
    from TriggerJobOpts.TriggerFlags import TriggerFlags

    # this configuration of the LVL1ConfigSvc is only temporary
    TriggerFlags.readLVL1configFromXML = True
    TriggerFlags.outputLVL1configFile = None
    log.info("setting up LVL1ConfigSvc, including the menu generation")
    from TrigConfigSvc.TrigConfigSvcCfg import getL1ConfigSvc
    svcMgr += conf2toConfigurable(getL1ConfigSvc(flags))

    ##################################################
    # Calo
    ##################################################

    if flags.Trigger.enableL1CaloLegacy:

        from TrigT1CaloSim.TrigT1CaloSimRun2Config import Run2TriggerTowerMaker
        caloTowerMaker = Run2TriggerTowerMaker("Run2TriggerTowerMaker25ns")
        caloTowerMaker.ExtraInputs = [
            "LArTTL1Container#LArTTL1EM", "LArTTL1Container#LArTTL1HAD",
            "TileTTL1Container#TileTTL1Cnt"
        ]
        caloTowerMaker.ZeroSuppress = True
        caloTowerMaker.CellType = 3

        from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__Run2CPMTowerMaker
        from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__Run2JetElementMaker
        from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__CPMSim
        from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__JEMJetSim
        from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__JEMEnergySim
        from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__CPCMX
        from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__JetCMX
        from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__EnergyCMX
        from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__RoIROD

        from TrigT1MBTS.TrigT1MBTSConf import LVL1__TrigT1MBTS
        from TrigT1ZDC.TrigT1ZDCConf import LVL1__TrigT1ZDC

        l1CaloSim = seqAND(
            'l1CaloSim',
            [
                caloTowerMaker,
                #LVL1__Run2CPMTowerMaker( 'CPMTowerMaker', ExtraInputs=["XYZ#1"], ExtraOutputs=["XYZ#2"]) ,
                LVL1__Run2CPMTowerMaker('CPMTowerMaker'),
                LVL1__Run2JetElementMaker('JetElementMaker'),
                LVL1__CPMSim('CPMSim'),
                LVL1__JEMJetSim('JEMJetSim'),
                LVL1__JEMEnergySim('JEMEnergySim'),
                LVL1__CPCMX('CPCMX'),
                LVL1__JetCMX('JetCMX'),
                LVL1__EnergyCMX('EnergyCMX'),
                LVL1__RoIROD('RoIROD'),
                LVL1__TrigT1MBTS(),
                LVL1__TrigT1ZDC()
            ])

        from IOVDbSvc.CondDB import conddb
        L1CaloFolderList = []
        #L1CaloFolderList += ["/TRIGGER/L1Calo/V1/Calibration/Physics/PprChanCalib"]
        L1CaloFolderList += [
            "/TRIGGER/L1Calo/V2/Calibration/Physics/PprChanCalib"
        ]
        #L1CaloFolderList += ["/TRIGGER/L1Calo/V1/Conditions/RunParameters"]
        #L1CaloFolderList += ["/TRIGGER/L1Calo/V1/Conditions/DerivedRunPars"]
        #L1CaloFolderList += ["/TRIGGER/Receivers/Conditions/VgaDac"]
        #L1CaloFolderList += ["/TRIGGER/Receivers/Conditions/Strategy"]
        L1CaloFolderList += ["/TRIGGER/L1Calo/V2/Conditions/DisabledTowers"]
        L1CaloFolderList += ["/TRIGGER/L1Calo/V2/Calibration/PpmDeadChannels"]
        L1CaloFolderList += [
            "/TRIGGER/L1Calo/V2/Configuration/PprChanDefaults"
        ]

        for l1calofolder in L1CaloFolderList:
            #conddb.addFolderWithTag("TRIGGER_OFL", l1calofolder, "HEAD")
            conddb.addFolder("TRIGGER_OFL", l1calofolder)

    ##################################################
    # Muons
    ##################################################

    from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import MuonRdoToMuonDigitTool
    MuonRdoToMuonDigitTool = MuonRdoToMuonDigitTool(
        DecodeMdtRDO=False,
        DecodeRpcRDO=True,
        DecodeTgcRDO=True,
        DecodeCscRDO=False,
        DecodeSTGC_RDO=False,
        DecodeMM_RDO=False,
        # for those subdetectors where the decoding is turned off, no need to create a RDO_Decoder ToolHandle
        mdtRdoDecoderTool="",
        cscRdoDecoderTool="",
        stgcRdoDecoderTool="",
        mmRdoDecoderTool="",
        RpcDigitContainer="RPC_DIGITS_L1",
        TgcDigitContainer="TGC_DIGITS_L1")

    MuonRdoToMuonDigitTool.cscCalibTool = "CscCalibTool"
    from AthenaCommon.AppMgr import ToolSvc
    ToolSvc += MuonRdoToMuonDigitTool

    from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import MuonRdoToMuonDigit
    from TrigT1RPCsteering.TrigT1RPCsteeringConf import TrigT1RPC
    from TrigT1TGC.TrigT1TGCConf import LVL1TGCTrigger__LVL1TGCTrigger

    TrigT1RPC.useRun3Config = flags.Trigger.enableL1Phase1
    LVL1TGCTrigger__LVL1TGCTrigger.useRun3Config = flags.Trigger.enableL1Phase1

    if flags.Trigger.enableL1Phase1:
        # Placeholder for phase-I MUCTPI simulation
        log.info("Configuring Phase-I MUCTPI simulation")
        from TrigT1MuctpiPhase1.TrigT1MuctpiPhase1Config import L1MuctpiPhase1
        from TrigT1MuctpiPhase1.TrigT1MuctpiPhase1Config import L1MuctpiPhase1Tool

        ToolSvc += L1MuctpiPhase1Tool("MUCTPI_AthTool")
        ToolSvc.MUCTPI_AthTool.LVL1ConfigSvc = svcMgr.LVL1ConfigSvc

        muctpi = L1MuctpiPhase1()
        muctpi.LVL1ConfigSvc = svcMgr.LVL1ConfigSvc

    else:
        log.info("Configuring legacy (Run 2) MUCTPI simulation")
        from TrigT1Muctpi.TrigT1MuctpiConfig import L1Muctpi
        from TrigT1Muctpi.TrigT1MuctpiConfig import L1MuctpiTool

        ToolSvc += L1MuctpiTool("L1MuctpiTool")
        ToolSvc.L1MuctpiTool.LVL1ConfigSvc = svcMgr.LVL1ConfigSvc

        muctpi = L1Muctpi()
        muctpi.LVL1ConfigSvc = svcMgr.LVL1ConfigSvc

    # Sets up and configures the muon alignment and detector manager
    from MuonRecExample import MuonAlignConfig  # noqa: F401

    l1MuonSim = seqAND(
        "l1MuonSim",
        [
            MuonRdoToMuonDigit(
                "MuonRdoToMuonDigit",
                MuonRdoToMuonDigitTool=ToolSvc.MuonRdoToMuonDigitTool),
            TrigT1RPC(
                "TrigT1RPC",
                Hardware=
                True,  # not sure if needed, not there in old config, present in JO
                DataDetail=False,
                RPCbytestream=False,
                RPCbytestreamFile="",
                RPCDigitContainer="RPC_DIGITS_L1"),

            # based on Trigger/TrigT1/TrigT1TGC/python/TrigT1TGCConfig.py
            # interesting is that this JO sets inexisting properties, commented out below
            LVL1TGCTrigger__LVL1TGCTrigger(
                "LVL1TGCTrigger",
                InputData_perEvent="TGC_DIGITS_L1",
                MuCTPIInput_TGC="L1MuctpiStoreTGC",
                MaskFileName12="TrigT1TGCMaskedChannel._12.db"),
            muctpi
        ])

    # only needed for MC
    conddb.addFolder("TGC_OFL",
                     "/TGC/TRIGGER/CW_EIFI",
                     className="CondAttrListCollection")
    conddb.addFolder("TGC_OFL",
                     "/TGC/TRIGGER/CW_BW",
                     className="CondAttrListCollection")
    conddb.addFolder("TGC_OFL",
                     "/TGC/TRIGGER/CW_TILE",
                     className="CondAttrListCollection")
    condSeq = AthSequencer("AthCondSeq")
    from MuonCondSvc.MuonCondSvcConf import TGCTriggerDbAlg
    condSeq += TGCTriggerDbAlg()

    ##################################################
    # Topo
    ##################################################

    l1TopoSim = None
    if flags.Trigger.enableL1Phase1:
        log.info("No phase1 configuration for L1Topo simulation is available")
    else:
        from L1TopoSimulation.L1TopoSimulationConfig import L1TopoSimulation
        l1TopoSim = L1TopoSimulation()

        l1TopoSim.MuonInputProvider.ROIBResultLocation = ""  #disable input from RoIBResult
        l1TopoSim.MuonInputProvider.MuctpiSimTool = ToolSvc.L1MuctpiTool

        # enable the reduced (coarse) granularity topo simulation
        # currently only for MC
        from AthenaCommon.GlobalFlags import globalflags
        if globalflags.DataSource() != 'data':
            l1TopoSim.MuonInputProvider.MuonEncoding = 1
        else:
            l1TopoSim.MuonInputProvider.MuonEncoding = 0

    ##################################################
    # CTP
    ##################################################

    from TrigT1CTP.TrigT1CTPConfig import CTPSimulationInReco
    ctp = CTPSimulationInReco("CTPSimulation")
    ctp.DoLUCID = False
    ctp.DoBCM = False
    ctp.DoL1Topo = not flags.Trigger.enableL1Phase1
    ctp.UseCondL1Menu = False
    ctp.TrigConfigSvc = svcMgr.LVL1ConfigSvc
    ctpSim = seqAND("ctpSim", [ctp])

    if flags.Trigger.enableL1CaloLegacy or not flags.Trigger.enableL1Phase1:
        from TrigT1RoIB.TrigT1RoIBConfig import RoIBuilder
        roib = RoIBuilder("RoIBuilder")
        roib.DoCalo = flags.Trigger.enableL1CaloLegacy
        roib.DoMuon = not flags.Trigger.enableL1Phase1
        ctpSim += [roib]

    #l1Sim = seqAND("l1Sim", [caloTowerMaker] )
    if l1TopoSim:
        l1Sim = seqAND("l1Sim", [l1CaloSim, l1MuonSim, l1TopoSim, ctpSim])
    else:
        l1Sim = seqAND("l1Sim", [l1CaloSim, l1MuonSim, ctpSim])

    return l1Sim
Example #7
0
def configure_hlt_result(hypo_algs):
    from TrigEDMConfig.DataScoutingInfo import getFullHLTResultID
    from TrigOutputHandling.TrigOutputHandlingConfig import TriggerEDMSerialiserToolCfg, StreamTagMakerToolCfg, TriggerBitsMakerToolCfg

    # Tool serialising EDM objects to fill the HLT result
    serialiser = TriggerEDMSerialiserToolCfg('Serialiser')
    for hypo in hypo_algs:
        serialiser.addCollectionListToMainResult([
            'xAOD::TrigCompositeContainer_v1#' + hypo.HypoOutputDecisions,
            'xAOD::TrigCompositeAuxContainer_v2#' + hypo.HypoOutputDecisions +
            'Aux.',
        ])

    # Data scouting example
    resultList = [getFullHLTResultID(), 1]
    collections = set()
    chain_names = []
    for hypo in hypo_algs:
        for hypo_tool in hypo.HypoTools:
            chain_names.append(hypo_tool.name())
            if hasattr(hypo_tool, 'CreateRandomData'):
                for coll_name in hypo_tool.CreateRandomData.keys():
                    collections.add(coll_name)
    for coll_name in collections:
        serialiser.addCollectionListToResults([
            'xAOD::TrigCompositeContainer_v1#{:s}'.format(coll_name),
            'xAOD::TrigCompositeAuxContainer_v2#{:s}Aux.'.format(coll_name)
        ], resultList)

    # StreamTag definitions
    streamPhysicsMain = {
        'name': 'Main',
        'type': 'physics',
        'obeyLB': True,
        'forceFullEventBuilding': True
    }
    streamExamplePEB = {
        'name': 'ExamplePEB',
        'type': 'calibration',
        'obeyLB': True,
        'forceFullEventBuilding': False
    }
    streamExampleDataScoutingPEB = {
        'name': 'ExampleDataScoutingPEB',
        'type': 'physics',
        'obeyLB': True,
        'forceFullEventBuilding': False
    }
    chain_to_streams = {}
    for counter, ch in enumerate(chain_names, start=1):
        if counter % 3 == 1:
            chain_to_streams[ch] = [streamPhysicsMain]
        elif counter % 3 == 2:
            chain_to_streams[ch] = [streamExamplePEB]
        elif counter % 3 == 0:
            chain_to_streams[ch] = [streamExampleDataScoutingPEB]

    menu_json = write_dummy_menu_json(chain_to_streams.keys(),
                                      chain_to_streams)

    # Give the menu json name to HLTConfigSvc
    from AthenaCommon.AppMgr import ServiceMgr as svcMgr
    if not hasattr(svcMgr, 'HLTConfigSvc'):
        from TrigConfigSvc.TrigConfigSvcConfig import HLTConfigSvc
        svcMgr += HLTConfigSvc()
    svcMgr.HLTConfigSvc.JsonFileName = menu_json

    # Tool adding stream tags to HLT result
    stmaker = StreamTagMakerToolCfg()
    stmaker.ChainDecisions = 'HLTNav_Summary'
    stmaker.PEBDecisionKeys = [hypo.HypoOutputDecisions for hypo in hypo_algs]

    # Tool adding HLT bits to HLT result
    bitsmaker = TriggerBitsMakerToolCfg()
    bitsmaker.ChainDecisions = 'HLTNav_Summary'

    # Configure the HLT result maker to use the above tools
    from AthenaCommon.AppMgr import ServiceMgr as svcMgr
    hltResultMaker = svcMgr.HltEventLoopMgr.ResultMaker
    hltResultMaker.StreamTagMaker = conf2toConfigurable(stmaker)
    hltResultMaker.MakerTools = [
        conf2toConfigurable(tool) for tool in [bitsmaker, serialiser]
    ]
Example #8
0
    if option in globals():
        setattr(opt, option, globals()[option])
        log.info(' %20s = %s' % (option, getattr(opt, option)))
    else:
        log.info(' %20s = (Default) %s' % (option, getattr(opt, option)))

TriggerFlags.generateMenuDiagnostics = True

from TrigConfigSvc.TrigConfigSvcCfg import getHLTConfigSvc, getL1ConfigSvc
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaConfiguration.ComponentAccumulator import conf2toConfigurable
from AthenaConfiguration.AllConfigFlags import ConfigFlags

ConfigFlags.Trigger.triggerMenuSetup = TriggerFlags.triggerMenuSetup = 'LS2_v1'

svcMgr += conf2toConfigurable(getHLTConfigSvc(ConfigFlags))
svcMgr += conf2toConfigurable(getL1ConfigSvc(ConfigFlags))

topSequence = AlgSequence()

if opt.doMenu is True:
    generateL1DecoderAndChainsByMenu(topSequence)
else:
    generateL1DecoderAndChainsManually(topSequence)

generateJSON()

from AthenaCommon.AppMgr import theApp, ServiceMgr as svcMgr
from GaudiSvc.GaudiSvcConf import THistSvc
svcMgr += THistSvc()
if hasattr(svcMgr.THistSvc, "Output"):
Example #9
0
def GetCompatibleComponent(component):
    if Convert2Configurable:
        return conf2toConfigurable(component)
    return component
Example #10
0
def triggerOutputCfg(flags, decObj, decObjHypoOut, summaryAlg):
    # Following cases are considered:
    # 1) Running in partition or athenaHLT - configure BS output written by the HLT framework
    # 2) Running offline athena and writing BS - configure BS output written by OutputStream alg
    # 3) Running offline athena with POOL output - configure POOL output written by OutputStream alg
    onlineWriteBS = False
    offlineWriteBS = False
    writePOOL = False

    isPartition = len(flags.Trigger.Online.partitionName) > 0
    if flags.Trigger.writeBS:
        if isPartition:
            onlineWriteBS = True
        else:
            offlineWriteBS = True
    if flags.Output.doWriteRDO or flags.Output.doWriteESD or flags.Output.doWriteAOD:
        writePOOL = True

    # Consistency checks
    if offlineWriteBS and not flags.Output.doWriteBS:
        __log.error('flags.Trigger.writeBS is True but flags.Output.doWriteBS is False')
        return None, ''
    if writePOOL and onlineWriteBS:
        __log.error("POOL HLT output writing is configured online")
        return None, ''
    if writePOOL and offlineWriteBS:
        __log.error("Writing HLT output to both BS and POOL in one job is not supported at the moment")
        return None, ''

    # Determine EDM set name
    edmSet = ''
    if writePOOL:
        edmSet = flags.Trigger.AODEDMSet if flags.Output.doWriteAOD else flags.Trigger.ESDEDMSet
    elif onlineWriteBS or offlineWriteBS:
        edmSet = 'BS'

    # Create the configuration
    if onlineWriteBS:
        __log.info("Configuring online ByteStream HLT output")
        acc = triggerBSOutputCfg(flags, decObj, decObjHypoOut, summaryAlg)
        # Configure the online HLT result maker to use the above tools
        # For now use old svcMgr interface as this service is not available from acc.getService()
        from AthenaCommon.AppMgr import ServiceMgr as svcMgr
        hltEventLoopMgr = svcMgr.HltEventLoopMgr
        hltEventLoopMgr.ResultMaker.MakerTools = []
        for tool in acc.popPrivateTools():
            if 'StreamTagMaker' in tool.getName():
                hltEventLoopMgr.ResultMaker.StreamTagMaker = conf2toConfigurable(tool)
            else:
                hltEventLoopMgr.ResultMaker.MakerTools += [ conf2toConfigurable(tool) ]
    elif offlineWriteBS:
        __log.info("Configuring offline ByteStream HLT output")
        acc = triggerBSOutputCfg(flags, decObj, decObjHypoOut, summaryAlg, offline=True)
    elif writePOOL:
        __log.info("Configuring POOL HLT output")
        acc = triggerPOOLOutputCfg(flags, decObj, decObjHypoOut, edmSet)
    else:
        __log.info("No HLT output writing is configured")
        acc = ComponentAccumulator()

    return acc, edmSet
Example #11
0
def FtagJetCollection(jetcol, seq, OutputLevel=WARNING):

    from AthenaCommon.AppMgr import athCondSeq

    from AthenaCommon.Configurable import Configurable

    Configurable.configurableRun3Behavior = 1
    from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
    from AthenaConfiguration.ComponentFactory import CompFactory
    from AthenaConfiguration.ComponentAccumulator import conf2toConfigurable
    from BTagging.JetParticleAssociationAlgConfig import JetParticleAssociationAlgCfg
    from BTagging.JetBTaggingAlgConfig import JetBTaggingAlgCfg
    from BTagging.JetSecVertexingAlgConfig import JetSecVertexingAlgCfg
    from BTagging.JetSecVtxFindingAlgConfig import JetSecVtxFindingAlgCfg
    from BTagging.BTagTrackAugmenterAlgConfig import BTagTrackAugmenterAlgCfg
    from BTagging.BTagHighLevelAugmenterAlgConfig import BTagHighLevelAugmenterAlgCfg
    from BTagging.HighLevelBTagAlgConfig import HighLevelBTagAlgCfg
    from AthenaConfiguration.AllConfigFlags import ConfigFlags as cfgFlags

    jetcol_name_without_Jets = jetcol.replace('Jets', '')
    BTaggingCollection = cfgFlags.BTagging.OutputFiles.Prefix + jetcol_name_without_Jets

    kwargs = {}
    kwargs['Release'] = '22'

    cfgFlags.Input.Files = jps.AthenaCommonFlags.FilesInput.get_Value()

    acc = ComponentAccumulator()

    taggerlist = ['IP2D', 'IP3D', 'SV1', 'SoftMu']

    CalibrationChannelAliases = [
        "AntiKt4EMPFlow->AntiKt4EMPFlow,AntiKt4EMTopo,AntiKt4TopoEM,AntiKt4LCTopo"
    ]

    grades = cfgFlags.BTagging.Grades

    RNNIPConfig = {'rnnip': ''}

    JetTagCalibCondAlg = CompFactory.Analysis.JetTagCalibCondAlg
    jettagcalibcondalg = "JetTagCalibCondAlg"
    readkeycalibpath = "/GLOBAL/BTagCalib/RUN12"
    connSchema = "GLOBAL_OFL"
    if not cfgFlags.Input.isMC:
        readkeycalibpath = readkeycalibpath.replace("/GLOBAL/BTagCalib",
                                                    "/GLOBAL/Onl/BTagCalib")
        connSchema = "GLOBAL"
    histoskey = "JetTagCalibHistosKey"
    from IOVDbSvc.CondDB import conddb

    conddb.addFolder(connSchema,
                     readkeycalibpath,
                     className='CondAttrListCollection')
    JetTagCalib = JetTagCalibCondAlg(jettagcalibcondalg,
                                     ReadKeyCalibPath=readkeycalibpath,
                                     HistosKey=histoskey,
                                     taggers=taggerlist,
                                     channelAliases=CalibrationChannelAliases,
                                     IP2D_TrackGradePartitions=grades,
                                     RNNIP_NetworkConfig=RNNIPConfig)

    athCondSeq += conf2toConfigurable(JetTagCalib, indent="  ")

    acc.merge(
        JetParticleAssociationAlgCfg(cfgFlags, jetcol_name_without_Jets,
                                     "InDetTrackParticles",
                                     'BTagTrackToJetAssociator', **kwargs))

    SecVertexingAndAssociators = {
        'JetFitter': 'BTagTrackToJetAssociator',
        'SV1': 'BTagTrackToJetAssociator'
    }
    for k, v in SecVertexingAndAssociators.items():

        acc.merge(
            JetSecVtxFindingAlgCfg(cfgFlags, jetcol_name_without_Jets,
                                   "PrimaryVertices", k, v))

        acc.merge(
            JetSecVertexingAlgCfg(cfgFlags, BTaggingCollection,
                                  jetcol_name_without_Jets, "PrimaryVertices",
                                  k, v))

    acc.merge(
        JetBTaggingAlgCfg(cfgFlags,
                          BTaggingCollection=BTaggingCollection,
                          JetCollection=jetcol_name_without_Jets,
                          PrimaryVertexCollectionName="PrimaryVertices",
                          TaggerList=taggerlist,
                          SVandAssoc=SecVertexingAndAssociators))

    postTagDL2JetToTrainingMap = {
        'AntiKt4EMPFlow': [
            #'BTagging/201903/smt/antikt4empflow/network.json',
            'BTagging/201903/rnnip/antikt4empflow/network.json',
            'BTagging/201903/dl1r/antikt4empflow/network.json',
            'BTagging/201903/dl1/antikt4empflow/network.json',
            #'BTagging/201903/dl1rmu/antikt4empflow/network.json',
        ]
    }

    acc.merge(BTagTrackAugmenterAlgCfg(cfgFlags))

    acc.merge(
        BTagHighLevelAugmenterAlgCfg(cfgFlags,
                                     JetCollection=jetcol_name_without_Jets,
                                     BTagCollection=BTaggingCollection,
                                     Associator='BTagTrackToJetAssociator'))

    for jsonfile in postTagDL2JetToTrainingMap[jetcol_name_without_Jets]:
        acc.merge(
            HighLevelBTagAlgCfg(cfgFlags,
                                BTaggingCollection=BTaggingCollection,
                                TrackCollection='InDetTrackParticles',
                                NNFile=jsonfile))

    Configurable.configurableRun3Behavior = 0

    algs = findAllAlgorithms(acc.getSequence("AthAlgSeq"))

    for alg in algs:

        seq += conf2toConfigurable(alg)

    acc.wasMerged()

    return
Example #12
0
def bJetStep2Sequence():
    prmVtxKey = "HLT_IDVertex_FS"
    outputRoIName = "HLT_Roi_Bjet"

    from ViewAlgs.ViewAlgsConf import EventViewCreatorAlgorithm
    from DecisionHandling.DecisionHandlingConf import ViewCreatorCentredOnJetWithPVConstraintROITool
    InputMakerAlg = EventViewCreatorAlgorithm("IMBJet_step2")
    #
    newRoITool = ViewCreatorCentredOnJetWithPVConstraintROITool()
    newRoITool.RoisWriteHandleKey = recordable(outputRoIName)
    newRoITool.VertexReadHandleKey = prmVtxKey
    newRoITool.PrmVtxLink = prmVtxKey.replace("HLT_", "")
    #
    InputMakerAlg.mergeUsingFeature = True
    InputMakerAlg.RoITool = newRoITool
    #
    InputMakerAlg.Views = "BTagViews"
    InputMakerAlg.InViewRoIs = "InViewRoIs"
    #
    InputMakerAlg.RequireParentView = False
    InputMakerAlg.ViewFallThrough = True
    # BJet specific
    InputMakerAlg.PlaceJetInView = True
    InputMakerAlg.InViewJets = recordable("HLT_bJets")

    # Prepare data objects for view verifier
    viewDataObjects = [('TrigRoiDescriptorCollection',
                        'StoreGateSvc+' + InputMakerAlg.InViewRoIs),
                       ('xAOD::VertexContainer', 'StoreGateSvc+' + prmVtxKey),
                       ('xAOD::JetContainer',
                        'StoreGateSvc+' + InputMakerAlg.InViewJets)]

    # Second stage of Fast Tracking and Precision Tracking
    from TriggerMenuMT.HLTMenuConfig.Bjet.BjetTrackingConfiguration import getSecondStageBjetTracking
    secondStageAlgs, PTTrackParticles = getSecondStageBjetTracking(
        inputRoI=InputMakerAlg.InViewRoIs, dataObjects=viewDataObjects)

    from AthenaCommon.Configurable import Configurable
    Configurable.configurableRun3Behavior = 1

    # Flavour Tagging
    from TriggerMenuMT.HLTMenuConfig.Bjet.BjetFlavourTaggingConfiguration import getFlavourTagging
    acc_flavourTaggingAlgs, bTaggingContainerName = getFlavourTagging(
        inputJets=InputMakerAlg.InViewJets,
        inputVertex=prmVtxKey,
        inputTracks=PTTrackParticles[0])

    Configurable.configurableRun3Behavior = 0

    #Conversion of flavour-tagging algorithms from new to old-style
    from AthenaCommon.CFElements import findAllAlgorithms
    from AthenaConfiguration.ComponentAccumulator import conf2toConfigurable
    AllFlavourTaggingAlgs = []
    for alg in findAllAlgorithms(
            acc_flavourTaggingAlgs.getSequence("AthAlgSeq")):
        AllFlavourTaggingAlgs.append(conf2toConfigurable(alg))

    acc_flavourTaggingAlgs.wasMerged(
    )  #Needed to remove error message; Next we add all algorithms to sequence so this is kind of an old-style merge
    bJetBtagSequence = seqAND("bJetBtagSequence",
                              secondStageAlgs + AllFlavourTaggingAlgs)
    InputMakerAlg.ViewNodeName = "bJetBtagSequence"

    # Sequence
    BjetAthSequence = seqAND("BjetAthSequence_step2",
                             [InputMakerAlg, bJetBtagSequence])

    from TrigBjetHypo.TrigBjetHypoConf import TrigBjetBtagHypoAlgMT
    hypo = TrigBjetBtagHypoAlgMT("TrigBjetBtagHypoAlg")
    # keys
    hypo.BTaggedJetKey = InputMakerAlg.InViewJets
    hypo.BTaggingKey = bTaggingContainerName
    hypo.TracksKey = PTTrackParticles[0]
    hypo.PrmVtxKey = newRoITool.VertexReadHandleKey
    # links for navigation
    hypo.BTaggingLink = bTaggingContainerName.replace("HLT_", "")
    hypo.PrmVtxLink = newRoITool.PrmVtxLink

    from TrigBjetHypo.TrigBjetOnlineMonitoringMTConfig import TrigBjetOnlineMonitoring
    hypo.MonTool = TrigBjetOnlineMonitoring()

    from TrigBjetHypo.TrigBjetBtagHypoTool import TrigBjetBtagHypoToolFromDict
    return MenuSequence(Sequence=BjetAthSequence,
                        Maker=InputMakerAlg,
                        Hypo=hypo,
                        HypoToolGen=TrigBjetBtagHypoToolFromDict)
Example #13
0
def jetRecoSequence(dummyFlags,
                    dataSource,
                    RoIs='HLT_FSJETRoI',
                    **jetRecoDict):

    jetDefString = jetRecoDictToString(jetRecoDict)
    recoSeq = parOR("JetRecSeq_" + jetDefString, [])

    recoAlg = jetRecoDict["recoAlg"]
    doGrooming = recoAlg.endswith("t")  # Maybe other grooming strategies
    doRecluster = recoAlg.endswith("r")
    jetNamePrefix = "HLT_"

    from TrigEDMConfig.TriggerEDMRun3 import recordable
    from JetRecConfig import ConfigurableCompatibility
    ConfigurableCompatibility.Convert2Configurable = True
    from JetRecConfig.JetRecConfig import getConstitPJGAlg, getJetAlgorithm
    if doRecluster:
        # Reclustering -- recursively call the basic jet reco and add this to the sequence,
        # then add another jet algorithm to run the reclustering step
        basicJetRecoDict = dict(jetRecoDict)
        basicJetRecoDict["recoAlg"] = "a4"  # Standard size for reclustered
        (basicJetRecoSequence,
         basicJetsName) = RecoFragmentsPool.retrieve(jetRecoSequence,
                                                     None,
                                                     dataSource=dataSource,
                                                     **basicJetRecoDict)
        recoSeq += basicJetRecoSequence

        rcJetPtMin = 15e3  # 15 GeV minimum pt for jets to be reclustered
        from JetRec.JetRecConf import JetViewAlg
        filteredJetsName = basicJetsName + "_pt15"
        recoSeq += JetViewAlg("jetview_" + filteredJetsName,
                              InputContainer=basicJetsName,
                              OutputContainer=filteredJetsName,
                              PtMin=rcJetPtMin)

        rcJetDef = JetRecoConfiguration.defineReclusteredJets(jetRecoDict)
        rcJetDef.inputdef.inputname = filteredJetsName
        rcJetsFullName = jetNamePrefix + rcJetDef.basename + "RCJets_" + jetRecoDict[
            "jetCalib"]
        rcModList = []  # Could set substructure mods
        rcJetDef.modifiers = rcModList

        rcConstitPJAlg = getConstitPJGAlg(rcJetDef.inputdef)
        rcConstitPJKey = rcConstitPJAlg.OutputContainer
        recoSeq += conf2toConfigurable(rcConstitPJAlg)

        # Get online monitoring tool
        from JetRec import JetOnlineMon
        monTool = JetOnlineMon.getMonTool_TrigJetAlgorithm("HLTJets/" +
                                                           rcJetsFullName +
                                                           "/")

        rcPJs = [rcConstitPJKey]
        rcJetRecAlg = getJetAlgorithm(rcJetsFullName, rcJetDef, rcPJs,
                                      rcModList, monTool)

        recoSeq += conf2toConfigurable(rcJetRecAlg)

        sequenceOut = recordable(rcJetsFullName)

    elif doGrooming:
        # Grooming needs to be set up similarly to reclustering
        # --> build ungroomed jets, then add a grooming alg
        ungroomedJetRecoDict = dict(jetRecoDict)
        ungroomedJetRecoDict["recoAlg"] = ungroomedJetRecoDict[
            "recoAlg"].rstrip("t")  # Drop grooming spec
        ungroomedJetRecoDict["jetCalib"] = "nojcalib"  # No need to calibrate
        ungroomedDef = JetRecoConfiguration.defineJets(ungroomedJetRecoDict)

        (ungroomedJetRecoSequence,
         ungroomedJetsName) = RecoFragmentsPool.retrieve(
             jetRecoSequence,
             None,
             dataSource=dataSource,
             **ungroomedJetRecoDict)
        recoSeq += conf2toConfigurable(ungroomedJetRecoSequence)
        # Need to forward the pseudojets of the parents to the groomer
        parentpjs = getattr(
            ungroomedJetRecoSequence,
            "jetalg_{}".format(ungroomedJetsName)).Tools[0].InputPseudoJets

        groomDef = JetRecoConfiguration.defineGroomedJets(
            jetRecoDict, ungroomedDef, ungroomedJetsName)
        groomedJetsFullName = jetNamePrefix + groomDef.basename + "Jets_" + jetRecoDict[
            "jetCalib"]

        groomedModList = JetRecoConfiguration.defineCalibFilterMods(
            jetRecoDict, dataSource)
        # Can add substructure mods here

        # Get online monitoring tool
        from JetRec import JetOnlineMon
        monTool = JetOnlineMon.getMonTool_TrigJetAlgorithm(
            "HLTJets/" + groomedJetsFullName + "/")

        from JetRecConfig.JetGroomConfig import getJetGroomAlg
        groomalg = getJetGroomAlg(groomedJetsFullName, groomDef, parentpjs,
                                  groomedModList, monTool)
        recoSeq += conf2toConfigurable(groomalg)

        sequenceOut = recordable(groomedJetsFullName)
    else:
        # Normal jet reconstruction, no reclustering or grooming

        # Start by adding the topocluster reco sequence
        # This makes EM clusters!
        from TriggerMenuMT.HLTMenuConfig.CommonSequences.CaloSequenceSetup import (
            caloClusterRecoSequence, LCCaloClusterRecoSequence)
        if jetRecoDict["calib"] == "em":
            topoClusterSequence, clustersKey = RecoFragmentsPool.retrieve(
                caloClusterRecoSequence, flags=None, RoIs=RoIs)
        elif jetRecoDict["calib"] == "lcw":
            topoClusterSequence, clustersKey = RecoFragmentsPool.retrieve(
                LCCaloClusterRecoSequence, flags=None, RoIs=RoIs)
        else:
            raise ValueError("Invalid value for calib: '{}'".format(
                jetRecoDict["calib"]))
        recoSeq += topoClusterSequence

        # Set up tracking sequence -- may need to reorganise or relocate
        # depending on how we want to handle HLT preselection
        trkcolls = None
        if jetRecoDict["trkopt"] != "notrk":
            from .JetTrackingConfig import JetTrackingSequence
            (jettrkseq, trkcolls) = RecoFragmentsPool.retrieve(
                JetTrackingSequence,
                None,
                trkopt=jetRecoDict["trkopt"],
                RoIs=RoIs)
            recoSeq += jettrkseq

        # Potentially add particle flow reconstruction
        # Work in progress
        if "pf" in jetRecoDict["dataType"]:
            if jetRecoDict["trkopt"] == "notrk":
                raise RuntimeError(
                    "PFlow jet chain requested with no tracking option!")
            from eflowRec.PFHLTSequence import PFHLTSequence
            (pfseq, pfoPrefix) = RecoFragmentsPool.retrieve(
                PFHLTSequence,
                None,
                clustersin=clustersKey,
                tracktype=jetRecoDict["trkopt"])
            recoSeq += pfseq
            jetDef = JetRecoConfiguration.defineJets(jetRecoDict,
                                                     pfoPrefix=pfoPrefix)
        else:
            jetDef = JetRecoConfiguration.defineJets(jetRecoDict,
                                                     clustersKey=clustersKey)
        useConstitMods = ["sktc", "cssktc", "pf", "csskpf"]
        doConstitMods = jetRecoDict["dataType"] in useConstitMods

        # chosen jet collection
        jetsFullName = jetNamePrefix + jetDef.basename + "Jets_" + jetRecoDict[
            "jetCalib"]
        if jetRecoDict["trkopt"] != "notrk":
            jetsFullName += "_{}".format(jetRecoDict["trkopt"])
        sequenceOut = recordable(jetsFullName)

        if doConstitMods:
            # Get online monitoring jet rec tool
            from JetRecTools import OnlineMon
            monJetRecTool = OnlineMon.getMonTool_Algorithm("HLTJets/" +
                                                           jetsFullName + "/")

            from JetRecConfig.ConstModHelpers import getConstitModAlg
            if jetRecoDict["trkopt"] == "notrk":
                recoSeq += getConstitModAlg(jetDef.inputdef,
                                            suffix="HLT",
                                            tvaKey="JetTrackVtxAssoc",
                                            vtxKey="PrimaryVertices",
                                            monTool=monJetRecTool)
            else:
                recoSeq += getConstitModAlg(jetDef.inputdef,
                                            suffix="HLT",
                                            tvaKey=trkcolls["TVA"],
                                            vtxKey=trkcolls["Vertices"],
                                            monTool=monJetRecTool)

        # Add the PseudoJetGetter alg to the sequence
        constitPJAlg = getConstitPJGAlg(jetDef.inputdef)
        constitPJKey = constitPJAlg.OutputContainer
        recoSeq += conf2toConfigurable(constitPJAlg)
        # Basic list of PseudoJets is just the constituents
        # Append ghosts (tracks) if desired
        pjs = [constitPJKey]
        if trkcolls:
            pjs.append(trkcolls["GhostTracks"])

        from JetRecConfig import JetRecConfig
        jetModList = []
        if jetRecoDict["trkopt"] != "notrk":
            trkMods = JetRecoConfiguration.defineTrackMods(
                jetRecoDict["trkopt"])
            jetModList += trkMods

        rhoKey = "auto"
        if "sub" in jetRecoDict["jetCalib"]:
            # Add the event shape alg if needed for area subtraction
            eventShapeAlg = JetRecConfig.getEventShapeAlg(
                jetDef.inputdef, constitPJKey, "HLT_")
            recoSeq += conf2toConfigurable(eventShapeAlg)
            # Not currently written because impossible to merge
            # across event views, which is maybe a concern in
            # the case of regional PFlow
            rhoKey = eventShapeAlg.EventDensityTool.OutputContainer

        # Import the standard jet modifiers as defined for offline
        # We can add/configure these differently if desired. In particular,
        # we could define a TriggerJetMods module if settings need to
        # diverge substantially e.g. track/vertex collections
        calibMods = JetRecoConfiguration.defineCalibFilterMods(
            jetRecoDict, dataSource, rhoKey)
        jetModList += calibMods

        # Get online monitoring tool
        from JetRec import JetOnlineMon
        monTool = JetOnlineMon.getMonTool_TrigJetAlgorithm("HLTJets/" +
                                                           jetsFullName + "/")

        # Generate a JetAlgorithm to run the jet finding and modifiers
        # (via a JetRecTool instance).
        jetRecAlg = JetRecConfig.getJetAlgorithm(jetsFullName, jetDef, pjs,
                                                 jetModList, monTool)
        recoSeq += conf2toConfigurable(jetRecAlg)
        # End of basic jet reco
        pass

    return (recoSeq, sequenceOut)