diff --git a/Event/EventOverlay/EventOverlayJobTransforms/share/OverlayOutput_jobOptions.py b/Event/EventOverlay/EventOverlayJobTransforms/share/OverlayOutput_jobOptions.py index 24ddaf49c5faf58e5aec5b6834d958552dcec370..fbfa6c2ca80d78c764412cfa08dc820bd47ba932 100644 --- a/Event/EventOverlay/EventOverlayJobTransforms/share/OverlayOutput_jobOptions.py +++ b/Event/EventOverlay/EventOverlayJobTransforms/share/OverlayOutput_jobOptions.py @@ -147,21 +147,21 @@ if DetFlags.overlay.LVL1_on(): #add the tracks if overlayFlags.doTrackOverlay(): - outStream.ItemList += [ 'TrackCollection#Bkg_CombinedInDetTracks' ] - outStream.ItemList += [ 'TrackCollection#Bkg_DisappearingTracks' ] - outStream.ItemList += [ 'TrackCollection#Bkg_ResolvedForwardTracks' ] - outStream.ItemList += [ 'TrackCollection#Bkg_ResolvedLargeD0Tracks' ] - outStream.ItemList += [ 'InDet::TRT_DriftCircleContainer#Bkg_TRT_DriftCircles' ] - outStream.ItemList += [ 'InDet::PixelClusterContainer#Bkg_PixelClusters' ] - outStream.ItemList += [ 'InDet::SCT_ClusterContainer#Bkg_SCT_Clusters' ] + outStream.ItemList += [ 'TrackCollection#'+overlayFlags.bkgPrefix()+'CombinedInDetTracks' ] + outStream.ItemList += [ 'TrackCollection#'+overlayFlags.bkgPrefix()+'DisappearingTracks' ] + outStream.ItemList += [ 'TrackCollection#'+overlayFlags.bkgPrefix()+'ResolvedForwardTracks' ] + outStream.ItemList += [ 'TrackCollection#'+overlayFlags.bkgPrefix()+'ResolvedLargeD0Tracks' ] + outStream.ItemList += [ 'InDet::TRT_DriftCircleContainer#'+overlayFlags.bkgPrefix()+'TRT_DriftCircles' ] + outStream.ItemList += [ 'InDet::PixelClusterContainer#'+overlayFlags.bkgPrefix()+'PixelClusters' ] + outStream.ItemList += [ 'InDet::SCT_ClusterContainer#'+overlayFlags.bkgPrefix()+'SCT_Clusters' ] if DetFlags.overlay.Truth_on(): - outStream.ItemList += [ 'PRD_MultiTruthCollection#Bkg_PRD_MultiTruthTRT' ] - outStream.ItemList += [ 'PRD_MultiTruthCollection#Bkg_PRD_MultiTruthPixel' ] - outStream.ItemList += [ 'PRD_MultiTruthCollection#Bkg_PRD_MultiTruthSCT' ] - outStream.ItemList += [ 'DetailedTrackTruthCollection#Bkg_DisappearingTracksDetailedTruth' ] - outStream.ItemList += [ 'DetailedTrackTruthCollection#Bkg_ResolvedForwardTracksDetailedTruth' ] - outStream.ItemList += [ 'DetailedTrackTruthCollection#Bkg_CombinedInDetTracksDetailedTruth' ] - outStream.ItemList += [ 'DetailedTrackTruthCollection#Bkg_ResolvedLargeD0TracksDetailedTruth' ] + outStream.ItemList += [ 'PRD_MultiTruthCollection#'+overlayFlags.bkgPrefix()+'PRD_MultiTruthTRT' ] + outStream.ItemList += [ 'PRD_MultiTruthCollection#'+overlayFlags.bkgPrefix()+'PRD_MultiTruthPixel' ] + outStream.ItemList += [ 'PRD_MultiTruthCollection#'+overlayFlags.bkgPrefix()+'PRD_MultiTruthSCT' ] + outStream.ItemList += [ 'DetailedTrackTruthCollection#'+overlayFlags.bkgPrefix()+'DisappearingTracksDetailedTruth' ] + outStream.ItemList += [ 'DetailedTrackTruthCollection#'+overlayFlags.bkgPrefix()+'ResolvedForwardTracksDetailedTruth' ] + outStream.ItemList += [ 'DetailedTrackTruthCollection#'+overlayFlags.bkgPrefix()+'ResolvedLargeD0TracksDetailedTruth' ] + outStream.ItemList += [ 'DetailedTrackTruthCollection#'+overlayFlags.bkgPrefix()+'CombinedInDetTracksDetailedTruth' ] # Temporary to ensure the output is stored outStream.TransientItems = outStream.ItemList diff --git a/Event/EventOverlay/EventOverlayJobTransforms/share/TrackOverlay_jobOptions.py b/Event/EventOverlay/EventOverlayJobTransforms/share/TrackOverlay_jobOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..f6df71eb1d967f47a9561fe392a871a5e5060796 --- /dev/null +++ b/Event/EventOverlay/EventOverlayJobTransforms/share/TrackOverlay_jobOptions.py @@ -0,0 +1,25 @@ +include.block ( "EventOverlayJobTransforms/TrackOverlay_jobOptions.py" ) + +from AthenaCommon import CfgGetter +from OverlayCommonAlgs.OverlayFlags import overlayFlags + +job += CfgGetter.getAlgorithm('CopyPixelClusterContainer') +job += CfgGetter.getAlgorithm('CopySCT_ClusterContainer') +job += CfgGetter.getAlgorithm('CopyTRT_DriftCircleContainer') + +trackContainers=['CombinedInDetTracks','DisappearingTracks','ResolvedForwardTracks','ResolvedLargeD0Tracks'] +for container in trackContainers: + job += CfgGetter.getAlgorithmClone('CopyTrackCollection'+container, 'CopyTrackCollection', collectionName=container) + +truthContainers=['DisappearingTracksDetailedTruth','ResolvedForwardTracksDetailedTruth','CombinedInDetTracksDetailedTruth','ResolvedLargeD0TracksDetailedTruth'] +for container in truthContainers: + job += CfgGetter.getAlgorithmClone('CopyDetailedTrackTruthCollection'+container, 'CopyDetailedTrackTruthCollection', collectionName=container) + +prdTruthContainers=['PRD_MultiTruthTRT','PRD_MultiTruthPixel','PRD_MultiTruthSCT'] +for container in prdTruthContainers: + job += CfgGetter.getAlgorithmClone('CopyPRD_MultiTruthCollection'+container, 'CopyPRD_MultiTruthCollection', collectionName=container) + +from TrkEventCnvTools.TrkEventCnvToolsConf import Trk__EventCnvSuperTool +TrkEventCnvSuperTool = Trk__EventCnvSuperTool(name="EventCnvSuperTool") +TrkEventCnvSuperTool.DoTrackOverlay=True +ToolSvc+=TrkEventCnvSuperTool diff --git a/InnerDetector/InDetDigitization/PixelDigitization/python/PixelDigitizationConfigNew.py b/InnerDetector/InDetDigitization/PixelDigitization/python/PixelDigitizationConfigNew.py index 9584d0d361f5b04f3a7047f072bed01894035ac5..9c6590fb330d4b3559ead9d7329e8d4ac7f00a60 100644 --- a/InnerDetector/InDetDigitization/PixelDigitization/python/PixelDigitizationConfigNew.py +++ b/InnerDetector/InDetDigitization/PixelDigitization/python/PixelDigitizationConfigNew.py @@ -280,8 +280,13 @@ def PixelDigitizationSplitNoMergePUToolCfg(flags, name="PixelDigitizationSplitNo def PixelOverlayDigitizationToolCfg(flags, name="PixelOverlayDigitizationTool", **kwargs): """Return ComponentAccumulator with PixelDigitizationTool configured for overlay""" kwargs.setdefault("OnlyUseContainerName", False) - kwargs.setdefault("RDOCollName", flags.Overlay.SigPrefix + "PixelRDOs") - kwargs.setdefault("SDOCollName", flags.Overlay.SigPrefix + "PixelSDO_Map") + #in the case of track overlay, only run digitization on the HS + if not flags.Overlay.doTrackOverlay: + kwargs.setdefault("RDOCollName", flags.Overlay.SigPrefix + "PixelRDOs") + kwargs.setdefault("SDOCollName", flags.Overlay.SigPrefix + "PixelSDO_Map") + else: + kwargs.setdefault("RDOCollName", "PixelRDOs") + kwargs.setdefault("SDOCollName", "PixelSDO_Map") kwargs.setdefault("HardScatterSplittingMode", 0) kwargs.setdefault("PileUpMergeSvc", '') return PixelDigitizationBasicToolCfg(flags, name, **kwargs) diff --git a/InnerDetector/InDetDigitization/SCT_Digitization/python/SCT_DigitizationConfigNew.py b/InnerDetector/InDetDigitization/SCT_Digitization/python/SCT_DigitizationConfigNew.py index c7aa28aba4b21c7904485abc8f3c8723a18860e0..f7d81205695544eb927a14ef63db2eefde5771a7 100644 --- a/InnerDetector/InDetDigitization/SCT_Digitization/python/SCT_DigitizationConfigNew.py +++ b/InnerDetector/InDetDigitization/SCT_Digitization/python/SCT_DigitizationConfigNew.py @@ -108,8 +108,13 @@ def SCT_OverlayDigitizationToolCfg(flags, name="SCT_OverlayDigitizationTool",**k """Return ComponentAccumulator with overlay configured SCT digitization tool""" acc = ComponentAccumulator() kwargs.setdefault("OnlyUseContainerName", False) - kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "SCT_RDOs") - kwargs.setdefault("OutputSDOName", flags.Overlay.SigPrefix + "SCT_SDO_Map") + #in the case of track overlay, only run digitization on the HS + if not flags.Overlay.doTrackOverlay: + kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "SCT_RDOs") + kwargs.setdefault("OutputSDOName", flags.Overlay.SigPrefix + "SCT_SDO_Map") + else: + kwargs.setdefault("OutputObjectName", "SCT_RDOs") + kwargs.setdefault("OutputSDOName", "SCT_SDO_Map") kwargs.setdefault("HardScatterSplittingMode", 0) kwargs.setdefault("MergeSvc", '') tool = acc.popToolsAndMerge(SCT_DigitizationCommonCfg(flags, name, **kwargs)) diff --git a/InnerDetector/InDetDigitization/TRT_Digitization/python/TRT_DigitizationConfigNew.py b/InnerDetector/InDetDigitization/TRT_Digitization/python/TRT_DigitizationConfigNew.py index 1954a1186fa1e5c03097812e748dfe46292b4d8a..8d1f13c4e3ef297c1e84bbb9135d85cfe1832f26 100644 --- a/InnerDetector/InDetDigitization/TRT_Digitization/python/TRT_DigitizationConfigNew.py +++ b/InnerDetector/InDetDigitization/TRT_Digitization/python/TRT_DigitizationConfigNew.py @@ -163,13 +163,19 @@ def TRT_OverlayDigitizationToolCfg(flags, name="TRT_OverlayDigitizationTool", ** """Return ComponentAccumulator with configured Overlay TRT digitization tool""" acc = ComponentAccumulator() kwargs.setdefault("OnlyUseContainerName", False) - kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "TRT_RDOs") - kwargs.setdefault("OutputSDOName", flags.Overlay.SigPrefix + "TRT_SDO_Map") + #in the case of track overlay, only run digitization on the HS + if not flags.Overlay.doTrackOverlay: + kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "TRT_RDOs") + kwargs.setdefault("OutputSDOName", flags.Overlay.SigPrefix + "TRT_SDO_Map") + kwargs.setdefault("Override_isOverlay", 1) + else: + kwargs.setdefault("OutputObjectName", "TRT_RDOs") + kwargs.setdefault("OutputSDOName", "TRT_SDO_Map") + kwargs.setdefault("Override_isOverlay", 0) kwargs.setdefault("HardScatterSplittingMode", 0) kwargs.setdefault("Override_getT0FromData", 0) kwargs.setdefault("Override_noiseInSimhits", 0) kwargs.setdefault("Override_noiseInUnhitStraws", 0) - kwargs.setdefault("Override_isOverlay", 1) kwargs.setdefault("MergeSvc", '') tool = acc.popToolsAndMerge(TRT_DigitizationBasicToolCfg(flags, name, **kwargs)) acc.setPrivateTools(tool) diff --git a/InnerDetector/InDetEventCnv/InDetEventTPCnv/src/InDetRIO_OnTrack/PixelClusterOnTrackCnv_p2.cxx b/InnerDetector/InDetEventCnv/InDetEventTPCnv/src/InDetRIO_OnTrack/PixelClusterOnTrackCnv_p2.cxx index c437b85ddb63a6b3e7094e72867f80089b32f223..73e8c1c1df1a2406313947a6310eb917a72b546c 100644 --- a/InnerDetector/InDetEventCnv/InDetEventTPCnv/src/InDetRIO_OnTrack/PixelClusterOnTrackCnv_p2.cxx +++ b/InnerDetector/InDetEventCnv/InDetEventTPCnv/src/InDetRIO_OnTrack/PixelClusterOnTrackCnv_p2.cxx @@ -20,7 +20,7 @@ void PixelClusterOnTrackCnv_p2::persToTrans( const InDet::PixelClusterOnTrack_p2 } ElementLinkToIDCPixelClusterContainer rio; - m_elCnv.persToTrans(&persObj->m_prdLink,&rio,log); + m_elCnv.persToTrans(&persObj->m_prdLink,&rio,log); Trk::LocalParameters localParams; fillTransFromPStore( &m_localParCnv, persObj->m_localParams, &localParams, log ); @@ -65,17 +65,12 @@ void PixelClusterOnTrackCnv_p2::transToPers( const InDet::PixelClusterOnTrack *t persObj->m_isFake = transObj->isFake(); persObj->m_energyLoss = transObj->energyLoss(); - //3 scenarios here - //1: standard running, the EL has only the cached object and the EventCnvSuperTool track overlay flag is false - //2: running reco on the overlay RDO file to build the tracks for track overlay, where the EL has only the cached object but the EventCnvSuperTool track overlay flag is true - //3: the overlay step, in which the EventCnvSuperTool track overlay flag is false but the EL should have the correct dataID stored - std::string clusContName="PixelClusters"; - if(transObj->prepRawDataLink().dataID()!="") clusContName=transObj->prepRawDataLink().dataID(); - else if(m_eventCnvTool->doTrackOverlay()) clusContName="Bkg_PixelClusters"; - static const SG::InitializedReadHandleKey pixelClusContName (clusContName.c_str()); + static const SG::InitializedReadHandleKey pixelClusContName("PixelClusters"); // (clusContName.c_str()); ElementLink::index_type hashAndIndex{0}; bool isFound{m_eventCnvTool->getHashAndIndex(transObj, pixelClusContName, hashAndIndex)}; - persObj->m_prdLink.m_contName = (isFound ? pixelClusContName.key() : ""); + //in the case of track overlay, the final output container has a different name which we use instead + if(m_eventCnvTool->doTrackOverlay()) persObj->m_prdLink.m_contName = (isFound ? "Bkg_PixelClusters" : ""); + else persObj->m_prdLink.m_contName = (isFound ? pixelClusContName.key() : ""); persObj->m_prdLink.m_elementIndex = hashAndIndex; } diff --git a/InnerDetector/InDetEventCnv/InDetEventTPCnv/src/InDetRIO_OnTrack/SCT_ClusterOnTrackCnv_p2.cxx b/InnerDetector/InDetEventCnv/InDetEventTPCnv/src/InDetRIO_OnTrack/SCT_ClusterOnTrackCnv_p2.cxx index f78af39d01c6cb0c58d32c10e2750645ee01e7c7..7c87d3cce0f23b0a69fe0930aefc639cb8acbffb 100644 --- a/InnerDetector/InDetEventCnv/InDetEventTPCnv/src/InDetRIO_OnTrack/SCT_ClusterOnTrackCnv_p2.cxx +++ b/InnerDetector/InDetEventCnv/InDetEventTPCnv/src/InDetRIO_OnTrack/SCT_ClusterOnTrackCnv_p2.cxx @@ -65,16 +65,10 @@ void SCT_ClusterOnTrackCnv_p2::transToPers(const InDet::SCT_ClusterOnTrack* tran persObj->m_isbroad = transObj->isBroadCluster(); persObj->m_positionAlongStrip = static_cast(transObj->positionAlongStrip()); - //3 scenarios here - //1: standard running, the EL has only the cached object and the EventCnvSuperTool track overlay flag is false - //2: running reco on the overlay RDO file to build the tracks for track overlay, where the EL has only the cached object but the EventCnvSuperTool track overlay flag is true - //3: the overlay step, in which the EventCnvSuperTool track overlay flag is false but the EL should have the correct dataID stored - std::string clusContName="SCT_Clusters"; - if(transObj->prepRawDataLink().dataID()!="") clusContName=transObj->prepRawDataLink().dataID(); - else if(m_eventCnvTool->doTrackOverlay()) clusContName="Bkg_SCT_Clusters"; - static const SG::InitializedReadHandleKey sctClusContName (clusContName.c_str()); + static const SG::InitializedReadHandleKey sctClusContName ("SCT_Clusters"); ElementLink::index_type hashAndIndex{0}; bool isFound{m_eventCnvTool->getHashAndIndex(transObj, sctClusContName, hashAndIndex)}; - persObj->m_prdLink.m_contName = (isFound ? sctClusContName.key() : ""); + if(m_eventCnvTool->doTrackOverlay()) persObj->m_prdLink.m_contName = (isFound ? "Bkg_SCT_Clusters" : ""); + else persObj->m_prdLink.m_contName = (isFound ? sctClusContName.key() : ""); persObj->m_prdLink.m_elementIndex = hashAndIndex; } diff --git a/InnerDetector/InDetEventCnv/InDetEventTPCnv/src/InDetRIO_OnTrack/TRT_DriftCircleOnTrackCnv_p2.cxx b/InnerDetector/InDetEventCnv/InDetEventTPCnv/src/InDetRIO_OnTrack/TRT_DriftCircleOnTrackCnv_p2.cxx index c85bb5902902970f49a89f9752830d9c647dee6c..dd6207e8f6b3bcfb0984eb56a5fc89e5a198e204 100644 --- a/InnerDetector/InDetEventCnv/InDetEventTPCnv/src/InDetRIO_OnTrack/TRT_DriftCircleOnTrackCnv_p2.cxx +++ b/InnerDetector/InDetEventCnv/InDetEventTPCnv/src/InDetRIO_OnTrack/TRT_DriftCircleOnTrackCnv_p2.cxx @@ -63,16 +63,10 @@ void TRT_DriftCircleOnTrackCnv_p2::transToPers( const InDet::TRT_DriftCircleOnTr // added in 12.5 persObj->m_timeOverThreshold = static_cast(transObj->timeOverThreshold()); - //3 scenarios here - //1: standard running, the EL has only the cached object and the EventCnvSuperTool track overlay flag is false - //2: running reco on the overlay RDO file to build the tracks for track overlay, where the EL has only the cached object but the EventCnvSuperTool track overlay flag is true - //3: the overlay step, in which the EventCnvSuperTool track overlay flag is false but the EL should have the correct dataID stored - std::string clusContName="TRT_DriftCircles"; - if(transObj->prepRawDataLink().dataID()!="") clusContName=transObj->prepRawDataLink().dataID(); - else if(m_eventCnvTool->doTrackOverlay()) clusContName="Bkg_TRT_DriftCircles"; - static const SG::InitializedReadHandleKey trtCircleContName (clusContName.c_str()); + static const SG::InitializedReadHandleKey trtCircleContName ("TRT_DriftCircles"); ElementLink::index_type hashAndIndex{0}; bool isFound{m_eventCnvTool->getHashAndIndex(transObj, trtCircleContName, hashAndIndex)}; - persObj->m_prdLink.m_contName = (isFound ? trtCircleContName.key() : ""); + if(m_eventCnvTool->doTrackOverlay()) persObj->m_prdLink.m_contName = (isFound ? "Bkg_TRT_DriftCircles" : ""); + else persObj->m_prdLink.m_contName = (isFound ? trtCircleContName.key() : ""); persObj->m_prdLink.m_elementIndex = hashAndIndex; } diff --git a/InnerDetector/InDetRawAlgs/InDetOverlay/python/PixelOverlayConfig.py b/InnerDetector/InDetRawAlgs/InDetOverlay/python/PixelOverlayConfig.py index 331b0d50b0e4c7fc861e85090c9f4823176512f6..289138ad437a4b910844acc85ba08a4cbd76a07d 100644 --- a/InnerDetector/InDetRawAlgs/InDetOverlay/python/PixelOverlayConfig.py +++ b/InnerDetector/InDetRawAlgs/InDetOverlay/python/PixelOverlayConfig.py @@ -95,9 +95,11 @@ def PixelOverlayCfg(flags): # Add Pixel overlay digitization algorithm from PixelDigitization.PixelDigitizationConfigNew import PixelOverlayDigitizationBasicCfg acc.merge(PixelOverlayDigitizationBasicCfg(flags)) - # Add Pixel overlay algorithm - acc.merge(PixelOverlayAlgCfg(flags)) - # Add Pixel truth overlay - acc.merge(PixelTruthOverlayCfg(flags)) + #if track overlay, don't run the standard overlay + if not flags.Overlay.doTrackOverlay: + # Add Pixel overlay algorithm + acc.merge(PixelOverlayAlgCfg(flags)) + # Add Pixel truth overlay + acc.merge(PixelTruthOverlayCfg(flags)) return acc diff --git a/InnerDetector/InDetRawAlgs/InDetOverlay/python/SCTOverlayConfig.py b/InnerDetector/InDetRawAlgs/InDetOverlay/python/SCTOverlayConfig.py index 998c6b2030de1d0c8c72ec6dbe2be65231ca4ba5..7fea20875f235164fe79f961a18b3b1fa0513226 100644 --- a/InnerDetector/InDetRawAlgs/InDetOverlay/python/SCTOverlayConfig.py +++ b/InnerDetector/InDetRawAlgs/InDetOverlay/python/SCTOverlayConfig.py @@ -98,9 +98,11 @@ def SCTOverlayCfg(flags): # Add SCT overlay digitization algorithm from SCT_Digitization.SCT_DigitizationConfigNew import SCT_OverlayDigitizationBasicCfg acc.merge(SCT_OverlayDigitizationBasicCfg(flags)) - # Add SCT overlay algorithm - acc.merge(SCTOverlayAlgCfg(flags)) - # Add SCT truth overlay - acc.merge(SCTTruthOverlayCfg(flags)) + #if track overlay, don't run the standard overlay + if not flags.Overlay.doTrackOverlay: + # Add SCT overlay algorithm + acc.merge(SCTOverlayAlgCfg(flags)) + # Add SCT truth overlay + acc.merge(SCTTruthOverlayCfg(flags)) return acc diff --git a/InnerDetector/InDetRawAlgs/InDetOverlay/python/TRTOverlayConfig.py b/InnerDetector/InDetRawAlgs/InDetOverlay/python/TRTOverlayConfig.py index 36ad37ea46ae60637742fd799ff96642eaf6cb89..a9e09ce928a477ae6a613c3d0137312f7781c3a3 100644 --- a/InnerDetector/InDetRawAlgs/InDetOverlay/python/TRTOverlayConfig.py +++ b/InnerDetector/InDetRawAlgs/InDetOverlay/python/TRTOverlayConfig.py @@ -120,9 +120,11 @@ def TRTOverlayCfg(flags): # Add TRT overlay digitization algorithm from TRT_Digitization.TRT_DigitizationConfigNew import TRT_OverlayDigitizationBasicCfg acc.merge(TRT_OverlayDigitizationBasicCfg(flags)) - # Add TRT overlay algorithm - acc.merge(TRTOverlayAlgCfg(flags)) - # Add TRT truth overlay - acc.merge(TRTTruthOverlayCfg(flags)) + #if track overlay, only run digitization on the HS input + if not flags.Overlay.doTrackOverlay: + # Add TRT overlay algorithm + acc.merge(TRTOverlayAlgCfg(flags)) + # Add TRT truth overlay + acc.merge(TRTTruthOverlayCfg(flags)) return acc diff --git a/Simulation/Overlay/OverlayConfiguration/python/OverlaySteering.py b/Simulation/Overlay/OverlayConfiguration/python/OverlaySteering.py index 08bafaff36a28cf30a1be35c230c78b58b336d2f..e83fc65feb1ef5fbbef2045b124780b4c6d8efd8 100644 --- a/Simulation/Overlay/OverlayConfiguration/python/OverlaySteering.py +++ b/Simulation/Overlay/OverlayConfiguration/python/OverlaySteering.py @@ -120,4 +120,18 @@ def OverlayMainContentCfg(configFlags): from PerfMonComps.PerfMonCompsConfig import PerfMonMTSvcCfg acc.merge(PerfMonMTSvcCfg(configFlags)) + #track overlay + if configFlags.Overlay.doTrackOverlay: + #need this to ensure that the ElementLinks to the PRDs are handled correctly (since the name is hardcoded in the converters) + from TrkEventCnvTools.TrkEventCnvToolsConfigCA import TrkEventCnvSuperToolCfg + acc.merge(TrkEventCnvSuperToolCfg(configFlags)) + from OverlayCopyAlgs.OverlayCopyAlgsConfig import CopyTrackCollectionsCfg,CopyDetailedTrackTruthCollectionsCfg,CopyPRD_MultiTruthCollectionsCfg, \ + CopyPixelClusterContainerCfg, CopySCT_ClusterContainerCfg, CopyTRT_DriftCircleContainerCfg + acc.merge(CopyTrackCollectionsCfg(configFlags)) + acc.merge(CopyDetailedTrackTruthCollectionsCfg(configFlags)) + acc.merge(CopyPRD_MultiTruthCollectionsCfg(configFlags)) + acc.merge(CopyPixelClusterContainerCfg(configFlags)) + acc.merge(CopySCT_ClusterContainerCfg(configFlags)) + acc.merge(CopyTRT_DriftCircleContainerCfg(configFlags)) + return acc diff --git a/Simulation/Overlay/OverlayConfiguration/share/skeleton_LegacyOverlay.py b/Simulation/Overlay/OverlayConfiguration/share/skeleton_LegacyOverlay.py index 790a4fc7122cfdcbc5579211ece341302f3f0d0c..6d8055267a692e4795e0325b2359bda6c5fbd72d 100644 --- a/Simulation/Overlay/OverlayConfiguration/share/skeleton_LegacyOverlay.py +++ b/Simulation/Overlay/OverlayConfiguration/share/skeleton_LegacyOverlay.py @@ -233,6 +233,9 @@ if (MuonGeometryFlags.hasCSC() and DetFlags.overlay.CSC_on()) or DetFlags.overla if DetFlags.overlay.LVL1_on(): include('EventOverlayJobTransforms/Level1Overlay_jobOptions.py') # noqa F821 +if overlayFlags.doTrackOverlay(): + include('EventOverlayJobTransforms/TrackOverlay_jobOptions.py') # noqa F821 + # Run calculation of weight for the beam spot size reweighting if digitizationFlags.doBeamSpotSizeReweighting() and digitizationFlags.OldBeamSpotZSize() > 0: include('Digitization/BeamSpotReweight.py') # noqa F821 diff --git a/Simulation/Overlay/OverlayCopyAlgs/CMakeLists.txt b/Simulation/Overlay/OverlayCopyAlgs/CMakeLists.txt index 99ca0db3b0a612758e40c9093bc99b06bbbafd82..722d177ed96b92153cbd974be4fd14cebdd4fd3f 100644 --- a/Simulation/Overlay/OverlayCopyAlgs/CMakeLists.txt +++ b/Simulation/Overlay/OverlayCopyAlgs/CMakeLists.txt @@ -11,7 +11,7 @@ atlas_add_component( OverlayCopyAlgs src/components/*.cxx LINK_LIBRARIES GaudiKernel AthenaBaseComps CaloSimEvent GeneratorObjects RecEvent - TrackRecordLib xAODJet xAODTruth xAODEventInfo ) + TrackRecordLib xAODJet xAODTruth xAODEventInfo TrkTrack TrkTruthData InDetPrepRawData InDetIdentifier) # Install files from the package: atlas_install_python_modules( python/*.py diff --git a/Simulation/Overlay/OverlayCopyAlgs/python/OverlayCopyAlgsConfig.py b/Simulation/Overlay/OverlayCopyAlgs/python/OverlayCopyAlgsConfig.py index bc2136a0c9952099dc72fc59e871ac8136fb51de..f0cca4777e3cc7d6f883a87b68b98abd586e1c2a 100644 --- a/Simulation/Overlay/OverlayCopyAlgs/python/OverlayCopyAlgsConfig.py +++ b/Simulation/Overlay/OverlayCopyAlgs/python/OverlayCopyAlgsConfig.py @@ -201,6 +201,97 @@ def CopyMcEventCollectionCfg(flags, name="CopyMcEventCollection", **kwargs): return acc +def CopyPixelClusterContainerAlgCfg(flags, **kwargs): + """Return a ComponentAccumulator for the CopyPixelClusterContainer algorithm""" + acc = ComponentAccumulator() + + kwargs.setdefault("InputKey","PixelClusters") + kwargs.setdefault("OutputKey",flags.Overlay.BkgPrefix+"PixelClusters") + + alg=CompFactory.CopyPixelClusterContainer("CopyPixelClusterContainer", **kwargs) + acc.addEventAlgo(alg) + + return acc + +def CopySCT_ClusterContainerAlgCfg(flags, **kwargs): + """Return a ComponentAccumulator for the CopySCT_ClusterContainer algorithm""" + acc = ComponentAccumulator() + + kwargs.setdefault("InputKey","SCT_Clusters") + kwargs.setdefault("OutputKey",flags.Overlay.BkgPrefix+"SCT_Clusters") + + alg=CompFactory.CopySCT_ClusterContainer("CopySCT_ClusterContainer", **kwargs) + acc.addEventAlgo(alg) + + return acc + +def CopyTRT_DriftCircleContainerAlgCfg(flags, **kwargs): + """Return a ComponentAccumulator for the CopyTRT_DriftCircleContainer algorithm""" + acc = ComponentAccumulator() + + kwargs.setdefault("InputKey","TRT_DriftCircles") + kwargs.setdefault("OutputKey",flags.Overlay.BkgPrefix+"TRT_DriftCircles") + + alg=CompFactory.CopyTRT_DriftCircleContainer("CopyTRT_DriftCircleContainer", **kwargs) + acc.addEventAlgo(alg) + + return acc + +def CopyTrackCollectionAlgCfg(flags, collectionName, **kwargs): + """Return a ComponentAccumulator for the TrackCollection copying""" + acc = ComponentAccumulator() + + kwargs.setdefault("OutputKey",flags.Overlay.BkgPrefix + collectionName) + kwargs.setdefault("InputKey", collectionName) + + alg = CompFactory.CopyTrackCollection("CopyTrackCollection"+collectionName) + acc.addEventAlgo(alg) + + if flags.Output.doWriteRDO: + from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg + acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[ + "TrackCollection#" + flags.Overlay.BkgPrefix+collectionName])) + + return acc + + +def CopyDetailedTrackTruthCollectionAlgCfg(flags, collectionName, **kwargs): + """Return a ComponentAccumulator for the DetailedTrackTruthCollection copying""" + acc = ComponentAccumulator() + + kwargs.setdefault("OutputKey",flags.Overlay.BkgPrefix + collectionName) + kwargs.setdefault("InputKey", collectionName) + + alg = CompFactory.CopyDetailedTrackTruthCollection("CopyDetailedTrackTruthCollection"+collectionName) + acc.addEventAlgo(alg) + + if flags.Output.doWriteRDO: + from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg + acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[ + "DetailedTrackTruthCollection#" + flags.Overlay.BkgPrefix+collectionName + ])) + + return acc + +def CopyPRD_MultiTruthCollectionAlgCfg(flags, collectionName, **kwargs): + """Return a ComponentAccumulator for the PRD_MultiTruthCollection copying""" + acc = ComponentAccumulator() + + kwargs.setdefault("OutputKey",flags.Overlay.BkgPrefix + collectionName) + kwargs.setdefault("InputKey", collectionName) + + alg = CompFactory.CopyPRD_MultiTruthCollection("CopyPRD_MultiTruthCollection"+collectionName) + acc.addEventAlgo(alg) + + if flags.Output.doWriteRDO: + from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg + acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[ + "PRD_MultiTruthCollection#" + flags.Overlay.BkgPrefix+collectionName + ])) + + return acc + + def CopyTimingsCfg(flags, name="CopyTimings", **kwargs): """Return a ComponentAccumulator for the CopyTimings algorithm""" acc = ComponentAccumulator() @@ -278,7 +369,6 @@ def CopyTrackRecordCollectionAlgCfg(flags, collectionName, name="CopyTrackRecord return acc - def CopyCaloCalibrationHitContainersCfg(flags, **kwargs): """Return overlay configuration for the CopyCalibrationHitContainer algorithms""" @@ -302,6 +392,41 @@ def CopyCaloCalibrationHitContainersCfg(flags, **kwargs): return acc +def CopyPixelClusterContainerCfg(flags, **kwargs): + """Return overlay configuration for the CopyPixelClusterContainer algorithm""" + + acc = CopyPixelClusterContainerAlgCfg(flags, **kwargs) + if flags.Output.doWriteRDO: + from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg + acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[ + "InDet::PixelClusterContainer#Bkg_PixelClusters" + ])) + + return acc + +def CopySCT_ClusterContainerCfg(flags, **kwargs): + """Return overlay configuration for the CopySCT_ClusterContainer algorithm""" + + acc = CopySCT_ClusterContainerAlgCfg(flags, **kwargs) + if flags.Output.doWriteRDO: + from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg + acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[ + "InDet::SCT_ClusterContainer#Bkg_SCT_Clusters" + ])) + + return acc + +def CopyTRT_DriftCircleContainerCfg(flags, **kwargs): + """Return overlay configuration for the CopyTRT_DriftCircleContainer algorithm""" + + acc = CopyTRT_DriftCircleContainerAlgCfg(flags, **kwargs) + if flags.Output.doWriteRDO: + from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg + acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[ + "InDet::TRT_DriftCircleContainer#Bkg_TRT_DriftCircles"])) + + return acc + def CopyTrackRecordCollectionsCfg(flags, **kwargs): """Return overlay configuration for the TrackRecordCollection algorithms""" @@ -325,3 +450,77 @@ def CopyTrackRecordCollectionsCfg(flags, **kwargs): acc.merge(CopyTrackRecordCollectionAlgCfg(flags, container, **kwargs)) return acc + +def CopyTrackCollectionsCfg(flags, **kwargs): + """ Return overlay configuration for copying tracks""" + + acc = ComponentAccumulator() + + allowedContainers = [ + "CombinedInDetTracks", + "DisappearingTracks", + "ResolvedForwardTracks", + "ResolvedLargeD0Tracks" + ] + + availableContainers = [] + + # Detect the list of track collections + for container in allowedContainers: + if (flags.Overlay.DataOverlay and container in flags.Input.Collections) \ + or (not flags.Overlay.DataOverlay and container in flags.Input.SecondaryCollections): + availableContainers.append(container) + + for container in availableContainers: + acc.merge(CopyTrackCollectionAlgCfg(flags, container, **kwargs)) + + return acc + +def CopyDetailedTrackTruthCollectionsCfg(flags, **kwargs): + """ Return overlay configuration for copying detailed track truth""" + + acc = ComponentAccumulator() + + allowedContainers = [ + "DisappearingTracksDetailedTruth", + "ResolvedForwardTracksDetailedTruth", + "CombinedInDetTracksDetailedTruth", + "ResolvedLargeD0TracksDetailedTruth" + ] + + availableContainers = [] + + # Detect the list of detailed track truth collections + for container in allowedContainers: + if (flags.Overlay.DataOverlay and container in flags.Input.Collections) \ + or (not flags.Overlay.DataOverlay and container in flags.Input.SecondaryCollections): + availableContainers.append(container) + + for container in availableContainers: + acc.merge(CopyDetailedTrackTruthCollectionAlgCfg(flags, container, **kwargs)) + + return acc + +def CopyPRD_MultiTruthCollectionsCfg(flags, **kwargs): + """ Return overlay configuration for copying detailed track truth""" + + acc = ComponentAccumulator() + + allowedContainers = [ + "PRD_MultiTruthTRT", + "PRD_MultiTruthPixel", + "PRD_MultiTruthSCT" + ] + + availableContainers = [] + + # Detect the list of detailed track truth collections + for container in allowedContainers: + if (flags.Overlay.DataOverlay and container in flags.Input.Collections) \ + or (not flags.Overlay.DataOverlay and container in flags.Input.SecondaryCollections): + availableContainers.append(container) + + for container in availableContainers: + acc.merge(CopyPRD_MultiTruthCollectionAlgCfg(flags, container, **kwargs)) + + return acc diff --git a/Simulation/Overlay/OverlayCopyAlgs/python/OverlayCopyAlgsConfigDb.py b/Simulation/Overlay/OverlayCopyAlgs/python/OverlayCopyAlgsConfigDb.py index 6e7089bc660632132427c6aa6b5b35195e7fbdd1..0274b046368b5265bb0c30504ce6a95f28f4ce0e 100644 --- a/Simulation/Overlay/OverlayCopyAlgs/python/OverlayCopyAlgsConfigDb.py +++ b/Simulation/Overlay/OverlayCopyAlgs/python/OverlayCopyAlgsConfigDb.py @@ -1,4 +1,4 @@ -# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration +# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration from AthenaCommon.CfgGetter import addAlgorithm @@ -11,3 +11,9 @@ addAlgorithm("OverlayCopyAlgs.OverlayCopyAlgsConfigLegacy.getCopyPileupParticleT addAlgorithm("OverlayCopyAlgs.OverlayCopyAlgsConfigLegacy.getCopyMcEventCollection", "CopyMcEventCollection") addAlgorithm("OverlayCopyAlgs.OverlayCopyAlgsConfigLegacy.getCopyTimings", "CopyTimings") addAlgorithm("OverlayCopyAlgs.OverlayCopyAlgsConfigLegacy.getCopyTrackRecordCollection", "CopyTrackRecordCollection") +addAlgorithm("OverlayCopyAlgs.OverlayCopyAlgsConfigLegacy.getCopyTrackCollection", "CopyTrackCollection") +addAlgorithm("OverlayCopyAlgs.OverlayCopyAlgsConfigLegacy.getCopyDetailedTrackTruthCollection", "CopyDetailedTrackTruthCollection") +addAlgorithm("OverlayCopyAlgs.OverlayCopyAlgsConfigLegacy.getCopyPRD_MultiTruthCollection", "CopyPRD_MultiTruthCollection") +addAlgorithm("OverlayCopyAlgs.OverlayCopyAlgsConfigLegacy.getCopyPixelClusterContainer", "CopyPixelClusterContainer") +addAlgorithm("OverlayCopyAlgs.OverlayCopyAlgsConfigLegacy.getCopySCT_ClusterContainer", "CopySCT_ClusterContainer") +addAlgorithm("OverlayCopyAlgs.OverlayCopyAlgsConfigLegacy.getCopyTRT_DriftCircleContainer", "CopyTRT_DriftCircleContainer") diff --git a/Simulation/Overlay/OverlayCopyAlgs/python/OverlayCopyAlgsConfigLegacy.py b/Simulation/Overlay/OverlayCopyAlgs/python/OverlayCopyAlgsConfigLegacy.py index e6b08a51783799f0b2f3f7860f0694e6820d0661..a7f517d6e3673647d2094f6cbb31a14d9f20820f 100644 --- a/Simulation/Overlay/OverlayCopyAlgs/python/OverlayCopyAlgsConfigLegacy.py +++ b/Simulation/Overlay/OverlayCopyAlgs/python/OverlayCopyAlgsConfigLegacy.py @@ -1,4 +1,4 @@ -# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration +# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration from AthenaCommon import CfgMgr from AthenaCommon.ConfiguredFactory import ConfigurationError @@ -142,3 +142,60 @@ def getCopyTrackRecordCollection(name, collectionName="", **kwargs): kwargs.setdefault("OutputKey", overlayFlags.outputStore() + "+" + collectionName) return CfgMgr.CopyTrackRecordCollection(name, **kwargs) + +def getCopyTrackCollection(name, collectionName="", **kwargs): + from OverlayCommonAlgs.OverlayFlags import overlayFlags + + if not collectionName: + raise ConfigurationError("'collectionName' should be set! Use `CfgGetter.getAlgorithmClone`") + + kwargs.setdefault("InputKey", collectionName) + kwargs.setdefault("OutputKey", overlayFlags.bkgPrefix() + collectionName) + + return CfgMgr.CopyTrackCollection(name, **kwargs) + +def getCopyDetailedTrackTruthCollection(name, collectionName="", **kwargs): + from OverlayCommonAlgs.OverlayFlags import overlayFlags + + if not collectionName: + raise ConfigurationError("'collectionName' should be set! Use `CfgGetter.getAlgorithmClone`") + + kwargs.setdefault("InputKey", collectionName) + kwargs.setdefault("OutputKey", overlayFlags.bkgPrefix() + collectionName) + + return CfgMgr.CopyDetailedTrackTruthCollection(name, **kwargs) + +def getCopyPRD_MultiTruthCollection(name, collectionName="", **kwargs): + from OverlayCommonAlgs.OverlayFlags import overlayFlags + + if not collectionName: + raise ConfigurationError("'collectionName' should be set! Use `CfgGetter.getAlgorithmClone`") + + kwargs.setdefault("InputKey", collectionName) + kwargs.setdefault("OutputKey", overlayFlags.bkgPrefix() + collectionName) + + return CfgMgr.CopyPRD_MultiTruthCollection(name, **kwargs) + +def getCopyPixelClusterContainer(name="CopyPixelClusterContainer", **kwargs): + from OverlayCommonAlgs.OverlayFlags import overlayFlags + + kwargs.setdefault("InputKey", "PixelClusters") + kwargs.setdefault("OutputKey", overlayFlags.bkgPrefix() + "PixelClusters") + + return CfgMgr.CopyPixelClusterContainer(name, **kwargs) + +def getCopySCT_ClusterContainer(name="CopySCT_ClusterContainer", **kwargs): + from OverlayCommonAlgs.OverlayFlags import overlayFlags + + kwargs.setdefault("InputKey", "SCT_Clusters") + kwargs.setdefault("OutputKey", overlayFlags.bkgPrefix() + "SCT_Clusters") + + return CfgMgr.CopySCT_ClusterContainer(name, **kwargs) + +def getCopyTRT_DriftCircleContainer(name="CopyTRT_DriftCircleContainer", **kwargs): + from OverlayCommonAlgs.OverlayFlags import overlayFlags + + kwargs.setdefault("InputKey", "TRT_DriftCircles") + kwargs.setdefault("OutputKey", overlayFlags.bkgPrefix() + "TRT_DriftCircles") + + return CfgMgr.CopyTRT_DriftCircleContainer(name, **kwargs) diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/CopyDetailedTrackTruthCollection.cxx b/Simulation/Overlay/OverlayCopyAlgs/src/CopyDetailedTrackTruthCollection.cxx new file mode 100644 index 0000000000000000000000000000000000000000..b2f318ba2a54381a912dbd8b321fb2d5866a3093 --- /dev/null +++ b/Simulation/Overlay/OverlayCopyAlgs/src/CopyDetailedTrackTruthCollection.cxx @@ -0,0 +1,50 @@ +/* + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration +*/ + +#include "CopyDetailedTrackTruthCollection.h" + + +CopyDetailedTrackTruthCollection::CopyDetailedTrackTruthCollection(const std::string &name, ISvcLocator *pSvcLocator) + : AthReentrantAlgorithm(name, pSvcLocator) { } + +StatusCode CopyDetailedTrackTruthCollection::initialize() +{ + ATH_MSG_DEBUG("Initializing..."); + + // Check and initialize keys + ATH_CHECK( m_inputKey.initialize() ); + ATH_MSG_VERBOSE("Initialized ReadHandleKey: " << m_inputKey); + ATH_CHECK( m_outputKey.initialize() ); + ATH_MSG_VERBOSE("Initialized WriteHandleKey: " << m_outputKey); + + return StatusCode::SUCCESS; +} + +StatusCode CopyDetailedTrackTruthCollection::execute(const EventContext& ctx) const +{ + ATH_MSG_DEBUG("execute() begin"); + // Reading the input container + ATH_MSG_VERBOSE("Retrieving input container"); + + SG::ReadHandle inputContainer(m_inputKey, ctx); + if (!inputContainer.isValid()) { + ATH_MSG_ERROR("Could not get pileup DetailedTrackTruthCollection " << inputContainer.name() << " from store " << inputContainer.store()); + return StatusCode::FAILURE; + } + ATH_MSG_DEBUG("Found pileup DetailedTrackTruthCollection " << inputContainer.name() << " in store " << inputContainer.store()); + + // Creating output RDO container + SG::WriteHandle outputContainer(m_outputKey, ctx); + ATH_CHECK(outputContainer.record(std::make_unique(inputContainer->trackCollectionLink()))); + if (!outputContainer.isValid()) { + ATH_MSG_ERROR("Could not record output DetailedTrackTruthCollection " << outputContainer.name() << " to store " << outputContainer.store()); + return StatusCode::FAILURE; + } + ATH_MSG_DEBUG("Recorded output DetailedTrackTruthCollection container " << outputContainer.name() << " in store " << outputContainer.store()); + + for(const std::pair& element : *inputContainer){ + outputContainer->insert(std::make_pair(element.first,element.second)); + } + return StatusCode::SUCCESS; +} diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/CopyDetailedTrackTruthCollection.h b/Simulation/Overlay/OverlayCopyAlgs/src/CopyDetailedTrackTruthCollection.h new file mode 100644 index 0000000000000000000000000000000000000000..4582014c423e22717a34e3852896178261ed50da --- /dev/null +++ b/Simulation/Overlay/OverlayCopyAlgs/src/CopyDetailedTrackTruthCollection.h @@ -0,0 +1,26 @@ +/* + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration +*/ + +#ifndef OVERLAYCOPYALGS_COPYDETAILEDTRACKTRUTHCOLLECTION_H +#define OVERLAYCOPYALGS_COPYDETAILEDTRACKTRUTHCOLLECTION_H + +#include "AthenaBaseComps/AthReentrantAlgorithm.h" +#include "TrkTruthData/DetailedTrackTruthCollection.h" + +class CopyDetailedTrackTruthCollection : public AthReentrantAlgorithm +{ +public: + + CopyDetailedTrackTruthCollection(const std::string &name, ISvcLocator *pSvcLocator); + + virtual StatusCode initialize() override; + virtual StatusCode execute(const EventContext& ctx) const override; + +private: + SG::ReadHandleKey m_inputKey{ this, "InputKey", "", "ReadHandleKey for Pileup DetailedTrackTruthCollection" }; + SG::WriteHandleKey m_outputKey{ this, "OutputKey", "", "WriteHandleKey for Output DetailedTrackTruthCollection" }; + +}; + +#endif // OVERLAYCOPYALGS_COPYDETAILEDTRACKTRUTHCOLLECTION_H diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/CopyPRD_MultiTruthCollection.cxx b/Simulation/Overlay/OverlayCopyAlgs/src/CopyPRD_MultiTruthCollection.cxx new file mode 100644 index 0000000000000000000000000000000000000000..b92b6423f3e2c16679e7f86980314f992019a201 --- /dev/null +++ b/Simulation/Overlay/OverlayCopyAlgs/src/CopyPRD_MultiTruthCollection.cxx @@ -0,0 +1,50 @@ +/* + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration +*/ + +#include "CopyPRD_MultiTruthCollection.h" + + +CopyPRD_MultiTruthCollection::CopyPRD_MultiTruthCollection(const std::string &name, ISvcLocator *pSvcLocator) + : AthReentrantAlgorithm(name, pSvcLocator) { } + +StatusCode CopyPRD_MultiTruthCollection::initialize() +{ + ATH_MSG_DEBUG("Initializing..."); + + // Check and initialize keys + ATH_CHECK( m_inputKey.initialize() ); + ATH_MSG_VERBOSE("Initialized ReadHandleKey: " << m_inputKey); + ATH_CHECK( m_outputKey.initialize() ); + ATH_MSG_VERBOSE("Initialized WriteHandleKey: " << m_outputKey); + + return StatusCode::SUCCESS; +} + +StatusCode CopyPRD_MultiTruthCollection::execute(const EventContext& ctx) const +{ + ATH_MSG_DEBUG("execute() begin"); + // Reading the input container + ATH_MSG_VERBOSE("Retrieving input container"); + + SG::ReadHandle inputContainer(m_inputKey, ctx); + if (!inputContainer.isValid()) { + ATH_MSG_ERROR("Could not get pileup PRD_MultiTruthCollection " << inputContainer.name() << " from store " << inputContainer.store()); + return StatusCode::FAILURE; + } + ATH_MSG_DEBUG("Found pileup PRD_MultiTruthCollection " << inputContainer.name() << " in store " << inputContainer.store()); + + // Creating output RDO container + SG::WriteHandle outputContainer(m_outputKey, ctx); + ATH_CHECK(outputContainer.record(std::make_unique())); + if (!outputContainer.isValid()) { + ATH_MSG_ERROR("Could not record output PRD_MultiTruthCollection " << outputContainer.name() << " to store " << outputContainer.store()); + return StatusCode::FAILURE; + } + ATH_MSG_DEBUG("Recorded output PRD_MultiTruthCollection container " << outputContainer.name() << " in store " << outputContainer.store()); + + for(const std::pair& element : *inputContainer){ + outputContainer->insert(std::make_pair(element.first,element.second)); + } + return StatusCode::SUCCESS; +} diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/CopyPRD_MultiTruthCollection.h b/Simulation/Overlay/OverlayCopyAlgs/src/CopyPRD_MultiTruthCollection.h new file mode 100644 index 0000000000000000000000000000000000000000..5f2fd83dfc1d3fdbf25e4a057aa13f16f1e71e0c --- /dev/null +++ b/Simulation/Overlay/OverlayCopyAlgs/src/CopyPRD_MultiTruthCollection.h @@ -0,0 +1,26 @@ +/* + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration +*/ + +#ifndef OVERLAYCOPYALGS_COPYPRDMULTITRUTHCOLLECTION_H +#define OVERLAYCOPYALGS_COPYPRDMULTITRUTHCOLLECTION_H + +#include "AthenaBaseComps/AthReentrantAlgorithm.h" +#include "TrkTruthData/PRD_MultiTruthCollection.h" + +class CopyPRD_MultiTruthCollection : public AthReentrantAlgorithm +{ +public: + + CopyPRD_MultiTruthCollection(const std::string &name, ISvcLocator *pSvcLocator); + + virtual StatusCode initialize() override; + virtual StatusCode execute(const EventContext& ctx) const override; + +private: + SG::ReadHandleKey m_inputKey{ this, "InputKey", "", "ReadHandleKey for Pileup PRD_MultiTruthCollection" }; + SG::WriteHandleKey m_outputKey{ this, "OutputKey", "", "WriteHandleKey for Output PRD_MultiTruthCollection" }; + +}; + +#endif // OVERLAYCOPYALGS_COPYPRDMULTITRUTHCOLLECTION_H diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/CopyPixelClusterContainer.cxx b/Simulation/Overlay/OverlayCopyAlgs/src/CopyPixelClusterContainer.cxx new file mode 100644 index 0000000000000000000000000000000000000000..f8f4b9dc105ad2d0a3f3a4b77b977d7aafe53ecd --- /dev/null +++ b/Simulation/Overlay/OverlayCopyAlgs/src/CopyPixelClusterContainer.cxx @@ -0,0 +1,58 @@ +/* + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration +*/ + +#include "CopyPixelClusterContainer.h" +#include "InDetPrepRawData/PixelClusterCollection.h" +#include "InDetPrepRawData/PixelCluster.h" +#include "InDetIdentifier/PixelID.h" + +CopyPixelClusterContainer::CopyPixelClusterContainer(const std::string &name, ISvcLocator *pSvcLocator) + : AthReentrantAlgorithm(name, pSvcLocator) { } + +StatusCode CopyPixelClusterContainer::initialize() +{ + ATH_MSG_DEBUG("Initializing..."); + + // Check and initialize keys + ATH_CHECK( m_inputKey.initialize() ); + ATH_MSG_VERBOSE("Initialized ReadHandleKey: " << m_inputKey); + ATH_CHECK( m_outputKey.initialize() ); + ATH_MSG_VERBOSE("Initialized WriteHandleKey: " << m_outputKey); + + ATH_CHECK(detStore()->retrieve(m_idHelper,"PixelID")); + + return StatusCode::SUCCESS; +} + +StatusCode CopyPixelClusterContainer::execute(const EventContext& ctx) const +{ + ATH_MSG_DEBUG("execute() begin"); + // Reading the input container + ATH_MSG_VERBOSE("Retrieving input container"); + + SG::ReadHandle inputContainer(m_inputKey, ctx); + if (!inputContainer.isValid()) { + ATH_MSG_ERROR("Could not get pileup PixelClusterContainer " << inputContainer.name() << " from store " << inputContainer.store()); + return StatusCode::FAILURE; + } + ATH_MSG_DEBUG("Found pileup PixelClusterContainer " << inputContainer.name() << " in store " << inputContainer.store()); + + // Creating output RDO container + SG::WriteHandle outputContainer(m_outputKey, ctx); + ATH_CHECK(outputContainer.record(std::make_unique(m_idHelper->wafer_hash_max()))); + if (!outputContainer.isValid()) { + ATH_MSG_ERROR("Could not record output PixelClusterContainer " << outputContainer.name() << " to store " << outputContainer.store()); + return StatusCode::FAILURE; + } + ATH_MSG_DEBUG("Recorded output PixelClusterContainer container " << outputContainer.name() << " in store " << outputContainer.store()); + + for(const InDet::PixelClusterCollection* col : *inputContainer){ + InDet::PixelClusterCollection* newCol=new InDet::PixelClusterCollection(col->identifyHash()); + for(const InDet::PixelCluster* clus : *col){ + newCol->push_back(std::make_unique(*clus)); + } + ATH_CHECK(outputContainer->addCollection(newCol,newCol->identifyHash())); + } + return StatusCode::SUCCESS; +} diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/CopyPixelClusterContainer.h b/Simulation/Overlay/OverlayCopyAlgs/src/CopyPixelClusterContainer.h new file mode 100644 index 0000000000000000000000000000000000000000..7be08f70340ed18e6fc6c6b27b7a37680a3db0e2 --- /dev/null +++ b/Simulation/Overlay/OverlayCopyAlgs/src/CopyPixelClusterContainer.h @@ -0,0 +1,30 @@ +/* + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration +*/ + +#ifndef OVERLAYCOPYALGS_COPYPIXELCLUSTERCONTAINER_H +#define OVERLAYCOPYALGS_COPYPIXELCLUSTERCONTAINER_H + +#include "AthenaBaseComps/AthReentrantAlgorithm.h" +#include "InDetPrepRawData/PixelClusterContainer.h" + +class PixelID; + +class CopyPixelClusterContainer : public AthReentrantAlgorithm +{ +public: + + CopyPixelClusterContainer(const std::string &name, ISvcLocator *pSvcLocator); + + virtual StatusCode initialize() override; + virtual StatusCode execute(const EventContext& ctx) const override; + +private: + SG::ReadHandleKey m_inputKey{ this, "InputKey", "", "ReadHandleKey for Pileup PixelClusterContainer" }; + SG::WriteHandleKey m_outputKey{ this, "OutputKey", "", "WriteHandleKey for Output PixelClusterContainer" }; + + const PixelID* m_idHelper; + +}; + +#endif // OVERLAYCOPYALGS_COPYPIXELCLUSTERCONTAINER_H diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/CopySCT_ClusterContainer.cxx b/Simulation/Overlay/OverlayCopyAlgs/src/CopySCT_ClusterContainer.cxx new file mode 100644 index 0000000000000000000000000000000000000000..8df7b795de6c559a6464ceeb61db8b28b60a707d --- /dev/null +++ b/Simulation/Overlay/OverlayCopyAlgs/src/CopySCT_ClusterContainer.cxx @@ -0,0 +1,58 @@ +/* + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration +*/ + +#include "CopySCT_ClusterContainer.h" +#include "InDetPrepRawData/SCT_ClusterCollection.h" +#include "InDetPrepRawData/SCT_Cluster.h" +#include "InDetIdentifier/SCT_ID.h" + +CopySCT_ClusterContainer::CopySCT_ClusterContainer(const std::string &name, ISvcLocator *pSvcLocator) + : AthReentrantAlgorithm(name, pSvcLocator) { } + +StatusCode CopySCT_ClusterContainer::initialize() +{ + ATH_MSG_DEBUG("Initializing..."); + + // Check and initialize keys + ATH_CHECK( m_inputKey.initialize() ); + ATH_MSG_VERBOSE("Initialized ReadHandleKey: " << m_inputKey); + ATH_CHECK( m_outputKey.initialize() ); + ATH_MSG_VERBOSE("Initialized WriteHandleKey: " << m_outputKey); + + ATH_CHECK(detStore()->retrieve(m_idHelper,"SCT_ID")); + + return StatusCode::SUCCESS; +} + +StatusCode CopySCT_ClusterContainer::execute(const EventContext& ctx) const +{ + ATH_MSG_DEBUG("execute() begin"); + // Reading the input container + ATH_MSG_VERBOSE("Retrieving input container"); + + SG::ReadHandle inputContainer(m_inputKey, ctx); + if (!inputContainer.isValid()) { + ATH_MSG_ERROR("Could not get pileup SCT_ClusterContainer " << inputContainer.name() << " from store " << inputContainer.store()); + return StatusCode::FAILURE; + } + ATH_MSG_DEBUG("Found pileup SCT_ClusterContainer " << inputContainer.name() << " in store " << inputContainer.store()); + + // Creating output RDO container + SG::WriteHandle outputContainer(m_outputKey, ctx); + ATH_CHECK(outputContainer.record(std::make_unique(m_idHelper->wafer_hash_max()))); + if (!outputContainer.isValid()) { + ATH_MSG_ERROR("Could not record output SCT_ClusterContainer " << outputContainer.name() << " to store " << outputContainer.store()); + return StatusCode::FAILURE; + } + ATH_MSG_DEBUG("Recorded output SCT_ClusterContainer container " << outputContainer.name() << " in store " << outputContainer.store()); + + for(const InDet::SCT_ClusterCollection* col : *inputContainer){ + InDet::SCT_ClusterCollection* newCol=new InDet::SCT_ClusterCollection(col->identifyHash()); + for(const InDet::SCT_Cluster* clus : *col){ + newCol->push_back(std::make_unique(*clus)); + } + ATH_CHECK(outputContainer->addCollection(newCol,newCol->identifyHash())); + } + return StatusCode::SUCCESS; +} diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/CopySCT_ClusterContainer.h b/Simulation/Overlay/OverlayCopyAlgs/src/CopySCT_ClusterContainer.h new file mode 100644 index 0000000000000000000000000000000000000000..ccddcdb729000cfcc91a72e2c25ecdf74d202970 --- /dev/null +++ b/Simulation/Overlay/OverlayCopyAlgs/src/CopySCT_ClusterContainer.h @@ -0,0 +1,30 @@ +/* + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration +*/ + +#ifndef OVERLAYCOPYALGS_COPYSCTCLUSTERCONTAINER_H +#define OVERLAYCOPYALGS_COPYSCTCLUSTERCONTAINER_H + +#include "AthenaBaseComps/AthReentrantAlgorithm.h" +#include "InDetPrepRawData/SCT_ClusterContainer.h" + +class SCT_ID; + +class CopySCT_ClusterContainer : public AthReentrantAlgorithm +{ +public: + + CopySCT_ClusterContainer(const std::string &name, ISvcLocator *pSvcLocator); + + virtual StatusCode initialize() override; + virtual StatusCode execute(const EventContext& ctx) const override; + +private: + SG::ReadHandleKey m_inputKey{ this, "InputKey", "", "ReadHandleKey for Pileup SCT_ClusterContainer" }; + SG::WriteHandleKey m_outputKey{ this, "OutputKey", "", "WriteHandleKey for Output SCT_ClusterContainer" }; + + const SCT_ID* m_idHelper; + +}; + +#endif // OVERLAYCOPYALGS_COPYSCTCLUSTERCONTAINER_H diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/CopyTRT_DriftCircleContainer.cxx b/Simulation/Overlay/OverlayCopyAlgs/src/CopyTRT_DriftCircleContainer.cxx new file mode 100644 index 0000000000000000000000000000000000000000..d55af37d2d50cef7ad5c41151c1027da1e917aa5 --- /dev/null +++ b/Simulation/Overlay/OverlayCopyAlgs/src/CopyTRT_DriftCircleContainer.cxx @@ -0,0 +1,58 @@ +/* + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration +*/ + +#include "CopyTRT_DriftCircleContainer.h" +#include "InDetPrepRawData/TRT_DriftCircleCollection.h" +#include "InDetPrepRawData/TRT_DriftCircle.h" +#include "InDetIdentifier/TRT_ID.h" + +CopyTRT_DriftCircleContainer::CopyTRT_DriftCircleContainer(const std::string &name, ISvcLocator *pSvcLocator) + : AthReentrantAlgorithm(name, pSvcLocator) { } + +StatusCode CopyTRT_DriftCircleContainer::initialize() +{ + ATH_MSG_DEBUG("Initializing..."); + + // Check and initialize keys + ATH_CHECK( m_inputKey.initialize() ); + ATH_MSG_VERBOSE("Initialized ReadHandleKey: " << m_inputKey); + ATH_CHECK( m_outputKey.initialize() ); + ATH_MSG_VERBOSE("Initialized WriteHandleKey: " << m_outputKey); + + ATH_CHECK(detStore()->retrieve(m_idHelper,"TRT_ID")); + + return StatusCode::SUCCESS; +} + +StatusCode CopyTRT_DriftCircleContainer::execute(const EventContext& ctx) const +{ + ATH_MSG_DEBUG("execute() begin"); + // Reading the input container + ATH_MSG_VERBOSE("Retrieving input container"); + + SG::ReadHandle inputContainer(m_inputKey, ctx); + if (!inputContainer.isValid()) { + ATH_MSG_ERROR("Could not get pileup TRT_DriftCircleContainer " << inputContainer.name() << " from store " << inputContainer.store()); + return StatusCode::FAILURE; + } + ATH_MSG_DEBUG("Found pileup TRT_DriftCircleContainer " << inputContainer.name() << " in store " << inputContainer.store()); + + // Creating output RDO container + SG::WriteHandle outputContainer(m_outputKey, ctx); + ATH_CHECK(outputContainer.record(std::make_unique(m_idHelper->straw_layer_hash_max()))); + if (!outputContainer.isValid()) { + ATH_MSG_ERROR("Could not record output TRT_DriftCircleContainer " << outputContainer.name() << " to store " << outputContainer.store()); + return StatusCode::FAILURE; + } + ATH_MSG_DEBUG("Recorded output TRT_DriftCircleContainer container " << outputContainer.name() << " in store " << outputContainer.store()); + + for(const InDet::TRT_DriftCircleCollection* col : *inputContainer){ + InDet::TRT_DriftCircleCollection* newCol=new InDet::TRT_DriftCircleCollection(col->identifyHash()); + for(const InDet::TRT_DriftCircle* clus : *col){ + newCol->push_back(std::make_unique(*clus)); + } + ATH_CHECK(outputContainer->addCollection(newCol,newCol->identifyHash())); + } + return StatusCode::SUCCESS; +} diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/CopyTRT_DriftCircleContainer.h b/Simulation/Overlay/OverlayCopyAlgs/src/CopyTRT_DriftCircleContainer.h new file mode 100644 index 0000000000000000000000000000000000000000..c67fad5560dc638a5593c998be57efbc60dd8e69 --- /dev/null +++ b/Simulation/Overlay/OverlayCopyAlgs/src/CopyTRT_DriftCircleContainer.h @@ -0,0 +1,30 @@ +/* + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration +*/ + +#ifndef OVERLAYCOPYALGS_COPYTRTDRIFTCIRCLECONTAINER_H +#define OVERLAYCOPYALGS_COPYTRTDRIFTCIRCLECONTAINER_H + +#include "AthenaBaseComps/AthReentrantAlgorithm.h" +#include "InDetPrepRawData/TRT_DriftCircleContainer.h" + +class TRT_ID; + +class CopyTRT_DriftCircleContainer : public AthReentrantAlgorithm +{ +public: + + CopyTRT_DriftCircleContainer(const std::string &name, ISvcLocator *pSvcLocator); + + virtual StatusCode initialize() override; + virtual StatusCode execute(const EventContext& ctx) const override; + +private: + SG::ReadHandleKey m_inputKey{ this, "InputKey", "", "ReadHandleKey for Pileup TRT_DriftCircleContainer" }; + SG::WriteHandleKey m_outputKey{ this, "OutputKey", "", "WriteHandleKey for Output TRT_DriftCircleContainer" }; + + const TRT_ID* m_idHelper; + +}; + +#endif // OVERLAYCOPYALGS_COPYTRTDRIFTCIRCLECONTAINER_H diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/CopyTrackCollection.cxx b/Simulation/Overlay/OverlayCopyAlgs/src/CopyTrackCollection.cxx new file mode 100644 index 0000000000000000000000000000000000000000..060c671b2e447ff9184a99af71aba5efde448812 --- /dev/null +++ b/Simulation/Overlay/OverlayCopyAlgs/src/CopyTrackCollection.cxx @@ -0,0 +1,53 @@ +/* + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration +*/ + +#include "CopyTrackCollection.h" + + +CopyTrackCollection::CopyTrackCollection(const std::string &name, ISvcLocator *pSvcLocator) + : AthReentrantAlgorithm(name, pSvcLocator) { } + +StatusCode CopyTrackCollection::initialize() +{ + ATH_MSG_DEBUG("Initializing..."); + + // Check and initialize keys + ATH_CHECK( m_inputKey.initialize() ); + ATH_MSG_VERBOSE("Initialized ReadHandleKey: " << m_inputKey); + ATH_CHECK( m_outputKey.initialize() ); + ATH_MSG_VERBOSE("Initialized WriteHandleKey: " << m_outputKey); + + return StatusCode::SUCCESS; +} + +StatusCode CopyTrackCollection::execute(const EventContext& ctx) const +{ + ATH_MSG_DEBUG("execute() begin"); + // Reading the input container + ATH_MSG_VERBOSE("Retrieving input container"); + + SG::ReadHandle inputContainer(m_inputKey, ctx); + if (!inputContainer.isValid()) { + ATH_MSG_ERROR("Could not get pileup TrackCollection " << inputContainer.name() << " from store " << inputContainer.store()); + return StatusCode::FAILURE; + } + ATH_MSG_DEBUG("Found pileup TrackCollection " << inputContainer.name() << " in store " << inputContainer.store()); + + // Creating output container + SG::WriteHandle outputContainer(m_outputKey, ctx); + ATH_CHECK(outputContainer.record(std::make_unique())); + if (!outputContainer.isValid()) { + ATH_MSG_ERROR("Could not record output TrackCollection " << outputContainer.name() << " to store " << outputContainer.store()); + return StatusCode::FAILURE; + } + ATH_MSG_DEBUG("Recorded output TrackCollection container " << outputContainer.name() << " in store " << outputContainer.store()); + + // Copy pileup tracks + for (const Trk::Track* track : *inputContainer) { + outputContainer->push_back(new Trk::Track(*track)); + } + + ATH_MSG_DEBUG("execute() end"); + return StatusCode::SUCCESS; +} diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/CopyTrackCollection.h b/Simulation/Overlay/OverlayCopyAlgs/src/CopyTrackCollection.h new file mode 100644 index 0000000000000000000000000000000000000000..a2c4971ab4459e85b48fd58f8b9ddc8b0d34ad52 --- /dev/null +++ b/Simulation/Overlay/OverlayCopyAlgs/src/CopyTrackCollection.h @@ -0,0 +1,26 @@ +/* + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration +*/ + +#ifndef OVERLAYCOPYALGS_COPYTRACKCOLLECTION_H +#define OVERLAYCOPYALGS_COPYTRACKCOLLECTION_H + +#include "AthenaBaseComps/AthReentrantAlgorithm.h" +#include "TrkTrack/TrackCollection.h" + +class CopyTrackCollection : public AthReentrantAlgorithm +{ +public: + + CopyTrackCollection(const std::string &name, ISvcLocator *pSvcLocator); + + virtual StatusCode initialize() override; + virtual StatusCode execute(const EventContext& ctx) const override; + +private: + SG::ReadHandleKey m_inputKey{ this, "InputKey", "", "ReadHandleKey for Pileup TrackCollection" }; + SG::WriteHandleKey m_outputKey{ this, "OutputKey", "", "WriteHandleKey for Output TrackCollection" }; + +}; + +#endif // OVERLAYCOPYALGS_COPYTRACKCOLLECTION_H diff --git a/Simulation/Overlay/OverlayCopyAlgs/src/components/OverlayCopyAlgs_entries.cxx b/Simulation/Overlay/OverlayCopyAlgs/src/components/OverlayCopyAlgs_entries.cxx index 0b48ce349eb6a35dd40aefeab6ebae22418bdd81..958af92ae0bc2da76c976ae978ded606d68919f5 100644 --- a/Simulation/Overlay/OverlayCopyAlgs/src/components/OverlayCopyAlgs_entries.cxx +++ b/Simulation/Overlay/OverlayCopyAlgs/src/components/OverlayCopyAlgs_entries.cxx @@ -4,6 +4,12 @@ #include "../CopyMcEventCollection.h" #include "../CopyTimings.h" #include "../CopyTrackRecordCollection.h" +#include "../CopyTrackCollection.h" +#include "../CopyDetailedTrackTruthCollection.h" +#include "../CopyPRD_MultiTruthCollection.h" +#include "../CopyPixelClusterContainer.h" +#include "../CopySCT_ClusterContainer.h" +#include "../CopyTRT_DriftCircleContainer.h" DECLARE_COMPONENT( CopyCaloCalibrationHitContainer ) DECLARE_COMPONENT( CopyJetTruthInfo ) @@ -11,3 +17,9 @@ DECLARE_COMPONENT( CopyPileupParticleTruthInfo ) DECLARE_COMPONENT( CopyMcEventCollection ) DECLARE_COMPONENT( CopyTimings ) DECLARE_COMPONENT( CopyTrackRecordCollection ) +DECLARE_COMPONENT( CopyPixelClusterContainer ) +DECLARE_COMPONENT( CopySCT_ClusterContainer ) +DECLARE_COMPONENT( CopyTRT_DriftCircleContainer ) +DECLARE_COMPONENT( CopyTrackCollection ) +DECLARE_COMPONENT( CopyDetailedTrackTruthCollection ) +DECLARE_COMPONENT( CopyPRD_MultiTruthCollection ) diff --git a/Tracking/TrkEventCnv/TrkEventCnvTools/python/TrkEventCnvToolsConfigCA.py b/Tracking/TrkEventCnv/TrkEventCnvTools/python/TrkEventCnvToolsConfigCA.py index 556b4c06091ee5a9e23801dbdd2d716cc741cacc..e4834ef0ce7708d4f3c47dcb5afd233b71747208 100644 --- a/Tracking/TrkEventCnv/TrkEventCnvTools/python/TrkEventCnvToolsConfigCA.py +++ b/Tracking/TrkEventCnv/TrkEventCnvTools/python/TrkEventCnvToolsConfigCA.py @@ -2,6 +2,7 @@ from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator from AthenaConfiguration.ComponentFactory import CompFactory +from AthenaConfiguration.Enums import ProductionStep def TrkEventCnvSuperToolCfg(flags): @@ -12,5 +13,7 @@ def TrkEventCnvSuperToolCfg(flags): DoID=flags.Reco.EnableTracking, DoMuons=flags.Detector.EnableMuon, ) + if flags.Common.ProductionStep == ProductionStep.Overlay and flags.Overlay.TrackOverlay: + EventCnvSuperTool.doTrackOverlay=True acc.addPublicTool(EventCnvSuperTool) return acc