Plugins/Podio/PodioTrackStateContainerTest.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/unit_test.hpp>
0011 #include <boost/test/unit_test_suite.hpp>
0012
0013 #include "Acts/Definitions/TrackParametrization.hpp"
0014 #include "Acts/Definitions/Units.hpp"
0015 #include "Acts/EventData/SourceLink.hpp"
0016 #include "Acts/EventData/TrackStatePropMask.hpp"
0017 #include "Acts/EventData/detail/MultiTrajectoryTestsCommon.hpp"
0018 #include "Acts/Geometry/GeometryContext.hpp"
0019 #include "Acts/Plugins/Podio/PodioTrackStateContainer.hpp"
0020 #include "Acts/Plugins/Podio/PodioUtil.hpp"
0021 #include "Acts/Surfaces/PlaneSurface.hpp"
0022 #include "Acts/Surfaces/RectangleBounds.hpp"
0023 #include "ActsPodioEdm/BoundParametersCollection.h"
0024 #include "ActsPodioEdm/JacobianCollection.h"
0025 #include "ActsPodioEdm/TrackStateCollection.h"
0026
0027 #include <filesystem>
0028
0029 #include <podio/UserDataCollection.h>
0030
0031 namespace {
0032
0033 using namespace Acts;
0034 using namespace Acts::UnitLiterals;
0035 using namespace Acts::detail::Test;
0036 namespace bd = boost::unit_test::data;
0037
0038 std::default_random_engine rng(31415);
0039
0040 class NullHelper : public PodioUtil::ConversionHelper {
0041  public:
0042   std::optional<PodioUtil::Identifier> surfaceToIdentifier(
0043       const Surface& /*surface*/) const override {
0044     return {};
0045   }
0046   const Surface* identifierToSurface(
0047       PodioUtil::Identifier /*identifier*/) const override {
0048     return nullptr;
0049   }
0050
0051   SourceLink identifierToSourceLink(
0052       PodioUtil::Identifier /*identifier*/) const override {
0053     return SourceLink{0};
0054   }
0055
0056   PodioUtil::Identifier sourceLinkToIdentifier(
0057       const SourceLink& /*sourceLink*/) override {
0058     return 0;
0059   }
0060 };
0061
0062 struct MapHelper : public NullHelper {
0063   std::optional<PodioUtil::Identifier> surfaceToIdentifier(
0064       const Surface& surface) const override {
0065     for (auto&& [id, srf] : surfaces) {
0066       if (srf == &surface) {
0067         return id;
0068       }
0069     }
0070     return {};
0071   }
0072   const Surface* identifierToSurface(PodioUtil::Identifier id) const override {
0073     auto it = surfaces.find(id);
0074     if (it == surfaces.end()) {
0075       return nullptr;
0076     }
0077
0078     return it->second;
0079   }
0080
0081   PodioUtil::Identifier sourceLinkToIdentifier(const SourceLink& sl) override {
0082     sourceLinks.push_back(sl);
0083     return sourceLinks.size() - 1;
0084   }
0085
0086   SourceLink identifierToSourceLink(PodioUtil::Identifier id) const override {
0087     return sourceLinks.at(id);
0088   }
0089
0090   std::unordered_map<PodioUtil::Identifier, const Surface*> surfaces;
0091   std::vector<SourceLink> sourceLinks;
0092 };
0093
0094 struct Factory {
0095   using trajectory_t = MutablePodioTrackStateContainer;
0096   using const_trajectory_t = ConstPodioTrackStateContainer;
0097
0098   MapHelper m_helper;
0099
0100   MutablePodioTrackStateContainer create() {
0101     return MutablePodioTrackStateContainer{m_helper};
0102   }
0103 };
0104
0105 using CommonTests = MultiTrajectoryTestsCommon<Factory>;
0106
0107 }  // namespace
0108
0109 BOOST_AUTO_TEST_SUITE(PodioTrackStateContainerTest)
0110
0111 BOOST_AUTO_TEST_CASE(Build) {
0112   CommonTests ct;
0113   ct.testBuild();
0114 }
0115
0116 BOOST_AUTO_TEST_CASE(ConstCorrectness) {
0117   // @TODO: Const version can only be non-owning!
0118 }
0119
0120 BOOST_AUTO_TEST_CASE(Clear) {
0121   CommonTests ct;
0122   ct.testClear();
0123 }
0124
0125 BOOST_AUTO_TEST_CASE(ApplyWithAbort) {
0126   CommonTests ct;
0127   ct.testApplyWithAbort();
0128 }
0129
0130 BOOST_AUTO_TEST_CASE(AddTrackStateWithBitMask) {
0131   CommonTests ct;
0132   ct.testAddTrackStateWithBitMask();
0133 }
0134
0135 BOOST_AUTO_TEST_CASE(AddTrackStateComponents) {
0136   CommonTests ct;
0137   ct.testAddTrackStateComponents();
0138 }
0139
0140 // assert expected "cross-talk" between trackstate proxies
0141 BOOST_AUTO_TEST_CASE(TrackStateProxyCrossTalk) {
0142   CommonTests ct;
0143   ct.testTrackStateProxyCrossTalk(rng);
0144 }
0145
0146 BOOST_AUTO_TEST_CASE(TrackStateReassignment) {
0147   CommonTests ct;
0148   ct.testTrackStateReassignment(rng);
0149 }
0150
0151 BOOST_DATA_TEST_CASE(TrackStateProxyStorage, bd::make({1u, 2u}),
0152                      nMeasurements) {
0153   CommonTests ct;
0154   ct.testTrackStateProxyStorage(rng, nMeasurements);
0155 }
0156
0157 BOOST_AUTO_TEST_CASE(TrackStateProxyAllocations) {
0158   CommonTests ct;
0159   ct.testTrackStateProxyAllocations(rng);
0160 }
0161
0162 BOOST_AUTO_TEST_CASE(TrackStateProxyGetMask) {
0163   CommonTests ct;
0164   ct.testTrackStateProxyGetMask();
0165 }
0166
0167 BOOST_AUTO_TEST_CASE(TrackStateProxyCopy) {
0168   CommonTests ct;
0169   ct.testTrackStateProxyCopy(rng);
0170 }
0171
0172 BOOST_AUTO_TEST_CASE(TrackStateCopyDynamicColumns) {
0173   CommonTests ct;
0174   ct.testTrackStateCopyDynamicColumns();
0175 }
0176
0177 BOOST_AUTO_TEST_CASE(TrackStateProxyCopyDiffMTJ) {
0178   CommonTests ct;
0179   ct.testTrackStateProxyCopyDiffMTJ();
0180 }
0181
0182 BOOST_AUTO_TEST_CASE(ProxyAssignment) {
0183   CommonTests ct;
0184   ct.testProxyAssignment();
0185 }
0186
0187 BOOST_AUTO_TEST_CASE(CopyFromConst) {
0188   CommonTests ct;
0189   ct.testCopyFromConst();
0190 }
0191
0192 BOOST_AUTO_TEST_CASE(TrackStateProxyShare) {
0193   CommonTests ct;
0194   ct.testTrackStateProxyShare(rng);
0195 }
0196
0197 BOOST_AUTO_TEST_CASE(MultiTrajectoryExtraColumns) {
0198   CommonTests ct;
0199   ct.testMultiTrajectoryExtraColumns();
0200 }
0201
0202 BOOST_AUTO_TEST_CASE(MultiTrajectoryExtraColumnsRuntime) {
0203   CommonTests ct;
0204   ct.testMultiTrajectoryExtraColumnsRuntime();
0205 }
0206
0207 BOOST_AUTO_TEST_CASE(MultiTrajectoryAllocateCalibratedInit) {
0208   CommonTests ct;
0209   ct.testMultiTrajectoryAllocateCalibratedInit(rng);
0210 }
0211
0212 BOOST_AUTO_TEST_CASE(WriteToPodioFrame) {
0213   using namespace HashedStringLiteral;
0214
0215   MapHelper helper;
0216
0217   auto tmp_path = std::filesystem::temp_directory_path();
0218   auto outfile = tmp_path / "trackstates.root";
0219
0220   BoundVector tv1;
0221   tv1 << 1, 1, 1, 1, 1, 1;
0222
0223   BoundVector tv2 = tv1 * 2;
0224   BoundVector tv3 = tv1 * 3;
0225   BoundVector tv4 = tv1 * 4;
0226
0227   BoundMatrix cov1;
0228   cov1.setOnes();
0229
0230   BoundMatrix cov2 = cov1 * 2;
0231   BoundMatrix cov3 = cov1 * 3;
0232   BoundMatrix cov4 = cov1 * 4;
0233
0234   auto rBounds = std::make_shared<RectangleBounds>(15, 20);
0235   auto trf = Transform3::Identity();
0236   trf.translation().setRandom();
0237   auto free = Acts::Surface::makeShared<PlaneSurface>(trf, rBounds);
0238   auto reg = Acts::Surface::makeShared<PlaneSurface>(trf, rBounds);
0239
0240   helper.surfaces[666] = reg.get();
0241
0242   podio::Frame frame;
0243
0244   MutablePodioTrackStateContainer c{helper};
0245   BOOST_CHECK(!c.hasColumn("int_column"_hash));
0246   BOOST_CHECK(!c.hasColumn("float_column"_hash));
0247   c.addColumn<std::int32_t>("int_column");
0248   c.addColumn<float>("float_column");
0249   BOOST_CHECK(c.hasColumn("int_column"_hash));
0250   BOOST_CHECK(c.hasColumn("float_column"_hash));
0251
0252   {
0253     auto t1 = c.makeTrackState(TrackStatePropMask::Predicted);
0254     t1.predicted() = tv1;
0255     t1.predictedCovariance() = cov1;
0256
0257     t1.setReferenceSurface(free);
0258
0259     auto t2 = c.makeTrackState(TrackStatePropMask::All, t1.index());
0260     t2.predicted() = tv2;
0261     t2.predictedCovariance() = cov2;
0262
0263     t2.filtered() = tv3;
0264     t2.filteredCovariance() = cov3;
0265
0266     t2.smoothed() = tv4;
0267     t2.smoothedCovariance() = cov4;
0268
0269     t2.jacobian() = cov2;
0270
0271     auto t3 = c.makeTrackState();
0272     t3.setReferenceSurface(reg);
0273
0274     t1.component<std::int32_t, "int_column"_hash>() = -11;
0275     t2.component<std::int32_t, "int_column"_hash>() = 42;
0276     t3.component<std::int32_t, "int_column"_hash>() = -98;
0277
0278     t1.component<float, "float_column"_hash>() = -11.2f;
0279     t2.component<float, "float_column"_hash>() = 42.4f;
0280     t3.component<float, "float_column"_hash>() = -98.9f;
0281   }
0282
0283   c.releaseInto(frame, "test");
0284
0285   BOOST_CHECK_EQUAL(frame.get("trackStates_test")->size(), 3);
0286   BOOST_CHECK_EQUAL(frame.get("trackStateParameters_test")->size(), 7);
0287   BOOST_CHECK_EQUAL(frame.get("trackStateJacobians_test")->size(), 2);
0288   BOOST_CHECK_NE(frame.get("trackStates_test_extra__int_column"), nullptr);
0289   BOOST_CHECK_NE(frame.get("trackStates_test_extra__float_column"), nullptr);
0290
0291   ConstPodioTrackStateContainer cc{helper, frame, "test"};
0292
0293   BOOST_CHECK_EQUAL(cc.size(), 3);
0294   BOOST_CHECK(cc.hasColumn("int_column"_hash));
0295   BOOST_CHECK(cc.hasColumn("float_column"_hash));
0296
0297   auto t1 = cc.getTrackState(0);
0298   auto t2 = cc.getTrackState(1);
0299   auto t3 = cc.getTrackState(2);
0300
0301   BOOST_CHECK_EQUAL(t2.previous(), 0);
0302
0303   BOOST_CHECK(t1.hasReferenceSurface());
0304   BOOST_CHECK(!t2.hasReferenceSurface());
0305   BOOST_CHECK(t3.hasReferenceSurface());
0306
0307   Acts::GeometryContext gctx;
0308
0309   const auto& ext = t1.referenceSurface();
0310   BOOST_CHECK_NE(&ext, free.get());
0311   BOOST_CHECK_EQUAL(trf.matrix(), ext.transform(gctx).matrix());
0312   BOOST_CHECK_EQUAL(free->bounds().type(), ext.bounds().type());
0313   BOOST_CHECK_EQUAL(free->type(), ext.type());
0314   const auto* rBounds2 = dynamic_cast<const RectangleBounds*>(&ext.bounds());
0315   BOOST_REQUIRE_NE(rBounds2, nullptr);
0316   BOOST_CHECK_EQUAL(rBounds->halfLengthX(), rBounds2->halfLengthX());
0317   BOOST_CHECK_EQUAL(rBounds->halfLengthY(), rBounds2->halfLengthY());
0318
0319   BOOST_CHECK_EQUAL(t1.predicted(), tv1);
0320   BOOST_CHECK_EQUAL(t1.predictedCovariance(), cov1);
0321
0322   BOOST_CHECK_EQUAL(t2.predicted(), tv2);
0323   BOOST_CHECK_EQUAL(t2.predictedCovariance(), cov2);
0324   BOOST_CHECK_EQUAL(t2.filtered(), tv3);
0325   BOOST_CHECK_EQUAL(t2.filteredCovariance(), cov3);
0326   BOOST_CHECK_EQUAL(t2.smoothed(), tv4);
0327   BOOST_CHECK_EQUAL(t2.smoothedCovariance(), cov4);
0328
0329   BOOST_CHECK_EQUAL(t2.jacobian(), cov2);
0330
0331   BOOST_CHECK_EQUAL(&t3.referenceSurface(), reg.get());
0332
0333   BOOST_CHECK_EQUAL((t1.component<std::int32_t, "int_column"_hash>()), -11);
0334   BOOST_CHECK_EQUAL((t2.component<std::int32_t, "int_column"_hash>()), 42);
0335   BOOST_CHECK_EQUAL((t3.component<std::int32_t, "int_column"_hash>()), -98);
0336
0337   BOOST_CHECK_EQUAL((t1.component<float, "float_column"_hash>()), -11.2f);
0338   BOOST_CHECK_EQUAL((t2.component<float, "float_column"_hash>()), 42.4f);
0339   BOOST_CHECK_EQUAL((t3.component<float, "float_column"_hash>()), -98.9f);
0340 }
0341
0342 BOOST_AUTO_TEST_SUITE_END()