Add Truthiness collection output if it exists

Author: wdconinc

src/algorithms/reco/Truthiness.cc

@@ -13,19 +13,38 @@
 #include <cmath>
 #include <set>
 
+#if __has_include(<edm4eic/Truthiness.h>)
+#include <edm4eic/Truthiness.h>
+#include <edm4eic/TruthinessCollection.h>
+#endif
+
 namespace eicrecon {
 
-void Truthiness::process(const Truthiness::Input& input,
-                         const Truthiness::Output& /* output */) const {
+void Truthiness::process(const Truthiness::Input& input, const Truthiness::Output& output) const {
 
   const auto [mc_particles, rc_particles, associations] = input;
 
-  double truthiness = 0.0;
+  double truthiness                  = 0.0;
+  double total_pid_contribution      = 0.0;
+  double total_energy_contribution   = 0.0;
+  double total_momentum_contribution = 0.0;
 
   // Track which MC particles and reconstructed particles are covered by associations
   std::set<edm4hep::MCParticle> associated_mc_particles;
   std::set<edm4eic::ReconstructedParticle> associated_rc_particles;
 
+#if __has_include(<edm4eic/Truthiness.h>)
+  // Vectors to store per-association contributions
+  std::vector<float> assoc_truthiness_vec;
+  std::vector<float> assoc_pid_vec;
+  std::vector<float> assoc_energy_vec;
+  std::vector<float> assoc_momentum_vec;
+  assoc_truthiness_vec.reserve(associations->size());
+  assoc_pid_vec.reserve(associations->size());
+  assoc_energy_vec.reserve(associations->size());
+  assoc_momentum_vec.reserve(associations->size());
+#endif
+
   // Process all associations
   for (const auto& assoc : *associations) {
     const auto& mc_part = assoc.getSim();
@@ -66,14 +85,30 @@ void Truthiness::process(const Truthiness::Input& input,
           momentum_penalty, pdg_penalty);
 
     truthiness += assoc_penalty;
+    total_pid_contribution += pdg_penalty;
+    total_energy_contribution += energy_penalty;
+    total_momentum_contribution += momentum_penalty;
+
+#if __has_include(<edm4eic/Truthiness.h>)
+    assoc_truthiness_vec.push_back(static_cast<float>(assoc_penalty));
+    assoc_pid_vec.push_back(static_cast<float>(pdg_penalty));
+    assoc_energy_vec.push_back(static_cast<float>(energy_penalty));
+    assoc_momentum_vec.push_back(static_cast<float>(momentum_penalty));
+#endif
   }
 
   // Penalty for unassociated charged MC particles with generator status 2
   int unassociated_mc_count = 0;
+#if __has_include(<edm4eic/Truthiness.h>)
+  std::vector<edm4hep::MCParticle> unassociated_mc_vec;
+#endif
   for (const auto& mc_part : *mc_particles) {
     if (mc_part.getGeneratorStatus() == 2 && mc_part.getCharge() != 0.0) {
       if (associated_mc_particles.find(mc_part) == associated_mc_particles.end()) {
         unassociated_mc_count++;
+#if __has_include(<edm4eic/Truthiness.h>)
+        unassociated_mc_vec.push_back(mc_part);
+#endif
         trace("Unassociated MC particle: PDG={}, charge={:.1f}, status={}", mc_part.getPDG(),
               mc_part.getCharge(), mc_part.getGeneratorStatus());
       }
@@ -86,9 +121,15 @@ void Truthiness::process(const Truthiness::Input& input,
 
   // Penalty for unassociated reconstructed particles
   int unassociated_rc_count = 0;
+#if __has_include(<edm4eic/Truthiness.h>)
+  std::vector<edm4eic::ReconstructedParticle> unassociated_rc_vec;
+#endif
   for (const auto& rc_part : *rc_particles) {
     if (associated_rc_particles.find(rc_part) == associated_rc_particles.end()) {
       unassociated_rc_count++;
+#if __has_include(<edm4eic/Truthiness.h>)
+      unassociated_rc_vec.push_back(rc_part);
+#endif
       trace("Unassociated reconstructed particle: PDG={}, E={:.3f}, p=[{:.3f},{:.3f},{:.3f}]",
             rc_part.getPDG(), rc_part.getEnergy(), rc_part.getMomentum().x, rc_part.getMomentum().y,
             rc_part.getMomentum().z);
@@ -107,6 +148,45 @@ void Truthiness::process(const Truthiness::Input& input,
   // Report final truthiness
   debug("Event truthiness: {:.6f} (from {} associations, {} unassociated MC, {} unassociated RC)",
         truthiness, associations->size(), unassociated_mc_count, unassociated_rc_count);
+
+#if __has_include(<edm4eic/Truthiness.h>)
+  // Create output collection if available
+  const auto [truthiness_output] = output;
+  auto truthiness_obj            = truthiness_output->create();
+
+  // Set scalar values
+  truthiness_obj.setEvent_truthiness(static_cast<float>(truthiness));
+  truthiness_obj.setEvent_pid_contribution(static_cast<float>(total_pid_contribution));
+  truthiness_obj.setEvent_energy_contribution(static_cast<float>(total_energy_contribution));
+  truthiness_obj.setEvent_momentum_contribution(static_cast<float>(total_momentum_contribution));
+  truthiness_obj.setUnassociated_mc_particles_contribution(static_cast<float>(mc_penalty));
+  truthiness_obj.setUnassociated_rc_particles_contribution(static_cast<float>(rc_penalty));
+
+  // Add associations and their contributions
+  for (const auto& assoc : *associations) {
+    truthiness_obj.addToAssociations(assoc);
+  }
+  for (const auto& val : assoc_truthiness_vec) {
+    truthiness_obj.addToAssociation_truthiness(val);
+  }
+  for (const auto& val : assoc_pid_vec) {
+    truthiness_obj.addToAssociation_pid_contribution(val);
+  }
+  for (const auto& val : assoc_energy_vec) {
+    truthiness_obj.addToAssociation_energy_contribution(val);
+  }
+  for (const auto& val : assoc_momentum_vec) {
+    truthiness_obj.addToAssociation_momentum_contribution(val);
+  }
+
+  // Add unassociated particles
+  for (const auto& mc_part : unassociated_mc_vec) {
+    truthiness_obj.addToUnassociated_mc_particles(mc_part);
+  }
+  for (const auto& rc_part : unassociated_rc_vec) {
+    truthiness_obj.addToUnassociated_rc_particles(rc_part);
+  }
+#endif
 }
 
 } // namespace eicrecon

src/algorithms/reco/Truthiness.h

@@ -10,16 +10,26 @@
 #include <stdint.h>
 #include <string>
 #include <string_view>
+#if __has_include(<edm4eic/Truthiness.h>)
+#include <edm4eic/TruthinessCollection.h>
+#endif
 
 #include "TruthinessConfig.h"
 #include "algorithms/interfaces/WithPodConfig.h"
 
 namespace eicrecon {
 
+#if __has_include(<edm4eic/Truthiness.h>)
+using TruthinessAlgorithm = algorithms::Algorithm<
+    algorithms::Input<edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection,
+                      edm4eic::MCRecoParticleAssociationCollection>,
+    algorithms::Output<edm4eic::TruthinessCollection>>;
+#else
 using TruthinessAlgorithm = algorithms::Algorithm<
     algorithms::Input<edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection,
                       edm4eic::MCRecoParticleAssociationCollection>,
     algorithms::Output<>>;
+#endif
 
 class Truthiness : public TruthinessAlgorithm, public WithPodConfig<TruthinessConfig> {
 
@@ -32,9 +42,14 @@ class Truthiness : public TruthinessAlgorithm, public WithPodConfig<TruthinessCo
       : TruthinessAlgorithm{
             name,
             {"inputMCParticles", "inputReconstructedParticles", "inputAssociations"},
+#if __has_include(<edm4eic/Truthiness.h>)
+            {"outputTruthiness"},
+#else
             {},
+#endif
             "Calculate truthiness metric comparing reconstructed particles to MC "
-            "truth."} {}
+            "truth."} {
+  }
 
   void init() final {};
   void process(const Input&, const Output&) const final;

src/factories/reco/Truthiness_factory.h

@@ -9,6 +9,10 @@
 #include <utility>
 #include <vector>
 
+#if __has_include(<edm4eic/Truthiness.h>)
+#include <edm4eic/TruthinessCollection.h>
+#endif
+
 #include "algorithms/reco/Truthiness.h"
 #include "extensions/jana/JOmniFactory.h"
 #include "services/algorithms_init/AlgorithmsInit_service.h"
@@ -27,6 +31,10 @@ class Truthiness_factory : public JOmniFactory<Truthiness_factory> {
   FactoryT::PodioInput<edm4eic::ReconstructedParticle> m_rc_particles_input{this};
   FactoryT::PodioInput<edm4eic::MCRecoParticleAssociation> m_associations_input{this};
 
+#if __has_include(<edm4eic/Truthiness.h>)
+  FactoryT::PodioOutput<edm4eic::Truthiness> m_truthiness_output{this};
+#endif
+
   FactoryT::Service<AlgorithmsInit_service> m_algorithmsInit{this};
 
 public:
@@ -37,7 +45,12 @@ class Truthiness_factory : public JOmniFactory<Truthiness_factory> {
   }
 
   void Process(int32_t /* run_number */, uint64_t /* event_number */) {
+#if __has_include(<edm4eic/Truthiness.h>)
+    m_algo->process({m_mc_particles_input(), m_rc_particles_input(), m_associations_input()},
+                    {m_truthiness_output().get()});
+#else
     m_algo->process({m_mc_particles_input(), m_rc_particles_input(), m_associations_input()}, {});
+#endif
   }
 };
 

src/global/reco/Truthiness_processor.cc

@@ -15,6 +15,10 @@
 #include <map>
 #include <string>
 
+#if __has_include(<edm4eic/Truthiness.h>)
+#include <edm4eic/TruthinessCollection.h>
+#endif
+
 #include "services/log/Log_service.h"
 
 namespace eicrecon {
@@ -64,7 +68,12 @@ void Truthiness_processor::Process(const std::shared_ptr<const JEvent>& event) {
 
   // Call the algorithm
   Truthiness::Input input{mc_particles, rc_particles, associations};
+#if __has_include(<edm4eic/Truthiness.h>)
+  auto truthiness_coll = std::make_unique<edm4eic::TruthinessCollection>();
+  Truthiness::Output output{truthiness_coll.get()};
+#else
   Truthiness::Output output{};
+#endif
   m_algo->process(input, output);
 }
 

src/global/reco/reco.cc

@@ -10,6 +10,9 @@
 #include <edm4eic/MCRecoClusterParticleAssociation.h>
 #include <edm4eic/MCRecoParticleAssociation.h>
 #include <edm4eic/ReconstructedParticle.h>
+#if __has_include(<edm4eic/Truthiness.h>)
+#include <edm4eic/Truthiness.h>
+#endif
 #include <edm4hep/MCParticle.h>
 #include <fmt/core.h>
 #include <map>
@@ -42,6 +45,9 @@
 #include "factories/reco/ScatteredElectronsTruth_factory.h"
 #include "factories/reco/TrackClusterMatch_factory.h"
 #include "factories/reco/TransformBreitFrame_factory.h"
+#if __has_include(<edm4eic/Truthiness.h>)
+#include "factories/reco/Truthiness_factory.h"
+#endif
 #include "factories/reco/UndoAfterBurnerMCParticles_factory.h"
 #include "global/reco/Truthiness_processor.h"
 
@@ -269,7 +275,13 @@ void InitPlugin(JApplication* app) {
   app->Add(new JOmniFactoryGeneratorT<PrimaryVertices_factory>(
       "PrimaryVertices", {"CentralTrackVertices"}, {"PrimaryVertices"}, {}, app));
 
-  // Truthiness metric for event quality assessment
+#if __has_include(<edm4eic/Truthiness.h>)
+  app->Add(new JOmniFactoryGeneratorT<Truthiness_factory>(
+      "Truthiness", {"MCParticles", "ReconstructedParticles", "ReconstructedParticleAssociations"},
+      {"Truthiness"}, {}, app));
+#else
+  // Include as processor if Truthiness output is not available
   app->Add(new Truthiness_processor());
+#endif
 }
 } // extern "C"