Merge branch 'DoNotCreateViews' into 'main'

Do not create views at offline level but only RoIs

See merge request atlas/athena!70023

InnerDetector/InDetConfig/python/SiliconPreProcessing.py

@@ -115,9 +115,9 @@ def ITkRecPreProcessingSiliconCfg(flags):
         
     if flags.Tracking.ActiveConfig.doActsCluster:
         # If ACTS clusterization is activated, then schedule RoI creator
-        from ActsConfig.ActsViewConfig import ActsEventViewCreatorAlgCfg
-        acc.merge(ActsEventViewCreatorAlgCfg(flags,
-                                             name=f"{flags.Tracking.ActiveConfig.extension}EventViewCreatorAlg"))
+        from ActsConfig.ActsRegionsOfInterestConfig import ActsRegionsOfInterestCreatorAlgCfg
+        acc.merge(ActsRegionsOfInterestCreatorAlgCfg(flags,
+                                                     name=f"{flags.Tracking.ActiveConfig.extension}RegionsOfInterestCreatorAlg"))
 
         from ActsConfig.ActsClusterizationConfig import ActsClusterizationCfg
         acc.merge(ActsClusterizationCfg(flags))

InnerDetector/InDetValidation/InDetPhysValMonitoring/test/test_run4_acts_ttbar_PU200.sh

@@ -43,7 +43,7 @@ run "Reconstruction" \
     --outputAODFile AOD.root \
     --steering doRAWtoALL \
     --preInclude "InDetConfig.ConfigurationHelpers.OnlyTrackingPreInclude" \
-    --postInclude "ActsConfig.ActsViewConfig.ActsGlobalEventViewCreatorAlgCfg,ActsConfig.ActsClusterizationConfig.ActsMainClusterizationCfg,ActsConfig.ActsSpacePointFormationConfig.ActsMainSpacePointFormationCfg,ActsConfig.ActsPostIncludes.PersistifyActsEDMCfg" \
+    --postInclude "ActsConfig.ActsRegionsOfInterestConfig.ActsMainRegionsOfInterestCreatorAlgCfg,ActsConfig.ActsClusterizationConfig.ActsMainClusterizationCfg,ActsConfig.ActsSpacePointFormationConfig.ActsMainSpacePointFormationCfg,ActsConfig.ActsPostIncludes.PersistifyActsEDMCfg" \
     --preExec "flags.Reco.EnableHGTDExtension=False;flags.Acts.EDM.PersistifyClusters=True;flags.Acts.EDM.PersistifySpacePoints=True;" \
     --ignorePatterns "${ignore_pattern}" \
     --maxEvents 20 \

Tracking/Acts/ActsConfig/python/ActsClusterizationConfig.py

@@ -67,7 +67,7 @@ def ActsPixelClusterizationAlgCfg(flags,
     kwargs.setdefault("RDOContainerKey", "ITkPixelRDOs")
     kwargs.setdefault("ClustersKey", "ITkPixelClusters")
     # Regional selection
-    kwargs.setdefault('RoIs', 'OfflineFullScanRegion')
+    kwargs.setdefault('RoIs', 'ActsRegionOfInterest')
 
     kwargs.setdefault('EnableCache', flags.Acts.useCache)
     kwargs.setdefault('ClusterCacheBackend', 'ActsPixelClusterCache_Back')
@@ -97,7 +97,7 @@ def ActsStripClusterizationAlgCfg(flags,
     kwargs.setdefault("expectedClustersPerRDO", 6)
     kwargs.setdefault("IDHelper", "SCT_ID")
     # Regional selection
-    kwargs.setdefault('RoIs', 'OfflineFullScanRegion')
+    kwargs.setdefault('RoIs', 'ActsRegionOfInterest')
 
     kwargs.setdefault('EnableCache', flags.Acts.useCache)
     kwargs.setdefault('ClusterCacheBackend', 'ActsStripClusterCache_Back')
@@ -132,7 +132,7 @@ def ActsPixelClustersViewFillerAlgCfg(flags,
     acc = ComponentAccumulator()
     kwargs.setdefault("InputIDC", "ActsPixelClustersCache")
     kwargs.setdefault("Output", "ITkPixelClusters_InView")
-    kwargs.setdefault('RoIs', 'OfflineFullScanRegion')
+    kwargs.setdefault('RoIs', 'ActsRegionOfInterest')
 
     if 'RegSelTool' not in kwargs:
         from RegionSelector.RegSelToolConfig import regSelTool_ITkPixel_Cfg
@@ -147,7 +147,7 @@ def ActsStripClustersViewFillerAlgCfg(flags,
     acc = ComponentAccumulator()
     kwargs.setdefault("InputIDC", "ActsStripClustersCache")
     kwargs.setdefault("Output", "ITkStripClusters_InView")
-    kwargs.setdefault('RoIs', 'OfflineFullScanRegion')
+    kwargs.setdefault('RoIs', 'ActsRegionOfInterest')
 
     if 'RegSelTool' not in kwargs:
         from RegionSelector.RegSelToolConfig import regSelTool_ITkStrip_Cfg
@@ -157,22 +157,27 @@ def ActsStripClustersViewFillerAlgCfg(flags,
     return acc
 
 
-def ActsMainClusterizationCfg(flags) -> ComponentAccumulator:
+def ActsMainClusterizationCfg(flags,
+                              RoIs: str = "ActsRegionOfInterest") -> ComponentAccumulator:
     acc = ComponentAccumulator()
 
     if flags.Acts.useCache:
         acc.merge(ActsClusterCacheCreatorAlgCfg(flags))
 
     if flags.Detector.EnableITkPixel:
-        acc.merge(ActsPixelClusterizationAlgCfg(flags))
+        acc.merge(ActsPixelClusterizationAlgCfg(flags,
+                                                RoIs=RoIs))
     if flags.Detector.EnableITkStrip:
-        acc.merge(ActsStripClusterizationAlgCfg(flags))
+        acc.merge(ActsStripClusterizationAlgCfg(flags,
+                                                RoIs=RoIs))
 
     if flags.Acts.useCache:
         if flags.Detector.EnableITkPixel:
-            acc.merge(ActsPixelClustersViewFillerAlgCfg(flags))
+            acc.merge(ActsPixelClustersViewFillerAlgCfg(flags,
+                                                        RoIs=RoIs))
         if flags.Detector.EnableITkStrip:
-            acc.merge(ActsStripClustersViewFillerAlgCfg(flags))
+            acc.merge(ActsStripClustersViewFillerAlgCfg(flags,
+                                                        RoIs=RoIs))
             
     # Analysis extensions
     if flags.Acts.doAnalysis:
@@ -193,14 +198,14 @@ def ActsConversionClusterizationCfg(flags) -> ComponentAccumulator:
                                                 name="ActsConversionStripClusterizationAlg",
                                                 ClustersKey="ITkConversionStripClusters",
                                                 EnableCache=False,
-                                                RoIs="OfflineCaloBasedRegion"))
+                                                RoIs="ActsConversionRegionOfInterest"))
 
     if flags.Acts.useCache:
         if flags.Detector.EnableITkStrip:
             acc.merge(ActsStripClustersViewFillerAlgCfg(flags,
                                                         name="ActsConversionStripClustersViewFiller",
                                                         Output="ITkConversionStripClusters_InView",
-                                                        RoIs="OfflineCaloBasedRegion"))
+                                                        RoIs="ActsConversionRegionOfInterest"))
     
     # Analysis extensions
     if flags.Acts.doAnalysis:
