from AthenaPoolTest.AthenaPoolTestConf import EventInfoWriter
topSequence += EventInfoWriter("EventInfoWriter")
#--------------------------------------------------------------
# Input options
#--------------------------------------------------------------
# ItemList:
include("EventAthenaPool/EventAthenaPoolItemList_joboptions.py")
printfunc(fullItemList)
# Run OutputStream as an algorithm
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("Stream1",
"SimplePoolFile2.root",
asAlg=True,
noTag=True)
# List of DO's to write out
Stream1.ItemList += fullItemList
#--------------------------------------------------------------
# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )
#--------------------------------------------------------------
svcMgr.MessageSvc.OutputLevel = INFO
svcMgr.MessageSvc.debugLimit = 100000
from AthenaServices import AthenaServicesConf
AthenaEventLoopMgr = AthenaServicesConf.AthenaEventLoopMgr()
AthenaEventLoopMgr.OutputLevel = INFO
theApp.EvtMax = 500
svcMgr.MessageSvc.OutputLevel = WARNING
import AthenaPoolCnvSvc.ReadAthenaPool
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("Stream1")
Stream1.OutputFile = "ESDout.pool.root"
svcMgr.EventSelector.InputCollections = []
"root://eosatlas//eos/atlas/atlascerngroupdisk/proj-sit/digitization/RTT/mc10/mc10_7TeV.005008.CavernInput.merge.HITS.e4_e607_s951_s952_tid170551_00/HITS.170551._000011.pool.root.1",
"root://eosatlas//eos/atlas/atlascerngroupdisk/proj-sit/digitization/RTT/mc10/mc10_7TeV.005008.CavernInput.merge.HITS.e4_e607_s951_s952_tid170551_00/HITS.170551._000111.pool.root.1" ]
ServiceMgr += getConfigurable("EventSelectorAthenaPool")("MinBiasSelector" )
ServiceMgr.MinBiasSelector.InputCollections = [
"root://eosatlas//eos/atlas/atlascerngroupdisk/proj-sit/digitization/RTT/mc10/mc10_7TeV.105001.pythia_minbias.merge.HITS.e577_s932_s952_tid170554_00/HITS.170554._000034.pool.root.1",
"root://eosatlas//eos/atlas/atlascerngroupdisk/proj-sit/digitization/RTT/mc10/mc10_7TeV.105001.pythia_minbias.merge.HITS.e577_s932_s952_tid170554_00/HITS.170554._000043.pool.root.1" ]
ServiceMgr.EventMixer.OutputRunNumber=54321
ServiceMgr.EventMixer.EventNumbers=[1, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 47]
#--------------------------------------------------------------
#--- Output stream configuration
#--------------------------------------------------------------
include( "AthenaPoolCnvSvc/WriteAthenaPool_jobOptions.py" )
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream( "Stream1" )
Stream1.OutputFile = "MixedFile.root"; # ** mandatory parameter ** // The output file name
Stream1.ForceRead=TRUE; #force read of output data objs
Stream1.ItemList=["MergedEventInfo#*",
"EventInfo#*",
"McEventCollection#*",
"SiHitCollection#SCT_Hits",
"SiHitCollection/PixelHits"]; #SYNTAX ERROR: / not #
#--------------------------------------------------------------
#--- Monitoring and Debug printouts
#--------------------------------------------------------------
MessageSvc.OutputLevel = INFO
ServiceMgr.EventMixer.OutputLevel = VERBOSE
MessageSvc.setVerbose += [ "MixingEventSelector::TriggerList" ]
from PoolSvc.PoolSvcConf import PoolSvc svcMgr += PoolSvc() PoolSvc = svcMgr.PoolSvc PoolSvc.ReadCatalog = ["xmlcatalog_file:EventSplit.xml"] svcMgr.EventSelector.InputCollections = ["AthenaPoolMultiTest_StreamAll2.root"] #-------------------------------------------------------------- # Private Application Configuration options #-------------------------------------------------------------- # include stream transform include( "AthenaPoolMultiTest/ExampleStreamConfig.py" ) from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream # Unfiltered stream StreamAll = AthenaPoolOutputStream( "StreamAllP", "AthenaPoolMultiTest_Propagate.root", False, noTag=False, decisionFilter="Stream" ) StreamAll.CheckNumberOfWrites = False StreamAll.WritingTool.AttributeListKey="SimpleTag" StreamAll.WritingTool.SaveDecisions = False StreamAll.TakeItemsFromInput = True #EventInfoTagBuilder.FilterString = "Stream" #EventInfoTagBuilder.PropagateInput=True # Add the outputstreams to the execution sequence #athOutSeq+=StreamAll #-------------------------------------------------------------- # Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL) #-------------------------------------------------------------- svcMgr.MessageSvc.OutputLevel = INFO
'vertZ:': ' constant -139500.0',
't:': ' constant 0.0',
'eta:': ' constant -100.0',
'phi:': ' flat 0 6.28318',
'e:': ' constant 1360000'
}
# 'pt:' : ' constant 50000'}
#--- Output printout level -----------------------------------
#output threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL)
#you can override this for individual modules if necessary
MessageSvc = Service("MessageSvc")
MessageSvc.OutputLevel = 2
#==============================================================
# Job configuration
# ***>> Do not add flags or simulation options below this line
#==============================================================
from G4AtlasApps import SimKernel
# The following lines store the desired container into the output file
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
stream1 = AthenaPoolOutputStream("StreamEVGEN")
stream1.OutputFile = "SimOut.pool.root"
stream1.ItemList += [
'EventInfo#*', 'McEventCollection#*', 'ZDC_SimPixelHit_Collection#*',
'ZDC_SimStripHit_Collection#*'
]
#--- End jobOptions.G4Atlas_Sim.py file ------------------------------
from Starlight_i.Starlight_iConf import Starlight_i
genSeq += Starlight_i("Starlight")
genSeq.Starlight.McEventKey = "GEN_EVENT"
evgenConfig.generators += ["Starlight"]
## Extra stream persistency
## 2101 == EventInfo, 133273 == MCTruth (HepMC)
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
_evgenstream = AthenaPoolOutputStream("StreamEVGEN")
_evgenstream.ItemList = ["2101#*","133273#GEN_EVENT"]
del _evgenstream
#--------------------------------------------------------------
#RootHistSvc = Service( "RootHistSvc" )
#HbookHistSvc.NPAWC = 1500000
#HistogramPersistencySvc = Service( "HistogramPersistencySvc" )
#HistogramPersistencySvc.OutputFile = "histo.root"
svcMgr.NTupleSvc.Output = [
"FILE1 DATAFILE='pythiaB.root' OPT='NEW' TYP='ROOT'"
]
###############################################################
# Add POOL persistency
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
include("GeneratorObjectsAthenaPool/GeneratorObjectsAthenaPool_joboptions.py")
Stream1 = AthenaPoolOutputStream("Stream1")
Stream1.ForceRead = TRUE
Stream1.OutputFile = "pythiaB.pool.root"
# 2101 = EventInfo
# 133273 = MCTruth (HepMC)
Stream1.ItemList += ["2101#*", "133273#*"]
include("AthenaSealSvc/AthenaSealSvc_joboptions.py")
AthenaSealSvc.CheckDictionary = TRUE
#==============================================================
#
# End of job options file
#
###############################################################
## Pool persistency for evgen
from AthenaCommon.AppMgr import theApp
stream = theApp.getOutputStream("StreamEVGEN")
if stream is None:
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
stream = AthenaPoolOutputStream("StreamEVGEN")
stream.OutputFile = "evgen.pool.root"
if "OUTFILE" in dir():
stream.OutputFile = OUTFILE
stream.ItemList += ["EventInfo#*", "McEventCollection#*"]
Stream1 = DecisionAlg( "Stream1" ) Stream1.AcceptAlgs = ["Splitter1"] Stream2 = DecisionAlg( "Stream2" ) Stream2.AcceptAlgs = ["Splitter2"] Stream2.VetoAlgs = ["Splitter1"] Stream3 = DecisionAlg( "Stream3" ) Stream3.AcceptAlgs = ["Splitter3"] Stream3.VetoAlgs = ["Splitter2"] topSequence += Stream1 topSequence += Stream2 topSequence += Stream3 from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream # Unfiltered stream StreamAll = AthenaPoolOutputStream( "StreamAll2", "AthenaPoolMultiTest_StreamAll2.root", False, noTag=False ) StreamAll.CheckNumberOfWrites = False StreamAll.WritingTool.AttributeListKey="SimpleTag" StreamAll.WritingTool.SaveDecisions = True StreamAll.TakeItemsFromInput = True # Add the outputstreams to the execution sequence #athOutSeq+=StreamAll #-------------------------------------------------------------- # Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL) #-------------------------------------------------------------- svcMgr.MessageSvc.OutputLevel = INFO svcMgr.MessageSvc.debugLimit = 5000 import AthenaCommon.CfgMgr as CfgMgr if not hasattr(svcMgr, 'DecisionSvc'): svcMgr += CfgMgr.DecisionSvc()
include.block("EventOverlayJobTransforms/OverlayOutputItemList_jobOptions.py")
from AthenaCommon.AppMgr import ServiceMgr
from AthenaCommon.DetFlags import DetFlags
from Digitization.DigitizationFlags import digitizationFlags
# The output - overlay
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
outStream = AthenaPoolOutputStream("StreamRDO", OverlayCollection)
outStream.Store = ServiceMgr.StoreGateSvc
print "ACH123 new OverlayOutputItemList_jobOptions.py"
# overlay output stream
outStream.ItemList += ["EventInfo#*", "PileUpEventInfo#*"]
outStream.ItemList += ["LumiBlockCollection#*"]
# timings
if not isRealData:
outStream.ItemList += ["RecoTimingObj#EVNTtoHITS_timings"]
outStream.ItemList += ["RecoTimingObj#HITStoRDO_timings"]
if DetFlags.overlay.Truth_on():
outStream.ItemList += ["McEventCollection#*", "TrackRecordCollection#*"]
outStream.ItemList += ["xAOD::JetContainer#InTimeAntiKt4TruthJets"]
outStream.ItemList += ["xAOD::JetAuxContainer#InTimeAntiKt4TruthJetsAux."]
outStream.ItemList += ["xAOD::JetContainer#OutOfTimeAntiKt4TruthJets"]
outStream.ItemList += [
"xAOD::JetAuxContainer#OutOfTimeAntiKt4TruthJetsAux."
]
if DetFlags.overlay.CSC_on():
outStream.ItemList += ["CscSimDataCollection#CSC_SDO"]
# #--- Create TileCal h33 ntuple with all merged G4 hits ---------
theTileHitToNtuple2 = TileHitVecToNtuple("TileHitVecToNtuple2")
topSequence += theTileHitToNtuple2
theTileHitToNtuple2.MaxLength = 99999
theTileHitToNtuple2.TileHitVector = "TileHitVec_FCS"
theTileHitToNtuple2.NTupleID = "h33"
theTileHitToNtuple2.NTupleLoc = "/AANT"
#--------------------------------------------------------------
# Creating POOL file
#--------------------------------------------------------------
if doCreatePool:
# Pool Output
include("AthenaPoolCnvSvc/WriteAthenaPool_jobOptions.py")
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
FileName = "HITS.merge.pool.root"
Stream1 = AthenaPoolOutputStream("Stream1", FileName)
# list of output objects
Stream1.ItemList += ["TileHitVector#*"]
Stream1.ItemList += ["TileDigitsContainer#*"]
Stream1.ItemList += ["TileBeamElemContainer#*"]
Stream1.ItemList += ["TileRawChannelContainer#*"]
Stream1.ItemList += ["TileMuContainer#*"]
Stream1.ItemList += ["TileL2Container#*"]
Stream1.ItemList += ["TileCosmicMuonContainer#*"]
Stream1.ItemList += ["TileCellContainer#*"]
Stream1.ItemList += ["CaloCellContainer#*"]
import os.path
FTK_RDO_CreatorAlgo.mergeTrackBName = "FTKMergedTracksStream"
FTK_RDO_CreatorAlgo.mergedTrackPaths = inputNTUP_FTKFile
from RecExConfig.RecFlags import rec
rec.doCBNT.set_Value_and_Lock(False)
rec.doWriteRDO.set_Value_and_Lock(True)
rec.doAOD.set_Value_and_Lock(False)
rec.doWriteAOD.set_Value_and_Lock(False)
rec.doWriteTAG.set_Value_and_Lock(False)
rec.doTruth.set_Value_and_Lock(False)
rec.doWriteRDO.set_Value_and_Lock(True)
from AthenaCommon.AlgSequence import AlgSequence
topSeq = AlgSequence()
topSeq += FTK_RDO_CreatorAlgo
# main jobOption
include("RecExCommon/RecExCommon_topOptions.py")
theApp.Dlls += ["TrigFTKSim"]
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
StreamRDO = AthenaPoolOutputStream("StreamRDO")
StreamRDO.ItemList += ["FTK_RawTrackContainer#*"]
from RecExConfig.ObjKeyStore import objKeyStore
objKeyStore.addStreamRDO("FTK_RawTrackContainer", "FTK_RDO_Tracks")
topSequence += JetSlimmer("slimJets")
#Track Slimming
from DPDUtils.DpdLib import TrackSlimmer
topSequence += TrackSlimmer("slimTracks")
#Electron Filter
from DPDUtils.DpdLib import ElectronFilter
topSequence += ElectronFilter("ElectronFilter")
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
StreamDPD = AthenaPoolOutputStream("StreamDPD")
## configure the thinning service
from AthenaServices.Configurables import ThinningSvc
svcMgr += ThinningSvc(Streams=['StreamDPD'])
######################Write Item List##########################################
StreamDPD.ItemList = ['EventInfo#*', 'TrackRecordCollection#*']
StreamDPD.ItemList += ['ElectronContainer#ElectronAODCollection']
StreamDPD.ItemList += ['egDetailContainer#egDetailAOD']
StreamDPD.ItemList += ['Analysis::MuonContainer#StacoMuonCollection']
StreamDPD.ItemList += ['JetKeyDescriptor#JetKeyMap']
StreamDPD.ItemList += ['JetCollection#Cone4H1TowerJets']
StreamDPD.ItemList += ['JetCollection#Cone4TruthJets']
StreamDPD.ItemList += ['Rec::TrackParticleContainer#TrackParticleCandidate']
theApp.CreateSvc += [svcMgr.THistSvc.getFullName()]
if not 'TUPLEFILENAME' in dir():
TUPLEFILENAME = 'reaccessed.mc.aod.root'
pass
from McParticleTools.McParticleToolsConf import McAodTupleWriterTool
from McParticleAlgs.McParticleAlgsConf import McAodTupleWriter
topSequence += McAodTupleWriter(McWriter=McAodTupleWriterTool(
TruthParticles="SpclMC", Output=TUPLEFILENAME),
OutputLevel=DEBUG)
pass
#--------------------------------------------------------------
# Output options
#--------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
outStream = AthenaPoolOutputStream("StreamAOD")
import os
outStream.OutputFile = os.path.join( \
os.path.dirname(INPUT[0]),
"reaccessed.%s" % os.path.basename(INPUT[0]) )
outStream.ForceRead = True
outStream.ItemList += ["EventInfo#McEventInfo"]
outStream.ItemList += ["McEventCollection#GEN_EVENT"]
outStream.ItemList += ["McEventCollection#GEN_AOD"]
outStream.ItemList += ["TruthParticleContainer#SpclMC"]
outStream.ItemList += ["TruthEtIsolationsContainer#TruthEtIsol_GEN_EVENT"]
outStream.ItemList += ["TruthEtIsolationsContainer#TruthEtIsol_GEN_AOD"]
## tweak the default commit interval
svcMgr.AthenaPoolCnvSvc.CommitInterval = 100
#--------------------------------------------------------------
# JobOptions for the loading of the AthenaSealSvc
#--------------------------------------------------------------
# Check the dictionary in memory for completeness
#include( "AthenaSealSvc/AthenaSealSvc_joboptions.py" )
svcMgr.AthenaSealSvc.CheckDictionary = True
#--------------------------------------------------------------
# Output options
#--------------------------------------------------------------
# Stream's output file
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("Stream1")
Stream1.OutputFile = "SimplePoolFile.root"
# List of DO's to write out
Stream1.ItemList += ["TrackCollection#*"]
#--------------------------------------------------------------
# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )
#--------------------------------------------------------------
svcMgr.MessageSvc.OutputLevel = WARNING
svcMgr.MessageSvc.debugLimit = 100000
svcMgr.MessageSvc.errorLimit = 100000
#ClassIDSvc = Service( "ClassIDSvc" )
#ClassIDSvc.OutputLevel = INFO
TrkTrackFakeWriter.OutputLevel = DEBUG
AthenaEventLoopMgr = Service("AthenaEventLoopMgr")
#AthenaEventLoopMgr.OutputLevel = DEBUG
# Try to also read in the first half that is going to be written out
# again => this should produce an error
#AthenaPoolTestDataWriter.ReadFirstHalf = TRUE
#--------------------------------------------------------------
# Output options
#--------------------------------------------------------------
# ItemList:
include("EventAthenaPool/EventAthenaPoolItemList_joboptions.py")
include(
"AthenaPoolTestAthenaPool/AthenaPoolTestAthenaPoolItemList_joboptions.py")
print fullItemList
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("Stream1")
# Run OutputStream as an algorithm
topSequence += AthenaPoolOutputStream("Stream1")
# Must make sure that no OutStream's have been declared
theApp.OutStream = []
# Stream's output file
Stream1.WritingTool = "AthenaPoolOutputStreamTool"
Stream1.OutputFile = "SimplePoolFile1.root"
# List of DO's to write out
#Stream1.ItemList += fullItemList
Stream1.ItemList += ["EventInfo#*"]
#Stream1.ItemList += ["IAthenaPoolTestCollection#*"]
# Write out only a new set of cols 1,2,3, and matrix
Stream1.ItemList += ["IAthenaPoolTestCollection#AthenaPoolTestCollection_1"]
Stream1.ItemList += ["IAthenaPoolTestCollection#AthenaPoolTestCollection_2"]
filAlg=ttbarFilterAlgorithm("ttbarFilter")
# to change properties of the filter instantiate it like this:
# filAlg=ttbarFilterAlgorithm("ttbarFilter",JetMinEt=40*GeV)
topSequence += ConfigurablePyAlgorithm("ttbarFilter")
#==============================================================
#
# End of job options file
#
###############################################################
#--------------------------------------------------------------
#--- Secondary Write portion ----- Don't change it !!!
#--------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
StreamDPD = AthenaPoolOutputStream("StreamDPD")
StreamDPD.ItemList = ['EventInfo#*', 'TrackRecordCollection#*']
StreamDPD.ItemList += ['ElectronContainer#ElectronAODCollection']
StreamDPD.ItemList += ['egDetailContainer#egDetailAOD']
StreamDPD.ItemList += ['MissingET#MET_RefFinal']
StreamDPD.ItemList += ['MissingET#MET_LocHadObj']
StreamDPD.ItemList += ['CaloClusterContainer#CaloCalTopoCluster']
StreamDPD.ItemList += ['Analysis::MuonContainer#StacoMuonCollection']
StreamDPD.ItemList += ['JetCollection#Kt4LCTopoJets']
StreamDPD.ItemList += ['JetKeyDescriptor#JetKeyMap']
StreamDPD.ItemList += ['JetCollection#Kt4TruthJets']
StreamDPD.ItemList += ['Rec::TrackParticleContainer#TrackParticleCandidate']
StreamDPD.ItemList += ['Rec::TrackParticleContainer#StacoTrackParticles']
StreamDPD.ItemList += ['TruthParticleContainer#SpclMC']
StreamDPD.ItemList += ['McEventCollection#GEN_AOD']
#--------------------------------------------------------------
theApp.OutStream = []
from AthenaCommon.AppMgr import ToolSvc
IOVDbTestAlg.StreamName = "CondStream2"
from OutputStreamAthenaPool.OutputStreamAthenaPoolConf import AthenaPoolOutputStreamTool
ToolSvc += AthenaPoolOutputStreamTool("CondStream2",OutputFile = "SimplePoolFile.root")
include( "EventAthenaPool/EventAthenaPoolItemList_joboptions.py" )
print fullItemList
# Stream's output file
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream( "Stream1", "SimpleEventPoolFile.root" )
# List of DO's to write out
Stream1.ItemList += fullItemList
# List of folders to write to file meta data
svcMgr.IOVDbSvc.FoldersToMetaData = []
svcMgr.IOVDbSvc.FoldersToMetaData += [ "/IOVDbTest/*" ]
#svcMgr.IOVDbSvc.FoldersToMetaData += [ "/IOVDbTest/IOVDbTestAMDBCorrection" ]
#svcMgr.IOVDbSvc.FoldersToMetaData += ["/IOVDbTest/IOVDbTestAttrList" ]
#svcMgr.IOVDbSvc.FoldersToMetaData += [ "/IOVDbTest/IOVDbTestAttrListColl" ]
#svcMgr.IOVDbSvc.FoldersToMetaData += [ "/IOVDbTest/IOVDbTestMDTEleMapColl" ]
#--------------------------------------------------------------
# Create simulation and digitization parameters and add them to the
# file meta data
#--------------------------------------------------------------
if BTaggingFlags.doJetTagNtuple:
theApp.TopAlg = [ e for e in theApp.TopAlg if e not in ['JetTagNtupleBuilder/JTNtBuilder'] ]
theApp.TopAlg += ['JetTagNtupleBuilder/JTNtBuilder']
if BTaggingFlags.doJetTagSlimNtuple:
theApp.TopAlg = [ e for e in theApp.TopAlg if e not in ['JetTagNtupleBuilder/JTNtSlimBuilder'] ]
theApp.TopAlg += ['JetTagNtupleBuilder/JTNtSlimBuilder']
# override DB: to have the worst case for pixel dead modules
if OverridePixMapOverlay != "":
print '#BTAG# Overriding PixMapOverlay with ',OverridePixMapOverlay
conddb.addOverride('/PIXEL/PixMapOverlay', OverridePixMapOverlay)
# --- output a new AOD file if requested (not fully validated ! strange behavior for re-tagged collections !)
if WriteNewAODFile:
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
StreamAOD = AthenaPoolOutputStream( "StreamAOD", "newAOD.pool.root", True )
StreamAOD.ForceRead = True
StreamAOD.ExtendProvenanceRecord = False
StreamAOD.TakeItemsFromInput=True
taggedJetList = []
for key in BTaggingFlags.Jets:
if key in BTaggingFlags.RetagJets:
# newJetColl = "JetCollection#"+key+"JetsAOD"
newJetColl = "JetCollection#"+key+"JetsReTagged"
else:
newJetColl = "JetCollection#"+key+"Jets"
print '#BTAG# jet collection: ',newJetColl
taggedJetList += [ newJetColl ]
StreamAOD.ItemList += taggedJetList
print '#BTAG# writing out :',StreamAOD.ItemList
DoSkimming=True)
topSequence += ObjectThinner
####### If the data contains the Truth, then do this, uncomment this lines
# Make Truth Jet on the Fly if there is truth in this data
#from JetRec.JetGetters import *
#from JetRec.JetRecFlags import jetFlags
#jetFlags.inputFileType = 'GEN'
#make_StandardJetGetter('Cone',0.4,'Truth').jetAlgorithmHandle()
# Slim the McEventCollection
#include ( "DPDUtils/TruthSlimming.py" )
#################### End the treatment of the Truth ########
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
StreamDPD = AthenaPoolOutputStream("StreamDPD")
StreamDPD.OutputFile = "D2PD.pool.root"
#Metadata and luminosity block
StreamDPD.ItemList += ["IOVMetaDataContainer#*"]
StreamDPD.ItemList += ["LumiBlockCollection#*"]
#Event Level
StreamDPD.ItemList += ['EventInfo#*']
StreamDPD.ItemList += ['PileUpEventInfo#*']
StreamDPD.ItemList += ['EventStreamInfo#*']
StreamDPD.ItemList += ['MergedEventInfo#*']
StreamDPD.ItemList += ["TrigDec::TrigDecision#TrigDecision"]
StreamDPD.ItemList += ["CTP_Decision#CTP_Decision"]
try:
ServiceMgr.EventSelector.CollectionType = CollType
except:
print "Reading from file"
SkipEvents = 0
ServiceMgr.EventSelector.SkipEvents = SkipEvents
#--------------------------------------------------------------
# Setup Output
#--------------------------------------------------------------
if hasattr(runArgs, "outputRDOFile"): Out = runArgs.outputRDOFile
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
try:
StreamRDO = AthenaPoolOutputStream("StreamRDO", Out, True)
except:
StreamRDO = AthenaPoolOutputStream("StreamRDO", "DidNotSetOutputName.root",
True)
StreamRDO.TakeItemsFromInput = TRUE
StreamRDO.ForceRead = TRUE
#force read of output data objs
# The next line is an example on how to exclude clid's if they are causing a problem
#StreamRDO.ExcludeList = ['6421#*']
# Look for lists of filter algorithms
try:
StreamRDO.AcceptAlgs = AcceptList
except:
print "No accept algs indicated in AcceptList"
try:
topSequence.McAodBuilder.CnvTool.TruthParticlesOutput = "SpclMC"
if not 'ALGMODE' in dir():
ALGMODE = 'cpp'
pass
if ALGMODE == 'py':
from McParticleTests.Lib import PyMcAodSymLinkTests as McAodSymLinkTests
else:
from McParticleTests.McParticleTestsConf import McAodSymLinkTests
topSequence += McAodSymLinkTests(OutputLevel=DEBUG)
#---------------------------------------------------------------
# Pool Persistency
#---------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
outStream = AthenaPoolOutputStream("OutStream", noTag=True)
outStream.ItemList = ["EventInfo#*"]
outStream.ItemList += ["McEventCollection#GEN_EVENT"]
outStream.ItemList += ["TruthParticleContainer#SpclMC"]
if 'OUTPUT' not in dir():
OUTPUT = "mc.aod.symlinktests.pool"
pass
outStream.OutputFile = OUTPUT
outStream.EvtConversionSvc = "AthenaPoolCnvSvc"
svcMgr.MessageSvc.defaultLimit = 4000000
svcMgr.MessageSvc.OutputLevel = ERROR
#==============================================================
#
# End of job options file
## "pydat3 mdme 202 1 "+Wtojj, # to t' : keep default value
## "pydat3 mdme 203 1 "+Wtojj, # to t' : keep default value
## "pydat3 mdme 204 1 "+Wtojj, # to t' : keep default value
## "pydat3 mdme 205 1 "+Wtojj, # to t' : keep default value
# No tau decays (Tauola)
"pydat3 mdcy 15 1 0",
# No FSR (Photos)
"pydat1 parj 90 20000",
######################
"pysubs ckin 1 300", # minimun for the invariant mass
# of WZ
"pyinit pylistf 1",
# list 1st 10 events
"pyinit dumpr 1 10",
# print the decay info
"pyinit pylisti 12"
]
#---------------------------------------------------------------
# Pool Persistency
#---------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("StreamEVGEN")
Stream1.OutputFile = "pythia.pool.root"
Stream1.ItemList += ['EventInfo#*', 'McEventCollection#*']
###############################################################
if not 'TUPLEFILENAME' in dir():
TUPLEFILENAME = 'reaccessed.mc.event.root'
pass
from McParticleTools.McParticleToolsConf import HepMcTupleWriterTool
from McParticleAlgs.McParticleAlgsConf import GenEventTupleWriter
topSequence += GenEventTupleWriter(McWriter=HepMcTupleWriterTool(
McEvents="GEN_EVENT", Output=TUPLEFILENAME),
OutputLevel=INFO)
pass
#--------------------------------------------------------------
# Output options
#--------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
outStream = AthenaPoolOutputStream("StreamEvGen")
outStream.ItemList = ["EventInfo#McEventInfo"]
outStream.ItemList += ["McEventCollection#GEN_EVENT"]
OUTPUT = os.path.join(os.path.dirname(INPUT[0]),
"reaccessed.%s" % os.path.basename(INPUT[0]))
import os
outStream.OutputFile = OUTPUT
outStream.ForceRead = True #force read of output data objs
## tweak the default commit interval
svcMgr.AthenaPoolCnvSvc.CommitInterval = 100
#--------------------------------------------------------------
# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )
D3PDMakerFlags.JetSGKey.set_Value_and_Lock('AntiKt4LCTopoJets')
## ////////////////////////////////////////////////
## Execution part
#Main JobOptions
include("RecExCommon/RecExCommon_topOptions.py")
#Add PanTau
from AthenaCommon.AlgSequence import AlgSequence
include("PanTauAnalysis/TauIdAnalysis_topOptions.py")
# Add eflowContainers
# Build AOD objects and write them out to a POOL file
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
StreamAOD = AthenaPoolOutputStream("StreamAOD")
import AthenaCommon.PropertiesManip as manip
manip.appendItemsToList(StreamAOD, 'ItemList',
'eflowObjectContainer#eflowObjects_tauMode')
manip.appendItemsToList(StreamAOD, 'ItemList',
'CaloClusterContainer#eflowClusters_tauMode')
#adjusting outputlevels to get rid of over abundant warnings from MuonMET something
from JetMissingEtTagTools.JetMissingEtTagToolsConf import JetMissingEtTagTool as ConfiguredJetMissingEtTagTool
ConfiguredJetMissingEtTagTool.OutputLevel = ERROR
#Silence the TrigDecision tool
ToolSvc.TrigDecisionTool.OutputLevel = ERROR
#Silence the StoreGateSvc
StoreGateSvc = Service("StoreGateSvc")
'xAOD::TruthEventAuxContainer#TruthEventsAux.',
'xAOD::TruthEventContainer#TruthEvents_PU',
'xAOD::TruthEventAuxContainer#TruthEvents_PUAux.',
'xAOD::TruthEventContainer#SpclMCPU',
'xAOD::TruthEventAuxContainer#SpclMCPUAux.',
'xAOD::TruthPileupEventContainer#TruthPileupEvents',
'xAOD::TruthPileupEventAuxContainer#TruthPileupEventsAux.',
'xAOD::TruthParticleContainer#TruthParticles',
'xAOD::TruthParticleAuxContainer#TruthParticlesAux.',
'xAOD::TruthVertexContainer#TruthVertices',
'xAOD::TruthVertexAuxContainer#TruthVerticesAux.',
'PileUpEventInfo#OverlayEvent' ]
if doWriteESD:
# --- create stream
StreamESD = AthenaPoolOutputStream ( "StreamESD", InDetKeys.OutputESDFileName(),asAlg=True)
# --- save MC collections if truth turned on
if InDetFlags.doTruth():
StreamESD.ItemList += truthList
# ---- load list of objects
include ( "InDetRecExample/WriteInDetESD.py" )
StreamESD.ItemList += InDetESDList
StreamESD.ItemList += [ 'xAOD::EventInfo#EventInfo' , 'xAOD::EventAuxInfo#EventInfoAux.' ]
# --- add trigger to IDRE standalone ESD
StreamESD.ItemList += [ "TrigDec::TrigDecision#TrigDecision" ]
StreamESD.ItemList += [ "HLT::HLTResult#HLTResult_L2" ]
StreamESD.ItemList += [ "HLT::HLTResult#HLTResult_EF" ]
if InDetFlags.doDBMstandalone():
StreamESD.ItemList+=["TrackCollection#SiSPSeededTracks"]
if doWriteAOD:
#topSequence.ttbarFilter.jetsName = 'Kt4LCTopoJets' # use new LC topo jets
#topSequence.ttbarFilter.maxDeltaRcx = 100.4 # effectively switch off
# cluster thinning
#print topSequence
#==============================================================
#
# End of job options file
#
###############################################################
#--------------------------------------------------------------
#--- Secondary Write portion ----- Don't change it !!!
#--------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
StreamDPD = AthenaPoolOutputStream("StreamDPD")
StreamDPD.TakeItemsFromInput = True
#StreamDPD.ItemList += ['CaloClusterContainer#CaloCalTopoCluster']
#StreamDPD.ItemList += ['JetCollection#Cone4H1TowerJets']
#StreamDPD.ItemList += ['JetKeyDescriptor#JetKeyMap']
#StreamDPD.ItemList += ['Rec::TrackParticleContainer#TrackParticleCandidate']
#StreamDPD.ItemList += ['Rec::TrackParticleContainer#StacoTrackParticles']
#StreamDPD.ItemList += ['TruthParticleContainer#SpclMC']
#StreamDPD.ItemList += ['McEventCollection#GEN_AOD']
StreamDPD.ExcludeList =['CaloClusterContainer#CaloCalTopoCluster']
StreamDPD.ExcludeList+=['TrigRoiDescriptor#HLTAutoKey*']
StreamDPD.ExcludeList+=['98849495#ConvertedMBoySegments']
StreamDPD.ExcludeList+=['107385089#*']
StreamDPD.ExcludeList+=['Rec::TrackParticleContainer#TrackParticleCandidate']
StreamDPD.OutputLevel = DEBUG
StreamDPD.OutputFile = "SkimmedThin.AOD.pool.root"
import AthenaCommon.AtlasUnixGeneratorJob from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() ## get a handle on the ApplicationManager from AthenaCommon.AppMgr import theApp theApp.EvtMax = 20 ## get a handle on the ServiceManager from AthenaCommon.AppMgr import ServiceMgr as svcMgr svcMgr.EventSelector.RunNumber = 1 from AthenaPoolExampleAlgorithms.AthenaPoolExampleAlgorithmsConf import AthPoolEx__WriteData topSequence += AthPoolEx__WriteData( "WriteData" ) #from AthenaRootComps.WriteAthenaRoot import AthenaRootOutputStream from AthenaRootComps.OutputStreamAthenaRoot import createOutputStream Stream1 = createOutputStream( "Stream1" , "SimpleRootFile.root" , True ) Stream1.ItemList += [ "ExampleHitContainer#MyHits" ] from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream Stream2 = AthenaPoolOutputStream( "Stream2" , "SimplePoolFile.root" , True ) Stream2.ItemList += [ "ExampleHitContainer#MyHits" ] svcMgr.MessageSvc.OutputLevel = 0
# Take the file name form the command line -c options
EventSelector = svcMgr.EventSelector
try:
EventSelector.InputCollections = In
except:
print "Usage: -c 'In=['file']'"
# Check collection type
try:
EventSelector.CollectionType = CollType
except:
print "Reading from file"
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
try:
Stream1 = AthenaPoolOutputStream("Stream1", Out, True)
except:
Stream1 = AthenaPoolOutputStream("Stream1", "DidNotSetOutputName.root",
True)
Stream1.TakeItemsFromInput = TRUE
Stream1.ForceRead = TRUE
#force read of output data objs
# The next line is an example on how to exclude clid's if they are causing a problem
#Stream1.ExcludeList = ['6421#*']
# Look for lists of filter algorithms
try:
Stream1.AcceptAlgs = AcceptList
except:
print "No accept algs indicated in AcceptList"
try:
outdata.close()
print("INFO: Written", i, "starting points")
## Algorithm sequence
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
## AthenaCommon flags
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
athenaCommonFlags.EvtMax = i
athenaCommonFlags.PoolHitsOutput.set_Off()
from AthenaCommon.AppMgr import theApp
theApp.EvtMax = i
import AthenaCommon.AtlasUnixGeneratorJob
from ReadEventFromFile.ReadEventFromFileConf import ReadHepMcFromAscii
read = ReadHepMcFromAscii()
read.AsciiFile = options.outfile
topSequence += read
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
outStream = AthenaPoolOutputStream("OutStream")
outStream.ItemList = ["EventInfo#*", "McEventCollection#*"]
outfile = options.outfile
if outfile.endswith(".ascii"):
outfile = outfile[:-6]
outStream.OutputFile = outfile + ".pool.root"
# "yLimits 0. 0.", # lower and upper limits. The upper limit is optional ## "zLimits -4000. 4000.", # required for shape=cylinder # "ptLimits 0. 0.", # lower and upper limits. The upper limit is optional # "phiLimits 0. 0.", # lower and upper limits. The upper limit is optional # "etaLimits 0. 0.", # lower and upper limits. The upper limit is optional ## "rLimits 650. 1950."] # required for shape=cylinder # "weightLimits 0. 0."] # lower and upper limits. The upper limit is optional topSequence += BeamHaloGenerator print BeamHaloGenerator # Required when monitoring plots are enabled. theApp.HistogramPersistency = "ROOT" if not hasattr(ServiceMgr, 'THistSvc'): from GaudiSvc.GaudiSvcConf import THistSvc ServiceMgr += THistSvc() ServiceMgr.THistSvc.Output += [ "BeamHalo DATAFILE='BeamHalo.root' OPT='RECREATE'"] # For debugging #from TruthExamples.TruthExamplesConf import DumpMC #topSequence += DumpMC() from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream Stream1 = AthenaPoolOutputStream( "StreamEVGEN" ) Stream1.OutputFile = "evgen.pool.root" Stream1.ItemList += [ 'EventInfo#*', 'McEventCollection#*' ]
job += epos
genSeq.ExtSvc += ["AtRndmGenSvc"]
# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )
MessageSvc = Service("MessageSvc")
MessageSvc.OutputLevel = 3
# Number of events to be processed (default is 10)
#theApp.EvtMax = 200
evgenConfig.minevents = 100
# ----------------------------------------------------------------------
# Printing service
# ----------------------------------------------------------------------
from TruthExamples.TruthExamplesConf import DumpMC
#job += DumpMC()
# ----------------------------------------------------------------------
# Ntuple service output
# ----------------------------------------------------------------------
import AthenaPoolCnvSvc.WriteAthenaPool
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
stream1 = AthenaPoolOutputStream("StreamEVGEN")
stream1.WritingTool = "AthenaOutputStreamTool"
stream1.OutputFile = "epos_events.pool.root"
stream1.TakeItemsFromInput = True
stream1.ItemList += ['EventInfo#*', 'McEventCollection#*']
# ----------------------------------------------------------------------
topSequence += McAodBuilder(
"McAodBuilder",
OutputLevel=INFO,
FilterTool=NoopFilterTool(
McEvents="GEN_EVENT",
DoEtIsolations=jp.McAodFlags.doTruthEtIsolations()),
CnvTool=TruthParticleCnvTool(
McEvents="GEN_AOD",
TruthParticlesOutput="SpclMC",
DoEtIsolations=jp.McAodFlags.doTruthEtIsolations()))
#---------------------------------------------------------------
# Pool Persistency
#---------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
outStream = AthenaPoolOutputStream("OutStream", noTag=True)
outStream.ItemList = ["EventInfo#McEventInfo"]
outStream.ItemList += ["McEventCollection#GEN_EVENT"]
outStream.ItemList += ["McEventCollection#GEN_AOD"]
outStream.ItemList += ["TruthParticleContainer#SpclMC"]
outStream.ItemList += ["TruthEtIsolationsContainer#TruthEtIsol_GEN_EVENT"]
if not 'OUTPUT' in dir():
OUTPUT = "my.data.pool"
pass
outStream.OutputFile = OUTPUT
from GaudiSvc.GaudiSvcConf import MessageSvc
svcMgr += MessageSvc(defaultLimit=4000000)
svcMgr.MessageSvc.OutputLevel = WARNING
# Event related parameters
#--------------------------------------------------------------
# Number of events to be processed (default is 10)
#theApp.EvtMax = 20
theApp.EvtSel = "EventSelector"
# Use auditors
theApp.Dlls += [ "GaudiAud" ]
#
# write out a summary of the time spent
#
from GaudiSvc.GaudiSvcConf import AuditorSvc
svcMgr += AuditorSvc()
from GaudiSvc.GaudiSvcConf import ChronoStatSvc
svcMgr += ChronoStatSvc()
from GaudiSvc.GaudiSvcConf import MessageSvc
svcMgr += MessageSvc( defaultLimit = 100000000 )
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("Stream1")
Stream1.OutputFile = "ctb_CaloDigit.pool.root"
Stream1.ForceRead=TRUE
Stream1.ItemList+=["EventInfo#*"]
Stream1.ItemList+=["LArRawChannelContainer#*"]
Stream1.ItemList+=["TileRawChannelContainer#*"]
Stream1.ItemList+=["McEventCollection#*"]
Stream1.ItemList += ["CaloCalibrationHitContainer#*"]
svcMgr.IOVDbSvc.GlobalTag = GlobalTag
topSeq += ToyNextPassFilterAlg(NPasses=3)
#services that need to be reinit
ServiceMgr.MultipleEventLoopMgr.ToBeReinitialized = ["StoreGateSvc", "DetectorStore"]
#
# I/O stuff
#
ServiceMgr.EventSelector.InputCollections = [
"root://eosatlas//eos/atlas/atlascerngroupdisk/proj-sit/digitization/RTT/mc10/mc10_7TeV.005008.CavernInput.merge.HITS.e4_e607_s951_s952_tid170551_00/HITS.170551._000011.pool.root.1" ]
# Set up for seeking.
ServiceMgr.EventSelector.CollectionType = "SeekableROOT"
include( "AthenaPoolCnvSvc/WriteAthenaPool_jobOptions.py" )
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream( "Stream1" )
Stream1.OutputFile = "MultiplePassFile.root"; # ** mandatory parameter ** // The output file name
Stream1.ForceRead=TRUE #force read of output data objs
Stream1.ItemList=["EventInfo#*", "McEventCollection#*"]
#--------------------------------------------------------------
#--- Monitoring and Debug printouts
#--------------------------------------------------------------
MessageSvc.OutputLevel = INFO
Stream1.OutputLevel = DEBUG
#StoreGateSvc.Dump=1
#StoreGateSvc.OutputLevel=DEBUG
from AthenaCommon.AppMgr import theAuditorSvc
from GaudiAud.GaudiAudConf import ChronoAuditor
'xAOD::TruthEventAuxContainer#TruthEvents_PUAux.',
'xAOD::TruthEventContainer#SpclMCPU',
'xAOD::TruthEventAuxContainer#SpclMCPUAux.',
'xAOD::TruthPileupEventContainer#TruthPileupEvents',
'xAOD::TruthPileupEventAuxContainer#TruthPileupEventsAux.',
'xAOD::TruthParticleContainer#TruthParticles',
'xAOD::TruthParticleAuxContainer#TruthParticlesAux.',
'xAOD::TruthVertexContainer#TruthVertices',
'xAOD::TruthVertexAuxContainer#TruthVerticesAux.',
'PileUpEventInfo#OverlayEvent'
]
if doWriteESD:
# --- create stream
StreamESD = AthenaPoolOutputStream("StreamESD",
InDetKeys.OutputESDFileName(),
asAlg=True)
# --- save MC collections if truth turned on
if InDetFlags.doTruth():
StreamESD.ItemList += truthList
# ---- load list of objects
include("InDetRecExample/WriteInDetESD.py")
StreamESD.ItemList += InDetESDList
StreamESD.ItemList += [
'xAOD::EventInfo#EventInfo', 'xAOD::EventAuxInfo#EventInfoAux.'
]
# --- add trigger to IDRE standalone ESD
StreamESD.ItemList += ["TrigDec::TrigDecision#TrigDecision"]
StreamESD.ItemList += ["HLT::HLTResult#HLTResult_L2"]
StreamESD.ItemList += ["HLT::HLTResult#HLTResult_EF"]
StreamESD.ForceRead = True # otherwise unread stuff is not copied
print "Reading from file"
SkipEvents=0
if hasattr(runArgs,"skipEvents"):
SkipEvents = runArgs.skipEvents
ServiceMgr.EventSelector.SkipEvents = SkipEvents
#--------------------------------------------------------------
# Setup Output
#--------------------------------------------------------------
if not hasattr(runArgs,"outputHitsFile"):
raise RuntimeError("No outputHitsFile provided.")
Out = runArgs.outputHitsFile
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
try:
StreamHITS = AthenaPoolOutputStream( "StreamHITS", Out, True )
except:
StreamHITS = AthenaPoolOutputStream( "StreamHITS", "DidNotSetOutputName.root", True )
StreamHITS.TakeItemsFromInput=TRUE;
StreamHITS.ForceRead=TRUE; #force read of output data objs
# The next line is an example on how to exclude clid's if they are causing a problem
#StreamHITS.ExcludeList = ['6421#*']
# Look for lists of filter algorithms
try:
StreamHITS.AcceptAlgs = AcceptList
except:
print "No accept algs indicated in AcceptList"
try:
StreamHITS.RequireAlgs = RequireList
except:
# MC truth information
if doWriteESD or doWriteAOD:
if InDetFlags.doTruth():
truthList = [ 'xAOD::TruthEventContainer#TruthEvents',
'xAOD::TruthEventAuxContainer#TruthEventsAux.',
'xAOD::TruthPileupEventContainer#TruthPileupEvents',
'xAOD::TruthPileupEventAuxContainer#TruthPileupEventsAux.',
'xAOD::TruthParticleContainer#TruthParticles',
'xAOD::TruthParticleAuxContainer#TruthParticlesAux.',
'xAOD::TruthVertexContainer#TruthVertices',
'xAOD::TruthVertexAuxContainer#TruthVerticesAux.',
'PileUpEventInfo#OverlayEvent' ]
if doWriteESD:
# --- create stream
StreamESD = AthenaPoolOutputStream ( "StreamESD", InDetKeys.OutputESDFileName(),asAlg=True)
# --- save MC collections if truth turned on
if InDetFlags.doTruth():
StreamESD.ItemList += truthList
# ---- load list of objects
include ( "InDetRecExample/WriteInDetESD.py" )
StreamESD.ItemList += InDetESDList
StreamESD.ItemList += [ 'xAOD::EventInfo#EventInfo' , 'xAOD::EventAuxInfo#EventInfoAux.' ]
# --- add trigger to IDRE standalone ESD
StreamESD.ItemList += [ "TrigDec::TrigDecision#TrigDecision" ]
StreamESD.ItemList += [ "HLT::HLTResult#HLTResult_L2" ]
StreamESD.ItemList += [ "HLT::HLTResult#HLTResult_EF" ]
StreamESD.ForceRead = True # otherwise unread stuff is not copied
if InDetFlags.doDBMstandalone():
topSequence.StreamESD.ItemList+=["TrackCollection#SiSPSeededTracks"]
