Plugins/Podio/PodioTrackStateContainerTest.cpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2023 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/tools/old/interface.hpp>
0011 #include <boost/test/unit_test.hpp>
0012 #include <boost/test/unit_test_suite.hpp>
0013
0014 #include "Acts/Definitions/TrackParametrization.hpp"
0015 #include "Acts/Definitions/Units.hpp"
0016 #include "Acts/EventData/SourceLink.hpp"
0017 #include "Acts/EventData/TrackStatePropMask.hpp"
0018 #include "Acts/EventData/detail/MultiTrajectoryTestsCommon.hpp"
0019 #include "Acts/Geometry/GeometryContext.hpp"
0020 #include "Acts/Plugins/Podio/PodioTrackStateContainer.hpp"
0021 #include "Acts/Plugins/Podio/PodioUtil.hpp"
0022 #include "Acts/Surfaces/PlaneSurface.hpp"
0023 #include "Acts/Surfaces/RectangleBounds.hpp"
0024 #include "ActsPodioEdm/BoundParametersCollection.h"
0025 #include "ActsPodioEdm/JacobianCollection.h"
0026 #include "ActsPodioEdm/TrackStateCollection.h"
0027
0028 #include <filesystem>
0029
0030 #include <podio/ROOTFrameReader.h>
0031 #include <podio/ROOTFrameWriter.h>
0032 #include <podio/UserDataCollection.h>
0033
0034 namespace {
0035
0036 using namespace Acts;
0037 using namespace Acts::UnitLiterals;
0038 using namespace Acts::detail::Test;
0039 namespace bd = boost::unit_test::data;
0040
0041 std::default_random_engine rng(31415);
0042
0043 class NullHelper : public PodioUtil::ConversionHelper {
0044  public:
0045   std::optional<PodioUtil::Identifier> surfaceToIdentifier(
0046       const Surface& /*surface*/) const override {
0047     return {};
0048   }
0049   const Surface* identifierToSurface(
0050       PodioUtil::Identifier /*identifier*/) const override {
0051     return nullptr;
0052   }
0053
0054   SourceLink identifierToSourceLink(
0055       PodioUtil::Identifier /*identifier*/) const override {
0056     return SourceLink{0};
0057   }
0058
0059   PodioUtil::Identifier sourceLinkToIdentifier(
0060       const SourceLink& /*sourceLink*/) override {
0061     return 0;
0062   }
0063 };
0064
0065 struct MapHelper : public NullHelper {
0066   std::optional<PodioUtil::Identifier> surfaceToIdentifier(
0067       const Surface& surface) const override {
0068     for (auto&& [id, srf] : surfaces) {
0069       if (srf == &surface) {
0070         return id;
0071       }
0072     }
0073     return {};
0074   }
0075   const Surface* identifierToSurface(PodioUtil::Identifier id) const override {
0076     auto it = surfaces.find(id);
0077     if (it == surfaces.end()) {
0078       return nullptr;
0079     }
0080
0081     return it->second;
0082   }
0083
0084   PodioUtil::Identifier sourceLinkToIdentifier(const SourceLink& sl) override {
0085     sourceLinks.push_back(sl);
0086     return sourceLinks.size() - 1;
0087   }
0088
0089   SourceLink identifierToSourceLink(PodioUtil::Identifier id) const override {
0090     return sourceLinks.at(id);
0091   }
0092
0093   std::unordered_map<PodioUtil::Identifier, const Surface*> surfaces;
0094   std::vector<SourceLink> sourceLinks;
0095 };
0096
0097 struct Factory {
0098   using trajectory_t = MutablePodioTrackStateContainer;
0099   using const_trajectory_t = ConstPodioTrackStateContainer;
0100
0101   MapHelper m_helper;
0102
0103   MutablePodioTrackStateContainer create() { return {m_helper}; }
0104 };
0105
0106 using CommonTests = MultiTrajectoryTestsCommon<Factory>;
0107
0108 }  // namespace
0109
0110 BOOST_AUTO_TEST_SUITE(PodioTrackStateContainerTest)
0111
0112 BOOST_AUTO_TEST_CASE(Build) {
0113   CommonTests ct;
0114   ct.testBuild();
0115 }
0116
0117 BOOST_AUTO_TEST_CASE(ConstCorrectness) {
0118   // @TODO: Const version can only be non-owning!
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(WriteToPodioFrame) {
0209   using namespace HashedStringLiteral;
0210
0211   MapHelper helper;
0212
0213   auto tmp_path = std::filesystem::temp_directory_path();
0214   auto outfile = tmp_path / "trackstates.root";
0215
0216   BoundVector tv1;
0217   tv1 << 1, 1, 1, 1, 1, 1;
0218
0219   BoundVector tv2 = tv1 * 2;
0220   BoundVector tv3 = tv1 * 3;
0221   BoundVector tv4 = tv1 * 4;
0222
0223   BoundMatrix cov1;
0224   cov1.setOnes();
0225
0226   BoundMatrix cov2 = cov1 * 2;
0227   BoundMatrix cov3 = cov1 * 3;
0228   BoundMatrix cov4 = cov1 * 4;
0229
0230   auto rBounds = std::make_shared<RectangleBounds>(15, 20);
0231   auto trf = Transform3::Identity();
0232   trf.translation().setRandom();
0233   auto free = Acts::Surface::makeShared<PlaneSurface>(trf, rBounds);
0234   auto reg = Acts::Surface::makeShared<PlaneSurface>(trf, rBounds);
0235
0236   helper.surfaces[666] = reg.get();
0237
0238   podio::Frame frame;
0239
0240   MutablePodioTrackStateContainer c{helper};
0241   BOOST_CHECK(!c.hasColumn("int_column"_hash));
0242   BOOST_CHECK(!c.hasColumn("float_column"_hash));
0243   c.addColumn<int32_t>("int_column");
0244   c.addColumn<float>("float_column");
0245   BOOST_CHECK(c.hasColumn("int_column"_hash));
0246   BOOST_CHECK(c.hasColumn("float_column"_hash));
0247
0248   {
0249     auto t1 = c.makeTrackState(TrackStatePropMask::Predicted);
0250     t1.predicted() = tv1;
0251     t1.predictedCovariance() = cov1;
0252
0253     t1.setReferenceSurface(free);
0254
0255     auto t2 = c.makeTrackState(TrackStatePropMask::All, t1.index());
0256     t2.predicted() = tv2;
0257     t2.predictedCovariance() = cov2;
0258
0259     t2.filtered() = tv3;
0260     t2.filteredCovariance() = cov3;
0261
0262     t2.smoothed() = tv4;
0263     t2.smoothedCovariance() = cov4;
0264
0265     t2.jacobian() = cov2;
0266
0267     auto t3 = c.makeTrackState();
0268     t3.setReferenceSurface(reg);
0269
0270     t1.component<int32_t, "int_column"_hash>() = -11;
0271     t2.component<int32_t, "int_column"_hash>() = 42;
0272     t3.component<int32_t, "int_column"_hash>() = -98;
0273
0274     t1.component<float, "float_column"_hash>() = -11.2f;
0275     t2.component<float, "float_column"_hash>() = 42.4f;
0276     t3.component<float, "float_column"_hash>() = -98.9f;
0277   }
0278
0279   c.releaseInto(frame, "test");
0280
0281   BOOST_CHECK_EQUAL(frame.get("trackStates_test")->size(), 3);
0282   BOOST_CHECK_EQUAL(frame.get("trackStateParameters_test")->size(), 7);
0283   BOOST_CHECK_EQUAL(frame.get("trackStateJacobians_test")->size(), 2);
0284   BOOST_CHECK_NE(frame.get("trackStates_test_extra__int_column"), nullptr);
0285   BOOST_CHECK_NE(frame.get("trackStates_test_extra__float_column"), nullptr);
0286
0287   ConstPodioTrackStateContainer cc{helper, frame, "test"};
0288
0289   BOOST_CHECK_EQUAL(cc.size(), 3);
0290   BOOST_CHECK(cc.hasColumn("int_column"_hash));
0291   BOOST_CHECK(cc.hasColumn("float_column"_hash));
0292
0293   auto t1 = cc.getTrackState(0);
0294   auto t2 = cc.getTrackState(1);
0295   auto t3 = cc.getTrackState(2);
0296
0297   BOOST_CHECK_EQUAL(t2.previous(), 0);
0298
0299   BOOST_CHECK(t1.hasReferenceSurface());
0300   BOOST_CHECK(!t2.hasReferenceSurface());
0301   BOOST_CHECK(t3.hasReferenceSurface());
0302
0303   Acts::GeometryContext gctx;
0304
0305   const auto& ext = t1.referenceSurface();
0306   BOOST_CHECK_NE(&ext, free.get());
0307   BOOST_CHECK_EQUAL(trf.matrix(), ext.transform(gctx).matrix());
0308   BOOST_CHECK_EQUAL(free->bounds().type(), ext.bounds().type());
0309   BOOST_CHECK_EQUAL(free->type(), ext.type());
0310   const auto* rBounds2 = dynamic_cast<const RectangleBounds*>(&ext.bounds());
0311   BOOST_REQUIRE_NE(rBounds2, nullptr);
0312   BOOST_CHECK_EQUAL(rBounds->halfLengthX(), rBounds2->halfLengthX());
0313   BOOST_CHECK_EQUAL(rBounds->halfLengthY(), rBounds2->halfLengthY());
0314
0315   BOOST_CHECK_EQUAL(t1.predicted(), tv1);
0316   BOOST_CHECK_EQUAL(t1.predictedCovariance(), cov1);
0317
0318   BOOST_CHECK_EQUAL(t2.predicted(), tv2);
0319   BOOST_CHECK_EQUAL(t2.predictedCovariance(), cov2);
0320   BOOST_CHECK_EQUAL(t2.filtered(), tv3);
0321   BOOST_CHECK_EQUAL(t2.filteredCovariance(), cov3);
0322   BOOST_CHECK_EQUAL(t2.smoothed(), tv4);
0323   BOOST_CHECK_EQUAL(t2.smoothedCovariance(), cov4);
0324
0325   BOOST_CHECK_EQUAL(t2.jacobian(), cov2);
0326
0327   BOOST_CHECK_EQUAL(&t3.referenceSurface(), reg.get());
0328
0329   BOOST_CHECK_EQUAL((t1.component<int32_t, "int_column"_hash>()), -11);
0330   BOOST_CHECK_EQUAL((t2.component<int32_t, "int_column"_hash>()), 42);
0331   BOOST_CHECK_EQUAL((t3.component<int32_t, "int_column"_hash>()), -98);
0332
0333   BOOST_CHECK_EQUAL((t1.component<float, "float_column"_hash>()), -11.2f);
0334   BOOST_CHECK_EQUAL((t2.component<float, "float_column"_hash>()), 42.4f);
0335   BOOST_CHECK_EQUAL((t3.component<float, "float_column"_hash>()), -98.9f);
0336 }
0337
0338 BOOST_AUTO_TEST_SUITE_END()