Exemplo n.º 1
0
##
## B-Jet trigger information:
##
if triggerAvailable:
    from TrigBJetD3PDMaker.TrigBJetD3PD import TrigBJetD3PDObjects
    TrigBJetD3PDObjects(d3pdalg,
                        level=1,
                        addNaviInfo=True,
                        addConfigInfo=False)
    pass

##
## Offline MET information:
##
from MissingETD3PDMaker.MissingETD3PDObject import MissingETD3PDObject
d3pdalg += MissingETD3PDObject(3, allowMissing=True)

##
## MET trigger information:
##
if triggerAvailable:
    from TrigMissingETD3PDMaker.TrigMETD3PD import TrigMETD3PDObjects
    TrigMETD3PDObjects(d3pdalg)
    pass

##
## Additional offline information:
##
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags
TrackD3PDFlags.vertexPositionLevelOfDetails = 1
TrackD3PDFlags.storeVertexTrackIndexAssociation = False
Exemplo n.º 2
0
def backgroundD3PD(alg=None,
                   level=10,
                   file='background.root',
                   tuplename='background',
                   flags=BackgroundD3PDMakerFlags,
                   **kw):

    preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
    if (not hasattr(topSequence, 'BeamBackgroundFiller')
            and not hasattr(preseq, 'BeamBackgroundFiller')):
        if cfgKeyStore.isInInput("Trk::SegmentCollection",
                                 "ConvertedMBoySegments"):
            from RecBackgroundAlgs import RecBackgroundAlgsConf
            preseq += RecBackgroundAlgsConf.BeamBackgroundFiller()

    if (not hasattr(topSequence, 'BeamBackgroundFillerMoore')
            and not hasattr(preseq, 'BeamBackgroundFillerMoore')):
        if cfgKeyStore.isInInput("Trk::SegmentCollection", "MooreSegments"):
            from RecBackgroundAlgs.RecBackgroundAlgsConf import BeamBackgroundFiller
            BeamBackgroundFillerMoore = BeamBackgroundFiller(
                'BeamBackgroundFillerMoore',
                muonSegmentContainerKey='MooreSegments',
                BeamBackgroundKey='BeamBackgroundDataMoore')
            preseq += BeamBackgroundFillerMoore

    # The core algorithm
    if not alg:
        from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
        alg = MSMgr.NewRootStream(tuplename, file)

    #Event level info
    alg += EventInfoD3PDObject(**_args(1, 'EventInfo', kw))
    if globalflags.DataSource == "data":
        alg += LBLengthD3PDObject(**_args(0, 'LBLength', kw))

    if rec.doTruth():
        from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject
        alg += GenEventD3PDObject(**_args(0, 'GenEvent', kw))

    if rec.doTrigger():
        alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw))
        addTrigConfMetadata(alg)

        bcToolType = ""
        if globalflags.DataSource == "data":
            bcToolType = "LHC"
        addBunchStructureMetadata(alg, bcToolType)

        alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw))

        if flags.AddTriggerBits():
            alg += getBkgdTriggerBitsD3PDObject([])

    alg += BackgroundWordD3PDObject(**_args(0, 'BkgWord', kw))
    if flags.doLUCID():
        alg += Lucid_RawDataD3PDObject(**_args(0, 'Lucid', kw))
    alg += RawInfoSummaryForTagD3PDObject(**_args(0, 'SumForTag', kw))

    alg += MBTSD3PDObject(**_args(0, 'MBTS', kw))
    alg += LArCollisionTimeD3PDObject(**_args(0, 'LArTimeDiff', kw))

    if flags.doMet():
        alg += MissingETD3PDObject(**_args(1,
                                           'MET_RefFinal',
                                           kw,
                                           sgkey='MET_RefFinal',
                                           prefix='MET_RefFinal',
                                           allowMissing=True))

    alg += MuonD3PDObject(
        **_args(0,
                'Muon',
                kw,
                sgkey='MuonCollection',
                prefix='mu_',
                include=[
                    "Isolation", "Quality", "MuonTimingFillerTool",
                    "MuonTileTimeTool", "ChamberT0"
                ],
                allowMissing=True))
    alg += MuonD3PDObject(
        **_args(0,
                'MuidMuon',
                kw,
                sgkey='MuidMuonCollection',
                prefix='mu_muid_',
                include=[
                    "Isolation", "Quality", "MuonTimingFillerTool",
                    "MuonTileTimeTool", "ChamberT0"
                ],
                allowMissing=True))
    alg += MuonD3PDObject(
        **_args(0,
                'StacoMuon',
                kw,
                sgkey='StacoMuonCollection',
                prefix='mu_staco_',
                include=[
                    "Isolation", "Quality", "MuonTimingFillerTool",
                    "MuonTileTimeTool", "ChamberT0"
                ],
                allowMissing=True))
    if flags.doCaloMuon():
        alg += MuonD3PDObject(
            **_args(0,
                    'CaloMuon',
                    kw,
                    sgkey='CaloMuonCollection',
                    prefix='mu_calo_',
                    include=[
                        "Isolation", "Quality", "MuonTimingFillerTool",
                        "MuonTileTimeTool", "ChamberT0"
                    ],
                    allowMissing=True))

    alg += MuonSegmentD3PDObject(**_args(
        1,
        'MuonSeg',
        kw,
        sgkey='MuonSegments',
        prefix='museg_',
        # MooreSegmentT0 takes the default time
        # MuonboySegmentT0 recalculates time (see MuonSegmentD3PDObject.py and MuonSegmentT0FillerTool.cxx)
        include=['MooreSegmentT0'],
        exclude=['MuonboySegmentT0'],
        allowMissing=True))
    alg += MuonSegmentD3PDObject(**_args(1,
                                         'MooreSeg',
                                         kw,
                                         sgkey='MooreSegments',
                                         prefix='mooreseg_',
                                         include=['MooreSegmentT0'],
                                         exclude=['MuonboySegmentT0'],
                                         allowMissing=True))
    alg += MuonSegmentD3PDObject(**_args(1,
                                         'MboySeg',
                                         kw,
                                         sgkey='ConvertedMBoySegments',
                                         prefix='mboyseg_',
                                         include=['MuonboySegmentT0'],
                                         exclude=['MooreSegmentT0'],
                                         allowMissing=True))
    if flags.doMuGirlSeg():
        alg += MuonSegmentD3PDObject(**_args(1,
                                             'MuGirlSeg',
                                             kw,
                                             sgkey='MuGirlSegments',
                                             prefix='mgseg_',
                                             include=['MooreSegmentT0'],
                                             exclude=['MuonboySegmentT0'],
                                             allowMissing=True))

    if flags.doTrk():
        alg += xAODTrackParticleD3PDObject(
            **_args(0, 'TrackParticle', kw, prefix='trk_'))

    if flags.doMuonHits():
        alg += MdtPrepDataD3PDObject(0)
        alg += RpcPrepDataD3PDObject(0)
        alg += CscPrepDataD3PDObject(0)
        alg += TgcPrepDataD3PDObject(0)

        alg += TgcPrepDataD3PDObject(**_args(0,
                                             'TGC_MeasurementsPriorBC',
                                             kw,
                                             sgkey='TGC_MeasurementsPriorBC',
                                             prefix='tgcPriorBC_',
                                             label='TgcPrepDataPriorBC'))
        alg += TgcPrepDataD3PDObject(**_args(0,
                                             'TGC_MeasurementsNextBC',
                                             kw,
                                             sgkey='TGC_MeasurementsNextBC',
                                             prefix='tgcNextBC_',
                                             label='TgcPrepDataNextBC'))

    if flags.doCaloJet():
        #alg += JetD3PDObject (**_args(4,'AntiKt4TopoEMJets', kw,  sgkey='AntiKt4TopoEMJets',   prefix='AntiKt4TopoEM_', include='BeamBackground' ))
        if cfgKeyStore.isInInput("Trk::SegmentCollection",
                                 "ConvertedMBoySegments"):
            alg += JetD3PDObject(
                **_args(4,
                        'AntiKt4TopoEMJets',
                        kw,
                        sgkey='AntiKt4TopoEMJets',
                        prefix='AntiKt4TopoEM_',
                        include=['BeamBackground'],
                        exclude=[
                            'JetVertexFraction', 'JVtx', 'ActiveArea',
                            'TruthMF', 'TracksMoments'
                        ],
                        BeamBackground_BeamBackgroundKey='BeamBackgroundData'))
        else:
            alg += JetD3PDObject(
                **_args(4,
                        'AntiKt4TopoEMJets',
                        kw,
                        sgkey='AntiKt4TopoEMJets',
                        prefix='AntiKt4TopoEM_',
                        exclude=[
                            'JetVertexFraction', 'JVtx', 'ActiveArea',
                            'TruthMF', 'TracksMoments'
                        ]))
    else:
        alg += JetD3PDObject(
            **_args(4,
                    'AntiKt4TrackJets',
                    kw,
                    sgkey='AntiKt4TrackJets',
                    prefix='AntiKt4Track_',
                    exclude=[
                        'JetVertexFraction', 'JVtx', 'ActiveArea', 'TruthMF',
                        'TracksMoments'
                    ]))

    alg += PrimaryxAODVertexD3PDObject(0)

    if flags.doBeamBkgd():
        #alg += BeamBackgroundD3PDObject(1)
        if cfgKeyStore.isInInput("Trk::SegmentCollection",
                                 "ConvertedMBoySegments"):
            alg += BeamBackgroundD3PDObject(
                **_args(1,
                        'BeamBackgroundData',
                        kw,
                        sgkey='BeamBackgroundData',
                        prefix='bb_',
                        bbJetIndex_Target='AntiKt4TopoEM_',
                        bbClusterIndex_Target='cl_'))
        if cfgKeyStore.isInInput("Trk::SegmentCollection", "MooreSegments"):
            alg += BeamBackgroundD3PDObject(
                **_args(1,
                        'BeamBackgroundData',
                        kw,
                        sgkey='BeamBackgroundDataMoore',
                        prefix='bbMoore_',
                        bbJetIndex_Target='AntiKt4TopoEM_',
                        bbClusterIndex_Target='cl_'))

    if flags.doBCM():
        alg += BcmRdoFlatD3PDObject(**_args(0, 'BCMRdo', kw))

    if flags.doZDC():
        if globalflags.DataSource == "data": alg += ZdcD3PDObject(10)

    if flags.doPixelClus():
        from InDetD3PDMaker.PixelClusterD3PDObject import PixelClusterD3PDObject
        alg += PixelClusterD3PDObject(0)

    if flags.doCaloClus():
        from CaloSysD3PDMaker.ClusterD3PDObject import ClusterD3PDObject
        alg += ClusterD3PDObject(1)

    return alg
