def muonRdoDecodeTestMC():
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior = 1
from AthenaConfiguration.AllConfigFlags import ConfigFlags
ConfigFlags.Input.Files = [
"/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/TriggerTest/valid1.110401.PowhegPythia_P2012_ttbar_nonallhad.recon.RDO.e3099_s2578_r7572_tid07644622_00/RDO.07644622._000001.pool.root.1"
]
ConfigFlags.lock()
ConfigFlags.dump()
from AthenaCommon.Logging import log
log.setLevel(DEBUG)
log.info('About to setup Rpc RDO data decoding')
cfg = ComponentAccumulator()
# We are reading a pool file for this test
from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
cfg.merge(PoolReadCfg(ConfigFlags))
# Schedule RDO conversion
# RPC decoding
rpcdecodingAcc = RpcRDODecodeCfg(ConfigFlags)
cfg.merge(rpcdecodingAcc)
# TGC decoding
tgcdecodingAcc = TgcRDODecodeCfg(ConfigFlags)
cfg.merge(tgcdecodingAcc)
# MDT decoding
mdtdecodingAcc = MdtRDODecodeCfg(ConfigFlags)
cfg.merge(mdtdecodingAcc)
# CSC decoding
cscdecodingAcc = CscRDODecodeCfg(ConfigFlags)
cfg.merge(cscdecodingAcc)
cscbuildingAcc = CscClusterBuildCfg(ConfigFlags)
cfg.merge(cscbuildingAcc)
log.info('Print Config')
cfg.printConfig(withDetails=True)
# Store config as pickle
log.info('Save Config')
with open('MuonRdoDecode.pkl', 'wb') as f:
cfg.store(f)
f.close()
return cfg
def skip_test_sequences_merging(self):
from AthenaConfiguration.AllConfigFlags import ConfigFlags
ConfigFlags.lock()
from AthenaCommon.Logging import logging
logging.getLogger('ComponentAccumulator').setLevel(DEBUG)
print("ca1")
ca1 = ComponentAccumulator()
ca1.addEventAlgo(TestAlgo("alg1"))
ca1.printConfig()
ca1.addSequence(seqAND("someSequence"))
print("ca2")
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
ca2 = OutputStreamCfg(ConfigFlags,
"RDO",
ItemList=[
"SCT_RDO_Container#SCT_RDOs",
"InDetSimDataCollection#SCT_SDO_Map"
])
ca2.printConfig()
print("after merge")
ca1.merge(ca2)
ca1.printConfig()
self.assertEqual(len(ca1._allSequences), 2,
"Dangling sequences not maintained")
print("Instantiating top CA")
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
topca = MainServicesCfg(ConfigFlags)
topca.printConfig()
print("Merging to the top level CA")
topca.merge(ca1)
topca.printConfig()
topca.wasMerged()
def SetupMuonStandaloneConfigFlags(args):
from AthenaConfiguration.AllConfigFlags import ConfigFlags
# Keeping this commented out so we can easily switch to the default for testing against that.
# from AthenaConfiguration.TestDefaults import defaultTestFiles
# ConfigFlags.Input.Files = defaultTestFiles.ESD
ConfigFlags.Input.Files = [
'/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/RecExRecoTest/ESD.16747874._000011_100events.pool.root'
]
ConfigFlags.Concurrency.NumThreads = args.threads
ConfigFlags.Concurrency.NumConcurrentEvents = args.threads # Might change this later, but good enough for the moment.
ConfigFlags.Detector.GeometryMDT = True
ConfigFlags.Detector.GeometryTGC = True
ConfigFlags.Detector.GeometryCSC = True
ConfigFlags.Detector.GeometryRPC = True
ConfigFlags.Output.ESDFileName = args.output
ConfigFlags.Input.isMC = True
ConfigFlags.lock()
ConfigFlags.dump()
return ConfigFlags
cfgFlags.Output.ESDFileName = "esdOut.pool.root"
# Flags relating to multithreaded execution
cfgFlags.Concurrency.NumThreads = args.nThreads
if args.nThreads > 0:
cfgFlags.Scheduler.ShowDataDeps = True
cfgFlags.Scheduler.ShowDataFlow = True
cfgFlags.Scheduler.ShowControlFlow = True
cfgFlags.Concurrency.NumConcurrentEvents = args.nThreads
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
acc = MainServicesCfg(cfgFlags)
acc.getService("MessageSvc").Format = "% F%80W%S%7W%R%T %0W%M"
# Prevent the flags from being modified
cfgFlags.lock()
acc.merge(PrepareStandAloneBTagCfg(cfgFlags))
JetCollection = ['AntiKt4EMTopo', 'AntiKt4EMPFlow']
if args.highlevel:
acc.merge(BTagHLTaggersCfg(cfgFlags, JetCollection=JetCollection))
else:
kwargs = {}
kwargs['Release'] = args.release
if args.release == "21.2":
kwargs["TimeStamp"] = ['201810', '201903']
kwargs['Release'] = '21'
kwargs["SplitAlg"] = args.splitAlg
Configurable.configurableRun3Behavior = 1
# Setup logs
from AthenaCommon.Logging import log
from AthenaCommon.Constants import INFO
log.setLevel(INFO)
# Set the Athena configuration flags
from AthenaConfiguration.AllConfigFlags import ConfigFlags
path = '/afs/cern.ch/work/j/jodafons/public/valid_sampleA/AOD.20745922._000041.pool.root.1'
ConfigFlags.Input.Files = [path]
ConfigFlags.Input.isMC = False
ConfigFlags.Output.HISTFileName = 'TrigEgammaMonitorOutput.root'
ConfigFlags.lock()
# Initialize configuration object, add accumulator, merge, and run.
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
cfg = MainServicesCfg(ConfigFlags)
cfg.merge(PoolReadCfg(ConfigFlags))
trigEgammaMonitorAcc = TrigEgammaMonConfig(ConfigFlags)
cfg.merge(trigEgammaMonitorAcc)
# If you want to turn on more detailed messages ...
#trigEgammaMonitorAcc.getEventAlgo('TrigEgammaMonAlg').OutputLevel = 2 # DEBUG
cfg.printConfig(withDetails=False) # set True for exhaustive info
cfg.run(10) #use cfg.run(20) to only run on first 20 events
flags.needFlagsCategory('Trigger')
setupMenuModule.setupMenu(flags)
flags.Exec.MaxEvents = 50
flags.Input.isMC = False
flags.Input.Files = [
"/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/TrigP1Test/data17_13TeV.00327265.physics_EnhancedBias.merge.RAW._lb0100._SFO-1._0001.1"
]
flags.Trigger.L1Decoder.forceEnableAllChains = True
flags.Concurrency.NumThreads = 1
flags.Concurrency.NumConcurrentEvents = 1
flags.InDet.useSctDCS = False
flags.InDet.usePixelDCS = False
flags.lock()
from AthenaCommon.Constants import DEBUG, WARNING
acc = MainServicesCfg(flags)
acc.getService('AvalancheSchedulerSvc').VerboseSubSlots = True
# this delcares to the scheduer that EventInfo object is produced
acc.addEventAlgo(
CompFactory.SGInputLoader(Load=[('xAOD::EventInfo',
'StoreGateSvc+EventInfo')]), "AthAlgSeq")
from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
acc.merge(ByteStreamReadCfg(flags))
def muonRdoDecodeTestData(forTrigger=False):
# Add a flag, forTrigger, which will initially put the ByteStreamDecodeCfg code into "Cached Container" mode
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior = 1
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from AthenaConfiguration.TestDefaults import defaultTestFiles
ConfigFlags.Input.Files = defaultTestFiles.RAW
# Set global tag by hand for now
ConfigFlags.IOVDb.GlobalTag = "CONDBR2-BLKPA-2018-13" #"CONDBR2-BLKPA-2015-17"
ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2016-01-00-01" #"ATLAS-R2-2015-03-01-00"
ConfigFlags.lock()
ConfigFlags.dump()
from AthenaCommon.Logging import log
log.setLevel(INFO)
log.info('About to setup Raw data decoding')
cfg = ComponentAccumulator()
# Seem to need this to read BS properly
from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
cfg.merge(ByteStreamReadCfg(ConfigFlags))
# Add the MuonCache to ComponentAccumulator for trigger/RoI testing mode
if forTrigger:
# cache creators loaded independently
from MuonConfig.MuonBytestreamDecodeConfig import MuonCacheCfg
cfg.merge(MuonCacheCfg())
# Schedule Rpc bytestream data decoding
from MuonConfig.MuonBytestreamDecodeConfig import RpcBytestreamDecodeCfg
rpcdecodingAcc = RpcBytestreamDecodeCfg(ConfigFlags, forTrigger)
cfg.merge(rpcdecodingAcc)
# Schedule Mdt bytestream data decoding
from MuonConfig.MuonBytestreamDecodeConfig import TgcBytestreamDecodeCfg
tgcdecodingAcc = TgcBytestreamDecodeCfg(ConfigFlags, forTrigger)
cfg.merge(tgcdecodingAcc)
from MuonConfig.MuonBytestreamDecodeConfig import MdtBytestreamDecodeCfg
mdtdecodingAcc = MdtBytestreamDecodeCfg(ConfigFlags, forTrigger)
cfg.merge(mdtdecodingAcc)
from MuonConfig.MuonBytestreamDecodeConfig import CscBytestreamDecodeCfg
cscdecodingAcc = CscBytestreamDecodeCfg(ConfigFlags, forTrigger)
cfg.merge(cscdecodingAcc)
# Schedule RDO conversion
rpcdecodingAcc = RpcRDODecodeCfg(ConfigFlags)
cfg.merge(rpcdecodingAcc)
tgcdecodingAcc = TgcRDODecodeCfg(ConfigFlags)
cfg.merge(tgcdecodingAcc)
mdtdecodingAcc = MdtRDODecodeCfg(ConfigFlags)
cfg.merge(mdtdecodingAcc)
cscdecodingAcc = CscRDODecodeCfg(ConfigFlags)
cfg.merge(cscdecodingAcc)
cscbuildingAcc = CscClusterBuildCfg(ConfigFlags)
cfg.merge(cscbuildingAcc)
# Need to add POOL converter - may be a better way of doing this?
cfg.addService(CompFactory.AthenaPoolCnvSvc())
cfg.getService("EventPersistencySvc").CnvServices += ["AthenaPoolCnvSvc"]
log.info('Print Config')
cfg.printConfig(withDetails=True)
if forTrigger:
pklName = 'MuonRdoDecode_Cache.pkl'
else:
pklName = 'MuonRdoDecode.pkl'
# Store config as pickle
log.info('Save Config')
with open(pklName, 'wb') as f:
cfg.store(f)
f.close()
return cfg
def fromRunArgs(runArgs):
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior = True
from AthenaCommon.Logging import logging
logOverlay = logging.getLogger('Overlay')
logOverlay.info('****************** STARTING OVERLAY *****************')
logOverlay.info('**** Transformation run arguments')
logOverlay.info(str(runArgs))
logOverlay.info('**** Setting-up configuration flags')
from AthenaConfiguration.AllConfigFlags import ConfigFlags
commonRunArgsToFlags(runArgs, ConfigFlags)
hasRDO_BKGInput = hasattr(runArgs, 'inputRDO_BKGFile')
hasBS_SKIMInput = hasattr(runArgs, 'inputBS_SKIMFile')
if not hasattr(runArgs, 'inputHITSFile'):
raise RuntimeError('No input HITS file defined')
if hasRDO_BKGInput and hasBS_SKIMInput:
raise RuntimeError('Both RDO_BKG and BS_SKIM are defined')
if not hasRDO_BKGInput and not hasBS_SKIMInput:
raise RuntimeError('Define one of RDO_BKG and BS_SKIM file types')
if hasRDO_BKGInput:
logOverlay.info('Running MC+MC overlay')
ConfigFlags.Overlay.DataOverlay = False
ConfigFlags.Input.isMC = True
ConfigFlags.Input.Files = runArgs.inputRDO_BKGFile
ConfigFlags.Input.SecondaryFiles = runArgs.inputHITSFile
else:
logOverlay.info('Running MC+data overlay')
ConfigFlags.Overlay.DataOverlay = True
ConfigFlags.Input.isMC = False
ConfigFlags.Input.Files = runArgs.inputHITSFile
ConfigFlags.Input.SecondaryFiles = runArgs.inputBS_SKIMFile
if hasattr(runArgs, 'outputRDOFile'):
if runArgs.outputRDOFile == 'None':
ConfigFlags.Output.RDOFileName = ''
else:
ConfigFlags.Output.RDOFileName = runArgs.outputRDOFile
else:
raise RuntimeError('No output RDO file defined')
if hasattr(runArgs, 'outputRDO_SGNLFile'):
ConfigFlags.Output.RDO_SGNLFileName = runArgs.outputRDO_SGNLFile
# Autoconfigure enabled subdetectors
if hasattr(runArgs, 'detectors'):
detectors = runArgs.detectors
else:
detectors = None
# Setup digitization flags
from Digitization.DigitizationConfigFlags import digitizationRunArgsToFlags
digitizationRunArgsToFlags(runArgs, ConfigFlags)
# Setup common overlay flags
defaultOverlayFlags(ConfigFlags, detectors)
# Pre-exec
if hasattr(runArgs,
'preExec') and runArgs.preExec != 'NONE' and runArgs.preExec:
for cmd in runArgs.preExec:
exec(cmd)
# Pre-include
if hasattr(runArgs, 'preInclude') and runArgs.preInclude:
raise ValueError('preInclude not supported')
# TODO not parsed yet:
# '--fSampltag'
# '--triggerConfig'
# Lock flags
ConfigFlags.lock()
# Main overlay steering
from OverlayConfiguration.OverlaySteering import OverlayMainCfg
acc = OverlayMainCfg(ConfigFlags)
acc.merge(OverlayMessageSvcCfg(ConfigFlags))
# Post-include
if hasattr(runArgs, 'postInclude') and runArgs.postInclude:
from OverlayConfiguration.OverlayHelpers import accFromFragment
for fragment in runArgs.postInclude:
acc.merge(accFromFragment(fragment, ConfigFlags))
# Post-exec
if hasattr(runArgs,
'postExec') and runArgs.postExec != 'NONE' and runArgs.postExec:
for cmd in runArgs.postExec:
exec(cmd)
# Run the final accumulator
sc = acc.run()
sys.exit(not sc.isSuccess())
# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
from AthenaCommon import Logging
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
if __name__=="__main__":
# Setting needed for the ComponentAccumulator to do its thing
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior=True
# Set message levels
from AthenaCommon import Constants
msgLvl = "WARNING"
from AthenaCommon.Logging import log
log.setLevel(msgLvl)
# Config flags steer the job at various levels
from AthenaConfiguration.AllConfigFlags import ConfigFlags
ConfigFlags.Input.isMC = True
ConfigFlags.Input.Files = ["/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/ASG/mc16_13TeV.410501.PowhegPythia8EvtGen_A14_ttbar_hdamp258p75_nonallhad.merge.AOD.e5458_s3126_r9364_r9315/AOD.11182705._000001.pool.root.1"]
# Flags relating to multithreaded execution
nthreads=0
ConfigFlags.Concurrency.NumThreads =nthreads
if nthreads>0:
ConfigFlags.Concurrency.NumThreads = 1
ConfigFlags.Concurrency.NumConcurrentEvents = 1
ConfigFlags.MET.UseTracks = True
ConfigFlags.MET.DoPFlow = True
if ConfigFlags.Beam.Type == 'cosmics' or ConfigFlags.Beam.Type == 'singlebeam':# used to have " or not rec.doInDet()" on the end
def TPCnvTest(infile,
keys,
useGeoModelSvc=False,
useIOVDbSvc=False,
doPixel=False,
doSCT=False,
doTRT=False,
doLAr=False,
doTile=False,
doMuon=False):
# Make sure we don't have a stale file catalog.
if os.path.exists('PoolFileCatalog.xml'):
os.remove('PoolFileCatalog.xml')
if ('ATLAS_REFERENCE_TAG' not in globals()
and 'ATLAS_REFERENCE_TAG' in os.environ):
ATLAS_REFERENCE_TAG = os.environ['ATLAS_REFERENCE_TAG'] # noqa: F841
refpaths = [
os.environ.get('ATLAS_REFERENCE_DATA', None),
'/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art',
'/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/CommonInputs',
'/afs/cern.ch/atlas/maxidisk/d33/referencefiles'
]
if infile.startswith('rtt:'):
infile = infile[4:]
infile = find_file(infile, refpaths)
# Provide MC input
ConfigFlags.Input.Files = [infile]
ConfigFlags.GeoModel.AtlasVersion = 'ATLAS-R1-2012-03-01-00'
ConfigFlags.GeoModel.Align.Dynamic = False
ConfigFlags.Detector.GeometryPixel = doPixel
ConfigFlags.Detector.GeometrySCT = doSCT
ConfigFlags.Detector.GeometryTRT = doTRT
ConfigFlags.Detector.GeometryLAr = doLAr
ConfigFlags.Detector.GeometryTile = doTile
ConfigFlags.Detector.GeometryMuon = doMuon
ConfigFlags.lock()
# Construct ComponentAccumulator
acc = MainServicesCfg(ConfigFlags)
acc.merge(PoolReadCfg(ConfigFlags))
if useIOVDbSvc:
acc.merge(IOVDbSvcCfg(ConfigFlags))
if useGeoModelSvc:
if ConfigFlags.Detector.GeometryPixel:
acc.merge(PixelGeometryCfg(ConfigFlags))
useGeoModelSvc = True
if ConfigFlags.Detector.GeometrySCT:
acc.merge(SCT_GeometryCfg(ConfigFlags))
useGeoModelSvc = True
if ConfigFlags.Detector.GeometryTRT:
acc.merge(TRT_GeometryCfg(ConfigFlags))
useGeoModelSvc = True
if ConfigFlags.Detector.GeometryLAr:
acc.merge(LArGMCfg(ConfigFlags))
useGeoModelSvc = True
if ConfigFlags.Detector.GeometryTile:
acc.merge(TileGMCfg(ConfigFlags))
useGeoModelSvc = True
if ConfigFlags.Detector.GeometryMuon:
acc.merge(MuonGeoModelCfg(ConfigFlags))
useGeoModelSvc = True
#acc.merge(ForDetGeometryCfg(ConfigFlags))
acc.merge(GeoModelCfg(ConfigFlags))
acc.getService("GeoModelSvc").IgnoreTagDifference = True
acc.addEventAlgo(
Dumper('dumper', ConfigFlags.Input.Files[0], keys, refpaths),
'AthAlgSeq')
return acc.run(maxEvents=10)