@@ -225,6 +230,7 @@ def ActsClusterizationCfg(flags) -> ComponentAccumulator:
         acc.merge(ActsConversionClusterizationCfg(flags))
     # Any other pass -> Validation mainly
     else:
-        acc.merge(ActsMainClusterizationCfg(flags))
+        acc.merge(ActsMainClusterizationCfg(flags,
+                                            RoIs = f"{flags.Tracking.ActiveConfig.extension}RegionOfInterest"))
 
     return acc

Tracking/Acts/ActsConfig/python/ActsViewConfig.py → Tracking/Acts/ActsConfig/python/ActsRegionsOfInterestConfig.py

@@ -7,57 +7,46 @@ def ActsFullScanRoICreatorToolCfg(flags,
                                   name: str = "ActsFullScanRoICreatorTool",
                                   **kwargs) -> ComponentAccumulator:
     acc = ComponentAccumulator()
-    kwargs.setdefault('RoIs', 'OfflineFullScanRegion')
-    acc.setPrivateTools(CompFactory.FullScanRoICreatorTool(name, **kwargs))
+    acc.setPrivateTools(CompFactory.ActsTrk.FullScanRoICreatorTool(name, **kwargs))
     return acc
 
-def ActsConversionRoICreatorToolCfg(flags,
-                                    name : str = "ActsConversionRoICreatorTool",
-                                    **kwargs) -> ComponentAccumulator:
+def CaloBasedRoICreatorToolCfg(flags,
+                               name : str = "ActsCaloBasedRoICreatorTool",
+                               **kwargs) -> ComponentAccumulator:
     acc = ComponentAccumulator()
-    kwargs.setdefault('RoIs', 'OfflineCaloBasedRegion')
     kwargs.setdefault('CaloClusterRoIContainer', 'ITkCaloClusterROIPhiRZ15GeVUnordered')
-    acc.setPrivateTools(CompFactory.CaloBasedRoICreatorTool(name, **kwargs))
+    acc.setPrivateTools(CompFactory.ActsTrk.CaloBasedRoICreatorTool(name, **kwargs))
     return acc
 
-def ActsGlobalEventViewCreatorAlgCfg(flags,
-                                     name: str = "ActsGlobalEventViewCreatorAlg",
-                                     **kwargs) -> ComponentAccumulator:
+def ActsMainRegionsOfInterestCreatorAlgCfg(flags,
+                                           name: str = "ActsMainRegionsOfInterestCreatorAlg",
+                                           **kwargs) -> ComponentAccumulator:
     acc = ComponentAccumulator()
+    
     if 'RoICreatorTool' not in kwargs:
         kwargs.setdefault('RoICreatorTool', acc.popToolsAndMerge(ActsFullScanRoICreatorToolCfg(flags)))
 
