Cleanup final legacy overlay leftovers

AtlasTest/DatabaseTest/AthenaPoolTest/CMakeLists.txt

@@ -69,18 +69,20 @@ athenapooltest_run_test( AthenaPoolTestRead AthenaPoolTestRead
                          DEPENDS AthenaPoolTestWrite )
 
 # Write with DoubleEventSelector
-athenapooltest_run_test( AthenaPoolTestWriteDoubleSelector AthenaPoolTestWriteDoubleSelector
-                         "^DoubleEvent|^SecondaryEvent|^AthenaPoolTest" )
-athenapooltest_run_test( AthenaPoolTestReadDoubleSelector AthenaPoolTestReadDoubleSelector
-                         "^DoubleEvent|^SecondaryEvent|^AthenaPoolTest"
-                         DEPENDS AthenaPoolTestWriteDoubleSelector )
+# TODO: migrate to CA
+# athenapooltest_run_test( AthenaPoolTestWriteDoubleSelector AthenaPoolTestWriteDoubleSelector
+#                          "^DoubleEvent|^SecondaryEvent|^AthenaPoolTest" )
+# athenapooltest_run_test( AthenaPoolTestReadDoubleSelector AthenaPoolTestReadDoubleSelector
+#                          "^DoubleEvent|^SecondaryEvent|^AthenaPoolTest"
+#                          DEPENDS AthenaPoolTestWriteDoubleSelector )
 
 # Add on test of navigation still using simple objects:
 # AthenaPoolTestWrite - Step2 - rewrite part in another file
 # DoubleEventSelector