Exemplo n.º 3
0
def physicsD3PD(alg=None,
                trigalg=None,
                file='physics.root',
                tuplename='physics',
                **kw):

    # Core algorithm
    # By default the user of this function should have created an algorithm already.
    # But for backwards compatibility let the function create its own algorithm if
    # needed...
    if not alg:
        from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
        alg = MSMgr.NewRootStream(tuplename, file)

    alg += EventInfoD3PDObject(**_args(10, 'EventInfo', kw))

    # Segregate trigger decision flags in a separate tree.
    if not trigalg:
        from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
        trigalg = MSMgr.NewRootStream(tuplename + ':' + tuplename + 'TrigDec',
                                      FileName=file,
                                      TreeName=tuplename + 'TrigDec')
    trigalg += EventInfoD3PDObject(0)
    alg.Stream.trigDecisionTree = trigalg

    # Add bunch structure metadata.
    from TriggerD3PDMaker.BunchStructureMetadata \
         import addBunchStructureMetadata
    addBunchStructureMetadata(alg)

    # Make track jets, but we can only do this if we have vertices.
    if testSGKey('VxContainer', 'VxPrimaryCandidate'):
        from D3PDMakerConfig.createTrackJets import createTrackJets
        createTrackJets(AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()))
        alg += JetD3PDObject(**_args(
            -1, 'TrackJet', kw, prefix='trackjet_', sgkey='AntiKtZ5TrackJets'))
        k = 'Electron_EgammaTrackJetSignedIPAndPTRel_target'
        if not kw.has_key(k):
            kw[k] = 'trackjet_'

    alg += LArCollisionTimeD3PDObject(**_args(10, 'LArCollisionTime', kw))

    # Electron/Photon blocks

    alg += ElectronD3PDObject(
        **_args(10,
                'Electron',
                kw,
                EgammaJetSignedIPAndPTRel_target='jet_antikt4h1topo_'))
    alg += PhotonD3PDObject(
        **_args(10, 'Photon', kw, ConversionVertexTrackIndex_target='trk'))
    if testSGKey('ElectronContainer', D3PDMakerFlags.GSFElectronSGKey()):
        alg += GSFElectronD3PDObject(
            **_args(level,
                    'GSFElectron',
                    kw,
                    sgkey=D3PDMakerFlags.GSFElectronSGKey(),
                    prefix='el_gsf_'))

    # Muon blocks

    alg += MuonD3PDObject(**_args(10,
                                  'MuidMuon',
                                  kw,
                                  sgkey='MuidMuonCollection',
                                  prefix='mu_muid_',
                                  allowMissing=True))
    alg += MuonD3PDObject(**_args(10,
                                  'StacoMuon',
                                  kw,
                                  sgkey='StacoMuonCollection',
                                  prefix='mu_staco_',
                                  allowMissing=True))
    alg += MuonD3PDObject(**_args(
        10, 'Muons', kw, sgkey='Muons', prefix='mu_', allowMissing=True))

    # Tau block

    alg += TauD3PDObject(**_args(1, 'Tau', kw))

    # Jet blocks

    alg += JetD3PDObject(**_args(9,
                                 'AK4TopoJet',
                                 kw,
                                 sgkey='AntiKt4TopoEMJets,' +
                                 'AntiKt4TopoJets,' + 'AntiKt4H1TopoJets',
                                 prefix='jet_antikt4h1topo_',
                                 ConstitIndex_Target='cl_',
                                 exclude=['Constituents'],
                                 allowMissing=True))
    alg += JetD3PDObject(**_args(6,
                                 'AK4TowerJet',
                                 kw,
                                 sgkey='AntiKt4TowerAODJets,' +
                                 'AntiKt4TowerJets,' + 'AntiKt4H1TowerJets',
                                 prefix='jet_antikt4h1tower_',
                                 exclude=['Constituents'],
                                 allowMissing=True))
    alg += JetD3PDObject(**_args(6,
                                 'AK6TowerJet',
                                 kw,
                                 sgkey='AntiKt6TowerAODJets,' +
                                 'AntiKt6TowerJets,' + 'AntiKt6H1TowerJets',
                                 prefix='jet_antikt6h1tower_',
                                 exclude=['Constituents'],
                                 allowMissing=True))
    #alg += JetD3PDObject              (**_args ( 9, 'AK4TopoJetLC', kw,
    #                                             sgkey='AntiKt4LCTopoJets', prefix='jet_antikt4lctopo_'))
    #alg += JetD3PDObject              (**_args ( 9, 'AK6TopoJetLC', kw,
    #                                             sgkey='AntiKt6LCTopoMyJets', prefix='jet_antikt6lctopo_'))
    #alg += JetD3PDObject              (**_args ( 9, 'AK6TopoJetH1', kw,
    #                                             sgkey='AntiKt6H1TopoMyJets', prefix='jet_antikt6h1topo_'))

    # MET blocks

    alg += MissingETD3PDObject(**_args(10, 'MissingET', kw, allowMissing=True))
    alg += MissingETGoodnessD3PDObject(**_args(2, 'METGoodness', kw))

    # track and cluster blocks

    alg += ClusterD3PDObject(**_args(1, 'Cluster', kw))
    alg += EMClusterD3PDObject(**_args(2, 'EMCluster', kw))

    # Many of these are just being set to the defaults --- that's because
    # they're being changed in TrigEgamma...
    alg += TrackParticleD3PDObject(
        **_args(3,
                'TrackParticle',
                kw,
                TruthParticleTarget='mc_',
                storeTruthInfo=True,
                trackParametersAtGlobalPerigeeLevelOfDetails=3,
                storeDiagonalCovarianceAsErrors=True))

    # MBTS

    alg += MBTSD3PDObject(**_args(10, 'MBTS', kw))
    alg += MBTSTimeD3PDObject(**_args(10, 'MBTSTime', kw))
    alg += MBTSTriggerBitsD3PDObject(**_args(10, 'MBTSTriggerBits', kw))
    alg += CollisionDecisionD3PDObject(**_args(10, 'CollisionDecision', kw))

    # ZDC
    alg += ZDCTriggerBitsD3PDObject(**_args(10, 'ZDCTriggerBits', kw))

    # Primary vertex block - May be missing in single-beam data.

    alg += PrimaryVertexD3PDObject(
        **_args(1,
                'PrimaryVertex',
                kw,
                allowMissing=True,
                sgkey=D3PDMakerFlags.VertexSGKey(),
                prefix='vxp_',
                storeVertexTrackAssociation=True,
                storeDiagonalCovarianceAsErrors=True))

    # Truth

    if rec.doTruth():
        from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
        alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw))
        alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw))
        alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw))
        alg += JetD3PDObject(**_args(3,
                                     'AK4TruthJet',
                                     kw,
                                     sgkey='AntiKt4TruthJets',
                                     prefix='jet_antikt4truth_',
                                     allowMissing=True))
        #alg += JetD3PDObject          (**_args ( 3, 'AK6Ttruth', kw,
        #                                         sgkey='AntiKt6TruthJets',
        #                                         prefix='jet_antikt6truth_'))

    # Trigger

    if D3PDMakerFlags.DoTrigger():
        from TriggerD3PDMaker.TrigDecisionD3PDObject \
             import TrigDecisionD3PDObject
        alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw))
        TrigEgammaD3PDObjects(alg, **_args(1, 'TrigEgamma', kw))

        alg += egammaTriggerBitsD3PDObject(**_args(2, 'EgammaTriggerBits', kw))
        alg += MuonTriggerBitsD3PDObject(**_args(2, 'MuonTriggerBits', kw))
        alg += METD3PDTriggerBitsObject(**_args(2, 'METTriggerBits', kw))

        from TriggerD3PDMaker.EnergySumROID3PDObject import EnergySumROID3PDObject
        from TrigMissingETD3PDMaker.TrigMETD3PDObject import TrigMETD3PDObject

        alg += EnergySumROID3PDObject(**_args(
            2, 'EnergySumROI', kw, prefix="trig_L1_esum_", allowMissing=True))

        # The LVL2 information:
        alg += TrigMETD3PDObject(**_args(
            2, 'TrigMETL2', kw, prefix="trig_L2_met_",
            sgkey="HLT_T2MissingET"))

        # The EF information:
        alg += TrigMETD3PDObject(**_args(2,
                                         'TrigMETEF',
                                         kw,
                                         prefix="trig_EF_met_",
                                         sgkey="HLT_TrigEFMissingET"))

        from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject
        alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw))