-    kwargs.setdefault('Views', 'OfflineFullScanEventView')
-    kwargs.setdefault('InViewRoIs', 'OfflineFullScanInViewRegion')
-    acc.addEventAlgo(CompFactory.EventViewCreatorAlg(name, **kwargs))
+    kwargs.setdefault('RoIs', 'ActsRegionOfInterest')
+    acc.addEventAlgo(CompFactory.ActsTrk.RegionsOfInterestCreatorAlg(name, **kwargs))    
     return acc
 
-def ActsCaloBasedEventViewCreatorAlgCfg(flags,
-                                        name: str = "ActsCaloBasedEventViewCreatorAlg",
-                                        **kwargs) -> ComponentAccumulator:
+def ActsRegionsOfInterestCreatorAlgCfg(flags,
+                                       name: str = "ActsRegionsOfInterestCreatorAlg",
+                                       **kwargs) -> ComponentAccumulator:
     acc = ComponentAccumulator()
-    if 'RoICreatorTool' not in kwargs:
-         kwargs.setdefault('RoICreatorTool', acc.popToolsAndMerge(ActsConversionRoICreatorToolCfg(flags)))
-
-    kwargs.setdefault('Views', 'OfflineCaloBasedEventView')
-    kwargs.setdefault('InViewRoIs', 'OfflineCaloBasedInViewRegion')
-    acc.addEventAlgo(CompFactory.EventViewCreatorAlg(name, **kwargs))
-    return acc
 
-def ActsEventViewCreatorAlgCfg(flags,
-                               name: str = "ActsEventViewCreatorAlg",
-                               **kwargs) -> ComponentAccumulator:
-    acc = ComponentAccumulator()
-    # Acts main pass
-    if flags.Tracking.ActiveConfig.extension == "Acts":
-        acc.merge(ActsGlobalEventViewCreatorAlgCfg(flags, name, **kwargs))
-    # Acts conversion pass
-    elif flags.Tracking.ActiveConfig.extension == "ActsConversion":
+    # Conversion tracking pass requirements
+    if flags.Tracking.ActiveConfig.extension == "ActsConversion":
         from InDetConfig.InDetCaloClusterROISelectorConfig import ITkCaloClusterROIPhiRZContainerMakerCfg
         acc.merge(ITkCaloClusterROIPhiRZContainerMakerCfg(flags))
-        acc.merge(ActsCaloBasedEventViewCreatorAlgCfg(flags, name, **kwargs))
-    # Any other Acts pass, that means validation passes
-    else:
-        acc.merge(ActsGlobalEventViewCreatorAlgCfg(flags, name, **kwargs))
 
+    # Set proper RoI creation tool
+    if 'RoICreatorTool' not in kwargs:
+        if flags.Tracking.ActiveConfig.extension == "ActsConversion":
+            kwargs.setdefault('RoICreatorTool', acc.popToolsAndMerge(CaloBasedRoICreatorToolCfg(flags)))
+        else:
+            kwargs.setdefault('RoICreatorTool', acc.popToolsAndMerge(ActsFullScanRoICreatorToolCfg(flags)))
+
+    kwargs.setdefault('RoIs', f"{flags.Tracking.ActiveConfig.extension}RegionOfInterest")
+    acc.merge(ActsMainRegionsOfInterestCreatorAlgCfg(flags, name, **kwargs))
     return acc

Tracking/Acts/ActsDataPreparation/test/runCompositeRoICode.py

@@ -8,7 +8,6 @@ def TestCompositeRoIToolCfg(flags,
                             **kwargs) -> ComponentAccumulator:
     acc = ComponentAccumulator()
 
-    kwargs.setdefault('RoIs', 'TestCompositeRoI')
     kwargs.setdefault('EtaCenters', [-1.2, 2.3, 3.8])
     kwargs.setdefault('PhiCenters', [0, 1, 2])
     kwargs.setdefault('HalfEtaWidths', [0.3, 0.1, 0.05])
