feat: use algorithms logger service in IrtCherenkovParticleID

cmake/jana_plugin.cmake

@@ -240,6 +240,19 @@ macro(plugin_add_algorithms _name)
     find_package(algorithms REQUIRED)
   endif()
 
+  if(${_name}_WITH_LIBRARY)
+    target_compile_definitions(
+      ${PLUGIN_NAME}_library
+      PRIVATE "algorithms_VERSION_MAJOR=${algorithms_VERSION_MAJOR}"
+              "algorithms_VERSION_MINOR=${algorithms_VERSION_MINOR}")
+  endif()
+  if(${_name}_WITH_PLUGIN)
+    target_compile_definitions(
+      ${PLUGIN_NAME}_plugin
+      PRIVATE "algorithms_VERSION_MAJOR=${algorithms_VERSION_MAJOR}"
+              "algorithms_VERSION_MINOR=${algorithms_VERSION_MINOR}")
+  endif()
+
   plugin_link_libraries(${_name} algorithms::algocore)
 
 endmacro()

src/algorithms/pid/IrtCherenkovParticleID.h

@@ -11,18 +11,16 @@
 #include <edm4eic/MCRecoTrackerHitAssociationCollection.h>
 #include <edm4eic/RawTrackerHitCollection.h>
 #include <edm4eic/TrackSegmentCollection.h>
-#include <spdlog/logger.h>
 #include <stdint.h>
 #include <map>
-#include <memory>
 #include <string>
 #include <string_view>
 #include <unordered_map>
 
 // EICrecon
-#include "IrtCherenkovParticleIDConfig.h"
 #include "algorithms/interfaces/ParticleSvc.h"
 #include "algorithms/interfaces/WithPodConfig.h"
+#include "algorithms/pid/IrtCherenkovParticleIDConfig.h"
 
 namespace eicrecon {
 
@@ -51,12 +49,18 @@ class IrtCherenkovParticleID : public IrtCherenkovParticleIDAlgorithm,
                                         {"outputAerogelParticleIDs", "outputGasParticleIDs"},
                                         "Effectively 'zip' the input particle IDs"} {}
 
-  void init(CherenkovDetectorCollection* irt_det_coll, std::shared_ptr<spdlog::logger>& logger);
+  // FIXME: init() must not take arguments
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat"
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Woverloaded-virtual"
+  void init(CherenkovDetectorCollection* irt_det_coll);
+#pragma clang diagnostic pop
+#pragma GCC diagnostic pop
 
   void process(const Input&, const Output&) const;
 
 private:
-  std::shared_ptr<spdlog::logger> m_log;
   CherenkovDetectorCollection* m_irt_det_coll;
   CherenkovDetector* m_irt_det;
 
@@ -67,4 +71,5 @@ class IrtCherenkovParticleID : public IrtCherenkovParticleIDAlgorithm,
   std::unordered_map<int, double> m_pdg_mass;
   std::map<std::string, CherenkovRadiator*> m_pid_radiators;
 };
+
 } // namespace eicrecon

