Merge branch 'AddSpacePointReader' into 'main'

Add space point reader

See merge request !69009

InnerDetector/InDetValidation/InDetPhysValMonitoring/scripts/runIDPVM.py

@@ -107,6 +107,11 @@ acc = MainServicesCfg(flags)
 from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
 acc.merge(PoolReadCfg(flags))
 
+# Schedule ACTS data pool if requested
+if flags.PhysVal.IDPVM.doActs:
+    from ActsConfig.ActsCollectionsConfig import ActsPoolReadCfg
+    acc.merge(ActsPoolReadCfg(flags))
+
 if flags.PhysVal.IDPVM.doPRW:    
     acc.addService(CompFactory.CP.SystematicsSvc("SystematicsSvc"))
     from AsgAnalysisAlgorithms.PileupReweightingAlgConfig import PileupReweightingAlgCfg

Tracking/Acts/ActsCollectionAlgs/CMakeLists.txt

+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+
+# Declare the package name:
+atlas_subdir( ActsCollectionAlgs )
+
+# Component(s) in the package:
+atlas_add_component( ActsCollectionAlgs
+                        src/*.h src/*.cxx
+                        src/components/*.cxx
+                     LINK_LIBRARIES
+		        AthenaBaseComps
+			AthLinks
+		        GaudiKernel
+			StoreGateLib
+		        xAODInDetMeasurement
+			xAODMeasurementBase
+		    )

Tracking/Acts/ActsCollectionAlgs/src/SpacePointReader.cxx

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration 
+*/
+
+#include "SpacePointReader.h"
+#include "xAODMeasurementBase/UncalibratedMeasurementContainer.h"
+#include "AthLinks/ElementLink.h"
+#include "StoreGate/WriteDecorHandle.h"
+
+namespace ActsTrk {
+
+  SpacePointReader::SpacePointReader(const std::string& name,
+				     ISvcLocator* pSvcLocator)
+    : AthReentrantAlgorithm(name, pSvcLocator)
+  {}
+  
+  StatusCode SpacePointReader::initialize()
+  {
+    ATH_MSG_DEBUG("Initializing " << name() << " ... ");
+
+    m_clusterDecoration = m_spacePointKey.key() + "." + m_clusterDecoration.key();
+
+    ATH_MSG_DEBUG("Properties:");
+    ATH_MSG_DEBUG(m_spacePointKey);
+    ATH_MSG_DEBUG(m_clusterDecoration);
+    
+    ATH_CHECK(m_spacePointKey.initialize());
+    ATH_CHECK(m_clusterDecoration.initialize());
+
+    return StatusCode::SUCCESS;
+  }
+  
+  StatusCode SpacePointReader::execute(const EventContext& ctx) const
+  {
+    ATH_MSG_DEBUG("Executing " << name() << " ...");
+
+    ATH_MSG_DEBUG("Retrieving input space point collection with key: " << m_spacePointKey.key());
+    SG::ReadHandle< xAOD::SpacePointContainer > spHandle = SG::makeHandle( m_spacePointKey, ctx );
+    ATH_CHECK(spHandle.isValid());
+    const xAOD::SpacePointContainer* spacePoints = spHandle.cptr();
+    ATH_MSG_DEBUG("Retrieved " << spacePoints->size() << " elements from space point container");
+
+    ATH_MSG_DEBUG("Adding decoration to space point collection: bare pointers to clusters");
+    ATH_MSG_DEBUG("Decoration name: " << m_clusterDecoration.key());
+    using decoration_type = std::vector<const xAOD::UncalibratedMeasurement*>;
+    SG::WriteDecorHandle< xAOD::SpacePointContainer,
+			  decoration_type > barePointersToClusters( m_clusterDecoration, ctx );
+    
+    ATH_MSG_DEBUG("Retrieving Element Links to Clusters from the Space Points and attaching the bare pointers to the object");
+    static const SG::AuxElement::Accessor< std::vector<ElementLink<xAOD::UncalibratedMeasurementContainer>> > accesor("measurementLink");
+    for (const xAOD::SpacePoint* sp : *spacePoints) {
+      if (not accesor.isAvailable(*sp)) {
+	ATH_MSG_ERROR("Space point does not possess element link to cluster. Decoration `measurementLink` is not available and this should not happen!");
+	return StatusCode::FAILURE;
+      }
+      
+      const std::vector< ElementLink< xAOD::UncalibratedMeasurementContainer > >& els = accesor(*sp);
+      std::vector< const xAOD::UncalibratedMeasurement* > meas;
+      meas.reserve(els.size());
+      for (const ElementLink< xAOD::UncalibratedMeasurementContainer >& el : els) {
+	meas.push_back(*el);
+      }
+
+      barePointersToClusters(*sp) = meas;
+    }
+    
+    return StatusCode::SUCCESS;
+  }
+
+}

Tracking/Acts/ActsCollectionAlgs/src/SpacePointReader.h

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ACTS_COLLECTIONALGS_SPACEPOINTS_H
+#define ACTS_COLLECTIONALGS_SPACEPOINTS_H
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "GaudiKernel/EventContext.h"
+#include "StoreGate/ReadHandleKey.h"
+#include "StoreGate/WriteDecorHandleKey.h"
+
+// EDM
+#include "xAODInDetMeasurement/SpacePointContainer.h"
+
+namespace ActsTrk {
+
+class SpacePointReader
+  : public AthReentrantAlgorithm {
+ public:
+  SpacePointReader(const std::string& name, ISvcLocator* pSvcLocator);
+  virtual ~SpacePointReader() override = default;
+
+  virtual StatusCode initialize() override;
+  virtual StatusCode execute(const EventContext&) const override;
+
+ private:
+  SG::ReadHandleKey< xAOD::SpacePointContainer > m_spacePointKey
+  {this, "SpacePointKey", "",
+      "Key for input space point container"};
+
+  SG::WriteDecorHandleKey< xAOD::SpacePointContainer > m_clusterDecoration
+    {this, "ClusterDecorationKey", "measurements",
+    "Decoration key for the cluster bare pointer"};
+};
+
+} // namespace ActsTrk
+
+#endif

Tracking/Acts/ActsCollectionAlgs/src/components/ActsCollectionAlgs_entries.cxx

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

Tracking/Acts/ActsConfig/python/ActsCollectionsConfig.py

+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+def SpacePointReaderCfg(flags,
+                        name: str,
+                        **kwargs) -> ComponentAccumulator:
+    acc = ComponentAccumulator()
+    acc.addEventAlgo(CompFactory.ActsTrk.SpacePointReader(name=name, **kwargs))
+    return acc
+
+def ActsPoolReadCfg(flags) -> ComponentAccumulator:
+    acc = ComponentAccumulator()
+
+    import re
+    typedCollections = flags.Input.TypedCollections
+    for col in typedCollections:
+        match = re.findall(r"xAOD::SpacePointContainer#(\S+)", col)
+        if match:
+            spCol = match[0]
+            acc.merge(SpacePointReaderCfg(flags,
+                                          name=f"{spCol}Reader",
+                                          SpacePointKey=spCol))
+
+    return acc

Tracking/Acts/ActsMonitoring/src/SpacePointAnalysisAlg.cxx

@@ -57,12 +57,14 @@ namespace ActsTrk {
 	  [[maybe_unused]] const auto idHash = el->identifierHash();
 	}
       } else if (sp->isAvailable< std::vector< ElementLink<xAOD::UncalibratedMeasurementContainer> > >("measurementLink")) {
-	// For now this is still allowed. Once we have a Space Point reader algorithm, thi will imply an error instead
-	static const SG::AuxElement::Accessor< std::vector< ElementLink<xAOD::UncalibratedMeasurementContainer> > > accCluster("measurementLink");
-	const auto& els = accCluster(*sp);
-	for (const auto& el : els) {
-          [[maybe_unused]] const auto idHash = (*el)->identifierHash();
-        }
+	// if we are here, that means the bare pointers are not available
+	// This should not happen
+	ATH_MSG_ERROR("Space point has Element links but not bare pointers to cluster. This should not happen!");
+	return StatusCode::FAILURE;
+      } else {
+	// This should never happen
+	ATH_MSG_ERROR("There are no decorations that link the space point to the original clusters");
+	return StatusCode::FAILURE;
       }
     }
 

Tracking/Acts/ActsMonitoring/test/ActsReadEDM.py

@@ -27,6 +27,9 @@ if __name__ == "__main__":
     
     from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
     acc.merge(PoolReadCfg(flags))
+
+    from ActsConfig.ActsCollectionsConfig import ActsPoolReadCfg
+    acc.merge(ActsPoolReadCfg(flags))
     
     if flags.readClusters:
         if flags.Detector.EnableITkPixel: