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