-athenapooltest_run_test( AthenaPoolTestStep2WriteDoubleSelector AthenaPoolTestStep2WriteDoubleSelector
-                         "^DoubleEvent|^SecondaryEvent|^AthenaPoolTest"
-                         DEPENDS AthenaPoolTestWriteDoubleSelector )
+# TODO: migrate to CA
+# athenapooltest_run_test( AthenaPoolTestStep2WriteDoubleSelector AthenaPoolTestStep2WriteDoubleSelector
+#                          "^DoubleEvent|^SecondaryEvent|^AthenaPoolTest"
+#                          DEPENDS AthenaPoolTestWriteDoubleSelector )
 # normal EventSelector
 athenapooltest_run_test( AthenaPoolTestStep2Write AthenaPoolTestStep2Write
                          "^AthenaPoolTestD"
@@ -101,12 +103,13 @@ athenapooltest_run_test( LArCellContRead LArCellContReader_jobOptions
                          DEPENDS LArCellContWriter )
 
 # Read two RDOs with the DoubleEventSelector
-athenapooltest_run_test( ReadRDODoubleSelector ReadRDODoubleSelector
-                         "^DoubleEvent|^SecondaryEvent|^RDOReader"
-                         DEPENDS InDetRawDataWriter LArCellContWriter )
-athenapooltest_run_test( ReadCombinedRDO ReadCombinedRDO
-                         "^DoubleEvent|^SecondaryEvent|^LArCellContFake|^InDetRawDataFak"
-                         DEPENDS ReadRDODoubleSelector )
+# TODO: migrate to CA
+# athenapooltest_run_test( ReadRDODoubleSelector ReadRDODoubleSelector
+#                          "^DoubleEvent|^SecondaryEvent|^RDOReader"
+#                          DEPENDS InDetRawDataWriter LArCellContWriter )
+# athenapooltest_run_test( ReadCombinedRDO ReadCombinedRDO
+#                          "^DoubleEvent|^SecondaryEvent|^LArCellContFake|^InDetRawDataFak"
+#                          DEPENDS ReadRDODoubleSelector )
 
 # Test basic overlay algorithms with DoubleEventSelector
 # TODO: migrate to CA

Database/AthenaPOOL/AthenaPoolCnvSvc/python/ReadAthenaPoolDouble.py

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-
-## @file ReadAthena.py
-## @brief AthenaPool python module for reading event objects.
-## @author Peter van Gemmeren <gemmeren@bnl.gov>
-###############################################################
-"""
-    Copy of the one made for standard EventSelector to work with
-    the DoubleEventSelector.
-"""
-
-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  # noqa: F401
-
-    # 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("EventSelector")    
-    theApp.EvtSel = "DoubleEventSelectorAthenaPool/EventSelector"
-
-    # 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
-
-## configuration at module import
-_configureReadAthenaPoolDouble()
-
-## clean-up: avoid running multiple times this method
-del _configureReadAthenaPoolDouble

Event/EventOverlay/OverlayCommonAlgs/CMakeLists.txt

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-
-# Declare the package name:
-atlas_subdir( OverlayCommonAlgs )
-
-# Install files from the package:
-atlas_install_python_modules( python/*.py POST_BUILD_CMD ${ATLAS_FLAKE8} )

Event/EventOverlay/OverlayCommonAlgs/python/OverlayFlags.py

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-
-"""
-Flag class for Pileup Overlay building
-
-usage:
-from OverlayCommonAlgs.OverlayFlags import overlayFlags
-overlayFlags.EventIDTextFile= runArgs.inputTXT_EVENTIDFile[0]
-
-"""
-
-from AthenaCommon.JobProperties import JobProperty, JobPropertyContainer, jobproperties
-
-from AthenaCommon.Logging import logging
-
-overlayflaglog = logging.getLogger('Overlay_Flags')
-
-class isOverlayMT(JobProperty):
-    """Flag to separate the new MT-ready overlay from the old one"""
-    statusOn=True
-    allowedTypes=['bool']
-    StoredValue = False
-
-class isDataOverlay(JobProperty):
-    """Flag to separate data vs MC overlay"""
-    statusOn=True
-    allowedTypes=['bool']
-    StoredValue = True
-
-class SkipSecondaryEvents(JobProperty):
-    """Number of secondary input events to skip when reading an input POOL file. This should
-    be given to the EventSelector service.
-    """
-    statusOn     = False
-    allowedTypes = ['int']
-    StoredValue  = -1
-
-class EventIDTextFile(JobProperty):
-    """Name of the Event ID Text file"""
-    statusOn=True
-    allowedTypes=['str']
-    StoredValue = 'events.txt'
-
-class signalOnlyOutput(JobProperty):
-    """Output signal-only RDOs"""
-    statusOn=True
-    allowedTypes=['bool']
-    StoredValue = False
-
-class PoolSignalRDOOutput(JobProperty):
-    """The name of the output signal POOL RDO file"""
-    statusOn     = True
-    allowedTypes = ['str']
-    StoredValue  = "RDO_SGNL.pool.root"     
-
-class evtStore(JobProperty):
-    """MC EvtStore name for overlay"""
-    statusOn=True
-    allowedTypes=['str']
-    StoredValue = 'BkgEvent_0_SG'
-
-class dataStore(JobProperty):
-    """Data EvtStore name for overlay"""
-    statusOn=True
-    allowedTypes=['str']
-    StoredValue = 'OriginalEvent_SG'
-    
-class outputStore(JobProperty):
-    """Output EvtStore name for overlay"""
-    statusOn=True
-    allowedTypes=['str']
-    StoredValue = 'StoreGateSvc'
-
-class bkgPrefix(JobProperty):
-    """Overlay background StoreGate key prefix"""
-    statusOn=True
-    allowedTypes=['str']
-    StoredValue = 'Bkg_'
-
-class sigPrefix(JobProperty):
-    """Overlay signal StoreGate key prefix"""
-    statusOn=True
-    allowedTypes=['str']
-    StoredValue = 'Sig_'
-
-class extraTagInfoPairs(JobProperty):
-    """ workaround to correctly populate the /TagInfo metadata container
-    """
-    statusOn=False
-    allowedTypes=['dict']
-    StoredValue=dict()
-
-class optionalContainerMap(JobProperty):
-    """ workaround to track presence of optional containers
-    """
-    statusOn=False
-    allowedTypes=['dict']
-    StoredValue=dict()
-
-class processLegacyEventInfo(JobProperty):
-    """ workaround to track presence of the legacy EventInfo """
-    statusOn=False
-    allowedTypes=['bool']
-    StoredValue = False
-
-class doTrackOverlay(JobProperty):
-    """ perform the track overlay (meaning that the ID overlay is turned off) """
-    statusOn=True
-    allowedTypes=['bool']
-    StoredValue=False
-
-## Definition and registration of the simulation flag container
-class Overlay_Flags(JobPropertyContainer):
-    """ The global Overlay flag/job property container.
-    """
-
-## Register and populate the Overlay_Flags container
-jobproperties.add_Container(Overlay_Flags)
-for jpname in dir():
-    jp = eval(jpname)
-    import inspect
-    if inspect.isclass(jp):
-        if issubclass(jp, JobProperty) and jp is not JobProperty:
-            overlayflaglog.debug("Adding OverlayFlag '%s' to Overlay_Flags container", jpname)
-            jobproperties.Overlay_Flags.add_JobProperty(jp)
-
-## Short-cut alias (standard naming)
-overlayFlags = jobproperties.Overlay_Flags

Event/EventOverlay/OverlayCommonAlgs/python/__init__.py

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-

Event/xAOD/xAODEventInfoCnv/python/EventInfoBeamSpotDecoratorAlgConfig.py

-# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-
-from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
-from AthenaConfiguration.ComponentFactory import CompFactory
-
-
-def EventInfoBeamSpotDecoratorAlgCfg(flags, name="EventInfoBeamSpotDecoratorAlg", eventInfoKey="EventInfo", **kwargs):
-    result = ComponentAccumulator()
-
-    from BeamSpotConditions.BeamSpotConditionsConfig import BeamSpotCondAlgCfg
-    result.merge(BeamSpotCondAlgCfg(flags))
-
-    kwargs.setdefault("beamPosXKey", f"{eventInfoKey}.beamPosX")
-    kwargs.setdefault("beamPosYKey", f"{eventInfoKey}.beamPosY")
-    kwargs.setdefault("beamPosZKey", f"{eventInfoKey}.beamPosZ")
-    kwargs.setdefault("beamPosSigmaXKey", f"{eventInfoKey}.beamPosSigmaX")
-    kwargs.setdefault("beamPosSigmaYKey", f"{eventInfoKey}.beamPosSigmaY")
-    kwargs.setdefault("beamPosSigmaZKey", f"{eventInfoKey}.beamPosSigmaZ")
-    kwargs.setdefault("beamPosSigmaXYKey", f"{eventInfoKey}.beamPosSigmaXY")
-    kwargs.setdefault("beamTiltXZKey", f"{eventInfoKey}.beamTiltXZ")
-    kwargs.setdefault("beamTiltYZKey", f"{eventInfoKey}.beamTiltYZ")
-    kwargs.setdefault("beamStatusKey", f"{eventInfoKey}.beamStatus")
-
-    result.addEventAlgo(CompFactory.xAODMaker.EventInfoBeamSpotDecoratorAlg(name, **kwargs))
-
-    return result

Event/xAOD/xAODEventInfoCnv/python/xAODEventInfoCnvConfig.py

@@ -134,3 +134,25 @@ def EventInfoUpdateFromContextAlgCfg(flags, name="EventInfoUpdateFromContextAlg"
     ]))
 
     return acc
+
+
+def EventInfoBeamSpotDecoratorAlgCfg(flags, name="EventInfoBeamSpotDecoratorAlg", eventInfoKey="EventInfo", **kwargs):
+    result = ComponentAccumulator()
+
+    from BeamSpotConditions.BeamSpotConditionsConfig import BeamSpotCondAlgCfg
+    result.merge(BeamSpotCondAlgCfg(flags))
+
+    kwargs.setdefault("beamPosXKey", f"{eventInfoKey}.beamPosX")
+    kwargs.setdefault("beamPosYKey", f"{eventInfoKey}.beamPosY")
+    kwargs.setdefault("beamPosZKey", f"{eventInfoKey}.beamPosZ")
+    kwargs.setdefault("beamPosSigmaXKey", f"{eventInfoKey}.beamPosSigmaX")
+    kwargs.setdefault("beamPosSigmaYKey", f"{eventInfoKey}.beamPosSigmaY")
+    kwargs.setdefault("beamPosSigmaZKey", f"{eventInfoKey}.beamPosSigmaZ")
+    kwargs.setdefault("beamPosSigmaXYKey", f"{eventInfoKey}.beamPosSigmaXY")
+    kwargs.setdefault("beamTiltXZKey", f"{eventInfoKey}.beamTiltXZ")
+    kwargs.setdefault("beamTiltYZKey", f"{eventInfoKey}.beamTiltYZ")
+    kwargs.setdefault("beamStatusKey", f"{eventInfoKey}.beamStatus")
+
+    result.addEventAlgo(CompFactory.xAODMaker.EventInfoBeamSpotDecoratorAlg(name, **kwargs))
+
+    return result

Event/xAOD/xAODEventInfoCnv/python/xAODEventInfoCnvConfigDb.py

-# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-
-from AthenaCommon.CfgGetter import addAlgorithm
-
-addAlgorithm("xAODEventInfoCnv.xAODEventInfoCnvConfigLegacy.getEventInfoOverlay", "EventInfoOverlay")
-addAlgorithm("xAODEventInfoCnv.xAODEventInfoCnvConfigLegacy.getEventInfoUpdateFromContextAlg", "EventInfoUpdateFromContextAlg")

Event/xAOD/xAODEventInfoCnv/python/xAODEventInfoCnvConfigLegacy.py

-# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-
-from AthenaCommon import CfgMgr
-
-
-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())
-
-    from AtlasGeoModel.CommonGMJobProperties import CommonGeometryFlags as commonGeoFlags
-    kwargs.setdefault("ValidateBeamSpot", not overlayFlags.isDataOverlay() and commonGeoFlags.Run() == "RUN3")
-
-    from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
-    if athenaCommonFlags.MCChannelNumber() > 0:
-        kwargs.setdefault("MCChannelNumber", athenaCommonFlags.MCChannelNumber())
-
-    return CfgMgr.xAODMaker__EventInfoOverlay(name, **kwargs)
-
-
-def getEventInfoUpdateFromContextAlg(name="EventInfoUpdateFromContextAlg", **kwargs):
-    from AthenaCommon.AlgSequence import AthSequencer
-    condSeq = AthSequencer("AthCondSeq")
-    if not hasattr(condSeq, "BeamSpotCondAlg"):
-        from IOVDbSvc.CondDB import conddb
-        conddb.addFolderSplitOnline("INDET","/Indet/Onl/Beampos","/Indet/Beampos", className='AthenaAttributeList')
-        condSeq += CfgMgr.BeamSpotCondAlg( "BeamSpotCondAlg" )
-    from SGComps import AddressRemappingSvc
-    AddressRemappingSvc.addInputRename("xAOD::EventInfo","EventInfo","Input_EventInfo")
-    AddressRemappingSvc.addInputRename("xAOD::EventAuxInfo","EventInfoAux.","Input_EventInfoAux.")
-
-    kwargs.setdefault("SignalInputKey", "Input_EventInfo")
-    kwargs.setdefault("OutputKey", "EventInfo")
-
-    from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
-    if athenaCommonFlags.MCChannelNumber() > 0:
-        kwargs.setdefault("MCChannelNumber", athenaCommonFlags.MCChannelNumber())
-
-    return CfgMgr.xAODMaker__EventInfoUpdateFromContextAlg(name, **kwargs)

MuonSpectrometer/MuonCnv/MuonByteStreamCnvTest/CMakeLists.txt

-# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 
 # Declare the package name:
 atlas_subdir( MuonByteStreamCnvTest )
@@ -13,6 +13,3 @@ atlas_add_library( MuonByteStreamCnvTestLib
 atlas_add_component( MuonByteStreamCnvTest
                      src/components/*.cxx
                      LINK_LIBRARIES MuonByteStreamCnvTestLib MuonCablingData MuonCondData MuonCSC_CnvToolsLib MuonMDT_CnvToolsLib MuonRPC_CnvToolsLib MuonTGC_CnvToolsLib MuonSTGC_CnvToolsLib MuonMM_CnvToolsLib )
-
-# Install files from the package:
-atlas_install_python_modules( python/*.py POST_BUILD_CMD ${ATLAS_FLAKE8} )

MuonSpectrometer/MuonCnv/MuonByteStreamCnvTest/python/MuonByteStreamCnvTestConfigDb.py

-# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-
-from AthenaCommon.CfgGetter import addAlgorithm, addTool
-
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getMdtRdoToMdtDigitAlg", "MdtRdoToMdtDigitAlg")
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getRpcRdoToRpcDigitAlg", "RpcRdoToRpcDigitAlg")
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getNrpcDigitToNrpcRDO", "NrpcRdoToNrpcDigitAlg")
-
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getTgcRdoToTgcDigitAlg", "TgcRdoToTgcDigitAlg")
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getSTGC_RdoToDigitAlg", "STGC_RdoToDigitAlg")
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getMM_RdoToDigitAlg", "MM_RdoToDigitAlg")
-
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getMdtDigitToMdtRDO" , "MdtDigitToMdtRDO")
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getRpcDigitToRpcRDO" , "RpcDigitToRpcRDO")
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getNrpcDigitToNrpcRDO" , "NrpcDigitToNrpcRDO")
-
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getTgcDigitToTgcRDO" , "TgcDigitToTgcRDO")
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getSTGC_DigitToRDO" , "STGC_DigitToRDO")
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getMM_DigitToRDO" , "MM_DigitToRDO")
-
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getSigMdtDigitToMdtRDO" , "SigMdtDigitToMdtRDO")
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getSigRpcDigitToRpcRDO" , "SigRpcDigitToRpcRDO")
-addAlgorithm("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getSigTgcDigitToTgcRDO" , "SigTgcDigitToTgcRDO")
-
-addTool("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getCscRdoDecoder", "CscRDO_Decoder")
-addTool("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getsTgcRdoDecoder", "STGC_RDO_Decoder")
-addTool("MuonByteStreamCnvTest.MuonByteStreamCnvTestConfigLegacy.getMmRdoDecoder", "MM_RDO_Decoder")

MuonSpectrometer/MuonCnv/MuonByteStreamCnvTest/python/MuonByteStreamCnvTestConfigLegacy.py

-# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-
-from AthenaCommon import CfgMgr
-
-def getMdtRdoToMdtDigitAlg(name="MdtRdoToMdtDigitAlg", **kwargs):
-    from OverlayCommonAlgs.OverlayFlags import overlayFlags
-    if overlayFlags.isOverlayMT():
-        kwargs.setdefault("MdtRdoContainer", overlayFlags.bkgPrefix() + "MDTCSM")
-        kwargs.setdefault("MdtDigitContainer", overlayFlags.bkgPrefix() + "MDT_DIGITS")
-    else:
-        kwargs.setdefault("EvtStore", overlayFlags.dataStore())
-        kwargs.setdefault("MdtRdoContainer", overlayFlags.dataStore()+"+MDTCSM")
-        kwargs.setdefault("MdtDigitContainer", overlayFlags.dataStore()+"+MDT_DIGITS")
-    return CfgMgr.MdtRdoToMdtDigit(name, **kwargs)
-
-
-def getRpcRdoToRpcDigitAlg(name="RpcRdoToRpcDigitAlg", **kwargs):
-    from OverlayCommonAlgs.OverlayFlags import overlayFlags
-    if overlayFlags.isOverlayMT():
-        kwargs.setdefault("RpcRdoContainer", overlayFlags.bkgPrefix() + "RPCPAD")
-        kwargs.setdefault("RpcDigitContainer", overlayFlags.bkgPrefix() + "RPC_DIGITS")
-    else:
-        kwargs.setdefault("EvtStore", overlayFlags.dataStore())
-        kwargs.setdefault("RpcRdoContainer", overlayFlags.dataStore()+"+RPCPAD")
-        kwargs.setdefault("RpcDigitContainer", overlayFlags.dataStore()+"+RPC_DIGITS")
-    return CfgMgr.RpcRdoToRpcDigit(name, **kwargs)
-
-
-def getTgcRdoToTgcDigitAlg(name="TgcRdoToTgcDigitAlg", **kwargs):
-    from OverlayCommonAlgs.OverlayFlags import overlayFlags
-    if overlayFlags.isOverlayMT():
-        kwargs.setdefault("TgcRdoContainer", overlayFlags.bkgPrefix() + "TGCRDO")
-        kwargs.setdefault("TgcDigitContainer", overlayFlags.bkgPrefix() + "TGC_DIGITS")
-    else:
-        kwargs.setdefault("EvtStore", overlayFlags.dataStore())
-        kwargs.setdefault("TgcRdoContainer", overlayFlags.dataStore()+"+TGCRDO")
-        kwargs.setdefault("TgcDigitContainer", overlayFlags.dataStore()+"+TGC_DIGITS")
-    return CfgMgr.TgcRdoToTgcDigit(name, **kwargs)
-
-
-def getSTGC_RdoToDigitAlg(name="STGC_RdoToDigitAlg", **kwargs):
-    from OverlayCommonAlgs.OverlayFlags import overlayFlags
-    if overlayFlags.isOverlayMT():
-        kwargs.setdefault("sTgcRdoContainer", overlayFlags.bkgPrefix() + "sTGCRDO")
-        kwargs.setdefault("sTgcDigitContainer", overlayFlags.bkgPrefix() + "sTGC_DIGITS")
-    else:
-        kwargs.setdefault("EvtStore", overlayFlags.dataStore())
-        kwargs.setdefault("sTgcRdoContainer", overlayFlags.dataStore()+"+sTGCRDO")
-        kwargs.setdefault("sTgcDigitContainer", overlayFlags.dataStore()+"+sTGC_DIGITS")
-    kwargs.setdefault("sTgcRdoDecoderTool", "STGC_RDO_Decoder")
-    return CfgMgr.STGC_RdoToDigit(name, **kwargs)
-
-
-def getMM_RdoToDigitAlg(name="MM_RdoToDigitAlg", **kwargs):
-    from OverlayCommonAlgs.OverlayFlags import overlayFlags
-    if overlayFlags.isOverlayMT():
-        kwargs.setdefault("MmRdoContainer", overlayFlags.bkgPrefix() + "MMRDO")
-        kwargs.setdefault("MmDigitContainer", overlayFlags.bkgPrefix() + "MM_DIGITS")
-    else:
-        kwargs.setdefault("EvtStore", overlayFlags.dataStore())
-        kwargs.setdefault("MmRdoContainer", overlayFlags.dataStore()+"+MMRDO")
-        kwargs.setdefault("MmDigitContainer", overlayFlags.dataStore()+"+MM_DIGITS")
-    kwargs.setdefault("mmRdoDecoderTool", "MM_RDO_Decoder")
-    return CfgMgr.MM_RdoToDigit(name, **kwargs)
-
-
-def getMdtDigitToMdtRDO(name="MdtDigitToMdtRDO", **kwargs):
-    from Digitization.DigitizationFlags import digitizationFlags
-    if digitizationFlags.PileUpPresampling and 'LegacyOverlay' not in digitizationFlags.experimentalDigi():
-        from OverlayCommonAlgs.OverlayFlags import overlayFlags
-        kwargs.setdefault("OutputObjectName", overlayFlags.bkgPrefix() + "MDTCSM")
-    else:
-        kwargs.setdefault("OutputObjectName", "MDTCSM")
-    from AtlasGeoModel.CommonGMJobProperties import CommonGeometryFlags
-    kwargs.setdefault("isPhaseII", CommonGeometryFlags.Run in ["RUN4"])
-    return CfgMgr.MdtDigitToMdtRDO(name, **kwargs)
-
-def getRpcDigitToRpcRDO(name="RpcDigitToRpcRDO", **kwargs):
-    from MuonRecExample import MuonAlignConfig  # noqa: F401 (import side-effects)
-    from Digitization.DigitizationFlags import digitizationFlags
-    if digitizationFlags.PileUpPresampling and 'LegacyOverlay' not in digitizationFlags.experimentalDigi():
-        from OverlayCommonAlgs.OverlayFlags import overlayFlags
-        kwargs.setdefault("OutputObjectName", overlayFlags.bkgPrefix() + "RPCPAD")
-    else:
-        kwargs.setdefault("OutputObjectName", "RPCPAD")
-    return CfgMgr.RpcDigitToRpcRDO(name, **kwargs)
-
-def getNrpcDigitToNrpcRDO(name="NrpcDigitToNrpcRDO", **kwargs):
-    from Digitization.DigitizationFlags import digitizationFlags
-    if digitizationFlags.PileUpPresampling and 'LegacyOverlay' not in digitizationFlags.experimentalDigi():
-        from OverlayCommonAlgs.OverlayFlags import overlayFlags
-        kwargs.setdefault("NrpcRdoKey", overlayFlags.bkgPrefix() + "NRPCRDO")
-    else:
-        kwargs.setdefault("NrpcRdoKey", "NRPCRDO")
-    return CfgMgr.NrpcDigitToNrpcRDO(name, **kwargs)
-
-def getTgcDigitToTgcRDO(name="TgcDigitToTgcRDO", **kwargs):
-    from Digitization.DigitizationFlags import digitizationFlags
-    if digitizationFlags.PileUpPresampling and 'LegacyOverlay' not in digitizationFlags.experimentalDigi():
-        from OverlayCommonAlgs.OverlayFlags import overlayFlags
-        kwargs.setdefault("OutputObjectName", overlayFlags.bkgPrefix() + "TGCRDO")
-    else:
-        kwargs.setdefault("OutputObjectName", "TGCRDO")
-    return CfgMgr.TgcDigitToTgcRDO(name, **kwargs)
-
-
-def getSTGC_DigitToRDO(name="STGC_DigitToRDO", **kwargs):
-    from Digitization.DigitizationFlags import digitizationFlags
-    if digitizationFlags.PileUpPresampling and 'LegacyOverlay' not in digitizationFlags.experimentalDigi():
-        from OverlayCommonAlgs.OverlayFlags import overlayFlags
-        kwargs.setdefault("OutputObjectName", overlayFlags.bkgPrefix() + "sTGCRDO")
-    else:
-        kwargs.setdefault("OutputObjectName", "sTGCRDO")
-    kwargs.setdefault("CalibrationTool", "NSWCalibTool")
-    return CfgMgr.STGC_DigitToRDO(name, **kwargs)
-
-
-def getMM_DigitToRDO(name="MM_DigitToRDO", **kwargs):
-    from Digitization.DigitizationFlags import digitizationFlags
-    if digitizationFlags.PileUpPresampling and 'LegacyOverlay' not in digitizationFlags.experimentalDigi():
-        from OverlayCommonAlgs.OverlayFlags import overlayFlags
-        kwargs.setdefault("OutputObjectName", overlayFlags.bkgPrefix() + "MMRDO")
-    else:
-        kwargs.setdefault("OutputObjectName", "MMRDO")
-    kwargs.setdefault("CalibrationTool", "NSWCalibTool")
-    return CfgMgr.MM_DigitToRDO(name, **kwargs)
-
-
-def getSigMdtDigitToMdtRDO(name="SigMdtDigitToMdtRDO", **kwargs):
-    from OverlayCommonAlgs.OverlayFlags import overlayFlags
-    kwargs.setdefault("InputObjectName",overlayFlags.evtStore()+"+MDT_DIGITS")
-    kwargs.setdefault("OutputObjectName",overlayFlags.evtStore()+"+MDTCSM")
-    from AtlasGeoModel.CommonGMJobProperties import CommonGeometryFlags  
-    kwargs.setdefault("isPhaseII", CommonGeometryFlags.Run in ["RUN4"])
-    return CfgMgr.MdtDigitToMdtRDO(name, **kwargs)
-
-
-def getSigRpcDigitToRpcRDO(name="SigRpcDigitToRpcRDO", **kwargs):
-    from OverlayCommonAlgs.OverlayFlags import overlayFlags
-    kwargs.setdefault("InputObjectName",overlayFlags.evtStore()+"+RPC_DIGITS")
-    kwargs.setdefault("OutputObjectName",overlayFlags.evtStore()+"+RPCPAD")
-    return CfgMgr.RpcDigitToRpcRDO(name, **kwargs)
-
-
-def getSigTgcDigitToTgcRDO(name="SigTgcDigitToTgcRDO", **kwargs):
-    from OverlayCommonAlgs.OverlayFlags import overlayFlags
-    kwargs.setdefault("InputObjectName",overlayFlags.evtStore()+"+TGC_DIGITS")
-    kwargs.setdefault("OutputObjectName",overlayFlags.evtStore()+"+TGCRDO")
-    return CfgMgr.TgcDigitToTgcRDO(name, **kwargs)
-
-
-def getCscRdoDecoder(name="CscRDO_Decoder", **kwargs):
-    return CfgMgr.Muon__CscRDO_Decoder(name, **kwargs)
-
-
-def getsTgcRdoDecoder(name="STGC_RDO_Decoder", **kwargs):
-    kwargs.setdefault("CalibrationTool", "NSWCalibTool")
-    return CfgMgr.Muon__STGC_RDO_Decoder(name,**kwargs)
-
-
-def getMmRdoDecoder(name = "MM_RDO_Decoder", **kwargs):
-    kwargs.setdefault("CalibrationTool", "NSWCalibTool")
-    return CfgMgr.Muon__MM_RDO_Decoder(name,**kwargs)

Reconstruction/HeavyIonRec/HIRecConfig/python/HIRecConfig.py

@@ -77,7 +77,7 @@ if __name__ == "__main__":
     from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
     acc.merge(ByteStreamReadCfg(flags))
     if flags.Reco.EnableBeamSpotDecoration:
-        from xAODEventInfoCnv.EventInfoBeamSpotDecoratorAlgConfig import EventInfoBeamSpotDecoratorAlgCfg
+        from xAODEventInfoCnv.xAODEventInfoCnvConfig import EventInfoBeamSpotDecoratorAlgCfg
         acc.merge(EventInfoBeamSpotDecoratorAlgCfg(flags))
     if flags.HeavyIon.redoTracking:
         from InDetConfig.TrackRecoConfig import InDetTrackRecoCfg

Reconstruction/RecExample/RecExOnline/share/GlobalMonitoring_CA.py

 #!/usr/bin/env python3
 #
-# Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 #
 '''
 @author Tulin Mete
@@ -187,9 +187,6 @@ if __name__=='__main__':
 
     flags.dump()
 
-    from AthenaConfiguration.ComponentFactory import CompFactory
-    from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
-
     from AthenaConfiguration.MainServicesConfig import MainServicesCfg
     acc = MainServicesCfg(flags)
 
@@ -230,10 +227,10 @@ if __name__=='__main__':
             bytestreamInput.StreamNames = ['express','IDCosmic','HLT_IDCosmic','CosmicMuons','CosmicCalo']
         else:
             if GetAtlasReady():
-                printfunc ("ATLAS READY, reading express stream")
+                print ("ATLAS READY, reading express stream")
                 bytestreamInput.StreamNames = ['express']
             else:
-                printfunc ("ATLAS NOT READY, reading standby stream")
+                print ("ATLAS NOT READY, reading standby stream")
                 bytestreamInput.StreamNames = ['express','IDCosmic','HLT_IDCosmic','CosmicMuons','MinBias','Standby','Main','CosmicCalo']
     else:
         bytestreamInput.StreamLogic = 'Ignore'
@@ -247,7 +244,7 @@ if __name__=='__main__':
     # This needs to be fixed by muon experts 
     # ######################################################################
 
-    from xAODEventInfoCnv.EventInfoBeamSpotDecoratorAlgConfig import EventInfoBeamSpotDecoratorAlgCfg
+    from xAODEventInfoCnv.xAODEventInfoCnvConfig import EventInfoBeamSpotDecoratorAlgCfg
     acc.merge(EventInfoBeamSpotDecoratorAlgCfg(flags))
 
     # ###########################################################

Reconstruction/RecJobTransforms/python/RecoSteering.py

-# Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 
 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
 from AthenaConfiguration.Enums import Format, MetadataCategory, HIMode
@@ -19,7 +19,7 @@ def RecoSteering(flags):
         acc.merge(ByteStreamReadCfg(flags))
         # Decorate EventInfo obj with Beam Spot information
         if flags.Reco.EnableBeamSpotDecoration:
-            from xAODEventInfoCnv.EventInfoBeamSpotDecoratorAlgConfig import (
+            from xAODEventInfoCnv.xAODEventInfoCnvConfig import (
                 EventInfoBeamSpotDecoratorAlgCfg)
             acc.merge(EventInfoBeamSpotDecoratorAlgCfg(flags))
         log.info("---------- Configured BS reading")

Simulation/BeamEffects/python/BeamEffectsConfigDb.py

-# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
-
-from AthenaCommon.CfgGetter import addAlgorithm
-## Algorithms
-addAlgorithm("BeamEffects.BeamEffectsConfigLegacy.getBeamSpotFixerAlg",             "BeamSpotFixerAlg")
-addAlgorithm("BeamEffects.BeamEffectsConfigLegacy.getBeamSpotReweightingAlg",       "BeamSpotReweightingAlg")
-

Simulation/BeamEffects/python/BeamEffectsConfigLegacy.py

-# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
-
-"""
-Configurations for classes in BeamEffects package
-"""
-
-from AthenaCommon import CfgMgr
-
-def getBeamSpotFixerAlg(name="BeamSpotFixerAlg", **kwargs):
-    kwargs.setdefault('InputKey', 'Input_EventInfo')
-
-    from Digitization.DigitizationFlags import digitizationFlags
-    if digitizationFlags.PileUpPresampling and 'LegacyOverlay' not in digitizationFlags.experimentalDigi():
-        from OverlayCommonAlgs.OverlayFlags import overlayFlags
-        kwargs.setdefault('OutputKey', overlayFlags.bkgPrefix() + 'EventInfo')
-    else:
-        kwargs.setdefault('OutputKey', 'EventInfo')
-
-    return CfgMgr.Simulation__BeamSpotFixerAlg(name, **kwargs)
-
-def getBeamSpotReweightingAlg(name="BeamSpotReweightingAlg", **kwargs):
-    from Digitization.DigitizationFlags import digitizationFlags
-    kwargs.setdefault('Input_beam_sigma_z', digitizationFlags.OldBeamSpotZSize())
-
-    return CfgMgr.Simulation__BeamSpotReweightingAlg(name, **kwargs)

Simulation/FastSimulation/FastChainPileup/test/test_MC21a_ATLFAST3F_G4MS_HybridOverlay_ttbar_CA.sh

@@ -58,7 +58,7 @@ if [ ${ca} -eq 0 ]
 then
     # Reconstruction
     Reco_tf.py \
-               --CA "all:True" "RDOtoRDOTrigger:False" \
+               --CA \
                --inputRDOFile ${RDO_File} \
                --outputAODFile ${AOD_File} \
                --steering 'doRDO_TRIG' 'doTRIGtoALL' \
@@ -68,7 +68,7 @@ then
                --geometryVersion 'ATLAS-R3S-2021-03-00-00' \
                --athenaopts "all:--threads=1" \
                --postExec 'RAWtoALL:from AthenaCommon.ConfigurationShelve import saveToAscii;saveToAscii("RAWtoALL_config.txt")' \
-               --preExec 'RAWtoALL:flags.Reco.EnableTrackOverlay=True;' 'RDOtoRDOTrigger:from OverlayCommonAlgs.OverlayFlags import overlayFlags; overlayFlags.doTrackOverlay=True; ConfigFlags.Overlay.doTrackOverlay=True;'\
+               --preExec 'all:flags.Overlay.doTrackOverlay=True;' \
                --imf False
 
      rec=$?
@@ -80,7 +80,7 @@ then
                     --maxEvents '-1' \
                     --conditionsTag 'OFLCOND-MC21-SDR-RUN3-07' \
                     --geometryVersion 'ATLAS-R3S-2021-03-00-00' \
-		    --asetup 'Athena,23.0.53' \
+		                --asetup 'Athena,23.0.53' \
                     --ignoreErrors True \
                     --validationFlags 'doInDet' \
                     --valid 'True'

Simulation/FastSimulation/FastChainPileup/test/test_MC21a_ATLFAST3F_G4MS_MCOverlay2_ttbar_CA.sh

@@ -58,7 +58,7 @@ if [ ${ca} -eq 0 ]
 then
     # Reconstruction
     Reco_tf.py \
-               --CA "all:True" "RDOtoRDOTrigger:False" \
+               --CA \
                --inputRDOFile ${RDO_File} \
                --outputAODFile ${AOD_File} \
                --steering 'doRDO_TRIG' 'doTRIGtoALL' \
@@ -68,7 +68,7 @@ then
                --geometryVersion 'ATLAS-R3S-2021-03-00-00' \
                --athenaopts "all:--threads=1" \
                --postExec 'RAWtoALL:from AthenaCommon.ConfigurationShelve import saveToAscii;saveToAscii("RAWtoALL_config.txt")' \
-               --preExec 'RAWtoALL:flags.Reco.EnableTrackOverlay=True; flags.TrackOverlay.MLThreshold=0.1;' 'RDOtoRDOTrigger:from OverlayCommonAlgs.OverlayFlags import overlayFlags; overlayFlags.doTrackOverlay=True; ConfigFlags.Overlay.doTrackOverlay=True;'\
+               --preExec 'RAWtoALL:flags.Reco.EnableTrackOverlay=True; flags.TrackOverlay.MLThreshold=0.1;' 'RDOtoRDOTrigger:flags.Overlay.doTrackOverlay=True;'\
                --imf False
 
      rec=$?
@@ -80,7 +80,7 @@ then
                     --maxEvents '-1' \
                     --conditionsTag 'OFLCOND-MC21-SDR-RUN3-07' \
                     --geometryVersion 'ATLAS-R3S-2021-03-00-00' \
-		    --asetup 'Athena,23.0.53' \
+		                --asetup 'Athena,23.0.53' \
                     --ignoreErrors True \
                     --validationFlags 'doInDet' \
                     --valid 'True'

Simulation/FastSimulation/FastChainPileup/test/test_MC21a_ATLFAST3F_G4MS_MCOverlay_ttbar_CA.sh

@@ -56,7 +56,7 @@ if [ ${ca} -eq 0 ]
 then
     # Reconstruction
     Reco_tf.py \
-               --CA "all:True" "RDOtoRDOTrigger:False" \
+               --CA \
                --inputRDOFile ${RDO_File} \
                --outputAODFile ${AOD_File} \
                --steering 'doRDO_TRIG' 'doTRIGtoALL' \