[WIP] Pandora interface for the IDEA detector

k4GaudiPandora/CMakeLists.txt

@@ -24,9 +24,10 @@ set(_plugin_sources ${CMAKE_CURRENT_LIST_DIR}/
                     src/DDScintillatorPpdDigi.cc
                     src/DDBFieldPlugin.cc
                     src/DDCaloHitCreator.cc
-                    # src/DDExternalClusteringAlgorithm.cc
+                    src/DDExternalClusteringAlgorithm.cc
                     src/DDGeometryCreator.cc
                     src/DDMCParticleCreator.cc
+                    src/PfoCreatorBase.cc
                     src/DDPfoCreator.cc
                     src/DDSimpleMuonDigi.cc
                     src/DDTrackCreatorBase.cc
@@ -36,8 +37,19 @@ set(_plugin_sources ${CMAKE_CURRENT_LIST_DIR}/
                     src/DDGeometryCreatorALLEGRO.cc
                     src/DDTrackCreatorALLEGRO.cc
                     src/DDCaloHitCreatorALLEGRO.cc
+                    src/TrackCreatorIdea.cc
+                    src/DualReadoutCaloHitCreator.cc
+                    src/PfoCreatorIdea.cc
+                    src/GeometryCreatorIdea.cc
 )
 
+# PandoraPFAIdeaAlgorithm registers the ONNX algorithms (ClusterNeutralPid,
+# SatelliteAssignmentOnnx) provided by LCContentML, so it is built only when ML is enabled.
+option(K4GP_BUILD_ML "Build the ONNX/ML-dependent IDEA reconstruction (needs LCContentML)" OFF)
+if(K4GP_BUILD_ML)
+    list(APPEND _plugin_sources src/PandoraPFAIdeaAlgorithm.cc)
+endif()
+
 gaudi_add_module(k4GaudiPandoraPlugins
                  SOURCES ${_plugin_sources}
                  LINK Gaudi::GaudiKernel
@@ -51,6 +63,7 @@ gaudi_add_module(k4GaudiPandoraPlugins
                       GSL::gslcblas # This seems to be necessary on Ubuntu 24.04 when linking with mold
                       ${PandoraSDK_LIBRARIES}
                       ${LCContent_LIBRARIES}
+                      $<$<BOOL:${K4GP_BUILD_ML}>:LCContent::LCContentML>
                     )
 if(K4GAUDIPANDORA_USE_DDKALTEST)
   target_compile_definitions(k4GaudiPandoraPlugins PRIVATE K4GAUDIPANDORA_USE_DDKALTEST)

k4GaudiPandora/README.md

@@ -42,10 +42,12 @@ faces it can choose between is whatever the upstream extrapolation stored.
 Note that `OFF` does not make k4GaudiPandora depend on k4ActsTracking; nothing is linked or included
 from it.
 
+Independently of this option, a track with no `AtCalorimeter` state is still passed to pandora with
+`reachesCalorimeter` false: the state remains (0,0,0) and `timeAtCalorimeter` is -1 when the track doesn't
+reach calo (Pandora requires them as mendatory input parameters). Use ReachesCalorimeter() method to check it.
+
 Caveats when `OFF`:
 
-- The input tracks **must** carry an `AtCalorimeter` track state. Tracks without one are dropped by
-  the track creators, which report `Failed to extract a track`.
 - `TrackStateTolerance` has no effect, since it only bounds the acceptance radius of the endcap
   state.
 

k4GaudiPandora/include/DDExternalClusteringAlgorithm.h

@@ -27,20 +27,56 @@
 #ifndef DDEXTERNALCLUSTERINGALGORITHM_H
 #define DDEXTERNALCLUSTERINGALGORITHM_H 1
 
-#include "Pandora/Algorithm.h"
+// Pandora
+#include "Helpers/XmlHelper.h"
+#include "Objects/CaloHit.h"
+#include "Pandora/ExternallyConfiguredAlgorithm.h"
 
+// Podio
+#include "podio/ObjectID.h"
+
+#include "edm4hep/Cluster.h"
+
+// c++
 #include <map>
+#include <unordered_map>
+#include <vector>
 
 namespace pandora {
 class CaloHit;
 }
 
+/**
+ *  @brief  ExternalClusterHolder class - holds pointers to the external clusters and the calo hits
+ */
+
+class ExternalClusterHolder {
+public:
+  ExternalClusterHolder() = default;
+  ~ExternalClusterHolder() = default;
+
+  void setExternalClusters(std::vector<std::vector<edm4hep::Cluster>>* externalClusters);
+  const std::vector<std::vector<edm4hep::Cluster>>& getExternalClusters() const;
+
+  std::vector<std::vector<edm4hep::Cluster>>* m_externalClusters; ///< The external clusters
+};
+
+//------------------------------------------------------------------------------------------------------------------------------------------
+
+/**
+ *  @brief  ExternalEventParameter class - holds Gaudi event service for external clustering
+ */
+class ExternalEventParameter : public pandora::ExternalParameters {
+public:
+  ExternalClusterHolder* m_externalClusterHolder; ///< Pointer to external cluster holder
+};
+
 //------------------------------------------------------------------------------------------------------------------------------------------
 
 /**
  *  @brief  DDExternalClusteringAlgorithm class
  */
-class DDExternalClusteringAlgorithm : public pandora::Algorithm {
+class DDExternalClusteringAlgorithm : public pandora::ExternallyConfiguredAlgorithm {
 public:
   /**
    *  @brief  Factory class for instantiating algorithm
@@ -59,10 +95,11 @@ class DDExternalClusteringAlgorithm : public pandora::Algorithm {
   pandora::StatusCode Run();
   pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
 
-  typedef std::map<const void*, const pandora::CaloHit*> ParentAddressToCaloHitMap;
+  typedef std::unordered_map<podio::ObjectID, const pandora::CaloHit*> ExternalToPandoraCaloHitMap;
+
+  bool m_flagClustersAsPhotons = false; ///< Whether to automatically flag new clusters as fixed photons
 
-  std::string m_externalClusterCollectionName = ""; ///< The collection name for the external clusters
-  bool m_flagClustersAsPhotons = true;              ///< Whether to automatically flag new clusters as fixed photons
+  ExternalClusterHolder* m_externalClusterHolder = nullptr; ///< Pointer to external cluster holder
 };
 
 //------------------------------------------------------------------------------------------------------------------------------------------

k4GaudiPandora/include/DDGeometryCreator.h

@@ -46,7 +46,13 @@ class DDGeometryCreator {
    */
   DDGeometryCreator(const Settings& settings, pandora::Pandora& pandora, Gaudi::Algorithm* algorithm);
 
-  pandora::StatusCode CreateGeometry() const;
+  /**
+   *  @brief  Destructor.  Virtual because derived creators are held and deleted through a
+   *          DDGeometryCreator pointer (see DDPandoraPFANewAlgorithm::m_geometryCreator).
+   */
+  virtual ~DDGeometryCreator() = default;
+
+  virtual pandora::StatusCode CreateGeometry() const;
 
 protected:
   typedef std::map<pandora::SubDetectorType, PandoraApi::Geometry::SubDetector::Parameters> SubDetectorTypeMap;
@@ -56,7 +62,7 @@ class DDGeometryCreator {
    *
    *  @param  subDetectorTypeMap the sub detector type map
    */
-  void SetMandatorySubDetectorParameters(SubDetectorTypeMap& subDetectorTypeMap) const;
+  virtual void SetMandatorySubDetectorParameters(SubDetectorTypeMap& subDetectorTypeMap) const;
 
   /**
    *  @brief  Set additional sub detector parameters

k4GaudiPandora/include/DDGeometryCreatorALLEGRO.h

@@ -50,15 +50,15 @@ class DDGeometryCreatorALLEGRO : public DDGeometryCreator {
   /**
    *  @brief  Create geometry
    */
-  pandora::StatusCode CreateGeometry() const;
+  pandora::StatusCode CreateGeometry() const override;
 
 private:
   /**
    *  @brief  Set mandatory sub detector parameters
    *
    *  @param  subDetectorTypeMap the sub detector type map
    */
-  void SetMandatorySubDetectorParameters(SubDetectorTypeMap& subDetectorTypeMap) const;
+  void SetMandatorySubDetectorParameters(SubDetectorTypeMap& subDetectorTypeMap) const override;
 };
 
 #endif // #ifndef GEOMETRY_CREATOR_H

k4GaudiPandora/include/DDPandoraPFANewAlgorithm.h

@@ -46,6 +46,10 @@ namespace pandora {
 class Pandora;
 }
 
+// forward declarations for the external clustering algorithm
+class ExternalEventParameter;
+class ExternalClusterHolder;
+
 dd4hep::rec::LayeredCalorimeterData* getExtension(unsigned int includeFlag, unsigned int excludeFlag = 0);
 
 struct DDPandoraPFANewAlgorithm final
@@ -61,7 +65,8 @@ struct DDPandoraPFANewAlgorithm final
           const std::vector<const edm4hep::CalorimeterHitCollection*>&,
           const std::vector<const edm4hep::CalorimeterHitCollection*>&,
           const std::vector<const edm4hep::CalorimeterHitCollection*>&,
-          const std::vector<const edm4hep::CaloHitSimCaloHitLinkCollection*>&)> {
+          const std::vector<const edm4hep::CaloHitSimCaloHitLinkCollection*>&,
+          const std::vector<const edm4hep::ClusterCollection*>&)> {
 public:
   class Settings {
   public:
@@ -137,7 +142,8 @@ struct DDPandoraPFANewAlgorithm final
              const std::vector<const edm4hep::CalorimeterHitCollection*>& mCalCollections,
              const std::vector<const edm4hep::CalorimeterHitCollection*>& lCalCollections,
              const std::vector<const edm4hep::CalorimeterHitCollection*>& lhCalCollections,
-             const std::vector<const edm4hep::CaloHitSimCaloHitLinkCollection*>& caloLinkCollections) const override;
+             const std::vector<const edm4hep::CaloHitSimCaloHitLinkCollection*>& caloLinkCollections,
+             const std::vector<const edm4hep::ClusterCollection*>& clusterCollections) const override;
 
   const pandora::Pandora* GetPandora() const;
 
@@ -165,6 +171,9 @@ struct DDPandoraPFANewAlgorithm final
   std::unique_ptr<DDMCParticleCreator> m_pDDMCParticleCreator; ///< The mc particle creator
   std::unique_ptr<DDPfoCreator> m_pfoCreator;                  ///< The pfo creator
   SmartIF<IGeoSvc> m_geoSvc;                                   ///< The GeoSvc
+  ExternalEventParameter* m_extEvtParam;                     ///< external event parameter (pandora::ExternalParameters)
+                                                             ///< created by this algo but deleted by Pandora
+  std::unique_ptr<ExternalClusterHolder> m_extClusterHolder; ///< Pointer to external cluster holder
 
   Settings m_settings{};                                       ///< The settings for the pandora pfa new processor
   DDCaloHitCreator::Settings m_caloHitCreatorSettings{};       ///< The calo hit creator settings

k4GaudiPandora/include/DDPfoCreator.h

@@ -19,6 +19,8 @@
 #ifndef K4GAUDIPANDORA_DDPFOCREATOR_H
 #define K4GAUDIPANDORA_DDPFOCREATOR_H 1
 
+#include "PfoCreatorBase.h"
+
 #include "Api/PandoraApi.h"
 
 #include <Gaudi/Algorithm.h>
@@ -32,7 +34,7 @@ class MutableVertex;
 class VertexCollection;
 } // namespace edm4hep
 
-class DDPfoCreator {
+class DDPfoCreator : public PfoCreatorBase {
 public:
   class Settings {
   public:
@@ -137,24 +139,6 @@ class DDPfoCreator {
   pandora::StatusCode calculateTrackBasedReferencePoint(const pandora::ParticleFlowObject* const pPandoraPfo,
                                                         pandora::CartesianVector& referencePoint) const;
 
-  /**
-   *  @brief  Add tracks to reconstructed particle
-   *
-   *  @param  pPandoraPfo the address of the pandora pfo
-   *  @param  pReconstructedParticle the address of the reconstructed particle to be added tracks
-   */
-  void AddTracksToRecoParticle(const pandora::ParticleFlowObject* const pPandoraPfo,
-                               edm4hep::MutableReconstructedParticle& pReconstructedParticle) const;
-
-  /**
-   *  @brief  Set properties of reconstructed particle from pandora pfo
-   *
-   *  @param  pPandoraPfo the address of the pandora pfo
-   *  @param  pReconstructedParticle the address of the reconstructed particle to be set properties
-   */
-  void SetRecoParticlePropertiesFromPFO(const pandora::ParticleFlowObject* const pPandoraPfo,
-                                        edm4hep::MutableReconstructedParticle& pReconstructedParticle) const;
-
   /**
    *  @brief  Whether parent and daughter tracks are associated with the same pfo
    *
@@ -196,9 +180,7 @@ class DDPfoCreator {
   bool AreAnyOtherSiblingsInList(const pandora::Track* const pPandoraTrack,
                                  const pandora::TrackList& allTrackList) const;
 
-  const Settings m_settings;           ///< The pfo creator settings
-  pandora::Pandora& m_pandora;         ///< Reference to the pandora object from which to extract the pfos
-  const Gaudi::Algorithm& m_algorithm; ///< Reference to the Gaudi algorithm for message streaming
+  const Settings m_settings; ///< The pfo creator settings
 };
 
 #endif // #ifndef K4GAUDIPANDORA_DDPFOCREATOR_H

k4GaudiPandora/include/DDTrackCreatorBase.h

@@ -178,6 +178,17 @@ class DDTrackCreatorBase {
   void Reset();
 
 protected:
+  /**
+   *  @brief  Build the DDKalTest tracking system used by GetTrackStatesAtCalo to extrapolate track
+   *          states to the calorimeter face.  Deliberately not called from the constructor: a
+   *          creator whose track states are already extrapolated upstream does not need it and
+   *          should not pay to build it.  A derived class that calls GetTrackStatesAtCalo must
+   *          call this from its constructor.
+   */
+#ifdef K4GAUDIPANDORA_USE_DDKALTEST
+  void InitialiseTrackingSystem();
+#endif
+
   const Settings m_settings;           ///< The track creator settings
   pandora::Pandora& m_pandora;         ///< Reference to the pandora object to create tracks and track relationships
   const Gaudi::Algorithm& m_algorithm; ///< Reference to the parent algorithm
@@ -206,16 +217,19 @@ class DDTrackCreatorBase {
    *
    *  @return boolean
    */
-  virtual bool PassesQualityCuts(const edm4hep::Track& pTrack,
-                                 const PandoraApi::Track::Parameters& trackParameters) const = 0;
+  virtual bool PassesQualityCuts(const edm4hep::Track& /*pTrack*/,
+                                 const PandoraApi::Track::Parameters& /*trackParameters*/) const {
+    return true; // no cuts by default: the selection may be done upstream of the creator
+  }
 
   /**
    *  @brief  Decide whether track reaches the ecal surface
    *
    *  @param  pTrack the lcio track
    *  @param  trackParameters the track parameters
    */
-  virtual void TrackReachesECAL(const edm4hep::Track& pTrack, PandoraApi::Track::Parameters& trackParameters) const = 0;
+  virtual void TrackReachesECAL(const edm4hep::Track& /*pTrack*/,
+                                PandoraApi::Track::Parameters& /*trackParameters*/) const {}
 
   /**
    *  @brief  Determine whether a track can be used to form a pfo under the following conditions:
@@ -225,8 +239,8 @@ class DDTrackCreatorBase {
    *  @param  pTrack the lcio track
    *  @param  trackParameters the track parameters
    */
-  virtual void DefineTrackPfoUsage(const edm4hep::Track& pTrack,
-                                   PandoraApi::Track::Parameters& trackParameters) const = 0;
+  virtual void DefineTrackPfoUsage(const edm4hep::Track& /*pTrack*/,
+                                   PandoraApi::Track::Parameters& /*trackParameters*/) const {}
 
   /**
    *  @brief  Extract kink information from specified collection
@@ -338,8 +352,12 @@ class DDTrackCreatorBase {
    *  @brief  Obtain track time when it reaches ECAL
    *
    *  @param  pTrack the lcio track
+   *  @param  trackTime to receive the generic time: path length from the reference point to the
+   *          intersection, divided by momentum
+   *
+   *  @return STATUS_CODE_NOT_FOUND if the helix meets neither calorimeter surface
    */
-  float CalculateTrackTimeAtCalorimeter(const edm4hep::Track& pTrack) const;
+  pandora::StatusCode CalculateTrackTimeAtCalorimeter(const edm4hep::Track& pTrack, float& trackTime) const;
 };
 
 //------------------------------------------------------------------------------------------------------------------------------------------