Core/Utilities/TrackHelpersTests.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 <boost/test/unit_test.hpp>
0010
0011 #include "Acts/Definitions/TrackParametrization.hpp"
0012 #include "Acts/EventData/TrackContainer.hpp"
0013 #include "Acts/EventData/TrackStateType.hpp"
0014 #include "Acts/EventData/VectorMultiTrajectory.hpp"
0015 #include "Acts/EventData/VectorTrackContainer.hpp"
0016 #include "Acts/Utilities/TrackHelpers.hpp"
0017 #include "ActsTests/CommonHelpers/FloatComparisons.hpp"
0018
0019 using namespace Acts;
0020
0021 namespace ActsTests {
0022
0023 namespace {
0024
0025 template <typename TrackContainer, typename FlagsPerState>
0026 auto createTestTrack(TrackContainer& tc, const FlagsPerState& flagsPerState) {
0027   auto t = tc.makeTrack();
0028
0029   for (const auto& flags : flagsPerState) {
0030     auto ts = t.appendTrackState();
0031     for (auto f : flags) {
0032       ts.typeFlags().set(f);
0033     }
0034   }
0035
0036   return t;
0037 }
0038
0039 template <typename TrackContainer>
0040 auto createTestTrackState(TrackContainer& tc) {
0041   auto t = tc.makeTrack();
0042
0043   auto ts = t.appendTrackState();
0044
0045   ts.allocateCalibrated(Vector2::Zero(), SquareMatrix2::Identity());
0046   ts.setProjectorSubspaceIndices(std::array{eBoundLoc0, eBoundLoc1});
0047
0048   ts.predicted() = BoundVector::Zero();
0049   ts.predicted()[eBoundLoc0] = 1.;
0050   ts.predicted()[eBoundLoc1] = 1.;
0051   ts.predictedCovariance() = BoundMatrix::Identity() * 1.;
0052
0053   ts.filtered() = BoundVector::Zero();
0054   ts.filtered()[eBoundLoc0] = 0.5;
0055   ts.filtered()[eBoundLoc1] = 0.5;
0056   ts.filteredCovariance() = BoundMatrix::Identity() * 0.5;
0057
0058   ts.smoothed() = BoundVector::Zero();
0059   ts.smoothed()[eBoundLoc0] = 0.1;
0060   ts.smoothed()[eBoundLoc1] = 0.1;
0061   ts.smoothedCovariance() = BoundMatrix::Identity() * 0.1;
0062
0063   return ts;
0064 }
0065
0066 }  // namespace
0067
0068 BOOST_AUTO_TEST_SUITE(UtilitiesSuite)
0069
0070 BOOST_AUTO_TEST_CASE(CalculateQuantities) {
0071   TrackContainer tc{VectorTrackContainer{}, VectorMultiTrajectory{}};
0072   auto t = createTestTrack(tc, std::vector<std::vector<TrackStateFlag>>{
0073                                    {MeasurementFlag},
0074                                    {OutlierFlag},
0075                                    {MeasurementFlag, SharedHitFlag},
0076                                    {HoleFlag},
0077                                    {OutlierFlag},
0078                                    {HoleFlag},
0079                                    {MeasurementFlag, SharedHitFlag},
0080                                    {OutlierFlag},
0081                                });
0082
0083   calculateTrackQuantities(t);
0084
0085   BOOST_CHECK_EQUAL(t.nHoles(), 2);
0086   BOOST_CHECK_EQUAL(t.nMeasurements(), 3);
0087   BOOST_CHECK_EQUAL(t.nOutliers(), 3);
0088   BOOST_CHECK_EQUAL(t.nSharedHits(), 2);
0089 }
0090
0091 BOOST_AUTO_TEST_CASE(TrimTrack) {
0092   TrackContainer tc{VectorTrackContainer{}, VectorMultiTrajectory{}};
0093   auto t = createTestTrack(tc, std::vector<std::vector<TrackStateFlag>>{
0094                                    {},
0095                                    {HoleFlag},
0096                                    {MeasurementFlag},
0097                                    {OutlierFlag},
0098                                    {MeasurementFlag, SharedHitFlag},
0099                                    {HoleFlag},
0100                                    {OutlierFlag},
0101                                    {HoleFlag},
0102                                    {MeasurementFlag},
0103                                    {OutlierFlag},
0104                                    {},
0105                                });
0106
0107   calculateTrackQuantities(t);
0108
0109   BOOST_CHECK_EQUAL(t.nTrackStates(), 11);
0110   BOOST_CHECK_EQUAL(t.nHoles(), 3);
0111   BOOST_CHECK_EQUAL(t.nMeasurements(), 3);
0112   BOOST_CHECK_EQUAL(t.nOutliers(), 3);
0113   BOOST_CHECK_EQUAL(t.nSharedHits(), 1);
0114
0115   trimTrackFront(t, true, true, true, true);
0116   calculateTrackQuantities(t);
0117
0118   BOOST_CHECK_EQUAL(t.nTrackStates(), 9);
0119   BOOST_CHECK_EQUAL(t.nHoles(), 2);
0120   BOOST_CHECK_EQUAL(t.nMeasurements(), 3);
0121   BOOST_CHECK_EQUAL(t.nOutliers(), 3);
0122   BOOST_CHECK_EQUAL(t.nSharedHits(), 1);
0123
0124   trimTrackBack(t, true, true, true, true);
0125   calculateTrackQuantities(t);
0126
0127   BOOST_CHECK_EQUAL(t.nTrackStates(), 7);
0128   BOOST_CHECK_EQUAL(t.nHoles(), 2);
0129   BOOST_CHECK_EQUAL(t.nMeasurements(), 3);
0130   BOOST_CHECK_EQUAL(t.nOutliers(), 2);
0131   BOOST_CHECK_EQUAL(t.nSharedHits(), 1);
0132
0133   trimTrack(t, true, true, true, true);
0134   calculateTrackQuantities(t);
0135
0136   BOOST_CHECK_EQUAL(t.nTrackStates(), 7);
0137   BOOST_CHECK_EQUAL(t.nHoles(), 2);
0138   BOOST_CHECK_EQUAL(t.nMeasurements(), 3);
0139   BOOST_CHECK_EQUAL(t.nOutliers(), 2);
0140   BOOST_CHECK_EQUAL(t.nSharedHits(), 1);
0141 }
0142
0143 BOOST_AUTO_TEST_CASE(CalculatePredictedChi2) {
0144   TrackContainer tc{VectorTrackContainer{}, VectorMultiTrajectory{}};
0145   auto ts = createTestTrackState(tc);
0146
0147   // reference found by running the code
0148   BOOST_CHECK_CLOSE(calculatePredictedChi2(ts), 1., 1e-6);
0149 }
0150
0151 BOOST_AUTO_TEST_CASE(CalculateFilteredChi2) {
0152   TrackContainer tc{VectorTrackContainer{}, VectorMultiTrajectory{}};
0153   auto ts = createTestTrackState(tc);
0154
0155   // reference found by running the code
0156   BOOST_CHECK_CLOSE(calculateFilteredChi2(ts), 1., 1e-6);
0157 }
0158
0159 BOOST_AUTO_TEST_CASE(CalculateSmoothedChi2) {
0160   TrackContainer tc{VectorTrackContainer{}, VectorMultiTrajectory{}};
0161   auto ts = createTestTrackState(tc);
0162
0163   // reference found by running the code
0164   BOOST_CHECK_CLOSE(calculateSmoothedChi2(ts), 1. / 45., 1e-6);
0165 }
0166
0167 BOOST_AUTO_TEST_CASE(CalculateUnbiasedParametersCovariance) {
0168   TrackContainer tc{VectorTrackContainer{}, VectorMultiTrajectory{}};
0169   auto ts = createTestTrackState(tc);
0170
0171   auto [params, cov] = calculateUnbiasedParametersCovariance(ts);
0172
0173   // reference found by running the code
0174   BoundVector refParams = BoundVector::Zero();
0175   refParams[eBoundLoc0] = 1. / 9.;
0176   refParams[eBoundLoc1] = 1. / 9.;
0177   BoundMatrix refCov = BoundMatrix::Identity() * 0.1;
0178   refCov(eBoundLoc0, eBoundLoc0) = 1. / 9.;
0179   refCov(eBoundLoc1, eBoundLoc1) = 1. / 9.;
0180
0181   CHECK_CLOSE_ABS(params, refParams, 1e-6);
0182   CHECK_CLOSE_ABS(cov, refCov, 1e-6);
0183 }
0184
0185 BOOST_AUTO_TEST_SUITE_END()
0186
0187 }  // namespace ActsTests