def runTest(self):
"""... Check if year dependent flags propagate the info correctly"""
from AthenaConfiguration.AllConfigFlags import ConfigFlags as flags
flags.Trigger.run2Config = '2017'
self.assertEqual(flags.Trigger.egamma.clusterCorrectionVersion,
"v12phiflip_noecorrnogap",
" dependent flag setting does not work")
flags.dump()
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 test_TriggerFlags(sample):
from AthenaConfiguration.AllConfigFlags import ConfigFlags
acf = ConfigFlags.clone()
acf.Input.Files = [inputfiles[sample]]
acf.addFlagsCategory("Trigger", createTriggerFlags)
# Test EDMDecodingVersion
EDMDecode_ref = {"Run1": 1, "Run2": 2, "Run3": 3}[sample[:4]]
log.info("EDMDecodingVersion: expected {}, configured {}".format(
EDMDecode_ref, acf.Trigger.EDMDecodingVersion))
assert (acf.Trigger.EDMDecodingVersion == EDMDecode_ref)
return
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
def runTest(self):
"""... Check if offline reco flags can be added to trigger"""
from AthenaConfiguration.AllConfigFlags import ConfigFlags as flags
flags.Trigger.Offline.Muon.doMDTs = False
flags.Muon.doMDTs = True
self.assertEqual(flags.Trigger.Offline.Muon.doMDTs, False,
" dependent flag setting does not work")
self.assertEqual(flags.Muon.doMDTs, True,
" dependent flag setting does not work")
newflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon')
self.assertEqual(flags.Muon.doMDTs, True,
" dependent flag setting does not work")
self.assertEqual(newflags.Muon.doMDTs, False,
" dependent flag setting does not work")
newflags.dump()
alg = BunchGroupCondAlg(name,
BunchGroupFolderInputKey=folder,
BunchGroupOutputKey='BunchGroupCondData')
result.addCondAlgo(alg)
return result
if __name__ == "__main__":
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior = 1
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from AthenaConfiguration.TestDefaults import defaultTestFiles
ConfigFlags.Input.Files = defaultTestFiles.RAW
ConfigFlags.lock()
print('--- data')
flags1 = ConfigFlags.clone()
flags1.Input.Files = defaultTestFiles.RAW
flags1.Input.ProjectName = 'data12_8TeV'
flags1.lock()
acc1 = BunchGroupCondAlgCfg(flags1)
acc1.printCondAlgs(summariseProps=True)
print('IOVDbSvc:', acc1.getService('IOVDbSvc').Folders)
acc1.wasMerged()
print('--- default')
flags2 = ConfigFlags.clone()
flags2.Input.Files = defaultTestFiles.RAW
flags2.lock()
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
BunchLumisCondAlg = CompFactory.BunchLumisCondAlg
alg = BunchLumisCondAlg(name,
BunchLumisFolderInputKey=folder,
FillParamsInputKey=fpalg.FillParamsOutputKey,
BunchLumisOutputKey='BunchLumisCondData')
result.addCondAlgo(alg)
return result
if __name__ == "__main__":
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior = 1
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from AthenaConfiguration.TestDefaults import defaultTestFiles
ConfigFlags.loadAllDynamicFlags()
print('--- data')
flags1 = ConfigFlags.clone()
flags1.Input.Files = defaultTestFiles.RAW
flags1.Input.ProjectName = 'data12_8TeV'
flags1.lock()
acc1 = BunchLumisCondAlgCfg(flags1)
acc1.printCondAlgs(summariseProps=True)
print('IOVDbSvc:', acc1.getService('IOVDbSvc').Folders)
acc1.wasMerged()
print('--- data+overlay')
flags2 = ConfigFlags.clone()
flags2.Input.Files = defaultTestFiles.RAW
flags2.Input.ProjectName = 'data12_8TeV'
if __name__ == "__main__":
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior = True
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from AthenaConfiguration.TestDefaults import defaultTestFiles
from AthenaCommon.Logging import log
from AthenaCommon.Constants import DEBUG
# Test setup
log.setLevel(DEBUG)
ConfigFlags.Input.Files = defaultTestFiles.RAW
ConfigFlags.fillFromArgs()
ConfigFlags.Output.ESDFileName = "myESD.pool.root"
ConfigFlags.lock()
# Construct our accumulator to run
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
acc = MainServicesCfg(ConfigFlags)
from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
acc.merge(
ByteStreamReadCfg(ConfigFlags,
["TileRawChannelContainer/TileRawChannelCnt"]))
acc.merge(TileRawChannelToL2OutputCfg(ConfigFlags, streamName='ESD'))
acc.getService('StoreGateSvc').Dump = True
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())
parser.add_argument('flags', nargs='*', help='Config flag overrides')
args = parser.parse_args()
# Setup the Run III behavior
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior = 1
# Set the Athena configuration flags
from AthenaConfiguration.AllConfigFlags import ConfigFlags
# Set the Athena configuration flags
ConfigFlags.Input.Files = [
"root://eosatlas.cern.ch//eos/atlas/atlasdatadisk/rucio/data16_13TeV/8d/de/AOD.10654269._000566.pool.root.1"
]
ConfigFlags.fillFromArgs(args.flags)
from PyUtils import AthFile
af = AthFile.fopen(ConfigFlags.Input.Files[0])
isMC = ('IS_SIMULATION' in af.fileinfos['evt_type'])
runNumber = af.fileinfos['run_number'][0]
ConfigFlags.Input.isMC = isMC
useBunchCrossingTool = (args.doRatesVsPositionInTrain
or args.vetoStartOfTrain > 0)
ConfigFlags.lock()
# Initialize configuration object, add accumulator, merge, and run.
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
from AthenaConfiguration.ComponentFactory import CompFactory
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
acc.merge(OutputStreamCfg(ConfigFlags, "HITS", ItemList=ItemList))
return acc
if __name__ == "__main__":
from AthenaCommon.Logging import log
from AthenaCommon.Constants import DEBUG
from AthenaCommon.Configurable import Configurable
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from SimulationFlags import ConfigFlagsSimulation
ConfigFlags.join(ConfigFlagsSimulation)
# Set up logging and config behaviour
log.setLevel(DEBUG)
Configurable.configurableRun3Behavior = 1
import os
inputDir = os.environ.get(
'ATLAS_REFERENCE_DATA',
'/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art')
# Provide input
ConfigFlags.Input.Files = [
inputDir + "/SimCoreTests/e_E50_eta34_49.EVNT.pool.root"
]
# Specify output
ConfigFlags.Output.HITSFileName = "myHITS.pool.root"
result.merge(TileGMCfg(configFlags))
from CaloTools.CaloEstimatedGainToolConfig import CaloEstimatedGainToolCfg
acc = CaloEstimatedGainToolCfg(configFlags)
acc.popPrivateTools()
result.merge(acc)
result.addEventAlgo(TestAlg('TestAlg'))
return result
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior = 1
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from AthenaConfiguration.TestDefaults import defaultTestFiles
ConfigFlags.Input.Files = defaultTestFiles.RDO
ConfigFlags.Detector.GeometryLAr = True
ConfigFlags.Detector.GeometryTile = True
ConfigFlags.needFlagsCategory('Tile')
ConfigFlags.needFlagsCategory('LAr')
ConfigFlags.lock()
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
acc = MainServicesCfg(ConfigFlags)
acc.merge(testCfg(ConfigFlags))
acc.run(1)
#!/usr/bin/env python
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from __future__ import print_function
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from AthenaConfiguration.TestDefaults import defaultTestFiles
ConfigFlags.Input.Files = defaultTestFiles.RDO
ConfigFlags._loadDynaFlags("Detector")
# Don't fail just because G4AtlasApps isn't present in this build.
havesim = True
try:
import G4AtlasApps # noqa: F401
except ImportError:
havesim = False
if havesim:
ConfigFlags._loadDynaFlags("Sim")
# Don't fail just because Digitization isn't present in this build.
haveDigi = True
try:
import Digitization # noqa: F401
except ImportError:
haveDigi = False
if haveDigi:
ConfigFlags._loadDynaFlags("Digitization")
# Don't fail just because OverlayConfiguration isn't present in this build.
haveOverlay = True
try:
import OverlayConfiguration # noqa: F401
# ConfigFlags.lock()
## Initialize a new component accumulator
cfg = MainServicesCfg(ConfigFlags)
from G4AtlasTools.G4FieldConfigNew import ATLASFieldManagerToolCfg, TightMuonsATLASFieldManagerToolCfg, Q1FwdFieldManagerToolCfg
#add the algorithm
acc1 = ATLASFieldManagerToolCfg(ConfigFlags)
acc2 = TightMuonsATLASFieldManagerToolCfg(ConfigFlags)
cfg.popToolsAndMerge(acc1)
cfg.popToolsAndMerge(acc2)
#don't run for simulation only tests (todo - make new general test)
import os
if not "AthSimulation_DIR" in os.environ:
acc3 = Q1FwdFieldManagerToolCfg(ConfigFlags)
cfg.popToolsAndMerge(acc3)
# Dump config
#cfg.getService("StoreGateSvc").Dump = True
#cfg.getService("ConditionStore").Dump = True
cfg.printConfig(withDetails=True, summariseProps=True)
ConfigFlags.dump()
f = open("test.pkl", "wb")
cfg.store(f)
f.close()
print("-----------------finished----------------------")
from FastCaloSim.AddNoiseCellBuilderToolConfig import AddNoiseCellBuilderToolCfg
acc = AddNoiseCellBuilderToolCfg(configFlags)
acc.popPrivateTools()
result.merge(acc)
result.addEventAlgo(TestAlg('TestAlg'))
return result
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior = 1
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from AthenaConfiguration.TestDefaults import defaultTestFiles
ConfigFlags.Input.Files = defaultTestFiles.RDO
ConfigFlags.addFlag("Input.InitialTimeStamp", 1000)
ConfigFlags.Detector.GeometryLAr = True
ConfigFlags.Detector.GeometryTile = True
ConfigFlags.needFlagsCategory('Tile')
ConfigFlags.needFlagsCategory('LAr')
ConfigFlags.lock()
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
acc = MainServicesCfg(ConfigFlags)
from McEventSelector.McEventSelectorConfig import McEventSelectorCfg
acc.merge(McEventSelectorCfg(ConfigFlags))
acc.merge(testCfg(ConfigFlags))
acc.run(1)
result = ComponentAccumulator()
from IOVDbSvc.CondDB import conddb # noqa: F401
folder = "/TRIGGER/LUMI/LBLB"
result.merge (addFolders (configFlags, folder, 'TRIGGER',
className = 'AthenaAttributeList'))
LBDurationCondAlg=CompFactory.LBDurationCondAlg
alg = LBDurationCondAlg (name,
LBLBFolderInputKey = folder,
LBDurationOutputKey = 'LBDurationCondData')
result.addCondAlgo (alg)
return result
if __name__ == "__main__":
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior=1
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from AthenaConfiguration.TestDefaults import defaultTestFiles
print ('--- data')
flags1 = ConfigFlags.clone()
flags1.Input.Files = defaultTestFiles.RAW
flags1.lock()
acc1 = LBDurationCondAlgCfg (flags1)
acc1.printCondAlgs(summariseProps=True)
print ('IOVDbSvc:', acc1.getService('IOVDbSvc').Folders)
acc1.wasMerged()
def _getTimingType(prevFlags):
# Tile timing types: PHY, LAS, GAP/LAS, CIS
timingType = {
'PHY': 'PHY',
'PED': 'PHY',
'LAS': 'LAS',
'BILAS': 'LAS',
'GAPLAS': 'GAP/LAS',
'CIS': 'CIS',
'MONOCIS': 'CIS'
}
return timingType.get(prevFlags.Tile.RunType, 'UNDEFINED')
if __name__ == "__main__":
import sys
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from AthenaConfiguration.TestDefaults import defaultTestFiles
ConfigFlags.Input.Files = defaultTestFiles.RAW
if len(sys.argv) > 1:
ConfigFlags.fillFromArgs()
ConfigFlags.lock()
ConfigFlags.needFlagsCategory('Tile')
ConfigFlags.initAll()
ConfigFlags.dump()
if __name__ == "__main__":
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior = True
from AthenaConfiguration.AllConfigFlags import ConfigFlags as cfgFlags
#cfgFlags.Input.Files=["myESD.pool.root"]
cfgFlags.Input.Files = [
"/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/RecExRecoTest/mc16_13TeV.361022.Pythia8EvtGen_A14NNPDF23LO_jetjet_JZ2W.recon.ESD.e3668_s3170_r10572_homeMade.pool.root"
]
#
cfgFlags.Calo.TopoCluster.doTopoClusterLocalCalib = False
#
cfgFlags.addFlag("eflowRec.TrackColl", "InDetTrackParticles")
cfgFlags.addFlag("eflowRec.VertexColl", "PrimaryVertices")
cfgFlags.addFlag("eflowRec.RawClusterColl", "CaloTopoClusters")
cfgFlags.addFlag("eflowRec.CalClusterColl", "CaloCalTopoClustersNew")
#PF flags
cfgFlags.PF.useUpdated2015ChargedShowerSubtraction = True
cfgFlags.PF.addClusterMoments = False
cfgFlags.PF.useClusterMoments = False
#
# Try to get around TRT alignment folder problem in MC
cfgFlags.GeoModel.Align.Dynamic = False
#
cfgFlags.lock()
ToolConstantsCondAlgCfg(
configFlags,
'CaloSwClusterCorrections.rfac-v5',
DetStoreKey='CaloSwClusterCorrections.rfac-v5'))
CaloClusterCorrDumper = CompFactory.CaloClusterCorrDumper # CaloRec
alg = CaloClusterCorrDumper(
'dumper1',
Constants=['deadOTXCorrCtes', 'CaloSwClusterCorrections.rfac-v5'])
result.addEventAlgo(alg)
return result
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior = 1
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from AthenaConfiguration.TestDefaults import defaultTestFiles
ConfigFlags.Input.Files = defaultTestFiles.RDO
ConfigFlags.addFlag("Input.InitialTimeStamp", 1000)
ConfigFlags.lock()
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
acc = MainServicesCfg(ConfigFlags)
from McEventSelector.McEventSelectorConfig import McEventSelectorCfg
acc.merge(McEventSelectorCfg(ConfigFlags))
acc.merge(testCfg(ConfigFlags))
acc.run(1)
#!/usr/bin/env python
#
# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
#
'''@file DQTestingDriver.py
@author C. D. Burton
@author P. Onyisi
@date 2019-06-20
@brief Driver script to run DQ with new-style configuration on an ESD/AOD
'''
if __name__ == '__main__':
import sys
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from argparse import ArgumentParser
parser = ConfigFlags.getArgumentParser()
parser.add_argument('--preExec',
help='Code to execute before locking configs')
parser.add_argument('--postExec', help='Code to execute after setup')
parser.add_argument(
'--dqOffByDefault',
action='store_true',
help=
'Set all DQ steering flags to False, user must then switch them on again explicitly'
)
# keep for compatibility reasons
parser.add_argument(
'--inputFiles',
help='Comma-separated list of input files (alias for --filesInput)')
# keep for compatibility reasons
parser.add_argument(
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
from AthenaCommon.Logging import log
from AthenaCommon.Constants import INFO #DEBUG
log.setLevel(INFO)
# set input file and config options
from AthenaConfiguration.AllConfigFlags import ConfigFlags
import glob
inputs = glob.glob(
'/eos/atlas/atlascerngroupdisk/data-art/build-output/master/Athena/x86_64-centos7-gcc8-opt/2020-04-06T2139/TrigP1Test/test_trigP1_v1PhysP1_T0Mon_build/ESD.pool.root'
)
ConfigFlags.Input.Files = inputs
ConfigFlags.Output.HISTFileName = 'ExampleMonitorOutput_LVL1.root'
ConfigFlags.lock()
ConfigFlags.dump() # print all the configs
from AthenaCommon.AppMgr import ServiceMgr
ServiceMgr.Dump = False
from AthenaConfiguration.MainServicesConfig import MainServicesSerialCfg
from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
cfg = MainServicesSerialCfg()
cfg.merge(PoolReadCfg(ConfigFlags))
PprMonitorCfg = PprMonitoringConfig(ConfigFlags)
cfg.merge(PprMonitorCfg)
# message level for algorithm
PprMonitorCfg.getEventAlgo('PprMonAlg').OutputLevel = 2 # 1/2 INFO/DEBUG
# Output configuration - currently testing offline workflow
flags.Trigger.writeBS = False
flags.Output.doWriteRDO = True
flags.Output.RDOFileName = 'RDO_TRIG.pool.root'
flags.Trigger.CostMonitoring.doCostMonitoring = True
import importlib
setupMenuPath = "TriggerMenuMT.HLTMenuConfig.Menu." + flags.Trigger.triggerMenuSetup + "_newJO"
setupMenuModule = importlib.import_module(setupMenuPath)
assert setupMenuModule is not None, "Could not import module {}".format(
setupMenuPath)
assert setupMenuModule.setupMenu is not None, "Could not import setupMenu from {}".format(
setupMenuPath)
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()
ToolConstantsCondAlg = CompFactory.ToolConstantsCondAlg # CaloRec
alg = ToolConstantsCondAlg(name,
COOLFolderKey=COOLFolder,
ToolConstantsKey=key,
DetStoreKey=DetStoreKey)
result.addCondAlgo(alg)
return result
if __name__ == "__main__":
from AthenaCommon.Configurable import Configurable
Configurable.configurableRun3Behavior = 1
from AthenaConfiguration.AllConfigFlags import ConfigFlags
ConfigFlags.loadAllDynamicFlags()
flags = ConfigFlags.clone()
flags.lock()
print('--- detstore')
acc1 = ToolConstantsCondAlgCfg(flags, 'key1', DetStoreKey='ds1')
acc1.printConfig(summariseProps=True)
acc1.wasMerged()
print('--- cool')
acc2 = ToolConstantsCondAlgCfg(flags, 'key2', COOLFolder='folder2')
acc2.printConfig(summariseProps=True)
acc2.wasMerged()
print('--- error')
from LArMonitoring.LArMonConfigFlags import createLArMonConfigFlags
createLArMonConfigFlags()
ConfigFlags.Input.Files = ["/eos/atlas/atlastier0/rucio/data20_calib/calibration_LArElec-Delay-32s-Medium-Em/00374740/data20_calib.00374740.calibration_LArElec-Delay-32s-Medium-Em.daq.RAW/data20_calib.00374740.calibration_LArElec-Delay-32s-Medium-Em.daq.RAW._lb0000._SFO-2._0001.data"]
ConfigFlags.Output.HISTFileName = 'LArCalibMonOutput.root'
ConfigFlags.DQ.enableLumiAccess = False
ConfigFlags.DQ.useTrigger = False
ConfigFlags.Beam.Type = 'collisions'
ConfigFlags.DQ.DataType = 'collisions'
ConfigFlags.AtlasVersion = 'ATLAS-R2-2016-01-00-01'
ConfigFlags.Detector.GeometryCSC=False
ConfigFlags.Detector.GeometrysTGC=False
ConfigFlags.Detector.GeometryMM=False
ConfigFlags.lock()
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
cfg = MainServicesCfg(ConfigFlags)
from LArByteStream.LArRawCalibDataReadingConfig import LArRawCalibDataReadingCfg
cfg.merge(LArRawCalibDataReadingCfg(ConfigFlags,gain="MEDIUM",doAccCalibDigit=True))
cfg.merge(LArCalibMonConfig(ConfigFlags, gain="MEDIUM",doAccCalibDigit=True))
cfg.printConfig()
ConfigFlags.dump()
f=open("LArCalibPedMon.pkl","w")
cfg.store(f)
f.close()
#!/usr/bin/env python
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from __future__ import print_function
from AthenaConfiguration.AllConfigFlags import ConfigFlags
from AthenaConfiguration.TestDefaults import defaultTestFiles
ConfigFlags.Input.Files = defaultTestFiles.HITS
ConfigFlags._loadDynaFlags("Detector")
# Don't fail just because G4AtlasApps isn't present in this build.
havesim = True
try:
import G4AtlasApps # noqa: F401
except ImportError:
havesim = False
if havesim:
ConfigFlags._loadDynaFlags("Sim")
ConfigFlags.initAll()
ConfigFlags.dump()
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
# 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
