src/AmbiguityResolution/GreedyAmbiguityResolution.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 "Acts/AmbiguityResolution/GreedyAmbiguityResolution.hpp"
0010
0011 #include <algorithm>
0012
0013 namespace Acts {
0014
0015 namespace {
0016
0017 /// Removes a track from the state which has to be done for multiple properties
0018 /// because of redundancy.
0019 static void removeTrack(GreedyAmbiguityResolution::State& state,
0020                         std::size_t iTrack) {
0021   for (auto iMeasurement : state.measurementsPerTrack[iTrack]) {
0022     state.tracksPerMeasurement[iMeasurement].erase(iTrack);
0023
0024     if (state.tracksPerMeasurement[iMeasurement].size() == 1) {
0025       auto jTrack = *state.tracksPerMeasurement[iMeasurement].begin();
0026       --state.sharedMeasurementsPerTrack[jTrack];
0027     }
0028   }
0029
0030   state.selectedTracks.erase(iTrack);
0031 }
0032
0033 }  // namespace
0034
0035 void GreedyAmbiguityResolution::resolve(State& state) const {
0036   /// Compares two tracks based on the number of shared measurements in order to
0037   /// decide if we already met the final state.
0038   auto sharedMeasurementsComperator = [&state](std::size_t a, std::size_t b) {
0039     return state.sharedMeasurementsPerTrack[a] <
0040            state.sharedMeasurementsPerTrack[b];
0041   };
0042
0043   /// Compares two tracks in order to find the one which should be evicted.
0044   /// First we compare the relative amount of shared measurements. If that is
0045   /// indecisive we use the chi2.
0046   auto trackComperator = [&state](std::size_t a, std::size_t b) {
0047     /// Helper to calculate the relative amount of shared measurements.
0048     auto relativeSharedMeasurements = [&state](std::size_t i) {
0049       return 1.0 * state.sharedMeasurementsPerTrack[i] /
0050              state.measurementsPerTrack[i].size();
0051     };
0052
0053     if (relativeSharedMeasurements(a) != relativeSharedMeasurements(b)) {
0054       return relativeSharedMeasurements(a) < relativeSharedMeasurements(b);
0055     }
0056     if (state.measurementsPerTrack[a].size() ==
0057         state.measurementsPerTrack[b].size()) {
0058       // chi2 comparison only makes sense if the number of measurements is the
0059       // same. Note that this is still not fully correct, as the measurement
0060       // dimensions might differ i.e. pixel and strip measurements are treated
0061       // the same here.
0062       return state.trackChi2[a] < state.trackChi2[b];
0063     }
0064     // If the number of measurements is different, we compare the number of
0065     // measurements. As mentioned above, this is not fully correct, but
0066     // should be sufficient for now.
0067     return state.measurementsPerTrack[a].size() >
0068            state.measurementsPerTrack[b].size();
0069   };
0070
0071   for (std::size_t i = 0; i < m_cfg.maximumIterations; ++i) {
0072     // Lazy out if there is nothing to filter on.
0073     if (state.selectedTracks.empty()) {
0074       ACTS_VERBOSE("no tracks left - exit loop");
0075       break;
0076     }
0077
0078     // Find the maximum amount of shared measurements per track to decide if we
0079     // are done or not.
0080     auto maximumSharedMeasurements = *std::ranges::max_element(
0081         state.selectedTracks, sharedMeasurementsComperator);
0082     ACTS_VERBOSE(
0083         "maximum shared measurements "
0084         << state.sharedMeasurementsPerTrack[maximumSharedMeasurements]);
0085     if (state.sharedMeasurementsPerTrack[maximumSharedMeasurements] <
0086         m_cfg.maximumSharedHits) {
0087       break;
0088     }
0089
0090     // Find the "worst" track by comparing them to each other
0091     auto badTrack =
0092         *std::ranges::max_element(state.selectedTracks, trackComperator);
0093     ACTS_VERBOSE("remove track "
0094                  << badTrack << " nMeas "
0095                  << state.measurementsPerTrack[badTrack].size() << " nShared "
0096                  << state.sharedMeasurementsPerTrack[badTrack] << " chi2 "
0097                  << state.trackChi2[badTrack]);
0098     removeTrack(state, badTrack);
0099   }
0100 }
0101
0102 }  // namespace Acts