diff --git a/Control/AthenaConfiguration/python/AllConfigFlags.py b/Control/AthenaConfiguration/python/AllConfigFlags.py
index 3dbc6b7a75c84e0e220d291d95a834f3f65332ec..c47cf0cd001edaf8fadaa8299d2e543fbfa124a6 100644
--- a/Control/AthenaConfiguration/python/AllConfigFlags.py
+++ b/Control/AthenaConfiguration/python/AllConfigFlags.py
@@ -70,6 +70,8 @@ def _createCfgFlags():
     acf.addFlag("GeoModel.Align.Dynamic", lambda prevFlags : (not prevFlags.Detector.Simulate))
     acf.addFlag("GeoModel.StripGeoType", "GMX") # Based on CommonGeometryFlags.StripGeoType
     acf.addFlag("GeoModel.Run","RUN2") # Based on CommonGeometryFlags.Run (InDetGeometryFlags.isSLHC replaced by GeoModel.Run=="RUN4")
+    acf.addFlag("GeoModel.Type", "UNDEFINED") # Geometry type in {ITKLoI, ITkLoI-VF, etc...}
+    acf.addFlag("GeoModel.IBLLayout", "UNDEFINED") # IBL layer layout  in {"planar", "3D", "noIBL", "UNDEFINED"}
 
 #IOVDbSvc Flags:
     acf.addFlag("IOVDb.GlobalTag",lambda prevFlags : GetFileMD(prevFlags.Input.Files).get("ConditionsTag","CONDBR2-BLKPA-2017-05"))
@@ -94,6 +96,8 @@ def _createCfgFlags():
     acf.addFlag("Calo.TopoCluster.doTreatEnergyCutAsAbsolute",False)
     acf.addFlag("Calo.TopoCluster.doTopoClusterLocalCalib",True)
 
+#Random engine Flags:
+    acf.addFlag("Random.Engine", "dSFMT") # Random service used in {"dSFMT", "Ranlux64", "Ranecu"}
 
     def __trigger():
         from TriggerJobOpts.TriggerConfigFlags import createTriggerFlags
