feat: implement Truthiness processor for event quality assessment (uses algorithm)

Author: wdconinc

src/algorithms/reco/Truthiness.cc

@@ -58,11 +58,11 @@ void Truthiness::process(const Truthiness::Input& input,
 
     const double assoc_penalty = energy_penalty + momentum_penalty + pdg_penalty;
 
-    debug("Association: MC PDG={} (E={:.3f}, p=[{:.3f},{:.3f},{:.3f}]) <-> "
+    trace("Association: MC PDG={} (E={:.3f}, p=[{:.3f},{:.3f},{:.3f}]) <-> "
           "RC PDG={} (E={:.3f}, p=[{:.3f},{:.3f},{:.3f}])",
           mc_part.getPDG(), mc_energy, mc_momentum.x, mc_momentum.y, mc_momentum.z,
           rc_part.getPDG(), rc_energy, rc_momentum.x, rc_momentum.y, rc_momentum.z);
-    debug("  Energy penalty: {:.6f}, Momentum penalty: {:.6f}, PDG penalty: {:.0f}", energy_penalty,
+    trace("  Energy penalty: {:.6f}, Momentum penalty: {:.6f}, PDG penalty: {:.0f}", energy_penalty,
           momentum_penalty, pdg_penalty);
 
     truthiness += assoc_penalty;
@@ -74,13 +74,13 @@ void Truthiness::process(const Truthiness::Input& input,
     if (mc_part.getGeneratorStatus() == 2 && mc_part.getCharge() != 0.0) {
       if (associated_mc_particles.find(mc_part) == associated_mc_particles.end()) {
         unassociated_mc_count++;
-        debug("Unassociated MC particle: PDG={}, charge={:.1f}, status={}", mc_part.getPDG(),
+        trace("Unassociated MC particle: PDG={}, charge={:.1f}, status={}", mc_part.getPDG(),
               mc_part.getCharge(), mc_part.getGeneratorStatus());
       }
     }
   }
   const double mc_penalty = static_cast<double>(unassociated_mc_count);
-  debug("Unassociated charged MC particles (status 2): {} (penalty: {:.0f})", unassociated_mc_count,
+  trace("Unassociated charged MC particles (status 2): {} (penalty: {:.0f})", unassociated_mc_count,
         mc_penalty);
   truthiness += mc_penalty;
 
@@ -89,19 +89,24 @@ void Truthiness::process(const Truthiness::Input& input,
   for (const auto& rc_part : *rc_particles) {
     if (associated_rc_particles.find(rc_part) == associated_rc_particles.end()) {
       unassociated_rc_count++;
-      debug("Unassociated reconstructed particle: PDG={}, E={:.3f}, p=[{:.3f},{:.3f},{:.3f}]",
+      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);
     }
   }
   const double rc_penalty = static_cast<double>(unassociated_rc_count);
-  debug("Unassociated reconstructed particles: {} (penalty: {:.0f})", unassociated_rc_count,
+  trace("Unassociated reconstructed particles: {} (penalty: {:.0f})", unassociated_rc_count,
         rc_penalty);
   truthiness += rc_penalty;
 
+  // Update statistics using online updating formula
+  // avg_n = avg_(n-1) + (x_n - avg_(n-1)) / n
+  m_event_count++;
+  m_average_truthiness += (truthiness - m_average_truthiness) / m_event_count;
+
   // Report final truthiness
-  info("Event truthiness: {:.6f} (from {} associations, {} unassociated MC, {} unassociated RC)",
-       truthiness, associations->size(), unassociated_mc_count, unassociated_rc_count);
+  debug("Event truthiness: {:.6f} (from {} associations, {} unassociated MC, {} unassociated RC)",
+        truthiness, associations->size(), unassociated_mc_count, unassociated_rc_count);
 }
 
 } // namespace eicrecon

src/algorithms/reco/Truthiness.h

@@ -22,6 +22,10 @@ using TruthinessAlgorithm = algorithms::Algorithm<
 
 class Truthiness : public TruthinessAlgorithm, public WithPodConfig<TruthinessConfig> {
 
+private:
+  mutable double m_average_truthiness{0.0};
+  mutable uint64_t m_event_count{0};
+
 public:
   Truthiness(std::string_view name)
       : TruthinessAlgorithm{
@@ -33,6 +37,10 @@ class Truthiness : public TruthinessAlgorithm, public WithPodConfig<TruthinessCo
 
   void init() final {};
   void process(const Input&, const Output&) const final;
+
+  // Accessors for statistics
+  double getAverageTruthiness() const { return m_average_truthiness; }
+  uint64_t getEventCount() const { return m_event_count; }
 };
 
 } // namespace eicrecon

src/global/reco/Truthiness_processor.cc

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2025 Wouter Deconinck
+
+#include "Truthiness_processor.h"
+
+#include <JANA/JApplication.h>
+#include <edm4eic/MCRecoParticleAssociationCollection.h>
+#include <edm4eic/ReconstructedParticleCollection.h>
+#include <edm4hep/MCParticleCollection.h>
+#include <string>
+
+#include "services/log/Log_service.h"
+
+namespace eicrecon {
+
+void Truthiness_processor::Init() {
+  std::string plugin_name = "Truthiness";
+  auto* app               = GetApplication();
+
+  // Get logger
+  m_log = app->GetService<Log_service>()->logger(plugin_name);
+
+  // Initialize algorithm
+  m_algo = std::make_unique<Truthiness>(plugin_name);
+  // Set algorithm log level to match processor log level
+  m_algo->level(static_cast<algorithms::LogLevel>(m_log->level()));
+  m_algo->init();
+
+  // Get input collection names from parameters
+  app->SetDefaultParameter(plugin_name + ":inputMCParticles", m_inputMCParticles,
+                           "Name of input MC particles collection");
+  app->SetDefaultParameter(plugin_name + ":inputReconstructedParticles",
+                           m_inputReconstructedParticles,
+                           "Name of input reconstructed particles collection");
+  app->SetDefaultParameter(plugin_name + ":inputAssociations", m_inputAssociations,
+                           "Name of input MC-reco associations collection");
+
+  m_log->info("Initialized with collections: MC='{}', Reco='{}', Assoc='{}'", m_inputMCParticles,
+              m_inputReconstructedParticles, m_inputAssociations);
+}
+
+void Truthiness_processor::Process(const std::shared_ptr<const JEvent>& event) {
+  // Get input collections
+  const auto* mc_particles = event->GetCollection<edm4hep::MCParticle>(m_inputMCParticles);
+  const auto* rc_particles =
+      event->GetCollection<edm4eic::ReconstructedParticle>(m_inputReconstructedParticles);
+  const auto* associations =
+      event->GetCollection<edm4eic::MCRecoParticleAssociation>(m_inputAssociations);
+
+  if (!mc_particles || !rc_particles || !associations) {
+    m_log->debug("Event {}: Missing required collections", event->GetEventNumber());
+    return;
+  }
+
+  m_log->debug("Event {}: Processing {} MC particles, {} reco particles, {} associations",
+               event->GetEventNumber(), mc_particles->size(), rc_particles->size(),
+               associations->size());
+
+  // Call the algorithm
+  Truthiness::Input input{mc_particles, rc_particles, associations};
+  Truthiness::Output output{};
+  m_algo->process(input, output);
+}
+
+void Truthiness_processor::Finish() {
+  if (m_algo) {
+    const auto event_count = m_algo->getEventCount();
+    if (event_count > 0) {
+      const auto average_truthiness = m_algo->getAverageTruthiness();
+      m_log->info("Processed {} events, average truthiness: {:.6f}", event_count,
+                  average_truthiness);
+    } else {
+      m_log->info("No events processed");
+    }
+  }
+}
+
+} // namespace eicrecon

src/global/reco/Truthiness_processor.h

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2025 Wouter Deconinck
+
+#pragma once
+
+#include <JANA/JEventProcessor.h>
+#include <edm4eic/MCRecoParticleAssociationCollection.h>
+#include <edm4eic/ReconstructedParticleCollection.h>
+#include <edm4hep/MCParticleCollection.h>
+#include <memory>
+#include <string>
+#include <spdlog/logger.h>
+
+#include "algorithms/reco/Truthiness.h"
+
+namespace eicrecon {
+
+class Truthiness_processor : public JEventProcessor {
+private:
+  std::unique_ptr<Truthiness> m_algo;
+  std::shared_ptr<spdlog::logger> m_log;
+  std::string m_inputMCParticles{"MCParticles"};
+  std::string m_inputReconstructedParticles{"ReconstructedParticles"};
+  std::string m_inputAssociations{"ReconstructedParticleAssociations"};
+
+public:
+  Truthiness_processor() { SetTypeName(NAME_OF_THIS); }
+
+  void Init() override;
+  void Process(const std::shared_ptr<const JEvent>& event) override;
+  void Finish() override;
+};
+
+} // namespace eicrecon

src/global/reco/reco.cc

@@ -42,8 +42,8 @@
 #include "factories/reco/ScatteredElectronsTruth_factory.h"
 #include "factories/reco/TrackClusterMatch_factory.h"
 #include "factories/reco/TransformBreitFrame_factory.h"
-#include "factories/reco/Truthiness_factory.h"
 #include "factories/reco/UndoAfterBurnerMCParticles_factory.h"
+#include "global/reco/Truthiness_processor.h"
 
 extern "C" {
 void InitPlugin(JApplication* app) {
@@ -270,8 +270,6 @@ void InitPlugin(JApplication* app) {
       "PrimaryVertices", {"CentralTrackVertices"}, {"PrimaryVertices"}, {}, app));
 
   // Truthiness metric for event quality assessment
-  app->Add(new JOmniFactoryGeneratorT<Truthiness_factory>(
-      "Truthiness", {"MCParticles", "ReconstructedParticles", "ReconstructedParticleAssociations"},
-      {}, app));
+  app->Add(new Truthiness_processor());
 }
 } // extern "C"