def test1NamedSingleton(self):
"""Test that instances w/ same name are the same"""
i1 = CfgItemList("MyItems")
i2 = CfgItemList("MyItems")
self.failUnless(i1 == i2, "instances are not equal !")
self.failUnless(i1 is i2, "instances are not identical !")
def test3Methods(self):
"""Test various methods of CfgKeyStore"""
ks = CfgKeyStore("MyStore")
self.failUnless(ks.streamESD() == [])
self.failUnless(ks['streamESD']() == [])
ks.streamESD.add({
'McEventCollection': ['GEN_EVENT', 'GEN_AOD', 'TruthEvent'],
})
self.failUnless(len(ks.streamESD()) == 3)
self.failUnless(len(ks.transient()) == 3)
self.failUnless(ks.streamESD.has_item('McEventCollection#TruthEvent'))
self.failUnless(not ks.streamESD.has_item('McEventCollection#gen_aod'))
ks.streamAOD += CfgItemList('subAod',
items=['Klass#key1', 'Klass#key2'])
self.failUnless(len(ks.streamAOD()) == 2)
self.failUnless(len(ks.transient()) == 5)
ks.streamESD.add({
'JetCollection':
['Cone4Jets', 'Cone7Jets', 'KtJets', 'Cone4TruthJets'],
})
self.failUnless(len(ks.streamESD()) == 3 + 4)
self.failUnless(len(ks.streamESD.dict().keys()) == 2)
self.failUnless(len(ks.transient.dict().keys()) == 3)
ks.streamESD.add(
{'JetCollection': ['Cone4Jets', 'Cone7Jets', 'KtJets']})
self.failUnless(len(ks.streamESD()) == 3 + 4)
self.failUnless(len(ks.streamESD.dict().keys()) == 2)
self.failUnless(len(ks.transient.dict().keys()) == 3)
ks.streamAOD.add('ParticleJetContainer#ConeTowerParticleJets')
self.failUnless(len(ks.streamAOD()) == 3)
self.failUnless(len(ks.streamAOD.dict().keys()) == 2)
self.failUnless(len(ks.transient.dict().keys()) == 4)
ks.streamAOD.add(['ParticleJetContainer#ConeTowerParticleJets'])
self.failUnless(len(ks.streamAOD()) == 3)
self.failUnless(len(ks.streamAOD.dict().keys()) == 2)
self.failUnless(len(ks.transient.dict().keys()) == 4)
ks.streamAOD.add(['ParticleJetContainer#Cone4TowerParticleJets'])
self.failUnless(len(ks.streamAOD()) == 4)
self.failUnless(len(ks.streamAOD.dict().keys()) == 2)
self.failUnless(len(ks.transient.dict().keys()) == 4)
caught = False
try:
ks['unallowedKey'] = range(10)
except KeyError, err:
caught = True
def test3Hierarchy( self ):
"""Test tree-like hierarchy structure of item lists"""
i = CfgItemList( 'MyItems',
items = [ 'Klass1#klass1',
'Klass2#klass2', ],
allowWildCard = False )
ii = CfgItemList( 'MySubItems',
items = [ 'Klass3#klass3',
'Klass4#klass4',
'Klass5#klass5',
'Klass6#klass6' ] )
self.failUnless( len(i()) == 2,
"Invalid output item list !!" )
self.failUnless( len(ii()) == 4,
"Invalid output item list !!" )
i += ii
self.failUnless( len(i()) == 6,
"Invalid output item list !!" )
self.failUnless( hasattr(i, ii.name()),
'Invalid hierarchy structure !!' )
oo = getattr(i, ii.name())
self.failUnless( oo == ii,
'Invalid hierarchy structure !!' )
self.failUnless( oo is ii,
'Invalid hierarchy structure !!' )
self.failUnless( len(oo()) == 4,
"Invalid output item list !!" )
del ii
ii = CfgItemList( 'MySubItems' )
self.failUnless( len(ii()) == 4,
"Invalid output item list !!" )
del i,ii
i = CfgItemList( 'MyItems' )
ii = CfgItemList( 'MySubItems' )
self.failUnless( len( i()) == 0, "Invalid output item list !!" )
self.failUnless( len(ii()) == 4, "Invalid output item list !!" )
del oo,ii
ii = CfgItemList( 'MySubItems' )
self.failUnless( len(ii()) == 0, "Invalid output item list !!" )
def test5WildCard(self):
"""Test the wildcard capabilities of CfgItemList"""
i = CfgItemList('MyItems')
self.failUnless(i.name() == 'MyItems')
## test wildcard
i.add("Klass#Foo")
self.failUnless(i("Klass") == ["Klass#Foo"])
# ignored as not allowing wildcarded items
i.add("Klass#*")
self.failUnless(i("Klass") == ["Klass#Foo"])
# allowed as special cases for trigger
i.clear()
i.add("TrigKlass#HLTAutoKey*")
self.failUnless(i("TrigKlass") == ["TrigKlass#HLTAutoKey*"])
i.clear()
i.add("TrigKlass#HLTAutoKey_*")
self.failUnless(i("TrigKlass") == ["TrigKlass#HLTAutoKey_*"])
i.clear()
i.add("TrigKlass#HLTAutoKey_foo_*")
self.failUnless(i("TrigKlass") == ["TrigKlass#HLTAutoKey_foo_*"])
i.clear()
i.add("TrigKlass#HLTAutoKey_foo_42_*")
self.failUnless(i("TrigKlass") == ["TrigKlass#HLTAutoKey_foo_42_*"])
def test4Methods(self):
"""Test various methods of CfgItemList"""
i = CfgItemList('MyItems')
self.failUnless(i.name() == 'MyItems')
i.add({'Klass': ['key1', 'key2']})
self.failUnless(i() == ['Klass#key1', 'Klass#key2'])
i.add({'Klass': ['key1', 'key3']})
self.failUnless(i() == ['Klass#key1', 'Klass#key2', 'Klass#key3'])
props = i.getProperties()
self.failUnless(props.has_key('Klass'))
self.failUnless(len(props['Klass']) == len(['key1', 'key2', 'key3']))
self.failUnless('key1' in props['Klass'])
self.failUnless('key2' in props['Klass'])
self.failUnless('key3' in props['Klass'])
self.failUnless(len(i.allChildren()) == 0)
self.failUnless(i.has_item('Klass#key1'))
self.failUnless(i.has_item('Klass#key*'))
self.failUnless(not i.has_item('Klass#Key1'))
self.failUnless(not i.has_item('Klass#Key*'))
i.clear()
self.failUnless(len(i()) == 0)
i.add({'Klass': ['key1', 'key2']})
self.failUnless(len(i()) == 2)
i.remove('Klass')
self.failUnless(len(i()) == 2)
i.remove('Klass#key1')
self.failUnless(len(i()) == 2)
i.removeAll()
self.failUnless(len(i()) == 2)
i.removeItem('Klass')
self.failUnless(len(i()) == 2)
i.removeItem('Klass#key1')
self.failUnless(len(i()) == 1)
_keys = ['key1', 'key2', 'key3']
i.add({'Klass': _keys})
self.failUnless(len(i()) == 3)
i.removeAllItems('Klass#key2')
self.failUnless(len(i()) == 2)
## test we don't modify input dict
d = {'Klassy': ['key1', 'key2', 'key3']}
orig_d = d.copy()
i.add(d)
self.failUnless(d == orig_d)
d = {'Klassy': 'key4'}
orig_d = d.copy()
i.add(d)
self.failUnless(d == orig_d)
## test extraction of the item list of a given Container type
_keys = ["Klassy#%s" % k for k in 'key1', 'key2', 'key3', 'key4']
self.failUnless(i("Klassy") == _keys)
self.failUnless(i.list("Klassy") == _keys)
self.failUnless(i(key="Klassy") == _keys)
self.failUnless(i.list(key="Klassy") == _keys)
## test dict()
_keys = ['key1', 'key2', 'key3', 'key4']
self.failUnless(i.dict()['Klass'] == ['key1', 'key3'])
self.failUnless(i.dict()['Klassy'] == _keys)
_dict = {
'Klass': ['key1', 'key3'],
'Klassy': ['key1', 'key2', 'key3', 'key4']
}
self.failUnless(i.dict() == _dict)
def HSG5D3PD (alg = None,
file = 'hsg5.root',
tuplename = 'physics',
streamname = 'd3pdstream',
flags=HSG5Flags,
**kw):
if flags.doTaus():
# tau
from TauD3PDMaker.TauD3PDObject import TauD3PDObject
# define associations
if flags.doPhotons() and not PhotonD3PDObject.allBlocknames().has_key('RecoveryMatch'):
from PhotonD3PDMaker.PhotonRecoveryAssociation import PhotonRecoveryAssociation
PhotonRecoveryAssoc = PhotonRecoveryAssociation(PhotonD3PDObject,
'ElectronContainer',
D3PDMakerFlags.ElectronSGKey(),
prefix = 'el_',
blockname = 'RecoveryMatch',
target = 'ph_ElectronRecovered_')
# define track and cluster filters
preseq = AlgSequence (D3PDMakerFlags.PreD3PDAlgSeqName())
if flags.doGoodTracks() and not hasattr( preseq, "GoodTracks" ):
filter1 = makeTrackFilterAlg(TracksName = D3PDMakerFlags.TrackSGKey(),
OutputTracksName='GoodTracks',
ptCut=0.,nSCTPix=4)
preseq += filter1
if flags.doHighPtTracks() and not hasattr( preseq, "HighPtTracks" ):
filter2 = makeTrackFilterAlg(TracksName = D3PDMakerFlags.TrackSGKey(),
OutputTracksName='HighPtTracks',
ptCut=5000.,nSCTPix=4)
preseq += filter2
if flags.doHighPtClusters() and not hasattr( preseq, "HighPtClusters" ):
filter3 = makeClusterFilter(InputName = D3PDMakerFlags.ClusterSGKey(),
OutputName = 'HighPtClusters',
ptCut=10000.)
preseq += filter3
if flags.doHighPtEMClusters() and not hasattr( preseq, "HighPtEMClusters" ):
filter4 = makeClusterFilter(InputName = D3PDMakerFlags.EMTopoClusterSGKey(),
OutputName = 'HighPtEMClusters',
ptCut=10000.)
preseq += filter4
# perform recoil calculation
if flags.doHadronicRecoil():
from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__ElectronSelector
from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__MuonSelector
from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__EflowSelector
from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__RecoilCalculation
from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__EflowRecoil
if not hasattr( preseq, "HadronicRecoil::ElectronSelector" ):
preseq += HadronicRecoil__ElectronSelector()
if not hasattr( preseq, "HadronicRecoil::MuonSelector" ):
preseq += HadronicRecoil__MuonSelector()
if not hasattr( preseq, "HadronicRecoil::EflowSelector" ):
preseq += HadronicRecoil__EflowSelector()
if not hasattr( preseq, "HadronicRecoil::RecoilCalculation" ):
preseq += HadronicRecoil__RecoilCalculation( ConeSizes = [0.20] )
if not hasattr( preseq, "EflowRecoil_20" ):
preseq += HadronicRecoil__EflowRecoil("EflowRecoil_20",
TrackRough = "RoughRecoil_track_20",
TrackUE = "ueCorrection_track_20",
TrackRef = "RefinedRecoil_track_20",
ClusNoTrackRough = "RoughRecoil_clusNoTrack_20",
ClusNoTrackUE = "ueCorrection_clusNoTrack_20",
ClusNoTrackRef = "RefinedRecoil_clusNoTrack_20",
RoughRecoil_out = "RoughRecoil_Eflow_20",
ueCorrection_out = "ueCorrection_Eflow_20",
RefinedRecoil_out= "RefinedRecoil_Eflow_20",
MET_out = "MET_HR_Eflow_20" )
# now configure the D3PD
if not alg:
alg = MSMgr.NewRootStream(StreamName = streamname, FileName = file, TreeName = tuplename)
alg += EventInfoD3PDObject (**_args (10, 'EventInfo', kw))
alg += LArCollisionTimeD3PDObject (**_args (10, 'LArCollisionTime', kw))
from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata
addBunchStructureMetadata (alg)
# Eta rings of energy
# FIXME brian crashing aod running
if not rec.readAOD:
from CaloD3PDMaker.RapgapD3PDObject import EtaRingsNonTileD3PDObject
from CaloD3PDMaker.RapgapD3PDObject import EtaRingsD3PDObject
alg += EtaRingsNonTileD3PDObject ( **_args ( 0, 'EtaRings', kw) )
alg += EtaRingsD3PDObject ( **_args ( 0, 'EtaRings', kw) )
# Electron/Photon blocks
alg += ElectronD3PDObject (**_args (10, 'Electron', kw))
if testSGKey ('ElectronContainer', D3PDMakerFlags.GSFElectronSGKey()):
alg += GSFElectronD3PDObject (**_args (10, 'GSFElectron', kw,
sgkey = D3PDMakerFlags.GSFElectronSGKey(),
prefix = 'el_gsf_'))
if flags.doPhotons():
print "adding photons"
alg += PhotonD3PDObject (**_args (10, 'Photon', kw))
# Muon blocks
### add the scattering significance filler - to be removed when added in the MuonD3PDMaker
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, 'MuidMuon', kw,
sgkey='MuidMuonCollection', prefix='mu_muid_',
include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex",
"L2CBInfoIndex", "L1InfoIndex"],
exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing = True ))
alg += MuonD3PDObject (**_args (10, 'StacoMuon', kw,
sgkey='StacoMuonCollection', prefix='mu_staco_',
include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex",
"L2CBInfoIndex", "L1InfoIndex"],
exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing = True ))
from AthenaCommon.KeyStore import CfgItemList
if CfgItemList("KeyStore_inputFile").has_item("Analysis::MuonContainer#Muons"):
alg += MuonD3PDObject (**_args (10, 'Muons', kw,
sgkey='Muons', prefix='mu_muons_',
include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex",
"L2CBInfoIndex", "L1InfoIndex"],
exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing = True ))
alg += MuonD3PDObject (**_args (0, 'CaloMuon', kw, sgkey='CaloMuonCollection', prefix='mu_calo_',
include = ["MuonHitSummary", "Authors", "Likelihood",
"Isolation", "CaloEnergyLoss", "Quality"] ))
# Tau block
if flags.doTaus():
alg += TauD3PDObject (**_args ( 1, 'Tau', kw))
# track and cluster blocks
# ... all clusters, very low LOD
alg += ClusterD3PDObject (**_args ( 0, 'Clusters1', kw,
exclude='SamplingBasics'))
# ... higher LOD for pt>10 GeV
if flags.doHighPtClusters():
alg += ClusterD3PDObject (**_args ( 2, 'Clusters2', kw,
sgkey = 'HighPtClusters',
prefix = 'clpt10_'))
if flags.doHighPtEMClusters():
alg += ClusterD3PDObject (**_args ( 3, 'Clusters3', kw,
sgkey = 'HighPtEMClusters',
prefix = 'emclpt10_'))
from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject
# ... good tracks only (nSCT>3; no pt cut)
# use standard level of track info for 'GoodTracks'
if flags.doGoodTracks():
# use standard level of track info for 'GoodTracks'
alg += TrackParticleD3PDObject (**_args ( 3, 'Tracks1', kw,
sgkey = 'GoodTracks',
label = 'trk',
prefix = 'trk_'))
# ... high-pt tracks (nSCT>3; pt>5 GeV)
if flags.doHighPtTracks():
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.storeTrackSummary.IDOutliers = True
highPtFlags.storeTrackSummary.PixelInfoPlus = True
highPtFlags.storeTrackSummary.SCTInfoPlus = True
highPtFlags.storeTrackSummary.TRTInfoPlus = True
highPtFlags.storeTrackSummary.InfoPlus = True
highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0
highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2
highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3
HighPtTrackParticleD3PDObject = TrackD3PDObject(_label='trkpt5',
_prefix='trkpt5_',
_sgkey='HighPtTracks',
typeName='Rec::TrackParticleContainer',
flags=highPtFlags)
alg += HighPtTrackParticleD3PDObject(**_args ( 3, 'Tracks2', kw,
sgkey = 'HighPtTracks',
label = 'trkpt5',
prefix = 'trkpt5_'))
# Jet blocks
from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags
# include list modified for HSG5D3PD
includelist = JetTagD3PDFlags.StdInfoInclude()
from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys
includelist += [JetTagD3PDKeys.BTagWeightsBlockName()]
#includelist += [JetTagD3PDKeys.JetFitterInfoBaseBlockName()]
#includelist += [JetTagD3PDKeys.JetFitterTagInfoBlockName()]
#includelist += [JetTagD3PDKeys.IP3DInfoBaseBlockName()]
#includelist += [JetTagD3PDKeys.IP3DIPInfoBaseBlockName()]
#includelist += [JetTagD3PDKeys.JetFitterCombInfoBaseBlockName()]
includelist += [JetTagD3PDKeys.JetTrackAssocBlockName()]
includelist += [JetTagD3PDKeys.JetTrackBlockName()]
includelist += [JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()]
includelist += [JetTagD3PDKeys.IPInfoPlusTrackBlockName()]
includelist += ['ConstituentScale']
jetkw = kw
if not jetkw.has_key ( 'AK4TopoEMJet_'+JetTagD3PDKeys.JetTrackAssocBlockName()+'_target'):
jetkw['AK4TopoEMJet_'+JetTagD3PDKeys.JetTrackAssocBlockName()+'_target']= "trk"
if not jetkw.has_key ( 'AK4TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target'):
jetkw['AK4TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target']= "trk"
alg += JetD3PDObject (**_args ( 3, 'AK4TopoEMJet', jetkw,
sgkey='AntiKt4TopoEMJets', prefix='jet_AntiKt4TopoEM_',
include = includelist,
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
allowMissing = True))
alg += JetD3PDObject (**_args ( 3, 'AK6TopoEMJet', kw,
sgkey='AntiKt6TopoEMJets', prefix='jet_AntiKt6TopoEM_',
include = [JetTagD3PDFlags.StdInfoInclude(),'ConstituentScale'],
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
allowMissing = True))
alg += JetD3PDObject (**_args ( 3, 'AK4LCTopoJet', kw,
sgkey='AntiKt4LCTopoJets', prefix='jet_AntiKt4LCTopo_',
exclude=['Layer'],
include=['ConstituentScale'],
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
allowMissing = True))
alg += JetD3PDObject (**_args ( 3, 'AK6LCTopoJet', kw,
sgkey='AntiKt6LCTopoJets', prefix='jet_AntiKt6LCTopo_',
exclude=['Layer'],
include=['ConstituentScale'],
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
allowMissing = True))
from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject
alg += HforD3PDObject(**_args (0, 'HforInfo', kw))
# MET blocks
# a whole mess to remove x,y components separately for all flavours
if flags.doAllMissingET() :
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_Muons_Comps','MET_Muons_Spectro_Comps','MET_Muons_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_RefMons_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_RefMuons_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','MET_Comps',
'MET_Track_Weights','MET_Cluster_Weights'],
allowMissing=True))
else :
alg += MissingETD3PDObject(0, sgkey = "MET_RefFinal", prefix = "MET_RefFinal")
# MuonBoy terms used in RefFinal
alg += MissingETD3PDObject(0, sgkey = "MET_MuonBoy", prefix = "MET_MuonBoy")
alg += MissingETD3PDObject(0, sgkey = "MET_RefMuon", prefix = "MET_RefMuon")
alg += MissingETD3PDObject(0, sgkey = "MET_CellOut_Eflow", prefix = "MET_CellOut_Eflow")
# terms needed to calculate RefFinal with Muid instead of Staco
alg += MissingETD3PDObject(0, sgkey = "MET_RefMuon_Muid", prefix = "MET_RefMuon_Muid")
alg += MissingETD3PDObject(0, sgkey = "MET_MuonMuid", prefix = "MET_MuonMuid")
alg += MissingETD3PDObject(0, sgkey = "MET_Muid", prefix = "MET_Muid")
alg += MissingETD3PDObject(0, sgkey = "MET_CellOut_Eflow_Muid", prefix = "MET_CellOut_Eflow_Muid")
# terms needed to calculate RefFinal with third chain instead of Staco
from AthenaCommon.KeyStore import CfgItemList
keystore = CfgItemList("KeyStore_inputFile")
if keystore.has_item("MissingET#MET_Muons"):
alg += MissingETD3PDObject(0, sgkey = "MET_Muons", prefix = "MET_Muons")
if keystore.has_item("MissingET#MET_RefMuons"):
alg += MissingETD3PDObject(0, sgkey = "MET_RefMuons", prefix = "MET_RefMuons")
if keystore.has_item("MissingET#MET_CellOut_Eflow_Muons"):
alg += MissingETD3PDObject(0, sgkey = "MET_CellOut_Eflow_Muons", prefix = "MET_CellOut_Eflow_Muons")
# I have no idea what these are for
alg += MissingETD3PDObject(0, sgkey = "MET_SoftJets", prefix = "MET_SoftJets")
alg += MissingETD3PDObject(0, sgkey = "MET_RefFinal_em", prefix = "MET_RefFinal_em")
alg += MissingETD3PDObject(0, sgkey = "MET_CellOut_em", prefix = "MET_CellOut_em")
alg += MissingETD3PDObject(0, sgkey = "MET_SoftJets_em", prefix = "MET_SoftJets_em")
# HadronicRecoil blocks
if flags.doHadronicRecoil():
alg += ElectronD3PDObject(0, sgkey = "HR_selectedElectrons", prefix = "hr_el_")
alg += MuonD3PDObject( 0, sgkey = "HR_selectedMuons", prefix = "hr_mu_" )
alg += MissingETD3PDObject(0, sgkey = "RoughRecoil_20", prefix = "hr_roughRecoil_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "ueCorrection_20", prefix = "hr_ueCorrection_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "RefinedRecoil_20", prefix = "hr_corrRecoil_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "MET_HR_20", prefix = "hr_MET_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "RoughRecoil_track_20", prefix = "hr_roughRecoil_track_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "ueCorrection_track_20", prefix = "hr_ueCorrection_track_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "RefinedRecoil_track_20", prefix = "hr_corrRecoil_track_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "MET_HR_track_20", prefix = "hr_MET_track_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "RoughRecoil_clusNoTrack_20", prefix = "hr_roughRecoil_clusNoTrack_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "ueCorrection_clusNoTrack_20", prefix = "hr_ueCorrection_clusNoTrack_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "RefinedRecoil_clusNoTrack_20", prefix = "hr_corrRecoil_clusNoTrack_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "MET_HR_clusNoTrack_20", prefix = "hr_MET_clusNoTrack_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "RoughRecoil_Eflow_20", prefix = "hr_roughRecoil_Eflow_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "ueCorrection_Eflow_20", prefix = "hr_ueCorrection_Eflow_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "RefinedRecoil_Eflow_20", prefix = "hr_corrRecoil_Eflow_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject(0, sgkey = "MET_HR_Eflow_20", prefix = "hr_MET_Eflow_20",
exclude=['MET_Regions','MET_Comps'] )
"""
# track and cluster blocks
# ... all clusters, very low LOD
alg += ClusterD3PDObject (**_args ( 0, 'Clusters1', kw,
exclude='SamplingBasics'))
# ... higher LOD for pt>10 GeV
if flags.doHighPtClusters():
alg += ClusterD3PDObject (**_args ( 2, 'Clusters2', kw,
sgkey = 'HighPtClusters',
prefix = 'clpt10_'))
if flags.doHighPtEMClusters():
alg += ClusterD3PDObject (**_args ( 3, 'Clusters3', kw,
sgkey = 'HighPtEMClusters',
prefix = 'emclpt10_'))
from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject
# ... good tracks only (nSCT>3; no pt cut)
# use standard level of track info for 'GoodTracks'
if flags.doGoodTracks():
# use standard level of track info for 'GoodTracks'
alg += TrackParticleD3PDObject (**_args ( 3, 'Tracks1', kw,
sgkey = 'GoodTracks',
label = 'trk',
prefix = 'trk_'))
# ... high-pt tracks (nSCT>3; pt>5 GeV)
if flags.doHighPtTracks():
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.storeTrackSummary.IDOutliers = True
highPtFlags.storeTrackSummary.PixelInfoPlus = True
highPtFlags.storeTrackSummary.SCTInfoPlus = True
highPtFlags.storeTrackSummary.TRTInfoPlus = True
highPtFlags.storeTrackSummary.InfoPlus = True
highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0
highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2
highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3
HighPtTrackParticleD3PDObject = TrackD3PDObject(_label='trkpt5',
_prefix='trkpt5_',
_sgkey='HighPtTracks',
typeName='Rec::TrackParticleContainer',
flags=highPtFlags)
alg += HighPtTrackParticleD3PDObject(**_args ( 3, 'Tracks2', kw,
sgkey = 'HighPtTracks',
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_'))
# 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))
# Truth
if rec.doTruth():
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))
alg += JetD3PDObject (**_args ( 1, 'AK6TruthJet', kw,
sgkey='AntiKt6TruthJets', prefix='jet_AntiKt6Truth_',
allowMissing = True))
alg += JetD3PDObject (**_args ( 1, 'AK4TruthJetALL', kw,
sgkey='AntiKt4TruthJets_ALL', prefix='jet_AntiKt4TruthALL_',
allowMissing = True))
alg += JetD3PDObject (**_args ( 1, 'AK6TruthJetALL', kw,
sgkey='AntiKt6TruthJets_ALL', prefix='jet_AntiKt6TruthALL_',
allowMissing = True))
alg += JetD3PDObject (**_args ( 1, 'AK4TruthJetWZ', kw,
sgkey='AntiKt4TruthJets_WZ', prefix='jet_AntiKt4TruthWZ_',
allowMissing = True))
alg += JetD3PDObject (**_args ( 1, 'AK6TruthJetWZ', kw,
sgkey='AntiKt6TruthJets_WZ', prefix='jet_AntiKt6TruthWZ_',
allowMissing = True))
if not rec.doTruth():
alg += BeamSpotD3PDObject(10)
from TrigMissingETD3PDMaker.TrigMETD3PD import TrigMETD3PDObjects
TrigMETD3PDObjects(alg,10)
# Trigger
if D3PDMakerFlags.DoTrigger():
alg += SMWZTriggerBitsD3PDObject (**_args (10, 'SMWZTriggerBits', kw))
# Trigger Decision + metadata
alg += TrigDecisionD3PDObject (**_args(10, 'TrigDecision', kw))
addTrigConfMetadata(alg)
# Bunch group info
alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw))
# Egamma and Mu
TrigEgammaD3PDObjects (alg, 1)
TrigMuonD3PDObjects( alg, 1)
# Esum
#alg += EnergySumROID3PDObject(**_args (2, 'EnergySumROI', kw,
# prefix = "trig_L1_esum_"))
# 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" ))
# Event metadata
alg.MetadataTools += [LBMetadataConfig()]
# Invoke routine to write GSCFactor and WidthFraction jet moments
#addSTRUCTCalib('AntiKt4LCTopoJets', input='Topo', mainParam=0.4)
#addSTRUCTCalib('AntiKt6LCTopoJets', input='Topo', mainParam=0.6)
#addSTRUCTCalib('AntiKt4TopoEMJets', input='Topo', mainParam=0.4)
#addSTRUCTCalib('AntiKt6TopoEMJets', input='Topo', mainParam=0.6)
if D3PDMakerFlags.FilterCollCand():
from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter')
return alg
outList = CfgItemList( 'HIPsStream',
items = ['EventInfo#*',
'EventInfo#ByteStreamEventInfo',
'InDet::PixelClusterContainer#PixelClusters',
'InDet::SCT_ClusterContainer#SCT_Clusters',
'BCM_RDO_Container#BCM_CompactDOs',
'BCM_RDO_Container#BCM_RDOs',
'LUCID_RawDataContainer#Lucid_RawData',
'LArDigitContainer#LArDigitContainer_EMClust',
'LArDigitContainer#LArDigitContainer_Thinned',
'CaloCellContainer#AllCalo',
'CaloCellContainer#HLT_CaloCellContainer_TrigCaloCellLoF',
'CaloCellContainer#HLT_CaloCellContainer_TrigCaloCellMaker_eGamma',
'CaloCellContainer#HLT_CaloCellContainer_TrigCaloCellMaker_tau',
'CaloCellContainer#HLT_CaloCellContainer_TrigT2CaloEgammaCells',
'CaloCellContainer#HLT_CaloCellContainer_TrigT2CaloTauCells',
'CaloCellContainer#TauCommonPi0Cells',
'TileDigitsContainer#MuRcvDigitsCnt',
'TileDigitsContainer#TileDigitsFlt',
'TileRawChannelContainer#MuRcvRawChCnt',
'TileRawChannelContainer#TileRawChannelFlt',
'TileCellContainer#E4prContainer',
'TileCellContainer#MBTSContainer',
'TileL2Container#TileL2Cnt',
'TileMuContainer#TileMuObj',
'TileMuonReceiverContainer#TileMuRcvCnt',
'RpcPadContainer#RPCPAD',
'ROIB::RoIBResult#RoIBResult',
'CTP_RDO#CTP_RDO',
'MuCTPI_RDO#MUCTPI_RDO',
'xAOD::TrigMissingETContainer#HLT_xAOD__TrigMissingETContainer_EFJetEtSum',
'xAOD::TrigMissingETContainer#HLT_xAOD__TrigMissingETContainer_EFMissingET_Fex_2sidednoiseSupp_PUC',
'xAOD::TrigMissingETContainer#HLT_xAOD__TrigMissingETContainer_T2MissingET',
'xAOD::TrigMissingETContainer#HLT_xAOD__TrigMissingETContainer_TrigEFMissingET',
'xAOD::TrigMissingETContainer#HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_FEB',
'xAOD::TrigMissingETContainer#HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_mht',
'xAOD::TrigMissingETContainer#HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_topocl',
'xAOD::TrigMissingETContainer#HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_topocl_PS',
'xAOD::TrigMissingETContainer#HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_topocl_PUC',
'xAOD::TrigMissingETContainer#HLT_xAOD__TrigMissingETContainer_TrigL2MissingET_FEB',
'xAOD::TrigConfKeys#TrigConfKeys',
'xAOD::EventAuxInfo#EventInfoAux.',
'xAOD::TrigDecisionAuxInfo#xTrigDecisionAux.',
'xAOD::EventInfo#EventInfo',
'xAOD::EnergySumRoI#LVL1EnergySumRoI',
'RecoTimingObj#RAWtoESD_mems',
'RecoTimingObj#RAWtoESD_timings',
'xAOD::TrigNavigationAuxInfo#TrigNavigationAux.',
'xAOD::TrigDecision#xTrigDecision',
'xAOD::JetEtRoI#LVL1JetEtRoI',
'Trk::SegmentCollection#MuonSegments',
'Trk::SegmentCollection#NCB_MuonSegments',
'xAOD::MissingETAuxAssociationMap#METAssoc_AntiKt4EMPFlowAux.',
'xAOD::MissingETAuxAssociationMap#METAssoc_AntiKt4EMTopoAux.',
'xAOD::MissingETAuxAssociationMap#METAssoc_AntiKt4LCTopoAux.',
'HLT::HLTResult#HLTResult_HLT',
'LArNoisyROSummary#LArNoisyROSummary',
'TrackCollection#CombinedMuonTracks',
'TrackCollection#ExtrapolatedMuonTracks',
'TrackCollection#GSFTracks',
'TrackCollection#HLT_TrackCollection_InDetTrigTrackSlimmer_Bjet_EFID',
'TrackCollection#HLT_TrackCollection_InDetTrigTrackSlimmer_Bphysics_EFID',
'TrackCollection#HLT_TrackCollection_InDetTrigTrackSlimmer_CosmicsN_EFID',
'TrackCollection#HLT_TrackCollection_InDetTrigTrackSlimmer_Electron_EFID',
'TrackCollection#HLT_TrackCollection_InDetTrigTrackSlimmer_FullScan_EFID',
'TrackCollection#HLT_TrackCollection_InDetTrigTrackSlimmer_Muon_EFID',
'TrackCollection#HLT_TrackCollection_InDetTrigTrackSlimmer_Photon_EFID',
'TrackCollection#HLT_TrackCollection_InDetTrigTrackSlimmer_Tau_EFID',
'TrackCollection#MuonSpectrometerTracks',
'TrackCollection#DisappearingTracks',
'TrackCollection#ResolvedForwardTracks',
'TrackCollection#Tracks',
'xAOD::EventShapeAuxInfo#Kt4EMPFlowEventShapeAux.',
'xAOD::EventShapeAuxInfo#Kt4EMTopoEventShapeAux.',
'xAOD::EventShapeAuxInfo#Kt4LCTopoEventShapeAux.',
'xAOD::EventShapeAuxInfo#NeutralParticleFlowIsoCentralEventShapeAux.',
'xAOD::EventShapeAuxInfo#NeutralParticleFlowIsoForwardEventShapeAux.',
'xAOD::EventShapeAuxInfo#ParticleFlowIsoCentralEventShapeAux.',
'xAOD::EventShapeAuxInfo#ParticleFlowIsoForwardEventShapeAux.',
'xAOD::EventShapeAuxInfo#TopoClusterIsoCentralEventShapeAux.',
'xAOD::EventShapeAuxInfo#TopoClusterIsoForwardEventShapeAux.',
'InDet::PixelGangedClusterAmbiguities#PixelClusterAmbiguitiesMap',
'InDet::PixelGangedClusterAmbiguities#SplitClusterAmbiguityMap',
'xAOD::MissingETAssociationMap#METAssoc_AntiKt4EMPFlow',
'xAOD::MissingETAssociationMap#METAssoc_AntiKt4EMTopo',
'xAOD::MissingETAssociationMap#METAssoc_AntiKt4LCTopo',
'xAOD::TrigNavigation#TrigNavigation',
'LArFebErrorSummary#LArFebErrorSummary',
'ComTime#TRT_Phase',
'xAOD::EventShape#Kt4EMPFlowEventShape',
'xAOD::EventShape#Kt4EMTopoEventShape',
'xAOD::EventShape#Kt4LCTopoEventShape',
'xAOD::EventShape#NeutralParticleFlowIsoCentralEventShape',
'xAOD::EventShape#NeutralParticleFlowIsoForwardEventShape',
'xAOD::EventShape#ParticleFlowIsoCentralEventShape',
'xAOD::EventShape#ParticleFlowIsoForwardEventShape',
'xAOD::EventShape#TopoClusterIsoCentralEventShape',
'xAOD::EventShape#TopoClusterIsoForwardEventShape',
'RawInfoSummaryForTag#RawInfoSummaryForTag',
'xAOD::JetEtRoIAuxInfo#LVL1JetEtRoIAux.',
'xAOD::EnergySumRoIAuxInfo#LVL1EnergySumRoIAux.',
'Muon::CscPrepDataContainer#CSC_Clusters',
'CombinedMuonFeatureContainer#HLT_CombinedMuonFeatureContainer',
'xAOD::EmTauRoIContainer#HLT_xAOD__EmTauRoIContainer_L1TopoEM',
'xAOD::EmTauRoIContainer#HLT_xAOD__EmTauRoIContainer_L1TopoTau',
'xAOD::EmTauRoIContainer#LVL1EmTauRoIs',
'xAOD::BTagVertexAuxContainer#BTagging_AntiKt2TrackJFVtxAux.',
'xAOD::BTagVertexAuxContainer#BTagging_AntiKt3TrackJFVtxAux.',
'xAOD::BTagVertexAuxContainer#BTagging_AntiKt4EMTopoJFVtxAux.',
'xAOD::BTagVertexAuxContainer#BTagging_AntiKt4LCTopoJFVtxAux.',
'xAOD::BTagVertexAuxContainer#BTagging_AntiKt4TrackJFVtxAux.',
'xAOD::BTagVertexAuxContainer#HLT_xAOD__BTagVertexContainer_BjetVertexFexAux.',
'xAOD::TrigRingerRingsAuxContainer#HLT_xAOD__TrigRingerRingsContainer_TrigT2CaloEgammaAux.',
'xAOD::TriggerTowerAuxContainer#ZdcTriggerTowersAux.',
'xAOD::TriggerTowerAuxContainer#xAODTriggerTowersAux.',
'xAOD::TriggerTowerAuxContainer#xAODTriggerTowersMuonAux.',
'xAOD::ElectronContainer#Electrons',
'xAOD::ElectronContainer#ForwardElectrons',
'xAOD::ElectronContainer#HLT_xAOD__ElectronContainer_egamma_Electrons',
'xAOD::BTaggingTrigAuxContainer#HLT_xAOD__BTaggingContainer_HLTBjetFexAux.',
'xAOD::TrigSpacePointCountsAuxContainer#HLT_xAOD__TrigSpacePointCountsContainer_spacepointsAux.',
'TrigVertexCountsCollection#HLT_TrigVertexCountsCollection_vertexcounts',
'xAOD::TrigT2ZdcSignalsContainer#HLT_xAOD__TrigT2ZdcSignalsContainer_zdcsignals',
'xAOD::VertexContainer#BTagging_AntiKt2TrackSecVtx',
'xAOD::VertexContainer#BTagging_AntiKt3TrackSecVtx',
'xAOD::VertexContainer#BTagging_AntiKt4EMTopoSecVtx',
'xAOD::VertexContainer#BTagging_AntiKt4LCTopoSecVtx',
'xAOD::VertexContainer#BTagging_AntiKt4TrackSecVtx',
'xAOD::VertexContainer#GSFConversionVertices',
'xAOD::VertexContainer#HLT_xAOD__VertexContainer_BjetSecondaryVertexFex',
'xAOD::VertexContainer#HLT_xAOD__VertexContainer_EFHistoPrmVtx',
'xAOD::VertexContainer#HLT_xAOD__VertexContainer_PrimVertexFTK',
'xAOD::VertexContainer#HLT_xAOD__VertexContainer_PrimVertexFTKRaw',
'xAOD::VertexContainer#HLT_xAOD__VertexContainer_PrimVertexFTKRefit',
'xAOD::VertexContainer#HLT_xAOD__VertexContainer_SecondaryVertex',
'xAOD::VertexContainer#HLT_xAOD__VertexContainer_xPrimVx',
'xAOD::VertexContainer#MSDisplacedVertex',
'xAOD::VertexContainer#PrimaryVertices',
'xAOD::VertexContainer#TauSecondaryVertices',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_EFBMuMuFexAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_EFBMuMuXFexAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_EFBMuMuXFex_XAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_EFDsPhiPiFexAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_EFMuPairsAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_EFMultiMuFexAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_EFTrackMassAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_L2BMuMuFexAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_L2BMuMuXFexAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_L2DiMuXFexAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_L2DsPhiPiFexDsAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_L2DsPhiPiFexPhiAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_L2JpsieeFexAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_L2MultiMuFexAux.',
'xAOD::TrigBphysAuxContainer#HLT_xAOD__TrigBphysContainer_L2TrackMassAux.',
'xAOD::CPMTowerAuxContainer#CPMTowersAux.',
'xAOD::CPMTowerAuxContainer#CPMTowersOverlapAux.',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_SplitJet',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_SuperRoi',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_TrigJetRec',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_TrigT2CaloJet',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_TrigT2CosmicJet',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_forID',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_forID1',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_forID2',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_forID3',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_forMS',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_initialRoI',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_secondaryRoI_EF',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_secondaryRoI_HLT',
'TrigRoiDescriptorCollection#HLT_TrigRoiDescriptorCollection_secondaryRoI_L2',
'xAOD::CMXRoIContainer#CMXRoIs',
'xAOD::CMXCPTobAuxContainer#CMXCPTobsAux.',
'xAOD::MissingETContainer#MET_Calo',
'xAOD::MissingETContainer#MET_Core_AntiKt4EMPFlow',
'xAOD::MissingETContainer#MET_Core_AntiKt4EMTopo',
'xAOD::MissingETContainer#MET_Core_AntiKt4LCTopo',
'xAOD::MissingETContainer#MET_EMTopo',
'xAOD::MissingETContainer#MET_EMTopoRegions',
'xAOD::MissingETContainer#MET_LocHadTopo',
'xAOD::MissingETContainer#MET_LocHadTopoRegions',
'xAOD::MissingETContainer#MET_Reference_AntiKt4EMPFlow',
'xAOD::MissingETContainer#MET_Reference_AntiKt4EMTopo',
'xAOD::MissingETContainer#MET_Reference_AntiKt4LCTopo',
'xAOD::MissingETContainer#MET_Track',
'xAOD::L2IsoMuonContainer#HLT_xAOD__L2IsoMuonContainer_MuonL2ISInfo',
'xAOD::PhotonContainer#HLT_xAOD__PhotonContainer_egamma_Photons',
'xAOD::PhotonContainer#Photons',
'xAOD::TrigRNNOutputContainer#HLT_xAOD__TrigRNNOutputContainer_TrigRingerNeuralFex',
'xAOD::TrigRNNOutputContainer#HLT_xAOD__TrigRNNOutputContainer_TrigTRTHTCounts',
'xAOD::TrackParticleClusterAssociationAuxContainer#InDetTrackParticlesClusterAssociationsAux.',
'xAOD::RODHeaderAuxContainer#RODHeadersAux.',
'xAOD::ZdcModuleContainer#ZdcModules',
'xAOD::TrigEMClusterAuxContainer#HLT_xAOD__TrigEMClusterContainer_TrigT2CaloEgammaAux.',
'xAOD::ElectronAuxContainer#ElectronsAux.',
'xAOD::ElectronAuxContainer#ForwardElectronsAux.',
'TrigTrackCountsCollection#HLT_TrigTrackCountsCollection_trackcounts',
'xAOD::TrigPassBitsContainer#HLT_xAOD__TrigPassBitsContainer_passbits',
'xAOD::TrigElectronContainer#HLT_xAOD__TrigElectronContainer_L2ElectronFex',
'xAOD::TrigElectronContainer#HLT_xAOD__TrigElectronContainer_L2IDCaloFex',
'TRT_BSIdErrContainer#TRT_ByteStreamIdErrs',
'xAOD::TrigT2MbtsBitsContainer#HLT_xAOD__TrigT2MbtsBitsContainer_T2Mbts',
'TrigSpacePointCountsCollection#HLT_TrigSpacePointCountsCollection_spacepoints',
'xAOD::TrigVertexCountsContainer#HLT_xAOD__TrigVertexCountsContainer_vertexcounts',
'xAOD::L2IsoMuonAuxContainer#HLT_xAOD__L2IsoMuonContainer_MuonL2ISInfoAux.',
'InDet::TRT_DriftCircleContainer#TRT_DriftCircles',
'xAOD::MuonSegmentContainer#MuonSegments',
'xAOD::MuonSegmentContainer#NCB_MuonSegments',
'xAOD::JetRoIContainer#HLT_xAOD__JetRoIContainer_L1TopoJet',
'xAOD::JetRoIContainer#LVL1JetRoIs',
'xAOD::JetElementAuxContainer#JetElementsAux.',
'xAOD::JetElementAuxContainer#JetElementsOverlapAux.',
'CaloClusterCellLinkContainer#CaloCalTopoClusters_links',
'CaloClusterCellLinkContainer#InDetTrackParticlesAssociatedClusters_links',
'CaloClusterCellLinkContainer#LArClusterEM7_11Nocorr_links',
'CaloClusterCellLinkContainer#LArClusterEM_links',
'CaloClusterCellLinkContainer#MuonClusterCollection_links',
'CaloClusterCellLinkContainer#egammaClusters_links',
'CaloClusterCellLinkContainer#egammaTopoSeededClusters_links',
'xAOD::TrigPhotonContainer#HLT_xAOD__TrigPhotonContainer_L2PhotonFex',
'xAOD::CMXCPHitsAuxContainer#CMXCPHitsAux.',
'TrigEFBjetContainer#HLT_TrigEFBjetContainer_EFBjetFex',
'xAOD::SlowMuonContainer#SlowMuons',
'xAOD::CMXJetHitsAuxContainer#CMXJetHitsAux.',
'xAOD::RODHeaderContainer#RODHeaders',
'xAOD::MuonAuxContainer#HLT_xAOD__MuonContainer_MuTagIMO_EFAux.',
'xAOD::MuonAuxContainer#HLT_xAOD__MuonContainer_MuonEFInfoAux.',
'xAOD::MuonAuxContainer#HLT_xAOD__MuonContainer_MuonEFInfo_FullScanAux.',
'xAOD::MuonAuxContainer#HLT_xAOD__MuonContainer_MuonEFInfo_MSonlyTrackParticles_FullScanAux.',
'xAOD::MuonAuxContainer#HLT_xAOD__MuonContainer_eMuonEFInfoAux.',
'xAOD::MuonAuxContainer#MuonsAux.',
'xAOD::MuonAuxContainer#StausAux.',
'Muon::MdtPrepDataContainer#MDT_DriftCircles',
'xAOD::HIEventShapeContainer#HLT_xAOD__HIEventShapeContainer_HIUE',
'xAOD::BTagVertexContainer#BTagging_AntiKt2TrackJFVtx',
'xAOD::BTagVertexContainer#BTagging_AntiKt3TrackJFVtx',
'xAOD::BTagVertexContainer#BTagging_AntiKt4EMTopoJFVtx',
'xAOD::BTagVertexContainer#BTagging_AntiKt4LCTopoJFVtx',
'xAOD::BTagVertexContainer#BTagging_AntiKt4TrackJFVtx',
'xAOD::BTagVertexContainer#HLT_xAOD__BTagVertexContainer_BjetVertexFex',
'xAOD::CaloClusterTrigAuxContainer#HLT_xAOD__CaloClusterContainer_TrigCaloClusterMakerAux.',
'xAOD::CaloClusterTrigAuxContainer#HLT_xAOD__CaloClusterContainer_TrigCaloClusterMaker_slwAux.',
'xAOD::CaloClusterTrigAuxContainer#HLT_xAOD__CaloClusterContainer_TrigCaloClusterMaker_topoAux.',
'xAOD::CaloClusterTrigAuxContainer#HLT_xAOD__CaloClusterContainer_TrigEFCaloCalibFexAux.',
'xAOD::SlowMuonAuxContainer#SlowMuonsAux.',
'xAOD::HIEventShapeAuxContainer#HLT_xAOD__HIEventShapeContainer_HIUEAux.',
'TrigMuonEFInfoContainer#HLT_TrigMuonEFInfoContainer_MuTagIMO_EF',
'TrigMuonEFInfoContainer#HLT_TrigMuonEFInfoContainer_MuonEFInfo',
'TrigMuonEFInfoContainer#HLT_TrigMuonEFInfoContainer_eMuonEFInfo',
'xAOD::TriggerTowerContainer#ZdcTriggerTowers',
'xAOD::TriggerTowerContainer#xAODTriggerTowers',
'xAOD::TriggerTowerContainer#xAODTriggerTowersMuon',
'TrigMuonEFIsolationContainer#HLT_TrigMuonEFIsolationContainer_MuonEFIsolation',
'xAOD::TrigCompositeAuxContainer#HLT_xAOD__TrigCompositeContainer_L1TopoCompositeAux.',
'xAOD::TrigCompositeAuxContainer#HLT_xAOD__TrigCompositeContainer_L1TopoMETAux.',
'xAOD::TrigCompositeAuxContainer#HLT_xAOD__TrigCompositeContainer_MuonRoIClusterAux.',
'xAOD::CMXJetTobAuxContainer#CMXJetTobsAux.',
'xAOD::ZdcModuleAuxContainer#ZdcModulesAux.',
'xAOD::TauJetContainer#HLT_xAOD__TauJetContainer_TrigTauRecMerged',
'xAOD::TauJetContainer#HLT_xAOD__TauJetContainer_TrigTauRecPreselection',
'xAOD::TauJetContainer#TauJets',
'xAOD::PFOContainer#JetETMissChargedParticleFlowObjects',
'xAOD::PFOContainer#JetETMissNeutralParticleFlowObjects',
'xAOD::PFOContainer#TauChargedParticleFlowObjects',
'xAOD::PFOContainer#TauHadronicParticleFlowObjects',
'xAOD::PFOContainer#TauNeutralParticleFlowObjects',
'xAOD::PFOContainer#TauShotParticleFlowObjects',
'xAOD::MuonContainer#HLT_xAOD__MuonContainer_MuTagIMO_EF',
'xAOD::MuonContainer#HLT_xAOD__MuonContainer_MuonEFInfo',
'xAOD::MuonContainer#HLT_xAOD__MuonContainer_MuonEFInfo_FullScan',
'xAOD::MuonContainer#HLT_xAOD__MuonContainer_MuonEFInfo_MSonlyTrackParticles_FullScan',
'xAOD::MuonContainer#HLT_xAOD__MuonContainer_eMuonEFInfo',
'xAOD::MuonContainer#Muons',
'xAOD::MuonContainer#Staus',
'xAOD::CMXEtSumsContainer#CMXEtSums',
'xAOD::TrigElectronAuxContainer#HLT_xAOD__TrigElectronContainer_L2ElectronFexAux.',
'xAOD::TrigElectronAuxContainer#HLT_xAOD__TrigElectronContainer_L2IDCaloFexAux.',
'TrigT2MbtsBitsContainer#HLT_TrigT2MbtsBitsContainer_T2Mbts',
'xAOD::L1TopoRawDataContainer#L1TopoRawData',
'xAOD::CPMTobRoIAuxContainer#CPMTobRoIsAux.',
'xAOD::CPMTobRoIAuxContainer#CPMTobRoIsRoIBAux.',
'Muon::TgcCoinDataContainer#TrigT1CoinDataCollection',
'Muon::TgcCoinDataContainer#TrigT1CoinDataCollectionNextBC',
'Muon::TgcCoinDataContainer#TrigT1CoinDataCollectionPriorBC',
'Muon::RpcCoinDataContainer#RPC_triggerHits',
'IsoMuonFeatureContainer#HLT_IsoMuonFeatureContainer',
'xAOD::CMXEtSumsAuxContainer#CMXEtSumsAux.',
'MuonFeatureContainer#HLT_MuonFeatureContainer',
'xAOD::L2CombinedMuonContainer#HLT_xAOD__L2CombinedMuonContainer_MuonL2CBInfo',
'xAOD::L2CombinedMuonAuxContainer#HLT_xAOD__L2CombinedMuonContainer_MuonL2CBInfoAux.',
'xAOD::JEMTobRoIContainer#JEMTobRoIs',
'xAOD::JEMTobRoIContainer#JEMTobRoIsRoIB',
'xAOD::L2StandAloneMuonAuxContainer#HLT_xAOD__L2StandAloneMuonContainer_MuonL2SAInfoAux.',
'xAOD::TrigSpacePointCountsContainer#HLT_xAOD__TrigSpacePointCountsContainer_spacepoints',
'xAOD::TrackParticleAuxContainer#CombinedMuonTrackParticlesAux.-caloExtension.-cellAssociation.-clusterAssociation',
'xAOD::TrackParticleAuxContainer#CombinedStauTrackParticlesAux.-caloExtension.-cellAssociation.-clusterAssociation',
'xAOD::TrackParticleAuxContainer#ExtrapolatedMuonTrackParticlesAux.-caloExtension.-cellAssociation.-clusterAssociation',
'xAOD::TrackParticleAuxContainer#ExtrapolatedStauTrackParticlesAux.-caloExtension.-cellAssociation.-clusterAssociation',
'xAOD::TrackParticleAuxContainer#GSFTrackParticlesAux.-caloExtension.-cellAssociation.-clusterAssociation',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnvIOTRT_CosmicsN_EFIDAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_BjetPrmVtx_FTFAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_EFIDAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_FTFAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_FTKAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_FTKRefitAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_FTKRefit_IDTrigAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_FTK_IDTrigAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_IDTrigAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bphysics_EFIDAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bphysics_FTFAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bphysics_IDTrigAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_CosmicsN_EFIDAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Electron_EFIDAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Electron_FTFAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Electron_IDTrigAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Electron_L2IDAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_FullScan_EFIDAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_MuonIso_EFIDAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_EFIDAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_FTFAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_FTKAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_FTKRefitAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_FTKRefit_IDTrigAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_FTK_IDTrigAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_IDTrigAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Photon_EFIDAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_TauCore_FTFAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_TauIso_FTFAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_EFIDAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_FTFAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_FTKAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_FTKRefitAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_FTKRefit_IDTrigAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_FTK_IDTrigAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_IDTrigAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_minBias_EFIDAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_MuTagIMO_EF_CombTrackParticlesAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_MuTagIMO_EF_ExtrapTrackParticlesAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_MuonEFInfo_CombTrackParticlesAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_MuonEFInfo_CombTrackParticles_FullScanAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_MuonEFInfo_ExtrapTrackParticlesAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_MuonEFInfo_ExtrapTrackParticles_FullScanAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_eMuonEFInfo_CombTrackParticlesAux.',
'xAOD::TrackParticleAuxContainer#HLT_xAOD__TrackParticleContainer_eMuonEFInfo_ExtrapTrackParticlesAux.',
'xAOD::TrackParticleAuxContainer#InDetForwardTrackParticlesAux.-caloExtension.-cellAssociation.-clusterAssociation.-trackParameterCovarianceMatrices.-parameterX.-parameterY.-parameterZ.-parameterPX.-parameterPY.-parameterPZ.-parameterPosition',
'xAOD::TrackParticleAuxContainer#InDetDisappearingTrackParticlesAux.',
'xAOD::TrackParticleAuxContainer#InDetTrackParticlesAux.-caloExtension.-cellAssociation.-clusterAssociation.-trackParameterCovarianceMatrices.-parameterX.-parameterY.-parameterZ.-parameterPX.-parameterPY.-parameterPZ.-parameterPosition',
'xAOD::TrackParticleAuxContainer#MSonlyTrackletsAux.-caloExtension.-cellAssociation.-clusterAssociation',
'xAOD::TrackParticleAuxContainer#MuonSpectrometerTrackParticlesAux.-caloExtension.-cellAssociation.-clusterAssociation',
'TrigPassFlagsCollection#HLT_TrigPassFlagsCollection_isEM',
'TrigPassFlagsCollection#HLT_TrigPassFlagsCollection_passflags',
'TrigEMClusterContainer#HLT_TrigEMClusterContainer_TrigT2CaloCosmic',
'xAOD::CaloClusterContainer#CaloCalTopoClusters',
'xAOD::CaloClusterContainer#ForwardElectronClusters',
'xAOD::CaloClusterContainer#HLT_xAOD__CaloClusterContainer_TrigCaloClusterMaker',
'xAOD::CaloClusterContainer#HLT_xAOD__CaloClusterContainer_TrigCaloClusterMaker_slw',
'xAOD::CaloClusterContainer#HLT_xAOD__CaloClusterContainer_TrigCaloClusterMaker_topo',
'xAOD::CaloClusterContainer#HLT_xAOD__CaloClusterContainer_TrigEFCaloCalibFex',
'xAOD::CaloClusterContainer#InDetTrackParticlesAssociatedClusters',
'xAOD::CaloClusterContainer#LArClusterEM',
'xAOD::CaloClusterContainer#LArClusterEM7_11Nocorr',
'xAOD::CaloClusterContainer#MuonClusterCollection',
'xAOD::CaloClusterContainer#TauPi0Clusters',
'xAOD::CaloClusterContainer#egammaClusters',
'xAOD::CaloClusterContainer#egammaTopoSeededClusters',
'xAOD::PFOAuxContainer#JetETMissChargedParticleFlowObjectsAux.',
'xAOD::PFOAuxContainer#JetETMissNeutralParticleFlowObjectsAux.',
'xAOD::PFOAuxContainer#TauChargedParticleFlowObjectsAux.',
'xAOD::PFOAuxContainer#TauHadronicParticleFlowObjectsAux.',
'xAOD::PFOAuxContainer#TauNeutralParticleFlowObjectsAux.',
'xAOD::PFOAuxContainer#TauShotParticleFlowObjectsAux.',
'MuonFeatureDetailsContainer#HLT_MuonFeatureDetailsContainer',
'xAOD::CMXRoIAuxContainer#CMXRoIsAux.',
'xAOD::MissingETAuxContainer#MET_CaloAux.',
'xAOD::MissingETAuxContainer#MET_Core_AntiKt4EMPFlowAux.',
'xAOD::MissingETAuxContainer#MET_Core_AntiKt4EMTopoAux.',
'xAOD::MissingETAuxContainer#MET_Core_AntiKt4LCTopoAux.',
'xAOD::MissingETAuxContainer#MET_EMTopoAux.',
'xAOD::MissingETAuxContainer#MET_EMTopoRegionsAux.',
'xAOD::MissingETAuxContainer#MET_LocHadTopoAux.',
'xAOD::MissingETAuxContainer#MET_LocHadTopoRegionsAux.',
'xAOD::MissingETAuxContainer#MET_Reference_AntiKt4EMPFlowAux.',
'xAOD::MissingETAuxContainer#MET_Reference_AntiKt4EMTopoAux.',
'xAOD::MissingETAuxContainer#MET_Reference_AntiKt4LCTopoAux.',
'xAOD::MissingETAuxContainer#MET_TrackAux.',
'xAOD::CMXJetTobContainer#CMXJetTobs',
'xAOD::TrigPassBitsAuxContainer#HLT_xAOD__TrigPassBitsContainer_passbitsAux.',
'xAOD::JEMEtSumsContainer#JEMEtSums',
'xAOD::CPMTobRoIContainer#CPMTobRoIs',
'xAOD::CPMTobRoIContainer#CPMTobRoIsRoIB',
'Muon::CscStripPrepDataContainer#CSC_Measurements',
'xAOD::BTaggingAuxContainer#BTagging_AntiKt2TrackAux.',
'xAOD::BTaggingAuxContainer#BTagging_AntiKt3TrackAux.',
'xAOD::BTaggingAuxContainer#BTagging_AntiKt4EMTopoAux.',
'xAOD::BTaggingAuxContainer#BTagging_AntiKt4LCTopoAux.',
'xAOD::BTaggingAuxContainer#BTagging_AntiKt4TrackAux.',
'xAOD::JetContainer#AntiKt10LCTopoJets',
'xAOD::JetContainer#AntiKt2PV0TrackJets',
'xAOD::JetContainer#AntiKt3PV0TrackJets',
'xAOD::JetContainer#AntiKt4EMPFlowJets',
'xAOD::JetContainer#AntiKt4EMTopoJets',
'xAOD::JetContainer#AntiKt4LCTopoJets',
'xAOD::JetContainer#AntiKt4PV0TrackJets',
'xAOD::JetContainer#CamKt12LCTopoJets',
'xAOD::JetContainer#HLT_xAOD__JetContainer_EFJet',
'xAOD::JetContainer#HLT_xAOD__JetContainer_FarawayJet',
'xAOD::JetContainer#HLT_xAOD__JetContainer_SplitJet',
'xAOD::JetContainer#HLT_xAOD__JetContainer_SuperRoi',
'xAOD::JetContainer#HLT_xAOD__JetContainer_TrigHLTJetDSSelectorCollection',
'xAOD::JetContainer#HLT_xAOD__JetContainer_TrigTauJet',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10TTemnojcalibFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10TThadnojcalibFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10r_tcemsubjesFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10tcemjesFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10tcemjesPS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10tcemnojcalibFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10tcemnojcalibPS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10tcemsubFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10tcemsubjesFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10tclcwjesFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10tclcwjesPS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10tclcwnojcalibFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10tclcwnojcalibPS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10tclcwsubFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a10tclcwsubjesFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a3ionemsubjesFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4TTemnojcalibFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4TThadnojcalibFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4ionemsubjesFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4tcemjesFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4tcemjesPS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4tcemnojcalibFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4tcemnojcalibPS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4tcemsubFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4tcemsubjesFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4tclcwjesFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4tclcwjesPS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4tclcwnojcalibFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4tclcwnojcalibPS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4tclcwsubFS',
'xAOD::JetContainer#HLT_xAOD__JetContainer_a4tclcwsubjesFS',
'xAOD::TrackParticleClusterAssociationContainer#InDetTrackParticlesClusterAssociations',
'xAOD::CMXCPTobContainer#CMXCPTobs',
'xAOD::PhotonAuxContainer#PhotonsAux.',
'xAOD::EmTauRoIAuxContainer#HLT_xAOD__EmTauRoIContainer_L1TopoEMAux.',
'xAOD::EmTauRoIAuxContainer#HLT_xAOD__EmTauRoIContainer_L1TopoTauAux.',
'xAOD::EmTauRoIAuxContainer#LVL1EmTauRoIsAux.',
'xAOD::TrigTrackCountsAuxContainer#HLT_xAOD__TrigTrackCountsContainer_trackcountsAux.',
'Muon::RpcPrepDataContainer#RPC_Measurements',
'xAOD::TrigT2MbtsBitsAuxContainer#HLT_xAOD__TrigT2MbtsBitsContainer_T2MbtsAux.',
'xAOD::JetElementContainer#JetElements',
'xAOD::JetElementContainer#JetElementsOverlap',
'xAOD::BTaggingContainer#BTagging_AntiKt2Track',
'xAOD::BTaggingContainer#BTagging_AntiKt3Track',
'xAOD::BTaggingContainer#BTagging_AntiKt4EMTopo',
'xAOD::BTaggingContainer#BTagging_AntiKt4LCTopo',
'xAOD::BTaggingContainer#BTagging_AntiKt4Track',
'xAOD::BTaggingContainer#HLT_xAOD__BTaggingContainer_HLTBjetFex',
'xAOD::TrigEMClusterContainer#HLT_xAOD__TrigEMClusterContainer_TrigT2CaloEgamma',
'xAOD::CPMTowerContainer#CPMTowers',
'xAOD::CPMTowerContainer#CPMTowersOverlap',
'xAOD::TrigRNNOutputAuxContainer#HLT_xAOD__TrigRNNOutputContainer_TrigRingerNeuralFexAux.',
'xAOD::TrigRNNOutputAuxContainer#HLT_xAOD__TrigRNNOutputContainer_TrigTRTHTCountsAux.',
'xAOD::PhotonTrigAuxContainer#HLT_xAOD__PhotonContainer_egamma_PhotonsAux.',
'TrigMissingETContainer#HLT_TrigMissingETContainer_EFJetEtSum',
'TrigMissingETContainer#HLT_TrigMissingETContainer_L2JetEtSum',
'TrigMissingETContainer#HLT_TrigMissingETContainer_L2MissingET_FEB',
'TrigMissingETContainer#HLT_TrigMissingETContainer_T2MissingET',
'TrigMissingETContainer#HLT_TrigMissingETContainer_TrigEFMissingET',
'TrigMissingETContainer#HLT_TrigMissingETContainer_TrigEFMissingET_FEB',
'TrigMissingETContainer#HLT_TrigMissingETContainer_TrigEFMissingET_topocl',
'TrigMissingETContainer#HLT_TrigMissingETContainer_TrigEFMissingET_topocl_PS',
'TrigMuonClusterFeatureContainer#HLT_TrigMuonClusterFeatureContainer_MuonCluster',
'xAOD::CMXJetHitsContainer#CMXJetHits',
'xAOD::DiTauJetContainer#DiTauJets',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_EFJetAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_FarawayJetAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_SplitJetAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_SuperRoiAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_TrigHLTJetDSSelectorCollectionAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_TrigTauJetAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10TTemnojcalibFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10TThadnojcalibFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10r_tcemsubjesFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10tcemjesFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10tcemjesPSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10tcemnojcalibFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10tcemnojcalibPSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10tcemsubFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10tcemsubjesFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10tclcwjesFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10tclcwjesPSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10tclcwnojcalibFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10tclcwnojcalibPSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10tclcwsubFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a10tclcwsubjesFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a3ionemsubjesFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4TTemnojcalibFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4TThadnojcalibFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4ionemsubjesFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4tcemjesFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4tcemjesPSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4tcemnojcalibFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4tcemnojcalibPSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4tcemsubFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4tcemsubjesFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4tclcwjesFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4tclcwjesPSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4tclcwnojcalibFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4tclcwnojcalibPSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4tclcwsubFSAux.',
'xAOD::JetTrigAuxContainer#HLT_xAOD__JetContainer_a4tclcwsubjesFSAux.',
'xAOD::TrackParticleContainer#CombinedMuonTrackParticles',
'xAOD::TrackParticleContainer#CombinedStauTrackParticles',
'xAOD::TrackParticleContainer#ExtrapolatedMuonTrackParticles',
'xAOD::TrackParticleContainer#ExtrapolatedStauTrackParticles',
'xAOD::TrackParticleContainer#GSFTrackParticles',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnvIOTRT_CosmicsN_EFID',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_BjetPrmVtx_FTF',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_EFID',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_FTF',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_FTK',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_FTKRefit',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_FTKRefit_IDTrig',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_FTK_IDTrig',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_IDTrig',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bphysics_EFID',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bphysics_FTF',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bphysics_IDTrig',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_CosmicsN_EFID',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Electron_EFID',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Electron_FTF',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Electron_IDTrig',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Electron_L2ID',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_FullScan_EFID',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_MuonIso_EFID',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_EFID',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_FTF',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_FTK',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_FTKRefit',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_FTKRefit_IDTrig',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_FTK_IDTrig',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_IDTrig',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Photon_EFID',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_TauCore_FTF',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_TauIso_FTF',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_EFID',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_FTF',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_FTK',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_FTKRefit',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_FTKRefit_IDTrig',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_FTK_IDTrig',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_IDTrig',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_minBias_EFID',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_MuTagIMO_EF_CombTrackParticles',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_MuTagIMO_EF_ExtrapTrackParticles',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_MuonEFInfo_CombTrackParticles',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_MuonEFInfo_CombTrackParticles_FullScan',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_MuonEFInfo_ExtrapTrackParticles',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_MuonEFInfo_ExtrapTrackParticles_FullScan',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_eMuonEFInfo_CombTrackParticles',
'xAOD::TrackParticleContainer#HLT_xAOD__TrackParticleContainer_eMuonEFInfo_ExtrapTrackParticles',
'xAOD::TrackParticleContainer#InDetForwardTrackParticles',
'xAOD::TrackParticleContainer#InDetDisappearingTrackParticles',
'xAOD::TrackParticleContainer#InDetTrackParticles',
'xAOD::TrackParticleContainer#MSonlyTracklets',
'xAOD::TrackParticleContainer#MuonSpectrometerTrackParticles',
'xAOD::JetRoIAuxContainer#HLT_xAOD__JetRoIContainer_L1TopoJetAux.',
'xAOD::JetRoIAuxContainer#LVL1JetRoIsAux.',
'xAOD::TrigMissingETAuxContainer#HLT_xAOD__TrigMissingETContainer_EFJetEtSumAux.',
'xAOD::TrigMissingETAuxContainer#HLT_xAOD__TrigMissingETContainer_EFMissingET_Fex_2sidednoiseSupp_PUCAux.',
'xAOD::TrigMissingETAuxContainer#HLT_xAOD__TrigMissingETContainer_T2MissingETAux.',
'xAOD::TrigMissingETAuxContainer#HLT_xAOD__TrigMissingETContainer_TrigEFMissingETAux.',
'xAOD::TrigMissingETAuxContainer#HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_FEBAux.',
'xAOD::TrigMissingETAuxContainer#HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_mhtAux.',
'xAOD::TrigMissingETAuxContainer#HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_topoclAux.',
'xAOD::TrigMissingETAuxContainer#HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_topocl_PSAux.',
'xAOD::TrigMissingETAuxContainer#HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_topocl_PUCAux.',
'xAOD::TrigMissingETAuxContainer#HLT_xAOD__TrigMissingETContainer_TrigL2MissingET_FEBAux.',
'xAOD::MuonRoIAuxContainer#HLT_xAOD__MuonRoIContainer_L1TopoMuonAux.',
'xAOD::MuonRoIAuxContainer#LVL1MuonRoIsAux.',
'TileTrackMuFeatureContainer#HLT_TileTrackMuFeatureContainer',
'xAOD::JetAuxContainer#AntiKt10LCTopoJetsAux.',
'xAOD::JetAuxContainer#AntiKt2PV0TrackJetsAux.',
'xAOD::JetAuxContainer#AntiKt3PV0TrackJetsAux.',
'xAOD::JetAuxContainer#AntiKt4EMPFlowJetsAux.',
'xAOD::JetAuxContainer#AntiKt4EMTopoJetsAux.',
'xAOD::JetAuxContainer#AntiKt4LCTopoJetsAux.',
'xAOD::JetAuxContainer#AntiKt4PV0TrackJetsAux.',
'xAOD::JetAuxContainer#CamKt12LCTopoJetsAux.',
'TileMuFeatureContainer#HLT_TileMuFeatureContainer',
'RpcSectorLogicContainer#RPC_SECTORLOGIC',
'TrigVertexCollection#HLT_TrigVertexCollection_TrigBeamSpotVertex',
'TrigVertexCollection#HLT_TrigVertexCollection_TrigL2SiTrackFinder_FullScan_ZF_Only',
'TrigInDetTrackCollection#HLT_TrigInDetTrackCollection',
'xAOD::TrigRingerRingsContainer#HLT_xAOD__TrigRingerRingsContainer_TrigT2CaloEgamma',
'xAOD::CaloClusterAuxContainer#CaloCalTopoClustersAux.',
'xAOD::CaloClusterAuxContainer#ForwardElectronClustersAux.',
'xAOD::CaloClusterAuxContainer#InDetTrackParticlesAssociatedClustersAux.',
'xAOD::CaloClusterAuxContainer#LArClusterEM7_11NocorrAux.',
'xAOD::CaloClusterAuxContainer#LArClusterEMAux.',
'xAOD::CaloClusterAuxContainer#MuonClusterCollectionAux.',
'xAOD::CaloClusterAuxContainer#TauPi0ClustersAux.',
'xAOD::CaloClusterAuxContainer#egammaClustersAux.',
'xAOD::CaloClusterAuxContainer#egammaTopoSeededClustersAux.',
'xAOD::CMXCPHitsContainer#CMXCPHits',
'xAOD::TrigT2ZdcSignalsAuxContainer#HLT_xAOD__TrigT2ZdcSignalsContainer_zdcsignalsAux.',
'xAOD::DiTauJetAuxContainer#DiTauJetsAux.',
'xAOD::JEMTobRoIAuxContainer#JEMTobRoIsAux.',
'xAOD::JEMTobRoIAuxContainer#JEMTobRoIsRoIBAux.',
'xAOD::L2StandAloneMuonContainer#HLT_xAOD__L2StandAloneMuonContainer_MuonL2SAInfo',
'xAOD::TauJetAuxContainer#HLT_xAOD__TauJetContainer_TrigTauRecMergedAux.',
'xAOD::TauJetAuxContainer#HLT_xAOD__TauJetContainer_TrigTauRecPreselectionAux.',
'xAOD::TauJetAuxContainer#TauJetsAux.',
'TrigPassBitsCollection#HLT_TrigPassBitsCollection_passbits',
'xAOD::MuonRoIContainer#HLT_xAOD__MuonRoIContainer_L1TopoMuon',
'xAOD::MuonRoIContainer#LVL1MuonRoIs',
'xAOD::JEMEtSumsAuxContainer#JEMEtSumsAux.',
'xAOD::TrigPhotonAuxContainer#HLT_xAOD__TrigPhotonContainer_L2PhotonFexAux.',
'InDetBSErrContainer#PixelByteStreamErrs',
'InDetBSErrContainer#SCT_ByteStreamErrs',
'xAOD::TrigVertexCountsAuxContainer#HLT_xAOD__TrigVertexCountsContainer_vertexcountsAux.',
'xAOD::VertexAuxContainer#BTagging_AntiKt2TrackSecVtxAux.-vxTrackAtVertex',
'xAOD::VertexAuxContainer#BTagging_AntiKt3TrackSecVtxAux.-vxTrackAtVertex',
'xAOD::VertexAuxContainer#BTagging_AntiKt4EMTopoSecVtxAux.-vxTrackAtVertex',
'xAOD::VertexAuxContainer#BTagging_AntiKt4LCTopoSecVtxAux.-vxTrackAtVertex',
'xAOD::VertexAuxContainer#BTagging_AntiKt4TrackSecVtxAux.-vxTrackAtVertex',
'xAOD::VertexAuxContainer#GSFConversionVerticesAux.-vxTrackAtVertex',
'xAOD::VertexAuxContainer#HLT_xAOD__VertexContainer_BjetSecondaryVertexFexAux.',
'xAOD::VertexAuxContainer#HLT_xAOD__VertexContainer_EFHistoPrmVtxAux.',
'xAOD::VertexAuxContainer#HLT_xAOD__VertexContainer_PrimVertexFTKAux.',
'xAOD::VertexAuxContainer#HLT_xAOD__VertexContainer_PrimVertexFTKRawAux.',
'xAOD::VertexAuxContainer#HLT_xAOD__VertexContainer_PrimVertexFTKRefitAux.',
'xAOD::VertexAuxContainer#HLT_xAOD__VertexContainer_SecondaryVertexAux.',
'xAOD::VertexAuxContainer#HLT_xAOD__VertexContainer_xPrimVxAux.',
'xAOD::VertexAuxContainer#MSDisplacedVertexAux.',
'xAOD::VertexAuxContainer#PrimaryVerticesAux.-vxTrackAtVertex.-MvfFitInfo.-isInitialized.-VTAV',
'xAOD::VertexAuxContainer#TauSecondaryVerticesAux.-vxTrackAtVertex',
'TrigOperationalInfoCollection#HLT_TrigOperationalInfoCollection_EXPRESS_OPI_HLT',
'TRT_BSErrContainer#TRT_ByteStreamErrs',
'xAOD::TrigTrackCountsContainer#HLT_xAOD__TrigTrackCountsContainer_trackcounts',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_EFBMuMuFex',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_EFBMuMuXFex',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_EFBMuMuXFex_X',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_EFDsPhiPiFex',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_EFMuPairs',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_EFMultiMuFex',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_EFTrackMass',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_L2BMuMuFex',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_L2BMuMuXFex',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_L2DiMuXFex',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_L2DsPhiPiFexDs',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_L2DsPhiPiFexPhi',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_L2JpsieeFex',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_L2MultiMuFex',
'xAOD::TrigBphysContainer#HLT_xAOD__TrigBphysContainer_L2TrackMass',
'xAOD::TrigCompositeContainer#HLT_xAOD__TrigCompositeContainer_L1TopoComposite',
'xAOD::TrigCompositeContainer#HLT_xAOD__TrigCompositeContainer_L1TopoMET',
'xAOD::TrigCompositeContainer#HLT_xAOD__TrigCompositeContainer_MuonRoICluster',
'xAOD::L1TopoRawDataAuxContainer#L1TopoRawDataAux.',
'xAOD::ElectronTrigAuxContainer#HLT_xAOD__ElectronContainer_egamma_ElectronsAux.',
'xAOD::MuonSegmentAuxContainer#MuonSegmentsAux.',
'xAOD::MuonSegmentAuxContainer#NCB_MuonSegmentsAux.',
'Muon::TgcPrepDataContainer#TGC_MeasurementsAllBCs',
'DataHeader#StreamESD']
)
#
from AthenaCommon.Resilience import treatException, protectedInclude
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.Logging import logging
logRecoOutputItemList_jobOptions = logging.getLogger(
'py:RecoOutputItemList_jobOptions')
from RecExConfig.RecFlags import rec
from AthenaCommon.KeyStore import CfgItemList
# Start with an empty list:
fullESDList = CfgItemList("EsdList")
# EventInfo stuff
fullItemList = ["xAOD::EventInfo#*", "xAOD::EventAuxInfo#*"]
protectedInclude("EventAthenaPool/EventAthenaPoolItemList_joboptions.py")
fullESDList += CfgItemList("EventAthenaPool",
items=fullItemList,
allowWildCard=True)
# DetectorStatus
#obsolete fullESDList += [ "DetStatusMap#DetectorStatus" ]
# RawInfoSummaryForTag
try:
fullItemList = []
protectedInclude(
def test4Methods( self ):
"""Test various methods of CfgItemList"""
i = CfgItemList( 'MyItems' )
self.failUnless( i.name() == 'MyItems' )
i.add( { 'Klass' : ['key1', 'key2'] } )
self.failUnless( i() == [ 'Klass#key1', 'Klass#key2' ] )
i.add( { 'Klass' : ['key1', 'key3' ] } )
self.failUnless( i() == [ 'Klass#key1', 'Klass#key2', 'Klass#key3' ] )
props = i.getProperties()
self.failUnless( props.has_key( 'Klass' ) )
self.failUnless( len(props['Klass']) == len(['key1','key2','key3']) )
self.failUnless( 'key1' in props['Klass'] )
self.failUnless( 'key2' in props['Klass'] )
self.failUnless( 'key3' in props['Klass'] )
self.failUnless( len(i.allChildren()) == 0 )
self.failUnless( i.has_item( 'Klass#key1' ) )
self.failUnless( i.has_item( 'Klass#key*' ) )
self.failUnless( not i.has_item( 'Klass#Key1' ) )
self.failUnless( not i.has_item( 'Klass#Key*' ) )
i.clear()
self.failUnless( len(i()) == 0 )
i.add( { 'Klass' : ['key1', 'key2'] } )
self.failUnless( len(i()) == 2 )
i.remove( 'Klass' )
self.failUnless( len(i()) == 2 )
i.remove( 'Klass#key1' )
self.failUnless( len(i()) == 2 )
i.removeAll()
self.failUnless( len(i()) == 2 )
i.removeItem( 'Klass' )
self.failUnless( len(i()) == 2 )
i.removeItem( 'Klass#key1' )
self.failUnless( len(i()) == 1 )
_keys = ['key1', 'key2', 'key3']
i.add( { 'Klass' : _keys } )
self.failUnless( len(i()) == 3 )
i.removeAllItems( 'Klass#key2' )
self.failUnless( len(i()) == 2 )
## test we don't modify input dict
d = { 'Klassy' : ['key1', 'key2', 'key3'] }
orig_d = d.copy()
i.add( d )
self.failUnless( d == orig_d )
d = { 'Klassy' : 'key4' }
orig_d = d.copy()
i.add( d )
self.failUnless( d == orig_d )
## test extraction of the item list of a given Container type
_keys = [ "Klassy#%s" % k for k in 'key1', 'key2', 'key3', 'key4' ]
self.failUnless( i( "Klassy" ) == _keys )
self.failUnless( i.list( "Klassy" ) == _keys )
self.failUnless( i( key = "Klassy" ) == _keys )
self.failUnless( i.list( key = "Klassy" ) == _keys )
## test dict()
_keys = [ 'key1', 'key2', 'key3', 'key4' ]
self.failUnless( i.dict()['Klass' ] == ['key1', 'key3'] )
self.failUnless( i.dict()['Klassy'] == _keys )
_dict = { 'Klass' : ['key1', 'key3'],
'Klassy': ['key1', 'key2', 'key3', 'key4']}
self.failUnless( i.dict() == _dict )
def test2KwConstructor(self):
"""Test keyword constructor"""
i = CfgItemList('MyItems',
items=[
'Klass1#klass1',
'Klass2#klass2',
],
allowWildCard=False)
self.failUnless(i.has_item('Klass1#klass1'),
'Corrupted output item list !')
self.failUnless(i.has_item('Klass2#klass2'),
'Corrupted output item list !')
self.failUnless(i.has_item('Klass1#*'), 'Corrupted output item list !')
self.failUnless(i.has_item('Klass2#*'), 'Corrupted output item list !')
self.failUnless(i.has_item('Klass1#klass*'),
'Corrupted output item list !')
self.failUnless(i.has_item('Klass2#klass*'),
'Corrupted output item list !')
self.failUnless(not i.has_item('Klass1#klass2'),
'Corrupted output item list !')
self.failUnless(not i.has_item('Klass2#klass1'),
'Corrupted output item list !')
self.failUnless(i._allowWildCard == False,
'Invalid "allowWildCard" state !')
self.failUnless(i() == [
'Klass1#klass1',
'Klass2#klass2',
], 'Invalid output item list value !')
del i
i = CfgItemList('MyItems',
items=[
'Klass3#klass3',
'Klass4#klass4',
],
allowWildCard=True)
self.failUnless(i._allowWildCard == True,
'Invalid "allowWildCard" state !')
self.failUnless(i() == [
'Klass3#klass3',
'Klass4#klass4',
], 'Invalid output item list value !')
del i
msg.setLevel(logging.ERROR)
i = CfgItemList('MyItems', items=['Klass3#*'], allowWildCard=False)
self.failUnless(len(i()) == 0, "AllowWildCard does not work !")
del i
i = CfgItemList('MyItems', items=['Klass3#*'])
self.failUnless(len(i()) == 0, "AllowWildCard does not work !")
del i
i = CfgItemList('MyItems')
i.add('Klass3#*')
self.failUnless(len(i()) == 0, "AllowWildCard does not work !")
from AthenaCommon.KeyStore import CfgItemList
recoMetadataItemList = CfgItemList(
"RecoMetadata",
items=[
"IOVMetaDataContainer#*", "xAOD::LumiBlockRangeContainer#*",
"xAOD::LumiBlockRangeAuxContainer#*", "xAOD::CutBookkeeperContainer#*",
"xAOD::CutBookkeeperAuxContainer#*", "ByteStreamMetadataContainer#*",
"xAOD::TruthMetaDataContainer#TruthMetaData",
"xAOD::TruthMetaDataAuxContainer#TruthMetaDataAux."
],
allowWildCard=True)
dfMetadataItemList = CfgItemList(
"DerivedMetadata",
items=[
"xAOD::TriggerMenuContainer#*", "xAOD::TriggerMenuAuxContainer#*",
"xAOD::FileMetaData#FileMetaData",
"xAOD::FileMetaDataAuxInfo#FileMetaDataAux.",
"xAOD::TruthMetaDataContainer#TruthMetaData",
"xAOD::TruthMetaDataAuxContainer#TruthMetaDataAux."
],
allowWildCard=True)
dfMetadataItemList.add(recoMetadataItemList())
def configure(self):
from AthenaCommon.Logging import logging
mlog = logging.getLogger('CaloCellGetter::configure:')
mlog.info('entering')
doStandardCellReconstruction = True
from CaloRec.CaloCellFlags import jobproperties
if not jobproperties.CaloCellFlags.doFastCaloSim.statusOn:
doFastCaloSim = False
mlog.info("doFastCaloSim not set, so not using it")
else:
doFastCaloSim = jobproperties.CaloCellFlags.doFastCaloSim()
if doFastCaloSim:
mlog.info("doFastCaloSim requested")
doStandardCellReconstruction = False
if jobproperties.CaloCellFlags.doFastCaloSimAddCells():
doStandardCellReconstruction = True
mlog.info(
"doFastCaloSimAddCells requested: FastCaloSim is added to fullsim calorimeter"
)
else:
mlog.info(
"doFastCaloSimAddCells not requested: Stand alone FastCaloSim is running"
)
else:
mlog.info("doFastCaloSim explicitly not requested")
# get handle to upstream object
# handle tile
if doStandardCellReconstruction:
# handle LAr
import traceback
try:
from LArROD.LArRODFlags import larRODFlags
from AthenaCommon.GlobalFlags import globalflags
if larRODFlags.readDigits() and globalflags.DataSource(
) == 'data':
from AthenaCommon.KeyStore import CfgItemList
CfgItemList("KeyStore_inputFile").removeItem(
"LArRawChannelContainer#LArRawChannels")
if (not larRODFlags.readDigits()
) and globalflags.InputFormat() == 'bytestream':
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
try:
if not "LArRawChannelContainer/LArRawChannels" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"LArRawChannelContainer/LArRawChannels"
]
except:
mlog.warning(
"Cannot remove LArRawChannelContainer/LArRawChannels from bytestream list"
)
from LArROD.LArRawChannelGetter import LArRawChannelGetter
theLArRawChannelGetter = LArRawChannelGetter()
except:
mlog.error("could not get handle to LArRawChannel Quit")
print traceback.format_exc()
return False
if not theLArRawChannelGetter.usable():
if not self.ignoreConfigError():
mlog.error("LArRawChannelGetter unusable. Quit.")
return False
else:
mlog.error(
"LArRawChannelGetter unusable. Continue nevertheless")
# writing of thinned digits
if jobproperties.CaloCellFlags.doLArThinnedDigits.statusOn and jobproperties.CaloCellFlags.doLArThinnedDigits(
):
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data':
try:
from LArROD.LArDigits import DefaultLArDigitThinner
LArDigitThinner = DefaultLArDigitThinner(
'LArDigitThinner'
) # automatically added to topSequence
LArDigitThinner.InputContainerName = "FREE"
LArDigitThinner.OutputContainerName = "LArDigitContainer_Thinned"
except Exception:
treatException("Problem with LArDigitThinner ")
# now configure the algorithm, part of this could be done in a separate class
# cannot have same name
try:
from CaloRec.CaloRecConf import CaloCellMaker
except:
mlog.error("could not import CaloRec.CaloCellMaker")
print traceback.format_exc()
return False
theCaloCellMaker = CaloCellMaker()
self._CaloCellMakerHandle = theCaloCellMaker
from AthenaCommon.AppMgr import ToolSvc
if doStandardCellReconstruction:
# configure CaloCellMaker here
# check LArCellMakerTool_jobOptions.py for full configurability
# FIXME
from RecExConfig.RecFlags import rec
if rec.doLArg():
try:
from LArCellRec.LArCellRecConf import LArCellBuilderFromLArRawChannelTool
theLArCellBuilder = LArCellBuilderFromLArRawChannelTool()
except:
mlog.error(
"could not get handle to LArCellBuilderFromLArRawChannel Quit"
)
print traceback.format_exc()
return False
if jobproperties.CaloCellFlags.doLArCreateMissingCells():
# bad channel tools
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
ToolSvc += theLArBadChannelTool
theLArCellBuilder.addDeadOTX = True
theLArCellBuilder.badChannelTool = theLArBadChannelTool
# add the tool to list of tool ( should use ToolHandle eventually)
ToolSvc += theLArCellBuilder
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellBuilder]
if rec.doTile():
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource(
) == 'data' and globalflags.InputFormat() == 'bytestream':
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
try:
svcMgr.ByteStreamCnvSvc.ROD2ROBmap = ["-1"]
if not "TileDigitsContainer/TileDigitsCnt" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"TileBeamElemContainer/TileBeamElemCnt",
"TileDigitsContainer/TileDigitsCnt",
"TileL2Container/TileL2Cnt",
"TileLaserObject/TileLaserObj",
"TileMuonReceiverContainer/TileMuRcvCnt"
]
except:
mlog.warning(
"Cannot add TileDigitsContainer/TileDigitsCnt et al. to bytestream list"
)
# set options for TileRawChannelMaker
from TileRecUtils.TileRecFlags import jobproperties
jobproperties.TileRecFlags.TileRunType = 1
# physics run type
# reading of digits can be disabled before calling CaloCellGetter
# if this is not done, but digits are not available in BS file
# reading of digits is automatically disabled at start of run
if jobproperties.TileRecFlags.readDigits() \
and not (jobproperties.TileRecFlags.doTileFlat \
or jobproperties.TileRecFlags.doTileFit \
or jobproperties.TileRecFlags.doTileFitCool \
or jobproperties.TileRecFlags.doTileOpt \
or jobproperties.TileRecFlags.doTileOF1 \
or jobproperties.TileRecFlags.doTileOpt2 \
or jobproperties.TileRecFlags.doTileOptATLAS \
or jobproperties.TileRecFlags.doTileMF):
from AthenaCommon.BeamFlags import jobproperties
# run Opt filter with iterations by default, both for cosmics and collisions before 2011
# run Opt filter without iterations for collisions in 2011 and later
if not 'doTileOpt2' in dir():
from RecExConfig.AutoConfiguration import GetRunNumber
rn = GetRunNumber()
if rn > 0 and rn < 171194:
doTileOpt2 = True
elif jobproperties.Beam.beamType() == 'collisions':
doTileOpt2 = False
# use OF without iterations for collisions
else:
doTileOpt2 = True
# always run OF with iterations for cosmics
# jobproperties.TileRecFlags.calibrateEnergy=True; # use pCb for RawChannels
# please, note that time correction and best phase are used only for collisions
if doTileOpt2:
jobproperties.TileRecFlags.doTileOpt2 = True
# run optimal filter with iterations
jobproperties.TileRecFlags.doTileOptATLAS = False
# disable optimal filter without iterations
jobproperties.TileRecFlags.correctAmplitude = False
# don't do parabolic correction
if jobproperties.Beam.beamType() == 'collisions':
jobproperties.TileRecFlags.correctTime = True
# apply time correction in physics runs
jobproperties.TileRecFlags.BestPhaseFromCOOL = False
# best phase is not needed for iterations
else:
jobproperties.TileRecFlags.doTileOpt2 = False
# disable optimal filter with iterations
jobproperties.TileRecFlags.doTileOptATLAS = True
# run optimal filter without iterations
jobproperties.TileRecFlags.correctAmplitude = True
# apply parabolic correction
if jobproperties.Beam.beamType() == 'collisions':
jobproperties.TileRecFlags.correctTime = False
# don't need time correction if best phase is used
jobproperties.TileRecFlags.BestPhaseFromCOOL = True
# use best phase stored in DB
try:
from TileRecUtils.TileRawChannelGetter import TileRawChannelGetter
theTileRawChannelGetter = TileRawChannelGetter()
except:
mlog.error("could not load TileRawChannelGetter Quit")
print traceback.format_exc()
return False
try:
from TileRecAlgs.TileRecAlgsConf import TileDigitsFilter
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += TileDigitsFilter()
except:
mlog.error("Could not configure TileDigitsFilter")
try:
from TileRecUtils.TileRecUtilsConf import TileCellBuilder
theTileCellBuilder = TileCellBuilder()
from TileRecUtils.TileRecFlags import jobproperties
theTileCellBuilder.TileRawChannelContainer = jobproperties.TileRecFlags.TileRawChannelContainer(
)
if not hasattr(ToolSvc, "TileBeamInfoProvider"):
from TileRecUtils.TileRecUtilsConf import TileBeamInfoProvider
ToolSvc += TileBeamInfoProvider()
if globalflags.DataSource(
) == 'data' and globalflags.InputFormat() == 'bytestream':
if jobproperties.TileRecFlags.readDigits():
# everything is already corrected at RawChannel level
theTileCellBuilder.correctTime = False
theTileCellBuilder.correctAmplitude = False
else:
ToolSvc.TileBeamInfoProvider.TileRawChannelContainer = "TileRawChannelCnt"
# by default parameters are tuned for opt.filter without iterations
theTileCellBuilder.correctTime = jobproperties.TileRecFlags.correctTime(
)
theTileCellBuilder.correctAmplitude = jobproperties.TileRecFlags.correctAmplitude(
)
theTileCellBuilder.AmpMinForAmpCorrection = jobproperties.TileRecFlags.AmpMinForAmpCorrection(
)
if jobproperties.TileRecFlags.TimeMaxForAmpCorrection(
) <= jobproperties.TileRecFlags.TimeMinForAmpCorrection(
):
from AthenaCommon.BeamFlags import jobproperties
mlog.info(
"adjusting min/max time of parabolic correction for %s"
% jobproperties.Beam.bunchSpacing)
halfBS = jobproperties.Beam.bunchSpacing.get_Value(
) / 2.
jobproperties.TileRecFlags.TimeMinForAmpCorrection = -halfBS
jobproperties.TileRecFlags.TimeMaxForAmpCorrection = halfBS
if jobproperties.TileRecFlags.TimeMaxForAmpCorrection(
) > jobproperties.TileRecFlags.TimeMinForAmpCorrection(
):
theTileCellBuilder.TimeMinForAmpCorrection = jobproperties.TileRecFlags.TimeMinForAmpCorrection(
)
theTileCellBuilder.TimeMaxForAmpCorrection = jobproperties.TileRecFlags.TimeMaxForAmpCorrection(
)
ToolSvc += theTileCellBuilder
theCaloCellMaker.CaloCellMakerToolNames += [
theTileCellBuilder
]
except:
mlog.error("could not get handle to TileCellBuilder Quit")
print traceback.format_exc()
return False
if doFastCaloSim:
mlog.info('configuring FastCaloSim here')
try:
from FastCaloSim.FastCaloSimConf import EmptyCellBuilderTool
theEmptyCellBuilderTool = EmptyCellBuilderTool()
ToolSvc += theEmptyCellBuilderTool
theCaloCellMaker.CaloCellMakerToolNames += [
theEmptyCellBuilderTool
]
print theEmptyCellBuilderTool
mlog.info("configure EmptyCellBuilderTool worked")
except:
mlog.error("could not get handle to EmptyCellBuilderTool Quit")
print traceback.format_exc()
return False
try:
from FastCaloSim.FastCaloSimFactory import FastCaloSimFactory
theFastShowerCellBuilderTool = FastCaloSimFactory()
ToolSvc += theFastShowerCellBuilderTool
theCaloCellMaker.CaloCellMakerToolNames += [
theFastShowerCellBuilderTool
]
mlog.info("configure FastShowerCellBuilderTool worked")
except:
mlog.error(
"could not get handle to FastShowerCellBuilderTool Quit")
print traceback.format_exc()
return False
doFastCaloSimNoise = jobproperties.CaloCellFlags.doFastCaloSimNoise(
)
if doFastCaloSimNoise:
try:
from FastCaloSim.FastCaloSimConf import AddNoiseCellBuilderTool
theAddNoiseCellBuilderTool = AddNoiseCellBuilderTool()
from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
theCaloNoiseTool = CaloNoiseToolDefault()
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += theCaloNoiseTool
theAddNoiseCellBuilderTool.CaloNoiseTool = theCaloNoiseTool.getFullName(
)
print theAddNoiseCellBuilderTool
ToolSvc += theAddNoiseCellBuilderTool
theCaloCellMaker.CaloCellMakerToolNames += [
theAddNoiseCellBuilderTool
]
mlog.info("configure AddNoiseCellBuilderTool worked")
except:
mlog.error(
"could not get handle to AddNoiseCellBuilderTool Quit")
print traceback.format_exc()
return False
#
# CaloCellContainerFinalizerTool : closing container and setting up iterators
#
from CaloRec.CaloRecConf import CaloCellContainerFinalizerTool
theCaloCellContainerFinalizerTool = CaloCellContainerFinalizerTool()
ToolSvc += theCaloCellContainerFinalizerTool
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellContainerFinalizerTool
]
#
# Mergeing of calo cellcontainer with sparse raw channel container with improved energies
#
doLArMerge = False
if globalflags.DataSource(
) == 'data' and jobproperties.CaloCellFlags.doLArRawChannelMerge.statusOn and jobproperties.CaloCellFlags.doLArRawChannelMerge(
):
from LArROD.LArRODFlags import larRODFlags
if larRODFlags.readDigits() and larRODFlags.keepDSPRaw():
doLArMerge = True
if doLArMerge:
try:
from LArCellRec.LArCellRecConf import LArCellMerger
theLArCellMerger = LArCellMerger()
except:
mlog.error("could not get handle to LArCellMerge Quit")
print traceback.format_exc()
return False
theLArCellMerger.RawChannelsName = larRODFlags.RawChannelFromDigitsContainerName(
)
ToolSvc += theLArCellMerger
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellMerger]
#
# masking of noisy and sporadic noisy cells in LAr
#
doNoiseMask = False
if jobproperties.CaloCellFlags.doLArNoiseMasking.statusOn and jobproperties.CaloCellFlags.doLArNoiseMasking(
):
doNoiseMask = True
doSporadicMask = False
if jobproperties.CaloCellFlags.doLArSporadicMasking.statusOn and jobproperties.CaloCellFlags.doLArSporadicMasking(
):
doSporadicMask = True
if doNoiseMask or doSporadicMask:
try:
from LArCellRec.LArCellRecConf import LArCellNoiseMaskingTool
theLArCellNoiseMaskingTool = LArCellNoiseMaskingTool()
except:
mlog.error(
"could not get handle to LArCellNoiseMaskingTool Quit")
print traceback.format_exc()
return False
# bad channel tools
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
ToolSvc += theLArBadChannelTool
if doSporadicMask:
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArSporadicNoiseMasker = LArBadChannelMasker(
"LArSporadicNoiseMasker")
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
theLArSporadicNoiseMasker.TheLArBadChanTool = theLArBadChannelTool
theLArSporadicNoiseMasker.DoMasking = True
theLArSporadicNoiseMasker.ProblemsToMask = [
"sporadicBurstNoise"
]
ToolSvc += theLArSporadicNoiseMasker
theLArCellNoiseMaskingTool.MaskingSporadicTool = theLArSporadicNoiseMasker
if doNoiseMask:
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArNoiseMasker = LArBadChannelMasker("LArNoiseMasker")
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
theLArNoiseMasker.TheLArBadChanTool = theLArBadChannelTool
theLArNoiseMasker.DoMasking = True
theLArNoiseMasker.ProblemsToMask = [
"highNoiseHG", "highNoiseMG", "highNoiseLG", "deadReadout",
"deadPhys"
]
ToolSvc += theLArNoiseMasker
theLArCellNoiseMaskingTool.MaskingTool = theLArNoiseMasker
theLArCellNoiseMaskingTool.maskNoise = doNoiseMask
theLArCellNoiseMaskingTool.maskSporadic = doSporadicMask
# quality cut for sporadic noise masking
theLArCellNoiseMaskingTool.qualityCut = 4000
ToolSvc += theLArCellNoiseMaskingTool
theCaloCellMaker.CaloCellMakerToolNames += [
theLArCellNoiseMaskingTool
]
#
# masking of Feb problems
#
doBadFebMasking = False
if jobproperties.CaloCellFlags.doLArBadFebMasking.statusOn and jobproperties.CaloCellFlags.doLArBadFebMasking(
):
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data':
doBadFebMasking = True
if doBadFebMasking:
try:
from LArCellRec.LArCellRecConf import LArBadFebMaskingTool
theLArBadFebMaskingTool = LArBadFebMaskingTool()
if (
rec.doExpressProcessing()
or athenaCommonFlags.isOnline()
): # In online or express processing, EventInfo::LArError is triggered if >=4 FEB with data corrupted
theLArBadFebMaskingTool.minFebInError = 4
except:
mlog.error("could not get handle to LArBadFebMaskingTool Quit")
print traceback.format_exc()
return False
ToolSvc += theLArBadFebMaskingTool
# bad channel tools
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
ToolSvc += theLArBadChannelTool
theLArBadFebMaskingTool.badChannelTool = theLArBadChannelTool
theCaloCellMaker.CaloCellMakerToolNames += [
theLArBadFebMaskingTool
]
#
# emulate gain pathologies on MC
#
doGainPathology = False
if jobproperties.CaloCellFlags.doLArCellGainPathology.statusOn and jobproperties.CaloCellFlags.doLArCellGainPathology(
):
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'geant4':
doGainPathology = True
if doGainPathology:
try:
from LArCellRec.LArCellRecConf import LArCellGainPathology
theLArCellGainPathology = LArCellGainPathology()
except:
mlog.error("could not get handle to LArCellGainPatholog< Quit")
print traceback.format_exc()
return False
ToolSvc += theLArCellGainPathology
theCaloCellMaker.CaloCellMakerToolNames += [
theLArCellGainPathology
]
# lar miscalibration if MC only (should be done after finalisation)
if not jobproperties.CaloCellFlags.doLArCellEmMisCalib.statusOn:
# the flag has not been set, so decide a reasonable default
# this is the old global flags should use the new one as
# soon as monitoring does
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data':
doLArCellEmMisCalib = False
mlog.info(
"jobproperties.CaloCellFlags.doLArMisCalib not set and real data: do not apply LArCellEmMisCalibTool"
)
else:
doLArCellEmMisCalib = True
mlog.info(
"jobproperties.CaloCellFlags.doLArMisCalib not set and Monte Carlo: apply LArCellEmMisCalibTool"
)
else:
doLArCellEmMisCalib = jobproperties.CaloCellFlags.doLArCellEmMisCalib(
)
if doLArCellEmMisCalib:
mlog.info("LArCellEmMisCalibTool requested")
else:
mlog.info("LArCellEmMisCalibTool explicitly not requested")
if doLArCellEmMisCalib:
try:
from LArCellRec.LArCellRecConf import LArCellEmMiscalib
theLArCellEmMiscalib = LArCellEmMiscalib("LArCellEmMiscalib")
except:
mlog.error("could not get handle to LArCellEmMisCalib Quit")
print traceback.format_exc()
return False
# examples on how to change miscalibration. Default values are 0.005 and 0.007
# theLArCellEmMiscalib.SigmaPerRegion = 0.005;
# theLArCellEmMiscalib.SigmaPerCell = 0.005;
ToolSvc += theLArCellEmMiscalib
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theMisCalibTool = CaloCellContainerCorrectorTool(
"MisCalibTool",
CaloNums=[SUBCALO.LAREM],
CellCorrectionToolNames=[theLArCellEmMiscalib])
except:
mlog.error("could not get handle to MisCalibTool Quit")
print traceback.format_exc()
return False
ToolSvc += theMisCalibTool
theCaloCellMaker.CaloCellMakerToolNames += [theMisCalibTool]
#
# Pedestal shift correction
#
doPedestalCorr = False
if jobproperties.CaloCellFlags.doPedestalCorr.statusOn:
from AthenaCommon.GlobalFlags import globalflags
if jobproperties.CaloCellFlags.doPedestalCorr() and (
globalflags.DataSource() == 'data'
or jobproperties.CaloCellFlags.doPileupOffsetBCIDCorr):
doPedestalCorr = True
mlog.info("Apply cell level pedestal shift correction")
import os
if doPedestalCorr:
try:
from CaloCellCorrection.CaloCellPedestalCorrDefault import CaloCellPedestalCorrDefault
theCaloCellPedestalCorr = CaloCellPedestalCorrDefault()
ToolSvc += theCaloCellPedestalCorr
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellPedestalCorr
]
except:
mlog.error("could not get handle to CaloCellPedestalCorr")
print traceback.format_exc()
#
# HV correction for offline reprocessing, reading HV from Cool-DCS database
#
doHVCorr = False
from AthenaCommon.DetFlags import DetFlags
if DetFlags.dcs.LAr_on():
if jobproperties.CaloCellFlags.doLArHVCorr.statusOn:
from AthenaCommon.GlobalFlags import globalflags
if jobproperties.CaloCellFlags.doLArHVCorr(
) and globalflags.DataSource() == 'data':
doHVCorr = True
mlog.info(
"Redoing HV correction at cell level from COOL/DCS database"
)
if doHVCorr:
from LArCellRec.LArCellHVCorrDefault import LArCellHVCorrDefault
theLArCellHVCorr = LArCellHVCorrDefault()
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theHVCorrTool = CaloCellContainerCorrectorTool(
"HVCorrTool",
CaloNums=[SUBCALO.LAREM, SUBCALO.LARHEC, SUBCALO.LARFCAL],
CellCorrectionToolNames=[theLArCellHVCorr])
except:
mlog.error("could not get handle to HVCorrTool Quit")
print traceback.format_exc()
return False
ToolSvc += theHVCorrTool
theCaloCellMaker.CaloCellMakerToolNames += [theHVCorrTool]
#
# correction to undo online calibration and apply new LAr electronics calibration for ADC->MeV conversion
#
doLArRecalibration = False
if jobproperties.CaloCellFlags.doLArRecalibration.statusOn:
from AthenaCommon.GlobalFlags import globalflags
from LArConditionsCommon.LArCondFlags import larCondFlags
if jobproperties.CaloCellFlags.doLArRecalibration(
) and globalflags.DataSource() == 'data' and (
not larCondFlags.SingleVersion()):
doLArRecalibration = True
mlog.info("Redoing LAr electronics calibration for ADC->MeV")
if doLArRecalibration:
# get tool for cell recalibration
try:
from LArCellRec.LArCellRecConf import LArCellRecalibration
theLArCellRecalibration = LArCellRecalibration(
"LArCellRecalibration")
except:
mlog.error("could not get handle to LArCellRecalibration Quit")
print traceback.format_exc()
return False
ToolSvc += theLArCellRecalibration
# get new ADC2MeVTool
try:
from LArRecUtils.LArADC2MeVToolDefault import LArADC2MeVToolDefault
theLArADC2MeVToolDefault = LArADC2MeVToolDefault()
except:
mlog.error(
"Could not get handle to LArADC2MeVToolDefault Quit")
print traceback.format_exc()
return False
ToolSvc += theLArADC2MeVToolDefault
# get old ADC2MeVTool
try:
from LArRecUtils.LArADC2MeVToolOnline import LArADC2MeVToolOnline
theLArADC2MeVToolOnline = LArADC2MeVToolOnline()
except:
mlog.error("Could not get handle to LArADC2MeVToolOnline Quit")
print traceback.format_exc()
return False
ToolSvc += theLArADC2MeVToolOnline
theLArCellRecalibration.adc2MeVTool = theLArADC2MeVToolDefault
theLArCellRecalibration.adc2MeVToolOnline = theLArADC2MeVToolOnline
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theLArRecalibrationTool = CaloCellContainerCorrectorTool(
"LArRecalibrationTool",
CaloNums=[SUBCALO.LAREM, SUBCALO.LARHEC, SUBCALO.LARFCAL],
CellCorrectionToolNames=[theLArCellRecalibration])
except:
mlog.error("could not get handle to HVCorrTool Quit")
print traceback.format_exc()
return False
ToolSvc += theLArRecalibrationTool
theCaloCellMaker.CaloCellMakerToolNames += [
theLArRecalibrationTool
]
#
# Correction for MinBias energy shift for MC pileup reco
#
doMinBiasAverage = False
if jobproperties.CaloCellFlags.doMinBiasAverage.statusOn:
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.CaloCellFlags.doMinBiasAverage(
) and globalflags.DataSource() == 'geant4' and (
not jobproperties.Beam.zeroLuminosity()):
doMinBiasAverage = True
if doMinBiasAverage:
try:
from CaloTools.CaloMBAverageToolDefault import CaloMBAverageToolDefault
theCaloMBAverageTool = CaloMBAverageToolDefault()
except:
mlog.error("could not get handle to CaloMBAverageTool Quit")
print traceback.format_exc()
return False
ToolSvc += theCaloMBAverageTool
try:
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellMBAverageCorr
theCaloCellMBAverageCorr = CaloCellMBAverageCorr(
"CaloCellMBAverageCorr")
theCaloCellMBAverageCorr.CaloMBAverageTool = theCaloMBAverageTool
except:
mlog.error(
"could not get handle to CaloCellMBAverageCorr Quit")
print traceback.format_exc()
return False
ToolSvc += theCaloCellMBAverageCorr
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theMBAverageTool = CaloCellContainerCorrectorTool(
"MBAverageTool",
CaloNums=[SUBCALO.NSUBCALO],
CellCorrectionToolNames=[theCaloCellMBAverageCorr])
except:
mlog.error(
"could not get handle to CaloCellContainerCorrectorTool/MBAverageTool Quit"
)
print traceback.format_exc()
return False
ToolSvc += theMBAverageTool
theCaloCellMaker.CaloCellMakerToolNames += [theMBAverageTool]
#
# Correction for dead cells, where we average the energy density of neighbor cells
#
doNeighborsAverage = False
if jobproperties.CaloCellFlags.doDeadCellCorr.statusOn:
if jobproperties.CaloCellFlags.doDeadCellCorr():
doNeighborsAverage = True
if doNeighborsAverage:
try:
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellNeighborsAverageCorr
theCaloCellNeighborsAverageCorr = CaloCellNeighborsAverageCorr(
"CaloCellNeighborsAverageCorr")
theCaloCellNeighborsAverageCorr.testMode = False
except:
mlog.error(
"could not get handle to CaloCellNeighborsAverageCorr Quit"
)
print traceback.format_exc()
return False
ToolSvc += theCaloCellNeighborsAverageCorr
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellNeighborsAverageCorr
]
#
# correction for missing Febs based on L1 readout
doLArDeadOTXCorr = False
if jobproperties.CaloCellFlags.doLArDeadOTXCorr.statusOn and jobproperties.CaloCellFlags.doLArCreateMissingCells.statusOn:
if jobproperties.CaloCellFlags.doLArDeadOTXCorr(
) and jobproperties.CaloCellFlags.doLArCreateMissingCells(
) and doStandardCellReconstruction:
if rec.doTrigger():
doLArDeadOTXCorr = True
else:
mlog.warning(
"Trigger is switched off. Can't run deadOTX correction."
)
if doLArDeadOTXCorr:
try:
from LArCellRec.LArCellDeadOTXCorrToolDefault import LArCellDeadOTXCorrToolDefault
theLArCellDeadOTXCorr = LArCellDeadOTXCorrToolDefault()
except:
mlog.error("could not get handle to LArCellDeadOTXCorr Quit")
print traceback.format_exc()
ToolSvc += theLArCellDeadOTXCorr
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellDeadOTXCorr]
doCaloEnergyRescaler = False
if jobproperties.CaloCellFlags.doCaloCellEnergyCorr(
) and globalflags.DataSource(
) == 'data' and not athenaCommonFlags.isOnline():
try:
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellEnergyRescaler
theCCERescalerTool = CaloCellEnergyRescaler()
theCCERescalerTool.Folder = "/LAR/CellCorrOfl/EnergyCorr"
ToolSvc += theCCERescalerTool
from IOVDbSvc.CondDB import conddb
# conddb.addFolder("","/LAR/CellCorrOfl/EnergyCorr<tag>EnergyScale-00</tag><db>sqlite://;schema=escale.db;dbname=COMP200</db>")
conddb.addFolder("LAR_OFL", "/LAR/CellCorrOfl/EnergyCorr")
ToolSvc += theCCERescalerTool
theCaloCellMaker.CaloCellMakerToolNames += [theCCERescalerTool]
except:
mlog.error(
"could not get handle to CaloCellEnergyRescaler Quit")
print traceback.format_exc()
return False
pass
if jobproperties.CaloCellFlags.doCaloCellTimeCorr(
) and globalflags.DataSource(
) == 'data' and not athenaCommonFlags.isOnline():
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellTimeCorrTool
theLArTimeCorr = CaloCellTimeCorrTool()
theLArTimeCorr.Folder = "/LAR/TimeCorrectionOfl/CellTimeOffset"
ToolSvc += theLArTimeCorr
from IOVDbSvc.CondDB import conddb
# conddb.addFolder("","/LAR/TimeCorrectionOfl/CellTimeOffset<tag>LARTimeCorrectionOflCellTimeOffset-empty</tag><db>sqlite://;schema=timecorr.db;dbname=COMP200</db>")
conddb.addFolder("LAR_OFL",
"/LAR/TimeCorrectionOfl/CellTimeOffset")
theCaloTimeCorrTool = CaloCellContainerCorrectorTool(
"LArTimeCorrTool",
CellCorrectionToolNames=[theLArTimeCorr])
ToolSvc += theCaloTimeCorrTool
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloTimeCorrTool
]
except:
mlog.error("could not get handle to CaloCellTimeCorrTool Quit")
print traceback.format_exc()
return False
pass
# make lots of checks (should not be necessary eventually)
# to print the check add:
from CaloRec.CaloRecConf import CaloCellContainerCheckerTool
theCaloCellContainerCheckerTool = CaloCellContainerCheckerTool()
# FIXME
# theCaloCellContainerCheckerTool.OutputLevel=DEBUG
ToolSvc += theCaloCellContainerCheckerTool
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellContainerCheckerTool
]
#
# sets output key
theCaloCellMaker.CaloCellsOutputName = self.outputKey()
# register output in objKeyStore
from RecExConfig.ObjKeyStore import objKeyStore
objKeyStore.addStreamESD(self.outputType(), self.outputKey())
# now add algorithm to topSequence
# this should always come at the end
mlog.info(" now adding CaloCellMaker to topSequence")
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += theCaloCellMaker
return True
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from AthenaCommon.Constants import VERBOSE, INFO
from AthenaCommon.KeyStore import CfgItemList
from AthenaCommon.Logging import logging
msg = logging.getLogger('ItemList')
msg.setLevel(VERBOSE)
msg = logging.getLogger('Athena')
msg.setLevel(INFO)
msg.info("[CfgItemList] test running...")
esdList = CfgItemList("esd")
inDetEsdList = CfgItemList("InDetEsd")
inDetEsdList.add("VxContainer#Conversions")
esdList += inDetEsdList
esdList += CfgItemList(
"CaloEsd", items=["CaloCellContainer#Boo", "CaloClusterContainer#BooBoo"])
assert (esdList.CaloEsd() == [
"CaloCellContainer#Boo", "CaloClusterContainer#BooBoo"
])
esdList += CfgItemList("TrigEsd",
items=["JetCollection#HLT_AutoKey*"],
allowWildCard=True)
assert (esdList.TrigEsd() == ["JetCollection#HLT_AutoKey*"])
# if the automatic trigger stream logics or command-line overrides did not activate a single selection,
# choose to not write out any events to the output file (can happen e.g. in Reco_trf.py test jobs)
else:
from PrimaryDPDMaker.DummyFilter import DummyFilter
dummyFilterName = "RPVLL_DESDMStream_DummyFilter"
topSequence += DummyFilter(dummyFilterName)
filtersToBookkeep += dummyFilterName
vetoAlgsNames = []
vetoAlgsNames.append(dummyFilterName)
RPVLL.VetoAlgs(vetoAlgsNames)
# ##########################################################################################
# Output stream definition
# ##########################################################################################
# Add everything from the input file
from AthenaCommon.KeyStore import CfgKeyStore, CfgItemList
theCKS = CfgKeyStore('KeyStore')
outList = CfgItemList('RPVLL')
outList += theCKS['inputFile']
# Remove items here, as needed
outList.removeAllItems('RpcPadContainer#RPCPAD') # Avoids crash in 20.1.0.2
# Configure the stream
RPVLL.AddItem(outList())
# make sure bookkeeping info is kept for additional filters
# MJF: Does this do anything useful?
RPVLL.AddOtherAlgsToBookkeep(filtersToBookkeep)
def test2KwConstructor( self ):
"""Test keyword constructor"""
i = CfgItemList( 'MyItems',
items = [ 'Klass1#klass1',
'Klass2#klass2', ],
allowWildCard = False )
self.failUnless( i.has_item( 'Klass1#klass1' ),
'Corrupted output item list !' )
self.failUnless( i.has_item( 'Klass2#klass2' ),
'Corrupted output item list !' )
self.failUnless( i.has_item( 'Klass1#*' ),
'Corrupted output item list !' )
self.failUnless( i.has_item( 'Klass2#*' ),
'Corrupted output item list !' )
self.failUnless( i.has_item( 'Klass1#klass*' ),
'Corrupted output item list !' )
self.failUnless( i.has_item( 'Klass2#klass*' ),
'Corrupted output item list !' )
self.failUnless( not i.has_item( 'Klass1#klass2' ),
'Corrupted output item list !' )
self.failUnless( not i.has_item( 'Klass2#klass1' ),
'Corrupted output item list !' )
self.failUnless( i._allowWildCard == False,
'Invalid "allowWildCard" state !' )
self.failUnless( i() == [ 'Klass1#klass1', 'Klass2#klass2', ],
'Invalid output item list value !' )
del i
i = CfgItemList( 'MyItems',
items = [ 'Klass3#klass3',
'Klass4#klass4', ],
allowWildCard = True )
self.failUnless( i._allowWildCard == True,
'Invalid "allowWildCard" state !' )
self.failUnless( i() == [ 'Klass3#klass3', 'Klass4#klass4', ],
'Invalid output item list value !' )
del i
msg.setLevel( logging.ERROR )
i = CfgItemList( 'MyItems',
items = [ 'Klass3#*' ],
allowWildCard = False )
self.failUnless( len(i()) == 0, "AllowWildCard does not work !" )
del i
i = CfgItemList( 'MyItems', items = [ 'Klass3#*' ] )
self.failUnless( len(i()) == 0, "AllowWildCard does not work !" )
del i
i = CfgItemList( 'MyItems' )
i.add( 'Klass3#*' )
self.failUnless( len(i()) == 0, "AllowWildCard does not work !" )
def test5WildCard( self ):
"""Test the wildcard capabilities of CfgItemList"""
i = CfgItemList( 'MyItems' )
self.failUnless( i.name() == 'MyItems' )
## test wildcard
i.add( "Klass#Foo" )
self.failUnless( i("Klass") == ["Klass#Foo"] )
# ignored as not allowing wildcarded items
i.add( "Klass#*" )
self.failUnless( i("Klass") == ["Klass#Foo"] )
# allowed as special cases for trigger
i.clear()
i.add( "TrigKlass#HLTAutoKey*" )
self.failUnless( i("TrigKlass") == ["TrigKlass#HLTAutoKey*"] )
i.clear()
i.add( "TrigKlass#HLTAutoKey_*" )
self.failUnless( i("TrigKlass") == ["TrigKlass#HLTAutoKey_*"] )
i.clear()
i.add( "TrigKlass#HLTAutoKey_foo_*" )
self.failUnless( i("TrigKlass") == ["TrigKlass#HLTAutoKey_foo_*"] )
i.clear()
i.add( "TrigKlass#HLTAutoKey_foo_42_*" )
self.failUnless( i("TrigKlass") == ["TrigKlass#HLTAutoKey_foo_42_*"] )
def test3Methods( self ):
"""Test various methods of CfgKeyStore"""
ks = CfgKeyStore( "MyStore" )
self.assertTrue( ks.streamESD() == [] )
self.assertTrue( ks['streamESD']() == [] )
ks.streamESD.add( {
'McEventCollection' : [ 'GEN_EVENT', 'GEN_AOD', 'TruthEvent' ],
} )
self.assertTrue( len(ks.streamESD()) == 3 )
self.assertTrue( len(ks.transient()) == 3 )
self.assertTrue(ks.streamESD.has_item('McEventCollection#TruthEvent'))
self.assertTrue(not ks.streamESD.has_item('McEventCollection#gen_aod'))
ks.streamAOD += CfgItemList( 'subAod',
items = [ 'Klass#key1', 'Klass#key2' ] )
self.assertTrue( len(ks.streamAOD()) == 2 )
self.assertTrue( len(ks.transient()) == 5 )
ks.streamESD.add( {
'JetCollection' : [ 'Cone4Jets', 'Cone7Jets', 'KtJets',
'Cone4TruthJets' ],
} )
self.assertTrue( len(ks.streamESD()) == 3+4 )
self.assertTrue( len(ks.streamESD.dict().keys()) == 2 )
self.assertTrue( len(ks.transient.dict().keys()) == 3 )
ks.streamESD.add( {
'JetCollection' : [ 'Cone4Jets', 'Cone7Jets', 'KtJets' ] } )
self.assertTrue( len(ks.streamESD()) == 3+4 )
self.assertTrue( len(ks.streamESD.dict().keys()) == 2 )
self.assertTrue( len(ks.transient.dict().keys()) == 3 )
ks.streamAOD.add( 'ParticleJetContainer#ConeTowerParticleJets' )
self.assertTrue( len(ks.streamAOD()) == 3 )
self.assertTrue( len(ks.streamAOD.dict().keys()) == 2 )
self.assertTrue( len(ks.transient.dict().keys()) == 4 )
ks.streamAOD.add( ['ParticleJetContainer#ConeTowerParticleJets'] )
self.assertTrue( len(ks.streamAOD()) == 3 )
self.assertTrue( len(ks.streamAOD.dict().keys()) == 2 )
self.assertTrue( len(ks.transient.dict().keys()) == 4 )
ks.streamAOD.add( ['ParticleJetContainer#Cone4TowerParticleJets'] )
self.assertTrue( len(ks.streamAOD()) == 4 )
self.assertTrue( len(ks.streamAOD.dict().keys()) == 2 )
self.assertTrue( len(ks.transient.dict().keys()) == 4 )
caught = False
try:
ks['unallowedKey'] = range(10)
except KeyError as err:
caught = True
self.assertTrue( caught )
caught = False
try: dummy = ks['unallowedKey']
except KeyError as err: caught = True
self.assertTrue( caught )
caught = False
try: dummy = ks['streamAOD']
except KeyError as err: caught = True
self.assertTrue( not caught )
del dummy
## test reset...
ks.streamTAG.add( 'JetCollection#Tag_Cone4Jets' )
self.assertTrue( len(ks.streamTAG()) == 1 )
ks.streamTAG.clear()
self.assertTrue( len(ks.streamTAG()) == 0 )
self.assertTrue( len(ks.streamAOD.dict().keys()) == 2 )
self.assertTrue( len(ks.transient.dict().keys()) == 4 )
ks.transient.clear()
self.assertTrue( len(ks.transient.dict().keys()) == 0 )
## might be a bit confusing but 'clear' also removes children
caught = False
try: dummy = ks.streamAOD
except AttributeError as err: caught = True
self.assertTrue( caught )
self.assertTrue( len(list(CfgKeyStore.instances.keys())) == 1 )
del ks
## FIXME
## ARGH!!! Somebody is keeping a ref toward ks!
## OK with py3
if six.PY3:
self.assertTrue( len(list(CfgKeyStore.instances.keys())) == 0 )
AOD_ItemList += ["TileMuContainer#TileMuObj"]
AOD_ItemList += ["TileCellContainer#MBTSContainer"]
# MC Truth for PileUp
AOD_ItemList += ["PileUpEventInfo#*"]
#obsolete AOD_ItemList+=[ "DetStatusMap#DetectorStatus" ]
if AODFlags.Trigger:
include("TriggerRelease/TriggerOutputItemListAOD_jobOptions.py")
# now merge the explicit AOD list to the one coming from ObjKeyStore
# (more and more will be taken from ObjKeyStore)
from AthenaCommon.KeyStore import CfgItemList, CfgKeyStore
theCKS = CfgKeyStore("KeyStore")
CILMergeAOD = CfgItemList("AODMerge", allowWildCard=True)
CILMergeAOD.add(AOD_ItemList)
CILMergeAOD.add(theCKS.streamAOD())
#now prune the itemlist from the object which are soft linked
# this doe not work CILMergeAOD.remove("DataVector<INavigable4Momentum>")
#this does
for k in CILMergeAOD('DataVector<INavigable4Momentum>'):
CILMergeAOD.removeItem(k)
# The only items declared in StreamESD are those written here.
# Note the use of "=" instead of "+=" is deliberate
#StreamESD.ItemList = fullESDList()
AOD_ItemList = CILMergeAOD()
def test3Hierarchy(self):
"""Test tree-like hierarchy structure of item lists"""
i = CfgItemList('MyItems',
items=[
'Klass1#klass1',
'Klass2#klass2',
],
allowWildCard=False)
ii = CfgItemList('MySubItems',
items=[
'Klass3#klass3', 'Klass4#klass4', 'Klass5#klass5',
'Klass6#klass6'
])
self.failUnless(len(i()) == 2, "Invalid output item list !!")
self.failUnless(len(ii()) == 4, "Invalid output item list !!")
i += ii
self.failUnless(len(i()) == 6, "Invalid output item list !!")
self.failUnless(hasattr(i, ii.name()),
'Invalid hierarchy structure !!')
oo = getattr(i, ii.name())
self.failUnless(oo == ii, 'Invalid hierarchy structure !!')
self.failUnless(oo is ii, 'Invalid hierarchy structure !!')
self.failUnless(len(oo()) == 4, "Invalid output item list !!")
del ii
ii = CfgItemList('MySubItems')
self.failUnless(len(ii()) == 4, "Invalid output item list !!")
del i, ii
i = CfgItemList('MyItems')
ii = CfgItemList('MySubItems')
self.failUnless(len(i()) == 0, "Invalid output item list !!")
self.failUnless(len(ii()) == 4, "Invalid output item list !!")
del oo, ii
ii = CfgItemList('MySubItems')
self.failUnless(len(ii()) == 0, "Invalid output item list !!")
# object added to any streams are also added to transient,
# this is wrong if stream is an output stream. But KeyStore does not know which are input, which are output stream.
# sets this up at construction? Adding to outpustream is inconsistent
from AthenaCommon.Resilience import treatException, protectedInclude
from AthenaCommon.Logging import logging
logRecoOutputItemList_jobOptions = logging.getLogger(
'py:RecoOutputItemList_jobOptions')
from RecExConfig.RecFlags import rec
from AthenaCommon.KeyStore import CfgItemList
# Start with an empty list:
fullAODList = CfgItemList("AodList")
# EventInfo stuff
fullItemList = ["xAOD::EventInfo#*", "xAOD::EventAuxInfo#*"]
try:
include("EventAthenaPool/EventAthenaPoolItemList_joboptions.py")
fullAODList += CfgItemList("EventAthenaPool",
items=fullItemList,
allowWildCard=True)
except Exception:
treatException(
"Could not include EventAthenaPool/EventAthenaPoolItemList_joboptions.py"
)
# RawInfoSummaryForTag