Implement Charged Candidate Maker (PFA1b)

src/algorithms/CMakeLists.txt

@@ -3,6 +3,7 @@ cmake_minimum_required(VERSION 3.16)
 add_subdirectory(interfaces)
 add_subdirectory(calorimetry)
 add_subdirectory(tracking)
+add_subdirectory(particle)
 add_subdirectory(pid)
 add_subdirectory(pid_lut)
 add_subdirectory(digi)

src/algorithms/particle/CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.16)
+
+set(PLUGIN_NAME "algorithms_particle")
+
+# Function creates ${PLUGIN_NAME}_plugin and ${PLUGIN_NAME}_library targets
+# Setting default includes, libraries and installation paths
+plugin_add(${PLUGIN_NAME} WITH_SHARED_LIBRARY WITHOUT_PLUGIN)
+
+# The macro grabs sources as *.cc *.cpp *.c and headers as *.h *.hh *.hpp Then
+# correctly sets sources for ${_name}_plugin and ${_name}_library targets Adds
+# headers to the correct installation directory
+plugin_glob_all(${PLUGIN_NAME})
+
+# Find dependencies
+plugin_add_algorithms(${PLUGIN_NAME})
+plugin_add_dd4hep(${PLUGIN_NAME})
+plugin_add_event_model(${PLUGIN_NAME})
+plugin_add_eigen3(${PLUGIN_NAME})

src/algorithms/particle/ChargedCandidateMaker.cc

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2025 Derek Anderson
+
+#include <edm4eic/Track.h>
+#include <gsl/pointers>
+#include <map>
+#include <vector>
+
+#include "ChargedCandidateMaker.h"
+
+namespace eicrecon {
+
+// ----------------------------------------------------------------------------
+//! Process inputs
+// ----------------------------------------------------------------------------
+/*! Construct a candidate charged particle via the
+ *  following algorithm.
+ *    1. Build map of tracks onto vectors of their
+ *       matched tracks
+ *    2. For each track, create a Reconstructed
+ *       Particle with track and cluster relations
+ *       filled
+ */
+void ChargedCandidateMaker::process(const ChargedCandidateMaker::Input& input,
+                                    const ChargedCandidateMaker::Output& output) const {
+
+  // grab inputs/outputs
+  const auto [in_match] = input;
+  auto [out_particle]   = output;
+
+  // exit if no matches in collection
+  if (in_match->size() == 0) {
+    debug("No track-cluster matches in collection");
+    return;
+  }
+
+  MapToVecClust mapTrkToClust;
+  for (const auto& match : *in_match) {
+    mapTrkToClust[match.getTrack()].push_back(match.getCluster());
+  }
+
+  for (const auto& [track, clusters] : mapTrkToClust) {
+    edm4eic::MutableReconstructedParticle particle = out_particle->create();
+    particle.addToTracks(track);
+    for (const edm4eic::Cluster& cluster : clusters) {
+      particle.addToClusters(cluster);
+    }
+  }
+} // end 'process(Input&, Output&)'
+} // namespace eicrecon

src/algorithms/particle/ChargedCandidateMaker.h

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2025 Derek Anderson
+
+#pragma once
+
+#include <algorithms/algorithm.h>
+#include <edm4eic/ClusterCollection.h>
+#include <edm4eic/ReconstructedParticleCollection.h>
+#include <edm4eic/Track.h>
+#include <edm4eic/TrackClusterMatchCollection.h>
+#include <podio/ObjectID.h>
+#include <map>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "algorithms/interfaces/WithPodConfig.h"
+
+namespace eicrecon {
+
+// --------------------------------------------------------------------------
+//! Algorithm input/output
+// --------------------------------------------------------------------------
+using ChargedCandidateMakerAlgorithm =
+    algorithms::Algorithm<algorithms::Input<edm4eic::TrackClusterMatchCollection>,
+                          algorithms::Output<edm4eic::ReconstructedParticleCollection>>;
+
+// ==========================================================================
+//! Candidate Charged Particle Maker
+// ==========================================================================
+/*! An algorithm which takes a collection of clusters and their matched
+ *  tracks, subtracts the sum of all tracks pointing to the cluster,
+ *  and outputs the remnant clusters, expected clusters, and their matched
+ *  tracks.
+ */
+class ChargedCandidateMaker : public ChargedCandidateMakerAlgorithm,
+                              public WithPodConfig<NoConfig> {
+
+public:
+  // ------------------------------------------------------------------------
+  //! Comparator struct for tracks
+  // ------------------------------------------------------------------------
+  /*! Organizes tracks by their ObjectIDs in decreasing collection
+   *  ID first, and by decreasing index second.
+   */
+  struct CompareTrack {
+    bool operator()(const edm4eic::Track& lhs, const edm4eic::Track& rhs) const {
+      if (lhs.getObjectID().collectionID == rhs.getObjectID().collectionID) {
+        return (lhs.getObjectID().index < rhs.getObjectID().index);
+      } else {
+        return (lhs.getObjectID().collectionID < rhs.getObjectID().collectionID);
+      }
+    }
+  };
+
+  ///! Alias for a map from a track to matched clusters
+  using MapToVecClust = std::map<edm4eic::Track, std::vector<edm4eic::Cluster>, CompareTrack>;
+
+  ///! Algorithm constructor
+  ChargedCandidateMaker(std::string_view name)
+      : ChargedCandidateMakerAlgorithm{name,
+                                       {"inputTrackClusterMatches"},
+                                       {"outputChargedCandidateParticles"},
+                                       "Forms candidate charged particles."} {}
+
+  // public method
+  void process(const Input&, const Output&) const final;
+
+}; // end ChargedCandidateMaker
+
+} // namespace eicrecon

src/algorithms/particle/ChargedCandidateMaker_factory.h

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Copyright (C) 2025 Derek Anderson
+
+#pragma once
+
+#include <string>
+
+#include "extensions/jana/JOmniFactory.h"
+#include "algorithms/particle/ChargedCandidateMaker.h"
+
+namespace eicrecon {
+
+class ChargedCandidateMaker_factory : public JOmniFactory<ChargedCandidateMaker_factory> {
+
+public:
+  ///! alias for algorithm name
+  using AlgoT = eicrecon::ChargedCandidateMaker;
+
+private:
+  // pointer to algorithm
+  std::unique_ptr<AlgoT> m_algo;
+
+  // input collection
+  PodioInput<edm4eic::TrackClusterMatch> m_track_cluster_match_input{this};
+
+  // output collection
+  PodioOutput<edm4eic::ReconstructedParticle> m_charged_candidate_output{this};
+
+public:
+  ///! Configures algorithm
+  void Configure() {
+    m_algo = std::make_unique<AlgoT>(GetPrefix());
+    m_algo->init();
+  }
+
+  ///! Primary algorithm call
+  void Process(int32_t /*run_number*/, uint64_t /*event_number*/) {
+    m_algo->process({m_track_cluster_match_input()}, {m_charged_candidate_output().get()});
+  }
+}; // end ChargedCandidateMaker_factory
+
+} // namespace eicrecon