# Event metadata

    alg.MetadataTools += [LBMetadataConfig()]

    if D3PDMakerFlags.FilterCollCand():
        from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
        alg.filterSeq += CollisionFilterAlg(tuplename + '_CollCandFilter')

    return alg
Exemplo n.º 4
0
    'MET_RefMuon_Track_SumEt', 'MET_Muon_Isol_Comps', 'MET_Muon_NonIsol_Comps',
    'MET_Muon_Total_Comps', 'MET_Muon_Isol_SumEt', 'MET_Muon_NonIsol_SumEt',
    'MET_Muon_Total_SumEt', 'MET_CellOut_Regions'
]

METIncludes += [
    'MET_RefFinal_STVF', 'MET_CellOut_Eflow_STVF', 'MET_CellOut_Eflow_JetArea',
    'MET_RefJet_JVF', 'MET_RefJet_JVFCut', 'MET_CellOut_Eflow_JetAreaJVF',
    'MET_CellOut_Eflow_JetAreaRhoEta5JVF', 'MET_RefFinal_STVF_Comps',
    'MET_RefFinal_STVF_SumEt', ' MET_RefFinal_STVF_Regions'
]

kw = {}
alg += MissingETD3PDObject(**_args(0,
                                   'MissingEt',
                                   kw,
                                   allowMissing=True,
                                   include=METIncludes,
                                   exclude=["MET_Cluster_Weights"]))

