Make CollectionCollector collections optional

src/detectors/LOWQ2/LOWQ2.cc

@@ -162,12 +162,12 @@ void InitPlugin(JApplication* app) {
   }
 
   // Combine the tracks from each module into one collection
-  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::Track>>(
+  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::Track, true>>(
       "TaggerTrackerLocalTracks", outputTrackTags, {"TaggerTrackerLocalTracks"}, app));
 
   // Combine the associations from each module into one collection
   app->Add(new JOmniFactoryGeneratorT<
-           CollectionCollector_factory<edm4eic::MCRecoTrackParticleAssociation>>(
+           CollectionCollector_factory<edm4eic::MCRecoTrackParticleAssociation, true>>(
       "TaggerTrackerLocalTrackAssociations", outputTrackAssociationTags,
       {"TaggerTrackerLocalTrackAssociations"}, app));
 

src/extensions/jana/JOmniFactory.h

@@ -42,7 +42,7 @@ class JOmniFactory : public JMultifactory {
     virtual void GetCollection(const JEvent& event) = 0;
   };
 
-  template <typename T> class Input : public InputBase {
+  template <typename T, bool IsOptional = false> class Input : public InputBase {
 
     std::vector<const T*> m_data;
 
@@ -58,10 +58,19 @@ class JOmniFactory : public JMultifactory {
   private:
     friend class JOmniFactory;
 
-    void GetCollection(const JEvent& event) { m_data = event.Get<T>(this->collection_names[0]); }
+    void GetCollection(const JEvent& event) {
+      try {
+        m_data = event.Get<T>(this->collection_names[0], !IsOptional);
+      } catch (const JException& e) {
+        if constexpr (!IsOptional) {
+          throw JException("JOmniFactory: Failed to get collection %s: %s",
+                           this->collection_names[0].c_str(), e.what());
+        }
+      }
+    }
   };
 
-  template <typename PodioT> class PodioInput : public InputBase {
+  template <typename PodioT, bool IsOptional = false> class PodioInput : public InputBase {
 
     const typename PodioTypeMap<PodioT>::collection_t* m_data;
 
@@ -78,11 +87,18 @@ class JOmniFactory : public JMultifactory {
     friend class JOmniFactory;
 
     void GetCollection(const JEvent& event) {
-      m_data = event.GetCollection<PodioT>(this->collection_names[0]);
+      try {
+        m_data = event.GetCollection<PodioT>(this->collection_names[0], !IsOptional);
+      } catch (const JException& e) {
+        if constexpr (!IsOptional) {
+          throw JException("JOmniFactory: Failed to get collection %s: %s",
+                           this->collection_names[0].c_str(), e.what());
+        }
+      }
     }
   };
 
-  template <typename PodioT> class VariadicPodioInput : public InputBase {
+  template <typename PodioT, bool IsOptional = false> class VariadicPodioInput : public InputBase {
 
     std::vector<const typename PodioTypeMap<PodioT>::collection_t*> m_data;
 
@@ -104,7 +120,14 @@ class JOmniFactory : public JMultifactory {
     void GetCollection(const JEvent& event) {
       m_data.clear();
       for (auto& coll_name : this->collection_names) {
-        m_data.push_back(event.GetCollection<PodioT>(coll_name));
+        try {
+          m_data.push_back(event.GetCollection<PodioT>(coll_name, !IsOptional));
+        } catch (const JException& e) {
+          if constexpr (!IsOptional) {
+            throw JException("JOmniFactory: Failed to get collection %s: %s", coll_name.c_str(),
+                             e.what());
+          }
+        }
       }
     }
   };

src/factories/meta/CollectionCollector_factory.h

@@ -6,17 +6,20 @@
 
 namespace eicrecon {
 
-template <class T>
-class CollectionCollector_factory : public JOmniFactory<CollectionCollector_factory<T>> {
+template <class T, bool IsOptional = false>
+class CollectionCollector_factory
+    : public JOmniFactory<CollectionCollector_factory<T, IsOptional>> {
 public:
   using AlgoT = eicrecon::CollectionCollector<typename T::collection_type>;
 
 private:
   std::unique_ptr<AlgoT> m_algo;
 
-  typename JOmniFactory<CollectionCollector_factory<T>>::template VariadicPodioInput<T> m_inputs{
-      this};
-  typename JOmniFactory<CollectionCollector_factory<T>>::template PodioOutput<T> m_output{this};
+  typename JOmniFactory<CollectionCollector_factory<T, IsOptional>>::template VariadicPodioInput<
+      T, IsOptional>
+      m_inputs{this};
+  typename JOmniFactory<CollectionCollector_factory<T, IsOptional>>::template PodioOutput<T>
+      m_output{this};
 
 public:
   void Configure() {

src/global/beam/beam.cc

@@ -40,7 +40,7 @@ void InitPlugin(JApplication* app) {
       app));
 
   // Combine beam protons and neutrons into beam hadrons
-  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4hep::MCParticle>>(
+  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4hep::MCParticle, true>>(
       "MCBeamHadrons", {"MCBeamProtons", "MCBeamNeutrons"}, {"MCBeamHadrons"}, app));
 }
 }

src/global/reco/reco.cc

@@ -78,23 +78,15 @@ void InitPlugin(JApplication* app) {
   app->Add(new JOmniFactoryGeneratorT<MC2SmearedParticle_factory>(
       "GeneratedParticles", {"MCParticles"}, {"GeneratedParticles"}, app));
 
-  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::Cluster>>(
-      "EcalClusters",
-      {
-          "EcalEndcapNClusters",
-          "EcalBarrelScFiClusters",
-          "EcalEndcapPClusters",
-      },
+  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::Cluster, true>>(
+      "EcalClusters", {"EcalEndcapNClusters", "EcalBarrelScFiClusters", "EcalEndcapPClusters"},
       {"EcalClusters"}, app));
 
   app->Add(new JOmniFactoryGeneratorT<
-           CollectionCollector_factory<edm4eic::MCRecoClusterParticleAssociation>>(
+           CollectionCollector_factory<edm4eic::MCRecoClusterParticleAssociation, true>>(
       "EcalClusterAssociations",
-      {
-          "EcalEndcapNClusterAssociations",
-          "EcalBarrelScFiClusterAssociations",
-          "EcalEndcapPClusterAssociations",
-      },
+      {"EcalEndcapNClusterAssociations", "EcalBarrelScFiClusterAssociations",
+       "EcalEndcapPClusterAssociations"},
       {"EcalClusterAssociations"}, app));
 
   app->Add(new JOmniFactoryGeneratorT<MatchClusters_factory>(
@@ -196,7 +188,7 @@ void InitPlugin(JApplication* app) {
       },
       app));
 
-  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::Cluster>>(
+  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::Cluster, true>>(
       "BarrelClusters",
       {
           "HcalBarrelClusters",

src/global/tracking/tracking.cc

@@ -1,20 +1,14 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-// Copyright (C) 2022 - 2024, Dmitry Romanov, Tyler Kutz, Wouter Deconinck, Dmitry Kalinkin
+// Copyright (C) 2022 - 2025, Dmitry Romanov, Tyler Kutz, Wouter Deconinck, Dmitry Kalinkin
 
-#include <DD4hep/Detector.h>
 #include <JANA/JApplication.h>
 #include <edm4eic/MCRecoTrackParticleAssociation.h>
 #include <edm4eic/MCRecoTrackerHitAssociationCollection.h>
 #include <edm4eic/TrackCollection.h>
 #include <edm4eic/TrackerHitCollection.h>
 #include <fmt/core.h>
-#include <algorithm>
-#include <gsl/pointers>
 #include <map>
 #include <memory>
-#include <string>
-#include <tuple>
-#include <vector>
 
 #include "ActsToTracks.h"
 #include "ActsToTracks_factory.h"
@@ -30,7 +24,6 @@
 #include "TracksToParticles_factory.h"
 #include "extensions/jana/JOmniFactoryGeneratorT.h"
 #include "factories/meta/CollectionCollector_factory.h"
-#include "services/geometry/dd4hep/DD4hep_service.h"
 
 //
 extern "C" {
@@ -42,49 +35,26 @@ void InitPlugin(JApplication* app) {
   app->Add(new JOmniFactoryGeneratorT<TrackParamTruthInit_factory>(
       "CentralTrackTruthSeeds", {"MCParticles"}, {"CentralTrackTruthSeeds"}, {}, app));
 
-  // Possible collections from arches, brycecanyon and craterlake configurations
-  std::vector<std::tuple<std::string, std::string, std::string, std::string>> possible_collections =
-      {{"SiBarrelHits", "SiBarrelRawHits", "SiBarrelRawHitAssociations", "SiBarrelTrackerRecHits"},
-       {"VertexBarrelHits", "SiBarrelVertexRawHits", "SiBarrelVertexRawHitAssociations",
-        "SiBarrelVertexRecHits"},
-       {"TrackerEndcapHits", "SiEndcapTrackerRawHits", "SiEndcapTrackerRawHitAssociations",
-        "SiEndcapTrackerRecHits"},
-       {"TOFBarrelHits", "TOFBarrelRawHits", "TOFBarrelRawHitAssociations", "TOFBarrelRecHits"},
-       {"TOFEndcapHits", "TOFEndcapRawHits", "TOFEndcapRawHitAssociations", "TOFEndcapRecHits"},
-       {"MPGDBarrelHits", "MPGDBarrelRawHits", "MPGDBarrelRawHitAssociations", "MPGDBarrelRecHits"},
-       {"OuterMPGDBarrelHits", "OuterMPGDBarrelRawHits", "OuterMPGDBarrelRawHitAssociations",
-        "OuterMPGDBarrelRecHits"},
-       {"BackwardMPGDEndcapHits", "BackwardMPGDEndcapRawHits",
-        "BackwardMPGDEndcapRawHitAssociations", "BackwardMPGDEndcapRecHits"},
-       {"ForwardMPGDEndcapHits", "ForwardMPGDEndcapRawHits", "ForwardMPGDEndcapRawHitAssociations",
-        "ForwardMPGDEndcapRecHits"},
-       {"B0TrackerHits", "B0TrackerRawHits", "B0TrackerRawHitAssociations", "B0TrackerRecHits"}};
-
-  // Filter out collections that are not present in the current configuration
-  std::vector<std::string> input_rec_collections;
-  std::vector<std::string> input_raw_assoc_collections;
-  auto readouts = app->GetService<DD4hep_service>()->detector()->readouts();
-  for (const auto& [hit_collection, raw_collection, raw_assoc_collection, rec_collection] :
-       possible_collections) {
-    if (readouts.find(hit_collection) != readouts.end()) {
-      // Add the collection to the list of input collections
-      input_rec_collections.push_back(rec_collection);
-      input_raw_assoc_collections.push_back(raw_assoc_collection);
-    }
-  }
-
   // Tracker hits collector
-  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::TrackerHit>>(
-      "CentralTrackingRecHits", input_rec_collections,
+  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::TrackerHit, true>>(
+      "CentralTrackingRecHits",
+      {"SiBarrelTrackerRecHits", "SiBarrelVertexRecHits", "SiEndcapTrackerRecHits",
+       "TOFBarrelRecHits", "TOFEndcapRecHits", "MPGDBarrelRecHits", "OuterMPGDBarrelRecHits",
+       "BackwardMPGDEndcapRecHits", "ForwardMPGDEndcapRecHits", "B0TrackerRecHits"},
       {"CentralTrackingRecHits"}, // Output collection name
       app));
 
   // Tracker hit associations collector
-  app->Add(
-      new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::MCRecoTrackerHitAssociation>>(
-          "CentralTrackingRawHitAssociations", input_raw_assoc_collections,
-          {"CentralTrackingRawHitAssociations"}, // Output collection name
-          app));
+  app->Add(new JOmniFactoryGeneratorT<
+           CollectionCollector_factory<edm4eic::MCRecoTrackerHitAssociation, true>>(
+      "CentralTrackingRawHitAssociations",
+      {"SiBarrelRawHitAssociations", "SiBarrelVertexRawHitAssociations",
+       "SiEndcapTrackerRawHitAssociations", "TOFBarrelRawHitAssociations",
+       "TOFEndcapRawHitAssociations", "MPGDBarrelRawHitAssociations",
+       "OuterMPGDBarrelRawHitAssociations", "BackwardMPGDEndcapRawHitAssociations",
+       "ForwardMPGDEndcapRawHitAssociations", "B0TrackerRawHitAssociations"},
+      {"CentralTrackingRawHitAssociations"}, // Output collection name
+      app));
 
   app->Add(new JOmniFactoryGeneratorT<TrackerMeasurementFromHits_factory>(
       "CentralTrackerMeasurements", {"CentralTrackingRecHits"}, {"CentralTrackerMeasurements"},
@@ -240,36 +210,24 @@ void InitPlugin(JApplication* app) {
       }},
       app));
 
-  std::vector<std::string> input_track_collections, input_track_assoc_collections;
-  std::vector<std::string> input_truth_track_collections, input_truth_track_assoc_collections;
-  //Check size of input_rec_collections to determine if CentralCKFTracks should be added to the input_track_collections
-  if (input_rec_collections.size() > 0) {
-    input_track_collections.push_back("CentralCKFTracks");
-    input_track_assoc_collections.push_back("CentralCKFTrackAssociations");
-    input_truth_track_collections.push_back("CentralCKFTruthSeededTracks");
-    input_truth_track_assoc_collections.push_back("CentralCKFTruthSeededTrackAssociations");
-  }
-  //Check if the TaggerTracker readout is present in the current configuration
-  if (readouts.find("TaggerTrackerHits") != readouts.end()) {
-    input_track_collections.push_back("TaggerTrackerTracks");
-    input_track_assoc_collections.push_back("TaggerTrackerTrackAssociations");
-    input_truth_track_collections.push_back("TaggerTrackerTracks");
-    input_truth_track_assoc_collections.push_back("TaggerTrackerTrackAssociations");
-  }
-
   // Add central and other tracks
-  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::Track>>(
-      "CombinedTracks", input_track_collections, {"CombinedTracks"}, app));
+  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::Track, true>>(
+      "CombinedTracks", {"CentralCKFTracks", "TaggerTrackerTracks"}, {"CombinedTracks"}, app));
+
   app->Add(new JOmniFactoryGeneratorT<
-           CollectionCollector_factory<edm4eic::MCRecoTrackParticleAssociation>>(
-      "CombinedTrackAssociations", input_track_assoc_collections, {"CombinedTrackAssociations"},
-      app));
-  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::Track>>(
-      "CombinedTruthSeededTracks", input_truth_track_collections, {"CombinedTruthSeededTracks"},
-      app));
+           CollectionCollector_factory<edm4eic::MCRecoTrackParticleAssociation, true>>(
+      "CombinedTrackAssociations",
+      {"CentralCKFTrackAssociations", "TaggerTrackerTrackAssociations"},
+      {"CombinedTrackAssociations"}, app));
+
+  app->Add(new JOmniFactoryGeneratorT<CollectionCollector_factory<edm4eic::Track, true>>(
+      "CombinedTruthSeededTracks", {"CentralCKFTruthSeededTracks", "TaggerTrackerTracks"},
+      {"CombinedTruthSeededTracks"}, app));
+
   app->Add(new JOmniFactoryGeneratorT<
-           CollectionCollector_factory<edm4eic::MCRecoTrackParticleAssociation>>(
-      "CombinedTruthSeededTrackAssociations", input_truth_track_assoc_collections,
+           CollectionCollector_factory<edm4eic::MCRecoTrackParticleAssociation, true>>(
+      "CombinedTruthSeededTrackAssociations",
+      {"CentralCKFTruthSeededTrackAssociations", "TaggerTrackerTrackAssociations"},
       {"CombinedTruthSeededTrackAssociations"}, app));
 
   app->Add(new JOmniFactoryGeneratorT<TracksToParticles_factory>(