@@ -19,7 +18,7 @@ def TestCompositeRoIToolCfg(flags,
 
     kwargs.setdefault('OutputLevel', 2)
 
-    acc.setPrivateTools(CompFactory.TestRoICreatorTool(name, **kwargs))
+    acc.setPrivateTools(CompFactory.ActsTrk.TestRoICreatorTool(name, **kwargs))
     return acc
     
 if __name__ == "__main__":
@@ -50,9 +49,10 @@ if __name__ == "__main__":
     acc.merge(PoolReadCfg(flags))
 
     # RoI creator
-    from ActsConfig.ActsViewConfig import ActsEventViewCreatorAlgCfg
-    acc.merge(ActsEventViewCreatorAlgCfg(flags,
-                                         RoICreatorTool=acc.popToolsAndMerge(TestCompositeRoIToolCfg(flags))))
+    from ActsConfig.ActsRegionsOfInterestConfig import ActsMainRegionsOfInterestCreatorAlgCfg
+    acc.merge(ActsMainRegionsOfInterestCreatorAlgCfg(flags,
+                                                     RoIs='TestCompositeRoI',
+                                                     RoICreatorTool=acc.popToolsAndMerge(TestCompositeRoIToolCfg(flags))))
 
     # Data Preparation - Clustering
     from ActsConfig.ActsClusterizationConfig import ActsPixelClusterizationAlgCfg

Tracking/Acts/ActsDataPreparation/test/runFullScanRoICode.py

@@ -29,8 +29,8 @@ if __name__ == "__main__":
     acc.merge(PoolReadCfg(flags))
 
     # RoI creator
-    from ActsConfig.ActsViewConfig import ActsEventViewCreatorAlgCfg
-    acc.merge(ActsEventViewCreatorAlgCfg(flags))
+    from ActsConfig.ActsRegionsOfInterestConfig import ActsMainRegionsOfInterestCreatorAlgCfg
+    acc.merge(ActsMainRegionsOfInterestCreatorAlgCfg(flags))
 
     # Data Preparation - Clustering
     from ActsConfig.ActsClusterizationConfig import ActsPixelClusterizationAlgCfg

Tracking/Acts/ActsDataPreparation/test/runSingleRoICode.py

@@ -8,13 +8,12 @@ def TestSingleRoIToolCfg(flags,
                          **kwargs) -> ComponentAccumulator:
     acc = ComponentAccumulator()
 
-    kwargs.setdefault('RoIs', 'TestSingleRoI')
     kwargs.setdefault('EtaCenters', [2.3])
     kwargs.setdefault('PhiCenters', [0])
     kwargs.setdefault('HalfEtaWidths', [0.05])
     kwargs.setdefault('HalfPhiWidths', [0.1])
 
-    acc.setPrivateTools(CompFactory.TestRoICreatorTool(name, **kwargs))
+    acc.setPrivateTools(CompFactory.ActsTrk.TestRoICreatorTool(name, **kwargs))
     return acc
     
 if __name__ == "__main__":
@@ -45,9 +44,10 @@ if __name__ == "__main__":
     acc.merge(PoolReadCfg(flags))
 
     # RoI creator
-    from ActsConfig.ActsViewConfig import ActsEventViewCreatorAlgCfg
-    acc.merge(ActsEventViewCreatorAlgCfg(flags,
-                                         RoICreatorTool=acc.popToolsAndMerge(TestSingleRoIToolCfg(flags))))
+    from ActsConfig.ActsRegionsOfInterestConfig import ActsMainRegionsOfInterestCreatorAlgCfg
+    acc.merge(ActsMainRegionsOfInterestCreatorAlgCfg(flags,
+                                                     RoIs='TestSingleRoI',
+                                                     RoICreatorTool=acc.popToolsAndMerge(TestSingleRoIToolCfg(flags))))
 
     # Data Preparation - Clustering
     from ActsConfig.ActsClusterizationConfig import ActsPixelClusterizationAlgCfg

Tracking/Acts/ActsRegionsOfInterest/ATLAS_CHECK_THREAD_SAFETY

+Tracking/Acts/ActsRegionsOfInterest

Tracking/Acts/ActsView/CMakeLists.txt → Tracking/Acts/ActsRegionsOfInterest/CMakeLists.txt

-# Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 
 # Declare the package name:
-atlas_subdir(ActsView)
+atlas_subdir(ActsRegionsOfInterest)
 
-atlas_add_library( ActsViewLib
-                   ActsView/*.h
-                   INTERFACE
-                   PUBLIC_HEADERS ActsView
-                   LINK_LIBRARIES
-		     AthLinks
-		     GaudiKernel
-		     TrigSteeringEvent )
-
-atlas_add_component( ActsView
+atlas_add_component( ActsRegionsOfInterest
                      src/*.h src/*.cxx
                      src/components/*.cxx
                      LINK_LIBRARIES
-		       ActsViewLib
+		       GaudiKernel
+		       ActsToolInterfacesLib
 		       AthContainers
 		       AthViews
 		       AthenaBaseComps

Tracking/Acts/ActsView/src/CaloBasedRoICreatorTool.cxx → Tracking/Acts/ActsRegionsOfInterest/src/CaloBasedRoICreatorTool.cxx

@@ -4,6 +4,8 @@
 
 #include "src/CaloBasedRoICreatorTool.h"
 
+namespace ActsTrk {
+
 CaloBasedRoICreatorTool::CaloBasedRoICreatorTool(const std::string& type,
 						 const std::string& name,
 						 const IInterface* parent)
@@ -15,22 +17,18 @@ StatusCode CaloBasedRoICreatorTool::initialize()
   ATH_MSG_DEBUG("Inizializing " << name() << " ..." );
 
   ATH_CHECK(m_caloClusterROIKey.initialize());
-  ATH_CHECK(m_roiCollectionKey.initialize());
   ATH_CHECK(m_beamSpotKey.initialize());
   
   return StatusCode::SUCCESS;
 }
 
 StatusCode CaloBasedRoICreatorTool::defineRegionsOfInterest(const EventContext& ctx,
-							   std::vector< ElementLink< TrigRoiDescriptorCollection > >& ELs) const 
+							    TrigRoiDescriptorCollection& collectionRoI) const
 {
-  // RoI collection gets stored in the SG
-  ATH_MSG_DEBUG("Storing ROI with ket " << m_roiCollectionKey.key());
-  SG::WriteHandle< TrigRoiDescriptorCollection > roiCollectionHandle = SG::makeHandle( m_roiCollectionKey, ctx );
-  ATH_CHECK( roiCollectionHandle.record( std::make_unique< TrigRoiDescriptorCollection >() ) );
-  TrigRoiDescriptorCollection *collectionRoI = roiCollectionHandle.ptr();
-  collectionRoI->push_back( new TrigRoiDescriptor(false) );
-  collectionRoI->back()->setComposite(true);
+  // Define RoI as not a FS RoI
+  collectionRoI.push_back( new TrigRoiDescriptor(false) );
+  // Define RoI as composite RoI
+  collectionRoI.back()->setComposite(true);
 
   // Retrieve Beam Spot data
   SG::ReadCondHandle< InDet::BeamSpotData > beamSpotHandle{ m_beamSpotKey, ctx };
@@ -45,7 +43,7 @@ StatusCode CaloBasedRoICreatorTool::defineRegionsOfInterest(const EventContext&
   ATH_MSG_DEBUG("   \\__ Retrived " << caloClusters->size() << " elements");
 
   // Add component RoIs
-  collectionRoI->back()->reserve(caloClusters->size());
+  collectionRoI.back()->reserve(caloClusters->size());
   double beamZ = beamSpotData->beamVtx().position().z();
   for (const ROIPhiRZ& calo_roi : *caloClusters) {
     double phi = calo_roi.phi();
@@ -62,16 +60,13 @@ StatusCode CaloBasedRoICreatorTool::defineRegionsOfInterest(const EventContext&
     double roiZMin = beamZ - m_deltaZ;
     double roiZMax = beamZ + m_deltaZ;
     
-    collectionRoI->back()->push_back( new TrigRoiDescriptor(eta, roiEtaMin, roiEtaMax,
-							    phi, roiPhiMin ,roiPhiMax,
-							    z, roiZMin, roiZMax ) );
+    collectionRoI.back()->push_back( new TrigRoiDescriptor(eta, roiEtaMin, roiEtaMax,
+							   phi, roiPhiMin ,roiPhiMax,
+							   z, roiZMin, roiZMax ) );
   }
 
-  ATH_MSG_DEBUG("Created composite RoI from Calo with " << collectionRoI->back()->size() << " RoIs");
-  
-  // Return element links to the created RoIs so that they can be used from the outside
-  ELs.push_back( ElementLink< TrigRoiDescriptorCollection >( *collectionRoI, 0ul ) );
-  ATH_CHECK( ELs.back().isValid() );
-
+  ATH_MSG_DEBUG("Created composite RoI from Calo with " << collectionRoI.back()->size() << " RoIs"); 
   return StatusCode::SUCCESS;
 }
+
+}

Tracking/Acts/ActsView/src/CaloBasedRoICreatorTool.h → Tracking/Acts/ActsRegionsOfInterest/src/CaloBasedRoICreatorTool.h

+
 /* 
    Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
@@ -6,13 +7,15 @@
 #define CALO_BASED_ROI_CREATOR_TOOL_H
 
 #include "AthenaBaseComps/AthAlgTool.h"
-#include "ActsView/IRoICreatorTool.h"
+#include "ActsToolInterfaces/IRoICreatorTool.h"
 #include "TrkCaloClusterROI/ROIPhiRZContainer.h"
 #include "BeamSpotConditionsData/BeamSpotData.h"
 
+namespace ActsTrk {
+
 class
 CaloBasedRoICreatorTool
-  : public extends<AthAlgTool, ::IRoICreatorTool> {
+  : public extends<AthAlgTool, ActsTrk::IRoICreatorTool> {
  public:
   CaloBasedRoICreatorTool(const std::string& type,
 			  const std::string& name,
@@ -24,16 +27,13 @@ CaloBasedRoICreatorTool
 
    virtual
    StatusCode defineRegionsOfInterest(const EventContext& ctx,
-				      std::vector< ElementLink< TrigRoiDescriptorCollection > >& ELs) const override;
+				      TrigRoiDescriptorCollection& collectionRoI) const override;
   
 private:
   SG::ReadHandleKey< ROIPhiRZContainer > m_caloClusterROIKey
     {this, "CaloClusterRoIContainer", "",
 	"Name of the calo cluster ROIs in Phi,R,Z parameterization"};
   
-  SG::WriteHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey
-    {this, "RoIs", ""};
-
   SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
     {this, "BeamSpotKey", "BeamSpotData",
 	"SG key for beam spot"};
@@ -46,4 +46,6 @@ private:
     {this, "DeltaZCaloRoI", 300.};
 };
 
+}
+
 #endif

Tracking/Acts/ActsView/src/FullScanRoICreatorTool.cxx → Tracking/Acts/ActsRegionsOfInterest/src/FullScanRoICreatorTool.cxx

@@ -4,35 +4,20 @@
 
 #include "src/FullScanRoICreatorTool.h"
 
-
+namespace ActsTrk {
+  
 FullScanRoICreatorTool::FullScanRoICreatorTool(const std::string& type,
 					       const std::string& name,
 					       const IInterface* parent)
   : base_class(type, name, parent) 
 {}
 
-StatusCode FullScanRoICreatorTool::initialize()
+StatusCode FullScanRoICreatorTool::defineRegionsOfInterest(const EventContext& /*ctx*/,
+							   TrigRoiDescriptorCollection& collectionRoI) const
 {
-  ATH_MSG_DEBUG("Inizializing " << name() << " ..." );
-
-  ATH_CHECK(m_roiCollectionKey.initialize());
-
+  // Add a Full Scan RoI
+  collectionRoI.push_back( new TrigRoiDescriptor(true) );
   return StatusCode::SUCCESS;
 }
 
-StatusCode FullScanRoICreatorTool::defineRegionsOfInterest(const EventContext& ctx,
-							   std::vector< ElementLink< TrigRoiDescriptorCollection > >& ELs) const 
-{
-  // RoI collection gets stored in the SG
-  SG::WriteHandle< TrigRoiDescriptorCollection > roiCollectionHandle = SG::makeHandle( m_roiCollectionKey, ctx );
-  ATH_CHECK( roiCollectionHandle.record( std::make_unique< TrigRoiDescriptorCollection >() ) );
-  TrigRoiDescriptorCollection *collectionRoI = roiCollectionHandle.ptr();
-
-  // Add a Full Scan RoI
-  collectionRoI->push_back( new TrigRoiDescriptor(true) );
-
-  // Return element links to the created RoIs so that they can be used from the outside
-  ELs.push_back( ElementLink< TrigRoiDescriptorCollection >( *collectionRoI, 0 ) );
-  ATH_CHECK( ELs.back().isValid() );
-  return StatusCode::SUCCESS;
 }

Tracking/Acts/ActsView/src/FullScanRoICreatorTool.h → Tracking/Acts/ActsRegionsOfInterest/src/FullScanRoICreatorTool.h

 /* 
-   Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+   Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef FULL_SCAN_ROI_CREATOR_TOOL_H
 #define FULL_SCAN_ROI_CREATOR_TOOL_H
 
 #include "AthenaBaseComps/AthAlgTool.h"
-#include "ActsView/IRoICreatorTool.h"
+#include "ActsToolInterfaces/IRoICreatorTool.h"
 
-class FullScanRoICreatorTool : public extends<AthAlgTool, ::IRoICreatorTool> {
+namespace ActsTrk {
+
+class FullScanRoICreatorTool : public extends<AthAlgTool, ActsTrk::IRoICreatorTool> {
  public:
   FullScanRoICreatorTool(const std::string& type,
 			 const std::string& name,
 			 const IInterface* parent);
   virtual ~FullScanRoICreatorTool() = default;
 
-  virtual 
-    StatusCode initialize() override;
-
    virtual
      StatusCode defineRegionsOfInterest(const EventContext& ctx,
-					std::vector< ElementLink< TrigRoiDescriptorCollection > >& ELs) const override;
-   
- private:
-  SG::WriteHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey {this, "RoIs", ""};
+					TrigRoiDescriptorCollection& collectionRoI) const override;
 };
 
+}
 #endif

Tracking/Acts/ActsRegionsOfInterest/src/RegionsOfInterestCreatorAlg.cxx

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "src/RegionsOfInterestCreatorAlg.h"
+
+namespace ActsTrk {
+
+RegionsOfInterestCreatorAlg::RegionsOfInterestCreatorAlg(const std::string& name, 
+							 ISvcLocator* pSvcLocator)
+  : AthReentrantAlgorithm(name, pSvcLocator)
+{}
+
+StatusCode RegionsOfInterestCreatorAlg::initialize() 
+{
+  ATH_MSG_DEBUG("Initialising " << name() << " ...");
+
+  ATH_CHECK(m_roiCollectionKey.initialize());
+  ATH_CHECK(m_roiTool.retrieve());
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode RegionsOfInterestCreatorAlg::execute(const EventContext& ctx) const
+{
+  ATH_MSG_DEBUG("Executing " << name() << " ...");
+
+  ATH_MSG_DEBUG("Creating ROI with key " << m_roiCollectionKey.key());
+  SG::WriteHandle< TrigRoiDescriptorCollection > roiCollectionHandle = SG::makeHandle( m_roiCollectionKey, ctx );
+  ATH_CHECK( roiCollectionHandle.record( std::make_unique< TrigRoiDescriptorCollection >() ) );
+  TrigRoiDescriptorCollection *collectionRoI = roiCollectionHandle.ptr();
+  ATH_CHECK(collectionRoI != nullptr);
+  
+  ATH_CHECK( m_roiTool->defineRegionsOfInterest(ctx, *collectionRoI) );
+  return StatusCode::SUCCESS;
+}
+
+}

Tracking/Acts/ActsRegionsOfInterest/src/RegionsOfInterestCreatorAlg.h

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ROI_CREATOR_ALG_H
+#define ROI_CREATOR_ALG_H
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "ActsToolInterfaces/IRoICreatorTool.h"
+#include "TrigSteeringEvent/TrigRoiDescriptorCollection.h"
+#include "StoreGate/WriteHandleKey.h"
+
+namespace ActsTrk {
+  
+class RegionsOfInterestCreatorAlg
+  : public AthReentrantAlgorithm {
+ public:
+  RegionsOfInterestCreatorAlg(const std::string& name, ISvcLocator* pSvcLocator);
+  virtual ~RegionsOfInterestCreatorAlg() = default;
+
+  virtual StatusCode initialize() override;
+  virtual StatusCode execute(const EventContext& ctx) const override;
+
+ private:
+  ToolHandle< ActsTrk::IRoICreatorTool > m_roiTool {this, "RoICreatorTool", "",
+      "Tool for creating RoIs"};
+  
+  SG::WriteHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey {this, "RoIs", "",
+    "The created RoI"};
+};
+
+}
+#endif

Tracking/Acts/ActsView/src/TestRoICreatorTool.cxx → Tracking/Acts/ActsRegionsOfInterest/src/TestRoICreatorTool.cxx

 /*
-   Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+   Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "src/TestRoICreatorTool.h"
 
+namespace ActsTrk {
+
 TestRoICreatorTool::TestRoICreatorTool(const std::string& type,
 				       const std::string& name,
 				       const IInterface* parent)
@@ -14,8 +16,6 @@ StatusCode TestRoICreatorTool::initialize()
 {
   ATH_MSG_DEBUG("Inizializing " << name() << " ..." );
 
-  ATH_CHECK(m_roiCollectionKey.initialize());
-
   // Check consistency
   // We need at least one entry
   if (m_eta_center_rois.size() == 0) {
@@ -45,19 +45,14 @@ StatusCode TestRoICreatorTool::initialize()
   return StatusCode::SUCCESS;
 }
 
-StatusCode TestRoICreatorTool::defineRegionsOfInterest(const EventContext& ctx,
-						       std::vector< ElementLink< TrigRoiDescriptorCollection > >& ELs) const 
+StatusCode TestRoICreatorTool::defineRegionsOfInterest(const EventContext& /*ctx*/,
+						       TrigRoiDescriptorCollection& collectionRoI) const
 {
-  // RoI collection gets stored in the SG
-  SG::WriteHandle< TrigRoiDescriptorCollection > roiCollectionHandle = SG::makeHandle( m_roiCollectionKey, ctx );
-  ATH_CHECK( roiCollectionHandle.record( std::make_unique< TrigRoiDescriptorCollection >() ) );
-  TrigRoiDescriptorCollection *collectionRoI = roiCollectionHandle.ptr();
-
   bool isComposite = m_eta_center_rois.size() > 1;
   // Add a composite RoI
   if (isComposite) {
-    collectionRoI->push_back( new TrigRoiDescriptor() );
-    collectionRoI->back()->setComposite(true);
+    collectionRoI.push_back( new TrigRoiDescriptor() );
+    collectionRoI.back()->setComposite(true);
   }
 
   bool useZconstraint = m_z_center_rois.size() != 0;
@@ -83,20 +78,19 @@ StatusCode TestRoICreatorTool::defineRegionsOfInterest(const EventContext& ctx,
     // if composite roi, add the consituent to it (already in the collection)
     // if not, the collection is empty and we have to add this one to it
     if (isComposite) {
-      collectionRoI->back()->push_back( std::move(toAdd) );
+      collectionRoI.back()->push_back( std::move(toAdd) );
     } else {
-      collectionRoI->push_back( std::move(toAdd) );
+      collectionRoI.push_back( std::move(toAdd) );
     }
   }
 
-  ATH_MSG_DEBUG("RoI collection size: " << collectionRoI->size());
+  ATH_MSG_DEBUG("RoI collection size: " << collectionRoI.size());
   ATH_MSG_DEBUG("Created a test RoI");
-  if (collectionRoI->back()->composite()) {
-    ATH_MSG_DEBUG("This is a composite RoI made from " << collectionRoI->back()->size() << " constituents");
+  if (collectionRoI.back()->composite()) {
+    ATH_MSG_DEBUG("This is a composite RoI made from " << collectionRoI.back()->size() << " constituents");
   }
 
-  // Return element links to the created RoIs so that they can be used from the outside
-  ELs.push_back( ElementLink< TrigRoiDescriptorCollection >( *collectionRoI, 0 ) );
-  ATH_CHECK( ELs.back().isValid() );
   return StatusCode::SUCCESS;
 }
+
+}

