Core/EventData/MeasurementTests.cpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2016-2020 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 http://mozilla.org/MPL/2.0/.
0008
0009 #include <boost/test/data/test_case.hpp>
0010 #include <boost/test/unit_test.hpp>
0011
0012 #include "Acts/Definitions/Algebra.hpp"
0013 #include "Acts/Definitions/TrackParametrization.hpp"
0014 #include "Acts/EventData/Measurement.hpp"
0015 #include "Acts/EventData/SourceLink.hpp"
0016 #include "Acts/EventData/detail/GenerateParameters.hpp"
0017 #include "Acts/EventData/detail/TestSourceLink.hpp"
0018 #include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
0019
0020 #include <algorithm>
0021 #include <array>
0022 #include <cmath>
0023 #include <limits>
0024 #include <random>
0025 #include <tuple>
0026 #include <utility>
0027 #include <variant>
0028 #include <vector>
0029
0030 using namespace Acts;
0031 using namespace Acts::detail::Test;
0032 using SourceLink = Acts::detail::Test::TestSourceLink;
0033 namespace bd = boost::unit_test::data;
0034
0035 namespace {
0036 constexpr BoundIndices boundIndices[] = {
0037     eBoundLoc0, eBoundLoc1, eBoundTime, eBoundPhi, eBoundTheta, eBoundQOverP,
0038 };
0039 constexpr FreeIndices freeIndices[] = {
0040     eFreePos0, eFreePos1, eFreePos2, eFreeTime,
0041     eFreeDir0, eFreeDir1, eFreeDir2, eFreeQOverP,
0042 };
0043 const TestSourceLink sourceOrig;
0044 const Acts::SourceLink source{sourceOrig};
0045 // fix seed for reproducible tests
0046 std::default_random_engine rng(123);
0047 }  // namespace
0048
0049 // the underlying subspace implementation is already tested exhaustively in a
0050 // separate unit test. here we only test concrete extreme cases and
0051 // measurement-specific functionality.
0052
0053 BOOST_AUTO_TEST_SUITE(EventDataMeasurement)
0054
0055 BOOST_DATA_TEST_CASE(FixedBoundOne, bd::make(boundIndices), index) {
0056   auto [params, cov] = generateParametersCovariance<ActsScalar, 1u>(rng);
0057   auto meas = makeMeasurement(source, params, cov, index);
0058
0059   BOOST_CHECK_EQUAL(meas.size(), 1);
0060   for (auto i : boundIndices) {
0061     if (i == index) {
0062       BOOST_CHECK(meas.contains(i));
0063     } else {
0064       BOOST_CHECK(!meas.contains(i));
0065     }
0066   }
0067   BOOST_CHECK_EQUAL(meas.parameters(), params);
0068   BOOST_CHECK_EQUAL(meas.covariance(), cov);
0069   BOOST_CHECK_EQUAL(meas.sourceLink().template get<TestSourceLink>(),
0070                     sourceOrig);
0071 }
0072
0073 BOOST_AUTO_TEST_CASE(FixedBoundAll) {
0074   auto [params, cov] = generateBoundParametersCovariance(rng);
0075   auto meas = makeMeasurement(source, params, cov, eBoundLoc0, eBoundLoc1,
0076                               eBoundPhi, eBoundTheta, eBoundQOverP, eBoundTime);
0077
0078   BOOST_CHECK_EQUAL(meas.size(), eBoundSize);
0079   for (auto i : boundIndices) {
0080     BOOST_CHECK(meas.contains(i));
0081   }
0082   BOOST_CHECK_EQUAL(meas.parameters(), params);
0083   BOOST_CHECK_EQUAL(meas.covariance(), cov);
0084   BOOST_CHECK_EQUAL(meas.sourceLink().get<TestSourceLink>(), sourceOrig);
0085 }
0086
0087 namespace {
0088 // example data for phi residual tests. each entry contains
0089 //
0090 //     measured, reference, expected residual
0091 //
0092 const std::vector<std::tuple<double, double, double>> kPhiDataset = {
0093     // measurement and reference in bounds and close
0094     {0.5, 0.75, -0.25},
0095     // measurement and reference in bounds but at different edges
0096     {0.25, 2 * M_PI - 0.25, 0.5},
0097     {2 * M_PI - 0.125, 0.125, -0.25},
0098     // measurement in bounds, reference ouf-of-bounds, both near lower edge
0099     {0.25, -0.25, 0.5},
0100     // measurement in bounds, reference ouf-of-bounds, both near upper edge
0101     {2 * M_PI - 0.25, 2 * M_PI + 0.25, -0.5},
0102     // measurement out-of-bounds, reference in bounds, both near lower edge
0103     {-0.25, 0.25, -0.5},
0104     // measurement out-of-bounds, reference in bounds, both near upper edge
0105     {2 * M_PI + 0.25, 2 * M_PI - 0.25, 0.5},
0106 };
0107 }  // namespace
0108
0109 BOOST_DATA_TEST_CASE(BoundResidualsPhi, bd::make(kPhiDataset), phiMea, phiRef,
0110                      phiRes) {
0111   using MeasurementVector = Acts::ActsVector<1>;
0112   using MeasurementCovariance = Acts::ActsSquareMatrix<1>;
0113
0114   // prepare measurement
0115   MeasurementVector params = MeasurementVector::Zero();
0116   MeasurementCovariance cov = MeasurementCovariance::Zero();
0117   params[0] = phiMea;
0118   auto measurement = makeMeasurement(source, params, cov, eBoundPhi);
0119   // prepare reference parameters
0120   Acts::BoundVector reference = Acts::BoundVector::Zero();
0121   reference[eBoundPhi] = phiRef;
0122
0123   // compute and check residual
0124   auto res = measurement.residuals(reference);
0125   CHECK_CLOSE_ABS(res[0], phiRes, std::numeric_limits<ActsScalar>::epsilon());
0126 }
0127
0128 BOOST_DATA_TEST_CASE(FixedFreeOne, bd::make(freeIndices), index) {
0129   auto [params, cov] = generateParametersCovariance<ActsScalar, 1u>(rng);
0130   auto meas = makeMeasurement(source, params, cov, index);
0131
0132   BOOST_CHECK_EQUAL(meas.size(), 1);
0133   for (auto i : freeIndices) {
0134     if (i == index) {
0135       BOOST_CHECK(meas.contains(i));
0136     } else {
0137       BOOST_CHECK(!meas.contains(i));
0138     }
0139   }
0140   BOOST_CHECK_EQUAL(meas.parameters(), params);
0141   BOOST_CHECK_EQUAL(meas.covariance(), cov);
0142   BOOST_CHECK_EQUAL(meas.sourceLink().template get<TestSourceLink>(),
0143                     sourceOrig);
0144
0145   // all free parameters are unrestricted and we know the expected residual.
0146   constexpr auto tol = std::numeric_limits<ActsScalar>::epsilon();
0147   auto [ref, refCov] = generateFreeParametersCovariance(rng);
0148   auto res = meas.residuals(ref);
0149   CHECK_CLOSE_ABS(res[0], params[0] - ref[index], tol);
0150 }
0151
0152 BOOST_AUTO_TEST_CASE(FixedFreeAll) {
0153   auto [params, cov] = generateFreeParametersCovariance(rng);
0154   auto meas =
0155       makeMeasurement(source, params, cov, eFreePos0, eFreePos1, eFreePos2,
0156                       eFreeTime, eFreeDir0, eFreeDir1, eFreeDir2, eFreeQOverP);
0157
0158   BOOST_CHECK_EQUAL(meas.size(), eFreeSize);
0159   for (auto i : freeIndices) {
0160     BOOST_CHECK(meas.contains(i));
0161   }
0162   BOOST_CHECK_EQUAL(meas.parameters(), params);
0163   BOOST_CHECK_EQUAL(meas.covariance(), cov);
0164   BOOST_CHECK_EQUAL(meas.sourceLink().get<TestSourceLink>(), sourceOrig);
0165
0166   // all free parameters are unrestricted and we know the expected residual.
0167   constexpr auto tol = std::numeric_limits<ActsScalar>::epsilon();
0168   auto [ref, refCov] = generateFreeParametersCovariance(rng);
0169   CHECK_CLOSE_ABS(meas.residuals(ref), params - ref, tol);
0170 }
0171
0172 BOOST_AUTO_TEST_CASE(VariantBound) {
0173   // generate w/ a single parameter
0174   auto [par1, cov1] = generateParametersCovariance<ActsScalar, 1u>(rng);
0175   BoundVariantMeasurement meas =
0176       makeMeasurement(source, par1, cov1, eBoundTheta);
0177   std::visit(
0178       [](const auto& m) {
0179         BOOST_CHECK_EQUAL(m.size(), 1);
0180         BOOST_CHECK(!m.contains(eBoundLoc0));
0181         BOOST_CHECK(!m.contains(eBoundLoc1));
0182         BOOST_CHECK(!m.contains(eBoundTime));
0183         BOOST_CHECK(!m.contains(eBoundPhi));
0184         BOOST_CHECK(m.contains(eBoundTheta));
0185         BOOST_CHECK(!m.contains(eBoundQOverP));
0186       },
0187       meas);
0188
0189   // reassign w/ all parameters
0190   auto [parN, covN] = generateBoundParametersCovariance(rng);
0191   meas = makeMeasurement(source, parN, covN, eBoundLoc0, eBoundLoc1, eBoundPhi,
0192                          eBoundTheta, eBoundQOverP, eBoundTime);
0193   std::visit(
0194       [](const auto& m) {
0195         BOOST_CHECK_EQUAL(m.size(), eBoundSize);
0196         BOOST_CHECK(m.contains(eBoundLoc0));
0197         BOOST_CHECK(m.contains(eBoundLoc1));
0198         BOOST_CHECK(m.contains(eBoundTime));
0199         BOOST_CHECK(m.contains(eBoundPhi));
0200         BOOST_CHECK(m.contains(eBoundTheta));
0201         BOOST_CHECK(m.contains(eBoundQOverP));
0202       },
0203       meas);
0204 }
0205
0206 BOOST_AUTO_TEST_CASE(VariantFree) {
0207   // generate w/ two parameters
0208   auto [par2, cov2] = generateParametersCovariance<ActsScalar, 2u>(rng);
0209   FreeVariantMeasurement meas =
0210       makeMeasurement(source, par2, cov2, eFreePos2, eFreeTime);
0211   std::visit(
0212       [](const auto& m) {
0213         BOOST_CHECK_EQUAL(m.size(), 2);
0214         BOOST_CHECK(!m.contains(eFreePos0));
0215         BOOST_CHECK(!m.contains(eFreePos1));
0216         BOOST_CHECK(m.contains(eFreePos2));
0217         BOOST_CHECK(m.contains(eFreeTime));
0218         BOOST_CHECK(!m.contains(eFreeDir0));
0219         BOOST_CHECK(!m.contains(eFreeDir1));
0220         BOOST_CHECK(!m.contains(eFreeDir2));
0221         BOOST_CHECK(!m.contains(eFreeQOverP));
0222       },
0223       meas);
0224
0225   // reassign w/ all parameters
0226   auto [parN, covN] = generateFreeParametersCovariance(rng);
0227   meas =
0228       makeMeasurement(source, parN, covN, eFreePos0, eFreePos1, eFreePos2,
0229                       eFreeTime, eFreeDir0, eFreeDir1, eFreeDir2, eFreeQOverP);
0230   std::visit(
0231       [](const auto& m) {
0232         BOOST_CHECK_EQUAL(m.size(), eFreeSize);
0233         BOOST_CHECK(m.contains(eFreePos0));
0234         BOOST_CHECK(m.contains(eFreePos1));
0235         BOOST_CHECK(m.contains(eFreePos2));
0236         BOOST_CHECK(m.contains(eFreeTime));
0237         BOOST_CHECK(m.contains(eFreeDir0));
0238         BOOST_CHECK(m.contains(eFreeDir1));
0239         BOOST_CHECK(m.contains(eFreeDir2));
0240         BOOST_CHECK(m.contains(eFreeQOverP));
0241       },
0242       meas);
0243 }
0244
0245 BOOST_AUTO_TEST_SUITE_END()