def MM_OverlayDigitizationTool(name="MM_OverlayDigitizationTool", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OutputObjectName",
overlayFlags.sigPrefix() + "MM_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("OutputSDOName",
overlayFlags.sigPrefix() + "MM_SDO")
else:
kwargs.setdefault("OutputObjectName",
overlayFlags.evtStore() + "+MM_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("OutputSDOName",
overlayFlags.evtStore() + "+MM_SDO")
return MM_DigitizationTool(name, **kwargs)
def Tgc_OverlayDigitizationTool(name="Tgc_OverlayDigitizationTool", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault("OutputObjectName",
overlayFlags.sigPrefix() + "TGC_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("OutputSDOName",
overlayFlags.sigPrefix() + "TGC_SDO")
else:
kwargs.setdefault("OutputObjectName",
overlayFlags.evtStore() + "+TGC_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("OutputSDOName",
overlayFlags.evtStore() + "+TGC_SDO")
return TgcDigitizationTool(name, **kwargs)
def getCscOverlayDigitizationTool(name="CscOverlayDigitizationTool", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault("OutputObjectName",
overlayFlags.sigPrefix() + "CSC_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("CSCSimDataCollectionOutputName",
overlayFlags.sigPrefix() + "CSC_SDO")
else:
kwargs.setdefault("OutputObjectName",
overlayFlags.evtStore() + "+CSC_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("CSCSimDataCollectionOutputName",
overlayFlags.evtStore() + "+CSC_SDO")
return getCscDigitizationToolBase(name, **kwargs)
def Mdt_OverlayDigitizationTool(name="Mdt_OverlayDigitizationTool", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault("OutputObjectName",
overlayFlags.sigPrefix() + "MDT_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("OutputSDOName",
overlayFlags.sigPrefix() + "MDT_SDO")
else:
kwargs.setdefault("OutputObjectName",
overlayFlags.evtStore() + "+MDT_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("OutputSDOName",
overlayFlags.evtStore() + "+MDT_SDO")
kwargs.setdefault("GetT0FromBD", overlayFlags.isDataOverlay())
return MdtDigitizationTool(name, **kwargs)
def getEventInfoOverlay(name="EventInfoOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("BkgInputKey", overlayFlags.bkgPrefix() + "EventInfo")
kwargs.setdefault("SignalInputKey", overlayFlags.sigPrefix() + "EventInfo")
kwargs.setdefault("OutputKey", "EventInfo")
kwargs.setdefault("DataOverlay", overlayFlags.isDataOverlay())
return CfgMgr.xAODMaker__EventInfoOverlay(name, **kwargs)
def CscRawDataProviderTool(name="CscRawDataProviderTool", **kwargs):
kwargs.setdefault("Decoder", "CscROD_Decoder")
if DetFlags.overlay.CSC_on() and overlayFlags.isDataOverlay():
if overlayFlags.isOverlayMT():
kwargs.setdefault("RdoLocation",
overlayFlags.bkgPrefix() + "CSCRDO")
else:
kwargs.setdefault("RdoLocation",
overlayFlags.dataStore() + "+CSCRDO")
return CfgMgr.Muon__CSC_RawDataProviderToolMT(name, **kwargs)
def MdtRawDataProviderTool(name="MdtRawDataProviderTool", **kwargs):
kwargs.setdefault("Decoder", "MdtROD_Decoder")
if DetFlags.overlay.MDT_on() and overlayFlags.isDataOverlay():
if overlayFlags.isOverlayMT():
kwargs.setdefault("RdoLocation",
overlayFlags.bkgPrefix() + "MDTCSM")
else:
kwargs.setdefault("RdoLocation",
overlayFlags.dataStore() + "+MDTCSM")
return CfgMgr.Muon__MDT_RawDataProviderToolMT(name, **kwargs)
def getCscOverlay(name="CscOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("BkgInputKey", overlayFlags.bkgPrefix() + "CSCRDO")
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "CSCRDO")
kwargs.setdefault("OutputKey", "CSCRDO")
else:
kwargs.setdefault("BkgInputKey", overlayFlags.dataStore() + "+CSCRDO")
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+CSCRDO")
kwargs.setdefault("OutputKey", "StoreGateSvc+CSCRDO")
kwargs.setdefault("isDataOverlay", overlayFlags.isDataOverlay())
from AthenaCommon import CfgMgr
return CfgMgr.CscOverlay(name, **kwargs)
def getTRTSDOOverlay(name="TRTSDOOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
if overlayFlags.isDataOverlay():
kwargs.setdefault("BkgInputKey", "")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.bkgPrefix() + "TRT_SDO_Map")
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "TRT_SDO_Map")
kwargs.setdefault("OutputKey", "TRT_SDO_Map")
else:
if overlayFlags.isDataOverlay():
kwargs.setdefault("BkgInputKey", "")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.dataStore() + "+TRT_SDO_Map")
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+TRT_SDO_Map")
kwargs.setdefault("OutputKey",
overlayFlags.outputStore() + "+TRT_SDO_Map")
return CfgMgr.InDetSDOOverlay(name, **kwargs)
def getBCMOverlay(name="BCMOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("isDataOverlay", overlayFlags.isDataOverlay())
if overlayFlags.isOverlayMT():
kwargs.setdefault("BkgInputKey",
overlayFlags.bkgPrefix() + "BCM_RDOs")
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "BCM_RDOs")
kwargs.setdefault("OutputKey", "BCM_RDOs")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.dataStore() + "+BCM_RDOs")
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+BCM_RDOs")
kwargs.setdefault("OutputKey",
overlayFlags.outputStore() + "+BCM_RDOs")
return CfgMgr.BCMOverlay(name, **kwargs)
def getTgcTruthOverlay(name="TgcTruthOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isDataOverlay():
kwargs.setdefault("BkgInputKey", "")
else:
if overlayFlags.isOverlayMT():
kwargs.setdefault("BkgInputKey",
overlayFlags.bkgPrefix() + "TGC_SDO")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.dataStore() + "+TGC_SDO")
if overlayFlags.isOverlayMT():
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "TGC_SDO")
kwargs.setdefault("OutputKey", "TGC_SDO")
else:
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+TGC_SDO")
kwargs.setdefault("OutputKey",
overlayFlags.outputStore() + "+TGC_SDO")
return CfgMgr.MuonSimDataOverlay(name, **kwargs)
include.block("EventOverlayJobTransforms/Level1Overlay_jobOptions.py")
from AthenaCommon import CfgGetter
from AthenaCommon.DetFlags import DetFlags
from Digitization.DigitizationFlags import digitizationFlags
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if DetFlags.overlay.LVL1_on():
if overlayFlags.isDataOverlay():
include("TrigT1CaloByteStream/ReadLVL1CaloBS_jobOptions.py")
#include ("MuonCommRecExample/ReadMuCTPI_jobOptions.py")
ServiceMgr.ByteStreamAddressProviderSvc.TypeNames += [
"MuCTPI_RDO/MUCTPI_RDO", "L2Result/L2Result", "CTP_RDO/CTP_RDO",
"ROIB::RecRoIBResult/RecRoIBResult", "MuCTPI_RIO/MUCTPI_RIO",
"CTP_RIO/CTP_RIO"
]
if DetFlags.simulateLVL1.LAr_on():
include("LArL1Sim/LArL1Sim_G4_jobOptions.py")
# Noise
if not digitizationFlags.doCaloNoise.get_Value():
job.LArTTL1Maker.NoiseOnOff = False #(default:True)
# PileUp
job.LArTTL1Maker.PileUp = True
# If we are doing MC overlay
if not overlayFlags.isDataOverlay():
if overlayFlags.isOverlayMT():
job.LArTTL1Maker.EmTTL1ContainerName = overlayFlags.sigPrefix(
) + "LArTTL1EM"
def readInputFileMetadata():
logOverlayReadMetadata.info("Checking for Signal Simulation MetaData...")
import PyUtils.AthFile as af
af.server.load_cache('digitization-afcache.ascii')
#--------------------------------------------------
# Check for the Run Number in the first Input file
#--------------------------------------------------
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
from Digitization.DigitizationFlags import digitizationFlags
from OverlayCommonAlgs.OverlayFlags import overlayFlags
digitizationFlags.simRunNumber = int(
digitizationFlags.getHitFileRunNumber(
athenaCommonFlags.PoolHitsInput.get_Value()[0]))
sigsimdict, sigtaginfodict, result = buildDict(
"Signal",
athenaCommonFlags.PoolHitsInput.get_Value()[0])
if result:
signalMetaDataCheck(sigsimdict)
if overlayFlags.isDataOverlay():
if 'RunNumber' in sigsimdict.keys():
year = sigsimdict['RunNumber'] % 100
logOverlayReadMetadata.info("Found Year = %s", year)
from RecExConfig.RecFlags import rec
rec.projectName = 'data' + str(year)
else:
## Check Pileup Simulation Parameters match those used for signal files
result = True
longpileuptype = "pre-mixed pile-up"
logOverlayReadMetadata.info(
"Checking %s MetaData against Signal Simulation MetaData...",
longpileuptype)
pileupsimdict, pileuptaginfodict, result = buildDict(
longpileuptype,
athenaCommonFlags.PoolRDOInput.get_Value()[0])
if not result:
logOverlayReadMetadata.warning(
"Failed to Create %s Simulation MetaData Dictionary from file %s.",
longpileuptype,
athenaCommonFlags.PoolHitsInput.get_Value()[0])
else:
if pileupMetaDataCheck(sigsimdict, pileupsimdict):
logOverlayReadMetadata.info(
"Pre-mixed RDO File Simulation MetaData matches Signal Simulation MetaData."
)
if tagInfoMetaDataCheck(sigtaginfodict, pileuptaginfodict):
logOverlayReadMetadata.info(
"Pre-mixed RDO File TagInfo MetaData matches Signal TagInfo MetaData."
)
## All checks completed here
logOverlayReadMetadata.info(
"Completed all checks against Signal Simulation MetaData.")
del pileupsimdict
del pileuptaginfodict
else:
logOverlayReadMetadata.info(
"Failed to Create Signal MetaData Dictionaries from file %s",
athenaCommonFlags.PoolHitsInput.get_Value()[0])
## control where metadata can be used
del sigsimdict
del sigtaginfodict
def TMEF_CscRawDataProviderTool(name="TMEF_CscRawDataProviderTool", **kwargs):
kwargs.setdefault("Decoder", "CscROD_Decoder")
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if DetFlags.overlay.CSC_on() and overlayFlags.isDataOverlay():
kwargs.setdefault("RdoLocation", overlayFlags.dataStore() + "+CSCRDO")
return CfgMgr.Muon__CSC_RawDataProviderTool(name, **kwargs)
def getLArPileUpTool(
name='LArPileUpTool',
**kwargs
): ## useLArFloat()=True,isOverlay()=False,outputKey='LArDigitContainer_MC'):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
from AthenaCommon.Logging import logging
mlog = logging.getLogger('LArPileUpToolDefault:')
mlog.info(" ---- in getLArPileUpTool ")
# the LAr and Calo detector description package
## FIXME includes to be replaced by confGetter configuration.
if not isOverlay():
from AthenaCommon.Resilience import protectedInclude
protectedInclude(
"CaloDetMgrDetDescrCnv/CaloDetMgrDetDescrCnv_joboptions.py")
protectedInclude("LArDetDescr/LArDetDescr_joboptions.py")
protectedInclude(
"LArConditionsCommon/LArConditionsCommon_MC_jobOptions.py")
else:
if overlayFlags.isDataOverlay():
#Shape taken from real-data DB has a different SG key
kwargs.setdefault('ShapeKey', "LArShape")
from Digitization.DigitizationFlags import digitizationFlags
kwargs.setdefault('NoiseOnOff', digitizationFlags.doCaloNoise.get_Value())
kwargs.setdefault('DoDigiTruthReconstruction',
digitizationFlags.doDigiTruth())
if digitizationFlags.doXingByXingPileUp():
kwargs.setdefault('FirstXing', -751)
kwargs.setdefault('LastXing', 101)
from LArDigitization.LArDigitizationFlags import jobproperties
# check if using high gain for Fcal or not
if (not jobproperties.LArDigitizationFlags.useFcalHighGain()) and (
not isOverlay()):
mlog.info("do not use high gain in Fcal digitization ")
kwargs.setdefault('HighGainThreshFCAL', 0)
else:
mlog.info("use high gain in Fcal digitization or overlay job")
# check if using high gain for EMEC IW or not
if (not jobproperties.LArDigitizationFlags.useEmecIwHighGain()) and (
not isOverlay()):
mlog.info("do not use high gain in EMEC IW digitization ")
kwargs.setdefault('HighGainThreshEMECIW', 0)
kwargs.setdefault('RndmEvtOverlay', isOverlay())
if useLArFloat():
kwargs.setdefault("LArHitContainers", [])
else:
kwargs.setdefault("LArHitFloatContainers", [])
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault('DigitContainer',
overlayFlags.bkgPrefix() + 'LArDigitContainer_MC')
else:
kwargs.setdefault(
'DigitContainer',
'LArDigitContainer_MC') ##FIXME - should not be hard-coded
# if doing MC+MC overlay
from AthenaCommon.GlobalFlags import globalflags
if isOverlay() and globalflags.DataSource() == 'geant4':
kwargs.setdefault('isMcOverlay', True)
from LArROD.LArRODFlags import larRODFlags
kwargs.setdefault('Nsamples', larRODFlags.nSamples())
kwargs.setdefault('firstSample', larRODFlags.firstSample())
if isOverlay():
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault(
'InputDigitContainer',
overlayFlags.bkgPrefix() + 'LArDigitContainer_MC')
else:
kwargs.setdefault('InputDigitContainer', 'LArDigitContainer_MC')
# ADC2MeVCondAlgo
from LArRecUtils.LArADC2MeVCondAlgDefault import LArADC2MeVCondAlgDefault
LArADC2MeVCondAlgDefault()
# AutoCorrNoiseCondAlgo
if not isOverlay():
from LArRecUtils.LArAutoCorrNoiseCondAlgDefault import LArAutoCorrNoiseCondAlgDefault
LArAutoCorrNoiseCondAlgDefault()
# bad channel masking
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArRCBMasker = LArBadChannelMasker("LArRCBMasker")
theLArRCBMasker.DoMasking = True
theLArRCBMasker.ProblemsToMask = ["deadReadout", "deadPhys"]
kwargs.setdefault('MaskingTool', theLArRCBMasker)
# CosmicTriggerTimeTool for cosmics digitization
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType == "cosmics":
from CommissionUtils.CommissionUtilsConf import CosmicTriggerTimeTool
from AthenaCommon.AppMgr import ToolSvc
theTriggerTimeTool = CosmicTriggerTimeTool()
ToolSvc += theTriggerTimeTool
kwargs.setdefault('UseTriggerTime', True)
kwargs.setdefault('TriggerTimeToolName', theTriggerTimeTool)
# pileup configuration "algorithm" way
if not digitizationFlags.doXingByXingPileUp():
from AthenaCommon.DetFlags import DetFlags
if DetFlags.pileup.LAr_on() or isOverlay():
kwargs.setdefault('PileUp', True)
kwargs.setdefault('useLArFloat', useLArFloat())
if useLArFloat():
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from SGComps.SGCompsConf import AddressRemappingSvc
AddressRemappingSvc = AddressRemappingSvc()
svcMgr += AddressRemappingSvc
from AthenaCommon.ConfigurableDb import getConfigurable
svcMgr += getConfigurable("ProxyProviderSvc")()
svcMgr.ProxyProviderSvc.ProviderNames += ["AddressRemappingSvc"]
svcMgr.AddressRemappingSvc.TypeKeyOverwriteMaps = [
"LArHitContainer#LArHitEMB->LArHitFloatContainer#LArHitEMB",
"LArHitContainer#LArHitEMEC->LArHitFloatContainer#LArHitEMEC",
"LArHitContainer#LArHitHEC->LArHitFloatContainer#LArHitHEC",
"LArHitContainer#LArHitFCAL->LArHitFloatContainer#LArHitFCAL"
]
svcMgr.AddressRemappingSvc.ProxyDict = "ActiveStoreSvc"
return CfgMgr.LArPileUpTool(name, **kwargs)
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
from OverlayCommonAlgs.OverlayFlags import overlayFlags
outStream = AthenaPoolOutputStream('StreamRDO',
athenaCommonFlags.PoolRDOOutput(),
asAlg=True)
outStream.ItemList = []
# Event info
outStream.ItemList += [
'xAOD::EventInfo#EventInfo', 'xAOD::EventAuxInfo#EventInfoAux.'
]
# Timings
outStream.ItemList += ['RecoTimingObj#EVNTtoHITS_timings']
if not overlayFlags.isDataOverlay():
outStream.ItemList += ['RecoTimingObj#HITStoRDO_timings']
# Truth
if DetFlags.overlay.Truth_on():
outStream.ItemList += ['McEventCollection#TruthEvent']
if 'TrackRecordCollection' in overlayFlags.optionalContainerMap():
for collection in overlayFlags.optionalContainerMap(
)['TrackRecordCollection']:
outStream.ItemList += ['TrackRecordCollection#' + collection]
if not overlayFlags.isDataOverlay():
outStream.ItemList += ['xAOD::JetContainer#InTimeAntiKt4TruthJets']
outStream.ItemList += [
'xAOD::JetAuxContainer#InTimeAntiKt4TruthJetsAux.'
from PileUpComps.PileUpCompsConf import BkgStreamsCache
import AthenaPoolCnvSvc.WriteAthenaPool
from EventSelectorAthenaPool.EventSelectorAthenaPoolConf import EventSelectorAthenaPool
from StoreGate.StoreGateConf import StoreGateSvc
from Digitization.DigitizationFlags import digitizationFlags
from OverlayCommonAlgs.OverlayFlags import overlayFlags
pileUpEventLoopMgr = PileUpEventLoopMgr(EventInfoName="Input_EventInfo")
pileUpEventLoopMgr.OutStreamType = "AthenaOutputStream"
printfunc("================ DetFlags ================ ")
DetFlags.Print()
if overlayFlags.isDataOverlay():
from InDetRecExample.InDetJobProperties import InDetFlags
from ByteStreamCnvSvc import ReadByteStream
include("RecExCommon/BSRead_config.py")
ServiceMgr.EventSelector.Input = DataInputCollections
ServiceMgr.ByteStreamInputSvc.EventStore = "StoreGateSvc/" + overlayFlags.dataStore(
)
from AthenaKernel import StoreID
ServiceMgr.ByteStreamAddressProviderSvc.StoreID = StoreID.UNKNOWN
from EventSelectorAthenaPool.EventSelectorAthenaPoolConf import AthenaPoolAddressProviderSvc
ServiceMgr += AthenaPoolAddressProviderSvc("AthenaPoolAddressProviderSvc")
ServiceMgr.ProxyProviderSvc.ProviderNames += [
"AthenaPoolAddressProviderSvc"
]
else:
import AthenaPoolCnvSvc.ReadAthenaPool
import MagFieldServices.SetupField
#------------------------------------------------------------
# Check Beam and Digitization jobproperties are synchronised
#------------------------------------------------------------
from Digitization.DigiConfigCheckers import syncBeamAndDigitizationJobProperties
syncBeamAndDigitizationJobProperties()
# TODO: Override run number if needed
# include("Digitization/RunNumberOverride.py")
#------------------------------------------------------------
# xAOD::EventInfo setup
#------------------------------------------------------------
from OverlayCommonAlgs.OverlayFlags import overlayFlags
# Support legacy EventInfo
if overlayFlags.processLegacyEventInfo() and not hasattr(
job, "xAODMaker::EventInfoCnvAlg"):
from xAODEventInfoCnv.xAODEventInfoCreator import xAODMaker__EventInfoCnvAlg
alg = xAODMaker__EventInfoCnvAlg("EventInfoCnvAlg")
alg.AODKey = overlayFlags.sigPrefix() + 'McEventInfo'
alg.xAODKey = overlayFlags.sigPrefix() + 'EventInfo'
job += alg
# Run the xAOD::EventInfo overlay
job += CfgGetter.getAlgorithm("EventInfoOverlay")
# Setup BS conversion for data overlay
if overlayFlags.isDataOverlay():
include("RecExCommon/BSRead_config.py")
def _configureReadAthenaPoolDouble():
""" Helper method to configure Athena to read back POOL files """
from AthenaCommon.Logging import logging
msg = logging.getLogger( 'configureReadAthenaPool' )
msg.debug( "Configuring Athena for reading POOL files..." )
from AthenaCommon import CfgMgr
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaCommon.AppMgr import theApp
# Load the basic services
import AthenaPoolCnvSvc.AthenaPool
# Switch on TTreeCache for CollectionTree
svcMgr.AthenaPoolCnvSvc.InputPoolAttributes += [ "DatabaseName = '*'; ContainerName = 'CollectionTree'; TREE_CACHE = '-1'" ]
# Load ProxyProviderSvc
if not hasattr (svcMgr, 'ProxyProviderSvc'):
svcMgr += CfgMgr.ProxyProviderSvc()
# Add in MetaDataSvc
if not hasattr (svcMgr, 'MetaDataSvc'):
svcMgr += CfgMgr.MetaDataSvc ("MetaDataSvc")
svcMgr.ProxyProviderSvc.ProviderNames += [ "MetaDataSvc" ]
# Add in MetaData Stores
if not hasattr (svcMgr, 'InputMetaDataStore'):
svcMgr += CfgMgr.StoreGateSvc ("InputMetaDataStore")
if not hasattr (svcMgr, 'MetaDataStore'):
svcMgr += CfgMgr.StoreGateSvc ("MetaDataStore")
# Enable IOVDbSvc to read MetaData
svcMgr.MetaDataSvc.MetaDataContainer = "MetaDataHdr"
svcMgr.MetaDataSvc.MetaDataTools += [ "IOVDbMetaDataTool" ]
if not hasattr (svcMgr.ToolSvc, 'IOVDbMetaDataTool'):
svcMgr.ToolSvc += CfgMgr.IOVDbMetaDataTool()
# BS specifics
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isDataOverlay():
# Load ByteStreamEventStorageInputSvc
if not hasattr (svcMgr, 'ByteStreamInputSvc'):
svcMgr += CfgMgr.ByteStreamEventStorageInputSvc ("ByteStreamInputSvc",
EventInfoKey=overlayFlags.bkgPrefix() + "EventInfo")
# Load ROBDataProviderSvc
if not hasattr (svcMgr, 'ROBDataProviderSvc'):
svcMgr += CfgMgr.ROBDataProviderSvc ("ROBDataProviderSvc")
# Load ByteStreamCnvSvc
if not hasattr (svcMgr, 'ByteStreamCnvSvc'):
svcMgr += CfgMgr.ByteStreamCnvSvc ("ByteStreamCnvSvc")
svcMgr.EventPersistencySvc.CnvServices += [ "ByteStreamCnvSvc" ]
# Add in ByteStreamAddressProviderSvc
if not hasattr (svcMgr, 'ByteStreamAddressProviderSvc'):
svcMgr += CfgMgr.ByteStreamAddressProviderSvc ("ByteStreamAddressProviderSvc")
svcMgr.ProxyProviderSvc.ProviderNames += [ "ByteStreamAddressProviderSvc" ]
# Enable ByteStream to read MetaData
svcMgr.MetaDataSvc.MetaDataTools += [ "ByteStreamMetadataTool" ]
if not hasattr (svcMgr.ToolSvc, 'ByteStreamMetadataTool'):
svcMgr.ToolSvc += CfgMgr.ByteStreamMetadataTool()
# Add in EventSelector
if overlayFlags.isDataOverlay():
svcMgr += CfgMgr.EventSelectorByteStream("SecondaryEventSelector", IsSecondary=True, ByteStreamInputSvc="ByteStreamInputSvc")
else:
svcMgr += CfgMgr.EventSelectorAthenaPool("SecondaryEventSelector", IsSecondary=True)
svcMgr += CfgMgr.DoubleEventSelectorAthenaPool("DoubleEventSelector")
theApp.EvtSel = "DoubleEventSelectorAthenaPool/DoubleEventSelector"
# Add in AthenaPoolAddressProviderSvc
if not hasattr (svcMgr, 'AthenaPoolAddressProviderSvcPrimary'):
svcMgr += CfgMgr.AthenaPoolAddressProviderSvc ("AthenaPoolAddressProviderSvcPrimary")
svcMgr.ProxyProviderSvc.ProviderNames += [ "AthenaPoolAddressProviderSvc/AthenaPoolAddressProviderSvcPrimary" ]
svcMgr.AthenaPoolAddressProviderSvcPrimary.DataHeaderKey = "EventSelector"
if not overlayFlags.isDataOverlay():
svcMgr.AthenaPoolAddressProviderSvcPrimary.AttributeListKey = "Input"
if not hasattr (svcMgr, 'AthenaPoolAddressProviderSvcSecondary'):
svcMgr += CfgMgr.AthenaPoolAddressProviderSvc ("AthenaPoolAddressProviderSvcSecondary")
svcMgr.ProxyProviderSvc.ProviderNames += [ "AthenaPoolAddressProviderSvc/AthenaPoolAddressProviderSvcSecondary" ]
svcMgr.AthenaPoolAddressProviderSvcSecondary.DataHeaderKey = "SecondaryEventSelector"
# Set up DataVector/DataProxyStorage backwards compatibility.
#from DataModelAthenaPool import DataModelCompatSvc
svcMgr += CfgMgr.DataModelCompatSvc()
# Always want AddressRemappingSvc, since that's responsible for suppressing
# the read of objects that are produced by a WriteHandle.
from SGComps.AddressRemappingSvc import getAddressRemappingSvc
getAddressRemappingSvc()
msg.debug( "Configuring Athena for reading two POOL files concurrently... [DONE]" )
return
def Mdt_OverlayDigitizationTool(name="Mdt_OverlayDigitizationTool", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("EvtStore", overlayFlags.evtStore())
kwargs.setdefault("GetT0FromBD", overlayFlags.isDataOverlay())
return MdtDigitizationTool(name, **kwargs)