diff --git a/Event/EventOverlay/OverlayCommonAlgs/python/OverlayConfigFlags.py b/Event/EventOverlay/OverlayCommonAlgs/python/OverlayConfigFlags.py
new file mode 100644
index 0000000000000000000000000000000000000000..19092cba371d46e031bf996e91a7c59e86072e2d
--- /dev/null
+++ b/Event/EventOverlay/OverlayCommonAlgs/python/OverlayConfigFlags.py
@@ -0,0 +1,19 @@
+"""Construct ConfigFlags for Overlay
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.AthConfigFlags import AthConfigFlags
+
+def createOverlayCfgFlags():
+    """Return an AthConfigFlags object with required flags"""
+    flags = AthConfigFlags()
+    # Overlay background StoreGate key prefix
+    flags.addFlag("Overlay.BkgPrefix", "Bkg_")
+    # Overlay signal StoreGate key prefix
+    flags.addFlag("Overlay.SigPrefix", "Sig_")
+    # Are we multithreaded?
+    flags.addFlag("Overlay.Legacy.MT", False)
+    # Name of MC EvtStore to overlay
+    flags.addFlag("Overlay.Legacy.EventStore", "BkgEvent_0_SG")
+    return flags
+
diff --git a/InnerDetector/InDetConditions/PixelConditionsTools/CMakeLists.txt b/InnerDetector/InDetConditions/PixelConditionsTools/CMakeLists.txt
index 0209bebcef783579de54bb7e819f634d7cd1a298..803c1555eab818a10e104ede9cd97652852a4953 100644
--- a/InnerDetector/InDetConditions/PixelConditionsTools/CMakeLists.txt
+++ b/InnerDetector/InDetConditions/PixelConditionsTools/CMakeLists.txt
@@ -51,6 +51,12 @@ atlas_add_component( PixelConditionsTools
                      INCLUDE_DIRS ${CORAL_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS} ${EIGEN_INCLUDE_DIRS}
                      LINK_LIBRARIES ${CORAL_LIBRARIES} ${CLHEP_LIBRARIES} ${EIGEN_LIBRARIES} AthenaKernel GeoPrimitives GaudiKernel AthenaBaseComps SGTools AthenaPoolUtilities DetDescrConditions Identifier PixelConditionsData PixelCoralClientUtils InDetIdentifier GeoModelUtilities InDetReadoutGeometry PathResolver ${extra_lib} )
 
+if( NOT SIMULATIONBASE )
+  atlas_add_test( PixelConditionsConfig_test
+                  SCRIPT test/PixelConditionsConfig_test.py
+                  PROPERTIES TIMEOUT 30 )
+endif()
+
 # Install files from the package:
 atlas_install_headers( PixelConditionsTools )
 atlas_install_joboptions( share/*.py )
diff --git a/InnerDetector/InDetConditions/PixelConditionsTools/python/PixelConditionsSummaryConfig.py b/InnerDetector/InDetConditions/PixelConditionsTools/python/PixelConditionsSummaryConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f5af82d70f289d60b5d0bd5910644c69b3be4c4
--- /dev/null
+++ b/InnerDetector/InDetConditions/PixelConditionsTools/python/PixelConditionsSummaryConfig.py
@@ -0,0 +1,35 @@
+"""Define methods to configure PixelConditionsSummary
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from IOVDbSvc.IOVDbSvcConfig import addFolders, addFoldersSplitOnline
+from PixelConditionsTools.PixelConditionsToolsConf import PixelConditionsSummaryTool
+from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelTDAQCondAlg
+from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelConfigCondAlg
+from PixelConditionsTools.PixelDCSConditionsConfig import PixelDCSConditionsCfg
+
+def PixelConditionsSummaryCfg(flags, name="PixelConditionsSummary", **kwargs):
+    """Return configured ComponentAccumulator and tool for PixelDCSConditions"""
+    acc = ComponentAccumulator()
+    kwargs.setdefault("UseDCSState", False)
+    kwargs.setdefault("UseByteStream", False)
+    kwargs.setdefault("UseTDAQ", False)
+    kwargs.setdefault("UseDeadMap", True)
+    PixelDeadMapFolder = "/PIXEL/PixMapOverlay"
+    if kwargs["UseDCSState"]:
+        acc.merge(PixelDCSConditionsCfg(flags, DCSConditionsTool=DCSTool))
+    if kwargs["UseTDAQ"]:
+        PixelTDAQFolder = "/TDAQ/Resources/ATLAS/PIXEL/Modules"
+        acc.merge(addFolders(flags, PixelTDAQFolder, "TDAQ_ONL", "CondAttrListCollection"))
+        acc.addCondAlgo(PixelTDAQCondAlg(name="PixelTDAQCondAlg", ReadKey=PixelTDAQFolder))
+    if kwargs["UseDeadMap"]:
+        acc.merge(addFolders(flags, PixelDeadMapFolder, "PIXEL_OFL","CondAttrListCollection"))
+        acc.merge(addFoldersSplitOnline(flags, "PIXEL", "/PIXEL/Onl/PixMapOverlay",
+                                        "/PIXEL/PixMapOverlay", "CondAttrListCollection"))
+    acc.addCondAlgo(PixelConfigCondAlg(name=name + "CondAlg", 
+                                       UseDeadMap=kwargs["UseDeadMap"],
+                                       ReadDeadMapKey=PixelDeadMapFolder))
+    tool = PixelConditionsSummaryTool(name=name + "Tool", **kwargs)
+    return acc, tool
+
diff --git a/InnerDetector/InDetConditions/PixelConditionsTools/python/PixelDCSConditionsConfig.py b/InnerDetector/InDetConditions/PixelConditionsTools/python/PixelDCSConditionsConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..60fd358a48a51a3bc2a74651cee74451f0068dc3
--- /dev/null
+++ b/InnerDetector/InDetConditions/PixelConditionsTools/python/PixelDCSConditionsConfig.py
@@ -0,0 +1,31 @@
+"""Define methods to configure PixelDCSConditions
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from IOVDbSvc.IOVDbSvcConfig import addFolders
+from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDCSCondStateAlg
+from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDCSCondHVAlg
+from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDCSCondTempAlg
+
+def PixelDCSConditionsCfg(flags, name="PixelDCSCond", **kwargs):
+    """Return configured ComponentAccumulator and tool for PixelDCSConditions"""
+    acc = ComponentAccumulator()
+    kwargs.setdefault("UseConditions", True)
+    if flags.Common.isOnline:
+        hvFolder = "/PIXEL/HLT/DCS/HV"
+        tempFolder = "/PIXEL/HLT/DCS/TEMPERATURE"
+        dbInstance = "PIXEL_ONL"
+    else:
+        hvFolder = "/PIXEL/DCS/HV"
+        tempFolder = "/PIXEL/DCS/TEMPERATURE"
+        dbInstance = "DCS_OFL"
+    folders = [hvFolder, tempFolder]
+    if not flags.Input.isMC:
+        folders.extend(["/PIXEL/DCS/FSMSTATE", "/PIXEL/DCS/FSMSTATUS"])
+        acc.addCondAlgo(PixelDCSCondStateAlg(name=name + "StateAlg"))
+    acc.merge(addFolders(flags, folders, dbInstance, "CondAttrListCollection"))
+    acc.addCondAlgo(PixelDCSCondHVAlg(name=name + "HVAlg", ReadKey=hvFolder))
+    acc.addCondAlgo(PixelDCSCondTempAlg(name=name + "TempAlg", ReadKey=tempFolder))
+    return acc
+
diff --git a/InnerDetector/InDetConditions/PixelConditionsTools/test/PixelConditionsConfig_test.py b/InnerDetector/InDetConditions/PixelConditionsTools/test/PixelConditionsConfig_test.py
new file mode 100755
index 0000000000000000000000000000000000000000..182a291c0788e270f6af93675e74d3064ce548d8
--- /dev/null
+++ b/InnerDetector/InDetConditions/PixelConditionsTools/test/PixelConditionsConfig_test.py
@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+"""Run tests on PixelConditionsTools/python/*Config.py scripts
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.AllConfigFlags import ConfigFlags
+from AthenaConfiguration.TestDefaults import defaultTestFiles
+from AthenaCommon.Logging import log
+from AthenaCommon.Constants import DEBUG
+from AthenaCommon.Configurable import Configurable
+from PixelConditionsTools.PixelDCSConditionsConfig import PixelDCSConditionsCfg
+from PixelConditionsTools.PixelConditionsSummaryConfig import PixelConditionsSummaryCfg
+
+# test setup
+log.setLevel(DEBUG)
+Configurable.configurableRun3Behavior = True
+ConfigFlags.Input.Files = defaultTestFiles.HITS
+# test
+DCSAcc = PixelDCSConditionsCfg(ConfigFlags, name="DCSTest")
+SummaryAcc, SummaryTool = PixelConditionsSummaryCfg(ConfigFlags, name="SummaryTest")
+# prevent raise on __del__
+DCSAcc.wasMerged()
+SummaryAcc.wasMerged()
+
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/CMakeLists.txt b/InnerDetector/InDetConditions/SCT_ConditionsTools/CMakeLists.txt
index 6f3c6525d757d1c3c5a57d2406b0b6de8bdf84cc..6a707095ed0d41a8cdcec804624e2d2f8475324c 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/CMakeLists.txt
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/CMakeLists.txt
@@ -52,7 +52,12 @@ atlas_add_test( SCT_RODVetoTool_test
                 LINK_LIBRARIES TestTools SCT_ConditionsToolsLib ${GTEST_LIBRARIES} ${GMOCK_LIBRARIES}
                 ENVIRONMENT "JOBOPTSEARCHPATH=${CMAKE_CURRENT_SOURCE_DIR}/share" )
 
+atlas_add_test( SCT_ConditionsConfig_test
+                SCRIPT test/SCT_ConditionsConfig_test.py
+                PROPERTIES TIMEOUT 300 )
+
 # Install files from the package:
 atlas_install_headers( SCT_ConditionsTools )
 atlas_install_python_modules( python/*.py )
 atlas_install_scripts( share/*.py )
+
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_DCSConditionsConfig.py b/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_DCSConditionsConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f09f2eb727d1285a8a00395b7b76728c58c0d9d
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_DCSConditionsConfig.py
@@ -0,0 +1,48 @@
+"""Define methods to configure SCT_DCSConditions
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from IOVDbSvc.IOVDbSvcConfig import addFolders
+from SCT_ConditionsTools.SCT_ConditionsToolsConf import SCT_DCSConditionsTool
+from SCT_ConditionsAlgorithms.SCT_ConditionsAlgorithmsConf import SCT_DCSConditionsStatCondAlg
+from SCT_ConditionsAlgorithms.SCT_ConditionsAlgorithmsConf import SCT_DCSConditionsHVCondAlg
+from SCT_ConditionsAlgorithms.SCT_ConditionsAlgorithmsConf import SCT_DCSConditionsTempCondAlg
+
+def SCT_DCSConditionsToolCfg(flags, name="InDetSCT_DCSConditionsTool", **kwargs):
+    """Return a configured SCT_DCSConditionsTool"""
+    kwargs.setdefault("ReadAllDBFolders", True)
+    kwargs.setdefault("ReturnHVTemp", True)
+    return SCT_DCSConditionsTool(name, **kwargs)
+
+def SCT_DCSConditionsCfg(flags, name="InDetSCT_DCSConditions", **kwargs):
+    """Return configured ComponentAccumulator and tool for SCT_DCSConditions
+
+    DCSConditionsTool may be provided in kwargs
+    """
+    acc = ComponentAccumulator()
+    tool = kwargs.get("DCSConditionsTool", SCT_DCSConditionsToolCfg(flags))
+    # folder arguments
+    dbInstance = kwargs.get("dbInstance", "DCS_OFL")
+    hvFolder = kwargs.get("hvFolder", "/SCT/DCS/HV")
+    tempFolder = kwargs.get("tempFolder", "/SCT/DCS/MODTEMP")
+    stateFolder = kwargs.get("stateFolder", "/SCT/DCS/CHANSTAT")
+    if tool.ReadAllDBFolders == tool.ReturnHVTemp:
+        acc.merge(addFolders(flags, stateFolder, dbInstance, className="CondAttrListCollection"))
+        # algo
+        statArgs = {
+            "name": name + "StatCondAlg",
+            "ReturnHVTemp": tool.ReturnHVTemp,
+            "ReadKeyHV": hvFolder,
+            "ReadKeyState": stateFolder,
+        }
+        statAlg = SCT_DCSConditionsStatCondAlg(**statArgs)
+        acc.addCondAlgo(statAlg)
+    if tool.ReturnHVTemp:
+        acc.merge(addFolders(flags, [hvFolder, tempFolder], dbInstance, className="CondAttrListCollection"))
+        hvAlg = SCT_DCSConditionsHVCondAlg(name=name + "HVCondAlg", ReadKey=hvFolder)
+        acc.addCondAlgo(hvAlg)
+        tempAlg = SCT_DCSConditionsTempCondAlg(name=name + "TempCondAlg", ReadKey=tempFolder)
+        acc.addCondAlgo(tempAlg)
+    return acc, tool
+
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_ReadCalibChipDataConfig.py b/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_ReadCalibChipDataConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..0727f41c115870ea81b2185dc4df3bb3f46bc755
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_ReadCalibChipDataConfig.py
@@ -0,0 +1,33 @@
+"""Define methods to configure ReadCalibChipDataTool
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from IOVDbSvc.IOVDbSvcConfig import addFoldersSplitOnline
+from SCT_ConditionsTools.SCT_ConditionsToolsConf import SCT_ReadCalibChipDataTool
+from SCT_ConditionsAlgorithms.SCT_ConditionsAlgorithmsConf import SCT_ReadCalibChipNoiseCondAlg
+from SCT_ConditionsAlgorithms.SCT_ConditionsAlgorithmsConf import SCT_ReadCalibChipGainCondAlg
+
+def SCT_ReadCalibChipDataToolCfg(flags, name="InDetSCT_ReadCalibChipDataTool", **kwargs):
+    """Return a ReadCalibChipDataTool configured for SCT"""
+    return SCT_ReadCalibChipDataTool(name, **kwargs)
+
+def SCT_ReadCalibChipDataCfg(flags, name="SCT_ReadCalibChip", **kwargs):
+    """Return configured ComponentAccumulator and tool for SCT_ReadCalibChipDataCfg
+
+    Accepts optional noiseFolder and gainFolder keyword arguments
+    """
+    acc = ComponentAccumulator()
+    # folders
+    noiseFolder = kwargs.get("noiseFolder", "/SCT/DAQ/Calibration/ChipNoise")
+    acc.merge(addFoldersSplitOnline(flags, "SCT", noiseFolder, noiseFolder, "CondAttrListCollection"))
+    gainFolder = kwargs.get("gainFolder", "/SCT/DAQ/Calibration/ChipGain")
+    acc.merge(addFoldersSplitOnline(flags, "SCT", gainFolder, gainFolder, "CondAttrListCollection"))
+    # Algorithms
+    noiseAlg = SCT_ReadCalibChipNoiseCondAlg(name=name + "NoiseCondAlg", ReadKey=noiseFolder)
+    acc.addCondAlgo(noiseAlg)
+    gainAlg = SCT_ReadCalibChipGainCondAlg(name=name + "GainCondAlg", ReadKey=gainFolder)
+    acc.addCondAlgo(gainAlg)
+    tool = kwargs.get("ReadCalibChipDataTool", SCT_ReadCalibChipDataToolCfg(flags))
+    return acc, tool
+
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_SiliconConditionsConfig.py b/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_SiliconConditionsConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb841600267fcbdb457f6f6a8c2446c513ed1358
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_SiliconConditionsConfig.py
@@ -0,0 +1,34 @@
+"""Define methods to configure SiPropertiesTool
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from SCT_ConditionsAlgorithms.SCT_ConditionsAlgorithmsConf import SCT_SiliconHVCondAlg
+from SCT_ConditionsAlgorithms.SCT_ConditionsAlgorithmsConf import SCT_SiliconTempCondAlg
+from SCT_ConditionsTools.SCT_ConditionsToolsConf import SCT_SiliconConditionsTool
+
+def SCT_SiliconConditionsToolCfg(flags, name="SCT_SiliconConditionsTool", **kwargs):
+    """Return a configured SCT_SiliconConditionsTool (a.k.a. SiConditionsTool)"""
+    kwargs.setdefault("UseDB", True)
+    kwargs.setdefault("ForceUseGeoModel", False)
+    return SCT_SiliconConditionsTool(name, **kwargs)
+
+def SCT_SiliconConditionsCfg(flags, name="SCT_Silicon", **kwargs):
+    """Return configured ComponentAccumulator and tool for SCT_SiliconConditions
+
+    SiConditionsTool and/or DCSConditionsTool may be provided in kwargs
+    """
+    acc = ComponentAccumulator()
+    tool = kwargs.get("SiConditionsTool", SCT_SiliconConditionsToolCfg(flags))
+    if tool.UseDB:
+        CondArgs = {}
+        if "DCSConditionsTool" in kwargs:
+            DCSConditionsTool = kwargs["DCSConditionsTool"]
+            CondArgs["UseState"] = DCSConditionsTool.ReadAllDBFolders
+            CondArgs["DCSConditionsTool"] = DCSConditionsTool
+        hvAlg = SCT_SiliconHVCondAlg(name=name + "HVCondAlg", **CondArgs)
+        tempAlg = SCT_SiliconTempCondAlg(name=name + "TempCondAlg", **CondArgs)
+        acc.addCondAlgo(hvAlg)
+        acc.addCondAlgo(tempAlg)
+    return acc, tool
+
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/test/SCT_ConditionsConfig_test.py b/InnerDetector/InDetConditions/SCT_ConditionsTools/test/SCT_ConditionsConfig_test.py
new file mode 100755
index 0000000000000000000000000000000000000000..78cdab2ff3f91e7240d6e2b80998d4a5bb03b563
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/test/SCT_ConditionsConfig_test.py
@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+"""Run tests on SCT_ConditionsTools/python/*Config.py scripts
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.AllConfigFlags import ConfigFlags
+from AthenaConfiguration.TestDefaults import defaultTestFiles
+from AthenaCommon.Logging import log
+from AthenaCommon.Constants import DEBUG
+from AthenaCommon.Configurable import Configurable
+from SCT_ConditionsTools.SCT_DCSConditionsConfig import SCT_DCSConditionsCfg
+from SCT_ConditionsTools.SCT_SiliconConditionsConfig import SCT_SiliconConditionsCfg
+from SCT_ConditionsTools.SCT_ReadCalibChipDataConfig import SCT_ReadCalibChipDataCfg
+
+# test setup
+log.setLevel(DEBUG)
+Configurable.configurableRun3Behavior = True
+ConfigFlags.Input.Files = defaultTestFiles.HITS
+# DCS
+DCSAcc, DCSTool = SCT_DCSConditionsCfg(ConfigFlags, name="DCSTest")
+# Silicon
+SiliconAcc, SiliconTool = SCT_SiliconConditionsCfg(ConfigFlags, name="SiliconTest")
+# ReadCalibChipData
+ReadAcc, ReadTool = SCT_ReadCalibChipDataCfg(ConfigFlags, name="ReadTest")
+# prevent raise on __del__
+DCSAcc.wasMerged()
+SiliconAcc.wasMerged()
+ReadAcc.wasMerged()
+
diff --git a/InnerDetector/InDetConditions/SiLorentzAngleTool/CMakeLists.txt b/InnerDetector/InDetConditions/SiLorentzAngleTool/CMakeLists.txt
index 86125e6f55e0f9b5d90085a3cc64e8f2bd0baf0c..10122dac8cd6c21828985c17a5da317320b4061b 100644
--- a/InnerDetector/InDetConditions/SiLorentzAngleTool/CMakeLists.txt
+++ b/InnerDetector/InDetConditions/SiLorentzAngleTool/CMakeLists.txt
@@ -41,6 +41,10 @@ atlas_add_test( TestSCTLorentzAngle
                 PROPERTIES TIMEOUT 300
                 ENVIRONMENT THREADS=5 )
 
+atlas_add_test( SiLorentzAngleConfig_test
+                SCRIPT test/SiLorentzAngleConfig_test.py
+                PROPERTIES TIMEOUT 30 )
+
 # Install files from the package:
 atlas_install_headers( SiLorentzAngleTool )
 atlas_install_python_modules( python/*.py )
diff --git a/InnerDetector/InDetConditions/SiLorentzAngleTool/python/PixelLorentzAngleConfig.py b/InnerDetector/InDetConditions/SiLorentzAngleTool/python/PixelLorentzAngleConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..908a57e1419c6bfc51f8139ff30ee8c423bd6dc3
--- /dev/null
+++ b/InnerDetector/InDetConditions/SiLorentzAngleTool/python/PixelLorentzAngleConfig.py
@@ -0,0 +1,34 @@
+"""Define methods to configure SCTLorentzAngleTool
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from SiPropertiesTool.PixelSiPropertiesConfig import PixelSiPropertiesCfg
+from SiLorentzAngleTool.SiLorentzAngleToolConf import SiLorentzAngleTool
+from SiLorentzAngleTool.SiLorentzAngleToolConf import PixelSiLorentzAngleCondAlg
+from PixelConditionsTools.PixelDCSConditionsConfig import PixelDCSConditionsCfg
+from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
+
+def PixelLorentzAngleToolCfg(flags, name="PixelLorentzAngleTool", **kwargs):
+    """Return a SiLorentzAngleTool configured for Pixel"""
+    kwargs.setdefault("DetectorName", "Pixel")
+    kwargs.setdefault("SiLorentzAngleCondData", "PixelSiLorentzAngleCondData")
+    kwargs.setdefault("UseMagFieldSvc", True)
+    return SiLorentzAngleTool(name, **kwargs)
+
+def PixelLorentzAngleCfg(flags, name="PixelSiLorentzAngleCondAlg", **kwargs):
+    """Return configured ComponentAccumulator and tool for PixelLorentzAngle
+
+    SiLorentzAngleTool may be provided in kwargs
+    """
+    acc, svc = MagneticFieldSvcCfg(flags)
+    tool = kwargs.get("SiLorentzAngleTool", PixelLorentzAngleToolCfg(flags))
+    acc.merge(PixelDCSConditionsCfg(flags))
+    SiPropAcc, SiPropTool = PixelSiPropertiesCfg(flags)
+    acc.merge(SiPropAcc)
+    kwargs.setdefault("SiPropertiesTool", SiPropTool)
+    kwargs.setdefault("UseMagFieldSvc", tool.UseMagFieldSvc)
+    kwargs.setdefault("UseMagFieldDcs", not flags.Common.isOnline)
+    acc.addCondAlgo(PixelSiLorentzAngleCondAlg(name, **kwargs))
+    return acc, tool
+
diff --git a/InnerDetector/InDetConditions/SiLorentzAngleTool/python/SCT_LorentzAngleConfig.py b/InnerDetector/InDetConditions/SiLorentzAngleTool/python/SCT_LorentzAngleConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..233f4ff54db39caa83fdea2c29180081acdc14de
--- /dev/null
+++ b/InnerDetector/InDetConditions/SiLorentzAngleTool/python/SCT_LorentzAngleConfig.py
@@ -0,0 +1,57 @@
+"""Define methods to configure SCTLorentzAngleTool
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaCommon import Logging
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from SiLorentzAngleTool.SiLorentzAngleToolConf import SiLorentzAngleTool
+from SiLorentzAngleTool.SiLorentzAngleToolConf import SCTSiLorentzAngleCondAlg
+from SCT_ConditionsTools.SCT_DCSConditionsConfig import SCT_DCSConditionsCfg
+from SCT_ConditionsTools.SCT_SiliconConditionsConfig import SCT_SiliconConditionsCfg
+from SCT_ConditionsTools.SCT_SiliconConditionsConfig import SCT_SiliconConditionsToolCfg
+from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
+
+def SCT_LorentzAngleToolCfg(flags, name="SCT_LorentzAngleTool", **kwargs):
+    """Return a SiLorentzAngleTool configured for SCT"""
+    kwargs.setdefault("DetectorName", "SCT")
+    kwargs.setdefault("SiLorentzAngleCondData", "SCTSiLorentzAngleCondData")
+    kwargs.setdefault("UseMagFieldSvc", True)
+    return SiLorentzAngleTool(name, **kwargs)
+
+def SCT_LorentzAngleCfg(flags, name="SCT_SiLorentzAngleCondAlg",
+                        forceUseDB=False, forceUseGeoModel=False, **kwargs):
+    """Return configured ComponentAccumulator and tool for SCT_LorentzAngle
+
+    SiLorentzAngleTool may be provided in kwargs
+    """
+    if forceUseDB and forceUseGeoModel:
+        msg = Logging.logging.getLogger("SCT_LorentzAngleCfg")
+        msg.error("Setting is wrong: both forceUseDB and forceUseGeoModel cannot be True at the same time")
+    # construct with field services
+    acc, svc = MagneticFieldSvcCfg(flags)
+    tool = kwargs.get("SiLorentzAngleTool", SCT_LorentzAngleToolCfg(flags))
+    if not forceUseGeoModel:
+        DCSkwargs = {}
+        # For HLT
+        if flags.Common.isOnline and not flags.Input.isMC:
+            dcs_folder = "/SCT/HLT/DCS"
+            DCSkwargs["dbInstance"] = "SCT"
+            DCSkwargs["hvFolder"] = dcs_folder + "/HV"
+            DCSkwargs["tempFolder"] = dcs_folder + "/MODTEMP"
+            DCSkwargs["stateFolder"] = dcs_folder + "/CHANSTAT"
+        DCSAcc, DCSTool = SCT_DCSConditionsCfg(flags, **DCSkwargs)
+        acc.merge(DCSAcc)
+        SCAcc, SCTool = SCT_SiliconConditionsCfg(flags, DCSConditionsTool=DCSTool)
+    else:
+        SCTool = SCT_SiliconConditionsToolCfg(flags, UseDB=False, ForceUseGeoModel=True)
+        SCAcc, SCTool = SCT_SiliconConditionsCfg(flags, SiliconConditionsTool=SCTool)
+    acc.merge(SCAcc)
+    # set up SCTSiLorentzAngleCondAlg
+    kwargs.setdefault("UseMagFieldSvc", tool.UseMagFieldSvc)
+    kwargs.setdefault("UseMagFieldDcs", not flags.Common.isOnline)
+    kwargs.setdefault("UseGeoModel", forceUseGeoModel)
+    kwargs.setdefault("useSctDefaults", False)
+    alg = SCTSiLorentzAngleCondAlg(name, **kwargs)
+    acc.addCondAlgo(alg)
+    return acc, tool
+
diff --git a/InnerDetector/InDetConditions/SiLorentzAngleTool/test/SiLorentzAngleConfig_test.py b/InnerDetector/InDetConditions/SiLorentzAngleTool/test/SiLorentzAngleConfig_test.py
new file mode 100755
index 0000000000000000000000000000000000000000..1c72737ed6f7f06be70315e55bf8b7d74777adb9
--- /dev/null
+++ b/InnerDetector/InDetConditions/SiLorentzAngleTool/test/SiLorentzAngleConfig_test.py
@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+"""Run tests on *LorentzAngleConfig.py
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.AllConfigFlags import ConfigFlags
+from AthenaConfiguration.TestDefaults import defaultTestFiles
+from AthenaCommon.Logging import log
+from AthenaCommon.Constants import DEBUG
+from AthenaCommon.Configurable import Configurable
+from SiLorentzAngleTool.SCT_LorentzAngleConfig import SCT_LorentzAngleCfg
+from SiLorentzAngleTool.PixelLorentzAngleConfig import PixelLorentzAngleCfg
+
+# test setup
+log.setLevel(DEBUG)
+Configurable.configurableRun3Behavior = True
+ConfigFlags.Input.Files = defaultTestFiles.HITS
+# case online
+ConfigFlags.Common.isOnline = True
+acc, tool = SCT_LorentzAngleCfg(ConfigFlags, name="SCT_LorentzAngleTestOnline")
+acc2, tool = PixelLorentzAngleCfg(ConfigFlags, name="PixelLorentzAngleTestOnline")
+acc.merge(acc2)
+acc.wasMerged()
+# case offline
+ConfigFlags.Common.isOnline = False
+acc, tool = SCT_LorentzAngleCfg(ConfigFlags, name="SCT_LorentzAngleTestOffline")
+acc2, tool = PixelLorentzAngleCfg(ConfigFlags, name="PixelLorentzAngleTestOffline")
+acc.merge(acc2)
+acc.wasMerged()
+
diff --git a/InnerDetector/InDetConditions/SiPropertiesTool/CMakeLists.txt b/InnerDetector/InDetConditions/SiPropertiesTool/CMakeLists.txt
index c91b4aef25d5bbafe24335973ae690ba4196a041..0cc2f935cad800878d6f79bc18854b2950acf79f 100644
--- a/InnerDetector/InDetConditions/SiPropertiesTool/CMakeLists.txt
+++ b/InnerDetector/InDetConditions/SiPropertiesTool/CMakeLists.txt
@@ -43,6 +43,11 @@ atlas_add_test( TestSCTProperties
                 PROPERTIES TIMEOUT 300
                 ENVIRONMENT THREADS=5 )
 
+atlas_add_test( SiPropertiesConfig_test
+                SCRIPT test/SiPropertiesConfig_test.py
+                PROPERTIES TIMEOUT 300 )
+
 # Install files from the package:
 atlas_install_python_modules( python/*.py )
 atlas_install_joboptions( share/*.py )
+
diff --git a/InnerDetector/InDetConditions/SiPropertiesTool/python/PixelSiPropertiesConfig.py b/InnerDetector/InDetConditions/SiPropertiesTool/python/PixelSiPropertiesConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..66de19b5e61c5ffced1ab01237fe366803585207
--- /dev/null
+++ b/InnerDetector/InDetConditions/SiPropertiesTool/python/PixelSiPropertiesConfig.py
@@ -0,0 +1,25 @@
+"""Define methods to configure SiPropertiesTool
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from PixelConditionsTools.PixelDCSConditionsConfig import PixelDCSConditionsCfg
+from SiPropertiesTool.SiPropertiesToolConf import SiPropertiesTool
+from SiPropertiesTool.SiPropertiesToolConf import PixelSiPropertiesCondAlg
+
+def PixelSiPropertiesToolCfg(flags, name="PixelSiPropertiesTool", **kwargs):
+    """Return a SiPropertiesTool configured for Pixel"""
+    kwargs.setdefault("DetectorName", "Pixel")
+    kwargs.setdefault("ReadKey", "PixelSiliconPropertiesVector")
+    return SiPropertiesTool(name=name, **kwargs)
+
+def PixelSiPropertiesCfg(flags, name="PixelSiPropertiesCondAlg", **kwargs):
+    """Return configured ComponentAccumulator and tool for PixelSiPropertiesCondAlg
+
+    SiPropertiesTool may be provided in kwargs
+    """
+    acc = PixelDCSConditionsCfg(flags)
+    tool = kwargs.get("SiPropertiesTool", PixelSiPropertiesToolCfg(flags))
+    acc.addCondAlgo(PixelSiPropertiesCondAlg(name, **kwargs))
+    return acc, tool
+
diff --git a/InnerDetector/InDetConditions/SiPropertiesTool/python/SCT_SiPropertiesConfig.py b/InnerDetector/InDetConditions/SiPropertiesTool/python/SCT_SiPropertiesConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..db9151a29e3def4f04f5d2dd722dbd7502856be9
--- /dev/null
+++ b/InnerDetector/InDetConditions/SiPropertiesTool/python/SCT_SiPropertiesConfig.py
@@ -0,0 +1,25 @@
+"""Define methods to configure SCT SiProperties
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from SiPropertiesTool.SiPropertiesToolConf import SiPropertiesTool
+from SiPropertiesTool.SiPropertiesToolConf import SCTSiPropertiesCondAlg
+
+def SCT_SiPropertiesToolCfg(flags, name="SCT_SiPropertiesTool", **kwargs):
+    """Return a SiPropertiesTool configured for SCT"""
+    kwargs.setdefault("DetectorName", "SCT")
+    kwargs.setdefault("ReadKey", "SCTSiliconPropertiesVector")
+    return SiPropertiesTool(name=name, **kwargs)
+
+def SCT_SiPropertiesCfg(flags, name="SCTSiPropertiesCondAlg", **kwargs):
+    """Return configured ComponentAccumulator and tool for SCT_SiProperties
+
+    SiConditionsTool and/or SiPropertiesTool may be provided in kwargs
+    """
+    acc = ComponentAccumulator()
+    tool = kwargs.get("SiPropertiesTool", SCT_SiPropertiesToolCfg(flags))
+    alg = SCTSiPropertiesCondAlg(name, **kwargs)
+    acc.addEventAlgo(alg)
+    return acc, tool
+
diff --git a/InnerDetector/InDetConditions/SiPropertiesTool/test/SiPropertiesConfig_test.py b/InnerDetector/InDetConditions/SiPropertiesTool/test/SiPropertiesConfig_test.py
new file mode 100755
index 0000000000000000000000000000000000000000..b68c74d5ce63700a141371ab782de23380df4a4b
--- /dev/null
+++ b/InnerDetector/InDetConditions/SiPropertiesTool/test/SiPropertiesConfig_test.py
@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+"""Run tests on SCT_SiPropertiesConfig.py
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.AllConfigFlags import ConfigFlags
+from AthenaConfiguration.TestDefaults import defaultTestFiles
+from AthenaCommon.Logging import log
+from AthenaCommon.Constants import DEBUG
+from AthenaCommon.Configurable import Configurable
+from SiPropertiesTool.SCT_SiPropertiesConfig import SCT_SiPropertiesCfg
+from SiPropertiesTool.PixelSiPropertiesConfig import PixelSiPropertiesCfg
+
+# test setup
+log.setLevel(DEBUG)
+Configurable.configurableRun3Behavior = True
+ConfigFlags.Input.Files = defaultTestFiles.HITS
+# test
+acc1, tool = SCT_SiPropertiesCfg(ConfigFlags, name="SCT_SiPropertiesConfigTest")
+acc2, tool = PixelSiPropertiesCfg(ConfigFlags, name="PixelSiPropertiesConfigTest")
+# prevent raise on __del__
+acc1.merge(acc2)
+acc1.wasMerged()
+
diff --git a/InnerDetector/InDetDetDescr/PixelCabling/CMakeLists.txt b/InnerDetector/InDetDetDescr/PixelCabling/CMakeLists.txt
index 3cf3b433165735f2c1d4b2ea160dca920f35583d..bf7ce80ff9a5d77efc8871fb59b2578f5e058bf4 100644
--- a/InnerDetector/InDetDetDescr/PixelCabling/CMakeLists.txt
+++ b/InnerDetector/InDetDetDescr/PixelCabling/CMakeLists.txt
@@ -40,6 +40,10 @@ atlas_add_component( PixelCabling
    ${TDAQ-COMMON_LIBRARIES} GaudiKernel AthenaBaseComps SGTools StoreGateLib
    AthenaPoolUtilities Identifier InDetIdentifier InDetReadoutGeometry PathResolver PixelCablingLib )
 
+atlas_add_test( PixelCablingConfigNew_test
+                SCRIPT test/PixelCablingConfigNew_test.py
+                PROPERTIES TIMEOUT 30 )
+
 # Install files from the package:
 atlas_install_python_modules( python/*.py )
 atlas_install_joboptions( share/*.py )
diff --git a/InnerDetector/InDetDetDescr/PixelCabling/python/PixelCablingConfigNew.py b/InnerDetector/InDetDetDescr/PixelCabling/python/PixelCablingConfigNew.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d631ad0ac627b768e6fb69785f71ca9050cac91
--- /dev/null
+++ b/InnerDetector/InDetDetDescr/PixelCabling/python/PixelCablingConfigNew.py
@@ -0,0 +1,100 @@
+"""Define a method to construct configured PixelCablingSvc
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaCommon.Logging import logging
+from IOVDbSvc.CondDB import conddb
+from IOVDbSvc.IOVDbSvcConfig import addFoldersSplitOnline, addFolders
+from PixelCabling.PixelCablingConf import PixelCablingSvc
+from RecExConfig.AutoConfiguration import GetRunNumber
+
+def PixelCablingSvcCfg(flags, name="PixelCablingSvc", **kwargs):
+    """Return a ComponentAccumulator with configured PixelCablingSvc"""
+    acc = ComponentAccumulator()
+    logger = logging.getLogger("PixelCablingSvc")
+    if flags.Input.isMC:
+        acc.merge(addFoldersSplitOnline(flags, "PIXEL", "/PIXEL/ReadoutSpeed", "/PIXEL/ReadoutSpeed"))
+    else:
+        acc.merge(addFolders(flags, "/PIXEL/ReadoutSpeed", "PIXEL"))
+    # Add the HitDiscCnfg folder
+    if (conddb.dbdata == "CONDBR2" or (conddb.dbmc == "OFLP200" and flags.GeoModel.Run == "RUN2")):
+        acc.merge(addFoldersSplitOnline(flags, "PIXEL", "/PIXEL/HitDiscCnfg", "/PIXEL/HitDiscCnfg"))
+    # Online mode
+    if flags.Common.isOnline:
+        logger.debug("Running in online mode")
+        # Request the CablingMap folder
+        # (COOL is the default mapping type)
+        if (conddb.dbdata == "CONDBR2"):
+            acc.merge(addFoldersSplitOnline(flags, "PIXEL", "/PIXEL/Onl/CablingMap","/PIXEL/CablingMap"))
+            logger.debug("Requested CablingMap folder")
+        else:
+            kwargs.setdefault("MappingType", "Final")
+            kwargs.setdefault("MappingFile", "PixelCabling/Pixels_Atlas_IdMapping_May08.dat")
+    # Offline mode
+    else:
+        logger.debug("Running in offline mode")
+        # SIMULATION
+        if flags.Input.isMC:
+            logger.debug("Running on simulation")
+            # Set cabling svc to get map from file
+            kwargs.setdefault("MappingType", "Final")
+            # ITk:
+            if flags.GeoModel.Run == "RUN4":
+                IdMappingDat = "ITk_Atlas_IdMapping.dat"
+                if flags.GeoModel.Type == "BrlIncl4.0_ref":
+                    IdMappingDat = "ITk_Atlas_IdMapping_InclBrl4.dat"
+                elif flags.GeoModel.Type == "IBrlExt4.0ref":
+                    IdMappingDat = "ITk_Atlas_IdMapping_IExtBrl4.dat"
+                elif flags.GeoModel.Type == "BrlExt4.0_ref":
+                    IdMappingDat = "ITk_Atlas_IdMapping_ExtBrl4.dat"
+                elif flags.GeoModel.Type == "BrlExt3.2_ref":
+                    IdMappingDat = "ITk_Atlas_IdMapping_ExtBrl32.dat"
+                logger.info("Using ITk pixel mapping: %s" % IdMappingDat)
+                kwargs.setdefault("MappingFile", IdMappingDat)
+            # IBL
+            elif flags.GeoModel.Run == "RUN2" or flags.GeoModel.Run == "RUN3":
+                # Planar IBL
+                if flags.GeoModel.IBLLayout == "planar":
+                    # DBM or not
+                    if flags.GeoModel.Run == "RUN2":
+                        kwargs.setdefault("MappingFile", "PixelCabling/Pixels_Atlas_IdMapping_inclIBL_DBM.dat")
+                    else:
+                        kwargs.setdefault("MappingFile", "PixelCabling/Pixels_Atlas_IdMapping_inclIBL.dat")
+                # Hybrid IBL plus DBM
+                elif flags.GeoModel.IBLLayout == "3D":
+                    #kwargs.setdefault("MappingFile", "Pixels_Atlas_IdMapping_inclIBL3D_DBM.dat")
+                    kwargs.setdefault("MappingFile", "PixelCabling/Pixels_Atlas_IdMapping_Run2.dat")
+                elif flags.GeoModel.IBLLayout == "UNDEFINED":
+                    logger.warning("IBL is required, but flags.GeoModel.IBLLayout is \"UNDEFINED\"")
+                    logger.warning("Pixel cabling map cannot be set at this point")
+            # No IBL
+            else:
+                kwargs.setdefault("MappingFile", "PixelCabling/Pixels_Atlas_IdMapping.dat")
+        # DATA
+        elif not flags.Input.isMC:
+            runNum = GetRunNumber()
+            logger.debug("Running on data, run number %d" % runNum)
+            # For data older than run number 222222, use the appropriate text file
+            if runNum < 222222:
+                kwargs.setdefault("MappingType", "Final")
+                kwargs.setdefault("MappingFile", "PixelCabling/Pixels_Atlas_IdMapping_May08.dat")
+            # For Run-2 onwards, get cabling map from database
+            else:
+                kwargs.setdefault("MappingType", "COOL")
+                kwargs.setdefault("KeyCabling", "/PIXEL/CablingMap")
+                # Request the CablingMap folder
+                acc.merge(addFoldersSplitOnline(flags, "PIXEL", "/PIXEL/Onl/CablingMap","/PIXEL/CablingMap"))
+                logger.debug("Requested CablingMap folder")
+                # Even though we are reading from COOL, set the correct fallback map.
+                if runNum >= 289350: # 2016
+                    kwargs.setdefault("MappingFile", "PixelCabling/Pixels_Atlas_IdMapping_2016.dat")
+                elif runNum >= 222222 and runNum < 289350: # 2015
+                    kwargs.setdefault("MappingFile", "PixelCabling/Pixels_Atlas_IdMapping_Run2.dat")
+                else:
+                    kwargs.setdefault("MappingFile", "PixelCabling/Pixels_Atlas_IdMapping_May08.dat")
+        # Unknown input
+        else:
+            logger.warning("Unknown input source. Pixel cabling map cannot be set at this point")
+    acc.addService(PixelCablingSvc(name, **kwargs))
+    return acc
diff --git a/InnerDetector/InDetDetDescr/PixelCabling/test/PixelCablingConfigNew_test.py b/InnerDetector/InDetDetDescr/PixelCabling/test/PixelCablingConfigNew_test.py
new file mode 100755
index 0000000000000000000000000000000000000000..16ad79046ad9aa914633738eceb2b15197386e27
--- /dev/null
+++ b/InnerDetector/InDetDetDescr/PixelCabling/test/PixelCablingConfigNew_test.py
@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+"""Run tests on PixelCablingConfigNew.py
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.AllConfigFlags import ConfigFlags
+from AthenaConfiguration.TestDefaults import defaultTestFiles
+from AthenaCommon.Logging import log
+from AthenaCommon.Constants import DEBUG
+from AthenaCommon.Configurable import Configurable
+from PixelCabling.PixelCablingConfigNew import PixelCablingSvcCfg
+
+# test setup
+log.setLevel(DEBUG)
+Configurable.configurableRun3Behavior = True
+ConfigFlags.Input.Files = defaultTestFiles.HITS
+# test
+PixelCablingAcc = PixelCablingSvcCfg(ConfigFlags, name="PixelCablingSvcTest")
+# prevent raise on __del__
+PixelCablingAcc.wasMerged()
+
diff --git a/InnerDetector/InDetDigitization/BCM_Digitization/python/BCM_DigitizationConfigNew.py b/InnerDetector/InDetDigitization/BCM_Digitization/python/BCM_DigitizationConfigNew.py
index b8f0e266f737d2b6ae0cc22fa6113ddf7a14e680..22fc5f896eb3a43eb2dd20e3b5ed816dc9733ef0 100755
--- a/InnerDetector/InDetDigitization/BCM_Digitization/python/BCM_DigitizationConfigNew.py
+++ b/InnerDetector/InDetDigitization/BCM_Digitization/python/BCM_DigitizationConfigNew.py
@@ -55,10 +55,10 @@ def BCM_DigitizationCfg(configFlags, name="BCM_OverlayDigitization", **kwargs):
 
 def BCM_OverlayDigitizationToolCfg(configFlags, name="BCM_OverlayDigitizationTool", **kwargs):
     """Return tuple (ComponentAccumulator, tool) configured for BCM Overlay Digitization"""
-    kwargs.setdefault("EvtStore", configFlags.Overlay.EventStore)
+    kwargs.setdefault("EvtStore", configFlags.Overlay.Legacy.EventStore)
     return BCM_DigitizationToolCfg(configFlags, name, **kwargs)
 
-def BCM_OverlayDigitization(configFlags, name="BCM_OverlayDigitization", **kwargs):
+def BCM_OverlayDigitizationCfg(configFlags, name="BCM_OverlayDigitization", **kwargs):
     """Return a ComponentAccumulator with BCM Overlay Digitization algorithm"""
     acc, tool = BCM_OverlayDigitizationToolCfg(configFlags, **kwargs)
     kwargs.setdefault("DigitizationTool", tool)
diff --git a/InnerDetector/InDetDigitization/BCM_Digitization/test/BCM_DigitizationConfigNew_test.py b/InnerDetector/InDetDigitization/BCM_Digitization/test/BCM_DigitizationConfigNew_test.py
index 17b3469e2e681b9cf29b9114c6cb5be07ab71030..daf3af3ae99f74a6ed41bc345250477e0492a7e6 100755
--- a/InnerDetector/InDetDigitization/BCM_Digitization/test/BCM_DigitizationConfigNew_test.py
+++ b/InnerDetector/InDetDigitization/BCM_Digitization/test/BCM_DigitizationConfigNew_test.py
@@ -9,37 +9,38 @@ from AthenaCommon.Constants import DEBUG
 from AthenaCommon.Configurable import Configurable
 from AthenaConfiguration.AllConfigFlags import ConfigFlags
 from AthenaConfiguration.MainServicesConfig import MainServicesSerialCfg
+from AthenaConfiguration.TestDefaults import defaultTestFiles
 from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
 from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
-from BCM_Digitization.BCM_DigitizationConfigFlags import createBCMCfgFlags
 from BCM_Digitization.BCM_DigitizationConfigNew import BCM_DigitizationCfg
+from Digitization.DigitizationConfigFlags import createDigitizationCfgFlags
+from OverlayCommonAlgs.OverlayConfigFlags import createOverlayCfgFlags
 from TrigUpgradeTest.InDetConfig import InDetGMConfig # FIXME This module would ideally be located somewhere else
+
 # Set up logging and new style config
 log.setLevel(DEBUG)
 Configurable.configurableRun3Behavior = True
-# Provide input
-dataDir = "/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art"
-inputDir = os.environ.get("ATLAS_REFERENCE_DATA", dataDir)
-fileDir = "/Tier0ChainTests/valid1.410000.PowhegPythiaEvtGen_P2012_ttbar_hdamp172p5_nonallhad.simul.HITS.e4993_s3091/HITS.10504490._000425.pool.root.1"
-ConfigFlags.Input.Files = [inputDir + fileDir]
-# Specify output
+# Configure
+ConfigFlags.Input.Files = defaultTestFiles.HITS
 ConfigFlags.Output.RDOFileName = "myRDO.pool.root"
+ConfigFlags.join(createDigitizationCfgFlags())
+ConfigFlags.join(createOverlayCfgFlags())
 ConfigFlags.lock()
-# Construct ComponentAccumulator
-cfg = MainServicesSerialCfg()
-cfg.merge(PoolReadCfg(ConfigFlags))
-cfg.merge(InDetGMConfig(ConfigFlags)) # FIXME This sets up the whole ID geometry would be nicer just to set up min required for BCM
-# Use BCM tools
-BCMflags = createBCMCfgFlags()
-acc = BCM_DigitizationCfg(BCMflags)
-cfg.merge(acc)
+# Construct our accumulator to run
+acc = MainServicesSerialCfg()
+from StoreGate.StoreGateConf import StoreGateSvc # FIXME remove this once athena is fixed
+acc.addService(StoreGateSvc("ConditionStore"))
+acc.merge(PoolReadCfg(ConfigFlags))
+acc.merge(InDetGMConfig(ConfigFlags)) # FIXME This sets up the whole ID geometry would be nicer just to set up min required for BCM
 # Add configuration to write HITS pool file
 outConfig = OutputStreamCfg(ConfigFlags, "RDO",
     ItemList=["InDetSimDataCollection#*", "BCM_RDO_Container#*"])
-cfg.merge(outConfig)
-cfg.getService("StoreGateSvc").Dump=True
-cfg.printConfig(withDetails=True)
+acc.merge(outConfig)
+# Dump config
+acc.getService("StoreGateSvc").Dump=True
+acc.getService("ConditionStore").Dump = True
+acc.printConfig(withDetails=True)
 ConfigFlags.dump()
 # Execute and finish
-cfg.run(maxEvents=3)
+acc.run(maxEvents=3)
 
diff --git a/InnerDetector/InDetDigitization/SCT_Digitization/CMakeLists.txt b/InnerDetector/InDetDigitization/SCT_Digitization/CMakeLists.txt
index 2b9b857907067fb49570c37c982fe3df6eef15b1..9430fcedfd7d4f9ad595dd06fe8f0651a8492970 100644
--- a/InnerDetector/InDetDigitization/SCT_Digitization/CMakeLists.txt
+++ b/InnerDetector/InDetDigitization/SCT_Digitization/CMakeLists.txt
@@ -42,6 +42,10 @@ atlas_add_component( SCT_Digitization
                      INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
                      LINK_LIBRARIES ${ROOT_LIBRARIES} ${Boost_LIBRARIES} ${CLHEP_LIBRARIES} CommissionEvent AthenaBaseComps AthenaKernel PileUpToolsLib Identifier xAODEventInfo GaudiKernel SiDigitization InDetRawData InDetSimEvent HitManagement GeneratorObjects SiPropertiesToolLib InDetIdentifier InDetReadoutGeometry InDetSimData )
 
+atlas_add_test( SCT_DigitizationConfigNew_test
+                SCRIPT test/SCT_DigitizationConfigNew_test.py
+                PROPERTIES TIMEOUT 300 )
+
 # Install files from the package:
 atlas_install_headers( SCT_Digitization )
 atlas_install_python_modules( python/*.py )
diff --git a/InnerDetector/InDetDigitization/SCT_Digitization/python/SCT_DigitizationConfigNew.py b/InnerDetector/InDetDigitization/SCT_Digitization/python/SCT_DigitizationConfigNew.py
new file mode 100644
index 0000000000000000000000000000000000000000..d54410fc56e1893d1ce5bf36c6c52773a2f456ca
--- /dev/null
+++ b/InnerDetector/InDetDigitization/SCT_Digitization/python/SCT_DigitizationConfigNew.py
@@ -0,0 +1,254 @@
+"""Define methods to construct configured SCT Digitization tools and algorithms
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaCommon import Logging
+from SCT_Digitization.SCT_DigitizationConf import (
+    SCT_RandomDisabledCellGenerator,
+    SCT_Amp,
+    SCT_DetailedSurfaceChargesGenerator,
+    SCT_SurfaceChargesGenerator,
+    SCT_FrontEnd,
+    SCT_DigitizationTool,
+    SCT_Digitization,
+)
+from PileUpComps.PileUpCompsConf import PileUpXingFolder
+from SCT_ConditionsTools.SCT_ConditionsToolsConf import SCT_RadDamageSummaryTool
+from SCT_GeoModel.SCT_GeoModelConfig import SCT_GeometryCfg
+from SCT_ConditionsTools.SCT_DCSConditionsConfig import SCT_DCSConditionsCfg
+from SCT_ConditionsTools.SCT_SiliconConditionsConfig import SCT_SiliconConditionsCfg
+from SCT_ConditionsTools.SCT_ReadCalibChipDataConfig import SCT_ReadCalibChipDataCfg
+from SiPropertiesTool.SCT_SiPropertiesConfig import SCT_SiPropertiesCfg
+from SiLorentzAngleTool.SCT_LorentzAngleConfig import SCT_LorentzAngleCfg
+from StoreGate.StoreGateConf import StoreGateSvc
+
+# The earliest and last bunch crossing times for which interactions will be sent
+# to the SCT Digitization code
+def SCT_FirstXing():
+    return -50
+
+def SCT_LastXing():
+    return 25
+
+def SCT_DigitizationCommonCfg(flags, name="SCT_DigitizationToolCommon", **kwargs):
+    """Return ComponentAccumulator with common SCT digitization tool config"""
+    acc = SCT_GeometryCfg(flags)
+    if not flags.Digitization.DoInnerDetectorNoise:
+        kwargs.setdefault("OnlyHitElements", True)
+    kwargs.setdefault("InputObjectName", "SCT_Hits")
+    kwargs.setdefault("EnableHits", True)
+    kwargs.setdefault("BarrelOnly", False)
+    # Set FixedTime for cosmics for use in SurfaceChargesGenerator
+    if flags.Beam.Type == "cosmics":
+        kwargs.setdefault("CosmicsRun", True)
+        kwargs.setdefault("FixedTime", 10)
+    if flags.Digitization.DoXingByXingPileUp:
+        kwargs.setdefault("FirstXing", SCT_FirstXing())
+        kwargs.setdefault("LastXing", SCT_LastXing() )
+    tool = SCT_DigitizationTool(name, **kwargs)
+    # attach ToolHandles
+    frontAcc, frontTool = SCT_FrontEndCfg(flags)
+    tool.FrontEnd = frontTool
+    surfAcc, surfTool = SCT_SurfaceChargesGeneratorCfg(flags)
+    tool.SurfaceChargesGenerator = surfTool
+    tool.RandomDisabledCellGenerator = SCT_RandomDisabledCellGeneratorCfg(flags)
+    acc.mergeAll([frontAcc, surfAcc])
+    return acc, tool
+
+def SCT_DigitizationToolCfg(flags, name="SCT_DigitizationTool", **kwargs):
+    """Return configured digitization tool"""
+    if flags.Digitization.PileUpPremixingForMT:
+        kwargs.setdefault("OutputObjectName", flags.Overlay.BkgPrefix + "SCT_RDOs")
+        kwargs.setdefault("OutputSDOName", flags.Overlay.BkgPrefix + "SCT_SDO_Map")
+    else:
+        kwargs.setdefault("OutputObjectName", "SCT_RDOs")
+        kwargs.setdefault("OutputSDOName", "SCT_SDO_Map")
+    kwargs.setdefault("HardScatterSplittingMode", 0)
+    return SCT_DigitizationCommonCfg(flags, name, **kwargs)
+
+def SCT_DigitizationToolHSCfg(flags, name="SCT_DigitizationToolHS", **kwargs):
+    """Return hard scatter configured digitization tool"""
+    kwargs.setdefault("OutputObjectName", "SCT_RDOs")
+    kwargs.setdefault("OutputSDOName", "SCT_SDO_Map")
+    kwargs.setdefault("HardScatterSplittingMode", 1)
+    return SCT_DigitizationCommonCfg(flags, name, **kwargs)
+
+def SCT_DigitizationToolPUCfg(flags, name="SCT_DigitizationToolPU",**kwargs):
+    """Return pileup configured digitization tool"""
+    kwargs.setdefault("OutputObjectName", "SCT_PU_RDOs")
+    kwargs.setdefault("OutputSDOName", "SCT_PU_SDO_Map")
+    kwargs.setdefault("HardScatterSplittingMode", 2)
+    return SCT_DigitizationCommonCfg(flags, name, **kwargs)
+
+def SCT_DigitizationToolOverlayCfg(flags, name="SCT_OverlayDigitizationTool",**kwargs):
+    """Return overlay configured digitization tool"""
+    acc = ComponentAccumulator()
+    if flags.Overlay.Legacy.MT:
+        kwargs.setdefault("InputSingleHitsName", "SCT_Hits")
+        kwargs.setdefault("OutputObjectName", "StoreGateSvc+" + flags.Overlay.SigPrefix + "SCT_RDOs")
+        kwargs.setdefault("OutputSDOName", "StoreGateSvc+" + flags.Overlay.SigPrefix + "SCT_SDO_Map")
+    else:
+        acc.addService(StoreGateSvc(flags.Overlay.Legacy.EventStore))
+        kwargs.setdefault("OutputObjectName", flags.Overlay.Legacy.EventStore + "+SCT_RDOs")
+        kwargs.setdefault("OutputSDOName", flags.Overlay.Legacy.EventStore + "+SCT_SDO_Map")
+    kwargs.setdefault("HardScatterSplittingMode", 0)
+    CommonAcc, tool = SCT_DigitizationCommonCfg(flags, name, **kwargs)
+    acc.merge(CommonAcc)
+    return acc, tool
+
+def SCT_DigitizationToolSplitNoMergePUCfg(flags, name="SCT_DigitizationToolSplitNoMergePU",**kwargs):
+    """Return no merged pileup configured digitization tool"""
+    kwargs.setdefault("InputObjectName", "PileupSCT_Hits")
+    kwargs.setdefault("HardScatterSplittingMode", 0)
+    kwargs.setdefault("OutputObjectName", "SCT_PU_RDOs")
+    kwargs.setdefault("OutputSDOName", "SCT_PU_SDO_Map")
+    kwargs.setdefault("OnlyHitElements", True)
+    kwargs.setdefault("FrontEnd", "PileupSCT_FrontEnd")
+    return SCT_DigitizationCommonCfg(flags, name, **kwargs)
+
+def SCT_DigitizationToolGeantinoTruthCfg(flags, name="SCT_GeantinoTruthDigitizationTool", **kwargs):
+    """Return Geantino truth configured digitization tool"""
+    kwargs.setdefault("ParticleBarcodeVeto", 0)
+    return SCT_DigitizationToolCfg(flags, name, **kwargs)
+
+def SCT_RandomDisabledCellGeneratorCfg(flags, name="SCT_RandomDisabledCellGenerator", **kwargs):
+    """Return configured random cell disabling tool"""
+    kwargs.setdefault("TotalBadChannels", 0.01)
+    return SCT_RandomDisabledCellGenerator(name, **kwargs)
+
+def SCT_AmpCfg(flags, name="SCT_Amp", **kwargs):
+    """Return configured amplifier and shaper tool"""
+    kwargs.setdefault("CrossFactor2sides", 0.1)
+    kwargs.setdefault("CrossFactorBack", 0.07)
+    kwargs.setdefault("PeakTime", 21)
+    kwargs.setdefault("deltaT", 1.0)
+    kwargs.setdefault("Tmin", -25.0)
+    kwargs.setdefault("Tmax", 150.0)
+    return SCT_Amp(name, **kwargs)
+
+def SCT_SurfaceChargesGeneratorCfg(flags, name="SCT_SurfaceChargesGenerator", **kwargs):
+    """Return configured (detailed) surface charges tool, conditioned on flags"""
+    acc = ComponentAccumulator()
+    kwargs.setdefault("FixedTime", -999)
+    kwargs.setdefault("SubtractTime", -999)
+    kwargs.setdefault("SurfaceDriftTime", 10)
+    kwargs.setdefault("NumberOfCharges", 1)
+    kwargs.setdefault("SmallStepLength", 5)
+    kwargs.setdefault("DepletionVoltage", 70)
+    kwargs.setdefault("BiasVoltage", 150)
+    kwargs.setdefault("isOverlay", flags.Detector.Overlay)
+    # kwargs.setdefault("doTrapping", True) # ATL-INDET-INT-2016-019
+    # experimental SCT_DetailedSurfaceChargesGenerator config dropped here
+    tool = SCT_SurfaceChargesGenerator(name, **kwargs)
+    tool.RadDamageSummaryTool = SCT_RadDamageSummaryTool()
+    DCSCondAcc, DCSCondTool = SCT_DCSConditionsCfg(flags)
+    SiliCondAcc, SiliCondTool = SCT_SiliconConditionsCfg(flags, DCSConditionsTool=DCSCondTool)
+    SiliPropsAcc, SiliPropsTool = SCT_SiPropertiesCfg(flags, SiConditionsTool=SiliCondTool)
+    LorentzAcc, LorentzTool = SCT_LorentzAngleCfg(flags)
+    tool.SiConditionsTool = SiliCondTool
+    tool.SiPropertiesTool = SiliPropsTool
+    tool.LorentzAngleTool = LorentzTool
+    acc.mergeAll([DCSCondAcc, SiliCondAcc, SiliPropsAcc, LorentzAcc])
+    return acc, tool
+
+def SCT_FrontEndCfg(flags, name="SCT_FrontEnd", **kwargs):
+    """Return configured ComponentAccumulator with front-end electronics tool"""
+    acc = ComponentAccumulator()
+    # Setup noise treament in SCT_FrontEnd
+    # To set the mean noise values for the different module types
+    # Default values set at 0 degrees, plus/minus ~5 enc per plus/minus degree
+    kwargs.setdefault("NoiseBarrel", 1500.0)
+    kwargs.setdefault("NoiseBarrel3", 1541.0)
+    kwargs.setdefault("NoiseInners", 1090.0)
+    kwargs.setdefault("NoiseMiddles", 1557.0)
+    kwargs.setdefault("NoiseShortMiddles", 940.0)
+    kwargs.setdefault("NoiseOuters", 1618.0)
+    kwargs.setdefault("NOBarrel", 1.5e-5)
+    kwargs.setdefault("NOBarrel3", 2.1e-5)
+    kwargs.setdefault("NOInners", 5.0e-9)
+    kwargs.setdefault("NOMiddles", 2.7e-5)
+    kwargs.setdefault("NOShortMiddles", 2.0e-9)
+    kwargs.setdefault("NOOuters", 3.5e-5)
+    if not flags.Digitization.DoInnerDetectorNoise:
+        Logging.logging.getLogger("SCT_FrontEndCfg")
+        log.info("SCT_Digitization:::: Turned off Noise in SCT_FrontEnd")
+        kwargs.setdefault("NoiseOn", False)
+        kwargs.setdefault("AnalogueNoiseOn", False)
+    else:
+        kwargs.setdefault("NoiseOn", True)
+        kwargs.setdefault("AnalogueNoiseOn", True)
+    # In overlay MC, only analogue noise is on. Noise hits are not added.
+    if flags.Detector.Overlay and flags.Input.isMC:
+        kwargs["NoiseOn"] = False
+        kwargs["AnalogueNoiseOn"] = True
+    # Use Calibration data from Conditions DB, still for testing purposes only
+    kwargs.setdefault("UseCalibData", True)
+    # Setup the ReadCalibChip folders and Svc
+    readAcc, readTool = SCT_ReadCalibChipDataCfg(flags)
+    kwargs.setdefault("SCT_ReadCalibChipDataTool", readTool)
+    acc.merge(readAcc)
+    # DataCompressionMode: 1 is level mode x1x (default), 2 is edge mode 01x, 3 is expanded any hit xxx
+    if flags.Digitization.PileUpPremixing:
+        kwargs.setdefault("DataCompressionMode", 3)
+    elif flags.Detector.Overlay and flags.Input.isMC:
+        kwargs.setdefault("DataCompressionMode", 2)
+    elif flags.Beam.BunchSpacing <= 50:
+        kwargs.setdefault("DataCompressionMode", 1)
+    else:
+        kwargs.setdefault("DataCompressionMode", 3)
+    # DataReadOutMode: 0 is condensed mode and 1 is expanded mode
+    if flags.Detector.Overlay and flags.Input.isMC:
+        kwargs.setdefault("DataReadOutMode", 0)
+    else:
+        kwargs.setdefault("DataReadOutMode", 1)
+    return acc, SCT_FrontEnd(name, **kwargs)
+
+def SCT_FrontEndPileupCfg(flags, name="PileupSCT_FrontEnd", **kwargs):
+    """Return pileup-configured ComponentAccumulator with front-end electronics tool"""
+    kwargs.setdefault("NoiseBarrel", 0.0)
+    kwargs.setdefault("NoiseBarrel3", 0.0)
+    kwargs.setdefault("NoiseInners", 0.0)
+    kwargs.setdefault("NoiseMiddles", 0.0)
+    kwargs.setdefault("NoiseShortMiddles", 0.0)
+    kwargs.setdefault("NoiseOuters", 0.0)
+    kwargs.setdefault("NOBarrel", 0.0)
+    kwargs.setdefault("NOBarrel3", 0.0)
+    kwargs.setdefault("NOInners", 0.0)
+    kwargs.setdefault("NOMiddles", 0.0)
+    kwargs.setdefault("NOShortMiddles", 0.0)
+    kwargs.setdefault("NOOuters", 0.0)
+    kwargs.setdefault("NoiseOn", False)
+    return SCT_FrontEndCfg(flags, name, **kwargs)
+
+def SiliconRangeCfg(flags, name="SiliconRange", **kwargs):
+    """Return a configured PileUpXingFolder tool"""
+    kwargs.setdefault("FirstXing", SCT_FirstXing())
+    kwargs.setdefault("LastXing", SCT_LastXing())
+    kwargs.setdefault("CacheRefreshFrequency", 1.0) # default 0 no dataproxy reset
+    kwargs.setdefault("ItemList", ["SiHitCollection#SCT_Hits"] )
+    return PileUpXingFolder(name, **kwargs)
+
+def SCT_DigitizationCfg(toolCfg, flags, name="SCT_Digitization", **kwargs):
+    """Return a ComponentAccumulator with toolCfg type SCT digitization"""
+    acc = ComponentAccumulator()
+    if "DigitizationTool" not in kwargs:
+        toolAcc, tool = toolCfg(flags)
+        kwargs["DigitizationTool"] = tool
+        acc.merge(toolAcc)
+    alg = SCT_Digitization(name, **kwargs)
+    acc.addEventAlgo(alg)
+    return acc
+
+def SCT_DigitizationHSCfg(flags, name="SCT_DigitizationHS", **kwargs):
+    """Return a ComponentAccumulator with Hard Scatter SCT digitization"""
+    return SCT_DigitizationCfg(SCT_DigitizationToolHSCfg, flags, name, **kwargs)
+
+def SCT_DigitizationPUCfg(flags, name="SCT_DigitizationPU", **kwargs):
+    """Return a ComponentAccumulator with PileUp SCT digitization"""
+    return SCT_DigitizationCfg(SCT_DigitizationToolPUCfg, flags, name, **kwargs)
+
+def SCT_DigitizationOverlayCfg(flags, name="SCT_OverlayDigitization", **kwargs):
+    """Return a ComponentAccumulator with Overlay SCT digitization"""
+    return SCT_DigitizationCfg(SCT_DigitizationToolOverlayCfg, flags, name, **kwargs)
+
diff --git a/InnerDetector/InDetDigitization/SCT_Digitization/test/SCT_DigitizationConfigNew_test.py b/InnerDetector/InDetDigitization/SCT_Digitization/test/SCT_DigitizationConfigNew_test.py
new file mode 100755
index 0000000000000000000000000000000000000000..334c611412167bff8baa220242436d18ec520933
--- /dev/null
+++ b/InnerDetector/InDetDigitization/SCT_Digitization/test/SCT_DigitizationConfigNew_test.py
@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+"""Run tests on SCT_DigitizationConfigNew.py
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaCommon.Logging import log
+from AthenaCommon.Constants import DEBUG
+from AthenaCommon.Configurable import Configurable
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.AllConfigFlags import ConfigFlags
+from AthenaConfiguration.MainServicesConfig import MainServicesSerialCfg
+from AthenaConfiguration.TestDefaults import defaultTestFiles
+from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
+from AtlasGeoModel.InDetGMConfig import InDetGeometryCfg
+from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+from SCT_Digitization.SCT_DigitizationConfigNew import (
+    SCT_RandomDisabledCellGeneratorCfg, SCT_AmpCfg, SCT_SurfaceChargesGeneratorCfg,
+    SCT_FrontEndCfg, SCT_FrontEndPileupCfg, SCT_DigitizationCommonCfg, SCT_DigitizationToolCfg,
+    SCT_DigitizationToolGeantinoTruthCfg, SCT_DigitizationToolHSCfg, SCT_DigitizationToolPUCfg,
+    SCT_DigitizationToolSplitNoMergePUCfg, SCT_DigitizationToolOverlayCfg, SCT_DigitizationHSCfg,
+    SCT_DigitizationPUCfg, SCT_DigitizationOverlayCfg, SiliconRangeCfg,
+)
+from Digitization.DigitizationConfigFlags import createDigitizationCfgFlags
+from OverlayCommonAlgs.OverlayConfigFlags import createOverlayCfgFlags
+
+# Set up logging and new style config
+log.setLevel(DEBUG)
+Configurable.configurableRun3Behavior = True
+# Configure
+ConfigFlags.join(createDigitizationCfgFlags())
+ConfigFlags.join(createOverlayCfgFlags())
+ConfigFlags.Input.Files = defaultTestFiles.HITS
+ConfigFlags.IOVDb.GlobalTag = "OFLCOND-MC16-SDR-16"
+ConfigFlags.GeoModel.Align.Dynamic = False
+ConfigFlags.Concurrency.NumThreads = 1
+ConfigFlags.lock()
+# Function tests
+acc1, tool = SCT_DigitizationCommonCfg(ConfigFlags)
+acc2, tool = SCT_DigitizationToolCfg(ConfigFlags)
+acc3, tool = SCT_DigitizationToolHSCfg(ConfigFlags)
+acc4, tool = SCT_DigitizationToolPUCfg(ConfigFlags)
+acc5, tool = SCT_DigitizationToolOverlayCfg(ConfigFlags)
+acc6, tool = SCT_DigitizationToolSplitNoMergePUCfg(ConfigFlags)
+acc7, tool = SCT_DigitizationToolGeantinoTruthCfg(ConfigFlags)
+tool = SCT_RandomDisabledCellGeneratorCfg(ConfigFlags)
+tool = SCT_AmpCfg(ConfigFlags)
+acc8, tool = SCT_SurfaceChargesGeneratorCfg(ConfigFlags)
+acc9, tool = SCT_FrontEndCfg(ConfigFlags)
+accA, tool = SCT_FrontEndPileupCfg(ConfigFlags)
+tool = SiliconRangeCfg(ConfigFlags)
+accB = SCT_DigitizationHSCfg(ConfigFlags)
+accC = SCT_DigitizationPUCfg(ConfigFlags)
+accD = SCT_DigitizationOverlayCfg(ConfigFlags)
+acc1.mergeAll([acc2, acc3, acc4, acc5, acc6, acc7, acc8, acc9, accA, accB, accC, accD])
+acc1.wasMerged()
+# Construct our accumulator to run
+acc = MainServicesSerialCfg()
+from StoreGate.StoreGateConf import StoreGateSvc # FIXME remove this once athena is fixed
+acc.addService(StoreGateSvc("ConditionStore"))
+acc.merge(PoolReadCfg(ConfigFlags))
+acc.merge(SCT_DigitizationHSCfg(ConfigFlags))
+# Add configuration to write HITS pool file
+outConfig = OutputStreamCfg(ConfigFlags, "RDO",
+                            ItemList=["InDet::SiClusterContainer#*", "SCT_RDO_Container#*"])
+acc.merge(outConfig)
+# Dump config
+acc.getService("StoreGateSvc").Dump = True
+acc.getService("ConditionStore").Dump = True
+acc.printConfig(withDetails=True)
+ConfigFlags.dump()
+# Execute and finish
+acc.run(maxEvents=3)
+
diff --git a/Simulation/Digitization/python/DigitizationConfigFlags.py b/Simulation/Digitization/python/DigitizationConfigFlags.py
new file mode 100644
index 0000000000000000000000000000000000000000..4345f43b11bc78e28db7f5a4fd030c7cf6702fc8
--- /dev/null
+++ b/Simulation/Digitization/python/DigitizationConfigFlags.py
@@ -0,0 +1,19 @@
+"""Construct ConfigFlags for Digitization
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.AthConfigFlags import AthConfigFlags
+
+def createDigitizationCfgFlags():
+    """Return an AthConfigFlags object with required flags"""
+    flags = AthConfigFlags()
+    # Run Inner Detector noise simulation
+    flags.addFlag("Digitization.DoInnerDetectorNoise", True)
+    # Run pile-up digitization on one bunch crossing at a time?
+    flags.addFlag("Digitization.DoXingByXingPileUp", False)
+    # Run pile-up premixing
+    flags.addFlag("Digitization.PileUpPremixing", False)
+    # Run pile-up premixing for Multi-Threading
+    flags.addFlag("Digitization.PileUpPremixingForMT", False)
+    return flags
+