# Create the D3PD streams:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
SMDYEED3PDStream = MSMgr.NewRootStream(streamName, fileName, "physics")
SMDYEED3PDStream.D3PDSvc = ServiceMgr.SMDYEE_D3PDSvc
# Now add all the content to this stream:
from PhysicsD3PDMaker.SMWZLightD3PD import SMWZLightD3PD
SMWZLightD3PD(SMDYEED3PDStream, stdElectronContainer='LowPtElectrons')
# apply skim
SMDYEED3PDStream.AddAcceptAlgs(["SMWZ_JPsieeFilter"])
# add cut flow information
from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig
SMDYEED3PDStream.MetadataTools += [CutFlowMetadataConfig(SMDYEED3PDStream)]
# Silence tool warnings:
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 = ERROR
if hasattr(ToolSvc, "SecondSoftMuonTagChi2"):
ToolSvc.SecondSoftMuonTagChi2.OutputLevel = ERROR
if hasattr(ToolSvc, "myTrkUpdator"):
ToolSvc.myTrkUpdator.OutputLevel = ERROR
TrigEgammaD3PDObjects(alg, 1)
from TrigJetD3PDMaker.TrigJetD3PD import *
TrigJetD3PDObjects(alg, 1)
from TrigMissingETD3PDMaker.TrigMETD3PD import TrigMETD3PDObjects
TrigMETD3PDObjects(alg, 1)
from TrigTauD3PDMaker.TrigTauD3PD import TrigTauD3PDObjects
TrigTauD3PDObjects(alg, 0, False, False)
from EventCommonD3PDMaker.LBMetadataConfig import LBMetadataConfig
from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig
from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata
alg.MetadataTools += [LBMetadataConfig()]
alg.MetadataTools += [CutFlowMetadataConfig(alg)]
addBunchStructureMetadata(alg)
#-------------------------------------------------------------------------------
def _args(level, name, kwin, **kw):
kw = kw.copy()
kw['level'] = level
for (k, v) in kwin.items():
if k.startswith(name + '_'):
kw[k[len(name) + 1:]] = v
return kw
# MET objects
from MissingETD3PDMaker.MissingETD3PDMakerFlags import MissingETD3PDMakerFlags
inputCollection="ElectronAODCollection",
outputCollection=NewElectronCollection,
minNumberPassed=2,
ptMin=20. * Units.GeV,
etMin=20. * Units.GeV,
clPtMin=20. * Units.GeV,
reclPtMin=20. * Units.GeV)
# photon selection
from D2PDMaker.D2PDMakerConf import D2PDPhotonSelector
NewPhotonCollection = 'ZPrimeHighPtPhotons'
preseq += D2PDPhotonSelector(
"ZPrimePhotonSelector",
inputCollection="PhotonAODCollection",
outputCollection=NewPhotonCollection,
ptMin=20. * Units.GeV,
)
# Set require algorithm
ZPrimeEED3PDStream.RequireAlgs += ['ZPrimeElectronSelector']
# Now add all the content to this stream:
from ExoticsD3PDMaker.ZPrimeEED3PD import ZPrimeEED3PD
ZPrimeEED3PD(ZPrimeEED3PDStream,
electronContainer=NewElectronCollection,
photonContainer=NewPhotonCollection)
# Add cut flow information
from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig
ZPrimeEED3PDStream.MetadataTools += [CutFlowMetadataConfig(ZPrimeEED3PDStream)]
from PhysicsD3PDMaker.SMWZLightD3PD import SMWZLightD3PD
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
SMWZLightD3PD(SMZMUMUD3PDStream,
stdElectronContainer='HighPtElectrons',
stacoMuonContainer='LowPtStacoMuons',
muidMuonContainer='LowPtMuidMuons',
photonContainer='HighPtPhotons',
jetContainer='HighPtJets')
# apply skim
SMZMUMUD3PDStream.AddAcceptAlgs(
["SMWZ_ZmumuStacoFilter", "SMWZ_ZmumuMuidFilter"])
# add cut flow information
from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig
SMZMUMUD3PDStream.MetadataTools += [CutFlowMetadataConfig(SMZMUMUD3PDStream)]
# Silence tool warnings:
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 = ERROR
if hasattr(ToolSvc, "SecondSoftMuonTagChi2"):
ToolSvc.SecondSoftMuonTagChi2.OutputLevel = ERROR
if hasattr(ToolSvc, "myTrkUpdator"):
ToolSvc.myTrkUpdator.OutputLevel = ERROR
# set flags
from HSG5DPDUtils.HSG5Flags import HSG5WHUFlags
HSG5WHUFlags.doTaus = True
HSG5WHUFlags.doPhotons = True
print "HSG5WHUFlags.doPhotons()=",HSG5WHUFlags.doPhotons()
from HSG5DPDUtils.HSG5D3PD import HSG5D3PD
print "after import of HSG5D3PD, HSG5WHUFlags.doPhotons()=",HSG5WHUFlags.doPhotons()
HSG5D3PD( HSG5D3PD_Stream, flags=HSG5WHUFlags )
include("HSG5DPDUtils/FatJetsConfig.py")
from HSG5DPDUtils.JSD3PD import JSD3PD
for xx in myJetKeys:
if xx[0] != None and xx[1] != None:
JSD3PD(xx, HSG5D3PD_Stream )
# add filters
HSG5D3PD_Stream.AcceptAlgs=[]
HSG5D3PD_Stream.RequireAlgs=[]
include ("HSG5DPDUtils/WHlnubb_unboostedFilter.py")
from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig
HSG5D3PD_Stream.MetadataTools += [CutFlowMetadataConfig(HSG5D3PD_Stream)]
ToolSvc.TrigDecisionTool.Navigation.OutputLevel=ERROR
SMWZD3PD(SMWMUNUJJD3PDStream,
stdElectronContainer='HighPtElectrons',
gsfElectronContainer='None',
muonContainer='None',
stacoMuonContainer='HighPtStacoMuons',
muidMuonContainer='None',
caloMuonContainer='None',
photonContainer='None',
tauContainer='None',
jetEM4Container='HighPtJets',
jetEM6Container='HighPtJetsEM6',
jetLC4Container='HighPtJetsLC4',
jetLC6Container='HighPtJetsLC6',
jetDetails=2,
METDetails=2)
# Define skims
from WZSkims.WZSkimsConf import WZSkimsMain
Wmunujj = WZSkimsMain("Wmunujj")
Wmunujj.doWmunujjSkim = True
Wmunujj.OutputLevel = INFO
SMWMUNUJJD3PDStream.filterSeq += Wmunujj
include("WZSkims/Wlnujj_branchSelection.py")
# add cut flow information
from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig
SMWMUNUJJD3PDStream.MetadataTools += [
CutFlowMetadataConfig(SMWMUNUJJD3PDStream)
]
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
SMTrilepD3PD(
SMTRILEPD3PDStream,
stdElectronContainer='TrilepElectrons',
#gsfElectronContainer = 'HighPtGSFElectrons',
stacoMuonContainer='TrilepStacoMuons',
thirdMuonContainer='TrilepThirdMuons',
caloMuonContainer='TrilepCaloMuons',
#muidMuonContainer = 'HighPtMuidMuons',
photonContainer='HighPtPhotons',
jetLC4Container="HighPtJetsLC4",
jetContainer='HighPtJets')
# add cut flow information
from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig
SMTRILEPD3PDStream.MetadataTools += [CutFlowMetadataConfig(SMTRILEPD3PDStream)]
# Silence tool warnings:
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 = ERROR
if hasattr(ToolSvc, "SecondSoftMuonTagChi2"):
ToolSvc.SecondSoftMuonTagChi2.OutputLevel = ERROR
if hasattr(ToolSvc, "myTrkUpdator"):
ToolSvc.myTrkUpdator.OutputLevel = ERROR
SMWZLightD3PD(SMWMUNUD3PDStream,
stdElectronContainer='HighPtElectrons',
stacoMuonContainer='HighPtStacoMuons',
muidMuonContainer='HighPtMuidMuons',
photonContainer='HighPtPhotons',
jetContainer='HighPtJets')
# apply skim
SMWMUNUD3PDStream.AddAcceptAlgs(
["SMWZ_HighPtStacoMuonFilter", "SMWZ_HighPtMuidMuonFilter"])
# add cut flow information
from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig
SMWMUNUD3PDStream.MetadataTools += [CutFlowMetadataConfig(SMWMUNUD3PDStream)]
# Silence tool warnings:
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 = ERROR
if hasattr(ToolSvc, "SecondSoftMuonTagChi2"):
ToolSvc.SecondSoftMuonTagChi2.OutputLevel = ERROR
if hasattr(ToolSvc, "myTrkUpdator"):
ToolSvc.myTrkUpdator.OutputLevel = ERROR
SMWZD3PD(SMWENUJJD3PDStream,
stdElectronContainer='HighPtElectrons',
gsfElectronContainer='None',
muonContainer='None',
stacoMuonContainer='HighPtStacoMuons',
muidMuonContainer='None',
caloMuonContainer='None',
photonContainer='None',
tauContainer='None',
jetEM4Container='HighPtJets',
jetEM6Container='HighPtJetsEM6',
jetLC4Container='HighPtJetsLC4',
jetLC6Container='HighPtJetsLC6',
jetDetails=2,
METDetails=2)
# Define skims
from WZSkims.WZSkimsConf import WZSkimsMain
Wenujj = WZSkimsMain("Wenujj")
Wenujj.doWenujjSkim = True
Wenujj.OutputLevel = INFO
SMWENUJJD3PDStream.filterSeq += Wenujj
include("WZSkims/Wlnujj_branchSelection.py")
# add cut flow information
from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig
SMWENUJJD3PDStream.MetadataTools += [CutFlowMetadataConfig(SMWENUJJD3PDStream)]
SMLIGHTD3PDStream.D3PDSvc = ServiceMgr.SMLIGHT_D3PDSvc
# Now add all the content to this stream:
from PhysicsD3PDMaker.SMWZLightD3PD import SMWZLightD3PD
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
SMWZLightD3PD(SMLIGHTD3PDStream,
stdElectronContainer='HighPtElectrons',
gsfElectronContainer='HighPtGSFElectrons',
stacoMuonContainer='HighPtStacoMuons',
muidMuonContainer='HighPtMuidMuons',
photonContainer='HighPtPhotons',
jetContainer='HighPtJets')
# add cut flow information
from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig
SMLIGHTD3PDStream.MetadataTools += [CutFlowMetadataConfig(SMLIGHTD3PDStream)]
# Silence tool warnings:
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 = ERROR
if hasattr(ToolSvc, "SecondSoftMuonTagChi2"):
ToolSvc.SecondSoftMuonTagChi2.OutputLevel = ERROR
if hasattr(ToolSvc, "myTrkUpdator"):
ToolSvc.myTrkUpdator.OutputLevel = ERROR
caloMuonContainer = 'None',
photonContainer = 'HighPtPhotons',
tauContainer = 'HighPtTaus',
jetEM4Container = 'HighPtJets',
jetEM6Container = 'HighPtJetsEM6',
jetLC4Container = 'HighPtJetsLC4',
jetLC6Container = 'HighPtJetsLC6',
jetDetails = 2,
METDetails = 2)
else:
from PhysicsD3PDMaker.SMWZD3PD import SMWZD3PD
SMWZD3PD( SkimD3PDStream )
SkimD3PDStream.filterSeq += WZSkimsMain("WZSkimsMain")
SkimD3PDStream.MetadataTools += [ CutFlowMetadataConfig( SkimD3PDStream ) ]
# additional branch selection for W -> l nu j j
if ('doWenujj' in dir() and doWenujj) or ('doWmunujj' in dir() and doWmunujj):
include("WZSkims/Wlnujj_branchSelection.py")
# Debug output once again
from AthenaCommon.AppMgr import theApp
svcMgr = theApp.serviceMgr()
svcMgr.MessageSvc.OutputLevel = OL
svcMgr.MessageSvc.defaultLimit = 1000000
svcMgr.MessageSvc.Format = "% F%80W%S%7W%R%T %0W%M"
svcMgr.MessageSvc.useColors = False
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
