def test2Constructor( self ):
"""Test constructor"""
ks = CfgKeyStore( "MyStore" )
self.failUnless( ks.name() == "MyStore" )
self.failUnless( len(ks.keys()) == len(ks._items)+4 )
for label in ks.keys():
if label == 'transient': n = 4 # nbr of streamXyz
else : n = 0
self.failUnless( len(ks[label]) == n )
self.failUnless( len(ks[label].list()) == 0 )
self.failUnless( hasattr(ks, label) )
ks.streamAOD.add( { 'Klass' : 'key1' } )
self.failUnless( ks.streamAOD() == [ 'Klass#key1' ] )
del ks
ks = CfgKeyStore( "MyStore" )
self.failUnless( ks.streamAOD() == [] )
pass
class _ObjKeyStore(object):
def __init__(self, name="KeyStore"):
object.__init__(self)
self._store = CfgKeyStore(name)
for label in CfgKeyStore.__slots__['Labels']:
labelName = "%s%s" % (
str(label)[0].upper(), # capitalize first letter
str(label)[1:])
self.__dict__['isIn%s' % labelName] = self.__isInDict(label)
self.__dict__['add%s' % labelName] = self.__addToDict(label)
self.__dict__['addManyTypes%s' %
labelName] = self.__addDictToDict(label)
self.__dict__['write%s' % labelName] = self.__writePy(label)
self.__dict__['read%s' % labelName] = self.__readPy(label)
return
# def __isInDict(self, label):
# fct = lambda key: self.__all[label].has_key(key)
# class __helper:
# def __call__(self,key):
# return fct(key)
# return __helper()
def __getitem__(self, k):
return self._store[k]
def __setitem__(self, k, v):
return self._store.__setitem__(k, v)
def keys(self):
return self._store.keys()
def clear(self, label=None):
return self._store.clear(label)
def __isInDict(self, label):
def isIn(d, k, v):
return d.has_item("%s#%s" % (k, v))
fct = lambda key, value: isIn(self._store[label], key, value)
class __helper:
def __call__(self, key, value):
return fct(key, value)
return __helper()
def __addToDict(self, label):
def fill(d, k, v):
d.add({k: v})
return
fct = lambda key, value: fill(self._store[label], key, value)
class __helper:
def __call__(self, key, value):
return fct(key, value)
return __helper()
def __addDictToDict(self, label):
# merge the dictionaries
def fill(d, thedict):
d.add(thedict)
return
fct = lambda thedict: fill(self._store[label], thedict)
class __helper:
def __call__(self, thedict):
return fct(thedict)
return __helper()
def __writePy(self, label):
fct = lambda fileName: self._store.write(fileName, label)
class __helper:
def __call__(self, fileName):
return fct(fileName)
return __helper()
def __readPy(self, label):
fct = lambda fileName: self._store.read(fileName, label)
class __helper:
def __call__(self, fileName):
return fct(fileName)
return __helper()
def isInInput(self, type="", key="*"):
flag = self.isInTransient(type, key) or self.isInInputFile(type, key)
return flag
def Print(self):
print(self._store)
def __repr__(self):
return "%r" % self._store
def __str__(self):
return "%s" % self._store
pass # _ObjKeyStore
# 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 test6KeyStoreDiff( self ):
"""Test keystore_diff"""
from AthenaCommon.KeyStore import keystore_diff
# reference
ref = CfgKeyStore( "ref" )
self.failUnless( ref.streamESD() == [] )
self.failUnless( ref.streamAOD() == [] )
self.failUnless( ref.transient() == [] )
ref.streamESD.add( {
'McEvent' : [ 'GEN_EVENT', 'GEN_AOD', 'TruthEvent' ],
'NoEvent' : [ 'GEN_EVENT', 'GEN_AOD', 'TruthEvent' ],
} )
self.failUnless( len(ref.streamESD()) == 6 )
self.failUnless( len(ref.streamAOD()) == 0 )
self.failUnless( len(ref.transient()) == 6 )
# check
chk = CfgKeyStore( "chk" )
self.failUnless( chk.streamESD() == [] )
self.failUnless( chk.streamAOD() == [] )
self.failUnless( chk.transient() == [] )
chk.streamESD.add( {
'NoEvent' : [ 'GEN_EVENT', 'TruthEvent' ],
} )
self.failUnless( len(chk.streamESD()) == 2 )
self.failUnless( len(chk.streamAOD()) == 0 )
self.failUnless( len(chk.transient()) == 2 )
diff_ref = "".join ([
"- len(ref[streamESD]) == 6",
"+ len(chk[streamESD]) == 2",
"- ref[streamESD] : McEvent#GEN_AOD",
"- ref[streamESD] : McEvent#GEN_EVENT",
"- ref[streamESD] : McEvent#TruthEvent",
"- ref[streamESD] : NoEvent#GEN_AOD",
""
])
import os,atexit
test1_fname = 'test1_%s.diff' % str(os.getpid())
otest1 = open (test1_fname, 'w')
atexit.register (os.unlink, test1_fname)
diff = keystore_diff (ref, chk, labels='streamESD', ofile=otest1)
self.failUnless (diff==diff_ref)
self.failUnless (os.path.exists (test1_fname))
diff = keystore_diff ("ref", "chk", labels='streamESD', ofile=otest1)
self.failUnless (diff==diff_ref)
self.failUnless (os.path.exists (test1_fname))
test2_fname = 'test2_%s.diff' % str(os.getpid())
otest2 = open (test2_fname, 'w')
atexit.register (os.unlink, test2_fname)
diff_ref = "".join ([
"- len(ref[transient]) == 6",
"+ len(chk[transient]) == 2",
"- ref[transient] : McEvent#GEN_AOD",
"- ref[transient] : McEvent#GEN_EVENT",
"- ref[transient] : McEvent#TruthEvent",
"- ref[transient] : NoEvent#GEN_AOD",
"- len(ref[streamESD]) == 6",
"+ len(chk[streamESD]) == 2",
"- ref[streamESD] : McEvent#GEN_AOD",
"- ref[streamESD] : McEvent#GEN_EVENT",
"- ref[streamESD] : McEvent#TruthEvent",
"- ref[streamESD] : NoEvent#GEN_AOD",
""
])
diff = keystore_diff (ref, chk, ofile=otest2)
self.failUnless (diff==diff_ref)
self.failUnless (os.path.exists (test2_fname))
diff = keystore_diff ("ref", "chk", ofile=otest2)
self.failUnless (diff==diff_ref)
self.failUnless (os.path.exists (test2_fname))
test3_fname = 'test3_%s.diff' % str(os.getpid())
otest3 = open (test3_fname, 'w')
atexit.register (os.unlink, test3_fname)
diff = keystore_diff (ref, ref, otest3)
self.failUnless (diff=='')
self.failUnless (os.path.exists (test3_fname))
diff = keystore_diff ("ref", "ref", otest3)
self.failUnless (diff=='')
## valid arguments...
err_msg = None
test4_fname = 'test4_%s.diff' % str(os.getpid())
otest4 = open (test4_fname, 'w')
atexit.register (os.unlink, test4_fname)
try:
diff = keystore_diff ("ref", "typo-chk", ofile=otest4)
except ValueError, err:
err_msg = str(err)
def test4Persistency( self ):
"""Test persistency of CfgKeyStore"""
ks = CfgKeyStore( "MyStore" )
self.failUnless( ks.streamESD() == [] )
self.failUnless( ks.streamAOD() == [] )
self.failUnless( ks.transient() == [] )
ks.streamESD.add( {
'McEventCollection' : [ 'GEN_EVENT', 'GEN_AOD', 'TruthEvent' ],
} )
self.failUnless( len(ks.streamESD()) == 3 )
self.failUnless( len(ks.streamAOD()) == 0 )
self.failUnless( len(ks.transient()) == 3 )
import os
outFileName = 'esd_%s.py' % str(os.getpid())
ks.write( outFileName, 'streamESD' )
del ks
ks = CfgKeyStore( "MyStore" )
self.failUnless( ks.streamESD() == [] )
self.failUnless( ks.streamAOD() == [] )
self.failUnless( ks.transient() == [] )
ks.read( outFileName, 'streamAOD' )
self.failUnless( len(ks.streamESD()) == 0 )
self.failUnless( len(ks.streamAOD()) == 3 )
self.failUnless( len(ks.transient()) == 3 )
del ks
ks = CfgKeyStore( "MyStore" )
self.failUnless( ks.streamESD() == [] )
self.failUnless( ks.streamAOD() == [] )
self.failUnless( ks.transient() == [] )
ks.read( outFileName, 'streamAOD' )
self.failUnless( len(ks.streamESD()) == 0 )
self.failUnless( len(ks.streamAOD()) == 3 )
self.failUnless( len(ks.transient()) == 3 )
del ks
ks = CfgKeyStore( "MyStore" )
self.failUnless( ks.streamESD() == [] )
self.failUnless( ks.streamAOD() == [] )
self.failUnless( ks.transient() == [] )
ks.read( outFileName, 'streamESD' )
self.failUnless( len(ks.streamESD()) == 3 )
self.failUnless( len(ks.streamAOD()) == 0 )
self.failUnless( len(ks.transient()) == 3 )
del ks
ks = CfgKeyStore( "MyStore" )
self.failUnless( ks.streamESD() == [] )
self.failUnless( ks.streamAOD() == [] )
self.failUnless( ks.transient() == [] )
ks.read( outFileName, 'streamESD' )
ks.read( outFileName, 'streamAOD' )
self.failUnless( len(ks.streamESD()) == 3 )
self.failUnless( len(ks.streamAOD()) == 3 )
self.failUnless( len(ks.transient()) == 3 )
os.remove( outFileName )
os.remove( outFileName+'c' )
import shelve
outFileName = 'esd_%s.dat' % str(os.getpid())
del ks
ks = CfgKeyStore( "MyStore" )
ks.streamESD.add( {
'McEventCollection' : [ 'GEN_EVENT', 'GEN_AOD', 'TruthEvent' ],
} )
self.failUnless( len(ks.streamESD()) == 3 )
self.failUnless( len(ks.streamAOD()) == 0 )
self.failUnless( len(ks.transient()) == 3 )
print 'outFileName:',outFileName
db = shelve.open( outFileName, 'c' )
db['store'] = ks
db.close()
del ks
db = shelve.open( outFileName, 'r' )
ks = db['store']
db.close()
self.failUnless( len(ks.streamESD()) == 3 )
self.failUnless( len(ks.streamAOD()) == 0 )
self.failUnless( len(ks.transient()) == 3 )
## MacOSX silently appends the .db suffix to shelve files. I haven't found a
## mechanism for determining the actual filename, which is why I've added the
## MacOSX-specific hack.
from sys import platform
if platform != 'darwin' :
os.remove( outFileName )
else:
os.remove( outFileName+'.db')
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
# ring-shaped calorimetry
if rec.doCaloRinger():
try:
include("CaloRingerAlgs/CaloRingerOutputItemList_jobOptions.py")
fullAODList += CfgItemList("caloRingerAod", items=caloRingerAODList)
StreamAOD_Augmented.AddMetaDataItem(caloRingerMetaDataList)
except Exception:
treatException(
"Could not load CaloRingerAlgs/CaloRingerOutputItemList_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(fullAODList())
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 StreamAOD are those written here.
# Note the use of "=" instead of "+=" is deliberate
StreamAOD.ItemList = CILMergeAOD()
