AmbiguityResolution/src/ScoreBasedAmbiguityResolutionAlgorithm.cpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #include "ActsExamples/AmbiguityResolution/ScoreBasedAmbiguityResolutionAlgorithm.hpp"
0010
0011 #include "Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.hpp"
0012 #include "Acts/Utilities/Logger.hpp"
0013 #include "ActsExamples/EventData/IndexSourceLink.hpp"
0014 #include "ActsExamples/Framework/ProcessCode.hpp"
0015 #include "ActsPlugins/Json/AmbiguityConfigJsonConverter.hpp"
0016
0017 #include <fstream>
0018
0019 namespace {
0020
0021 Acts::ScoreBasedAmbiguityResolution::Config transformConfig(
0022     const ActsExamples::ScoreBasedAmbiguityResolutionAlgorithm::Config& cfg,
0023     const std::string& configFile) {
0024   Acts::ScoreBasedAmbiguityResolution::Config result;
0025
0026   Acts::ConfigPair configPair;
0027   nlohmann::json json_file;
0028   std::ifstream file(configFile);
0029   if (!file.is_open()) {
0030     std::cerr << "Error opening file: " << configFile << std::endl;
0031     return {};
0032   }
0033   file >> json_file;
0034   file.close();
0035
0036   Acts::from_json(json_file, configPair);
0037
0038   result.volumeMap = configPair.first;
0039   result.detectorConfigs = configPair.second;
0040   result.minScore = cfg.minScore;
0041   result.minScoreSharedTracks = cfg.minScoreSharedTracks;
0042   result.maxSharedTracksPerMeasurement = cfg.maxSharedTracksPerMeasurement;
0043   result.maxShared = cfg.maxShared;
0044   result.minUnshared = cfg.minUnshared;
0045   result.useAmbiguityScoring = cfg.useAmbiguityScoring;
0046   return result;
0047 }
0048
0049 std::size_t sourceLinkHash(const Acts::SourceLink& a) {
0050   return static_cast<std::size_t>(
0051       a.get<ActsExamples::IndexSourceLink>().index());
0052 }
0053
0054 bool sourceLinkEquality(const Acts::SourceLink& a, const Acts::SourceLink& b) {
0055   return a.get<ActsExamples::IndexSourceLink>().index() ==
0056          b.get<ActsExamples::IndexSourceLink>().index();
0057 }
0058
0059 bool doubleHolesFilter(const Acts::TrackProxy<Acts::ConstVectorTrackContainer,
0060                                               Acts::ConstVectorMultiTrajectory,
0061                                               std::shared_ptr, true>& track) {
0062   bool doubleFlag = false;
0063   int counter = 0;
0064   for (const auto& ts : track.trackStatesReversed()) {
0065     auto iTypeFlags = ts.typeFlags();
0066     if (!iTypeFlags.isHole()) {
0067       doubleFlag = false;
0068     }
0069
0070     if (iTypeFlags.isHole()) {
0071       if (doubleFlag) {
0072         counter++;
0073         doubleFlag = false;
0074       } else {
0075         doubleFlag = true;
0076       };
0077     }
0078   }
0079   if (counter > 1) {
0080     return true;
0081   } else {
0082     return false;
0083   }
0084 }
0085
0086 }  // namespace
0087
0088 ActsExamples::ScoreBasedAmbiguityResolutionAlgorithm::
0089     ScoreBasedAmbiguityResolutionAlgorithm(
0090         ActsExamples::ScoreBasedAmbiguityResolutionAlgorithm::Config cfg,
0091         Acts::Logging::Level lvl)
0092     : ActsExamples::IAlgorithm("ScoreBasedAmbiguityResolutionAlgorithm", lvl),
0093       m_cfg(std::move(cfg)),
0094       m_ambi(transformConfig(cfg, m_cfg.configFile), logger().clone()) {
0095   if (m_cfg.inputTracks.empty()) {
0096     throw std::invalid_argument("Missing trajectories input collection");
0097   }
0098   if (m_cfg.outputTracks.empty()) {
0099     throw std::invalid_argument("Missing trajectories output collection");
0100   }
0101   m_inputTracks.initialize(m_cfg.inputTracks);
0102   m_outputTracks.initialize(m_cfg.outputTracks);
0103 }
0104
0105 ActsExamples::ProcessCode
0106 ActsExamples::ScoreBasedAmbiguityResolutionAlgorithm::execute(
0107     const AlgorithmContext& ctx) const {
0108   const auto& tracks = m_inputTracks(ctx);  // Read input data
0109   ACTS_VERBOSE("Number of input tracks: " << tracks.size());
0110
0111   Acts::ScoreBasedAmbiguityResolution::Optionals<ConstTrackProxy> optionals;
0112   optionals.cuts.push_back(doubleHolesFilter);
0113   std::vector<int> goodTracks = m_ambi.solveAmbiguity(
0114       tracks, &sourceLinkHash, &sourceLinkEquality, optionals);
0115   // Prepare the output track collection from the IDs
0116   TrackContainer solvedTracks{std::make_shared<Acts::VectorTrackContainer>(),
0117                               std::make_shared<Acts::VectorMultiTrajectory>()};
0118   solvedTracks.ensureDynamicColumns(tracks);
0119   for (auto iTrack : goodTracks) {
0120     auto destProxy = solvedTracks.makeTrack();
0121     auto srcProxy = tracks.getTrack(iTrack);
0122     destProxy.copyFromWithoutStates(srcProxy);
0123     destProxy.tipIndex() = srcProxy.tipIndex();
0124   }
0125
0126   ActsExamples::ConstTrackContainer outputTracks{
0127       std::make_shared<Acts::ConstVectorTrackContainer>(
0128           std::move(solvedTracks.container())),
0129       tracks.trackStateContainerHolder()};
0130
0131   m_outputTracks(ctx, std::move(outputTracks));
0132   return ActsExamples::ProcessCode::SUCCESS;
0133 }