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)