src/algorithms/pid/IrtCherenkovParticleIDConfig.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <Evaluator/DD4hepUnits.h>
+#include <algorithms/logger.h>
 #include <spdlog/spdlog.h>
 
 namespace eicrecon {
@@ -45,43 +46,31 @@ class IrtCherenkovParticleIDConfig {
   //
   /////////////////////////////////////////////////////
 
-  // print warnings about cheat modes
-  void PrintCheats(std::shared_ptr<spdlog::logger> m_log,
-                   spdlog::level::level_enum lvl = spdlog::level::debug, bool printAll = false) {
-    auto print_param = [&m_log, &lvl, &printAll](auto name, bool val, auto desc) {
-      if (printAll)
-        m_log->log(lvl, "  {:>20} = {:<}", name, val);
-      else if (val)
-        m_log->warn("CHEAT MODE '{}' ENABLED: {}", name, desc);
-    };
-    print_param("cheatPhotonVertex", cheatPhotonVertex,
-                "use MC photon vertex, wavelength, refractive index");
-    print_param("cheatTrueRadiator", cheatTrueRadiator, "use MC truth to obtain true radiator");
-  }
-
   // boolean: true if any cheat mode is enabled
   bool CheatModeEnabled() const { return cheatPhotonVertex || cheatTrueRadiator; }
 
-  // print all parameters
-  void Print(std::shared_ptr<spdlog::logger> m_log,
-             spdlog::level::level_enum lvl = spdlog::level::debug) {
-    m_log->log(lvl, "{:=^60}", " IrtCherenkovParticleIDConfig Settings ");
-    auto print_param = [&m_log, &lvl](auto name, auto val) {
-      m_log->log(lvl, "  {:>20} = {:<}", name, val);
+  // stream all parameters
+  friend std::ostream& operator<<(std::ostream& os, const IrtCherenkovParticleIDConfig& cfg) {
+    os << fmt::format("{:=^60}", " IrtCherenkovParticleIDConfig Settings ") << std::endl;
+    auto print_param = [&os](auto name, auto val) {
+      os << fmt::format("  {:>20} = {:<}", name, val) << std::endl;
     };
-    print_param("numRIndexBins", numRIndexBins);
-    PrintCheats(m_log, lvl, true);
-    m_log->log(lvl, "pdgList:");
-    for (const auto& pdg : pdgList)
-      m_log->log(lvl, "  {}", pdg);
-    for (const auto& [name, rad] : radiators) {
-      m_log->log(lvl, "{:-<60}", fmt::format("--- {} config ", name));
+    print_param("numRIndexBins", cfg.numRIndexBins);
+    print_param("cheatPhotonVertex", cfg.cheatPhotonVertex);
+    print_param("cheatTrueRadiator", cfg.cheatTrueRadiator);
+    os << "pdgList:" << std::endl;
+    for (const auto& pdg : cfg.pdgList)
+      os << fmt::format("  {}", pdg) << std::endl;
+    for (const auto& [name, rad] : cfg.radiators) {
+      os << fmt::format("{:-<60}", fmt::format("--- {} config ", name)) << std::endl;
       print_param("smearingMode", rad.smearingMode);
       print_param("smearing", rad.smearing);
       print_param("referenceRIndex", rad.referenceRIndex);
       print_param("attenuation", rad.attenuation);
     }
-    m_log->log(lvl, "{:=^60}", "");
-  }
+    os << fmt::format("{:=^60}", "") << std::endl;
+    return os;
+  };
 };
+
 } // namespace eicrecon

src/algorithms/pid/MergeParticleID.cc

@@ -3,13 +3,13 @@
 
 #include "MergeParticleID.h"
 
+#include <algorithms/logger.h>
 #include <edm4eic/CherenkovParticleIDHypothesis.h>
 #include <edm4eic/TrackSegmentCollection.h>
 #include <edm4hep/Vector2f.h>
 #include <fmt/core.h>
 #include <podio/ObjectID.h>
 #include <podio/RelationRange.h>
-#include <spdlog/common.h>
 #include <cstddef>
 #include <gsl/pointers>
 #include <stdexcept>
@@ -21,10 +21,7 @@
 
 namespace eicrecon {
 
-void MergeParticleID::init(std::shared_ptr<spdlog::logger>& logger) {
-  m_log = logger;
-  m_cfg.Print(m_log, spdlog::level::debug);
-}
+void MergeParticleID::init() { debug() << m_cfg << endmsg; }
 
 void MergeParticleID::process(const MergeParticleID::Input& input,
                               const MergeParticleID::Output& output) const {
@@ -68,25 +65,25 @@ void MergeParticleID::process(const MergeParticleID::Input& input,
   std::unordered_map<decltype(podio::ObjectID::index),
                      std::vector<std::pair<std::size_t, std::size_t>>>
       particle_pids;
-  m_log->trace("{:-<70}", "Build `particle_pids` indexing data structure ");
+  trace("{:-<70}", "Build `particle_pids` indexing data structure ");
 
   // loop over list of PID collections
   for (std::size_t idx_coll = 0; idx_coll < in_pid_collections_list.size(); idx_coll++) {
     const auto& in_pid_collection = in_pid_collections_list.at(idx_coll);
-    m_log->trace("idx_col={}", idx_coll);
+    trace("idx_col={}", idx_coll);
 
     // loop over this PID collection
     for (std::size_t idx_pid = 0; idx_pid < in_pid_collection->size(); idx_pid++) {
       // make the index pair
       const auto& in_pid                   = in_pid_collection->at(idx_pid);
       auto& charged_particle_track_segment = in_pid.getChargedParticle();
       if (!charged_particle_track_segment.isAvailable()) {
-        m_log->error("PID object found with no charged particle");
+        error("PID object found with no charged particle");
         continue;
       }
       auto id_particle = charged_particle_track_segment.getObjectID().index;
       auto idx_paired  = std::make_pair(idx_coll, idx_pid);
-      m_log->trace("  idx_pid={}  id_particle={}", idx_pid, id_particle);
+      trace("  idx_pid={}  id_particle={}", idx_pid, id_particle);
 
       // insert in `particle_pids`
       auto it = particle_pids.find(id_particle);
@@ -98,26 +95,26 @@ void MergeParticleID::process(const MergeParticleID::Input& input,
   }
 
   // trace logging
-  if (m_log->level() <= spdlog::level::trace) {
-    m_log->trace("{:-<70}", "Resulting `particle_pids` ");
+  if (level() <= algorithms::LogLevel::kTrace) {
+    trace("{:-<70}", "Resulting `particle_pids` ");
     for (auto& [id_particle, idx_paired_list] : particle_pids) {
-      m_log->trace("id_particle={}", id_particle);
+      trace("id_particle={}", id_particle);
       for (auto& [idx_coll, idx_pid] : idx_paired_list)
-        m_log->trace("  (idx_coll, idx_pid) = ({}, {})", idx_coll, idx_pid);
+        trace("  (idx_coll, idx_pid) = ({}, {})", idx_coll, idx_pid);
     }
   }
 
   // --------------------------------------------------------------------------------
 
   // loop over charged particles, combine weights from the associated `CherenkovParticleID` objects
   // and create a merged output `CherenkovParticleID` object
-  m_log->trace("{:-<70}", "Begin Merging PID Objects ");
+  trace("{:-<70}", "Begin Merging PID Objects ");
   for (auto& [id_particle, idx_paired_list] : particle_pids) {
 
     // trace logging
-    m_log->trace("Charged Particle:");
-    m_log->trace("  id = {}", id_particle);
-    m_log->trace("  PID Hypotheses:");
+    trace("Charged Particle:");
+    trace("  id = {}", id_particle);
+    trace("  PID Hypotheses:");
 
     // create mutable output `CherenkovParticleID` object `out_pid`
     auto out_pid                                            = out_pids->create();
@@ -135,9 +132,8 @@ void MergeParticleID::process(const MergeParticleID::Input& input,
       const auto& in_pid = in_pid_collections_list.at(idx_coll)->at(idx_pid);
 
       // logging
-      m_log->trace("    Hypotheses for PID result (idx_coll, idx_pid) = ({}, {}):", idx_coll,
-                   idx_pid);
-      Tools::PrintHypothesisTableHead(m_log, 6);
+      trace("    Hypotheses for PID result (idx_coll, idx_pid) = ({}, {}):", idx_coll, idx_pid);
+      trace(Tools::HypothesisTableHead(6));
 
       // merge scalar members
       out_npe += in_pid.getNpe();                                           // sum
@@ -154,7 +150,7 @@ void MergeParticleID::process(const MergeParticleID::Input& input,
 
       // merge PDG hypotheses, combining their weights and other members
       for (auto in_hyp : in_pid.getHypotheses()) {
-        Tools::PrintHypothesisTableLine(m_log, in_hyp, 6);
+        trace(Tools::HypothesisTableLine(in_hyp, 6));
         auto out_hyp_it = pdg_2_out_hyp.find(in_hyp.PDG);
         if (out_hyp_it == pdg_2_out_hyp.end()) {
           edm4eic::CherenkovParticleIDHypothesis out_hyp;
@@ -194,10 +190,10 @@ void MergeParticleID::process(const MergeParticleID::Input& input,
       out_pid.addToHypotheses(out_hyp);
 
     // logging: print merged hypothesis table
-    m_log->trace("    => merged hypothesis weights:");
-    Tools::PrintHypothesisTableHead(m_log, 6);
+    trace("    => merged hypothesis weights:");
+    trace(Tools::HypothesisTableHead(6));
     for (auto out_hyp : out_pid.getHypotheses())
-      Tools::PrintHypothesisTableLine(m_log, out_hyp, 6);
+      trace(Tools::HypothesisTableLine(out_hyp, 6));
 
   } // end `particle_pids` loop over charged particles
 }

src/algorithms/pid/MergeParticleID.h

@@ -8,15 +8,13 @@
 // data model
 #include <algorithms/algorithm.h>
 #include <edm4eic/CherenkovParticleIDCollection.h>
-#include <spdlog/logger.h>
-#include <memory>
 #include <string>
 #include <string_view>
 #include <vector>
 
 // EICrecon
-#include "MergeParticleIDConfig.h"
 #include "algorithms/interfaces/WithPodConfig.h"
+#include "algorithms/pid/MergeParticleIDConfig.h"
 
 namespace eicrecon {
 
@@ -34,15 +32,13 @@ class MergeParticleID : public MergeParticleIDAlgorithm,
                                  {"outputTrackSegments"},
                                  "Effectively 'zip' the input particle IDs"} {}
 
-  void init(std::shared_ptr<spdlog::logger>& logger);
+  void init();
 
   // - input: a list of particle ID collections, which we want to merge together
   // - output: the merged particle ID collection
   // - overload this function to support different collections from other PID subsystems, or to support
   //   merging PID results from overlapping subsystems
   void process(const Input&, const Output&) const final;
-
-private:
-  std::shared_ptr<spdlog::logger> m_log;
 };
+
 } // namespace eicrecon

src/algorithms/pid/MergeParticleIDConfig.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <algorithms/logger.h>
 #include <spdlog/spdlog.h>
 
 namespace eicrecon {
@@ -20,15 +21,17 @@ class MergeParticleIDConfig {
   //
   /////////////////////////////////////////////////////
 
-  // print all parameters
-  void Print(std::shared_ptr<spdlog::logger> m_log,
-             spdlog::level::level_enum lvl = spdlog::level::debug) {
-    m_log->log(lvl, "{:=^60}", " MergeParticleIDConfig Settings ");
-    auto print_param = [&m_log, &lvl](auto name, auto val) {
-      m_log->log(lvl, "  {:>20} = {:<}", name, val);
+  // stream all parameters
+  friend std::ostream& operator<<(std::ostream& os, const MergeParticleIDConfig& cfg) {
+    // print all parameters
+    os << fmt::format("{:=^60}", " MergeParticleIDConfig Settings ") << std::endl;
+    auto print_param = [&os](auto name, auto val) {
+      os << fmt::format("  {:>20} = {:<}", name, val) << std::endl;
     };
-    print_param("mergeMode", mergeMode);
-    m_log->log(lvl, "{:=^60}", "");
+    print_param("mergeMode", cfg.mergeMode);
+    os << fmt::format("{:=^60}", "") << std::endl;
+    return os;
   }
 };
+
 } // namespace eicrecon