def checkInput(self):
self.checkFileMetaData()
log = logging.getLogger( "TriggerConfigGetter.py" )
if "ReadPool" in self._environment or "WritePool" in self._environment:
log.info("Flags are ignored, since 'ReadPool' or 'WritePool' is specified")
return True
if rec.readESD() or rec.readAOD(): # and globalflags.DataSource()=='data': # need this for MC as well
protectedInclude("TriggerJobOpts/TriggerConfigCheckMetadata.py")
if rec.readRDO() and globalflags.InputFormat()=='bytestream' and globalflags.DataSource()=='data' and TriggerFlags.configForStartup()!='HLToffline':
protectedInclude("TriggerJobOpts/TriggerConfigCheckHLTpsk.py")
log.info("The following flags are set:")
log.info("globalflags.InputFormat : %s", globalflags.InputFormat())
log.info("rec.read.* : RDO: %s, ESD: %s, AOD: %s, TAG: %s", rec.readRDO(), rec.readESD(), rec.readAOD(), rec.readTAG())
log.info("rec.doWrite.* : ESD: %s, AOD: %s, TAG: %s", rec.doWriteESD(), rec.doWriteAOD(), rec.doWriteTAG())
log.info("globalflags.DataSource : %s", globalflags.DataSource())
log.info("TriggerFlags.configForStartup : %s", TriggerFlags.configForStartup())
log.info("TriggerFlags.dataTakingConditions : %s", TriggerFlags.dataTakingConditions())
log.info("TriggerFlags.configurationSourceList: %s", TriggerFlags.configurationSourceList())
count = len([1 for x in [rec.readRDO(),rec.readESD(),rec.readAOD()] if x ]) #readTAG is only set with another input
if count == 0:
log.warning("Don't know what the input format is.")
return False
if count >= 2:
log.warning("More than one input format specified, please set only the appropriate one.")
return False
return True
def inputFileNames():
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
if athenaCommonFlags.FilesInput() != []:
return athenaCommonFlags.FilesInput()
from RecExConfig.RecFlags import rec
inFiles = None
# highest flag have precedence
if rec.readTAG():
inFiles = athenaCommonFlags.PoolTAGInput()
elif rec.readAOD():
inFiles = athenaCommonFlags.PoolAODInput()
elif rec.readESD():
inFiles = athenaCommonFlags.PoolESDInput()
elif rec.readRDO():
from AthenaCommon.GlobalFlags import globalflags
if globalflags.InputFormat == 'bytestream':
inFiles = athenaCommonFlags.BSRDOInput()
else:
inFiles = athenaCommonFlags.PoolRDOInput()
else:
raise RutimeError("Unable to determine input file")
return inFiles
def _fixJetTiming(c, **kw):
# Check version number of the input data.
# If no version is found, assume old.
rlist = release_version()
if rlist:
if rlist[0] >= 16: return
if rlist[0] == 15 and rlist[1] >= 7: return
if rlist[0] == 15 and rlist[1] == 6 and rlist[2] >= 8: return
sgkey_in = c.Getter.SGKey
sgkey_in = resolveSGKey('JetCollection', sgkey_in)
sgkey_out = sgkey_in + '_timing'
seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
if not hasattr(seq, sgkey_out):
tools = []
caloqual_kw = {
'doCellBasedVariables': True,
'doConstituentBasedVariables': True,
'doSamplingBasedVariables': True,
'cutOnTile': 254,
'cutOnLAr': 4000,
'doTileQuality': True,
'doLArQuality': True
}
if hasattr(JetRecToolsConf, 'JetTimeQualityTool'):
# rel 15 setup
tool1 = JetRecToolsConf.JetTimeQualityTool(sgkey_out + 'TimeTool',
DoTime=False,
DoQuality=False,
UseCells=False)
if rec.readESD() or rec.readRDO():
tool1.DoTime = True
tool1.DoQuality = True
tool1.UseCells = True
if rec.readAOD() and (sgkey_in.find('H1Topo') >= 0
or sgkey_in.find('LCTopo') >= 0):
tool1.DoTime = True
tools.append(tool1)
else:
# rel 16
caloqual_kw['doTiming'] = True
tool2 = JetCaloQualityTool(sgkey_out + 'QualTool', **caloqual_kw)
tools.append(tool2)
alg = JetD3PDMaker.JetFixupAlg(sgkey_out,
InputKey=sgkey_in,
OutputKey=sgkey_out,
Tools=tools)
for t in tools:
alg += t
seq += alg
c.Getter.SGKey = sgkey_out
return
def egammaBuilderAvailable():
" Return true if egammaBuilder is available."
flag = False
if rec.readRDO() or rec.readESD() and not rec.readAOD():
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
if hasattr(topSequence, 'egamma'):
flag = True
return flag
def getMetaData():
'''
Try to determine from the meta data whether the decoration has been performed already.
'''
from RecExConfig.RecFlags import rec
if not rec.readRDO():
from PyUtils.MetaReaderPeekerFull import metadata
try:
return metadata['/TagInfo'][metaDataKey()]
except Exception:
pass
return ''
def __init__(self, name='TrigDataAccess'):
super(TrigDataAccess, self).__init__(name)
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from TriggerJobOpts.TriggerFlags import TriggerFlags
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
from AthenaCommon.Logging import logging
log = logging.getLogger(name)
self.loadFullCollections = (TriggerFlags.doEF()
or TriggerFlags.doHLT())
self.loadAllSamplings = (TriggerFlags.doLVL2() or TriggerFlags.doHLT())
if (globalflags.DatabaseInstance == "COMP200"
and TriggerFlags.doCaloOffsetCorrection()):
self.ApplyOffsetCorrection = False
log.warning(
"Not possible to run BCID offset correction with COMP200")
else:
if TriggerFlags.doCaloOffsetCorrection():
log.info('Enable HLT calo offset correction')
if globalflags.DataSource(
) == 'data' and athenaCommonFlags.isOnline():
from IOVDbSvc.CondDB import conddb
conddb.addFolder("LAR_ONL", "/LAR/ElecCalibFlat/OFC")
from LArRecUtils.LArRecUtilsConf import LArFlatConditionSvc
svcMgr += LArFlatConditionSvc()
svcMgr.LArFlatConditionSvc.OFCInput = "/LAR/ElecCalibFlat/OFC"
svcMgr.ProxyProviderSvc.ProviderNames += [
"LArFlatConditionSvc"
]
from CaloTools.CaloLumiBCIDToolDefault import CaloLumiBCIDToolDefault
theCaloLumiBCIDTool = CaloLumiBCIDToolDefault()
svcMgr.ToolSvc += theCaloLumiBCIDTool
self.CaloLumiBCIDTool = theCaloLumiBCIDTool
self.ApplyOffsetCorrection = True
else:
log.info('Disable HLT calo offset correction')
self.ApplyOffsetCorrection = False
from RecExConfig.RecFlags import rec
transientBS = (rec.readRDO()
and not globalflags.InputFormat() == 'bytestream')
if (transientBS or TriggerFlags.writeBS()):
if (not hasattr(svcMgr.ToolSvc, 'LArRawDataContByteStreamTool')):
from LArByteStream.LArByteStreamConfig import LArRawDataContByteStreamToolConfig
svcMgr.ToolSvc += LArRawDataContByteStreamToolConfig()
svcMgr.ToolSvc.LArRawDataContByteStreamTool.DSPRunMode = 4
svcMgr.ToolSvc.LArRawDataContByteStreamTool.RodBlockVersion = 10
return
def getMetaData():
'''
Try to determine from the meta data whether the decoration has been performed already.
'''
from RecExConfig.RecFlags import rec
if not rec.readRDO():
from RecExConfig.InputFilePeeker import inputFileSummary
try:
# print 'DEBUG InDetPhysValMonitoring getMetaData %s' % inputFileSummary['metadata']
return inputFileSummary['tag_info'][metaDataKey()]
except Exception:
pass
return ''
def sync_Trigger2Reco():
from AthenaCommon.Include import include
from RecExConfig.RecAlgsFlags import recAlgs
from AthenaCommon.GlobalFlags import globalflags
from RecExConfig.RecFlags import rec
if recAlgs.doTrigger() and rec.readRDO(
) and not globalflags.InputFormat() == 'bytestream':
include("TriggerJobOpts/TransientBS_DetFlags.py")
if globalflags.InputFormat() == 'bytestream':
TriggerFlags.readBS = True
TriggerFlags.doLVL1 = False
TriggerFlags.doLVL2 = False
TriggerFlags.doEF = False
if rec.doWriteBS():
TriggerFlags.writeBS = True
def GetDefaultTagRefStream(streams):
# spot the most downstream target : this will be the default
# except if one readXYZ is locked
from RecExConfig.RecFlags import rec
if rec.readRDO.is_locked() and rec.readRDO():
if 'Stream1_ref' in streams:
return 'Stream1_ref'
if 'StreamRDO_ref' in streams:
return 'StreamRDO_ref'
elif 'StreamRAW_ref' in streams:
return 'StreamRAW_ref'
else:
raise RuntimeError(
" readRDO locked True and no Stream1 nor StreamRDO nor StreamRAW !"
)
if rec.readESD.is_locked() and rec.readESD():
if 'StreamESD_ref' in streams:
return 'StreamESD_ref'
else:
raise RuntimeError(" readESD locked True and no StreamESD !")
if rec.readAOD.is_locked() and rec.readAOD():
if 'StreamAOD_ref' in streams:
return 'StreamAOD_ref'
else:
raise RuntimeError(" readAOD locked True and no StreamAOD !")
# now deal with default case
if 'StreamAOD_ref' in streams:
return 'StreamAOD_ref'
elif 'StreamESD_ref' in streams:
return 'StreamESD_ref'
elif 'Stream1_ref' in streams:
return 'Stream1_ref'
elif 'StreamRDO_ref' in streams:
return 'StreamRDO_ref'
elif 'StreamRAW_ref' in streams:
return 'StreamRAW_ref'
else:
raise RuntimeError(" no known streams !")
return None
def setMetaData():
'''
Write the input source on which the InDet decoration algorithm was running to the meta data
'''
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
if metaDataKey() in svcMgr.TagInfoMgr.ExtraTagValuePairs:
return
from RecExConfig.RecFlags import rec
str = ''
if rec.readRDO():
str = 'fromRDO'
elif rec.readESD():
str = 'fromESD'
elif rec.readAOD():
str = 'fromAOD'
if metaDataKey() not in svcMgr.TagInfoMgr.ExtraTagValuePairs:
svcMgr.TagInfoMgr.ExtraTagValuePairs[metaDataKey()] = str
def checkFileMetaData(self):
log = logging.getLogger("TriggerConfigGetter.py")
from RecExConfig.InputFilePeeker import inputFileSummary
self.hasLBwiseHLTPrescalesAndL1ItemDef = True
if rec.readESD() or rec.readAOD() or "ReadPool" in self._environment:
self.hasLBwiseHLTPrescalesAndL1ItemDef = inputFileSummary[
'metadata'].has_key(
'/TRIGGER/HLT/Prescales'
) # they were all added at the same time (Repro with 15.6.3.2 Prod)
# protection against early runs
if inputFileSummary.has_key(
'run_number'
) and self._environment == "" and globalflags.DataSource(
) == 'data' and rec.readRDO() and any(
[run < 134230 for run in inputFileSummary['run_number']]):
self.hasLBwiseHLTPrescalesAndL1ItemDef = False
if self.hasLBwiseHLTPrescalesAndL1ItemDef:
log.info("Using LB-wise HLT prescales")
else:
log.info("Using run-wise HLT prescales")
def OutputFileName(suffix=""):
from RecExConfig.RecFlags import rec
OutFileName = ""
if rec.OutputFileNameForRecoStep() == "":
if rec.readRDO():
if globalflags.InputFormat() == "bytestream":
OutFileName = "bs"
else:
OutFileName = "rdo"
elif rec.readESD():
OutFileName = "esd"
elif rec.readAOD():
OutFileName = "aod"
else:
OutFileName = "in"
OutFileName = OutFileName + "to"
if rec.doWriteBS():
OutFileName = OutFileName + "bs"
elif rec.doWriteRDO():
OutFileName = OutFileName + "rdo"
if rec.doESD():
OutFileName = OutFileName + "esd"
if rec.doAOD():
OutFileName = OutFileName + "aod"
if rec.doDPD():
OutFileName = OutFileName + "dpd"
if rec.doWriteTAG():
OutFileName = OutFileName + "tag"
if suffix != "":
OutFileName = OutFileName + "_" + suffix
print("Generated OutFileName", OutFileName)
else:
OutFileName = rec.OutputFileNameForRecoStep()
print("User defined OutFileName", OutFileName)
return OutFileName
def __init__(self, name='TrigDataAccess'):
super(TrigDataAccess, self).__init__(name)
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from TriggerJobOpts.TriggerFlags import TriggerFlags
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.Logging import logging
log = logging.getLogger(name)
self.loadFullCollections = ( TriggerFlags.doEF() or TriggerFlags.doHLT() )
self.loadAllSamplings = ( TriggerFlags.doLVL2() or TriggerFlags.doHLT() )
log.info('Not possible anymore to enable HLT calo offset correction, tools deprecated')
from RecExConfig.RecFlags import rec
transientBS = (rec.readRDO() and not globalflags.InputFormat()=='bytestream')
if ( transientBS or TriggerFlags.doTransientByteStream() ):
if ( not hasattr(svcMgr.ToolSvc,'LArRawDataContByteStreamTool') ):
from LArByteStream.LArByteStreamConfig import LArRawDataContByteStreamToolConfig
svcMgr.ToolSvc += LArRawDataContByteStreamToolConfig()
svcMgr.ToolSvc.LArRawDataContByteStreamTool.DSPRunMode=4
svcMgr.ToolSvc.LArRawDataContByteStreamTool.RodBlockVersion=10
return
def CaloAffectedToolDefault(name='CaloAffectedToolDefault'):
# check if tool already exists
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
if hasattr(svcMgr.ToolSvc, name):
# re-use previously configured (public) tool
return getattr(svcMgr.ToolSvc, name)
mlog = logging.getLogger( 'CaloAffectedToolDefault' )
from CaloTools.CaloToolsConf import CaloAffectedTool
theTool = CaloAffectedTool(name)
from RecExConfig.RecFlags import rec
if rec.readRDO():
theTool.readRaw = True
else:
theTool.readRaw = False
from IOVDbSvc.CondDB import conddb
conddb.addFolder ('', '/LAR/LArAffectedRegionInfo<metaOnly/>')
return theTool
def InputFileNames():
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
if athenaCommonFlags.FilesInput() != []:
return athenaCommonFlags.FilesInput()
from RecExConfig.RecFlags import rec
inFiles = None
## FIXME
## if (not athenaCommonFlags.PoolTAGInput.isDefault() or rec.readTAG() ):
## inFiles=athenaCommonFlags.PoolTAGInput()
## elif (not athenaCommonFlags.PoolAODInput.isDefault() or rec.readAOD() ):
## inFiles=athenaCommonFlags.PoolAODInput()
## elif (not athenaCommonFlags.PoolESDInput.isDefault() or rec.readESD() ):
## inFiles=athenaCommonFlags.PoolESDInput()
## elif not athenaCommonFlags.BSRDOInput.isDefault():
## inFiles=athenaCommonFlags.BSRDOInput()
## elif not athenaCommonFlags.PoolRDOInput.isDefault():
## inFiles=athenaCommonFlags.PoolRDOInput()
if rec.readTAG():
inFiles = athenaCommonFlags.PoolTAGInput()
elif rec.readAOD():
inFiles = athenaCommonFlags.PoolAODInput()
elif rec.readESD():
inFiles = athenaCommonFlags.PoolESDInput()
elif rec.readRDO():
from AthenaCommon.GlobalFlags import globalflags
if globalflags.InputFormat == 'bytestream':
inFiles = athenaCommonFlags.BSRDOInput()
else:
inFiles = athenaCommonFlags.PoolRDOInput()
else:
raise RuntimeError("Unable to determine input file")
return inFiles
from AthenaCommon.GlobalFlags import globalflags
from RecExConfig.RecFlags import rec
if globalflags.InputFormat=='bytestream' or (not TriggerFlags.doLVL1()):
CBNT_AthenaAware.Members += ["LVL1::CBNTAA_LVL1CaloESD/CBNT_LVL1calo"]
elif (rec.readESD() or rec.readAOD()):
CBNT_AthenaAware.Members += ["LVL1::CBNTAA_LVL1CaloESD/CBNT_LVL1calo"]
elif (rec.readRDO() and TriggerFlags.doLVL1()):
CBNT_AthenaAware.Members += [ "LVL1::CBNTAA_LVL1calo/CBNT_LVL1calo" ]
elif ( jobproperties.CaloCellFlags.doFastCaloSim() and TriggerFlags.doLVL1()):
CBNT_AthenaAware.Members += [ "LVL1::CBNTAA_LVL1calo/CBNT_LVL1calo" ]
CBNT_AthenaAware.Members += [ "CBNTAA_ReadRoIBResult/CBNT_ReadRoIBResult" ]
#CBNTAthenaAware=True
include( "CBNT_Athena/CBNT_AthenaAware_jobOptions.py" )
include( "CBNT_Athena/CBNT_EventInfo_jobOptions.py" )
if rec.Commissioning:
from AthenaMonitoring.DQMonFlags import DQMonFlags
if DQMonFlags.doCTPMon():
include ("TrigT1CTMonitoring/NtupleFragment.py")
if DQMonFlags.doLVL1CaloMon():
include( "TrigT1CaloCalibTools/CBNT_L1Calo_jobOptions.py" )
else:
doL1CaloCBNT_JEM = False
doL1CaloCBNT_CPM = False
doL1CaloCBNT_RODHeader = False
include( "TrigT1CaloCalibTools/CBNT_L1Calo_jobOptions.py" )
include("TrigNtInDet/jobOfragment_TrigNtInDet.py")
def ConfigureInputType():
from PyUtils.MetaReaderPeeker import metadata
from AthenaCommon.GlobalFlags import globalflags
streamsName = []
if metadata['file_type'] == 'BS':
#byte stream
logAutoConfiguration.info("Input BS detected")
globalflags.InputFormat = 'bytestream'
rec.readRDO = True
rec.readESD = False
rec.readAOD = False
rec.doAOD = False
rec.doESD = True
rec.doWriteAOD = False
logAutoConfiguration.info(
"BS format: setting globalflags.InputFormat=%s " %
globalflags.InputFormat())
logAutoConfiguration.info("BS format: setting rec.readRDO=%s " %
rec.readRDO())
logAutoConfiguration.info("BS format: setting rec.doAOD=%s " %
rec.doAOD())
logAutoConfiguration.info("BS format: setting rec.doESD=%s " %
rec.doESD())
logAutoConfiguration.info("BS format: setting rec.doWriteAOD=%s " %
rec.doWriteAOD())
else:
globalflags.InputFormat = 'pool'
#Get streamsName
streamsName = []
if 'processingTags' in metadata:
streamsName = metadata['processingTags']
if streamsName == None:
streamsName = []
logAutoConfiguration.info("Extracted streams %s from input file " %
streamsName)
if len(streamsName) == 0:
logAutoConfiguration.warning(
"ConfigureInputType: no stream in input file.")
elif len(streamsName) > 1:
logAutoConfiguration.warning(
"ConfigureInputType: more than one stream: %s in input file. Default action. Consider the highest one."
)
else:
rec.mergingStreamName = streamsName[0]
from RecExConfig.RecoFunctions import OverlapLists
try:
from PrimaryDPDMaker.PrimaryDPDFlags import listRAWtoDPD, listESDtoDPD, listAODtoDPD
except:
logAutoConfiguration.warning(
"Unable to import PrimaryDPDFlags. OK for ATN tests below AtlasAnalysis, otherwise suspicious."
)
listRAWtoDPD = []
listESDtoDPD = []
listAODtoDPD = []
## these lines have been added to guarantee the backward compatibility for the old DPD naming convention cosmics
try:
from PrimaryDPDMaker.PrimaryDPDFlags import listBackwardCompatibleAODtoDPD, listBackwardCompatibleESDtoDPD
listESDtoDPD.extend(listBackwardCompatibleESDtoDPD)
listAODtoDPD.extend(listBackwardCompatibleAODtoDPD)
except:
logAutoConfiguration.warning(
"Primary DPDMake does not support the old naming convention!!")
if 'TagStreamsRef' in metadata and metadata['TagStreamsRef'] != None:
logAutoConfiguration.info("Input TAG detected")
rec.readTAG = True
logAutoConfiguration.info("Auto configured rec.readTAG=%s " %
rec.readTAG())
from RecExConfig.RecoFunctions import ItemInListStartsWith
if ItemInListStartsWith("StreamAOD", streamsName) or ItemInListStartsWith(
'StreamDAOD', streamsName) or ItemInListStartsWith(
'StreamD2AOD', streamsName) or OverlapLists(
streamsName, listAODtoDPD) or ItemInListStartsWith(
'DAOD', streamsName) or ItemInListStartsWith(
'D2AOD', streamsName):
logAutoConfiguration.info("Input AOD detected")
rec.readRDO = False
rec.readESD = False
rec.readAOD = True
rec.doAOD = False
rec.doESD = False
logAutoConfiguration.info("setting rec.readAOD=%s " % rec.readAOD())
elif ItemInListStartsWith(
"StreamESD", streamsName) or ItemInListStartsWith(
'StreamDESD', streamsName) or ItemInListStartsWith(
'StreamD2ESD', streamsName) or OverlapLists(
streamsName, listESDtoDPD) or ItemInListStartsWith(
'DESD', streamsName) or ItemInListStartsWith(
'D2ESD', streamsName):
logAutoConfiguration.info("Input ESD detected")
rec.readRDO = False
rec.readESD = True
rec.readAOD = False
rec.doAOD = True
rec.doESD = False
logAutoConfiguration.info("setting rec.readESD=%s " % rec.readESD())
logAutoConfiguration.info("setting rec.doAOD=%s " % rec.doAOD())
elif ItemInListStartsWith("Stream1", streamsName) or ItemInListStartsWith(
"StreamRDO", streamsName) or ItemInListStartsWith(
"OutputStreamRDO", streamsName) or OverlapLists(
streamsName, listRAWtoDPD):
logAutoConfiguration.info("Input RDO detected")
rec.readRDO = True
rec.readESD = False
rec.readAOD = False
rec.doAOD = False
rec.doESD = True
logAutoConfiguration.info("setting rec.readRDO=%s " % rec.readRDO())
logAutoConfiguration.info("setting rec.doESD=%s " % rec.doESD())
elif ItemInListStartsWith("StreamEVGEN", streamsName):
logAutoConfiguration.info("Input EVGEN detected")
rec.readRDO = False
rec.readESD = False
rec.readAOD = False
rec.doAOD = False
rec.doESD = False
logAutoConfiguration.info(
"setting all unlocked rec.readXXX and rec.doXXX to False")
elif ItemInListStartsWith("StreamHITS", streamsName):
logAutoConfiguration.info("Input StreamEVGEN detected")
elif metadata['file_type'] != 'BS':
raise RuntimeError("ConfigureInputType cannot handle streamsName==%s" %
streamsName)
return
# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
from MuonCombinedRecExample.MuonCombinedKeys import MuonCombinedKeys as MuonCbKeys
from MuonCombinedRecExample.MuonCombinedRecFlags import muonCombinedRecFlags
from RecExConfig.RecFlags import rec
from RecExConfig.ObjKeyStore import cfgKeyStore
if (not rec.readRDO()
or muonCombinedRecFlags.doAOD()) and not muonCombinedRecFlags.doxAOD():
from RecExConfig.ObjKeyStore import cfgKeyStore
#SA
if not cfgKeyStore.isInInput('xAOD::TrackParticleContainer',
MuonCbKeys.ExtrapolatedMSParticles()):
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__TrackParticleCnvAlg
alg1 = xAODMaker__TrackParticleCnvAlg(
"TrackParticleCnvAlg_ExtrapolatedMS")
alg1.AODContainerName = 'ExtrapolatedMuonSpectrometerParticles' #ExtrapolatedMuonSpectrometerParticles
alg1.xAODContainerName = MuonCbKeys.ExtrapolatedMSParticles()
topSequence += alg1
print "Added convertor for ", MuonCbKeys.ExtrapolatedMSParticles()
# StatCombined
if not cfgKeyStore.isInInput('xAOD::TrackParticleContainer',
MuonCbKeys.StatCombinedParticles()):
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__TrackParticleCnvAlg
alg3 = xAODMaker__TrackParticleCnvAlg(
"TrackParticleCnvAlg_StatCombined")
alg3.AODContainerName = 'StatCombinedMuonParticles' #xStatCombinedMuonParticles
alg3.xAODContainerName = MuonCbKeys.StatCombinedParticles()
def AODFix_Init():
''' This function is called to correctly setup AODFix.'''
global _aodFixInstance
from RecExConfig.RecFlags import rec
##################
# exit if locked to false
##################
if rec.doApplyAODFix.is_locked() and rec.doApplyAODFix.get_Value(
) == False:
logAODFix.info(
"doApplyAODFix is locked to False; not applying anything")
return
##################
# deterimine in what release we are running (and fill some rec variables
##################
import os
curRelease = os.getenv("AtlasVersion") or ''
logAODFix.debug("curRelease set to " + curRelease)
##################
# determine athena with which input file was created and previous AODFix
##################
# RDO doesn't have MetaData
prevAODFix = ''
prevRelease = ''
isMC = False
isHI = rec.doHeavyIon()
isHIP = rec.doHIP()
# is it better to do this or to look at GlobalFlags?
from RecExConfig.InputFilePeeker import inputFileSummary
try:
isMC = (inputFileSummary['evt_type'][0] == "IS_SIMULATION")
except Exception:
logAODFix.warning(
"Could not tell if the input file is data or MC; setting to data")
isMC = False
if not rec.readRDO():
try:
AtlasReleaseVersionString = inputFileSummary['metadata'][
'/TagInfo']['AtlasRelease']
rv = AtlasReleaseVersionString.split('-')
if len(rv) > 1:
prevRelease = rv[1]
except Exception:
logAODFix.warning(
"no AthenRelease found in input file, setting to <none> !!")
prevRelease = ''
##################
# determine which is the previous verion of the AODFix
##################
try:
prevAODFix = inputFileSummary['tag_info']['AODFixVersion']
if prevAODFix.startswith("AODFix_"):
prevAODFix = prevAODFix[7:]
prevAODFix = prevAODFix.split("_")[0]
except Exception:
logAODFix.debug(
"no AODFixVersion found in input file, setting to <none>.")
prevAODFix = ''
logAODFix.info("Summary of MetaData for AODFix:")
if isMC:
logAODFix.info(" Input file is MC")
else:
logAODFix.info(" Input file is DATA")
logAODFix.info(" Input file produced with Athena version <%s>." %
prevRelease)
logAODFix.info(" AODFix version <%s> was previously applied." % prevAODFix)
if rec.doApplyAODFix.is_locked():
logAODFix.info(" AODFix is forced to run!")
##################
# determine which AODFix to run (if actually running--to be determined later)
##################
doAODFix = False
if rec.readAOD(): # change in policy: no AODFix if reading ESD.
doAODFix = True
# check to see if it's a DAOD; do not run by default in DAODs
from RecExConfig.InputFilePeeker import inputFileSummary
try:
streamNames = inputFileSummary['stream_names']
if any(map(lambda x: "StreamDAOD" in x,
streamNames)) and not rec.doApplyAODFix.is_locked():
logAODFix.info("Running on a DAOD, so not scheduling AODFix")
doAODFix = False
except Exception:
logAODFix.warning("Could not determine the stream name")
elif rec.readESD() and rec.doApplyAODFix.is_locked():
# only run on ESDs if forcing
doAODFix = True
#exit if not doing AODFix
if not doAODFix:
return
curReleaseSplit = curRelease.split('.')
prevReleaseSplit = prevRelease.split('.')
if len(curReleaseSplit) >= 2 and (rec.doApplyAODFix.is_locked()
or len(prevReleaseSplit) >= 2):
### If adding an AODFix for a release family that does not have it,
### please add it to the if-elif... statement below
# if (curReleaseSplit[0] == '21' and (curReleaseSplit[1] == '0' or curReleaseSplit[1] == '2') and
# (rec.doApplyAODFix.is_locked() or
# (prevReleaseSplit[0] == '21' and (prevReleaseSplit[1] == '0' or prevReleaseSplit[1] == '2')))):
# _aodFixInstance = AODFix_r210(prevAODFix, isMC, rec.doApplyAODFix.is_locked(), isHI, isHIP)
# else:
# logAODFix.info("No AODFix scheduled for this release.")
logAODFix.info("AODFix disabled.")
else:
logAODFix.info("Current release is of strange form: %s" % curRelease)
def configure(self):
if self._done:
log.info("configuration already done, who is calling it again?")
return True
self._done = True
# start with print some information what this will do
log.info(
"Basic configuration flags RecAlgsFlag.doTrigger: %d RecFlags.doTrigger: %d TriggerFlags.doTriggerConfigOnly %d",
recAlgs.doTrigger(), rec.doTrigger(), TF.doTriggerConfigOnly())
log.info(
"TriggerFlags: doL1Topo: %s, doLVL1: %s, doLVL2: %s, doEF: %s, doHLT: %s, doMT: %s",
TF.doL1Topo(), TF.doLVL1(), TF.doLVL2(), TF.doEF(), TF.doHLT(),
TF.doMT())
# RDOtoRDOTrigger MT temporarily coded in the transform skeleton, so skip here
if TF.doMT() and rec.readRDO() and rec.doWriteRDO():
log.info("Nothing happens in TriggerGetter for RDOtoRDOTrigger MT")
return True
else: #GenerateMenu imports slice flags, which are Menu/MenuMT dependent
from TriggerMenu.menu.GenerateMenu import GenerateMenu
willGenerateMenu = recAlgs.doTrigger() and (
TF.doLVL1() or TF.doLVL2() or TF.doEF()
or TF.doHLT()) and not TF.doTriggerConfigOnly()
willRunTriggerConfigGetter = recAlgs.doTrigger() or rec.doTrigger(
) or TF.doTriggerConfigOnly()
willRunLVL1SimulationGetter = recAlgs.doTrigger(
) and not TF.doTriggerConfigOnly()
willRunHLTSimulationGetter = willRunLVL1SimulationGetter and (
TF.doLVL2() or TF.doEF() or TF.doHLT())
log.info(
"Will run: %s%s%s%s", "GenerateMenu " if willGenerateMenu else "",
"TriggerConfigGetter " if willRunTriggerConfigGetter else "",
"LVL1SimulationGetter " if willRunLVL1SimulationGetter else "",
"HLTSimulationGetter " if willRunHLTSimulationGetter else "")
log.info(
"Will not run: %s%s%s%s",
"GenerateMenu " if not willGenerateMenu else "",
"TriggerConfigGetter " if not willRunTriggerConfigGetter else "",
"LVL1SimulationGetter " if not willRunLVL1SimulationGetter else "",
"HLTSimulationGetter " if not willRunHLTSimulationGetter else "")
if recAlgs.doTrigger():
if ((TF.doLVL1() or TF.doLVL2() or TF.doEF() or TF.doHLT())
and not TF.doTriggerConfigOnly()):
log.info("generating menu")
# trigger menu files generation
g = GenerateMenu()
g.generate()
# after the menu xml file has been created or the TriggerDB access is configured,
# the COOL/SQlite db can be written
# TB this needs to be optimized -- we do not need ti always but only when AOD or ESD are created
if recAlgs.doTrigger() or rec.doTrigger() or TF.doTriggerConfigOnly():
# setup configuration services
from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter
cfg = TriggerConfigGetter() # noqa: F841
from TrigConfigSvc.TrigConf2COOL import theConfCOOLWriter
theConfCOOLWriter.writeConf2COOL()
# preconfigure TrigDecisionTool
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += Trig__TrigDecisionTool("TrigDecisionTool")
from PyUtils.MetaReaderPeekerFull import metadata
if "metadata_items" in metadata and any(
('TriggerMenu' in key)
for key in metadata["metadata_items"].keys()):
# Use xAOD configuration.
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
if not hasattr(svcMgr, 'xAODConfigSvc'):
from TrigConfxAOD.TrigConfxAODConf import TrigConf__xAODConfigSvc
svcMgr += TrigConf__xAODConfigSvc('xAODConfigSvc')
ToolSvc += Trig__TrigDecisionTool("TrigDecisionTool")
ToolSvc.TrigDecisionTool.TrigConfigSvc = svcMgr.xAODConfigSvc
else:
# Use TrigConfigSvc
ToolSvc.TrigDecisionTool.TrigConfigSvc = "TrigConf::TrigConfigSvc/TrigConfigSvc"
from TrigEDMConfig.TriggerEDM import EDMLibraries
ToolSvc.TrigDecisionTool.Navigation.Dlls = [
e for e in EDMLibraries if 'TPCnv' not in e
]
# actuall trigger simulation running
if recAlgs.doTrigger() and not TF.doTriggerConfigOnly():
# setup Lvl1
# initialize LVL1ConfigSvc
log.info("configuring lvl1")
from TriggerJobOpts.Lvl1TriggerGetter import Lvl1SimulationGetter
lvl1 = Lvl1SimulationGetter() # noqa: F841
if TF.doTransientByteStream() or (
jobproperties.Global.InputFormat() != 'bytestream' and
(TF.doLVL2() or TF.doEF() or TF.doHLT())):
# Transient BS construction and intialization
from ByteStreamCnvSvc import WriteByteStream
StreamBS = WriteByteStream.getStream("Transient", "StreamBS")
StreamBS.ItemList += [
"DataVector<LVL1::TriggerTower>#TriggerTowers"
]
StreamBS.ItemList += ["TRT_RDO_Container#TRT_RDOs"]
StreamBS.ItemList += ["SCT_RDO_Container#SCT_RDOs"]
StreamBS.ItemList += ["PixelRDO_Container#PixelRDOs"]
# StreamBS.ItemList +=["LArRawChannelContainer#*"]
StreamBS.ItemList += ["2721#*"]
# StreamBS.ItemList +=["TileRawChannelContainer#*"]
StreamBS.ItemList += ["2927#*"]
StreamBS.ItemList += [
"2934#*"
] # added on request from: Arantxa Ruiz Martinez for TileRODMu
# don't need Muons in transient BS
# StreamBS.ItemList +=["MdtCsmContainer#*"]
# StreamBS.ItemList +=["RpcPadContainer#*"]
# StreamBS.ItemList +=["TgcRdoContainer#*"]
# StreamBS.ItemList +=["CscRawDataContainer#*"]
from AthenaCommon.Include import include
# setup trans BS for the ID
include("InDetRecExample/InDetRecCabling.py")
# setup HLT
# initialize HLT config svc
log.info("TriggerFlags: doLVL2 %r", TF.doLVL2())
log.info("TriggerFlags: doEF %r", TF.doEF())
log.info("TriggerFlags: doHLT %r", TF.doHLT())
if TF.doLVL2() or TF.doEF() or TF.doHLT():
log.info("configuring hlt")
from TriggerJobOpts.HLTTriggerGetter import HLTSimulationGetter
hlt = HLTSimulationGetter(g) # noqa: F841
else:
from RegionSelector.RegSelSvcDefault import RegSelSvcDefault
from AthenaCommon.AppMgr import ServiceMgr
ServiceMgr += RegSelSvcDefault()
ServiceMgr.RegSelSvc.enablePixel = False
ServiceMgr.RegSelSvc.enableSCT = False
# prepare result making of L1
from TriggerJobOpts.Lvl1ResultBuilderGetter import Lvl1ResultBuilderGetter
hltouput = Lvl1ResultBuilderGetter()
# prepare result making of HLT
if TF.doLVL2() or TF.doEF() or TF.doHLT() or (recAlgs.doTrigger()
and TF.readBS()):
from TriggerJobOpts.HLTTriggerResultGetter import HLTTriggerResultGetter
hltouput = HLTTriggerResultGetter() # noqa: F841
return True
"invalid jobproperties.Beam.beamType(): %s, using default (%s)",
jobproperties.Beam.beamType(), DQMonFlags.monManDataType)
# First, test to see if this is being run online
if athenaCommonFlags.isOnline:
DQMonFlags.monManEnvironment = 'online'
# Running offline; set the monMan environment based on monType
elif DQMonFlags.monType == 'BSonly':
DQMonFlags.monManEnvironment = 'tier0Raw'
if rec.readESD():
DQMonFlags.doMonitoring = False
elif DQMonFlags.monType == 'ESDonly':
DQMonFlags.monManEnvironment = 'tier0ESD'
if rec.readRDO():
DQMonFlags.doMonitoring = False
elif (DQMonFlags.monType == 'BS_ESD'):
if rec.readRDO():
DQMonFlags.monManEnvironment = 'tier0Raw'
if rec.readESD():
DQMonFlags.monManEnvironment = 'tier0ESD'
if rec.readAOD():
DQMonFlags.monManEnvironment = 'AOD'
elif DQMonFlags.monType == 'BSall':
DQMonFlags.monManEnvironment = 'tier0'
if rec.readESD():
DQMonFlags.doMonitoring = False
else:
jobproperties.Beam.beamType(), DQMonFlags.monManDataType)
# First, test to see if this is being run online
if athenaCommonFlags.isOnline:
DQMonFlags.monManEnvironment='online'
# Running offline; set the monMan environment based on monType
elif DQMonFlags.monType=='BSonly':
DQMonFlags.monManEnvironment='tier0Raw'
if rec.readESD():
DQMonFlags.doMonitoring=False
elif DQMonFlags.monType=='ESDonly':
DQMonFlags.monManEnvironment='tier0ESD'
if rec.readRDO():
DQMonFlags.doMonitoring=False
elif (DQMonFlags.monType=='BS_ESD'):
if rec.readRDO():
DQMonFlags.monManEnvironment='tier0Raw'
if rec.readESD():
DQMonFlags.monManEnvironment='tier0ESD'
if rec.readAOD():
DQMonFlags.monManEnvironment='AOD'
elif DQMonFlags.monType=='BSall':
DQMonFlags.monManEnvironment='tier0'
if rec.readESD():
DQMonFlags.doMonitoring=False
else:
"LAR", "/LAR/BadChannels/MissingFEBs",
"/LAR/BadChannelsOfl/MissingFEBs" + forceRN + rekeyMF)
# and the same for Known Noisy and MNB FEBs
if (rec.doESD() or rec.doRDOTrigger()) and ('COMP200'
not in conddb.GetInstance()):
rekeyBADF = "<key>/LAR/BadChannels/KnownBADFEBs</key>"
rekeyMNBF = "<key>/LAR/BadChannels/KnownMNBFEBs</key>"
conddb.addFolderSplitOnline(
"LAR", "/LAR/BadChannels/KnownBADFEBs",
"/LAR/BadChannelsOfl/KnownBADFEBs" + forceRN + rekeyBADF)
conddb.addFolderSplitOnline(
"LAR", "/LAR/BadChannels/KnownMNBFEBs",
"/LAR/BadChannelsOfl/KnownMNBFEBs" + forceRN + rekeyMNBF)
if not larCondFlags.LoadElecCalib.is_locked():
larCondFlags.LoadElecCalib.set_Value(rec.readRDO())
#For run 2 we use cool-inline storage in online database COOLONL_LAR/CONDBR2:
haveElecCalibInline = (conddb.dbdata == "CONDBR2")
if (haveElecCalibInline):
# Run 2 case:
#This service creates a objects in the DetectorStore that wrap the AttributeListCollections
#with the inline representation of the electronic calibration and makes them accessible through the
#ILArRamp, ILArOFC, etc. abstract interfaces
from LArRecUtils.LArRecUtilsConf import LArFlatConditionSvc
theLArCondSvc = LArFlatConditionSvc()
svcMgr += theLArCondSvc
svcMgr.ProxyProviderSvc.ProviderNames += ["LArFlatConditionSvc"]
#Load HVScaleCorr. For run 2,these constants are also used by the CaloNoiseToolDB
def RecoFix_Init():
''' This function is called to correctly setup RecoFix.'''
global _recoFixInstance
from RecExConfig.RecFlags import rec
##################
# deterimine in what release we are running (and fill some rec variables
##################
import os
curRelease = os.getenv("AtlasVersion") or ''
logRecoFix.debug("curRelease set to " + curRelease)
##################
# determine athena with which input file was created and previous RecoFix
##################
# RDO doesn't have MetaData
prevAODFix = ''
if not rec.readRDO():
##################
# determine which is the previous verion of the AODFix
##################
# is it better to do this or to look at GlobalFlags?
from RecExConfig.InputFilePeeker import inputFileSummary
try:
prevAODFix = inputFileSummary['tag_info']['AODFixVersion']
if prevAODFix.startswith("AODFix_"):
prevAODFix = prevAODFix[7:]
prevAODFix = prevAODFix.split("_")[0]
except Exception:
logRecoFix.debug(
"no AODFixVersion found in input file, setting to <none>.")
prevAODFix = ''
logRecoFix.info("Summary of MetaData for RecoFix:")
logRecoFix.info(" AODFix version <%s> was previously applied." %
prevAODFix)
##################
# determine which RecoFix to run (if actually running--to be determined later)
##################
doRecoFix = False
if rec.doESD():
# running from RAW or ESD, set recofix metadata
logRecoFix.debug("detected doESD=True, applying RecoFix metadata")
doRecoFix = True
#exit if not doing RecoFix
if not doRecoFix:
return
curReleaseSplit = curRelease.split('.')
if len(curReleaseSplit) >= 2:
### If adding an RecoFix for a release family that does not have it,
### please add it to the if-elif... statement below
if (curReleaseSplit[0] == '21'
and (curReleaseSplit[1] == '0' or curReleaseSplit[1] == '2')):
_recoFixInstance = RecoFix_r210()
else:
logRecoFix.info("No RecoFix scheduled for this release.")
else:
logRecoFix.info("Current release is of strange form: %s" % curRelease)
def sync_DetFlags(self,technologies="MDT,RPC,CSC,TGC,sTGC,Micromegas"):
self.setDefaults()
global rec
from AthenaCommon.DetFlags import DetFlags
# if Muons off, then do nothing
if not DetFlags.Muon_on() or not rec.doMuon(): return
flagsOn = []
flagsOff = [ 'readRIOBS' ] # we don't store RIO (=PRD) on bytestream ???
# Reading RDO
if rec.readRDO():
if muonRecFlags.makePRDs():
flagsOn.append( 'makeRIO' )
else:
flagsOff.append( 'makeRIO' )
if globalflags.InputFormat == 'pool' :
flagsOn.append( 'readRDOPool' )
flagsOff.append( 'readRDOBS' )
elif globalflags.InputFormat == 'bytestream':
flagsOn.append( 'readRDOBS' )
flagsOff.append( 'readRDOPool' )
else: # not reading RDO
flagsOff.append( 'makeRIO' )
# Reading ESD
if rec.readESD():
flagsOn.append( 'readRIOPool' )
else:
flagsOff.append( 'readRIOPool' )
# Writing RDO Pool
if rec.doWriteRDO():
flagsOn.append( 'writeRDOPool' )
else:
flagsOff.append( 'writeRDOPool' )
# Writing RDO bystream
if rec.doWriteBS() :
flagsOn.append( 'writeBS' )
else:
flagsOff.append( 'writeBS' )
# Writing ESD
if rec.doWriteESD():
flagsOn.append( 'writeRIOPool' )
else:
flagsOff.append( 'writeRIOPool' )
# Digitization on-the-fly
if self.doDigitization():
flagsOn.append( 'digitize' )
try:
flagsOn.remove( 'readRDOPool' )
except ValueError: # not in list
pass
try:
flagsOn.remove( 'readRDOBS' )
except ValueError: # not in list
pass
flagsOff.append( 'readRDOPool' )
flagsOff.append( 'readRDOBS' )
# very special case for normal Rome production (inspired by RecExCommon_DetFlags.py)
if 'readRIOPool' not in flagsOn:
flagsOn.append( 'readRIOPool' )
try:
flagsOff.remove( 'readRIOPool' )
except ValueError: # not in list
pass
if not rec.doWriteRDO() and 'makeRIO' not in flagsOn:
flagsOn.append( 'makeRIO' )
try:
flagsOff.remove( 'makeRIO' )
except ValueError: #not in list
pass
else:
flagsOff.append( 'digitize')
# do sync per technology for selected flags
MDT_on = self.doMDTs()
RPC_on = self.doRPCs()
CSC_on = self.doCSCs()
TGC_on = self.doTGCs()
sTGC_on = self.dosTGCs()
Micromegas_on = self.doMicromegas()
techList = technologies.split(',')
for f in flagsOn:
for tech in techList:
setOn = eval(tech+'_on')
isOn = eval("DetFlags.%s.%s_on()" % (f,tech))
if setOn:
if not isOn:
cmd = "DetFlags.%s.%s_setOn()" % (f,tech)
logMuon.info(cmd)
exec(cmd)
else: # set off
if isOn:
cmd = "DetFlags.%s.%s_setOff()" % (f,tech)
logMuon.info(cmd)
exec(cmd)
# Turn off Muon flags (row in DetFlags printout)
for f in flagsOff:
isOn = eval("DetFlags.%s.Muon_on()" % f)
if isOn:
cmd = "DetFlags.%s.Muon_setOff()" % f
logMuon.info(cmd)
exec(cmd)
def EDMDecodingVersion():
log = logging.getLogger("EDMDecodingVersion")
# BYTESTREAM: decide Run3 or later based on ROD version, decide Run1/Run2 based on run number
if globalflags.InputFormat.is_bytestream():
# Check HLT ROD version in first event of first input file
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
inputFileName = athenaCommonFlags.FilesInput()[0]
if not inputFileName and athenaCommonFlags.isOnline():
log.info(
"Online reconstruction mode, no input file available. Leaving default TriggerFlags.EDMDecodingVersion=%d",
TriggerFlags.EDMDecodingVersion())
return
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("HLT ROD minor version from input file is %d.%d",
rodVersionM, rodVersionL)
break
if rodVersionM < 0 or rodVersionL < 0:
log.warning(
"Cannot determine HLT ROD version from input file, falling back to runNumber-based decision"
)
elif rodVersionM >= 1:
TriggerFlags.EDMDecodingVersion = 3
log.info(
"Decoding version set to 3, because running on BS file with HLT ROD version %d.%d",
rodVersionM, rodVersionL)
return
# Use run number to determine decoding version
from RecExConfig.AutoConfiguration import GetRunNumber
runNumber = GetRunNumber()
boundary_run12 = 230000
boundary_run23 = 368000
if runNumber <= 0:
log.error(
"Cannot determine decoding version because run number %d is invalid. Leaving the default version %d",
runNumber, TriggerFlags.EDMDecodingVersion())
elif runNumber < boundary_run12:
# Run-1 data
TriggerFlags.EDMDecodingVersion = 1
TriggerFlags.doMergedHLTResult = False
log.info(
"Decoding version set to 1 based on BS file run number (runNumber < %d)",
boundary_run12)
elif runNumber < boundary_run23:
# Run-2 data
TriggerFlags.EDMDecodingVersion = 2
log.info(
"Decoding version set to 2 based on BS file run number (%d < runNumber < %d)",
boundary_run12, boundary_run23)
else:
# Run-3 data
TriggerFlags.EDMDecodingVersion = 3
log.info(
"Decoding version set to 3 based on BS file run number (runNumber > %d)",
boundary_run23)
else:
# POOL files: decide based on HLT output type present in file
from RecExConfig.ObjKeyStore import cfgKeyStore
from PyUtils.MetaReaderPeeker import convert_itemList
cfgKeyStore.addManyTypesInputFile(convert_itemList(layout='#join'))
TriggerFlags.doMergedHLTResult = True
if cfgKeyStore.isInInputFile("HLT::HLTResult", "HLTResult_EF"):
TriggerFlags.EDMDecodingVersion = 1
TriggerFlags.doMergedHLTResult = False
log.info(
"Decoding version set to 1, because HLTResult_EF found in POOL file"
)
elif cfgKeyStore.isInInputFile("xAOD::TrigNavigation",
"TrigNavigation"):
TriggerFlags.EDMDecodingVersion = 2
log.info(
"Decoding version set to 2, because TrigNavigation found in POOL file"
)
elif cfgKeyStore.isInInputFile("xAOD::TrigCompositeContainer",
"HLTNav_Summary"):
TriggerFlags.EDMDecodingVersion = 3
log.info(
"Decoding version set to 3, because HLTNav_Summary found in POOL file"
)
elif rec.readRDO():
# If running Trigger on RDO input (without previous trigger result), choose Run-2 or Run-3 based on doMT
if TriggerFlags.doMT():
TriggerFlags.EDMDecodingVersion = 3
log.info(
"Decoding version set to 3, because running Trigger with doMT=True"
)
else:
TriggerFlags.EDMDecodingVersion = 2
log.info(
"Decoding version set to 2, because running Trigger with doMT=False"
)
else:
log.warning(
"Cannot recognise HLT EDM format, leaving default TriggerFlags.EDMDecodingVersion=%d",
TriggerFlags.EDMDecodingVersion())
def configure(self):
log = logging.getLogger("HLTTriggerResultGetter.py")
from RecExConfig.ObjKeyStore import objKeyStore
# set EDMDecodingVersion
EDMDecodingVersion()
# Set AODFULL for data unless it was set explicitly already
if TriggerFlags.AODEDMSet.isDefault() and globalflags.DataSource(
) == 'data':
TriggerFlags.AODEDMSet = 'AODFULL'
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
log.info("BS unpacking (TF.readBS): %d", TriggerFlags.readBS())
if TriggerFlags.readBS():
if TriggerFlags.EDMDecodingVersion() <= 2:
bs = ByteStreamUnpackGetterRun2() # noqa: F841
else:
bs = ByteStreamUnpackGetter() # noqa: F841
xAODContainers = {}
# if not recAlgs.doTrigger(): #only convert when running on old data
if TriggerFlags.EDMDecodingVersion() == 1:
xaodcnvrt = xAODConversionGetter()
xAODContainers = xaodcnvrt.xaodlist
if recAlgs.doTrigger() or TriggerFlags.doTriggerConfigOnly():
if TriggerFlags.EDMDecodingVersion() <= 2:
tdt = TrigDecisionGetterRun2() # noqa: F841
else:
tdt = TrigDecisionGetter() # noqa: F841
# Temporary hack to add Run-3 navigation to ESD and AOD
if (rec.doESD()
or rec.doAOD()) and TriggerFlags.EDMDecodingVersion() == 3:
# The hack with wildcards is needed for BS->ESD because we don't know the exact keys
# of HLT navigation containers before unpacking them from the BS event.
objKeyStore._store['streamESD'].allowWildCard(True)
objKeyStore._store['streamAOD'].allowWildCard(True)
objKeyStore.addManyTypesStreamESD([
'xAOD::TrigCompositeContainer#HLTNav*',
'xAOD::TrigCompositeAuxContainer#HLTNav*'
])
objKeyStore.addManyTypesStreamAOD([
'xAOD::TrigCompositeContainer#HLTNav*',
'xAOD::TrigCompositeAuxContainer#HLTNav*'
])
# TrigJetRec additions
if rec.doWriteESD():
objKeyStore.addStreamESD("JetKeyDescriptor", "JetKeyMap")
objKeyStore.addStreamESD("JetMomentMap", "TrigJetRecMomentMap")
if rec.doWriteAOD():
objKeyStore.addStreamAOD("JetKeyDescriptor", "JetKeyMap")
objKeyStore.addStreamAOD("JetMomentMap", "TrigJetRecMomentMap")
# ID truth
if not rec.readESD() and (not rec.readAOD()) and TriggerFlags.doID() \
and rec.doTruth():
try:
from TrigInDetTruthAlgs.TrigInDetTruthAlgsConfig import \
TrigIDTruthMaker
topSequence += TrigIDTruthMaker()
except Exception:
log.warning("Couldn't set up the trigger ID truth maker")
pass
if rec.doESD() or rec.doAOD():
from TrigEDMConfig.TriggerEDM import getTrigIDTruthList
objKeyStore.addManyTypesStreamESD(
getTrigIDTruthList(TriggerFlags.ESDEDMSet()))
objKeyStore.addManyTypesStreamAOD(
getTrigIDTruthList(TriggerFlags.AODEDMSet()))
if (rec.doESD() or rec.doAOD()) and TriggerFlags.writeL1TopoValData():
objKeyStore.addManyTypesStreamESD([
'xAOD::TrigCompositeContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValData',
'xAOD::TrigCompositeAuxContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValDataAux.'
])
objKeyStore.addManyTypesStreamAOD([
'xAOD::TrigCompositeContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValData',
'xAOD::TrigCompositeAuxContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValDataAux.'
])
log.debug(
"HLT_xAOD__TrigCompositeContainer_L1TopoValData(Aux.) for L1Topo validation added to the data."
)
if rec.doAOD() or rec.doWriteAOD():
# schedule the RoiDescriptorStore conversion
# log.warning( "HLTTriggerResultGetter - setting up RoiWriter" )
roiWriter = RoiWriter()
# Add fictional input to ensure data dependency in AthenaMT
roiWriter.ExtraInputs += [("TrigBSExtractionOutput",
"StoreGateSvc+TrigBSExtractionOutput")]
topSequence += roiWriter
# write out the RoiDescriptorStores
from TrigEDMConfig.TriggerEDMRun2 import TriggerRoiList
objKeyStore.addManyTypesStreamAOD(TriggerRoiList)
#Are we adding operational info objects in ESD?
added = self._AddOPIToESD()
if added:
log.debug(
"Operational Info object HLT_EXPRESS_OPI_HLT with extra information about express stream prescaling added to the data."
)
# ESD objects definitions
_TriggerESDList = {}
from TrigEDMConfig.TriggerEDM import getTriggerEDMList
# we have to store xAOD containers in the root file, NOT AOD,
# if the xAOD container list is not empty
if (xAODContainers):
_TriggerESDList.update(xAODContainers)
else:
_TriggerESDList.update(
getTriggerEDMList(TriggerFlags.ESDEDMSet(),
TriggerFlags.EDMDecodingVersion()))
log.info(
"ESD content set according to the ESDEDMSet flag: %s and EDM version %d",
TriggerFlags.ESDEDMSet(), TriggerFlags.EDMDecodingVersion())
# AOD objects choice
_TriggerAODList = {}
#from TrigEDMConfig.TriggerEDM import getAODList
_TriggerAODList.update(
getTriggerEDMList(TriggerFlags.AODEDMSet(),
TriggerFlags.EDMDecodingVersion()))
log.info(
"AOD content set according to the AODEDMSet flag: %s and EDM version %d",
TriggerFlags.AODEDMSet(), TriggerFlags.EDMDecodingVersion())
log.debug("ESD EDM list: %s", _TriggerESDList)
log.debug("AOD EDM list: %s", _TriggerAODList)
# Highlight what is in AOD list but not in ESD list, as this can cause
# the "different number of entries in branch" problem, when it is in the
# AOD list but the empty container per event is not created
# Just compares keys of dicts, which are the class names, not their string keys in StoreGate
not_in = [
element for element in _TriggerAODList
if element not in _TriggerESDList
]
if (len(not_in) > 0):
log.warning("In AOD list but not in ESD list: ")
log.warning(not_in)
else:
log.info("AOD list is subset of ESD list - good.")
def _addSlimming(stream, edm):
from TrigNavTools.TrigNavToolsConfig import navigationThinningSvc
edmlist = list(y.split('-')[0] for x in edm.values()
for y in x) #flatten names
svc = navigationThinningSvc({
'name': 'HLTNav_%s' % stream,
'mode': 'cleanup',
'result': 'HLTResult_HLT',
'features': edmlist
})
from OutputStreamAthenaPool.CreateOutputStreams import registerTrigNavThinningSvc
registerTrigNavThinningSvc(stream, svc)
log.info("Configured slimming of HLT for %s", stream)
print(svc) # noqa: ATL901
del edmlist
if TriggerFlags.doNavigationSlimming() and rec.readRDO(
) and rec.doWriteAOD():
_addSlimming('StreamAOD',
_TriggerESDList) #Use ESD item list also for AOD!
log.info("configured navigation slimming for AOD output")
if TriggerFlags.doNavigationSlimming() and rec.readRDO(
) and rec.doWriteESD():
_addSlimming('StreamESD', _TriggerESDList)
log.info("configured navigation slimming for ESD output")
objKeyStore.addManyTypesStreamESD(_TriggerESDList)
objKeyStore.addManyTypesStreamAOD(_TriggerAODList)
return True
#specify beam type (default is "collisions", other values "cosmics" "singlebeam"
# pick the correct one
jobproperties.Beam.beamType = 'cosmics'
# singlebeam not tested recently
#jobproperties.Beam.beamType = 'singlebeam'
# input configuration (lock to prevent override)
# note that if reading from TAG, the input file spec is ignored,
# however the flag settings should still be consistent
if Input == 'data':
if rec.readTAG():
# read TAG, navigate to ESD
athenaCommonFlags.PoolTAGInput = ['../cosm/myTAGCOMM.root']
athenaCommonFlags.PoolInputQuery.set_Value_and_Lock("TRTTracks>0")
if rec.readRDO():
if jobproperties.Beam.beamType() == 'cosmics':
if RTTdata:
# this is ignored if TAG are read
athenaCommonFlags.BSRDOInput.set_Value_and_Lock([
'/castor/cern.ch/grid/atlas/DAQ/2008/91900/physics_IDCosmic/daq.ATLAS.0091900.physics.IDCosmic.LB0001.SFO-1._0001.data',
'/castor/cern.ch/grid/atlas/DAQ/2008/91900/physics_IDCosmic/daq.ATLAS.0091900.physics.IDCosmic.LB0001.SFO-1._0002.data',
'/castor/cern.ch/grid/atlas/DAQ/2008/91900/physics_IDCosmic/daq.ATLAS.0091900.physics.IDCosmic.LB0001.SFO-1._0003.data',
'/castor/cern.ch/grid/atlas/DAQ/2008/91900/physics_IDCosmic/daq.ATLAS.0091900.physics.IDCosmic.LB0001.SFO-2._0001.data',
'/castor/cern.ch/grid/atlas/DAQ/2008/91900/physics_IDCosmic/daq.ATLAS.0091900.physics.IDCosmic.LB0001.SFO-2._0002.data',
'/castor/cern.ch/grid/atlas/DAQ/2008/91900/physics_IDCosmic/daq.ATLAS.0091900.physics.IDCosmic.LB0001.SFO-2._0003.data',
'/castor/cern.ch/grid/atlas/DAQ/2008/91900/physics_IDCosmic/daq.ATLAS.0091900.physics.IDCosmic.LB0001.SFO-3._0001.data',
'/castor/cern.ch/grid/atlas/DAQ/2008/91900/physics_IDCosmic/daq.ATLAS.0091900.physics.IDCosmic.LB0001.SFO-3._0002.data',
'/castor/cern.ch/grid/atlas/DAQ/2008/91900/physics_IDCosmic/daq.ATLAS.0091900.physics.IDCosmic.LB0001.SFO-3._0003.data',
'/castor/cern.ch/grid/atlas/DAQ/2008/91900/physics_IDCosmic/daq.ATLAS.0091900.physics.IDCosmic.LB0001.SFO-4._0001.data',
'/castor/cern.ch/grid/atlas/DAQ/2008/91900/physics_IDCosmic/daq.ATLAS.0091900.physics.IDCosmic.LB0001.SFO-4._0002.data',
# now synchronise other flags
if rec.doWriteRDO():
logRecExCommon_flags.info("write RDO, do not make ESD AOD TAG CBNT")
# switch off all algorithms
rec.doESD = False
rec.doAOD = False
rec.doWriteESD = False
rec.doWriteAOD = False
rec.doWriteTAG = False
rec.doCBNT = False
if rec.readESD or rec.readAOD:
raise RuntimeError, "Cannot have readESD or readAOD if doWriteRDO"
if rec.readRDO() and globalflags.InputFormat() != 'bytestream':
# this is a RDO to RDO copy, do not put detector status
rec.doDetStatus = False
# in case several read specified, favour the highest one
if rec.readAOD():
logRecExCommon_flags.info("read AOD : all algs switched off ")
# switch off all algorithms
rec.doESD = False
rec.doAOD = False
rec.doWriteESD = False
rec.doWriteAOD = False
if rec.readRDO:
logRecExCommon_flags.info("readAOD : switch readRDO off ")
rec.readRDO = False
from AthenaCommon.AppMgr import ServiceMgr
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.DetFlags import DetFlags
from AthenaCommon import CfgMgr
from RecExConfig.RecFlags import rec
from RecExConfig.RecAlgsFlags import recAlgs
from MuonRecExample.MuonAlignFlags import muonAlignFlags
muonRecFlags.setDefaults()
topSequence = AlgSequence()
if muonRecFlags.doDigitization():
include("MuonRecExample/MuonDigitization_jobOptions.py")
if rec.readRDO():
if globalflags.InputFormat == 'bytestream':
include("MuonCnvExample/MuonReadBS_jobOptions.py")
else:
include("MuonCnvExample/MuonReadRDO_jobOptions.py")
if DetFlags.makeRIO.Muon_on():
include("MuonRecExample/MuonRDO_to_PRD_jobOptions.py")
### add PRD -> xAOD
if (rec.readRDO() or rec.readESD()) and muonRecFlags.prdToxAOD():
from AthenaCommon import CfgMgr
topSequence += CfgMgr.MDT_PrepDataToxAOD()
topSequence += CfgMgr.RPC_PrepDataToxAOD()
topSequence += CfgMgr.TGC_PrepDataToxAOD()
topSequence += CfgMgr.CSC_PrepDataToxAOD()
def setDefaults(self):
global globalflags
from MuonRecExample.MuonRecUtils import setJobPropertyDefault as setDefault
# as long as rec.Commissioning is alive, sync the default to it
# in case of BS->RDO, RDO->RDO, RDO->BS, BS->BS: don't run RIO (i.e RDO->PRD)
setDefault(self.makePRDs, rec.readRDO() and not rec.doWriteRDO() and not rec.doWriteBS())
setDefault(self.doStandalone,True)
setDefault(self.doDigitization,False)
setDefault(self.doCalib,False)
setDefault(self.applyResilience,athenaCommonFlags.AllowIgnoreConfigError())
setDefault(self.doSegmentsOnly,False)
setDefault(self.doMDTs,True)
setDefault(self.doRPCs,True)
setDefault(self.doTGCs,True)
setDefault(self.doCSCs,True)
setDefault(self.dosTGCs,True)
setDefault(self.doMicromegas,True)
setDefault(self.doMSVertex,True)
setDefault(self.useWireSagCorrections,False)
setDefault(self.enableErrorTuning,True)
setDefault(self.useLooseErrorTuning,False)
setDefault(self.useAlignmentCorrections,DetFlags.detdescr.Muon_on() and rec.doMuon())
setDefault(self.writeSDOs, rec.doWriteESD() and globalflags.DataSource != 'data')
setDefault(self.useTGCPriorNextBC,True)
setDefault(self.doMuonIso,True)
if beamFlags.beamType == 'cosmics' or beamFlags.beamType == 'singlebeam':
setDefault(self.doSegmentT0Fit,True)
else:
setDefault(self.doSegmentT0Fit,False)
setDefault(self.doPrdSelect,False)
# Default for MuonCalibration ntuple
setDefault(self.calibMuonStandalone, muonRecFlags.doStandalone() or rec.readESD() )
try:
from MuonCnvExample.MuonCalibFlags import muonCalibFlags
except ImportError:
from AthenaCommon.Resilience import treatException
treatException("Could not load MuonCalibFlags. Switching off calibration ntuple")
self.doCalib = False
self.doCalibNtuple = False
else:
doTracks = self.calibMuonStandalone()
# chose a default
if not muonCalibFlags.Mode.statusOn:
if doTracks:
muonCalibFlags.Mode = 'trackNtuple'
else:
muonCalibFlags.Mode = 'ntuple'
if muonCalibFlags.Mode == 'trackNtuple' and doTracks:
setDefault(self.doCalibNtuple,self.doCalib())
setDefault(self.calibNtupleSegments,True)
setDefault(self.calibNtupleTracks,True)
if rec.doTrigger: setDefault(self.calibNtupleTrigger,True)
else: setDefault(self.calibNtupleTrigger,False)
elif muonCalibFlags.Mode == 'ntuple' or (muonCalibFlags.Mode == 'trackNtuple' and not doTracks):
setDefault(self.doCalibNtuple,self.doCalib())
setDefault(self.calibNtupleSegments,True)
setDefault(self.calibNtupleTracks,False)
if rec.doTrigger: setDefault(self.calibNtupleTrigger,True)
else: setDefault(self.calibNtupleTrigger,False)
else:
setDefault(self.doCalibNtuple,False)
setDefault(self.calibNtupleSegments,False)
setDefault(self.calibNtupleTracks,False)
setDefault(self.calibNtupleTrigger,False)
