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