def configure(self):
if self._done:
log.info("configuration already done, who is calling it again?")
return True
self._done=True
# setup configuration services
from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter
cfg = TriggerConfigGetter()
# after the menu xml file has been created or the TriggerDB access is configured,
# the COOL/SQlite db can be written
from TrigConfigSvc.TrigConf2COOL import theConfCOOLWriter
theConfCOOLWriter.writeConf2COOL()
# preconfigure TrigDecisionTool
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += Trig__TrigDecisionTool( "TrigDecisionTool" )
# tell TDT to use TrigConfigSvc (Since 00-03-40, defaults to not use it)
ToolSvc.TrigDecisionTool.TrigConfigSvc = "Trig::TrigConfigSvc/TrigConfigSvc"
from TrigEDMConfig.TriggerEDM import EDMLibraries
ToolSvc.TrigDecisionTool.Navigation.Dlls = [e for e in EDMLibraries if 'TPCnv' not in e]
if withLVL1():
# setup Lvl1
# initialize LVL1ConfigSvc
log.info("configuring lvl1")
from TriggerJobOpts.Lvl1ResultBuilderGetter import Lvl1ResultBuilderGetter
lvl1 = Lvl1ResultBuilderGetter()
if withHLT():
# setup HLT
# initialize HLT config svc
log.info("configuring hlt")
from TriggerJobOpts.HLTTriggerResultGetter import HLTTriggerResultGetter
hlt = HLTTriggerResultGetter()
#Call the tools to unpack the bytestream
#bsu=ByteStreamUnpackGetter()
#Call the tool to make the TrigDecision object for ESD or AOD
#tdg=TrigDecisionGetter()
return True
def convert_trigdec(seq, xaod_key, key):
from AthenaCommon.AppMgr import ToolSvc
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
tdt = Trig__TrigDecisionTool('TrigDecisionToolCnv',
TrigDecisionKey='TrigDecision',
UseAODDecision=True)
ToolSvc += tdt
from xAODTriggerCnv.xAODTriggerCnvConf import \
xAODMaker__TrigDecisionCnvAlg, \
xAODMaker__TrigDecisionCnvTool
tdct = xAODMaker__TrigDecisionCnvTool(xaod_key + 'CnvTool',
TrigDecisionTool=tdt)
alg = xAODMaker__TrigDecisionCnvAlg(xaod_key + 'Cnv',
AODKey=key,
xAODKey=xaod_key,
CnvTool=tdct)
seq += alg
return
PoolAODInput=["/afs/cern.ch/user/t/tbold/public/TDTtest/attila.AOD.pool.root"]
# PoolAODInput=['/space2/tkohno/data/test/valid1.105144.PythiaZee.recon.AOD.e380_s513_r634_tid043141/AOD.043141._00005.pool.root.1']
import AthenaPoolCnvSvc.ReadAthenaPool
ServiceMgr.EventSelector.InputCollections=PoolAODInput
ServiceMgr.OutputLevel=ERROR
for i in ServiceMgr: i.OutputLevel=ERROR
#
# TrigDecisionTool
#
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
tdt = Trig__TrigDecisionTool("TrigDecisionTool")
ToolSvc += tdt
tdt.OutputLevel=ERROR
ToolSvc.TrigDecisionTool.Navigation.OutputLevel = ERROR
tdt.PublicChainGroups = {"EFTau": "EF_[0-9]?tau.*",
"EFPhoton": "EF_[0-9]?g*",
"EFJets":"EF_J.*",
}
#
# Example Code
#
from TrigAnalysisExamples.TrigAnalysisExamplesConf import Trig__TDTExample
from TrigAnalysisExamples.TDTExample import TriggerTree
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += Trig__TDTExample("TDTExample")
#? is this necessary if we use the public tdt?
####topSequence.TDTExample.TrigDecisionTool = tdt
from tauMonitoring.tauMonitoringConf import *
from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
monbadlb = GetLArBadLBFilterTool()
LowStat = True
if DQMonFlags.monManEnvironment() == 'online' :
LowStat = False
print "doLowStat " , LowStat
myTDT = None
if DQMonFlags.useTrigger() and LowStat :
if hasattr(ToolSvc, DQMonFlags.nameTrigDecTool()) :
myTDT = getattr(ToolSvc, DQMonFlags.nameTrigDecTool())
else :
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
myTDT = Trig__TrigDecisionTool( "tauDQ_TrigDecisionTool" )
ToolSvc += myTDT
tauMonTool = tauMonTool (name = "tauMonTool")
tauMonTool.doLowStat = LowStat
if myTDT is None :
tauMonTool.doTrigger = False
else :
tauMonTool.doTrigger = DQMonFlags.useTrigger()
tauMonTool.TrigDecisionTool = myTDT
print "doTrigger " , tauMonTool.doTrigger
if tauMonTool.doTrigger :
tauMonTool.TauEleJetMbtsTriggerItems = [ [ "L1_TAU1.*" , "L1_TAU2.*" , "L1_TAU60" , "L1_EM15VHI_2TAU.*" , "L1_EM15VHI_TAU40.*" , "L1_MU10_TAU.*" , "L1_J25_3J12_EM15-TAU.*" ] , [ "HLT_e2.*" , "L1_EM2.*" , "L1_2EM15" ] , [ "HLT_j55" , "HLT_j60" , "HLT_j85" , "HLT_j110" , "HLT_j175" , "HLT_4j85" , "HLT_4j10.*" ] , [ "HLT_mb_sp2000_trk70_hmt" ] ]
ToolSvc += IOVDbMetaDataTool("IOVDbMetaDataTool")
from AthenaServices.AthenaServicesConf import MetaDataSvc
ServiceMgr += MetaDataSvc("MetaDataSvc")
ServiceMgr.MetaDataSvc.MetaDataContainer = "MetaDataHdr"
ServiceMgr.MetaDataSvc.MetaDataTools += ["IOVDbMetaDataTool"]
import IOVDbSvc.IOVDb
from RecExConfig.RecFlags import rec
rec.readAOD = True
rec.doWriteAOD = False
rec.doWriteESD = False
# from TrigDecisionTool.TrigDecisionConf import TrigDecisionTool
# tdt = TrigDecisionTool()
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
tdt = Trig__TrigDecisionTool()
ToolSvc += tdt
# flags needed for TriggerConfigGetter
# To read AOD produced with 13.0.30 you need to change ds to aod:
from TriggerJobOpts.TriggerFlags import TriggerFlags
TriggerFlags.configurationSourceList = ['ds']
# set up trigger config service
from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter
cfg = TriggerConfigGetter()
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
svcMgr.MessageSvc.OutputLevel = INFO
## read pool data
SFtool.WorkingPoint = "CBandST"
SFtool.DataPeriod = "2012"
SFtool.OutputLevel = INFO
from MuonMomentumCorrections.MuonMomentumCorrectionsConf import CP__MuonCalibrationAndSmearingTool
CalibrationTool = CP__MuonCalibrationAndSmearingTool()
CalibrationTool.Year = 'Data12'
CalibrationTool.Release = 'Rel17.2Sum13'
CalibrationTool.OutputLevel = INFO
from MuonSelectorTools.MuonSelectorToolsConf import CP__MuonSelectionTool
SelectionTool = CP__MuonSelectionTool()
SelectionTool.OutputLevel = INFO
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
TriggerTool = Trig__TrigDecisionTool("TrigDecTool")
ToolSvc += TriggerTool
TriggerTool.TrigDecisionKey = "xTrigDecision"
TriggerTool.OutputLevel = INFO
from TrigMuonMatching.TrigMuonMatchingConf import Trig__TrigMuonMatching
MatchingTool = Trig__TrigMuonMatching("TrigMatchTool")
MatchingTool.dRmin = 0.1
MatchingTool.LVL1dRmin = 0.2
MatchingTool.TriggerTool = TriggerTool
MatchingTool.OutputLevel = INFO
# Create an instance of the Resonance selection tool for Zmumu
from MuonResonanceTools.MuonResonanceToolsConf import MuonResonanceSelectionTool
ToolSvc += MuonResonanceSelectionTool("MuonZSelectionTool")
ToolSvc.MuonZSelectionTool.PtCut = 20000
from glob import glob
import AthenaPoolCnvSvc.ReadAthenaPool
svcMgr.EventSelector.InputCollections = glob(inputFiles)
#ToolSvc += CfgMgr.TrigConf__xAODConfigTool("xAODConfigTool")
#ToolSvc += CfgMgr.Trig__TrigDecisionTool("TrigDecisionTool",
#ConfigTool = ToolSvc.xAODConfigTool,
#TrigDecisionKey = "xTrigDecision",
#OutputLevel = 1)
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
trigDecTool = Trig__TrigDecisionTool('TrigDecisionTool')
ToolSvc += trigDecTool
svcMgr += CfgMgr.AthenaEventLoopMgr(EventPrintoutInterval=1000)
from AthenaCommon.AlgSequence import AlgSequence
algSeq = AlgSequence()
from TrigTauMatching.TrigTauMatchingConf import Trig__TrigTauMatchingTool
tauMatchingTool = Trig__TrigTauMatchingTool('TrigTauMatchingTool')
tauMatchingTool.TrigDecisionTool = trigDecTool
ToolSvc += tauMatchingTool
from TrigTauMatching.TrigTauMatchingConf import TrigTauMatching_example
alg = TrigTauMatching_example()
alg.TrigTauMatchingTool = tauMatchingTool
algSeq += alg
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
tdt =Trig__TrigDecisionTool("TrigDecisionTool")
ToolSvc += tdt
tdt.OutputLevel = WARNING
ToolSvc.TrigDecisionTool.Navigation.OutputLevel = ERROR
include("RecExCond/AllDet_detDescr.py")
#-- import BS reading JO ------------------------------------------------------------------------------
include("RecExCommon/BSRead_config.py")
#-- get Trigger Configuration ------------------------------------------------------------------------------
from TriggerJobOpts.T0TriggerGetter import T0TriggerGetter
gettrigger = T0TriggerGetter()
#-- set up TrigDecision Tool ------------------------------------------------------------------------------
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
monTrigDecTool = Trig__TrigDecisionTool("monTrigDecTool")
ToolSvc += monTrigDecTool
#-- run reconstruction ------------------------------------------------------------------------------
# bug https://savannah.cern.ch/bugs/?54123
if not conddb.folderRequested('PIXEL/PixReco'):
conddb.addFolder('PIXEL_OFL','/PIXEL/PixReco');
#protectedInclude( "InDetRecExample/InDetRec_jobOptions.py" )
#protectedInclude ("CaloRec/CaloRec_jobOptions.py")
#include ("MuonRecExample/MuonRec_jobOptions.py")
#
#protectedInclude( "egammaRec/egammaRec_jobOptions.py" )
#include ("MuonCombinedRecExample/MuonCombinedRec_config.py")
#include( "JetRec/JetRec_jobOptions.py" )
# for ESD->AOD use trigger config stored as in-file meta-data,
if not 'TriggerFlags' in dir():
from TriggerJobOpts.TriggerFlags import TriggerFlags
TriggerFlags.configurationSourceList = ['ds']
# set up trigger config service
if not 'TriggerConfigGetter' in dir():
from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter
cfg = TriggerConfigGetter()
if not hasattr(ToolSvc, DQMonFlags.nameTrigDecTool()):
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
monTrigDecTool = Trig__TrigDecisionTool(name=DQMonFlags.nameTrigDecTool(),
OutputLevel=ERROR,
PublicChainGroups = {"EFTau": "EF_[0-9]?tau.*",
"EFPhoton": "EF_[0-9]?g*",
"EFJets":"EF_J.*",
}
)
ToolSvc += monTrigDecTool
tdt_local_logger.info('Scheduling the trigger translator')
# Look up all monitoring menu lists, shove into trigger translator
# pass them in as joined strings, unpack in tool
from TrigHLTMonitoring.HLTMonTriggerList import HLTMonTriggerList
tdt_local_hltconfig = HLTMonTriggerList()
import collections
tdt_mapping = {}
for tdt_menu, tdt_menu_item in tdt_local_hltconfig.__dict__.items():
if not isinstance(tdt_menu_item, collections.Iterable): continue
# work around possibly buggy category items
def HSG2physicsD3PD(name, file, tuplename='physics', **kw):
from AthenaCommon.AlgSequence import AlgSequence # needed for attila's code
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags # needed for attila's code
# define track and cluster filters
filter1 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(),
OutputTracksName='GoodTracks' + name,
ptCut=0.,
nSCTPix=4)
filter2 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(),
OutputTracksName='HighPtTracks' + name,
ptCut=5000.,
nSCTPix=4)
preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
preseq += filter1
preseq += filter2
# now configure the D3PD
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
alg = MSMgr.NewRootStream(name, file, TreeName=tuplename)
#alg = D3PDMakerCoreComps.MakerAlg(tuplename, seq,
# file = file,
# D3PDSvc = D3PDSvc,
# streamNameRoot = streamNameRoot)
alg += EventInfoD3PDObject(**_args(10, 'EventInfo', kw))
alg += LArCollisionTimeD3PDObject(**_args(10, 'LArCollisionTime', kw))
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import EventCommonD3PDMaker
# Electron/Photon block
alg += ElectronD3PDObject(
**_args(10,
'Electron',
kw,
exclude=[
'L1Index', 'L2Index', 'EMTrackFitDetails',
'EgammaJetSignedIPAndPTRelKin'
]))
# Photon block
alg += PhotonD3PDObject(**_args(10, 'Photon', kw))
# Muon blocks
alg += MuonD3PDObject(**_args(
10,
'MuidMuon',
kw,
sgkey='MuidMuonCollection',
prefix='mu_muid_',
include=["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
alg += MuonD3PDObject(**_args(
10,
'StacoMuon',
kw,
sgkey='StacoMuonCollection',
prefix='mu_staco_',
include=["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
alg += MuonD3PDObject(**_args(
10,
'CaloMuon',
kw,
sgkey='CaloMuonCollection',
prefix='mu_calo_',
include=["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
alg += MuonD3PDObject(**_args(
10,
'Muons',
kw,
sgkey='Muons',
prefix='mu_muon_',
include=["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
# Quadruplet vertex block
from AthenaCommon.AlgSequence import AlgSequence
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from HSG2VertexCreation.HSG2VertexReconstruction import HSG2VertexReconstruction
HSG2VertexReconstruction("HSG2VertexReconstruction",
AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()))
from HiggsD3PDMaker.HSG2VertexReconstruction import addHSG2VertexReconstruction
addHSG2VertexReconstruction(alg,
electron_target="el_",
muid_target="mu_muid_",
staco_target="mu_staco_",
calo_target="mu_calo_",
muon_target="mu_muon_")
# Tau block
alg += TauD3PDObject(**_args(1, 'Tau', kw))
# Jet blocks
alg += JetD3PDObject(**_args(
3,
'AK4TopoEMJet',
kw,
sgkey='AntiKt4TopoEMJets' + JetTagD3PD_CollectionPostfix,
prefix='jet_akt4topoem_',
#include = ['BTag','TrueFlavorComponents','BTagComponents'],
include=[
JetTagD3PDKeys.BTagWeightsBlockName(),
JetTagD3PDKeys.JetFitterCharmTagInfoBlockName(),
JetTagD3PDKeys.JetFitterCharmInfoBaseBlockName(),
JetTagD3PDKeys.TruthInfoBlockName(),
"Constituents",
'TracksMoments',
'Samplings', # For GSC corrections
],
allowMissing=True))
# For VBF and ZH(->inv) analyses
alg += JetD3PDObject(**_args(
3,
'AK4LCTopoJet',
kw,
sgkey='AntiKt4LCTopoJets' + JetTagD3PD_CollectionPostfix,
prefix='jet_AntiKt4LCTopo_',
include=[
JetTagD3PDKeys.BTagWeightsBlockName(),
JetTagD3PDKeys.JetFitterCharmTagInfoBlockName(),
JetTagD3PDKeys.JetFitterCharmInfoBaseBlockName(),
JetTagD3PDKeys.TruthInfoBlockName(),
"Constituents",
"ConstituentScale", # For ZH(->inv) analysis
'TracksMoments',
'Samplings', # For GSC corrections
],
allowMissing=True))
# MET blocks
# a whole mess to remove x,y components separately for all flavours
alg += MissingETD3PDObject(**_args(
10,
'MissingET',
kw,
exclude=[
'MET_Base', 'MET_Base0', 'MET_Truth_Int', 'MET_RefFinal_Comps',
'MET_Calib_Comps', 'MET_CellOut_Comps', 'MET_CorrTopo_Comps',
'MET_Cryo_Comps', 'MET_CryoCone_Comps', 'MET_Final_Comps',
'MET_LocHadTopo_Comps', 'MET_LocHadTopoObj_Comps',
'MET_Muid_Comps', 'MET_Muid_Spectro_Comps', 'MET_Muid_Track_Comps',
'MET_MuonBoy_Comps', 'MET_MuonBoy_Spectro_Comps',
'MET_MuonBoy_Track_Comps', 'MET_MuonMuid_Comps', 'MET_Muon_Comps',
'MET_Muon_Isol_Muid_Comps', 'MET_Muon_Isol_Staco_Comps',
'MET_Muon_NonIsol_Muid_Comps', 'MET_Muon_NonIsol_Staco_Comps',
'MET_Muon_Total_Muid_Comps', 'MET_Muon_Total_Staco_Comps',
'MET_RefEle_Comps', 'MET_RefEle_em_Comps', 'MET_RefGamma_Comps',
'MET_RefGamma_em_Comps', 'MET_RefJet_Comps', 'MET_RefJet_em_Comps',
'MET_RefMuon_Comps', 'MET_RefMuon_Muid_Comps',
'MET_RefMuon_Staco_Comps', 'MET_RefMuon_Track_Muid_Comps',
'MET_RefMuon_Track_Staco_Comps', 'MET_RefMuon_Track_em_Comps',
'MET_RefMuon_Track_Comps', 'MET_RefMuon_em_Comps',
'MET_RefTau_Comps', 'MET_RefTau_em_Comps', 'MET_SoftJets_Comps',
'MET_SoftJets_em_Comps', 'MET_Topo_Comps', 'MET_TopoObj_Comps',
'MET_Track_Comps'
],
allowMissing=True))
# Pileup-subtracted MET RefFinal for ZH(->inv) analysis
alg += MissingETCompositionD3PDObject(level=4,
sgkey='MET_RefComposition_STVF',
suffix='STVF_',
allowMissing=True,
jetSGKey='AntiKt4LCTopoJets',
jetPrefix='jet_AntiKt4LCTopo_MET_')
# ... good tracks only (nSCT>3; no pt cut)
alg += TrackParticleD3PDObject(**_args(3,
'Tracks1',
kw,
sgkey='GoodTracks' + name,
label='trk',
prefix='trk_'))
# ... high-pt tracks (nSCT>3; pt>5 GeV)
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as highPtFlags
highPtFlags.doTruth = True
highPtFlags.storeDiagonalCovarianceAsErrors = True
highPtFlags.storeHitTruthMatching = True
highPtFlags.storePixelHitsOnTrack = False
highPtFlags.storePixelHolesOnTrack = False
highPtFlags.storePixelOutliersOnTrack = False
highPtFlags.storeSCTHitsOnTrack = False
highPtFlags.storeSCTHolesOnTrack = False
highPtFlags.storeSCTOutliersOnTrack = False
highPtFlags.storeTRTHitsOnTrack = False
highPtFlags.storeTRTHolesOnTrack = False
highPtFlags.storeTRTOutliersOnTrack = False
highPtFlags.storeTrackFitQuality = True
highPtFlags.storeTrackMomentum = True
highPtFlags.storeTrackSummary = True
highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0
highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2
highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3
alg += TrackParticleD3PDObject(**_args(3,
'Tracks2',
kw,
sgkey='HighPtTracks' + name,
label='trkpt5',
prefix='trkpt5_'))
# Primary vertex block - May be missing in single-beam data.
alg += PrimaryVertexD3PDObject(**_args(1,
'PrimaryVertex',
kw,
allowMissing=True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_'))
# Truth
if rec.doTruth():
from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject
from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject
from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw))
alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw))
alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw))
# TruthJets
alg += JetD3PDObject(**_args(1,
'AK4TruthJet',
kw,
sgkey='AntiKt4TruthJets',
prefix='jet_antikt4truth_',
allowMissing=True))
# add Heavy flavour overlap
from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject
alg += HforD3PDObject(**_args(0, 'HforD3PD', kw))
# add mcVx information
from TrackD3PDMaker.TruthVertexD3PDObject import TruthVertexD3PDObject
alg += TruthVertexD3PDObject(**_args(0, 'TruthVertex', kw))
if not rec.doTruth():
alg += BeamSpotD3PDObject(10)
if D3PDMakerFlags.DoTrigger():
# Trigger Decision + metadata
alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw))
addTrigConfMetadata(alg)
from TrigMissingETD3PDMaker.TrigMETD3PD import TrigMETD3PDObjects
TrigMETD3PDObjects(alg)
from TrigEgammaD3PDMaker.TrigEgammaD3PD import TrigEgammaD3PDObjects
TrigMuonD3PDObjects(alg, 1)
TrigEgammaD3PDObjects(alg, level=10)
# Event metadata
alg.MetadataTools += [LBMetadataConfig()]
from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig
alg.MetadataTools += [CutFlowMetadataConfig(alg)]
# Bunch train information
from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata
addBunchStructureMetadata(alg)
## Silence the trigger navigation warnings about missing containers:
from AthenaCommon.AppMgr import ToolSvc
if not hasattr(ToolSvc, "TrigDecisionTool"):
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
ToolSvc += Trig__TrigDecisionTool("TrigDecisionTool")
pass
ToolSvc.TrigDecisionTool.Navigation.OutputLevel = 5
# EventShape variables
# https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/D3PDVariablesForPileup#EventShape_variables
from QcdD3PDMaker.QcdEventShapeD3PDObject import EventShapeD3PDObject
alg += EventShapeD3PDObject(**_args(0, 'rho', kw))
return alg