diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/CMakeLists.txt b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/CMakeLists.txt
index f5e44340b7955fdb13c5cf7e84de7ea06a442360..03a58ba3920678d40adf998adb14c85c5fe2c611 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/CMakeLists.txt
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/CMakeLists.txt
@@ -100,12 +100,28 @@ atlas_add_test( TestTdaqEnabled
SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testTdaqEnabled.py
PROPERTIES TIMEOUT 600
ENVIRONMENT THREADS=5 )
+
+atlas_add_test( TestCalibChipReadNewConf
+ SCRIPT python -m SCT_ConditionsAlgorithms.SCT_ReadCalibChipDataTestAlgConfig
+ PROPERTIES TIMEOUT 600 )
+atlas_add_test( TestCalibReadNewConf
+ SCRIPT python -m SCT_ConditionsAlgorithms.SCT_ReadCalibDataTestAlgConfig
+ PROPERTIES TIMEOUT 600 )
+atlas_add_test( TestConfigNewConf
+ SCRIPT python -m SCT_ConditionsAlgorithms.SCT_ConfigurationConditionsTestAlgConfig
+ PROPERTIES TIMEOUT 600 )
atlas_add_test( TestDCSConditionsNewConf
SCRIPT python -m SCT_ConditionsAlgorithms.SCT_DCSConditionsTestAlgConfig
PROPERTIES TIMEOUT 600 )
+atlas_add_test( TestMonReadNewConf
+ SCRIPT python -m SCT_ConditionsAlgorithms.SCT_MonitorConditionsTestAlgConfig
+ PROPERTIES TIMEOUT 600 )
atlas_add_test( TestSummaryNewConf
SCRIPT python -m SCT_ConditionsAlgorithms.SCT_ConditionsSummaryTestAlgConfig
PROPERTIES TIMEOUT 600 )
+atlas_add_test( TestTdaqEnabledNewConf
+ SCRIPT python -m SCT_ConditionsAlgorithms.SCT_TdaqEnabledTestAlgConfig
+ PROPERTIES TIMEOUT 600 )
# Install files from the package:
atlas_install_joboptions( share/*.py )
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ConditionsSummaryTestAlgConfig.py b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ConditionsSummaryTestAlgConfig.py
index 26a559c668a85e7ecd2a943d2d89502d0128b972..43759f21f9e81810d5d2da555fe249aaaea85594 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ConditionsSummaryTestAlgConfig.py
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ConditionsSummaryTestAlgConfig.py
@@ -28,16 +28,13 @@ if __name__=="__main__":
ConfigFlags.Input.RunNumber = [310809]
ConfigFlags.addFlag("Input.InitialTimeStamp", 1476741326) # LB 18 of run 310809, 10/17/2016 @ 9:55pm (UTC)
ConfigFlags.IOVDb.GlobalTag = "CONDBR2-BLKPA-2017-06"
- ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2015-03-01-00"
+ ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2016-01-00-01"
ConfigFlags.Detector.GeometrySCT = True
ConfigFlags.lock()
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
cfg = MainServicesCfg(ConfigFlags)
- from SCT_GeoModel.SCT_GeoModelConfig import SCT_GeometryCfg
- cfg.merge(SCT_GeometryCfg(ConfigFlags))
-
from McEventSelector.McEventSelectorConfig import McEventSelectorCfg
cfg.merge(McEventSelectorCfg(ConfigFlags))
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ConfigurationConditionsTestAlgConfig.py b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ConfigurationConditionsTestAlgConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..c30082d708d4bb3af9e595b9440938367d3851fa
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ConfigurationConditionsTestAlgConfig.py
@@ -0,0 +1,44 @@
+"""Define method to configure and test SCT_ConfigurationConditionsTestAlg
+
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+def SCT_ConfigurationConditionsTestAlgCfg(flags, name="SCT_ConfigurationConditionsTestAlg", **kwargs):
+ """Return a configured SCT_ConfigurationConditionsTestAlg"""
+ acc = ComponentAccumulator()
+ from InDetConfig.InDetRecToolConfig import SCT_ConfigurationConditionsToolCfg
+ kwargs.setdefault("SCT_ConfigurationConditionsTool", acc.popToolsAndMerge(SCT_ConfigurationConditionsToolCfg(flags)))
+ acc.addEventAlgo(CompFactory.SCT_ConfigurationConditionsTestAlg(**kwargs))
+ return acc
+
+if __name__=="__main__":
+ from AthenaCommon.Logging import log
+ from AthenaCommon.Constants import INFO
+ log.setLevel(INFO)
+
+ from AthenaCommon.Configurable import Configurable
+ Configurable.configurableRun3Behavior=1
+
+ from AthenaConfiguration.AllConfigFlags import ConfigFlags
+ ConfigFlags.Input.isMC = True
+ ConfigFlags.Input.ProjectName = "mc16_13TeV"
+ ConfigFlags.Input.RunNumber = 310000 # MC16e 2018 run number
+ ConfigFlags.addFlag("Input.InitialTimeStamp", 1550000000) # MC16e 2018 time stamp
+ ConfigFlags.IOVDb.GlobalTag = "OFLCOND-MC16-SDR-RUN2-01"
+ ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2016-01-00-01"
+ ConfigFlags.Detector.GeometrySCT = True
+ ConfigFlags.lock()
+
+ from AthenaConfiguration.MainServicesConfig import MainServicesCfg
+ cfg = MainServicesCfg(ConfigFlags)
+
+ from McEventSelector.McEventSelectorConfig import McEventSelectorCfg
+ cfg.merge(McEventSelectorCfg(ConfigFlags))
+
+ algkwargs = {}
+ algkwargs["OutputLevel"] = INFO
+ cfg.merge(SCT_ConfigurationConditionsTestAlgCfg(ConfigFlags, **algkwargs))
+
+ cfg.run(maxEvents=20)
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_MonitorConditionsTestAlgConfig.py b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_MonitorConditionsTestAlgConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..34f58e30f9bf3df63934677c2afe61e3efdb3796
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_MonitorConditionsTestAlgConfig.py
@@ -0,0 +1,44 @@
+"""Define method to configure and test SCT_MonitorConditionsTestAlg
+
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+def SCT_MonitorConditionsTestAlgCfg(flags, name="SCT_MonitorConditionsTestAlg", **kwargs):
+ """Return a configured SCT_MonitorConditionsTestAlg"""
+ acc = ComponentAccumulator()
+ from InDetConfig.InDetRecToolConfig import SCT_MonitorConditionsToolCfg
+ kwargs.setdefault("SCT_MonitorConditionsTool", acc.popToolsAndMerge(SCT_MonitorConditionsToolCfg(flags)))
+ acc.addEventAlgo(CompFactory.SCT_MonitorConditionsTestAlg(**kwargs))
+ return acc
+
+if __name__=="__main__":
+ from AthenaCommon.Logging import log
+ from AthenaCommon.Constants import INFO
+ log.setLevel(INFO)
+
+ from AthenaCommon.Configurable import Configurable
+ Configurable.configurableRun3Behavior=1
+
+ from AthenaConfiguration.AllConfigFlags import ConfigFlags
+ ConfigFlags.Input.isMC = True
+ ConfigFlags.Input.ProjectName = "mc16_13TeV"
+ ConfigFlags.Input.RunNumber = 310000 # MC16e 2018 run number
+ ConfigFlags.addFlag("Input.InitialTimeStamp", 1550000000) # MC16e 2018 time stamp
+ ConfigFlags.IOVDb.GlobalTag = "OFLCOND-MC16-SDR-RUN2-01"
+ ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2016-01-00-01"
+ ConfigFlags.Detector.GeometrySCT = True
+ ConfigFlags.lock()
+
+ from AthenaConfiguration.MainServicesConfig import MainServicesCfg
+ cfg = MainServicesCfg(ConfigFlags)
+
+ from McEventSelector.McEventSelectorConfig import McEventSelectorCfg
+ cfg.merge(McEventSelectorCfg(ConfigFlags))
+
+ algkwargs = {}
+ algkwargs["OutputLevel"] = INFO
+ cfg.merge(SCT_MonitorConditionsTestAlgCfg(ConfigFlags, **algkwargs))
+
+ cfg.run(maxEvents=20)
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ReadCalibChipDataTestAlgConfig.py b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ReadCalibChipDataTestAlgConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfbf482eee3849a13c9b947db0610dbd097d2c53
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ReadCalibChipDataTestAlgConfig.py
@@ -0,0 +1,48 @@
+"""Define method to configure and test SCT_ReadCalibChipDataTestAlg
+
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+def SCT_ReadCalibChipDataTestAlgCfg(flags, name="SCT_ReadCalibChipDataTestAlg", **kwargs):
+ """Return a configured SCT_ReadCalibChipDataTestAlg"""
+ acc = ComponentAccumulator()
+ from SCT_ConditionsTools.SCT_ReadCalibChipDataConfig import SCT_ReadCalibChipDataCfg
+ kwargs.setdefault("SCT_ReadCalibChipDataTool", acc.popToolsAndMerge(SCT_ReadCalibChipDataCfg(flags)))
+ acc.addEventAlgo(CompFactory.SCT_ReadCalibChipDataTestAlg(**kwargs))
+ return acc
+
+if __name__=="__main__":
+ from AthenaCommon.Logging import log
+ from AthenaCommon.Constants import INFO
+ log.setLevel(INFO)
+
+ from AthenaCommon.Configurable import Configurable
+ Configurable.configurableRun3Behavior=1
+
+ from AthenaConfiguration.AllConfigFlags import ConfigFlags
+ ConfigFlags.Input.isMC = True
+ ConfigFlags.Input.ProjectName = "mc16_13TeV"
+ ConfigFlags.Input.RunNumber = 300000 # MC16c 2017 run number
+ ConfigFlags.addFlag("Input.InitialTimeStamp", 1500000000) # MC16c 2017 time stamp
+ ConfigFlags.IOVDb.GlobalTag = "OFLCOND-MC16-SDR-18"
+ ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2015-03-01-00"
+ ConfigFlags.Detector.GeometrySCT = True
+ ConfigFlags.lock()
+
+ from AthenaConfiguration.MainServicesConfig import MainServicesCfg
+ cfg = MainServicesCfg(ConfigFlags)
+
+ from McEventSelector.McEventSelectorConfig import McEventSelectorCfg
+ cfg.merge(McEventSelectorCfg(ConfigFlags))
+
+ algkwargs = {}
+ ## Modules to test:
+ algkwargs["ModuleOfflinePosition"] = [-2, 0, 1, 11, 0, 706] #(EC/B, Disk/Layer, eta, phi, side, strip)
+ algkwargs["DoTestmyConditionsSummary"] = True
+ algkwargs["DoTestmyDataSummary"] = True
+ algkwargs["OutputLevel"] = INFO
+ cfg.merge(SCT_ReadCalibChipDataTestAlgCfg(ConfigFlags, **algkwargs))
+
+ cfg.run(maxEvents=20)
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ReadCalibDataTestAlgConfig.py b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ReadCalibDataTestAlgConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..34499dcda73c4817a0df9795ceaba677d6f5c8d7
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_ReadCalibDataTestAlgConfig.py
@@ -0,0 +1,48 @@
+"""Define method to configure and test SCT_ReadCalibDataTestAlg
+
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+def SCT_ReadCalibDataTestAlgCfg(flags, name="SCT_ReadCalibDataTestAlg", **kwargs):
+ """Return a configured SCT_ReadCalibDataTestAlg"""
+ acc = ComponentAccumulator()
+ from InDetConfig.InDetRecToolConfig import SCT_ReadCalibDataToolCfg
+ kwargs.setdefault("SCT_ReadCalibDataTool", acc.popToolsAndMerge(SCT_ReadCalibDataToolCfg(flags)))
+ acc.addEventAlgo(CompFactory.SCT_ReadCalibDataTestAlg(**kwargs))
+ return acc
+
+if __name__=="__main__":
+ from AthenaCommon.Logging import log
+ from AthenaCommon.Constants import INFO
+ log.setLevel(INFO)
+
+ from AthenaCommon.Configurable import Configurable
+ Configurable.configurableRun3Behavior=1
+
+ from AthenaConfiguration.AllConfigFlags import ConfigFlags
+ ConfigFlags.Input.isMC = True
+ ConfigFlags.Input.ProjectName = "mc16_13TeV"
+ ConfigFlags.Input.RunNumber = 300000 # MC16c 2017 run number
+ ConfigFlags.addFlag("Input.InitialTimeStamp", 1500000000) # MC16c 2017 time stamp
+ ConfigFlags.IOVDb.GlobalTag = "OFLCOND-MC16-SDR-18"
+ ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2015-03-01-00"
+ ConfigFlags.Detector.GeometrySCT = True
+ ConfigFlags.lock()
+
+ from AthenaConfiguration.MainServicesConfig import MainServicesCfg
+ cfg = MainServicesCfg(ConfigFlags)
+
+ from McEventSelector.McEventSelectorConfig import McEventSelectorCfg
+ cfg.merge(McEventSelectorCfg(ConfigFlags))
+
+ algkwargs = {}
+ ## Modules to test:
+ algkwargs["ModuleOfflinePosition"] = [2, 1, 2, 12, 1, 464] #(EC/B, Disk/Layer, eta, phi, side, strip)
+ algkwargs["DoTestmyConditionsSummary"] = True
+ algkwargs["DoTestmyDefectIsGood"] = True
+ algkwargs["OutputLevel"] = INFO
+ cfg.merge(SCT_ReadCalibDataTestAlgCfg(ConfigFlags, **algkwargs))
+
+ cfg.run(maxEvents=20)
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_TdaqEnabledTestAlgConfig.py b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_TdaqEnabledTestAlgConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..138b92e5e6c466f44e11db36a7cde2d757ec7cd7
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/python/SCT_TdaqEnabledTestAlgConfig.py
@@ -0,0 +1,44 @@
+"""Define method to configure and test SCT_TdaqEnabledTestAlg
+
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+def SCT_TdaqEnabledTestAlgCfg(flags, name="SCT_TdaqEnabledTestAlg", **kwargs):
+ """Return a configured SCT_TdaqEnabledTestAlg"""
+ acc = ComponentAccumulator()
+ from InDetConfig.InDetRecToolConfig import SCT_TdaqEnabledToolCfg
+ kwargs.setdefault("SCT_TdaqEnabledTool", acc.popToolsAndMerge(SCT_TdaqEnabledToolCfg(flags)))
+ acc.addEventAlgo(CompFactory.SCT_TdaqEnabledTestAlg(**kwargs))
+ return acc
+
+if __name__=="__main__":
+ from AthenaCommon.Logging import log
+ from AthenaCommon.Constants import INFO
+ log.setLevel(INFO)
+
+ from AthenaCommon.Configurable import Configurable
+ Configurable.configurableRun3Behavior=1
+
+ from AthenaConfiguration.AllConfigFlags import ConfigFlags
+ ConfigFlags.Input.isMC = False
+ ConfigFlags.Input.ProjectName = "data16_13TeV"
+ ConfigFlags.Input.RunNumber = 310809
+ ConfigFlags.addFlag("Input.InitialTimeStamp", 1476741326) # LB 18 of run 310809, 10/17/2016 @ 9:55pm (UTC)
+ ConfigFlags.IOVDb.GlobalTag = "CONDBR2-BLKPA-2017-06"
+ ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2016-01-00-01"
+ ConfigFlags.Detector.GeometrySCT = True
+ ConfigFlags.lock()
+
+ from AthenaConfiguration.MainServicesConfig import MainServicesCfg
+ cfg = MainServicesCfg(ConfigFlags)
+
+ from McEventSelector.McEventSelectorConfig import McEventSelectorCfg
+ cfg.merge(McEventSelectorCfg(ConfigFlags))
+
+ algkwargs = {}
+ algkwargs["OutputLevel"] = INFO
+ cfg.merge(SCT_TdaqEnabledTestAlgCfg(ConfigFlags, **algkwargs))
+
+ cfg.run(maxEvents=20)
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_ReadCalibChipDataConfig.py b/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_ReadCalibChipDataConfig.py
index 36e9a2bee5920dc127b2e2c64f6aba53c6773867..31870a0c2523457a3c8c78567d16cddf5dff989d 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_ReadCalibChipDataConfig.py
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_ReadCalibChipDataConfig.py
@@ -4,22 +4,20 @@ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
"""
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
+from AtlasGeoModel.GeoModelConfig import GeoModelCfg
from IOVDbSvc.IOVDbSvcConfig import addFoldersSplitOnline
SCT_ReadCalibChipDataTool=CompFactory.SCT_ReadCalibChipDataTool
SCT_ReadCalibChipNoiseCondAlg=CompFactory.SCT_ReadCalibChipNoiseCondAlg
SCT_ReadCalibChipGainCondAlg=CompFactory.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 with SCT_ReadCalibChipDataCfg tool
Accepts optional noiseFolder and gainFolder keyword arguments
"""
acc = ComponentAccumulator()
- # folders
+
+ # Folders
noiseFolder = kwargs.get("noiseFolder", "/SCT/DAQ/Calibration/ChipNoise")
gainFolder = kwargs.get("gainFolder", "/SCT/DAQ/Calibration/ChipGain")
if flags.Overlay.DataOverlay:
@@ -37,10 +35,13 @@ def SCT_ReadCalibChipDataCfg(flags, name="SCT_ReadCalibChip", **kwargs):
forceDb=forceDb, tag=gainTag))
# Algorithms
+ acc.merge(GeoModelCfg(flags)) # For SCT_ID used in SCT_ReadCalibChipNoiseCondAlg, SCT_ReadCalibChipGainCondAlg, SCT_ReadCalibChipDataTool
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))
- acc.setPrivateTools(tool)
+
+ # Tool
+ acc.setPrivateTools(SCT_ReadCalibChipDataTool(name="InDetSCT_ReadCalibChipDataTool"))
+
return acc
diff --git a/InnerDetector/InDetConfig/python/InDetRecToolConfig.py b/InnerDetector/InDetConfig/python/InDetRecToolConfig.py
index d8a4dcdec1f2060190f6f661a2a5331991ce1acd..1b5a16baff7ff8f5f4a6e340838e3fdf0c0848a4 100644
--- a/InnerDetector/InDetConfig/python/InDetRecToolConfig.py
+++ b/InnerDetector/InDetConfig/python/InDetRecToolConfig.py
@@ -136,26 +136,7 @@ def PixelConditionsSummaryToolCfg(flags, name = "InDetPixelConditionsSummaryTool
def InDetSCT_ConditionsSummaryToolCfg(flags, name = "InDetSCT_ConditionsSummaryTool", **kwargs) :
result = ComponentAccumulator()
- # Load conditions configuration service and load folders and algorithm for it
- # Load folders that have to exist for both MC and Data
- SCTConfigurationFolderPath='/SCT/DAQ/Config/'
- #if its COMP200, use old folders...
- if (flags.IOVDb.DatabaseInstance == "COMP200"):
- SCTConfigurationFolderPath='/SCT/DAQ/Configuration/'
- #...but now check if we want to override that decision with explicit flag (if there is one)
- if flags.InDet.ForceCoraCool:
- SCTConfigurationFolderPath='/SCT/DAQ/Configuration/'
- if flags.InDet.ForceCoolVectorPayload:
- SCTConfigurationFolderPath='/SCT/DAQ/Config/'
-
- if (flags.InDet.ForceCoolVectorPayload and flags.InDet.ForceCoraCool):
- print ('*** SCT DB CONFIGURATION FLAG CONFLICT: Both CVP and CoraCool selected****')
- SCTConfigurationFolderPath=''
-
- cond_kwargs={"ChannelFolder" : SCTConfigurationFolderPath+("ChipSlim" if flags.Input.isMC else "Chip"),
- "ModuleFolder" : SCTConfigurationFolderPath+"Module",
- "MurFolder" : SCTConfigurationFolderPath+"MUR"}
- cfgCondToolAcc = SCT_ConfigurationConditionsToolCfg(flags,name, cond_kwargs=cond_kwargs)
+ cfgCondToolAcc = SCT_ConfigurationConditionsToolCfg(flags, name)
SCT_ConfigurationConditionsTool = cfgCondToolAcc.popPrivateTools()
result.merge(cfgCondToolAcc)
if (flags.InDet.doPrintConfigurables):
@@ -242,39 +223,61 @@ def InDetSCT_ConditionsSummaryToolCfg(flags, name = "InDetSCT_ConditionsSummaryT
result.setPrivateTools(InDetSCT_ConditionsSummaryTool)
return result
-def SCT_ConfigurationConditionsToolCfg(flags, name="SCT_ConfigurationConditionsTool", cond_kwargs={}, **kwargs):
- cond_kwargs.setdefault("ChannelFolder", "/SCT/DAQ/Config/ChipSlim" if flags.Input.isMC else "/SCT/DAQ/Config/Chip")
- cond_kwargs.setdefault("ModuleFolder","/SCT/DAQ/Config/Module")
- cond_kwargs.setdefault("MurFolder","/SCT/DAQ/Config/MUR")
- cond_kwargs.setdefault("dbInstance","SCT")
- cond_kwargs.setdefault("SCT_ConfigurationCondAlgName","SCT_ConfigurationCondAlg")
+def SCT_ConfigurationConditionsToolCfg(flags, name="SCT_ConfigurationConditionsTool", **kwargs):
+ # Load conditions configuration service and load folders and algorithm for it
+ # Load folders that have to exist for both MC and Data
+ SCTConfigurationFolderPath='/SCT/DAQ/Config/'
+ #if its COMP200, use old folders...
+ if (flags.IOVDb.DatabaseInstance == "COMP200"):
+ SCTConfigurationFolderPath='/SCT/DAQ/Configuration/'
+ #...but now check if we want to override that decision with explicit flag (if there is one)
+ if flags.InDet.ForceCoraCool:
+ SCTConfigurationFolderPath='/SCT/DAQ/Configuration/'
+ if flags.InDet.ForceCoolVectorPayload:
+ SCTConfigurationFolderPath='/SCT/DAQ/Config/'
+
+ if (flags.InDet.ForceCoolVectorPayload and flags.InDet.ForceCoraCool):
+ print ('*** SCT DB CONFIGURATION FLAG CONFLICT: Both CVP and CoraCool selected****')
+ SCTConfigurationFolderPath=''
+
+ cond_kwargs = {}
+ cond_kwargs["ChannelFolder"] = SCTConfigurationFolderPath+("ChipSlim" if flags.Input.isMC else "Chip")
+ cond_kwargs["ModuleFolder"] = SCTConfigurationFolderPath+"Module"
+ cond_kwargs["MurFolder"] = SCTConfigurationFolderPath+"MUR"
+ cond_kwargs["dbInstance"] = "SCT"
+ cond_kwargs["SCT_ConfigurationCondAlgName"] = "SCT_ConfigurationCondAlg"
result = ComponentAccumulator()
+
+ # For SCT_ID and SCT_DetectorElementCollection used in SCT_ConfigurationCondAlg and SCT_ConfigurationConditionsTool
+ from SCT_GeoModel.SCT_GeoModelConfig import SCT_GeometryCfg
+ result.merge(SCT_GeometryCfg(flags))
+
if 'ChannelFolderDB' not in cond_kwargs:
result.merge(addFoldersSplitOnline(flags,
- detDb=cond_kwargs['dbInstance'],
- online_folders=cond_kwargs["ChannelFolder"],
- offline_folders=cond_kwargs["ChannelFolder"],
- className='CondAttrListVec',
- splitMC=True))
+ detDb=cond_kwargs['dbInstance'],
+ online_folders=cond_kwargs["ChannelFolder"],
+ offline_folders=cond_kwargs["ChannelFolder"],
+ className='CondAttrListVec',
+ splitMC=True))
else:
result.merge(addFolders(flags, [cond_kwargs["ChannelFolderDB"]], detDb = cond_kwargs['dbInstance'], className='CondAttrListVec'))
if 'ModuleFolderDB' not in cond_kwargs:
result.merge(addFoldersSplitOnline(flags,
- detDb=cond_kwargs['dbInstance'],
- online_folders=cond_kwargs["ModuleFolder"],
- offline_folders=cond_kwargs["ModuleFolder"],
- className='CondAttrListVec',
- splitMC=True))
+ detDb=cond_kwargs['dbInstance'],
+ online_folders=cond_kwargs["ModuleFolder"],
+ offline_folders=cond_kwargs["ModuleFolder"],
+ className='CondAttrListVec',
+ splitMC=True))
else:
result.merge(addFolders(flags, [cond_kwargs["ModuleFolderDB"]], detDb = cond_kwargs['dbInstance'], className='CondAttrListVec'))
if 'MurFolderDB' not in cond_kwargs:
result.merge(addFoldersSplitOnline(flags,
- detDb=cond_kwargs['dbInstance'],
- online_folders=cond_kwargs["MurFolder"],
- offline_folders=cond_kwargs["MurFolder"],
- className='CondAttrListVec',
- splitMC=True))
+ detDb=cond_kwargs['dbInstance'],
+ online_folders=cond_kwargs["MurFolder"],
+ offline_folders=cond_kwargs["MurFolder"],
+ className='CondAttrListVec',
+ splitMC=True))
else:
result.merge(addFolders(flags, [cond_kwargs["MurFolderDB"]], detDb = cond_kwargs['dbInstance'], className='CondAttrListVec'))
@@ -333,27 +336,30 @@ def SCT_ConfigurationCondAlgCfg(flags, name="SCT_ConfigurationCondAlg", **kwargs
def SCT_ReadCalibDataToolCfg(flags, name="SCT_ReadCalibDataTool", cond_kwargs={}, **kwargs):
result = ComponentAccumulator()
+ # For SCT_ID and SCT_DetectorElementCollection used in SCT_ReadCalibDataCondAlg and SCT_ReadCalibDataTool
+ from SCT_GeoModel.SCT_GeoModelConfig import SCT_GeometryCfg
+ result.merge(SCT_GeometryCfg(flags))
+
cond_kwargs.setdefault("NoiseFolder","/SCT/DAQ/Calibration/NoiseOccupancyDefects")
cond_kwargs.setdefault("GainFolder","/SCT/DAQ/Calibration/NPtGainDefects")
cond_kwargs.setdefault("ReadCalibDataCondAlgName","SCT_ReadCalibDataCondAlg")
result.merge(addFoldersSplitOnline(flags,
- detDb="SCT",
- online_folders=cond_kwargs["NoiseFolder"],
- offline_folders=cond_kwargs["NoiseFolder"],
- className='CondAttrListCollection',
- splitMC=True))
+ detDb="SCT",
+ online_folders=cond_kwargs["NoiseFolder"],
+ offline_folders=cond_kwargs["NoiseFolder"],
+ className='CondAttrListCollection',
+ splitMC=True))
result.merge(addFoldersSplitOnline(flags,
- detDb="SCT",
- online_folders=cond_kwargs["GainFolder"],
- offline_folders=cond_kwargs["GainFolder"],
- className='CondAttrListCollection',
- splitMC=True))
-
- result.addCondAlgo(CompFactory.SCT_ReadCalibDataCondAlg(
- name = cond_kwargs["ReadCalibDataCondAlgName"],
- ReadKeyGain = cond_kwargs["GainFolder"],
- ReadKeyNoise = cond_kwargs["NoiseFolder"]))
+ detDb="SCT",
+ online_folders=cond_kwargs["GainFolder"],
+ offline_folders=cond_kwargs["GainFolder"],
+ className='CondAttrListCollection',
+ splitMC=True))
+
+ result.addCondAlgo(CompFactory.SCT_ReadCalibDataCondAlg(name = cond_kwargs["ReadCalibDataCondAlgName"],
+ ReadKeyGain = cond_kwargs["GainFolder"],
+ ReadKeyNoise = cond_kwargs["NoiseFolder"]))
acc = SCT_CablingToolCfg(flags)
kwargs.setdefault("SCT_CablingTool", acc.popPrivateTools())
result.merge(acc)
@@ -376,6 +382,10 @@ def SCT_MonitorConditionsToolCfg(flags, name="InDetSCT_MonitorConditionsTool", c
result = ComponentAccumulator()
+ # For SCT_ID used in SCT_MonitorConditionsTool
+ from AtlasGeoModel.GeoModelConfig import GeoModelCfg
+ result.merge(GeoModelCfg(flags))
+
if "FolderDb" not in cond_kwargs:
cond_kwargs["FolderDb"] = cond_kwargs["Folder"]
result.merge(addFolders(flags, cond_kwargs["FolderDb"], cond_kwargs["dbInstance"], className="CondAttrListCollection"))
@@ -404,29 +414,29 @@ def SCT_CablingToolCfg(flags):
result.setPrivateTools(tool)
return result
-def SCT_TdaqEnabledToolCfg(flags):
- # Copied from https://gitlab.cern.ch/atlas/athena/blob/master/InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_TdaqEnabledToolSetup.py
- result = SCT_TdaqEnabledCondAlgCfg(flags)
- tool = CompFactory.SCT_TdaqEnabledTool()
- result.setPrivateTools(tool)
- return result
-
-def SCT_TdaqEnabledCondAlgCfg(flags, name="SCT_TdaqEnabledCondAlg", **kwargs):
+def SCT_TdaqEnabledToolCfg(flags, name="InDetSCT_TdaqEnabledTool", **kwargs):
if flags.Input.isMC:
print("Warning: should not setup SCT_TdaqEnabledCond for MC")
return
+
result = ComponentAccumulator()
+ # For SCT_ID used in SCT_TdaqEnabledTool
+ from AtlasGeoModel.GeoModelConfig import GeoModelCfg
+ result.merge(GeoModelCfg(flags))
+
+ # Folder
#FIXME - is there a better way to do this? What about run3?
folder = '/TDAQ/Resources/ATLAS/SCT/Robins' if (flags.IOVDb.DatabaseInstance == "CONDBR2") else '/TDAQ/EnabledResources/ATLAS/SCT/Robins'
-
result.merge( addFolders(flags, [folder], detDb="TDAQ", className="CondAttrListCollection") )
-
- acc = SCT_CablingToolCfg(flags)
- kwargs.setdefault( "SCT_CablingTool", acc.popPrivateTools() )
- result.merge(acc)
- result.addCondAlgo( CompFactory.SCT_TdaqEnabledCondAlg(name=name, **kwargs) )
+ # Algorithm
+ kwargs.setdefault( "SCT_CablingTool", result.popToolsAndMerge(SCT_CablingToolCfg(flags)) )
+ result.addCondAlgo( CompFactory.SCT_TdaqEnabledCondAlg(**kwargs) )
+
+ # Tool
+ result.setPrivateTools(CompFactory.SCT_TdaqEnabledTool(name=name))
+
return result
def InDetTestPixelLayerToolCfg(flags, name = "InDetTestPixelLayerTool", **kwargs):