def _createCfgFlags():
acf = AthConfigFlags()
#Flags steering the job execution:
from AthenaCommon.Constants import INFO
acf.addFlag('Exec.OutputLevel', INFO) #Global Output Level
acf.addFlag('Exec.MaxEvents', -1)
acf.addFlag("Exec.SkipEvents", 0)
acf.addFlag("Exec.DebugStage", "")
#Flags describing the input data
acf.addFlag('Input.Files', [
"_ATHENA_GENERIC_INPUTFILE_NAME_",
]) # former global.InputFiles
acf.addFlag('Input.SecondaryFiles',
[]) # secondary input files for DoubleEventSelector
acf.addFlag('Input.isMC', lambda prevFlags: "IS_SIMULATION" in GetFileMD(
prevFlags.Input.Files).get("eventTypes", [])) # former global.isMC
acf.addFlag('Input.RunNumber', lambda prevFlags: list(
GetFileMD(prevFlags.Input.Files).get("runNumbers", []))
) # former global.RunNumber
acf.addFlag(
'Input.ProjectName',
lambda prevFlags: GetFileMD(prevFlags.Input.Files).get(
"project_name", "data17_13TeV")) # former global.ProjectName
acf.addFlag('Input.Format',
lambda prevFlags: GetFileMD(prevFlags.Input.Files).get(
"file_type", "")) # former global.InputFormat
def _inputCollections(inputFile):
if not inputFile:
return []
rawCollections = [
type_key[1]
for type_key in GetFileMD(inputFile).get("itemList", [])
]
collections = filter(lambda col: not col.endswith('Aux.'),
rawCollections)
return collections
acf.addFlag('Input.Collections',
lambda prevFlags: _inputCollections(prevFlags.Input.Files))
acf.addFlag(
'Input.SecondaryCollections',
lambda prevFlags: _inputCollections(prevFlags.Input.SecondaryFiles))
acf.addFlag('Concurrency.NumProcs', 0)
acf.addFlag('Concurrency.NumThreads', 0)
acf.addFlag('Concurrency.NumConcurrentEvents', 0)
acf.addFlag('Scheduler.CheckDependencies', True)
acf.addFlag('Scheduler.ShowDataDeps', True)
acf.addFlag('Scheduler.ShowDataFlow', True)
acf.addFlag('Scheduler.ShowControlFlow', True)
acf.addFlag(
'Common.isOnline', False
) # Job runs in an online environment (access only to resources available at P1) # former global.isOnline
acf.addFlag(
'Common.useOnlineLumi', lambda prevFlags: prevFlags.Common.isOnline
) # Use online version of luminosity. ??? Should just use isOnline?
acf.addFlag('Common.doExpressProcessing', False)
acf.addFlag('Common.bunchCrossingSource', lambda prevFlags: "MC"
if prevFlags.Input.isMC else "TrigConf"
) # what BunchCrossingTool should we use?
def _checkProject():
import os
if "AthSimulation_DIR" in os.environ:
return "AthSimulation"
if "AthGeneration_DIR" in os.environ:
return "AthGeneration"
#TODO expand this method.
return "Athena"
acf.addFlag('Common.Project', _checkProject())
# replace global.Beam*
acf.addFlag('Beam.BunchSpacing', 25) # former global.BunchSpacing
acf.addFlag('Beam.Type',
lambda prevFlags: GetFileMD(prevFlags.Input.Files).get(
'beam_type', 'collisions')) # former global.BeamType
acf.addFlag("Beam.NumberOfCollisions", lambda prevFlags: 2.
if prevFlags.Beam.Type == 'collisions' else 0.
) # former global.NumberOfCollisions
acf.addFlag('Beam.Energy',
lambda prevFlags: GetFileMD(prevFlags.Input.Files).get(
'beam_energy', 7 * TeV)) # former global.BeamEnergy
acf.addFlag('Beam.estimatedLuminosity', lambda prevFlags : ( 1E33*(prevFlags.Beam.NumberOfCollisions)/2.3 ) *\
(25./prevFlags.Beam.BunchSpacing)) # former flobal.estimatedLuminosity
acf.addFlag('Output.EVNTFileName', '')
acf.addFlag('Output.HITSFileName', '')
acf.addFlag('Output.RDOFileName', '')
acf.addFlag('Output.RDO_SGNLFileName', '')
acf.addFlag('Output.ESDFileName', '')
acf.addFlag('Output.AODFileName', '')
acf.addFlag('Output.HISTFileName', '')
acf.addFlag('Output.doWriteRDO', lambda prevFlags: bool(
prevFlags.Output.RDOFileName)) # write out RDO file
acf.addFlag('Output.doWriteRDO_SGNL', lambda prevFlags: bool(
prevFlags.Output.RDO_SGNLFileName)) # write out RDO_SGNL file
acf.addFlag('Output.doWriteESD', lambda prevFlags: bool(
prevFlags.Output.ESDFileName)) # write out ESD file
acf.addFlag('Output.doESD', lambda prevFlags: prevFlags.Output.doWriteESD
) # produce ESD containers
acf.addFlag('Output.doWriteAOD', lambda prevFlags: bool(
prevFlags.Output.AODFileName)) # write out AOD file
acf.addFlag('Output.doWriteBS', False) # write out RDO ByteStream file
# Might move this elsewhere in the future.
# Some flags from https://gitlab.cern.ch/atlas/athena/blob/master/Tracking/TrkDetDescr/TrkDetDescrSvc/python/TrkDetDescrJobProperties.py
# (many, e.g. those that set properties of one tool are not needed)
acf.addFlag('TrackingGeometry.MagneticFileMode', 6)
acf.addFlag('TrackingGeometry.MaterialSource',
'COOL') # Can be COOL, Input or None
#Detector Flags:
def __detector():
from AthenaConfiguration.DetectorConfigFlags import createDetectorConfigFlags
return createDetectorConfigFlags()
acf.addFlagsCategory("Detector", __detector)
#Simulation Flags:
def __simulation():
from G4AtlasApps.SimConfigFlags import createSimConfigFlags
return createSimConfigFlags()
_addFlagsCategory(acf, "Sim", __simulation, 'G4AtlasApps')
#Digitization Flags:
def __digitization():
from Digitization.DigitizationConfigFlags import createDigitizationCfgFlags
return createDigitizationCfgFlags()
_addFlagsCategory(acf, "Digitization", __digitization, 'Digitization')
#Overlay Flags:
def __overlay():
from OverlayConfiguration.OverlayConfigFlags import createOverlayConfigFlags
return createOverlayConfigFlags()
_addFlagsCategory(acf, "Overlay", __overlay, 'OverlayConfiguration')
#Geo Model Flags:
def __geomodel():
from AthenaConfiguration.GeoModelConfigFlags import createGeoModelConfigFlags
return createGeoModelConfigFlags()
acf.addFlagsCategory("GeoModel", __geomodel)
#IOVDbSvc Flags:
acf.addFlag(
"IOVDb.GlobalTag",
lambda prevFlags: GetFileMD(prevFlags.Input.Files).get(
"IOVDbGlobalTag", None) or "CONDBR2-BLKPA-2017-05")
from IOVDbSvc.IOVDbAutoCfgFlags import getDatabaseInstanceDefault
acf.addFlag("IOVDb.DatabaseInstance", getDatabaseInstanceDefault)
def __bfield():
from MagFieldConfig.BFieldConfigFlags import createBFieldConfigFlags
return createBFieldConfigFlags()
_addFlagsCategory(acf, "BField", __bfield, 'MagFieldConfig')
def __lar():
from LArConfiguration.LArConfigFlags import createLArConfigFlags
return createLArConfigFlags()
_addFlagsCategory(acf, "LAr", __lar, 'LArConfiguration')
def __tile():
from TileConfiguration.TileConfigFlags import createTileConfigFlags
return createTileConfigFlags()
_addFlagsCategory(acf, 'Tile', __tile, 'TileConfiguration')
def __calo():
from CaloRec.CaloConfigFlags import createCaloConfigFlags
return createCaloConfigFlags()
_addFlagsCategory(acf, 'Calo', __calo, 'CaloRec')
#Random engine Flags:
acf.addFlag(
"Random.Engine",
"dSFMT") # Random service used in {"dSFMT", "Ranlux64", "Ranecu"}
def __trigger():
from TriggerJobOpts.TriggerConfigFlags import createTriggerFlags
return createTriggerFlags()
_addFlagsCategory(acf, "Trigger", __trigger, 'TriggerJobOpts')
def __indet():
from InDetConfig.InDetConfigFlags import createInDetConfigFlags
return createInDetConfigFlags()
_addFlagsCategory(acf, "InDet", __indet, 'InDetConfig')
def __muon():
from MuonConfig.MuonConfigFlags import createMuonConfigFlags
return createMuonConfigFlags()
_addFlagsCategory(acf, "Muon", __muon, 'MuonConfig')
def __muoncombined():
from MuonCombinedConfig.MuonCombinedConfigFlags import createMuonCombinedConfigFlags
return createMuonCombinedConfigFlags()
_addFlagsCategory(acf, "MuonCombined", __muoncombined,
'MuonCombinedConfig')
def __egamma():
from egammaConfig.egammaConfigFlags import createEgammaConfigFlags
return createEgammaConfigFlags()
_addFlagsCategory(acf, "Egamma", __egamma, 'egammaConfig')
def __met():
from METReconstruction.METConfigFlags import createMETConfigFlags
return createMETConfigFlags()
_addFlagsCategory(acf, "MET", __met, 'METReconstruction')
def __pflow():
from eflowRec.PFConfigFlags import createPFConfigFlags
return createPFConfigFlags()
_addFlagsCategory(acf, "PF", __pflow, 'eflowRec')
def __btagging():
from BTagging.BTaggingConfigFlags import createBTaggingConfigFlags
return createBTaggingConfigFlags()
_addFlagsCategory(acf, "BTagging", __btagging, 'BTagging')
def __dq():
from AthenaMonitoring.DQConfigFlags import createDQConfigFlags
dqf = createDQConfigFlags()
return dqf
_addFlagsCategory(acf, "DQ", __dq, 'AthenaMonitoring')
def __perfmon():
from PerfMonComps.PerfMonConfigFlags import createPerfMonConfigFlags
return createPerfMonConfigFlags()
_addFlagsCategory(acf, "PerfMon", __perfmon, 'PerfMonComps')
return acf
def createTriggerFlags():
flags = AthConfigFlags()
# enables L1 simulation
flags.addFlag('Trigger.doLVL1', lambda prevFlags: prevFlags.Input.isMC)
# enables L1 topological trigger simulation
flags.addFlag('Trigger.doL1Topo', True)
# writes additional info from Topo simulation
flags.addFlag('Trigger.writeL1TopoValData', True)
# need proper documentation
flags.addFlag('Trigger.useL1CaloCalibration', False)
# need proper documentation
flags.addFlag('Trigger.useRun1CaloEnergyScale', False)
# enable HLT part of the trigger
flags.addFlag('Trigger.doHLT', True)
# changes decoding of L1 so that allways all configured chains are enabled, testing mode
flags.addFlag("Trigger.L1Decoder.forceEnableAllChains", False)
# Enable Run-3 LVL1 simulation and/or decoding
flags.addFlag('Trigger.enableL1Phase1', False)
# Enable usage of new L1 menu
flags.addFlag('Trigger.readLVL1FromJSON', True)
# Enable Run-2 L1Calo simulation and/or decoding (possible even if enablePhase1 is True)
flags.addFlag('Trigger.enableL1CaloLegacy', True)
# Enable Inner Detector
flags.addFlag('Trigger.doID', True)
# Enable muon system
flags.addFlag('Trigger.doMuon', True)
# Enable calorimeters
flags.addFlag('Trigger.doCalo', True)
# if 1, Run1 decoding version is set; if 2, Run2; if 3, Run 3
def EDMDecodingVersion(flags):
log.debug("Attempting to determine EDMDecodingVersion.")
version = 3
if flags.Input.Format == "BS":
log.debug("EDMDecodingVersion: Input format is ByteStream")
inputFileName = flags.Input.Files[0]
if not inputFileName and flags.Common.isOnline():
log.debug(
"EDMDecodingVersion: Online reconstruction, no input file. Return default version, i.e. AthenaMT."
)
return version
log.debug("EDMDecodingVersion: Checking ROD version.")
import eformat
from libpyeformat_helper import SubDetector
bs = eformat.istream(inputFileName)
rodVersionM = -1
rodVersionL = -1
# Find the first HLT ROBFragment in the first event
for robf in bs[0]:
if robf.rob_source_id().subdetector_id(
) == SubDetector.TDAQ_HLT:
rodVersionM = robf.rod_minor_version() >> 8
rodVersionL = robf.rod_minor_version() & 0xFF
log.debug(
"EDMDecodingVersion: HLT ROD minor version from input file is {:d}.{:d}"
.format(rodVersionM, rodVersionL))
break
if rodVersionM >= 1:
version = 3
return version
log.info(
"EDMDecodingVersion: Could not determine ROD version -- falling back to run-number-based determination"
)
# Use run number to determine decoding version
runNumber = flags.Input.RunNumber[0]
log.debug(
"EDMDecodingVersion: Read run number {}.".format(runNumber))
boundary_run12 = 230000
boundary_run23 = 368000
if runNumber <= 0:
log.warning(
"EDMDecodingVersion: Cannot determine decoding version because run number {} is invalid. Leaving the default version."
.format(runNumber))
elif runNumber < boundary_run12:
# Run-1 data
version = 1
elif runNumber < boundary_run23:
# Run-2 data
version = 2
else:
# Run-3 data
version = 3
else:
log.debug(
"EDMDecodingVersion: Input format is POOL -- determine from input file collections."
)
# POOL files: decide based on HLT output type present in file
if "HLTResult_EF" in flags.Input.Collections:
version = 1
elif "TrigNavigation" in flags.Input.Collections:
version = 2
elif "HLTNav_Summary" in flags.Input.Collections:
version = 3
elif flags.Input.Format == "POOL":
# If running Trigger on RDO input (without previous trigger result), choose Run-3
version = 3
log.info("Determined EDMDecodingVersion to be {}.".format({
1: "Run 1",
2: "Run 2",
3: "AthenaMT"
}[version]))
return version
flags.addFlag('Trigger.EDMDecodingVersion',
lambda prevFlags: EDMDecodingVersion(prevFlags))
# enables additional algorithms colecting MC truth infrmation (this is only used by IDso maybe we need Trigger.ID.doTruth only?)
flags.addFlag('Trigger.doTruth', False)
# only enable services for analysis and BS -> ESD processing (we need better name)
flags.addFlag('Trigger.doTriggerConfigOnly', False)
# Enables collection and export of detailed monitoring data of the HLT execution
flags.addFlag('Trigger.CostMonitoring.doCostMonitoring', False)
flags.addFlag('Trigger.CostMonitoring.chain',
'HLT_costmonitor_CostMonDS_L1All')
flags.addFlag('Trigger.CostMonitoring.outputCollection',
'HLT_TrigCostContainer')
flags.addFlag('Trigger.CostMonitoring.monitorAllEvents', False)
# enable Bcm inputs simulation
flags.addFlag('Trigger.L1.doBcm', True)
# enable muon inputs simulation
flags.addFlag('Trigger.L1.doMuons', True)
# version of CTP data, int value up to 4
flags.addFlag('Trigger.L1.CTPVersion', 4)
# list of thresholds (not sure if we want to use new flags to generate L1, leaving out for now?)
# partition name used to determine online vs offline BS result writing
import os
flags.addFlag('Trigger.Online.partitionName',
os.getenv('TDAQ_PARTITION') or '')
# shortcut to check if job is running in a partition (i.e. partition name is not empty)
flags.addFlag(
'Trigger.Online.isPartition',
lambda prevFlags: len(prevFlags.Trigger.Online.partitionName) > 0)
# write BS output file
flags.addFlag('Trigger.writeBS', False)
# Write transient BS before executing HLT algorithms (for running on MC RDO with clients which require BS inputs)
flags.addFlag('Trigger.doTransientByteStream', False)
# list of EDM objects to be written to AOD
flags.addFlag('Trigger.AODEDMSet', 'AODSLIM')
# list of objects to be written to ESD
flags.addFlag('Trigger.ESDEDMSet', 'ESD')
# tag to be used for condutions used by HLT code
flags.addFlag('Trigger.OnlineCondTag', 'CONDBR2-HLTP-2018-01')
# geometry version used by HLT online
flags.addFlag('Trigger.OnlineGeoTag', 'ATLAS-R2-2016-01-00-01')
# configuration tune for various years of Run2 (why string?)
flags.addFlag('Trigger.run2Config', '2018')
# comissionig options
# one of: 'HltOnly',
# 'Lvl1Only',
# 'FullTrigger',
# 'NoTrigger'
flags.addFlag('Trigger.dataTakingConditions', 'FullTrigger')
# use or not frontier proxies
flags.addFlag('Trigger.triggerUseFrontier', False)
# the configuration source
# see https://twiki.cern.ch/twiki/bin/view/Atlas/TriggerConfigFlag
flags.addFlag('Trigger.triggerConfig', 'FILE')
# name of the trigger menu
flags.addFlag('Trigger.triggerMenuSetup', 'LS2_v1')
# name of the trigger menu
flags.addFlag('Trigger.generateMenuDiagnostics', False)
# version of the menu
from AthenaCommon.AppMgr import release_metadata
flags.addFlag('Trigger.menuVersion',
lambda prevFlags: release_metadata()['release'])
# generate or not the HLT configuration
flags.addFlag('Trigger.generateHLTMenu', False)
# HLT XML file name
flags.addFlag(
'Trigger.HLTMenuFile', lambda prevFlags: 'HLTMenu_' + prevFlags.Trigger
.triggerMenuSetup + '_' + prevFlags.Trigger.menuVersion + '.xml')
# generate or not the L1 configuration
flags.addFlag('Trigger.generateL1Menu', False)
def _deriveL1ConfigName(prevFlags):
import re
log = logging.getLogger('TrigConfigSvcCfg')
pattern = re.compile(r'_v\d+|DC14')
menuName = prevFlags.Trigger.triggerMenuSetup
patternPos = pattern.search(menuName)
if patternPos:
menuName = menuName[:patternPos.end()]
else:
log.info(
'Can\'t find pattern to shorten menu name, either non-existent in name or not implemented.'
)
return "LVL1config_" + menuName + "_" + prevFlags.Trigger.menuVersion + ".xml"
# L1 XML file name
flags.addFlag('Trigger.LVL1ConfigFile', _deriveL1ConfigName)
# L1 Json file name
flags.addFlag(
'Trigger.L1MenuFile', lambda prevFlags: 'L1Menu_' + prevFlags.Trigger.
triggerMenuSetup + '_' + prevFlags.Trigger.menuVersion + '.json')
# L1 topo XML file name
def _deriveTopoConfigName(prevFlags):
import re
menuSetup = prevFlags.Trigger.triggerMenuSetup
m = re.match(r'(.*v\d).*', menuSetup)
if m:
menuSetup = m.groups()[0]
return "L1Topoconfig_" + menuSetup + "_" + prevFlags.Trigger.menuVersion + ".xml"
flags.addFlag('Trigger.LVL1TopoConfigFile', _deriveTopoConfigName)
# trigger reconstruction
# enables the correction for pileup in cell energy calibration (should it be moved to some place where other calo flags are defined?)
flags.addFlag('Trigger.calo.doOffsetCorrection', True)
# helper to switch between versions
def __tunes(default, ver2016, ver2017):
from collections import defaultdict
return lambda year: defaultdict(lambda: default, (
('2016', ver2016), ('2017', ver2017)))[year]
# Particle ID tune
flags.addFlag(
'Trigger.egamma.pidVersion', lambda prevFlags: __tunes(
default='ElectronPhotonSelectorTools/trigger/rel21_mc16a/',
ver2016='ElectronPhotonSelectorTools/trigger/rel21_mc16a/',
ver2017='ElectronPhotonSelectorTools/trigger/rel21_20170214/')
(prevFlags.Trigger.run2Config))
# cluster correction version, allowed value is: None or v12phiflip_noecorrnogap
flags.addFlag(
'Trigger.egamma.clusterCorrectionVersion', lambda prevFlags: __tunes(
default=None, ver2016=None, ver2017='v12phiflip_noecorrnogap')
(prevFlags.Trigger.run2Config))
# tune of MVA
flags.addFlag(
'Trigger.egamma.calibMVAVersion',
lambda prevFlags: __tunes(default='egammaMVACalib/online/v3',
ver2016='egammaMVACalib/online/v3',
ver2017='egammaMVACalib/online/v6')
(prevFlags.Trigger.run2Config))
# muons
flags.addFlag('Trigger.muon.doEFRoIDrivenAccess', False)
# muon offline reco flags varaint for trigger
def __muon():
from MuonConfig.MuonConfigFlags import createMuonConfigFlags
return createMuonConfigFlags()
flags.addFlagsCategory('Trigger.Offline', __muon, prefix=True)
from TriggerJobOpts.MenuConfigFlags import createMenuFlags
flags.join(createMenuFlags())
return flags