From 589a6cd149d04c400c1db064eeccfcd4c475c194 Mon Sep 17 00:00:00 2001
From: Rupert Tombs <rt500@cam.ac.uk>
Date: Mon, 11 Mar 2019 17:51:11 +0000
Subject: [PATCH] ComponentAccumulator configuration for SCT and Pixel inner
 detectors. With ToolSetup dependencies also converted to new style.
 ConfigFlags initialisation set up for Digitization and Overlay. Tests for all
 new modules

Add ConditionsStore StoreGateSvc

Remove Pixel config update
---
 .../python/AllConfigFlags.py                  |   4 +
 .../python/OverlayConfigFlags.py              |  19 ++
 .../PixelConditionsTools/CMakeLists.txt       |   4 +
 .../python/PixelConditionsSummaryConfig.py    |  35 +++
 .../python/PixelDCSConditionsConfig.py        |  31 +++
 .../test/PixelConditionsConfig_test.py        |  25 ++
 .../SCT_ConditionsTools/CMakeLists.txt        |   5 +
 .../python/SCT_DCSConditionsConfig.py         |  48 ++++
 .../python/SCT_ReadCalibChipDataConfig.py     |  33 +++
 .../python/SCT_SiliconConditionsConfig.py     |  34 +++
 .../test/SCT_ConditionsConfig_test.py         |  29 ++
 .../SiLorentzAngleTool/CMakeLists.txt         |   4 +
 .../python/PixelLorentzAngleConfig.py         |  34 +++
 .../python/SCT_LorentzAngleConfig.py          |  57 ++++
 .../test/SiLorentzAngleConfig_test.py         |  31 +++
 .../SiPropertiesTool/CMakeLists.txt           |   5 +
 .../python/PixelSiPropertiesConfig.py         |  25 ++
 .../python/SCT_SiPropertiesConfig.py          |  25 ++
 .../test/SiPropertiesConfig_test.py           |  25 ++
 .../InDetDetDescr/PixelCabling/CMakeLists.txt |   4 +
 .../python/PixelCablingConfigNew.py           | 100 +++++++
 .../test/PixelCablingConfigNew_test.py        |  21 ++
 .../python/BCM_DigitizationConfigNew.py       |   4 +-
 .../test/BCM_DigitizationConfigNew_test.py    |  39 +--
 .../SCT_Digitization/CMakeLists.txt           |   4 +
 .../python/SCT_DigitizationConfigNew.py       | 254 ++++++++++++++++++
 .../test/SCT_DigitizationConfigNew_test.py    |  73 +++++
 .../python/DigitizationConfigFlags.py         |  19 ++
 28 files changed, 970 insertions(+), 21 deletions(-)
 create mode 100644 Event/EventOverlay/OverlayCommonAlgs/python/OverlayConfigFlags.py
 create mode 100644 InnerDetector/InDetConditions/PixelConditionsTools/python/PixelConditionsSummaryConfig.py
 create mode 100644 InnerDetector/InDetConditions/PixelConditionsTools/python/PixelDCSConditionsConfig.py
 create mode 100755 InnerDetector/InDetConditions/PixelConditionsTools/test/PixelConditionsConfig_test.py
 create mode 100644 InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_DCSConditionsConfig.py
 create mode 100644 InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_ReadCalibChipDataConfig.py
 create mode 100644 InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_SiliconConditionsConfig.py
 create mode 100755 InnerDetector/InDetConditions/SCT_ConditionsTools/test/SCT_ConditionsConfig_test.py
 create mode 100644 InnerDetector/InDetConditions/SiLorentzAngleTool/python/PixelLorentzAngleConfig.py
 create mode 100644 InnerDetector/InDetConditions/SiLorentzAngleTool/python/SCT_LorentzAngleConfig.py
 create mode 100755 InnerDetector/InDetConditions/SiLorentzAngleTool/test/SiLorentzAngleConfig_test.py
 create mode 100644 InnerDetector/InDetConditions/SiPropertiesTool/python/PixelSiPropertiesConfig.py
 create mode 100644 InnerDetector/InDetConditions/SiPropertiesTool/python/SCT_SiPropertiesConfig.py
 create mode 100755 InnerDetector/InDetConditions/SiPropertiesTool/test/SiPropertiesConfig_test.py
 create mode 100644 InnerDetector/InDetDetDescr/PixelCabling/python/PixelCablingConfigNew.py
 create mode 100755 InnerDetector/InDetDetDescr/PixelCabling/test/PixelCablingConfigNew_test.py
 create mode 100644 InnerDetector/InDetDigitization/SCT_Digitization/python/SCT_DigitizationConfigNew.py
 create mode 100755 InnerDetector/InDetDigitization/SCT_Digitization/test/SCT_DigitizationConfigNew_test.py
 create mode 100644 Simulation/Digitization/python/DigitizationConfigFlags.py

diff --git a/Control/AthenaConfiguration/python/AllConfigFlags.py b/Control/AthenaConfiguration/python/AllConfigFlags.py
index 3dbc6b7a75c..c47cf0cd001 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 00000000000..19092cba371
--- /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 0209bebcef7..ac5761032a3 100644
--- a/InnerDetector/InDetConditions/PixelConditionsTools/CMakeLists.txt
+++ b/InnerDetector/InDetConditions/PixelConditionsTools/CMakeLists.txt
@@ -51,6 +51,10 @@ 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} )
 
+atlas_add_test( PixelConditionsConfig_test
+                SCRIPT test/PixelConditionsConfig_test.py
+                PROPERTIES TIMEOUT 30 )
+
 # 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 00000000000..1f5af82d70f
--- /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 00000000000..60fd358a48a
--- /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 00000000000..182a291c078
--- /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 6f3c6525d75..6a707095ed0 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 00000000000..9f09f2eb727
--- /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 00000000000..0727f41c115
--- /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 00000000000..fb841600267
--- /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 00000000000..78cdab2ff3f
--- /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 86125e6f55e..10122dac8cd 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 00000000000..908a57e1419
--- /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 00000000000..233f4ff54db
--- /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 00000000000..1c72737ed6f
--- /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 c91b4aef25d..0cc2f935cad 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 00000000000..66de19b5e61
--- /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 00000000000..db9151a29e3
--- /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 00000000000..b68c74d5ce6
--- /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 3cf3b433165..bf7ce80ff9a 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 00000000000..1d631ad0ac6
--- /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 00000000000..16ad79046ad
--- /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 b8f0e266f73..22fc5f896eb 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 17b3469e2e6..daf3af3ae99 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 2b9b8579070..9430fcedfd7 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 00000000000..d54410fc56e
--- /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 00000000000..334c6114121
--- /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 00000000000..4345f43b11b
--- /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
+
-- 
GitLab