algorithms/tracking/AmbiguitySolver.cc

0001 // SPDX-License-Identifier: LGPL-3.0-or-later
0002 // Copyright (C) 2024 Minjung Kim, Barak Schmookler
0003 #include "AmbiguitySolver.h"
0004
0005 #include <Acts/AmbiguityResolution/GreedyAmbiguityResolution.hpp>
0006 #include <Acts/EventData/MeasurementHelpers.hpp>
0007 #include <Acts/EventData/SourceLink.hpp>
0008 #include <Acts/EventData/TrackStatePropMask.hpp>
0009 #include <Acts/EventData/VectorMultiTrajectory.hpp>
0010 #include <Acts/EventData/VectorTrackContainer.hpp>
0011 #include <ActsExamples/EventData/IndexSourceLink.hpp>
0012 #include <ActsExamples/EventData/Track.hpp>
0013 #include <boost/container/flat_set.hpp>
0014 #include <spdlog/common.h>
0015 #include <Eigen/Core>
0016 #include <Eigen/LU> // IWYU pragma: keep
0017 #include <any>
0018 #include <cstddef>
0019 #include <string>
0020 #include <tuple>
0021 #include <utility>
0022 #include <vector>
0023
0024 #include "Acts/Utilities/Logger.hpp"
0025 #include "AmbiguitySolverConfig.h"
0026 #include "extensions/spdlog/SpdlogFormatters.h" // IWYU pragma: keep
0027 #include "extensions/spdlog/SpdlogToActs.h"
0028
0029 namespace eicrecon {
0030
0031 Acts::GreedyAmbiguityResolution::Config
0032 transformConfig(const eicrecon::AmbiguitySolverConfig& cfg) {
0033   Acts::GreedyAmbiguityResolution::Config result;
0034   result.maximumSharedHits = cfg.maximum_shared_hits;
0035   result.maximumIterations = cfg.maximum_iterations;
0036   result.nMeasurementsMin  = cfg.n_measurements_min;
0037   return result;
0038 }
0039
0040 static std::size_t sourceLinkHash(const Acts::SourceLink& a) {
0041   return static_cast<std::size_t>(a.get<ActsExamples::IndexSourceLink>().index());
0042 }
0043
0044 static bool sourceLinkEquality(const Acts::SourceLink& a, const Acts::SourceLink& b) {
0045   return a.get<ActsExamples::IndexSourceLink>().index() ==
0046          b.get<ActsExamples::IndexSourceLink>().index();
0047 }
0048
0049 void AmbiguitySolver::init() {
0050   // Convert algorithm log level to Acts log level
0051   const auto spdlog_level = static_cast<spdlog::level::level_enum>(this->level());
0052   const auto acts_level   = eicrecon::SpdlogToActsLevel(spdlog_level);
0053
0054   // Create Acts logger with appropriate level
0055   m_acts_logger = Acts::getDefaultLogger("AmbiguitySolver", acts_level);
0056   m_acts_cfg    = transformConfig(m_cfg);
0057   m_core = std::make_unique<Acts::GreedyAmbiguityResolution>(m_acts_cfg, acts_logger().clone());
0058 }
0059
0060 void AmbiguitySolver::process(const Input& input, const Output& output) const {
0061   const auto [input_track_states, input_tracks] = input;
0062   auto [output_track_states, output_tracks]     = output;
0063
0064   // Construct ConstTrackContainer from underlying containers
0065   auto trackStateContainer =
0066       std::make_shared<Acts::ConstVectorMultiTrajectory>(*input_track_states);
0067   auto trackContainer = std::make_shared<Acts::ConstVectorTrackContainer>(*input_tracks);
0068   ActsExamples::ConstTrackContainer input_trks(trackContainer, trackStateContainer);
0069
0070   Acts::GreedyAmbiguityResolution::State state;
0071   m_core->computeInitialState(input_trks, state, &sourceLinkHash, &sourceLinkEquality);
0072   m_core->resolve(state);
0073
0074   ActsExamples::TrackContainer solvedTracks{std::make_shared<Acts::VectorTrackContainer>(),
0075                                             std::make_shared<Acts::VectorMultiTrajectory>()};
0076   solvedTracks.ensureDynamicColumns(input_trks);
0077
0078   for (auto iTrack : state.selectedTracks) {
0079     auto destProxy = solvedTracks.makeTrack();
0080     auto srcProxy  = input_trks.getTrack(state.trackTips.at(iTrack));
0081     destProxy.copyFrom(srcProxy);
0082   }
0083
0084   // Allocate new const containers and assign pointers to outputs
0085   *output_track_states =
0086       new Acts::ConstVectorMultiTrajectory(std::move(solvedTracks.trackStateContainer()));
0087   *output_tracks = new Acts::ConstVectorTrackContainer(std::move(solvedTracks.container()));
0088 }
0089
0090 } // namespace eicrecon