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/GenericBoundTrackParameters.hpp>
0007 #include <Acts/EventData/MeasurementHelpers.hpp>
0008 #include <Acts/EventData/MultiTrajectory.hpp>
0009 #include <Acts/EventData/SourceLink.hpp>
0010 #include <Acts/EventData/TrackContainer.hpp>
0011 #include <Acts/EventData/TrackProxy.hpp>
0012 #include <Acts/EventData/TrackStatePropMask.hpp>
0013 #include <Acts/EventData/VectorMultiTrajectory.hpp>
0014 #include <Acts/EventData/VectorTrackContainer.hpp>
0015 #include <Acts/Surfaces/Surface.hpp>
0016 #if (Acts_VERSION_MAJOR >= 37) && (Acts_VERSION_MAJOR < 43)
0017 #include <Acts/Utilities/Iterator.hpp>
0018 #endif
0019 #include <ActsExamples/EventData/IndexSourceLink.hpp>
0020 #include <ActsExamples/EventData/Track.hpp>
0021 #include <ActsExamples/EventData/Trajectories.hpp>
0022 #include <boost/container/flat_set.hpp>
0023 #include <boost/container/vector.hpp>
0024 #include <edm4eic/Measurement2DCollection.h>
0025 #include <Eigen/LU>
0026 #include <any>
0027 #include <cstddef>
0028 #include <optional>
0029 #include <string>
0030 #include <utility>
0031
0032 #include "Acts/Utilities/Logger.hpp"
0033 #include "AmbiguitySolverConfig.h"
0034 #include "extensions/spdlog/SpdlogFormatters.h" // IWYU pragma: keep
0035 #include "extensions/spdlog/SpdlogToActs.h"
0036
0037 namespace eicrecon {
0038
0039 Acts::GreedyAmbiguityResolution::Config
0040 transformConfig(const eicrecon::AmbiguitySolverConfig& cfg) {
0041   Acts::GreedyAmbiguityResolution::Config result;
0042   result.maximumSharedHits = cfg.maximum_shared_hits;
0043   result.maximumIterations = cfg.maximum_iterations;
0044   result.nMeasurementsMin  = cfg.n_measurements_min;
0045   return result;
0046 }
0047
0048 static std::size_t sourceLinkHash(const Acts::SourceLink& a) {
0049   return static_cast<std::size_t>(a.get<ActsExamples::IndexSourceLink>().index());
0050 }
0051
0052 static bool sourceLinkEquality(const Acts::SourceLink& a, const Acts::SourceLink& b) {
0053   return a.get<ActsExamples::IndexSourceLink>().index() ==
0054          b.get<ActsExamples::IndexSourceLink>().index();
0055 }
0056
0057 AmbiguitySolver::AmbiguitySolver() = default;
0058
0059 void AmbiguitySolver::init(std::shared_ptr<spdlog::logger> log) {
0060
0061   m_log         = log;
0062   m_acts_logger = eicrecon::getSpdlogLogger("AmbiguitySolver", m_log);
0063   m_acts_cfg    = transformConfig(m_cfg);
0064   m_core        = std::make_unique<Acts::GreedyAmbiguityResolution>(m_acts_cfg, logger().clone());
0065 }
0066
0067 std::tuple<std::vector<ActsExamples::ConstTrackContainer*>,
0068            std::vector<ActsExamples::Trajectories*>>
0069 AmbiguitySolver::process(std::vector<const ActsExamples::ConstTrackContainer*> input_container,
0070                          const edm4eic::Measurement2DCollection& /* meas2Ds */) {
0071
0072   // Assuming ActsExamples::ConstTrackContainer is compatible with Acts::ConstVectorTrackContainer
0073   // Create track container
0074   std::vector<ActsExamples::Trajectories*> output_trajectories;
0075   std::vector<ActsExamples::ConstTrackContainer*> output_tracks;
0076
0077   if (input_container.empty()) {
0078     return std::make_tuple(std::move(output_tracks), std::move(output_trajectories));
0079   }
0080
0081   auto& input_trks = input_container.front();
0082   Acts::GreedyAmbiguityResolution::State state;
0083   m_core->computeInitialState(*input_trks, state, &sourceLinkHash, &sourceLinkEquality);
0084   m_core->resolve(state);
0085
0086   ActsExamples::TrackContainer solvedTracks{std::make_shared<Acts::VectorTrackContainer>(),
0087                                             std::make_shared<Acts::VectorMultiTrajectory>()};
0088   solvedTracks.ensureDynamicColumns(*input_trks);
0089
0090   for (auto iTrack : state.selectedTracks) {
0091
0092     auto destProxy = solvedTracks.getTrack(solvedTracks.addTrack());
0093     auto srcProxy  = input_trks->getTrack(state.trackTips.at(iTrack));
0094 #if Acts_VERSION_MAJOR >= 44
0095     destProxy.copyFromWithoutStates(srcProxy);
0096 #else
0097     destProxy.copyFrom(srcProxy, false);
0098 #endif
0099     destProxy.tipIndex() = srcProxy.tipIndex();
0100   }
0101
0102   output_tracks.push_back(new ActsExamples::ConstTrackContainer(
0103       std::make_shared<Acts::ConstVectorTrackContainer>(std::move(solvedTracks.container())),
0104       input_trks->trackStateContainerHolder()));
0105
0106   //Make output trajectories
0107   ActsExamples::Trajectories::IndexedParameters parameters;
0108   std::vector<Acts::MultiTrajectoryTraits::IndexType> tips;
0109
0110   for (const auto& track : *(output_tracks.front())) {
0111
0112     tips.clear();
0113     parameters.clear();
0114
0115     tips.push_back(track.tipIndex());
0116     parameters.emplace(std::pair{
0117         track.tipIndex(),
0118         ActsExamples::TrackParameters{track.referenceSurface().getSharedPtr(), track.parameters(),
0119                                       track.covariance(), track.particleHypothesis()}});
0120
0121     output_trajectories.push_back(new ActsExamples::Trajectories(
0122         ((*output_tracks.front())).trackStateContainer(), tips, parameters));
0123   }
0124
0125   return std::make_tuple(std::move(output_tracks), std::move(output_trajectories));
0126 }
0127
0128 } // namespace eicrecon