Core/EventData/MultiTrajectoryTests.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/data/test_case.hpp>
0010 #include <boost/test/tools/context.hpp>
0011 #include <boost/test/unit_test.hpp>
0012
0013 #include "Acts/Definitions/Algebra.hpp"
0014 #include "Acts/Definitions/TrackParametrization.hpp"
0015 #include "Acts/Definitions/Units.hpp"
0016 #include "Acts/EventData/MultiTrajectory.hpp"
0017 #include "Acts/EventData/ProxyAccessor.hpp"
0018 #include "Acts/EventData/TrackParameters.hpp"
0019 #include "Acts/EventData/TrackStatePropMask.hpp"
0020 #include "Acts/EventData/VectorMultiTrajectory.hpp"
0021 #include "Acts/EventData/detail/MultiTrajectoryTestsCommon.hpp"
0022 #include "Acts/EventData/detail/TestSourceLink.hpp"
0023 #include "Acts/EventData/detail/TestTrackState.hpp"
0024 #include "Acts/Geometry/GeometryContext.hpp"
0025 #include "Acts/Geometry/GeometryIdentifier.hpp"
0026 #include "ActsTests/CommonHelpers/FloatComparisons.hpp"
0027
0028 #include <algorithm>
0029 #include <array>
0030 #include <ostream>
0031 #include <random>
0032 #include <stdexcept>
0033 #include <string>
0034 #include <type_traits>
0035 #include <utility>
0036 #include <variant>
0037 #include <vector>
0038
0039 namespace {
0040
0041 using namespace Acts;
0042 using namespace Acts::UnitLiterals;
0043 using namespace ActsTests;
0044 using namespace Acts::detail::Test;
0045 using namespace Acts::HashedStringLiteral;
0046 namespace bd = boost::unit_test::data;
0047
0048 using ParametersVector = BoundTrackParameters::ParametersVector;
0049 using CovarianceMatrix = BoundTrackParameters::CovarianceMatrix;
0050 using Jacobian = BoundMatrix;
0051
0052 const GeometryContext gctx;
0053 // fixed seed for reproducible tests
0054 std::default_random_engine rng(31415);
0055
0056 struct Factory {
0057   using trajectory_t = VectorMultiTrajectory;
0058   using const_trajectory_t = ConstVectorMultiTrajectory;
0059
0060   VectorMultiTrajectory create() { return {}; }
0061   ConstVectorMultiTrajectory createConst() { return {}; }
0062 };
0063
0064 using CommonTests = MultiTrajectoryTestsCommon<Factory>;
0065
0066 }  // namespace
0067
0068 namespace ActsTests {
0069
0070 BOOST_AUTO_TEST_SUITE(EventDataSuite)
0071
0072 BOOST_AUTO_TEST_CASE(Build) {
0073   CommonTests ct;
0074   ct.testBuild();
0075 }
0076
0077 BOOST_AUTO_TEST_CASE(ConstCorrectness) {
0078   // make mutable
0079   VectorMultiTrajectory t;
0080   auto i0 = t.addTrackState();
0081
0082   BOOST_CHECK(!IsReadOnlyMultiTrajectory<decltype(t)>::value);
0083
0084   {
0085     VectorMultiTrajectory::TrackStateProxy tsp = t.getTrackState(i0);
0086     static_cast<void>(tsp);
0087     VectorMultiTrajectory::ConstTrackStateProxy ctsp{t.getTrackState(i0)};
0088     static_cast<void>(ctsp);
0089
0090     tsp.predicted().setRandom();
0091     // const auto& tsp_const = tsp;
0092     // tsp_const.predicted().setRandom();
0093     // ctsp.predicted().setRandom();
0094   }
0095
0096   // is this something we actually want?
0097   ConstVectorMultiTrajectory ct{t};
0098   BOOST_CHECK_EQUAL(ct.size(), t.size());
0099
0100   ConstVectorMultiTrajectory ctm{std::move(t)};
0101   BOOST_CHECK_EQUAL(ctm.size(), ct.size());
0102
0103   {
0104     static_assert(
0105         std::is_same_v<ConstVectorMultiTrajectory::ConstTrackStateProxy,
0106                        decltype(ctm.getTrackState(i0))>,
0107         "Got mutable track state proxy");
0108     ConstVectorMultiTrajectory::ConstTrackStateProxy ctsp =
0109         ctm.getTrackState(i0);
0110     static_cast<void>(ctsp);
0111
0112     // doesn't compile:
0113     // ctsp.predictedCovariance().setIdentity();
0114   }
0115
0116   // doesn't compile:
0117   // ct.clear();
0118   // ct.addTrackState();
0119 }
0120
0121 BOOST_AUTO_TEST_CASE(Clear) {
0122   CommonTests ct;
0123   ct.testClear();
0124 }
0125
0126 BOOST_AUTO_TEST_CASE(ApplyWithAbort) {
0127   CommonTests ct;
0128   ct.testApplyWithAbort();
0129 }
0130
0131 BOOST_AUTO_TEST_CASE(AddTrackStateWithBitMask) {
0132   CommonTests ct;
0133   ct.testAddTrackStateWithBitMask();
0134 }
0135
0136 BOOST_AUTO_TEST_CASE(AddTrackStateComponents) {
0137   CommonTests ct;
0138   ct.testAddTrackStateComponents();
0139 }
0140
0141 // assert expected "cross-talk" between trackstate proxies
0142 BOOST_AUTO_TEST_CASE(TrackStateProxyCrossTalk) {
0143   CommonTests ct;
0144   ct.testTrackStateProxyCrossTalk(rng);
0145 }
0146
0147 BOOST_AUTO_TEST_CASE(TrackStateReassignment) {
0148   CommonTests ct;
0149   ct.testTrackStateReassignment(rng);
0150 }
0151
0152 BOOST_DATA_TEST_CASE(TrackStateProxyStorage, bd::make({1u, 2u}),
0153                      nMeasurements) {
0154   CommonTests ct;
0155   ct.testTrackStateProxyStorage(rng, nMeasurements);
0156 }
0157
0158 BOOST_AUTO_TEST_CASE(TrackStateProxyAllocations) {
0159   CommonTests ct;
0160   ct.testTrackStateProxyAllocations(rng);
0161 }
0162
0163 BOOST_AUTO_TEST_CASE(TrackStateProxyGetMask) {
0164   CommonTests ct;
0165   ct.testTrackStateProxyGetMask();
0166 }
0167
0168 BOOST_AUTO_TEST_CASE(TrackStateProxyCopy) {
0169   CommonTests ct;
0170   ct.testTrackStateProxyCopy(rng);
0171 }
0172
0173 BOOST_AUTO_TEST_CASE(TrackStateCopyDynamicColumns) {
0174   CommonTests ct;
0175   ct.testTrackStateCopyDynamicColumns();
0176 }
0177
0178 BOOST_AUTO_TEST_CASE(TrackStateProxyCopyDiffMTJ) {
0179   CommonTests ct;
0180   ct.testTrackStateProxyCopyDiffMTJ();
0181 }
0182
0183 BOOST_AUTO_TEST_CASE(ProxyAssignment) {
0184   CommonTests ct;
0185   ct.testProxyAssignment();
0186 }
0187
0188 BOOST_AUTO_TEST_CASE(CopyFromConst) {
0189   CommonTests ct;
0190   ct.testCopyFromConst();
0191 }
0192
0193 BOOST_AUTO_TEST_CASE(TrackStateProxyShare) {
0194   CommonTests ct;
0195   ct.testTrackStateProxyShare(rng);
0196 }
0197
0198 BOOST_AUTO_TEST_CASE(MultiTrajectoryExtraColumns) {
0199   CommonTests ct;
0200   ct.testMultiTrajectoryExtraColumns();
0201 }
0202
0203 BOOST_AUTO_TEST_CASE(MultiTrajectoryExtraColumnsRuntime) {
0204   CommonTests ct;
0205   ct.testMultiTrajectoryExtraColumnsRuntime();
0206 }
0207
0208 BOOST_AUTO_TEST_CASE(MultiTrajectoryAllocateCalibratedInit) {
0209   CommonTests ct;
0210   ct.testMultiTrajectoryAllocateCalibratedInit(rng);
0211 }
0212
0213 BOOST_AUTO_TEST_CASE(MemoryStats) {
0214   using namespace boost::histogram;
0215   using cat = axis::category<std::string>;
0216
0217   VectorMultiTrajectory mt;
0218
0219   auto stats = mt.statistics();
0220
0221   std::stringstream ss;
0222   stats.toStream(ss);
0223   std::string out = ss.str();
0224   BOOST_CHECK(!out.empty());
0225   BOOST_CHECK_NE(out.find("total"), std::string::npos);
0226
0227   const auto& h = stats.hist;
0228
0229   auto column_axis = axis::get<cat>(h.axis(0));
0230   auto type_axis = axis::get<axis::category<>>(h.axis(1));
0231
0232   for (int t = 0; t < type_axis.size(); t++) {
0233     for (int c = 0; c < column_axis.size(); c++) {
0234       double v = h.at(c, t);
0235       BOOST_CHECK_EQUAL(v, 0.0);
0236     }
0237   }
0238
0239   TestTrackState pc(rng, 2u);
0240   auto ts = mt.makeTrackState();
0241   fillTrackState<VectorMultiTrajectory>(pc, TrackStatePropMask::All, ts);
0242
0243   stats = mt.statistics();
0244
0245   for (int t = 0; t < type_axis.size(); t++) {
0246     BOOST_TEST_CONTEXT((type_axis.bin(t) == 1 ? "meas" : "other"))
0247     for (int c = 0; c < column_axis.size(); c++) {
0248       std::string key = column_axis.bin(c);
0249       BOOST_TEST_CONTEXT("column: " << key) {
0250         double v = h.at(c, t);
0251         if (t == 0) {
0252           BOOST_CHECK_NE(v, 0.0);
0253         } else {
0254           BOOST_CHECK_EQUAL(v, 0.0);
0255         }
0256       }
0257     }
0258   }
0259 }
0260
0261 BOOST_AUTO_TEST_CASE(Accessors) {
0262   VectorMultiTrajectory mtj;
0263   mtj.addColumn<unsigned int>("ndof");
0264   mtj.addColumn<double>("super_chi2");
0265
0266   auto ts = mtj.makeTrackState();
0267
0268   ProxyAccessor<unsigned int> ndof("ndof");
0269   ConstProxyAccessor<unsigned int> ndofConst("ndof");
0270   ProxyAccessor<double> superChi2("super_chi2");
0271   ConstProxyAccessor<double> superChi2Const("super_chi2");
0272
0273   ndof(ts) = 65;
0274   BOOST_CHECK_EQUAL((ts.component<unsigned int, "ndof"_hash>()), 65);
0275   BOOST_CHECK_EQUAL(ndofConst(ts), 65);
0276
0277   // should not compile
0278   // ndofConst(ts) = 66;
0279
0280   superChi2(ts) = 123.45;
0281   BOOST_CHECK_EQUAL((ts.component<double, "super_chi2"_hash>()), 123.45);
0282   BOOST_CHECK_EQUAL(superChi2Const(ts), 123.45);
0283
0284   // should not compile
0285   // superChi2Const(ts) = 66.66;
0286 }
0287
0288 BOOST_AUTO_TEST_CASE(ChangeSourceLinkType) {
0289   VectorMultiTrajectory mtj;
0290   auto ts = mtj.makeTrackState();
0291
0292   int value = 5;
0293   ts.setUncalibratedSourceLink(SourceLink{value});
0294
0295   BOOST_CHECK_EQUAL(ts.getUncalibratedSourceLink().get<int>(), value);
0296   BOOST_CHECK_THROW(ts.getUncalibratedSourceLink().get<double>(),
0297                     std::bad_any_cast);
0298
0299   double otherValue = 42.42;
0300
0301   // this changes the stored type
0302   ts.setUncalibratedSourceLink(SourceLink{otherValue});
0303   BOOST_CHECK_EQUAL(ts.getUncalibratedSourceLink().get<double>(), otherValue);
0304   BOOST_CHECK_THROW(ts.getUncalibratedSourceLink().get<int>(),
0305                     std::bad_any_cast);
0306 }
0307
0308 BOOST_AUTO_TEST_SUITE_END()
0309
0310 }  // namespace ActsTests