#####Jet objects

from JetD3PDMaker.JetD3PDObject import JetD3PDObject
from JetD3PDMaker.JetD3PDMakerConf import *
import JetD3PDMaker
from JetRecTools.JetRecToolsConf import *
from JetRec.JetMomentGetter import make_JetMomentGetter

jetIncludes = [
    'Kinematics', 'DQMoments', 'EMFraction', 'JESMoments', 'EMScale', 'JVtx',
    'BTagDefault', 'BTag', 'TrueFlavorComponents', 'Samplings',
    'BTagComponents', 'Constituents', 'ConstituentScale', 'CaloQual',
Exemplo n.º 5
0
def egammaD3PD(alg=None,
               trigalg=None,
               level=10,
               file='egamma.root',
               tuplename='egamma',
               **kw):

    preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
    createxAOD(preseq)

    if not cfgKeyStore.isInInput('xAOD::ElectronContainer', 'AllElectrons'):
        preseq += MergeElectrons()

    # Core algorithm
    # By default the user of this function should have created an algorithm already.
    # But for backwards compatibility let the function create its own algorithm if
    # needed...
    if not alg:
        from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
        alg = MSMgr.NewRootStream(tuplename, file)

    alg += EventInfoD3PDObject(**_args(level, 'EventInfo', kw))

    # Segregate trigger decision flags in a separate tree.
    if not trigalg:
        from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
        trigalg = MSMgr.NewRootStream(tuplename + ':' + tuplename + 'TrigDec',
                                      FileName=file,
                                      TreeName=tuplename + 'TrigDec')

    trigalg += EventInfoD3PDObject(0)
    alg.Stream.trigDecisionTree = trigalg

    # Add bunch structure metadata.
    from TriggerD3PDMaker.BunchStructureMetadata \
         import addBunchStructureMetadata
    addBunchStructureMetadata(alg)

    alg += LArCollisionTimeD3PDObject(**_args(level, 'LArCollisionTime', kw))
    alg += ElectronD3PDObject(**_args(
        level, 'Electron', kw, EgammaJetSignedIPAndPTRel_target='jet_'))
    alg += PhotonD3PDObject(**_args(level, 'Photon', kw))

    # # Additional muon variables for Zg skims.
    # if not MuonD3PDObject.allBlocknames().has_key("MuonScatteringAngleSignificance"):
    #     from AthenaCommon.AppMgr import ToolSvc
    #     muonScatteringSigTool=None
    #     if hasattr(ToolSvc, "MuonScatteringSigTool"):
    #         muonScatteringSigTool=ToolSvc.MuonScatteringSigTool
    #     from JetTagD3PDMaker import MuonScatteringAngleSignificanceFillerTool
    #     MuonD3PDObject.defineBlock (100, "MuonScatteringAngleSignificance",
    #                                 MuonScatteringAngleSignificanceFillerTool,
    #                                 ScatteringSigTool=muonScatteringSigTool)
    alg += MuonD3PDObject(**_args(
        10,
        'Muons',
        kw,
        sgkey='StacoMuonCollection,Muons',
        prefix='mu_',
        include=[
            "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex",
            "L1InfoIndex", "MuonScatteringAngleSignificance"
        ],
        exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
        allowMissing=True))

    alg += JetD3PDObject(
        **_args(0, 'Jet', kw, include=['JetQual', 'DQMoments']))
    alg += MBTSD3PDObject(**_args(level, 'MBTS', kw))
    alg += MBTSTimeD3PDObject(**_args(level, 'MBTSTime', kw))
    # alg += MBTSTriggerBitsD3PDObject  (**_args (level, 'MBTSTriggerBits', kw))
    # alg += ZDCTriggerBitsD3PDObject   (**_args (level, 'ZDCTriggerBits', kw))
    alg += CollisionDecisionD3PDObject(**_args(level, 'CollisionDecision', kw))
    alg += MissingETD3PDObject(**_args(level,
                                       'MissingET',
                                       kw,
                                       sgkey='MET_Core_AntiKt4EMTopo',
                                       prefix='MET_RefFinal_'))
    if D3PDMakerFlags.DoTrigger():
        from TriggerD3PDMaker.TrigDecisionD3PDObject \
             import TrigDecisionD3PDObject
        alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw))
        #TrigEgammaD3PDObjects (alg, **_args (1, 'TrigEgamma', kw,
        #                                     TrigEMCluster_level = 2))

    #     from TriggerD3PDMaker.EnergySumROID3PDObject import EnergySumROID3PDObject
    #     from TrigMissingETD3PDMaker.TrigMETD3PDObject import TrigMETD3PDObject

    #     alg += EnergySumROID3PDObject(**_args (level, 'EnergySumROI', kw,
    #                                            prefix = "trig_L1_esum_",
    #                                            allowMissing = True))

    #     # The LVL2 information:
    #     alg += TrigMETD3PDObject(**_args( level, 'TrigMETL2', kw,
    #                                       prefix = "trig_L2_met_",
    #                                       sgkey = "HLT_T2MissingET" ))
    #     if cfgKeyStore.isInInputFile( "TrigMissingETContainer", "HLT_L2MissingET_FEB" ):
    #         alg += TrigMETD3PDObject(**_args( level, 'TrigMETL2_FEB', kw,
    #                                           prefix = "trig_L2_feb_met_",
    #                                           sgkey = "HLT_L2MissingET_FEB" ))

    #     # The EF information:
    #     alg += TrigMETD3PDObject(**_args ( level, 'TrigMETEF', kw,
    #                                        prefix = "trig_EF_met_",
    #                                        sgkey = "HLT_TrigEFMissingET" ))

    #     from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject
    #     alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw))

    # May be missing in single-beam data.
    alg += PrimaryxAODVertexD3PDObject(**_args(
        1,
        'PrimaryVertex',
        kw,
        #allowMissing = True,
        sgkey=D3PDMakerFlags.VertexSGKey(),
        prefix='vxp_',
        storeVertexTrackIndexAssociation=False,
        storeVertexTrackAssociation=True,
        storeDiagonalCovarianceAsErrors=True))

    if rec.doTruth():
        from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
        alg += TruthMuonD3PDObject(**_args(level, 'TruthMuon', kw))
        alg += TruthEventD3PDObject(**_args(1, 'TruthEvent', kw))
        alg += TruthParticleD3PDObject(**_args(level, 'TruthParticle', kw))

    # alg.MetadataTools += [LBMetadataConfig()]

    # if D3PDMakerFlags.FilterCollCand():
    #     from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
    #     alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter')

    return alg