diff --git a/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CscRDO_Decoder.cxx b/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CscRDO_Decoder.cxx
index 06d5acf038ee8943acc6e268e6c83214ea9fcc2b..052c33c2a5813d540a39ec400c0a57cd5c923207 100644
--- a/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CscRDO_Decoder.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CscRDO_Decoder.cxx
@@ -10,11 +10,8 @@
/** constructor */
Muon::CscRDO_Decoder::CscRDO_Decoder
( const std::string& type, const std::string& name,const IInterface* parent )
- : base_class(type,name,parent),
- m_cabling( "CSCcablingSvc" ,name),
- m_cscCalibTool( "CscCalibTool") {
-
- declareProperty("CscCalibTool", m_cscCalibTool );
+ : base_class(type,name,parent)
+{
}
StatusCode Muon::CscRDO_Decoder::initialize()
diff --git a/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CscRDO_Decoder.h b/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CscRDO_Decoder.h
index e2ecf3ec9417ffd56a74c492f04ffabc05b96b61..510483137dbfb6b7c0f70725c48fce099a42c4bf 100644
--- a/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CscRDO_Decoder.h
+++ b/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CscRDO_Decoder.h
@@ -58,8 +58,8 @@ namespace Muon {
std::string m_detdescr;
ToolHandle<Muon::MuonIdHelperTool> m_muonIdHelperTool{this, "idHelper",
"Muon::MuonIdHelperTool/MuonIdHelperTool", "Handle to the MuonIdHelperTool"};
- ServiceHandle<CSCcablingSvc> m_cabling;
- ToolHandle<ICscCalibTool> m_cscCalibTool;
+ ServiceHandle<CSCcablingSvc> m_cabling{this, "CSCcablingSvc", "CSCcablingSvc", "CSC cabling service handle"};
+ ToolHandle<ICscCalibTool> m_cscCalibTool{this, "cscCalibTool", "CscCalibTool", "CSC calibration tool handle"};
double m_timeOffset ;
double m_samplingTime ;
double m_signalWidth ;
diff --git a/MuonSpectrometer/MuonConfig/python/CSC_DigitizationConfig.py b/MuonSpectrometer/MuonConfig/python/CSC_DigitizationConfig.py
index 800e8751c3f03dbb9b319646f5263e9aabde9830..86ebbc9504648436bb5134b1fc98a3227fb5a0b7 100644
--- a/MuonSpectrometer/MuonConfig/python/CSC_DigitizationConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/CSC_DigitizationConfig.py
@@ -7,9 +7,7 @@ from AthenaConfiguration.ComponentFactory import CompFactory
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
from MuonConfig.MuonCondAlgConfig import CscCondDbAlgCfg
-CscDigitizationTool, CscDigitBuilder=CompFactory.getComps("CscDigitizationTool","CscDigitBuilder",)
-PileUpXingFolder=CompFactory.PileUpXingFolder
-from MuonConfig.MuonByteStreamCnvTestConfig import CscDigitToCscRDOCfg, CscOverlayDigitToCscRDOCfg
+from MuonConfig.MuonByteStreamCnvTestConfig import CscDigitToCscRDOCfg
from MuonConfig.MuonCablingConfig import CSCCablingConfigCfg
from Digitization.TruthDigitizationOutputConfig import TruthDigitizationOutputCfg
from Digitization.PileUpToolsConfig import PileUpToolsCfg
@@ -31,21 +29,16 @@ def CSC_RangeToolCfg(flags, name="CSC_Range", **kwargs):
kwargs.setdefault("LastXing", CSC_LastXing())
kwargs.setdefault("CacheRefreshFrequency", 1.0)
kwargs.setdefault("ItemList", ["CSCSimHitCollection#CSC_Hits"])
+ PileUpXingFolder = CompFactory.PileUpXingFolder
return PileUpXingFolder(name, **kwargs)
-def CSC_DigitizationToolCfg(flags, name="CSC_DigitizationTool", **kwargs):
+def CSC_DigitizationToolCommonCfg(flags, name="CSC_DigitizationTool", **kwargs):
"""Return a ComponentAccumulator with configured CscDigitizationTool"""
acc = ComponentAccumulator()
if flags.Digitization.DoXingByXingPileUp:
kwargs.setdefault("FirstXing", CSC_FirstXing())
kwargs.setdefault("LastXing", CSC_LastXing())
- kwargs.setdefault("InputObjectName", "CSC_Hits")
- kwargs.setdefault("OutputObjectName", "CSC_DIGITS")
- if flags.Digitization.PileUpPremixing:
- kwargs.setdefault("CSCSimDataCollectionOutputName", flags.Overlay.BkgPrefix + "CSC_SDO")
- else:
- kwargs.setdefault("CSCSimDataCollectionOutputName", "CSC_SDO")
kwargs.setdefault("pedestal", 0.0)
kwargs.setdefault("WindowLowerOffset", -25.0)
kwargs.setdefault("WindowUpperOffset", 25.0)
@@ -54,19 +47,32 @@ def CSC_DigitizationToolCfg(flags, name="CSC_DigitizationTool", **kwargs):
kwargs.setdefault("NewDigitEDM", True)
kwargs.setdefault("DriftVelocity", 39)
kwargs.setdefault("ElectronEnergy", 66) # eV
+
+ from MuonConfig.MuonCalibConfig import CscCalibToolCfg
+ kwargs.setdefault("cscCalibTool", acc.popToolsAndMerge(CscCalibToolCfg(flags)))
+
+ CscDigitizationTool = CompFactory.CscDigitizationTool
acc.setPrivateTools(CscDigitizationTool(name, **kwargs))
return acc
-def CSC_OverlayDigitizationToolCfg(flags, name="CSC_OverlayDigitizationTool",**kwargs):
+def CSC_DigitizationToolCfg(flags, name="CSC_DigitizationTool", **kwargs):
+ """Return a ComponentAccumulator with configured CscDigitizationTool"""
+ kwargs.setdefault("InputObjectName", "CSC_Hits")
+ kwargs.setdefault("OutputObjectName", "CSC_DIGITS")
+ if flags.Digitization.PileUpPremixing:
+ kwargs.setdefault("CSCSimDataCollectionOutputName", flags.Overlay.BkgPrefix + "CSC_SDO")
+ else:
+ kwargs.setdefault("CSCSimDataCollectionOutputName", "CSC_SDO")
+ return CSC_DigitizationToolCommonCfg(flags, name, **kwargs)
+
+
+def CSC_OverlayDigitizationToolCfg(flags, name="CscOverlayDigitizationTool", **kwargs):
"""Return a ComponentAccumulator with CscDigitizationTool configured for Overlay"""
- acc = ComponentAccumulator()
kwargs.setdefault("OnlyUseContainerName", False)
- kwargs.setdefault("OutputObjectName", "StoreGateSvc+" + flags.Overlay.SigPrefix + "CSC_DIGITS")
- if not flags.Overlay.DataOverlay:
- kwargs.setdefault("CSCSimDataCollectionOutputName", "StoreGateSvc+" + flags.Overlay.SigPrefix + "CSC_SDO")
- acc.setPrivateTools(CscDigitizationTool(name, **kwargs))
- return acc
+ kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "CSC_DIGITS")
+ kwargs.setdefault("CSCSimDataCollectionOutputName", flags.Overlay.SigPrefix + "CSC_SDO")
+ return CSC_DigitizationToolCommonCfg(flags, name, **kwargs)
def CSC_OutputCfg(flags):
@@ -98,7 +104,12 @@ def CSC_OverlayDigitizationBasicCfg(flags, **kwargs):
if "DigitizationTool" not in kwargs:
tool = acc.popToolsAndMerge(CSC_OverlayDigitizationToolCfg(flags))
kwargs["DigitizationTool"] = tool
- acc.addEventAlgo(CscDigitBuilder(**kwargs))
+
+ if flags.Concurrency.NumThreads > 0:
+ kwargs.setdefault("Cardinality", flags.Concurrency.NumThreads)
+
+ CscDigitBuilder = CompFactory.CscDigitBuilder
+ acc.addEventAlgo(CscDigitBuilder(name="CscOverlayDigitBuilder", **kwargs))
return acc
@@ -110,24 +121,9 @@ def CSC_DigitizationCfg(flags, **kwargs):
return acc
-def CSC_OverlayDigitizationCfg(flags, **kwargs):
- """Return ComponentAccumulator with CSC Overlay digitization and Output"""
- acc = CSC_OverlayDigitizationBasicCfg(flags, **kwargs)
- acc.merge(CSC_OutputCfg(flags))
- return acc
-
-
def CSC_DigitizationDigitToRDOCfg(flags):
"""Return ComponentAccumulator with CSC Digitization and Digit to CSCRDO"""
acc = CSC_DigitizationCfg(flags)
acc.merge(CSCCablingConfigCfg(flags))
acc.merge(CscDigitToCscRDOCfg(flags))
return acc
-
-
-def CSC_OverlayDigitizationDigitToRDOCfg(flags):
- """Return ComponentAccumulator with CSC Overlay Digitization and Digit to CSCRDO"""
- acc = CSC_OverlayDigitizationCfg(flags)
- acc.merge(CSCCablingConfigCfg(flags))
- acc.merge(CscOverlayDigitToCscRDOCfg(flags))
- return acc
diff --git a/MuonSpectrometer/MuonConfig/python/CscOverlayConfig.py b/MuonSpectrometer/MuonConfig/python/CscOverlayConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..55073cb5543f6b9fc7fb84460a2b9295f1e69814
--- /dev/null
+++ b/MuonSpectrometer/MuonConfig/python/CscOverlayConfig.py
@@ -0,0 +1,99 @@
+
+"""Define methods to construct configured CSC overlay algorithms
+
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+"""
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+
+def CSCDataOverlayExtraCfg(flags, **kwargs):
+ """Return a ComponentAccumulator with CSC data overlay specifics"""
+ acc = ComponentAccumulator()
+
+ # We need to convert BS to RDO for data overlay
+ from MuonConfig.MuonBytestreamDecodeConfig import CscBytestreamDecodeCfg
+ acc.merge(CscBytestreamDecodeCfg(flags))
+
+ return acc
+
+
+def CscOverlayAlgCfg(flags, name="CscOverlay", **kwargs):
+ """Return a ComponentAccumulator for CSCOverlay algorithm"""
+ from MuonConfig.MuonCalibConfig import CscCalibToolCfg
+ acc = CscCalibToolCfg(flags)
+ kwargs.setdefault("CalibTool", acc.popPrivateTools())
+
+ from MuonConfig.MuonCSC_CnvToolsConfig import MuonCscRDODecoderCfg
+ kwargs.setdefault("CscRdoDecoderTool", acc.popToolsAndMerge(MuonCscRDODecoderCfg(flags)))
+
+ kwargs.setdefault("BkgInputKey", flags.Overlay.BkgPrefix + "CSCRDO")
+ kwargs.setdefault("SignalInputKey", flags.Overlay.SigPrefix + "CSCRDO")
+ kwargs.setdefault("OutputKey", "CSCRDO")
+
+ kwargs.setdefault("isDataOverlay", flags.Overlay.DataOverlay)
+
+ # Do CSC overlay
+ CscOverlay = CompFactory.CscOverlay
+ alg = CscOverlay(name, **kwargs)
+ acc.addEventAlgo(alg)
+
+ # Setup output
+ from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+ acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[
+ "CscRawDataContainer#CSCRDO"
+ ]))
+
+ return acc
+
+
+def CscTruthOverlayCfg(flags, name="CscTruthOverlay", **kwargs):
+ """Return a ComponentAccumulator for the CSC SDO overlay algorithm"""
+ acc = ComponentAccumulator()
+
+ # We do not need background CSC SDOs
+ if flags.Overlay.DataOverlay:
+ kwargs.setdefault("BkgInputKey", "")
+ else:
+ kwargs.setdefault("BkgInputKey",
+ flags.Overlay.BkgPrefix + "CSC_SDO")
+
+ kwargs.setdefault("SignalInputKey",
+ flags.Overlay.SigPrefix + "CSC_SDO")
+ kwargs.setdefault("OutputKey", "CSC_SDO")
+
+ # Do CSC truth overlay
+ CscSimDataOverlay = CompFactory.CscSimDataOverlay
+ alg = CscSimDataOverlay(name, **kwargs)
+ acc.addEventAlgo(alg)
+
+ # Setup output
+ from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+ acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[
+ "CscSimDataCollection#CSC_SDO"
+ ]))
+
+ return acc
+
+
+def CscOverlayCfg(flags):
+ """Configure and return a ComponentAccumulator for CSC overlay"""
+ acc = ComponentAccumulator()
+
+ # Add data overlay specifics
+ if flags.Overlay.DataOverlay:
+ acc.merge(CSCDataOverlayExtraCfg(flags))
+
+ # Add CSC overlay digitization algorithm
+ from MuonConfig.CSC_DigitizationConfig import CSC_OverlayDigitizationBasicCfg
+ acc.merge(CSC_OverlayDigitizationBasicCfg(flags))
+ # Add CSC digit to RDO config
+ from MuonConfig.MuonByteStreamCnvTestConfig import CscDigitToCscRDOCfg
+ acc.merge(CscDigitToCscRDOCfg(flags))
+ # Add CSC overlay algorithm
+ acc.merge(CscOverlayAlgCfg(flags))
+ # Add CSC truth overlay
+ acc.merge(CscTruthOverlayCfg(flags))
+
+ return acc
diff --git a/MuonSpectrometer/MuonConfig/python/MDT_DigitizationConfig.py b/MuonSpectrometer/MuonConfig/python/MDT_DigitizationConfig.py
index 350fb82977af1a382cc791affd049e17a4ae13e9..3c2875333e122e445c570c342606bac43c86f06f 100644
--- a/MuonSpectrometer/MuonConfig/python/MDT_DigitizationConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MDT_DigitizationConfig.py
@@ -1,16 +1,12 @@
"""Define methods to construct configured MDT Digitization tools and algorithms
-Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
"""
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
-from MDT_Digitization.MDT_DigitizationConf import (
- MdtDigitizationTool, MDT_Response_DigiTool, RT_Relation_DB_DigiTool, MDT_Digitizer
-)
-PileUpXingFolder=CompFactory.PileUpXingFolder
-from MuonConfig.MuonByteStreamCnvTestConfig import MdtDigitToMdtRDOCfg, MdtOverlayDigitToMdtRDOCfg
+from MuonConfig.MuonByteStreamCnvTestConfig import MdtDigitToMdtRDOCfg
from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
from Digitization.TruthDigitizationOutputConfig import TruthDigitizationOutputCfg
from Digitization.PileUpToolsConfig import PileUpToolsCfg
@@ -33,11 +29,13 @@ def MDT_RangeToolCfg(flags, name="MDT_Range", **kwargs):
kwargs.setdefault("LastXing", MDT_LastXing())
kwargs.setdefault("CacheRefreshFrequency", 1.0)
kwargs.setdefault("ItemList", ["MDTSimHitCollection#MDT_Hits"])
+ PileUpXingFolder=CompFactory.PileUpXingFolder
return PileUpXingFolder(name, **kwargs)
def RT_Relation_DB_DigiToolCfg(flags, name="RT_Relation_DB_DigiTool", **kwargs):
"""Return an RT_Relation_DB_DigiTool"""
+ RT_Relation_DB_DigiTool = CompFactory.RT_Relation_DB_DigiTool
return RT_Relation_DB_DigiTool(name, **kwargs)
@@ -45,11 +43,12 @@ def MDT_Response_DigiToolCfg(flags, name="MDT_Response_DigiTool",**kwargs):
"""Return a configured MDT_Response_DigiTool"""
QballConfig = (flags.Digitization.SpecialConfiguration.get("MDT_QballConfig") == "True")
kwargs.setdefault("DoQballGamma", QballConfig)
+ MDT_Response_DigiTool = CompFactory.MDT_Response_DigiTool
return MDT_Response_DigiTool(name, **kwargs)
-def MDT_DigitizationToolCfg(flags, name="MDT_DigitizationTool", **kwargs):
- """Return ComponentAccumulator with configured MdtDigitizationTool"""
+def MDT_DigitizationToolCommonCfg(flags, name="MDT_DigitizationTool", **kwargs):
+ """Return ComponentAccumulator with common MdtDigitizationTool config"""
from MuonConfig.MuonCondAlgConfig import MdtCondDbAlgCfg # MT-safe conditions access
acc = MdtCondDbAlgCfg(flags)
kwargs.setdefault("MaskedStations", [])
@@ -63,24 +62,28 @@ def MDT_DigitizationToolCfg(flags, name="MDT_DigitizationTool", **kwargs):
if flags.Digitization.DoXingByXingPileUp:
kwargs.setdefault("FirstXing", MDT_FirstXing())
kwargs.setdefault("LastXing", MDT_LastXing())
+ MdtDigitizationTool = CompFactory.MdtDigitizationTool
+ acc.setPrivateTools(MdtDigitizationTool(name, **kwargs))
+ return acc
+
+
+def MDT_DigitizationToolCfg(flags, name="MDT_DigitizationTool", **kwargs):
+ """Return ComponentAccumulator with configured MdtDigitizationTool"""
kwargs.setdefault("OutputObjectName", "MDT_DIGITS")
if flags.Digitization.PileUpPremixing:
kwargs.setdefault("OutputSDOName", flags.Overlay.BkgPrefix + "MDT_SDO")
else:
kwargs.setdefault("OutputSDOName", "MDT_SDO")
- acc.setPrivateTools(MdtDigitizationTool(name, **kwargs))
- return acc
+ return MDT_DigitizationToolCommonCfg(flags, name, **kwargs)
-def MDT_OverlayDigitizationToolCfg(flags, name="MDT_OverlayDigitizationTool",**kwargs):
+def MDT_OverlayDigitizationToolCfg(flags, name="Mdt_OverlayDigitizationTool", **kwargs):
"""Return ComponentAccumulator with MdtDigitizationTool configured for Overlay"""
- acc = ComponentAccumulator()
kwargs.setdefault("OnlyUseContainerName", False)
- kwargs.setdefault("OutputObjectName", "StoreGateSvc+" + flags.Overlay.SigPrefix + "MDT_DIGITS")
- kwargs.setdefault("GetT0FromBD", flags.Detector.Overlay)
- if not flags.Overlay.DataOverlay:
- kwargs.setdefault("OutputSDOName", "StoreGateSvc+" + flags.Overlay.SigPrefix + "MDT_SDO")
- return acc
+ kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "MDT_DIGITS")
+ kwargs.setdefault("OutputSDOName", flags.Overlay.SigPrefix + "MDT_SDO")
+ kwargs.setdefault("GetT0FromBD", flags.Detector.OverlayMDT and not flags.Input.isMC)
+ return MDT_DigitizationToolCommonCfg(flags, name, **kwargs)
def MDT_OutputCfg(flags):
@@ -110,7 +113,12 @@ def MDT_OverlayDigitizationBasicCfg(flags, **kwargs):
if "DigitizationTool" not in kwargs:
tool = acc.popToolsAndMerge(MDT_OverlayDigitizationToolCfg(flags))
kwargs["DigitizationTool"] = tool
- acc.addEventAlgo(MDT_Digitizer(**kwargs))
+
+ if flags.Concurrency.NumThreads > 0:
+ kwargs.setdefault("Cardinality", flags.Concurrency.NumThreads)
+
+ MDT_Digitizer = CompFactory.MDT_Digitizer
+ acc.addEventAlgo(MDT_Digitizer(name="MDT_OverlayDigitizer", **kwargs))
return acc
@@ -122,24 +130,9 @@ def MDT_DigitizationCfg(flags, **kwargs):
return acc
-def MDT_OverlayDigitizationCfg(flags, **kwargs):
- """Return ComponentAccumulator with MDT Overlay digitization and Output"""
- acc = MDT_OverlayDigitizationBasicCfg(flags, **kwargs)
- acc.merge(MDT_OutputCfg(flags))
- return acc
-
-
def MDT_DigitizationDigitToRDOCfg(flags):
"""Return ComponentAccumulator with MDT digitization and Digit to MDTCSM RDO"""
acc = MDT_DigitizationCfg(flags)
acc.merge(MDTCablingConfigCfg(flags))
acc.merge(MdtDigitToMdtRDOCfg(flags))
return acc
-
-
-def MDT_OverlayDigitizationDigitToRDOCfg(flags):
- """Return ComponentAccumulator with MDT Overlay digitization and Digit to MDTCSM RDO"""
- acc = MDT_OverlayDigitizationCfg(flags)
- acc.merge(MDTCablingConfigCfg(flags))
- acc.merge(MdtOverlayDigitToMdtRDOCfg(flags))
- return acc
diff --git a/MuonSpectrometer/MuonConfig/python/MdtOverlayConfig.py b/MuonSpectrometer/MuonConfig/python/MdtOverlayConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebffac04842d87e74d3d18595a2c22354772f45f
--- /dev/null
+++ b/MuonSpectrometer/MuonConfig/python/MdtOverlayConfig.py
@@ -0,0 +1,97 @@
+
+"""Define methods to construct configured MDT overlay algorithms
+
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+"""
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+
+def MDTDataOverlayExtraCfg(flags, **kwargs):
+ """Return a ComponentAccumulator with MDT data overlay specifics"""
+ acc = ComponentAccumulator()
+
+ # We need to convert BS to RDO for data overlay
+ from MuonConfig.MuonBytestreamDecodeConfig import MdtBytestreamDecodeCfg
+ acc.merge(MdtBytestreamDecodeCfg(flags))
+
+ return acc
+
+
+def MdtOverlayAlgCfg(flags, name="MdtOverlay", **kwargs):
+ """Return a ComponentAccumulator for MDTOverlay algorithm"""
+ acc = ComponentAccumulator()
+
+ kwargs.setdefault("BkgInputKey", flags.Overlay.BkgPrefix + "MDT_DIGITS")
+ kwargs.setdefault("SignalInputKey", flags.Overlay.SigPrefix + "MDT_DIGITS")
+ kwargs.setdefault("OutputKey", "MDT_DIGITS")
+
+ kwargs.setdefault("IntegrationWindow", 20) # in ns
+
+ # Do MDT overlay
+ MdtOverlay = CompFactory.MdtOverlay
+ alg = MdtOverlay(name, **kwargs)
+ acc.addEventAlgo(alg)
+
+ # Setup output
+ from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+ acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[
+ "MdtCsmContainer#MDTCSM"
+ ]))
+
+ return acc
+
+
+def MdtTruthOverlayCfg(flags, name="MdtTruthOverlay", **kwargs):
+ """Return a ComponentAccumulator for the MDT SDO overlay algorithm"""
+ acc = ComponentAccumulator()
+
+ # We do not need background MDT SDOs
+ if flags.Overlay.DataOverlay:
+ kwargs.setdefault("BkgInputKey", "")
+ else:
+ kwargs.setdefault("BkgInputKey",
+ flags.Overlay.BkgPrefix + "MDT_SDO")
+
+ kwargs.setdefault("SignalInputKey",
+ flags.Overlay.SigPrefix + "MDT_SDO")
+ kwargs.setdefault("OutputKey", "MDT_SDO")
+
+ # Do MDT truth overlay
+ MuonSimDataOverlay = CompFactory.MuonSimDataOverlay
+ alg = MuonSimDataOverlay(name, **kwargs)
+ acc.addEventAlgo(alg)
+
+ # Setup output
+ from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+ acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[
+ "MuonSimDataCollection#MDT_SDO"
+ ]))
+
+ return acc
+
+
+def MdtOverlayCfg(flags):
+ """Configure and return a ComponentAccumulator for MDT overlay"""
+ acc = ComponentAccumulator()
+
+ # Add data overlay specifics
+ if flags.Overlay.DataOverlay:
+ acc.merge(MDTDataOverlayExtraCfg(flags))
+
+ # Add MDT RDO to digit config
+ from MuonConfig.MuonByteStreamCnvTestConfig import MdtRdoToMdtDigitCfg
+ acc.merge(MdtRdoToMdtDigitCfg(flags))
+ # Add MDT overlay digitization algorithm
+ from MuonConfig.MDT_DigitizationConfig import MDT_OverlayDigitizationBasicCfg
+ acc.merge(MDT_OverlayDigitizationBasicCfg(flags))
+ # Add MDT overlay algorithm
+ acc.merge(MdtOverlayAlgCfg(flags))
+ # Add MDT truth overlay
+ acc.merge(MdtTruthOverlayCfg(flags))
+ # Add MDT digit to RDO config
+ from MuonConfig.MuonByteStreamCnvTestConfig import MdtDigitToMdtRDOCfg
+ acc.merge(MdtDigitToMdtRDOCfg(flags))
+
+ return acc
diff --git a/MuonSpectrometer/MuonConfig/python/MuonByteStreamCnvTestConfig.py b/MuonSpectrometer/MuonConfig/python/MuonByteStreamCnvTestConfig.py
index 43482003af004034edfc75c4e2c485fe6d786bf7..3607db8f187f454c559abfbd7ac97f4eef9a80db 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonByteStreamCnvTestConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonByteStreamCnvTestConfig.py
@@ -1,22 +1,22 @@
"""Define ComponentAccumulator functions for configuration of muon data conversions
-Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
"""
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
-from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import (
- MdtRdoToMdtDigit, RpcRdoToRpcDigit, TgcRdoToTgcDigit, STGC_RdoToDigit, MM_RdoToDigit,
- MdtDigitToMdtRDO, RpcDigitToRpcRDO, TgcDigitToTgcRDO, STGC_DigitToRDO, MM_DigitToRDO, CscDigitToCscRDO
-)
-CscDigitToCscRDOTool=CompFactory.CscDigitToCscRDOTool
-from MuonConfig.MuonCalibConfig import CscCalibToolCfg
+
def MdtRdoToMdtDigitCfg(flags, name="MdtRdoToMdtDigitAlg", **kwargs):
"""Return ComponentAccumulator with configured MdtRdoToMdtDigit algorithm"""
acc = ComponentAccumulator()
- if flags.Detector.Overlay:
+ from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
+ from MuonConfig.MuonCalibConfig import MdtCalibDbAlgCfg
+ acc.merge(MDTCablingConfigCfg(flags))
+ acc.merge(MdtCalibDbAlgCfg(flags))
+ if flags.Detector.OverlayMDT:
kwargs.setdefault("MdtRdoContainer", flags.Overlay.BkgPrefix + "MDTCSM")
kwargs.setdefault("MdtDigitContainer", flags.Overlay.BkgPrefix + "MDT_DIGITS")
+ MdtRdoToMdtDigit = CompFactory.MdtRdoToMdtDigit
acc.addEventAlgo(MdtRdoToMdtDigit(name, **kwargs))
return acc
@@ -24,9 +24,12 @@ def MdtRdoToMdtDigitCfg(flags, name="MdtRdoToMdtDigitAlg", **kwargs):
def RpcRdoToRpcDigitCfg(flags, name="RpcRdoToRpcDigitAlg", **kwargs):
"""Return ComponentAccumulator with configured RpcRdoToRpcDigit algorithm"""
acc = ComponentAccumulator()
- if flags.Detector.Overlay:
+ from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg
+ acc.merge(RPCCablingConfigCfg(flags))
+ if flags.Detector.OverlayRPC:
kwargs.setdefault("RpcRdoContainer", flags.Overlay.BkgPrefix + "RPCPAD")
kwargs.setdefault("RpcDigitContainer", flags.Overlay.BkgPrefix + "RPC_DIGITS")
+ RpcRdoToRpcDigit = CompFactory.RpcRdoToRpcDigit
acc.addEventAlgo(RpcRdoToRpcDigit(name, **kwargs))
return acc
@@ -34,9 +37,12 @@ def RpcRdoToRpcDigitCfg(flags, name="RpcRdoToRpcDigitAlg", **kwargs):
def TgcRdoToTgcDigitCfg(flags, name="TgcRdoToTgcDigitAlg", **kwargs):
"""Return ComponentAccumulator with configured TgcRdoToTgcDigit algorithm"""
acc = ComponentAccumulator()
- if flags.Detector.Overlay:
+ from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
+ acc.merge(TGCCablingConfigCfg(flags))
+ if flags.Detector.OverlayTGC:
kwargs.setdefault("TgcRdoContainer", flags.Overlay.BkgPrefix + "TGCRDO")
kwargs.setdefault("TgcDigitContainer", flags.Overlay.BkgPrefix + "TGC_DIGITS")
+ TgcRdoToTgcDigit = CompFactory.TgcRdoToTgcDigit
acc.addEventAlgo(TgcRdoToTgcDigit(name, **kwargs))
return acc
@@ -44,9 +50,10 @@ def TgcRdoToTgcDigitCfg(flags, name="TgcRdoToTgcDigitAlg", **kwargs):
def STGC_RdoToDigitCfg(flags, name="STGC_RdoToDigitAlg", **kwargs):
"""Return ComponentAccumulator with configured STGC_RdoToDigit algorithm"""
acc = ComponentAccumulator()
- if flags.Detector.Overlay:
+ if flags.Detector.OverlaysTGC:
kwargs.setdefault("sTgcRdoContainer", flags.Overlay.BkgPrefix + "sTGCRDO")
kwargs.setdefault("sTgcDigitContainer", flags.Overlay.BkgPrefix + "sTGC_DIGITS")
+ STGC_RdoToDigit = CompFactory.STGC_RdoToDigit
acc.addEventAlgo(STGC_RdoToDigit(name, **kwargs))
return acc
@@ -54,9 +61,10 @@ def STGC_RdoToDigitCfg(flags, name="STGC_RdoToDigitAlg", **kwargs):
def MM_RdoToDigitCfg(flags, name="MM_RdoToDigitAlg", **kwargs):
"""Return ComponentAccumulator with configured MM_RdoToDigit algorithm"""
acc = ComponentAccumulator()
- if flags.Detector.Overlay:
+ if flags.Detector.OverlayMM:
kwargs.setdefault("MmRdoContainer", flags.Overlay.BkgPrefix + "MMRDO")
kwargs.setdefault("MmDigitContainer", flags.Overlay.BkgPrefix + "MM_DIGITS")
+ MM_RdoToDigit = CompFactory.MM_RdoToDigit
acc.addEventAlgo(MM_RdoToDigit(name, **kwargs))
return acc
@@ -68,15 +76,7 @@ def MdtDigitToMdtRDOCfg(flags, name="MdtDigitToMdtRDO", **kwargs):
kwargs.setdefault("OutputObjectName", flags.Overlay.BkgPrefix + "MDTCSM")
else:
kwargs.setdefault("OutputObjectName", "MDTCSM")
- acc.addEventAlgo(MdtDigitToMdtRDO(name, **kwargs))
- return acc
-
-
-def MdtOverlayDigitToMdtRDOCfg(flags, name="MdtOverlayDigitToMdtRDO", **kwargs):
- """Return ComponentAccumulator with Overlay configured MdtDigitToMdtRDO algorithm"""
- acc = ComponentAccumulator()
- kwargs.setdefault("InputObjectName", flags.Overlay.SigPrefix + "MDT_DIGITS")
- kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "MDTCSM")
+ MdtDigitToMdtRDO = CompFactory.MdtDigitToMdtRDO
acc.addEventAlgo(MdtDigitToMdtRDO(name, **kwargs))
return acc
@@ -88,15 +88,7 @@ def RpcDigitToRpcRDOCfg(flags, name="RpcDigitToRpcRDO", **kwargs):
kwargs.setdefault("OutputObjectName", flags.Overlay.BkgPrefix + "RPCPAD")
else:
kwargs.setdefault("OutputObjectName", "RPCPAD")
- acc.addEventAlgo(RpcDigitToRpcRDO(name, **kwargs))
- return acc
-
-
-def RpcOverlayDigitToRpcRDOCfg(flags, name="RpcOverlayDigitToRpcRDO", **kwargs):
- """Return ComponentAccumulator with Overlay configured RpcDigitToRpcRDO algorithm"""
- acc = ComponentAccumulator()
- kwargs.setdefault("InputObjectName", flags.Overlay.SigPrefix + "RPC_DIGITS")
- kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "RPCPAD")
+ RpcDigitToRpcRDO = CompFactory.RpcDigitToRpcRDO
acc.addEventAlgo(RpcDigitToRpcRDO(name, **kwargs))
return acc
@@ -108,49 +100,38 @@ def TgcDigitToTgcRDOCfg(flags, name="TgcDigitToTgcRDO", **kwargs):
kwargs.setdefault("OutputObjectName", flags.Overlay.BkgPrefix + "TGCRDO")
else:
kwargs.setdefault("OutputObjectName", "TGCRDO")
+ TgcDigitToTgcRDO = CompFactory.TgcDigitToTgcRDO
acc.addEventAlgo(TgcDigitToTgcRDO(name, **kwargs))
return acc
-def TgcOverlayDigitToTgcRDOCfg(flags, name="TgcOverlayDigitToTgcRDO", **kwargs):
- """Return ComponentAccumulator with Overlay configured TgcDigitToTgcRDO algorithm"""
- acc = ComponentAccumulator()
- kwargs.setdefault("InputObjectName", flags.Overlay.SigPrefix + "TGC_DIGITS")
- kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "TGCRDO")
- acc.addEventAlgo(TgcDigitToTgcRDO(name, **kwargs))
- return acc
-
-
-def CscDigitToCscRDOCfg(flags, name="CscDigitToCscRDO", **kwargs):
+def CscDigitToCscRDOCfg(flags, name="CscDigitToCscRDO4", **kwargs):
"""Return ComponentAccumulator with configured CscDigitToCscRDO algorithm"""
# for Csc, configuration is in the tool CscDigitToCscRDOTool
# configure dependency
+ from MuonConfig.MuonCalibConfig import CscCalibToolCfg
acc = CscCalibToolCfg(flags)
CscCalibTool = acc.popPrivateTools()
# configure basic parameters
kwargs.setdefault("cscCalibTool", CscCalibTool)
kwargs.setdefault("NumSamples", 4)
kwargs.setdefault("Latency", 0)
- kwargs.setdefault("addNoise", True) # doMuonNoise flag not migrated
- if flags.Digitization.PileUpPremixing:
+ kwargs.setdefault("addNoise", not flags.Detector.OverlayCSC) # doMuonNoise flag not migrated
+ if flags.Detector.OverlayCSC:
+ kwargs.setdefault("InputObjectName", flags.Overlay.SigPrefix + "CSC_DIGITS")
+ kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "CSCRDO")
+ elif flags.Digitization.PileUpPremixing:
kwargs.setdefault("OutputObjectName", flags.Overlay.BkgPrefix + "CSCRDO")
else:
kwargs.setdefault("OutputObjectName", "CSCRDO")
# tool and container algorithm
- tool = CscDigitToCscRDOTool(name + "Tool", **kwargs)
+ CscDigitToCscRDOTool = CompFactory.CscDigitToCscRDOTool
+ tool = CscDigitToCscRDOTool("CscDigitToCscRDOTool4", **kwargs)
+ CscDigitToCscRDO = CompFactory.CscDigitToCscRDO
acc.addEventAlgo(CscDigitToCscRDO(name, CscDigitToRDOTool=tool))
return acc
-def CscOverlayDigitToCscRDOCfg(flags, name="CscOverlayDigitToCscRDO", **kwargs):
- """Return ComponentAccumulator with Overlay configured CscDigitToCscRDO algorithm"""
- kwargs.setdefault("NumSamples", 4)
- kwargs.setdefault("addNoise", False)
- kwargs.setdefault("InputObjectName", flags.Overlay.SigPrefix + "CSC_DIGITS")
- kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "CSCRDO")
- return CscDigitToCscRDOCfg(flags, name, **kwargs)
-
-
def STGC_DigitToRDOCfg(flags, name="STGC_DigitToRDO", **kwargs):
"""Return ComponentAccumulator with configured STGC_DigitToRDO algorithm"""
acc = ComponentAccumulator()
@@ -158,15 +139,7 @@ def STGC_DigitToRDOCfg(flags, name="STGC_DigitToRDO", **kwargs):
kwargs.setdefault("OutputObjectName", flags.Overlay.BkgPrefix + "sTGCRDO")
else:
kwargs.setdefault("OutputObjectName", "sTGCRDO")
- acc.addEventAlgo(STGC_DigitToRDO(name, **kwargs))
- return acc
-
-
-def STGC_OverlayDigitToRDOCfg(flags, name="STGC_OverlayDigitToRDO", **kwargs):
- """Return ComponentAccumulator with Overlay configured STGC_DigitToRDO algorithm"""
- acc = ComponentAccumulator()
- kwargs.setdefault("InputObjectName", flags.Overlay.SigPrefix + "sTGC_DIGITS")
- kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "STGCRDO")
+ STGC_DigitToRDO = CompFactory.STGC_DigitToRDO
acc.addEventAlgo(STGC_DigitToRDO(name, **kwargs))
return acc
@@ -178,15 +151,7 @@ def MM_DigitToRDOCfg(flags, name="MM_DigitToRDO", **kwargs):
kwargs.setdefault("OutputObjectName", flags.Overlay.BkgPrefix + "MMRDO")
else:
kwargs.setdefault("OutputObjectName", "MMRDO")
- acc.addEventAlgo(MM_DigitToRDO(name, **kwargs))
- return acc
-
-
-def MM_OverlayDigitToRDOCfg(flags, name="MM_OverlayDigitToRDO", **kwargs):
- """Return ComponentAccumulator with Overlay configured MM_DigitToRDO algorithm"""
- acc = ComponentAccumulator()
- kwargs.setdefault("InputObjectName", flags.Overlay.SigPrefix + "MM_DIGITS")
- kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "MMRDO")
+ MM_DigitToRDO = CompFactory.MM_DigitToRDO
acc.addEventAlgo(MM_DigitToRDO(name, **kwargs))
return acc
@@ -194,8 +159,9 @@ def MM_OverlayDigitToRDOCfg(flags, name="MM_OverlayDigitToRDO", **kwargs):
def SigMdtDigitToMdtRDOCfg(flags, name="SigMdtDigitToMdtRDO", **kwargs):
"""Return ComponentAccumulator with configured MdtDigitToMdtRDO algorithm"""
acc = ComponentAccumulator()
- kwargs.setdefault("InputObjectName", flags.Overlay.Legacy.EventStore + "+MDT_DIGITS")
- kwargs.setdefault("OutputObjectName", flags.Overlay.Legacy.EventStore + "+MDTCSM")
+ kwargs.setdefault("InputObjectName", flags.Overlay.SigPrefix + "MDT_DIGITS")
+ kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "MDTCSM")
+ MdtDigitToMdtRDO = CompFactory.MdtDigitToMdtRDO
acc.addEventAlgo(MdtDigitToMdtRDO(name, **kwargs))
return acc
@@ -203,8 +169,9 @@ def SigMdtDigitToMdtRDOCfg(flags, name="SigMdtDigitToMdtRDO", **kwargs):
def SigRpcDigitToRpcRDOCfg(flags, name="SigRpcDigitToRpcRDO", **kwargs):
"""Return ComponentAccumulator with configured RpcDigitToRpcRDO algorithm"""
acc = ComponentAccumulator()
- kwargs.setdefault("InputObjectName", flags.Overlay.Legacy.EventStore + "+RPC_DIGITS")
- kwargs.setdefault("OutputObjectName", flags.Overlay.Legacy.EventStore + "+RPCPAD")
+ kwargs.setdefault("InputObjectName", flags.Overlay.SigPrefix + "RPC_DIGITS")
+ kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "RPCPAD")
+ RpcDigitToRpcRDO = CompFactory.RpcDigitToRpcRDO
acc.addEventAlgo(RpcDigitToRpcRDO(name, **kwargs))
return acc
@@ -212,8 +179,9 @@ def SigRpcDigitToRpcRDOCfg(flags, name="SigRpcDigitToRpcRDO", **kwargs):
def SigTgcDigitToTgcRDOCfg(flags, name="SigTgcDigitToTgcRDO", **kwargs):
"""Return ComponentAccumulator with configured TgcDigitToTgcRDO algorithm"""
acc = ComponentAccumulator()
- kwargs.setdefault("InputObjectName", flags.Overlay.Legacy.EventStore + "+TGC_DIGITS")
- kwargs.setdefault("OutputObjectName", flags.Overlay.Legacy.EventStore + "+TGCRDO")
+ kwargs.setdefault("InputObjectName", flags.Overlay.SigPrefix + "TGC_DIGITS")
+ kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "TGCRDO")
+ TgcDigitToTgcRDO = CompFactory.TgcDigitToTgcRDO
acc.addEventAlgo(TgcDigitToTgcRDO(name, **kwargs))
return acc
diff --git a/MuonSpectrometer/MuonConfig/python/MuonBytestreamDecodeConfig.py b/MuonSpectrometer/MuonConfig/python/MuonBytestreamDecodeConfig.py
index ae447293546755d151adba7ad8e4fa3281c0e9fe..b61d1ecc61c4a4717679d2319079eb784a3747b3 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonBytestreamDecodeConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonBytestreamDecodeConfig.py
@@ -52,9 +52,11 @@ def RpcBytestreamDecodeCfg(flags, forTrigger=False):
acc.addService( robDPSvc )
# Setup the RAW data provider tool
+ keyName = flags.Overlay.BkgPrefix + "RPCPAD" if flags.Detector.OverlayRPC else "RPCPAD"
Muon__RPC_RawDataProviderToolMT=CompFactory.Muon__RPC_RawDataProviderToolMT
MuonRpcRawDataProviderTool = Muon__RPC_RawDataProviderToolMT(name = "RPC_RawDataProviderToolMT",
- Decoder = RPCRodDecoder )
+ Decoder = RPCRodDecoder,
+ RdoLocation = keyName )
if forTrigger:
MuonRpcRawDataProviderTool.RpcContainerCacheKey = MuonCacheNames.RpcCache
MuonRpcRawDataProviderTool.WriteOutRpcSectorLogic = False
@@ -95,9 +97,11 @@ def TgcBytestreamDecodeCfg(flags, forTrigger=False):
acc.addService( robDPSvc )
# Setup the RAW data provider tool
+ keyName = flags.Overlay.BkgPrefix + "TGCRDO" if flags.Detector.OverlayTGC else "TGCRDO"
Muon__TGC_RawDataProviderToolMT=CompFactory.Muon__TGC_RawDataProviderToolMT
MuonTgcRawDataProviderTool = Muon__TGC_RawDataProviderToolMT(name = "TGC_RawDataProviderToolMT",
- Decoder = TGCRodDecoder )
+ Decoder = TGCRodDecoder,
+ RdoLocation = keyName )
if forTrigger:
MuonTgcRawDataProviderTool.TgcContainerCacheKey = MuonCacheNames.TgcCache
@@ -138,9 +142,11 @@ def MdtBytestreamDecodeCfg(flags, forTrigger=False):
acc.addService( robDPSvc )
# Setup the RAW data provider tool
+ keyName = flags.Overlay.BkgPrefix + "MDTCSM" if flags.Detector.OverlayMDT else "MDTCSM"
Muon__MDT_RawDataProviderToolMT=CompFactory.Muon__MDT_RawDataProviderToolMT
MuonMdtRawDataProviderTool = Muon__MDT_RawDataProviderToolMT(name = "MDT_RawDataProviderToolMT",
- Decoder = MDTRodDecoder)
+ Decoder = MDTRodDecoder,
+ RdoLocation = keyName)
if forTrigger:
MuonMdtRawDataProviderTool.CsmContainerCacheKey = MuonCacheNames.MdtCsmCache
@@ -177,9 +183,11 @@ def CscBytestreamDecodeCfg(flags, forTrigger=False):
acc.addService( robDPSvc )
# Setup the RAW data provider tool
+ keyName = flags.Overlay.BkgPrefix + "CSCRDO" if flags.Detector.OverlayCSC else "CSCRDO"
Muon__CSC_RawDataProviderToolMT=CompFactory.Muon__CSC_RawDataProviderToolMT
MuonCscRawDataProviderTool = Muon__CSC_RawDataProviderToolMT(name = "CSC_RawDataProviderToolMT",
- Decoder = CSCRodDecoder)
+ Decoder = CSCRodDecoder,
+ RdoLocation = keyName)
if forTrigger:
MuonCscRawDataProviderTool.CscContainerCacheKey = MuonCacheNames.CscCache
diff --git a/MuonSpectrometer/MuonConfig/python/MuonCSC_CnvToolsConfig.py b/MuonSpectrometer/MuonConfig/python/MuonCSC_CnvToolsConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..147f852dc56f8c87c7f0d198059aeafd06b73c22
--- /dev/null
+++ b/MuonSpectrometer/MuonConfig/python/MuonCSC_CnvToolsConfig.py
@@ -0,0 +1,13 @@
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+
+def MuonCscRDODecoderCfg(flags, **kwargs):
+ from MuonConfig.MuonCalibConfig import CscCalibToolCfg
+ acc = CscCalibToolCfg(flags)
+ kwargs.setdefault("cscCalibTool", acc.popPrivateTools())
+
+ CscRDO_Decoder = CompFactory.Muon__CscRDO_Decoder
+ acc.setPrivateTools(CscRDO_Decoder(**kwargs))
+ return acc
diff --git a/MuonSpectrometer/MuonConfig/python/MuonCablingConfig.py b/MuonSpectrometer/MuonConfig/python/MuonCablingConfig.py
index ee3ecd36349af50b87daf99f3a344713f91c0fc4..8a76674e39fdbaa7f26813ffe49e03affce36aaf 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonCablingConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonCablingConfig.py
@@ -31,7 +31,7 @@ def RPCCablingConfigCfg(flags):
rpcCablingSvc.CorrFileName = 'LVL1confAtlas.corr'
rpcCablingSvc.ConfFilePath = 'MuonRPC_Cabling/'
rpcCablingSvc.RPCTriggerRoadsfromCool = True
- rpcCablingSvc.CosmicConfiguration = True # this was set to true by the modifier openThresholdRPCCabling in runHLT_standalone.py
+ rpcCablingSvc.CosmicConfiguration = 'HLT' in flags.IOVDb.GlobalTag # this was set to true by the modifier openThresholdRPCCabling in runHLT_standalone.py
from IOVDbSvc.IOVDbSvcConfig import addFolders
dbName = 'RPC_OFL' if flags.Input.isMC else 'RPC'
diff --git a/MuonSpectrometer/MuonConfig/python/MuonCalibConfig.py b/MuonSpectrometer/MuonConfig/python/MuonCalibConfig.py
index 76498e383568d2f4477f92c15f3c2a4f3f133523..4bd925e36864cc07e5d9b36c3cda7e25ee8d1dc2 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonCalibConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonCalibConfig.py
@@ -68,7 +68,6 @@ def _setupMdtCondDB(flags):
# end of function setupMdtCondDB()
def MdtCalibrationToolCfg(flags, **kwargs):
- from MdtCalibSvc.MdtCalibSvcConf import MdtCalibrationTool
result=MdtCalibrationDbToolCfg(flags, **kwargs)
mdt_calibibration_db_tool = result.getPrimary()
@@ -83,12 +82,12 @@ def MdtCalibrationToolCfg(flags, **kwargs):
result.merge(acc)
kwargs.setdefault("MagFieldSvc", mag_field_svc )
+ MdtCalibrationTool = CompFactory.MdtCalibrationTool
mdt_calibration_tool = MdtCalibrationTool(**kwargs)
result.setPrivateTools(mdt_calibration_tool)
return result
def MdtCalibrationDbToolCfg(flags, **kwargs):
- from MdtCalibSvc.MdtCalibSvcConf import MdtCalibrationDbTool
# We need the conditions objects to have been created.
result = MdtCalibDbAlgCfg(flags, **kwargs)
@@ -96,6 +95,7 @@ def MdtCalibrationDbToolCfg(flags, **kwargs):
kwargs.setdefault("CreateWireSagFunctions", flags.Muon.Calib.correctMdtRtWireSag)
kwargs.setdefault("CreateSlewingFunctions", flags.Muon.Calib.correctMdtRtForTimeSlewing)
+ MdtCalibrationDbTool = CompFactory.MdtCalibrationDbTool
mdt_calibration_db_tool = MdtCalibrationDbTool(**kwargs)
result.setPrivateTools(mdt_calibration_db_tool)
return result
diff --git a/MuonSpectrometer/MuonConfig/python/MuonConfigFlags.py b/MuonSpectrometer/MuonConfig/python/MuonConfigFlags.py
index 9713600b03fe03e35f97d567caea63804e36b733..479b78149b6e73b0129c0205a806ba33ced4b3f9 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonConfigFlags.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonConfigFlags.py
@@ -92,7 +92,7 @@ def createMuonConfigFlags():
mcf.addFlag("Muon.Calib.applyRtScaling", False) # TODO - apparently not needed, but currently used in MuonCalibConfig. Set false to match https://acode-browser1.usatlas.bnl.gov/lxr/source/athena/MuonSpectrometer/MuonCnv/MuonCnvExample/python/MuonCalibFlags.py#0072
mcf.addFlag("Muon.Calib.correctMdtRtWireSag", False) # Apply RT wiresag correction
mcf.addFlag("Muon.Calib.mdtCalibrationSource", "MDT") # Source for MDT t0s and rts
- mcf.addFlag("Muon.Calib.mdtPropagationSpeedBeta", 0.85) #
+ mcf.addFlag("Muon.Calib.mdtPropagationSpeedBeta", lambda prevFlags : 1.0 if prevFlags.Input.isMC else 0.85) #
mcf.addFlag("Muon.Calib.CscPedFromLocalFile", False)
mcf.addFlag("Muon.Calib.CscNoiseFromLocalFile", False)
diff --git a/MuonSpectrometer/MuonConfig/python/MuonConfigUtils.py b/MuonSpectrometer/MuonConfig/python/MuonConfigUtils.py
index f843eff1428157842b25f47c151f4d498a15a1ff..0581a31abf81101f0ccefc29e069a77610bd11fc 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonConfigUtils.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonConfigUtils.py
@@ -2,6 +2,7 @@
# This file is just for shared functions etc used by this package.
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
def SetupMuonStandaloneArguments():
from argparse import ArgumentParser
@@ -71,7 +72,7 @@ def SetupMuonStandaloneOutput(cfg, ConfigFlags, itemsToRecord):
outstream.ForceRead = True
# Fix for ATLASRECTS-5151
- from TrkEventCnvTools.TrkEventCnvToolsConf import Trk__EventCnvSuperTool
+ Trk__EventCnvSuperTool = CompFactory.Trk__EventCnvSuperTool
cnvTool = Trk__EventCnvSuperTool(name = 'EventCnvSuperTool')
cnvTool.MuonCnvTool.FixTGCs = True
- cfg.addPublicTool(cnvTool)
\ No newline at end of file
+ cfg.addPublicTool(cnvTool)
diff --git a/MuonSpectrometer/MuonConfig/python/MuonGeometryConfig.py b/MuonSpectrometer/MuonConfig/python/MuonGeometryConfig.py
index b733d3873960acc599ee9bf5ad2d1d13034c1bce..d6fac1734e4ab26771ba9cb9c8633b231f65bfb3 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonGeometryConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonGeometryConfig.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
@@ -24,7 +24,9 @@ def MuonGeoModelCfg(flags):
detTool.UseConditionDb = 1
detTool.UseIlinesFromGM = 1
detTool.BuildFromNova = 0
- if ( ( not flags.Detector.SimulateMuon or flags.Detector.OverlayMuon ) and flags.Common.Project != "AthSimulation" ):
+
+ enableAlignment = flags.Common.Project != 'AthSimulation' and not flags.Detector.SimulateMuon and not flags.Detector.OverlayMuon
+ if enableAlignment:
# This is all migrated from MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonAlignConfig.py
from IOVDbSvc.IOVDbSvcConfig import addFolders
@@ -121,10 +123,11 @@ def MuonGeoModelCfg(flags):
# turn on/off caching of MdtReadoutElement surfaces
detTool.CachingFlag = 1
- from MuonGeoModel.MuonGeoModelConf import MuonDetectorCondAlg
- MuonDetectorManagerCond = MuonDetectorCondAlg()
- MuonDetectorManagerCond.MuonDetectorTool = detTool
- acc.addCondAlgo(MuonDetectorManagerCond)
+ if enableAlignment:
+ MuonDetectorCondAlg = CompFactory.MuonDetectorCondAlg
+ MuonDetectorManagerCond = MuonDetectorCondAlg()
+ MuonDetectorManagerCond.MuonDetectorTool = detTool
+ acc.addCondAlgo(MuonDetectorManagerCond)
gms.DetectorTools += [ detTool ]
diff --git a/MuonSpectrometer/MuonConfig/python/MuonReconstructionConfig.py b/MuonSpectrometer/MuonConfig/python/MuonReconstructionConfig.py
index ab194938790bd6dea312322f289bb57080b8d9c4..913a945491846edee5fb03e82ce7883ec55bc17b 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonReconstructionConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonReconstructionConfig.py
@@ -33,15 +33,16 @@ if __name__=="__main__":
from AthenaCommon.Logging import log
log.info('Forcing track building cardinality to be equal to '+str(args.threads))
# We want to force the algorithms to run in parallel (eventually the algorithm will be marked as cloneable in the source code)
- from GaudiHive.GaudiHiveConf import AlgResourcePool
+ AlgResourcePool = CompFactory.AlgResourcePool
cfg.addService(AlgResourcePool( OverrideUnClonable=True ) )
track_builder = acc.getPrimary()
track_builder.Cardinality=args.threads
# This is a temporary fix - it should go someplace central as it replaces the functionality of addInputRename from here:
# https://gitlab.cern.ch/atlas/athena/blob/master/Control/SGComps/python/AddressRemappingSvc.py
- from SGComps.SGCompsConf import AddressRemappingSvc, ProxyProviderSvc
+ ProxyProviderSvc = CompFactory.ProxyProviderSvc
pps = ProxyProviderSvc()
+ AddressRemappingSvc = CompFactory.AddressRemappingSvc
ars=AddressRemappingSvc()
pps.ProviderNames += [ 'AddressRemappingSvc' ]
ars.TypeKeyRenameMaps += [ '%s#%s->%s' % ("TrackCollection", "MuonSpectrometerTracks", "MuonSpectrometerTracks_old") ]
diff --git a/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py b/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
index a81b16422c1377a0aec869dd9059e94911053b98..6001317af28aec61d0c95075f5cfd97d381bebba 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
@@ -29,7 +29,7 @@ from MuonConfig.MuonCalibConfig import MdtCalibDbAlgCfg
from MuonConfig.MuonRecToolsConfig import MCTBFitterCfg, MuonAmbiProcessorCfg, MuonStationIntersectSvcCfg, MuonTrackCleanerCfg
def MuonHoughPatternFinderTool(flags, **kwargs):
- # Taken from https://gitlab.cern.ch/atlas/athena/blob/master/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecTools.py#L173 from MuonHoughPatternTools/MuonHoughPatternToolsConf import Muon__MuonHoughPatternFinderTool
+ # Taken from https://gitlab.cern.ch/atlas/athena/blob/master/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecTools.py#L173
Muon__MuonHoughPatternFinderTool=CompFactory.Muon__MuonHoughPatternFinderTool
diff --git a/MuonSpectrometer/MuonConfig/python/RPC_DigitizationConfig.py b/MuonSpectrometer/MuonConfig/python/RPC_DigitizationConfig.py
index bec08779483e07422b70a1998d7687dda492655a..e941cfcf3b7f13b054104d153c872927a7f3ac0e 100644
--- a/MuonSpectrometer/MuonConfig/python/RPC_DigitizationConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/RPC_DigitizationConfig.py
@@ -1,14 +1,12 @@
"""Define methods to construct configured RPC Digitization tools and algorithms
-Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
"""
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
-RpcDigitizationTool, RPC_Digitizer=CompFactory.getComps("RpcDigitizationTool","RPC_Digitizer",)
-PileUpXingFolder=CompFactory.PileUpXingFolder
-from MuonConfig.MuonByteStreamCnvTestConfig import RpcDigitToRpcRDOCfg, RpcOverlayDigitToRpcRDOCfg
+from MuonConfig.MuonByteStreamCnvTestConfig import RpcDigitToRpcRDOCfg
from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg
from Digitization.TruthDigitizationOutputConfig import TruthDigitizationOutputCfg
from Digitization.PileUpToolsConfig import PileUpToolsCfg
@@ -30,10 +28,11 @@ def RPC_RangeToolCfg(flags, name="RPC_Range", **kwargs):
kwargs.setdefault("LastXing", RPC_LastXing())
kwargs.setdefault("CacheRefreshFrequency", 1.0)
kwargs.setdefault("ItemList", ["RPCSimHitCollection#RPC_Hits"])
+ PileUpXingFolder = CompFactory.PileUpXingFolder
return PileUpXingFolder(name, **kwargs)
-def RPC_DigitizationToolCfg(flags, name="RPC_DigitizationTool", **kwargs):
+def RPC_DigitizationToolCommonCfg(flags, name="RPC_DigitizationTool", **kwargs):
"""Return ComponentAccumulator with configured RpcDigitizationTool"""
from MuonConfig.MuonCondAlgConfig import RpcCondDbAlgCfg # MT-safe conditions access
acc = RpcCondDbAlgCfg(flags)
@@ -78,19 +77,27 @@ def RPC_DigitizationToolCfg(flags, name="RPC_DigitizationTool", **kwargs):
kwargs.setdefault("FracClusterSize2_C", [0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986, 0.259986])
kwargs.setdefault("FracClusterSizeTail_C",[0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035, 0.13035 ])
kwargs.setdefault("MeanClusterSizeTail_C",[0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598, 0.548598])
+ RpcDigitizationTool = CompFactory.RpcDigitizationTool
acc.setPrivateTools(RpcDigitizationTool(name, **kwargs))
return acc
-def RPC_OverlayDigitizationToolCfg(flags, name="RPC_DigitizationTool", **kwargs):
+def RPC_DigitizationToolCfg(flags, name="RPC_DigitizationTool", **kwargs):
+ """Return ComponentAccumulator with configured RpcDigitizationTool"""
+ kwargs.setdefault("OutputObjectName", "RPC_DIGITS")
+ if flags.Digitization.PileUpPremixing:
+ kwargs.setdefault("OutputSDOName", flags.Overlay.BkgPrefix + "RPC_SDO")
+ else:
+ kwargs.setdefault("OutputSDOName", "RPC_SDO")
+ return RPC_DigitizationToolCommonCfg(flags, name, **kwargs)
+
+
+def RPC_OverlayDigitizationToolCfg(flags, name="Rpc_OverlayDigitizationTool", **kwargs):
"""Return ComponentAccumulator with RpcDigitizationTool configured for Overlay"""
- acc = ComponentAccumulator()
kwargs.setdefault("OnlyUseContainerName", False)
- kwargs.setdefault("OutputObjectName", "StoreGateSvc+" + flags.Overlay.SigPrefix + "RPC_DIGITS")
- if not flags.Overlay.DataOverlay:
- kwargs.setdefault("OutputSDOName", "StoreGateSvc+" + flags.Overlay.SigPrefix + "RPC_SDO")
- acc.setPrivateTools(RpcDigitizationTool(name, **kwargs))
- return acc
+ kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "RPC_DIGITS")
+ kwargs.setdefault("OutputSDOName", flags.Overlay.SigPrefix + "RPC_SDO")
+ return RPC_DigitizationToolCommonCfg(flags, name, **kwargs)
def RPC_OutputCfg(flags):
@@ -120,7 +127,12 @@ def RPC_OverlayDigitizationBasicCfg(flags, **kwargs):
if "DigitizationTool" not in kwargs:
tool = acc.popToolsAndMerge(RPC_OverlayDigitizationToolCfg(flags))
kwargs["DigitizationTool"] = tool
- acc.addEventAlgo(RPC_Digitizer(**kwargs))
+
+ if flags.Concurrency.NumThreads > 0:
+ kwargs.setdefault("Cardinality", flags.Concurrency.NumThreads)
+
+ RPC_Digitizer = CompFactory.RPC_Digitizer
+ acc.addEventAlgo(RPC_Digitizer(name="RPC_OverlayDigitizer", **kwargs))
return acc
@@ -132,25 +144,9 @@ def RPC_DigitizationCfg(flags, **kwargs):
return acc
-def RPC_OverlayDigitizationCfg(flags, **kwargs):
- """Return ComponentAccumulator with RPC Overlay digitization and Output"""
- acc = RPC_OverlayDigitizationBasicCfg(flags, **kwargs)
- acc.merge(RPC_OutputCfg(flags))
- return acc
-
-
def RPC_DigitizationDigitToRDOCfg(flags):
"""Return ComponentAccumulator with RPC digitization and Digit to RPCPAD RDO"""
acc = RPC_DigitizationCfg(flags)
acc.merge(RPCCablingConfigCfg(flags))
acc.merge(RpcDigitToRpcRDOCfg(flags))
return acc
-
-
-def RPC_OverlayDigitizationDigitToRDOCfg(flags):
- """Return ComponentAccumulator with RPC Overlay digitization and Digit to RPCPAD RDO"""
- acc = RPC_OverlayDigitizationCfg(flags)
- acc.merge(RPCCablingConfigCfg(flags))
- acc.merge(RpcOverlayDigitToRpcRDOCfg(flags))
- return acc
-
diff --git a/MuonSpectrometer/MuonConfig/python/RpcOverlayConfig.py b/MuonSpectrometer/MuonConfig/python/RpcOverlayConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccedcadf798250cd70b794c6db9e5dfafea70a4e
--- /dev/null
+++ b/MuonSpectrometer/MuonConfig/python/RpcOverlayConfig.py
@@ -0,0 +1,95 @@
+
+"""Define methods to construct configured RPC overlay algorithms
+
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+"""
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+
+def RPCDataOverlayExtraCfg(flags, **kwargs):
+ """Return a ComponentAccumulator with RPC data overlay specifics"""
+ acc = ComponentAccumulator()
+
+ # We need to convert BS to RDO for data overlay
+ from MuonConfig.MuonBytestreamDecodeConfig import RpcBytestreamDecodeCfg
+ acc.merge(RpcBytestreamDecodeCfg(flags))
+
+ return acc
+
+
+def RpcOverlayAlgCfg(flags, name="RpcOverlay", **kwargs):
+ """Return a ComponentAccumulator for RPCOverlay algorithm"""
+ acc = ComponentAccumulator()
+
+ kwargs.setdefault("BkgInputKey", flags.Overlay.BkgPrefix + "RPC_DIGITS")
+ kwargs.setdefault("SignalInputKey", flags.Overlay.SigPrefix + "RPC_DIGITS")
+ kwargs.setdefault("OutputKey", "RPC_DIGITS")
+
+ # Do RPC overlay
+ RpcOverlay = CompFactory.RpcOverlay
+ alg = RpcOverlay(name, **kwargs)
+ acc.addEventAlgo(alg)
+
+ # Setup output
+ from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+ acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[
+ "RpcPadContainer#RPCPAD"
+ ]))
+
+ return acc
+
+
+def RpcTruthOverlayCfg(flags, name="RpcTruthOverlay", **kwargs):
+ """Return a ComponentAccumulator for the RPC SDO overlay algorithm"""
+ acc = ComponentAccumulator()
+
+ # We do not need background RPC SDOs
+ if flags.Overlay.DataOverlay:
+ kwargs.setdefault("BkgInputKey", "")
+ else:
+ kwargs.setdefault("BkgInputKey",
+ flags.Overlay.BkgPrefix + "RPC_SDO")
+
+ kwargs.setdefault("SignalInputKey",
+ flags.Overlay.SigPrefix + "RPC_SDO")
+ kwargs.setdefault("OutputKey", "RPC_SDO")
+
+ # Do RPC truth overlay
+ MuonSimDataOverlay = CompFactory.MuonSimDataOverlay
+ alg = MuonSimDataOverlay(name, **kwargs)
+ acc.addEventAlgo(alg)
+
+ # Setup output
+ from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+ acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[
+ "MuonSimDataCollection#RPC_SDO"
+ ]))
+
+ return acc
+
+
+def RpcOverlayCfg(flags):
+ """Configure and return a ComponentAccumulator for RPC overlay"""
+ acc = ComponentAccumulator()
+
+ # Add data overlay specifics
+ if flags.Overlay.DataOverlay:
+ acc.merge(RPCDataOverlayExtraCfg(flags))
+
+ # Add RPC RDO to digit config
+ from MuonConfig.MuonByteStreamCnvTestConfig import RpcRdoToRpcDigitCfg
+ acc.merge(RpcRdoToRpcDigitCfg(flags))
+ # Add RPC overlay digitization algorithm
+ from MuonConfig.RPC_DigitizationConfig import RPC_OverlayDigitizationBasicCfg
+ acc.merge(RPC_OverlayDigitizationBasicCfg(flags))
+ # Add RPC overlay algorithm
+ acc.merge(RpcOverlayAlgCfg(flags))
+ # Add RPC truth overlay
+ acc.merge(RpcTruthOverlayCfg(flags))
+ # Add RPC digit to RDO config
+ from MuonConfig.MuonByteStreamCnvTestConfig import RpcDigitToRpcRDOCfg
+ acc.merge(RpcDigitToRpcRDOCfg(flags))
+
+ return acc
diff --git a/MuonSpectrometer/MuonConfig/python/TGC_DigitizationConfig.py b/MuonSpectrometer/MuonConfig/python/TGC_DigitizationConfig.py
index 0eb8779e6236ed0f7a89dedc20b7fa274e340f6c..dcf3178a509db12840083734e3ce0079930f7fb6 100644
--- a/MuonSpectrometer/MuonConfig/python/TGC_DigitizationConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/TGC_DigitizationConfig.py
@@ -1,14 +1,12 @@
"""Define methods to construct configured TGC Digitization tools and algorithms
-Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
"""
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
-TgcDigitizationTool, TGCDigitizer=CompFactory.getComps("TgcDigitizationTool","TGCDigitizer",)
-PileUpXingFolder=CompFactory.PileUpXingFolder
-from MuonConfig.MuonByteStreamCnvTestConfig import TgcDigitToTgcRDOCfg, TgcOverlayDigitToTgcRDOCfg
+from MuonConfig.MuonByteStreamCnvTestConfig import TgcDigitToTgcRDOCfg
from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
from Digitization.TruthDigitizationOutputConfig import TruthDigitizationOutputCfg
from Digitization.PileUpToolsConfig import PileUpToolsCfg
@@ -30,6 +28,7 @@ def TGC_RangeToolCfg(flags, name="TGC_Range", **kwargs):
kwargs.setdefault("LastXing", TGC_LastXing())
kwargs.setdefault("CacheRefreshFrequency", 1.0)
kwargs.setdefault("ItemList", ["TGCSimHitCollection#TGC_Hits"])
+ PileUpXingFolder = CompFactory.PileUpXingFolder
return PileUpXingFolder(name, **kwargs)
@@ -44,17 +43,18 @@ def TGC_DigitizationToolCfg(flags, name="TGC_DigitizationTool", **kwargs):
kwargs.setdefault("OutputSDOName", flags.Overlay.BkgPrefix + "TGC_SDO")
else:
kwargs.setdefault("OutputSDOName", "TGC_SDO")
+ TgcDigitizationTool = CompFactory.TgcDigitizationTool
acc.setPrivateTools(TgcDigitizationTool(name, **kwargs))
return acc
-def TGC_OverlayDigitizationToolCfg(flags, name="TGC_OverlayDigitizationTool", **kwargs):
+def TGC_OverlayDigitizationToolCfg(flags, name="Tgc_OverlayDigitizationTool", **kwargs):
"""Return ComponentAccumulator with TgcDigitizationTool configured for Overlay"""
acc = ComponentAccumulator()
kwargs.setdefault("OnlyUseContainerName", False)
- kwargs.setdefault("OutputObjectName", "StoreGateSvc+" + flags.Overlay.SigPrefix + "TGC_DIGITS")
- if not flags.Overlay.DataOverlay:
- kwargs.setdefault("OutputSDOName", "StoreGateSvc+" + flags.Overlay.SigPrefix + "TGC_SDO")
+ kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "TGC_DIGITS")
+ kwargs.setdefault("OutputSDOName", flags.Overlay.SigPrefix + "TGC_SDO")
+ TgcDigitizationTool = CompFactory.TgcDigitizationTool
acc.setPrivateTools(TgcDigitizationTool(name, **kwargs))
return acc
@@ -86,7 +86,12 @@ def TGC_OverlayDigitizationBasicCfg(flags, **kwargs):
if "DigitizationTool" not in kwargs:
tool = acc.popToolsAndMerge(TGC_OverlayDigitizationToolCfg(flags))
kwargs["DigitizationTool"] = tool
- acc.addEventAlgo(TGCDigitizer(**kwargs))
+
+ if flags.Concurrency.NumThreads > 0:
+ kwargs.setdefault("Cardinality", flags.Concurrency.NumThreads)
+
+ TGCDigitizer = CompFactory.TGCDigitizer
+ acc.addEventAlgo(TGCDigitizer(name="TGC_OverlayDigitizer", **kwargs))
return acc
@@ -98,25 +103,9 @@ def TGC_DigitizationCfg(flags, **kwargs):
return acc
-def TGC_OverlayDigitizationCfg(flags, **kwargs):
- """Return ComponentAccumulator with TGC Overlay digitization and Output"""
- acc = TGC_OverlayDigitizationBasicCfg(flags, **kwargs)
- acc.merge(TGC_OutputCfg(flags))
- return acc
-
-
def TGC_DigitizationDigitToRDOCfg(flags):
"""Return ComponentAccumulator with TGC digitization and Digit to TGCRDO"""
acc = TGC_DigitizationCfg(flags)
acc.merge(TGCCablingConfigCfg(flags))
acc.merge(TgcDigitToTgcRDOCfg(flags))
return acc
-
-
-def TGC_OverlayDigitizationDigitToRDOCfg(flags):
- """Return ComponentAccumulator with TGC Overlay digitization and Digit to TGCRDO"""
- acc = TGC_OverlayDigitizationCfg(flags)
- acc.merge(TGCCablingConfigCfg(flags))
- acc.merge(TgcOverlayDigitToTgcRDOCfg(flags))
- return acc
-
diff --git a/MuonSpectrometer/MuonConfig/python/TgcOverlayConfig.py b/MuonSpectrometer/MuonConfig/python/TgcOverlayConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..dfceb435bf37292cabbcd7e18330cb490de383ab
--- /dev/null
+++ b/MuonSpectrometer/MuonConfig/python/TgcOverlayConfig.py
@@ -0,0 +1,95 @@
+
+"""Define methods to construct configured TGC overlay algorithms
+
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+"""
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+
+def TGCDataOverlayExtraCfg(flags, **kwargs):
+ """Return a ComponentAccumulator with TGC data overlay specifics"""
+ acc = ComponentAccumulator()
+
+ # We need to convert BS to RDO for data overlay
+ from MuonConfig.MuonBytestreamDecodeConfig import TgcBytestreamDecodeCfg
+ acc.merge(TgcBytestreamDecodeCfg(flags))
+
+ return acc
+
+
+def TgcOverlayAlgCfg(flags, name="TgcOverlay", **kwargs):
+ """Return a ComponentAccumulator for TGCOverlay algorithm"""
+ acc = ComponentAccumulator()
+
+ kwargs.setdefault("BkgInputKey", flags.Overlay.BkgPrefix + "TGC_DIGITS")
+ kwargs.setdefault("SignalInputKey", flags.Overlay.SigPrefix + "TGC_DIGITS")
+ kwargs.setdefault("OutputKey", "TGC_DIGITS")
+
+ # Do TGC overlay
+ TgcOverlay = CompFactory.TgcOverlay
+ alg = TgcOverlay(name, **kwargs)
+ acc.addEventAlgo(alg)
+
+ # Setup output
+ from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+ acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[
+ "TgcRdoContainer#TGCRDO"
+ ]))
+
+ return acc
+
+
+def TgcTruthOverlayCfg(flags, name="TgcTruthOverlay", **kwargs):
+ """Return a ComponentAccumulator for the TGC SDO overlay algorithm"""
+ acc = ComponentAccumulator()
+
+ # We do not need background TGC SDOs
+ if flags.Overlay.DataOverlay:
+ kwargs.setdefault("BkgInputKey", "")
+ else:
+ kwargs.setdefault("BkgInputKey",
+ flags.Overlay.BkgPrefix + "TGC_SDO")
+
+ kwargs.setdefault("SignalInputKey",
+ flags.Overlay.SigPrefix + "TGC_SDO")
+ kwargs.setdefault("OutputKey", "TGC_SDO")
+
+ # Do TGC truth overlay
+ MuonSimDataOverlay = CompFactory.MuonSimDataOverlay
+ alg = MuonSimDataOverlay(name, **kwargs)
+ acc.addEventAlgo(alg)
+
+ # Setup output
+ from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+ acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[
+ "MuonSimDataCollection#TGC_SDO"
+ ]))
+
+ return acc
+
+
+def TgcOverlayCfg(flags):
+ """Configure and return a ComponentAccumulator for TGC overlay"""
+ acc = ComponentAccumulator()
+
+ # Add data overlay specifics
+ if flags.Overlay.DataOverlay:
+ acc.merge(TGCDataOverlayExtraCfg(flags))
+
+ # Add TGC RDO to digit config
+ from MuonConfig.MuonByteStreamCnvTestConfig import TgcRdoToTgcDigitCfg
+ acc.merge(TgcRdoToTgcDigitCfg(flags))
+ # Add TGC overlay digitization algorithm
+ from MuonConfig.TGC_DigitizationConfig import TGC_OverlayDigitizationBasicCfg
+ acc.merge(TGC_OverlayDigitizationBasicCfg(flags))
+ # Add TGC overlay algorithm
+ acc.merge(TgcOverlayAlgCfg(flags))
+ # Add TGC truth overlay
+ acc.merge(TgcTruthOverlayCfg(flags))
+ # Add TGC digit to RDO config
+ from MuonConfig.MuonByteStreamCnvTestConfig import TgcDigitToTgcRDOCfg
+ acc.merge(TgcDigitToTgcRDOCfg(flags))
+
+ return acc
diff --git a/MuonSpectrometer/MuonConfig/test/MDT_DigitizationConfig_test.py b/MuonSpectrometer/MuonConfig/test/MDT_DigitizationConfig_test.py
index 7e89dd880eeaf2e5e70feec74b2d1f740c658332..6aa3821368fc9ca832e06a50239688e8c9391acf 100755
--- a/MuonSpectrometer/MuonConfig/test/MDT_DigitizationConfig_test.py
+++ b/MuonSpectrometer/MuonConfig/test/MDT_DigitizationConfig_test.py
@@ -1,7 +1,7 @@
#!/usr/bin/env python
"""Run tests on MDT_DigitizationConfigNew.py
-Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
"""
import sys
from AthenaCommon.Logging import log
@@ -11,7 +11,7 @@ from AthenaConfiguration.TestDefaults import defaultTestFiles
from AthenaConfiguration.MainServicesConfig import MainServicesSerialCfg
from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
from AthenaConfiguration.AllConfigFlags import ConfigFlags
-from MuonConfig.MDT_DigitizationConfig import MDT_DigitizerDigitToRDOCfg
+from MuonConfig.MDT_DigitizationConfig import MDT_DigitizationCfg
# Set up logging and new style config
log.setLevel(DEBUG)
@@ -24,7 +24,7 @@ ConfigFlags.lock()
# Construct our accumulator to run
acc = MainServicesSerialCfg()
acc.merge(PoolReadCfg(ConfigFlags))
-acc.merge(MDT_DigitizerDigitToRDOCfg(ConfigFlags))
+acc.merge(MDT_DigitizationCfg(ConfigFlags))
# Dump config
acc.getService("StoreGateSvc").Dump = True
acc.getService("ConditionStore").Dump = True
diff --git a/MuonSpectrometer/MuonConfig/test/MdtIntersectGeometry_test.py b/MuonSpectrometer/MuonConfig/test/MdtIntersectGeometry_test.py
index 8116c96c0dde07debc92840a24c015c345f090cf..02771d73b8c37b3d8dc72ae67721e3a50628b2ac 100644
--- a/MuonSpectrometer/MuonConfig/test/MdtIntersectGeometry_test.py
+++ b/MuonSpectrometer/MuonConfig/test/MdtIntersectGeometry_test.py
@@ -1,5 +1,5 @@
#
-# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration.
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration.
#
# File: MuonStationIntersectSvc/share/MdtIntersectGeometry_test.py
# Author: scott snyder
@@ -12,6 +12,7 @@
from __future__ import print_function
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaPython.PyAthenaComps import Alg, StatusCode
import ROOT
@@ -41,7 +42,7 @@ def testCfg (configFlags):
from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
result.merge (MagneticFieldSvcCfg(configFlags, UseDCS = False))
- from MuonStationIntersectSvc.MuonStationIntersectSvcConf import MuonStationIntersectSvc
+ MuonStationIntersectSvc = CompFactory.MuonStationIntersectSvc
result.addService (MuonStationIntersectSvc ('MuonStationIntersectSvc',
OutputLevel = 1))
diff --git a/MuonSpectrometer/MuonConfig/test/MdtRdoToPrepDataTool_test.py b/MuonSpectrometer/MuonConfig/test/MdtRdoToPrepDataTool_test.py
index aac52de592941b7293d4fb33eba8e4ff173fde6c..a5911c4aafa118a11be0b04cbc3ed6c57f9b5c7b 100644
--- a/MuonSpectrometer/MuonConfig/test/MdtRdoToPrepDataTool_test.py
+++ b/MuonSpectrometer/MuonConfig/test/MdtRdoToPrepDataTool_test.py
@@ -1,5 +1,5 @@
#
-# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration.
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration.
#
# File: MuonMDT_CnvTools/share/MdtRdoToPrepDataTool_test.py
# Author: scott snyder
@@ -12,6 +12,7 @@
from __future__ import print_function
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaPython.PyAthenaComps import Alg, StatusCode
import ROOT
@@ -43,7 +44,7 @@ def testCfg (configFlags):
from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
result.merge (MagneticFieldSvcCfg(configFlags, UseDCS = False))
- from MuonMDT_CnvTools.MuonMDT_CnvToolsConf import Muon__MdtRdoToPrepDataTool
+ Muon__MdtRdoToPrepDataTool = CompFactory.Muon__MdtRdoToPrepDataTool
result.addPublicTool (Muon__MdtRdoToPrepDataTool ('Muon__MdtRdoToPrepDataTool', OutputLevel = 1))
result.addEventAlgo (TestAlg ('TestAlg'))
diff --git a/MuonSpectrometer/MuonDigitization/CSC_Digitization/CSC_Digitization/CscDigitizationTool.h b/MuonSpectrometer/MuonDigitization/CSC_Digitization/CSC_Digitization/CscDigitizationTool.h
index 9151ec77c61b93209ff96df29c338bcd83901f0c..2de2b90ef3cfe62adb9d067a200d24a6f5459749 100644
--- a/MuonSpectrometer/MuonDigitization/CSC_Digitization/CSC_Digitization/CscDigitizationTool.h
+++ b/MuonSpectrometer/MuonDigitization/CSC_Digitization/CSC_Digitization/CscDigitizationTool.h
@@ -83,7 +83,7 @@ public: //possibly these should be private?
private:
- PublicToolHandle<ICscCalibTool> m_pcalib{this, "cscCalibTool", "CscCalibTool", ""};
+ ToolHandle<ICscCalibTool> m_pcalib{this, "cscCalibTool", "CscCalibTool", "CSC calibration tool"};
BooleanProperty m_onlyUseContainerName{this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."};
SG::ReadHandleKey<CSCSimHitCollection> m_hitsContainerKey{this, "InputObjectName", "CSC_Hits", "name of the input objects"}; // name of the input objects
diff --git a/MuonSpectrometer/MuonDigitization/CSC_Digitization/python/CSC_DigitizationConfig.py b/MuonSpectrometer/MuonDigitization/CSC_Digitization/python/CSC_DigitizationConfig.py
index 8022118349ad6ee58802954ede5e3dd0620d20d7..7768892374359ed092734379dc89addc88820628 100644
--- a/MuonSpectrometer/MuonDigitization/CSC_Digitization/python/CSC_DigitizationConfig.py
+++ b/MuonSpectrometer/MuonDigitization/CSC_Digitization/python/CSC_DigitizationConfig.py
@@ -26,20 +26,12 @@ def getCscRange(name="CscRange", **kwargs):
return CfgMgr.PileUpXingFolder(name, **kwargs)
-def getCscDigitizationTool(name="CscDigitizationTool", **kwargs):
+def getCscDigitizationToolBase(name, **kwargs):
if jobproperties.Digitization.doXingByXingPileUp(): # PileUpTool approach
# This should match the range for the CSC in Simulation/Digitization/share/MuonDigitization.py
kwargs.setdefault("FirstXing", CSC_FirstXing() )
kwargs.setdefault("LastXing", CSC_LastXing() )
- kwargs.setdefault("InputObjectName", "CSC_Hits")
- kwargs.setdefault("OutputObjectName", "CSC_DIGITS")
- if jobproperties.Digitization.PileUpPremixing and 'OverlayMT' in jobproperties.Digitization.experimentalDigi():
- from OverlayCommonAlgs.OverlayFlags import overlayFlags
- kwargs.setdefault("CSCSimDataCollectionOutputName", overlayFlags.bkgPrefix() + "CSC_SDO")
- else:
- kwargs.setdefault("CSCSimDataCollectionOutputName", "CSC_SDO")
-
kwargs.setdefault("pedestal", 0.0)
kwargs.setdefault("WindowLowerOffset", -25.0) #-50.0,
kwargs.setdefault("WindowUpperOffset", 25.0) #50.0
@@ -51,6 +43,18 @@ def getCscDigitizationTool(name="CscDigitizationTool", **kwargs):
return CfgMgr.CscDigitizationTool(name, **kwargs)
+
+def getCscDigitizationTool(name="CscDigitizationTool", **kwargs):
+ kwargs.setdefault("InputObjectName", "CSC_Hits")
+ kwargs.setdefault("OutputObjectName", "CSC_DIGITS")
+ if jobproperties.Digitization.PileUpPremixing and 'OverlayMT' in jobproperties.Digitization.experimentalDigi():
+ from OverlayCommonAlgs.OverlayFlags import overlayFlags
+ kwargs.setdefault("CSCSimDataCollectionOutputName", overlayFlags.bkgPrefix() + "CSC_SDO")
+ else:
+ kwargs.setdefault("CSCSimDataCollectionOutputName", "CSC_SDO")
+ return getCscDigitizationToolBase(name, **kwargs)
+
+
def getCscOverlayDigitizationTool(name="CscOverlayDigitizationTool",**kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
@@ -62,7 +66,8 @@ def getCscOverlayDigitizationTool(name="CscOverlayDigitizationTool",**kwargs):
kwargs.setdefault("OutputObjectName", overlayFlags.evtStore() + "+CSC_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("CSCSimDataCollectionOutputName", overlayFlags.evtStore() + "+CSC_SDO")
- return CfgMgr.CscDigitizationTool(name,**kwargs)
+ return getCscDigitizationToolBase(name, **kwargs)
+
def getCscOverlayDigitBuilder(name="CscOverlayDigitBuilder", **kwargs):
kwargs.setdefault("DigitizationTool","CscOverlayDigitizationTool")
diff --git a/MuonSpectrometer/MuonOverlay/CscOverlay/CscOverlay/CscOverlay.h b/MuonSpectrometer/MuonOverlay/CscOverlay/CscOverlay/CscOverlay.h
index 2bb8c59437d2370c0bf2d68392c4493da39e94d1..7012d0fdfefcdfed2f71df86136933bec3f3d526 100644
--- a/MuonSpectrometer/MuonOverlay/CscOverlay/CscOverlay/CscOverlay.h
+++ b/MuonSpectrometer/MuonOverlay/CscOverlay/CscOverlay/CscOverlay.h
@@ -97,7 +97,7 @@ private:
ToolHandle<Muon::MuonIdHelperTool> m_muonIdHelperTool{this, "idHelper",
"Muon::MuonIdHelperTool/MuonIdHelperTool", "Handle to the MuonIdHelperTool"};
ToolHandle<ICscCalibTool> m_cscCalibTool{this, "CalibTool", "CscCalibTool", ""};
- PublicToolHandle<Muon::ICSC_RDO_Decoder> m_cscRdoDecoderTool{this, "CscRdoDecoderTool", "Muon::CscRDO_Decoder", ""};
+ ToolHandle<Muon::ICSC_RDO_Decoder> m_cscRdoDecoderTool{this, "CscRdoDecoderTool", "Muon::CscRDO_Decoder", ""};
ServiceHandle <IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc", "Random Number Service"}; // Random number service
};
diff --git a/Simulation/Overlay/OverlayConfiguration/python/OverlaySteering.py b/Simulation/Overlay/OverlayConfiguration/python/OverlaySteering.py
index c48554e826d3229f424ce25188244962e2fc0740..389f208f3a55737b4c0c62e5723a7a59e99c108f 100644
--- a/Simulation/Overlay/OverlayConfiguration/python/OverlaySteering.py
+++ b/Simulation/Overlay/OverlayConfiguration/python/OverlaySteering.py
@@ -12,6 +12,10 @@ from AthenaPoolCnvSvc.PoolWriteConfig import PoolWriteCfg
from InDetOverlay.PixelOverlayConfig import PixelOverlayCfg
from InDetOverlay.SCTOverlayConfig import SCTOverlayCfg
from InDetOverlay.TRTOverlayConfig import TRTOverlayCfg
+from MuonConfig.CscOverlayConfig import CscOverlayCfg
+from MuonConfig.MdtOverlayConfig import MdtOverlayCfg
+from MuonConfig.RpcOverlayConfig import RpcOverlayCfg
+from MuonConfig.TgcOverlayConfig import TgcOverlayCfg
from OverlayCopyAlgs.OverlayCopyAlgsConfig import \
CopyCaloCalibrationHitContainersCfg, CopyJetTruthInfoCfg, CopyMcEventCollectionCfg, \
CopyTimingsCfg, CopyTrackRecordCollectionsCfg
@@ -59,4 +63,14 @@ def OverlayMainCfg(configFlags):
if configFlags.Detector.OverlayTRT:
acc.merge(TRTOverlayCfg(configFlags))
+ # Muon system
+ if configFlags.Detector.OverlayCSC:
+ acc.merge(CscOverlayCfg(configFlags))
+ if configFlags.Detector.OverlayMDT:
+ acc.merge(MdtOverlayCfg(configFlags))
+ if configFlags.Detector.OverlayRPC:
+ acc.merge(RpcOverlayCfg(configFlags))
+ if configFlags.Detector.OverlayTGC:
+ acc.merge(TgcOverlayCfg(configFlags))
+
return acc
diff --git a/Simulation/Overlay/OverlayConfiguration/python/OverlayTestHelpers.py b/Simulation/Overlay/OverlayConfiguration/python/OverlayTestHelpers.py
index 1387bbfb99b6ff1011ff6fcb4109df4b9a666b1f..8f34a948d4c63c1cf1d58832c68c06ef12de982e 100644
--- a/Simulation/Overlay/OverlayConfiguration/python/OverlayTestHelpers.py
+++ b/Simulation/Overlay/OverlayConfiguration/python/OverlayTestHelpers.py
@@ -6,7 +6,16 @@ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
from argparse import ArgumentParser
-from AthenaConfiguration.TestDefaults import defaultTestFiles
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+
+def JobOptsDumperCfg(flags):
+ """Configure event loop for overlay"""
+ JobOptsDumperAlg = CompFactory.JobOptsDumperAlg
+ acc = ComponentAccumulator()
+ acc.addEventAlgo(JobOptsDumperAlg(FileName="OverlayTestConfig.txt"))
+ return acc
def CommonTestArgumentParser(prog):
@@ -59,6 +68,7 @@ def setupOverlayTestDetectorFlags(configFlags, detectors):
def defaultTestFlags(configFlags, args):
"""Fill default overlay flags for testing"""
+ from AthenaConfiguration.TestDefaults import defaultTestFiles
configFlags.GeoModel.Align.Dynamic = False
configFlags.Digitization.DoInnerDetectorNoise = False
if args.data:
diff --git a/Simulation/Overlay/OverlayConfiguration/test/OverlayTest.py b/Simulation/Overlay/OverlayConfiguration/test/OverlayTest.py
index 76ee571a78ddc6486d756c34292e18881d673718..73ba5785953b2da1c00ffb5397c1270fd18a29ac 100755
--- a/Simulation/Overlay/OverlayConfiguration/test/OverlayTest.py
+++ b/Simulation/Overlay/OverlayConfiguration/test/OverlayTest.py
@@ -12,7 +12,7 @@ from AthenaConfiguration.AllConfigFlags import ConfigFlags
from OverlayConfiguration.OverlaySteering import OverlayMainCfg
from OverlayConfiguration.OverlayTestHelpers import \
- CommonTestArgumentParser, defaultTestFlags, postprocessAndLockFlags, printAndRun
+ CommonTestArgumentParser, JobOptsDumperCfg, defaultTestFlags, postprocessAndLockFlags, printAndRun
# Set up logging and new style config
Configurable.configurableRun3Behavior = True
@@ -38,6 +38,7 @@ postprocessAndLockFlags(ConfigFlags, args)
# Construct our accumulator to run
acc = OverlayMainCfg(ConfigFlags)
+acc.merge(JobOptsDumperCfg(ConfigFlags))
# dump pickle
with open("ConfigOverlay.pkl", "wb") as f:
diff --git a/Simulation/Tests/OverlayTests/test/test_DataOverlay_ConfigTest_Zmumu_Muon.sh b/Simulation/Tests/OverlayTests/test/test_DataOverlay_ConfigTest_Zmumu_Muon.sh
new file mode 100755
index 0000000000000000000000000000000000000000..d71b116cdf3fa5cfcd6217b33a62a4a29ae13f70
--- /dev/null
+++ b/Simulation/Tests/OverlayTests/test/test_DataOverlay_ConfigTest_Zmumu_Muon.sh
@@ -0,0 +1,78 @@
+#!/bin/sh
+
+# art-description: MC+data Overlay with MT support, config test
+# art-type: grid
+# art-include: master/Athena
+
+# art-output: legacyDataOverlayRDO.pool.root
+# art-output: dataOverlayRDO.pool.root
+# art-output: log.*
+# art-output: mem.summary.*
+# art-output: mem.full.*
+# art-output: runargs.*
+# art-output: *.pkl
+# art-output: *Config.txt
+
+set -o pipefail
+
+events=2
+
+OverlayBS_tf.py \
+--inputBS_SKIMFile /cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/OverlayMonitoringRTT/mc15_valid.00200010.overlay_streamsAll_2016_pp_1.skim.DRAW.r8381/DRAW.09331084._000146.pool.root.1 \
+--inputHITSFile /cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/OverlayMonitoringRTT/mc16_13TeV.361107.PowhegPythia8EvtGen_AZNLOCTEQ6L1_Zmumu.OverlaySim/HITS.pool.root \
+--outputRDOFile legacyDataOverlayRDO.pool.root \
+--maxEvents $events \
+--conditionsTag CONDBR2-BLKPA-2016-12 \
+--fSampltag LARElecCalibMCfSampl-G496-19213- \
+--preExec 'from LArROD.LArRODFlags import larRODFlags;larRODFlags.nSamples.set_Value_and_Lock(4);from LArConditionsCommon.LArCondFlags import larCondFlags; larCondFlags.OFCShapeFolder.set_Value_and_Lock("4samples1phase")' \
+--postExec 'outStream.ItemList.remove("xAOD::EventInfoContainer#*"); outStream.ItemList.remove("xAOD::EventInfoAuxContainer#*");' \
+--preInclude 'SimulationJobOptions/preInclude.MuonOnlyConfig.py,SimulationJobOptions/preInclude.TruthOnlyConfig.py' \
+--postInclude 'EventOverlayJobTransforms/Rt_override_CONDBR2-BLKPA-2015-12.py' \
+--ignorePatterns "L1TopoMenuLoader.+ERROR." \
+--imf False \
+--athenaopts '"--config-only=ConfigLegacy.pkl"'
+
+OverlayBS_tf.py \
+--inputBS_SKIMFile /cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/OverlayMonitoringRTT/mc15_valid.00200010.overlay_streamsAll_2016_pp_1.skim.DRAW.r8381/DRAW.09331084._000146.pool.root.1 \
+--inputHITSFile /cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/OverlayMonitoringRTT/mc16_13TeV.361107.PowhegPythia8EvtGen_AZNLOCTEQ6L1_Zmumu.OverlaySim/HITS.pool.root \
+--outputRDOFile legacyDataOverlayRDO.pool.root \
+--maxEvents $events \
+--conditionsTag CONDBR2-BLKPA-2016-12 \
+--fSampltag LARElecCalibMCfSampl-G496-19213- \
+--preExec 'from LArROD.LArRODFlags import larRODFlags;larRODFlags.nSamples.set_Value_and_Lock(4);from LArConditionsCommon.LArCondFlags import larCondFlags; larCondFlags.OFCShapeFolder.set_Value_and_Lock("4samples1phase")' \
+--postExec 'job+=CfgMgr.JobOptsDumperAlg(FileName="OverlayLegacyConfig.txt"); outStream.ItemList.remove("xAOD::EventInfoContainer#*"); outStream.ItemList.remove("xAOD::EventInfoAuxContainer#*");' \
+--preInclude 'SimulationJobOptions/preInclude.MuonOnlyConfig.py,SimulationJobOptions/preInclude.TruthOnlyConfig.py' \
+--postInclude 'EventOverlayJobTransforms/Rt_override_CONDBR2-BLKPA-2015-12.py' \
+--ignorePatterns "L1TopoMenuLoader.+ERROR." \
+--imf False
+
+rc=$?
+echo "art-result: $rc configLegacy"
+mv log.OverlayBS log.OverlayLegacy
+
+rc2=-9999
+if [ $rc -eq 0 ]
+then
+ OverlayTest.py Muon -d -t 1 -n $events 2>&1 | tee log.OverlayTest
+ rc2=$?
+fi
+echo "art-result: $rc2 configNew"
+
+rc3=-9999
+if [ $rc2 -eq 0 ]
+then
+ acmd.py diff-root legacyDataOverlayRDO.pool.root dataOverlayRDO.pool.root \
+ --error-mode resilient --mode=semi-detailed \
+ --ignore-leaves RecoTimingObj_p1_EVNTtoHITS_timings RecoTimingObj_p1_HITStoRDO_timings index_ref \
+ xAOD::EventAuxInfo_v1_EventInfoAuxDyn.subEventIndex \
+ xAOD::EventAuxInfo_v1_EventInfoAuxDyn.subEventTime \
+ xAOD::EventAuxInfo_v1_EventInfoAuxDyn.subEventType \
+ xAOD::EventAuxInfo_v1_EventInfoAux.detectorMask0 \
+ xAOD::EventAuxInfo_v1_EventInfoAux.detectorMask1 \
+ xAOD::EventAuxInfo_v1_EventInfoAux.detectorMask2 \
+ xAOD::EventAuxInfo_v1_EventInfoAux.detectorMask3 \
+ xAOD::EventAuxInfo_v1_EventInfoAux.actualInteractionsPerCrossing \
+ xAOD::EventAuxInfo_v1_EventInfoAux.averageInteractionsPerCrossing
+ rc3=$?
+fi
+echo "art-result: $rc3 comparison"
diff --git a/Simulation/Tests/OverlayTests/test/test_MCOverlay_ConfigTest_ttbar_Muon.sh b/Simulation/Tests/OverlayTests/test/test_MCOverlay_ConfigTest_ttbar_Muon.sh
new file mode 100755
index 0000000000000000000000000000000000000000..7690e142d31afd85f9193f968cf91d82a2affa04
--- /dev/null
+++ b/Simulation/Tests/OverlayTests/test/test_MCOverlay_ConfigTest_ttbar_Muon.sh
@@ -0,0 +1,62 @@
+#!/bin/sh
+
+# art-description: MC+MC Overlay with MT support, config test
+# art-type: grid
+# art-include: master/Athena
+
+# art-output: legacyMcOverlayRDO.pool.root
+# art-output: mcOverlayRDO.pool.root
+# art-output: log.*
+# art-output: mem.summary.*
+# art-output: mem.full.*
+# art-output: runargs.*
+# art-output: *.pkl
+# art-output: *Config.txt
+
+set -o pipefail
+
+events=2
+
+Overlay_tf.py \
+--inputHITSFile /cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/Tier0ChainTests/valid1.410000.PowhegPythiaEvtGen_P2012_ttbar_hdamp172p5_nonallhad.simul.HITS.e4993_s3091/HITS.10504490._000425.pool.root.1 \
+--inputRDO_BKGFile /cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/OverlayMonitoringRTT/PileupPremixing/22.0/v4/RDO.merged-pileup-MT.100events.pool.root \
+--outputRDOFile legacyMcOverlayRDO.pool.root \
+--maxEvents $events \
+--conditionsTag OFLCOND-MC16-SDR-20 \
+--geometryVersion ATLAS-R2-2016-01-00-01 \
+--preExec 'from LArROD.LArRODFlags import larRODFlags;larRODFlags.NumberOfCollisions.set_Value_and_Lock(20);larRODFlags.nSamples.set_Value_and_Lock(4);larRODFlags.doOFCPileupOptimization.set_Value_and_Lock(True);larRODFlags.firstSample.set_Value_and_Lock(0);larRODFlags.useHighestGainAutoCorr.set_Value_and_Lock(True); from LArDigitization.LArDigitizationFlags import jobproperties;jobproperties.LArDigitizationFlags.useEmecIwHighGain.set_Value_and_Lock(False);' \
+--preInclude 'Overlay:SimulationJobOptions/preInclude.MuonOnlyConfig.py,SimulationJobOptions/preInclude.TruthOnlyConfig.py' \
+--imf False \
+--athenaopts '"--config-only=ConfigLegacy.pkl"'
+
+Overlay_tf.py \
+--inputHITSFile /cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/OverlayMonitoringRTT/valid1.410000.PowhegPythiaEvtGen_P2012_ttbar_hdamp172p5_nonallhad.simul.HITS.e4993_s3091/HITS.10504490._000425.pool.root.1 \
+--inputRDO_BKGFile /cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/OverlayMonitoringRTT/PileupPremixing/22.0/v4/RDO.merged-pileup-MT.100events.pool.root \
+--outputRDOFile legacyMcOverlayRDO.pool.root \
+--maxEvents $events \
+--conditionsTag OFLCOND-MC16-SDR-20 \
+--geometryVersion ATLAS-R2-2016-01-00-01 \
+--preExec 'from LArROD.LArRODFlags import larRODFlags;larRODFlags.NumberOfCollisions.set_Value_and_Lock(20);larRODFlags.nSamples.set_Value_and_Lock(4);larRODFlags.doOFCPileupOptimization.set_Value_and_Lock(True);larRODFlags.firstSample.set_Value_and_Lock(0);larRODFlags.useHighestGainAutoCorr.set_Value_and_Lock(True); from LArDigitization.LArDigitizationFlags import jobproperties;jobproperties.LArDigitizationFlags.useEmecIwHighGain.set_Value_and_Lock(False);' \
+--postExec 'job+=CfgMgr.JobOptsDumperAlg(FileName="OverlayLegacyConfig.txt");' \
+--preInclude 'Overlay:SimulationJobOptions/preInclude.MuonOnlyConfig.py,SimulationJobOptions/preInclude.TruthOnlyConfig.py' \
+--imf False
+
+rc=$?
+echo "art-result: $rc configLegacy"
+mv log.Overlay log.OverlayLegacy
+
+rc2=-9999
+if [ $rc -eq 0 ]
+then
+ OverlayTest.py Muon -t 1 -n $events 2>&1 | tee log.OverlayTest
+ rc2=$?
+fi
+echo "art-result: $rc2 configNew"
+
+rc3=-9999
+if [ $rc2 -eq 0 ]
+then
+ acmd.py diff-root legacyMcOverlayRDO.pool.root mcOverlayRDO.pool.root --error-mode resilient --mode=semi-detailed --ignore-leaves RecoTimingObj_p1_EVNTtoHITS_timings RecoTimingObj_p1_HITStoRDO_timings index_ref
+ rc3=$?
+fi
+echo "art-result: $rc3 comparison"
diff --git a/Tools/PROCTools/python/RunTier0TestsTools.py b/Tools/PROCTools/python/RunTier0TestsTools.py
index da458f5c6e8e541bbec676179e10b585c1f94872..3483331c3f0169f37e0f774d5832cf2c12f43124 100644
--- a/Tools/PROCTools/python/RunTier0TestsTools.py
+++ b/Tools/PROCTools/python/RunTier0TestsTools.py
@@ -28,7 +28,7 @@ ciRefFileMap = {
's3505-22.0' : 'v2',
# OverlayTier0Test_required-test
'overlay-d1498-21.0' : 'v2',
- 'overlay-d1498-22.0' : 'v26',
+ 'overlay-d1498-22.0' : 'v27',
'overlay-bkg-21.0' : 'v1',
'overlay-bkg-22.0' : 'v4',
}