Tracking/Acts/ActsView/src/TestRoICreatorTool.h → Tracking/Acts/ActsRegionsOfInterest/src/TestRoICreatorTool.h

@@ -6,12 +6,12 @@
 #define TEST_ROI_CREATOR_TOOL_H
 
 #include "AthenaBaseComps/AthAlgTool.h"
-#include "ActsView/IRoICreatorTool.h"
-
-#include <vector>
+#include "ActsToolInterfaces/IRoICreatorTool.h"
 
+namespace ActsTrk {
+  
 class TestRoICreatorTool
-: public extends<AthAlgTool, ::IRoICreatorTool> {
+: public extends<AthAlgTool, ActsTrk::IRoICreatorTool> {
  public:
   TestRoICreatorTool(const std::string& type,
 		     const std::string& name,
@@ -23,11 +23,9 @@ class TestRoICreatorTool
 
    virtual
      StatusCode defineRegionsOfInterest(const EventContext& ctx,
-					std::vector< ElementLink< TrigRoiDescriptorCollection > >& ELs) const override;
+					TrigRoiDescriptorCollection& collectionRoI) const override;
    
  private:
-    SG::WriteHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey {this, "RoIs", ""};
-
    Gaudi::Property< std::vector<double> > m_eta_center_rois {this, "EtaCenters", {}, "Center of the RoI - eta coordinate"};
    Gaudi::Property< std::vector<double> > m_phi_center_rois {this, "PhiCenters", {}, "Center of the RoI - phi coordinate"};
    Gaudi::Property< std::vector<double> > m_z_center_rois {this, "ZCenters", {}, "Center of the RoI - z coordinate"};
@@ -37,4 +35,5 @@ class TestRoICreatorTool
    Gaudi::Property< std::vector<double> > m_half_z_width_rois {this, "HalfZWidths", {}, "Half width of the RoI - z coordinate"};
 };
 
+}
 #endif

Tracking/Acts/ActsRegionsOfInterest/src/components/ActsRegionsOnInterest_entries.cxx

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "src/RegionsOfInterestCreatorAlg.h"
+#include "src/FullScanRoICreatorTool.h"
+#include "src/CaloBasedRoICreatorTool.h"
+#include "src/TestRoICreatorTool.h"
+
+DECLARE_COMPONENT( ActsTrk::RegionsOfInterestCreatorAlg )
+DECLARE_COMPONENT( ActsTrk::FullScanRoICreatorTool )
+DECLARE_COMPONENT( ActsTrk::CaloBasedRoICreatorTool )
+DECLARE_COMPONENT( ActsTrk::TestRoICreatorTool )
+

Tracking/Acts/ActsView/ActsView/IRoICreatorTool.h → Tracking/Acts/ActsToolInterfaces/ActsToolInterfaces/IRoICreatorTool.h

@@ -11,6 +11,8 @@
 
 #include <vector>
 
+namespace ActsTrk {
+  
 class IRoICreatorTool 
 : virtual public IAlgTool {
  public:
@@ -19,7 +21,8 @@ class IRoICreatorTool
   virtual
     StatusCode
     defineRegionsOfInterest(const EventContext& ctx,
-			    std::vector< ElementLink< TrigRoiDescriptorCollection > >& ELs) const = 0;
+			    TrigRoiDescriptorCollection& collectionRoI) const = 0;
 };
 
+}
 #endif

Tracking/Acts/ActsView/src/EventViewCreatorAlg.cxx

-/*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "EventViewCreatorAlg.h"
-#include "AthViews/ViewHelper.h"
-
-EventViewCreatorAlg::EventViewCreatorAlg(const std::string& name, 
-					 ISvcLocator* pSvcLocator)
-  : AthReentrantAlgorithm(name, pSvcLocator)
-{}
-
-StatusCode EventViewCreatorAlg::initialize() 
-{
-  ATH_MSG_DEBUG("Initialising " << name() << " ...");
-
-  ATH_CHECK(m_viewsKey.initialize());
-  ATH_CHECK(m_inViewRoIs.initialize());
-
-  ATH_CHECK(m_roiTool.retrieve());
-
-  return StatusCode::SUCCESS;
-}
-
-StatusCode EventViewCreatorAlg::execute(const EventContext& ctx) const
-{
-  ATH_MSG_DEBUG("Executing " << name() << " ...");
-
-  SG::WriteHandle< ViewContainer > viewsHandle = SG::makeHandle( m_viewsKey, ctx ); 
-  ATH_CHECK( viewsHandle.record( std::make_unique<ViewContainer>() ) );
-  ViewContainer *viewVector = viewsHandle.ptr();
-
-  std::vector< ElementLink< TrigRoiDescriptorCollection > > roiELs;
-  ATH_CHECK( m_roiTool->defineRegionsOfInterest(ctx, roiELs) );
-
-  // Make the Event Views
-  for (const ElementLink< TrigRoiDescriptorCollection >& roiEL : roiELs) {
-    SG::View* newView = ViewHelper::makeView( name()+"_view", viewVector->size(), true);
-    viewVector->push_back( newView );
-
-    ATH_CHECK( placeRoIInView( roiEL, newView, ctx ) );
-  }
-
-  return StatusCode::SUCCESS;
-}
-
-StatusCode EventViewCreatorAlg::placeRoIInView( const ElementLink<TrigRoiDescriptorCollection>& roiEL, SG::View* view, const EventContext& ctx ) const {
-  // fill the RoI output collection
-  auto oneRoIColl = std::make_unique< ConstDataVector< TrigRoiDescriptorCollection > >(SG::VIEW_ELEMENTS);
-  oneRoIColl->push_back( *roiEL );
-  view->setROI(roiEL);
-
-  //store the RoI in the view
-  auto handle = SG::makeHandle( m_inViewRoIs, ctx );
-  ATH_CHECK( handle.setProxyDict( view ) );
-  ATH_CHECK( handle.record( std::move( oneRoIColl ) ) );
-  return StatusCode::SUCCESS;
-}
-
-