Io/Csv/MeasurementReaderWriterTests.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/unit_test.hpp>
0010
0011 #include "Acts/Definitions/TrackParametrization.hpp"
0012 #include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
0013 #include "Acts/Tests/CommonHelpers/WhiteBoardUtilities.hpp"
0014 #include "Acts/Utilities/BinUtility.hpp"
0015 #include "Acts/Utilities/Zip.hpp"
0016 #include "ActsExamples/Digitization/DigitizationConfig.hpp"
0017 #include "ActsExamples/Digitization/Smearers.hpp"
0018 #include "ActsExamples/EventData/Cluster.hpp"
0019 #include "ActsExamples/EventData/Measurement.hpp"
0020 #include "ActsExamples/Io/Csv/CsvMeasurementReader.hpp"
0021 #include "ActsExamples/Io/Csv/CsvMeasurementWriter.hpp"
0022
0023 #include <fstream>
0024 #include <iostream>
0025 #include <random>
0026
0027 using namespace ActsExamples;
0028 using namespace Acts::Test;
0029
0030 BOOST_AUTO_TEST_CASE(CsvMeasurementRoundTrip) {
0031   IndexSourceLinkContainer sourceLinksOriginal;
0032   MeasurementContainer measOriginal;
0033   ClusterContainer clusterOriginal;
0034   IndexMultimap<Index> mapOriginal;
0035
0036   ////////////////////////////
0037   // Create some dummy data //
0038   ////////////////////////////
0039   const std::size_t nMeasurements = 3;
0040   Acts::GeometryIdentifier someGeoId{298453};
0041
0042   std::mt19937 gen(23);
0043   std::uniform_int_distribution<std::uint32_t> disti(1, 10);
0044   std::uniform_real_distribution<double> distf(0.0, 1.0);
0045
0046   for (auto i = 0ul; i < nMeasurements; ++i) {
0047     IndexSourceLink sl(someGeoId, static_cast<Index>(i));
0048     sourceLinksOriginal.insert(sl);
0049
0050     Acts::Vector2 p = Acts::Vector2::Random();
0051     Acts::SquareMatrix2 c = Acts::SquareMatrix2::Random();
0052
0053     // NOTE this fails:
0054     // auto m = Acts::makeMeasurement(sl, p, c, eBoundLoc0, eBoundTime)
0055     // because we don't support non-consecutive parameters here for now
0056     auto m = Acts::makeMeasurement(Acts::SourceLink{sl}, p, c, Acts::eBoundLoc0,
0057                                    Acts::eBoundLoc1);
0058
0059     measOriginal.push_back(m);
0060
0061     ActsExamples::Cluster cl;
0062
0063     using Bin2D = ActsFatras::Segmentizer::Bin2D;
0064     using Seg2D = ActsFatras::Segmentizer::Segment2D;
0065
0066     // We have two cluster shapes which are displaced randomly
0067     const auto o = disti(gen);
0068     cl.channels.emplace_back(
0069         Bin2D{o + 0, o + 0},
0070         Seg2D{Acts::Vector2::Random(), Acts::Vector2::Random()}, distf(gen));
0071     cl.channels.emplace_back(
0072         Bin2D{o + 0, o + 1},
0073         Seg2D{Acts::Vector2::Random(), Acts::Vector2::Random()}, distf(gen));
0074     if (distf(gen) < 0.5) {
0075       cl.channels.emplace_back(
0076           Bin2D{o + 0, o + 2},
0077           Seg2D{Acts::Vector2::Random(), Acts::Vector2::Random()}, distf(gen));
0078       cl.sizeLoc0 = 1;
0079       cl.sizeLoc1 = 3;
0080     } else {
0081       cl.channels.emplace_back(
0082           Bin2D{o + 1, o + 0},
0083           Seg2D{Acts::Vector2::Random(), Acts::Vector2::Random()}, distf(gen));
0084       cl.sizeLoc0 = 2;
0085       cl.sizeLoc1 = 2;
0086     }
0087
0088     clusterOriginal.push_back(cl);
0089
0090     // Just generate some random hitid
0091     mapOriginal.insert(std::pair<Index, Index>{i, disti(gen)});
0092   }
0093
0094   ///////////
0095   // Write //
0096   ///////////
0097   CsvMeasurementWriter::Config writerConfig;
0098   writerConfig.inputClusters = "clusters";
0099   writerConfig.inputMeasurements = "meas";
0100   writerConfig.inputMeasurementSimHitsMap = "map";
0101   writerConfig.outputDir = "";
0102
0103   CsvMeasurementWriter writer(writerConfig, Acts::Logging::WARNING);
0104
0105   auto writeTool =
0106       GenericReadWriteTool<>()
0107           .add(writerConfig.inputMeasurements, measOriginal)
0108           .add(writerConfig.inputClusters, clusterOriginal)
0109           .add(writerConfig.inputMeasurementSimHitsMap, mapOriginal);
0110
0111   writeTool.write(writer);
0112
0113   //////////////////
0114   // Write & Read //
0115   //////////////////
0116   CsvMeasurementReader::Config readerConfig;
0117   readerConfig.inputDir = writerConfig.outputDir;
0118   readerConfig.outputMeasurements = writerConfig.inputMeasurements;
0119   readerConfig.outputMeasurementSimHitsMap =
0120       writerConfig.inputMeasurementSimHitsMap;
0121   readerConfig.outputClusters = writerConfig.inputClusters;
0122   readerConfig.outputSourceLinks = "sourcelinks";
0123
0124   CsvMeasurementReader reader(readerConfig, Acts::Logging::WARNING);
0125
0126   auto readTool =
0127       writeTool.add(readerConfig.outputSourceLinks, sourceLinksOriginal);
0128
0129   const auto [measRead, clusterRead, mapRead, sourceLinksRead] =
0130       readTool.read(reader);
0131
0132   ///////////
0133   // Check //
0134   ///////////
0135   auto checkMeasurementClose = [](const auto &m1, const auto &m2) {
0136     constexpr auto SizeA = std::decay_t<decltype(m1)>::size();
0137     constexpr auto SizeB = std::decay_t<decltype(m2)>::size();
0138     if constexpr (SizeA == SizeB) {
0139       CHECK_CLOSE_REL(m1.parameters(), m2.parameters(), 1e-4);
0140     }
0141   };
0142
0143   static_assert(
0144       std::is_same_v<std::decay_t<decltype(measRead)>, decltype(measOriginal)>);
0145   BOOST_REQUIRE(measRead.size() == measOriginal.size());
0146   for (const auto &[a, b] : Acts::zip(measRead, measOriginal)) {
0147     std::visit(checkMeasurementClose, a, b);
0148   }
0149
0150   static_assert(std::is_same_v<std::decay_t<decltype(clusterRead)>,
0151                                decltype(clusterOriginal)>);
0152   BOOST_REQUIRE(clusterRead.size() == clusterOriginal.size());
0153   for (auto [a, b] : Acts::zip(clusterRead, clusterOriginal)) {
0154     BOOST_REQUIRE(a.sizeLoc0 == b.sizeLoc0);
0155     BOOST_REQUIRE(a.sizeLoc1 == b.sizeLoc1);
0156
0157     for (const auto &ca : a.channels) {
0158       auto match = [&](const auto &cb) {
0159         return ca.bin == cb.bin &&
0160                std::abs(ca.activation - cb.activation) < 1.e-4;
0161       };
0162
0163       BOOST_CHECK(std::any_of(b.channels.begin(), b.channels.end(), match));
0164     }
0165   }
0166
0167   static_assert(
0168       std::is_same_v<std::decay_t<decltype(mapRead)>, decltype(mapOriginal)>);
0169   BOOST_REQUIRE(mapRead.size() == mapOriginal.size());
0170   for (const auto &[a, b] : Acts::zip(mapRead, mapOriginal)) {
0171     BOOST_REQUIRE(a == b);
0172   }
0173
0174   static_assert(std::is_same_v<std::decay_t<decltype(sourceLinksRead)>,
0175                                decltype(sourceLinksOriginal)>);
0176   BOOST_REQUIRE(sourceLinksRead.size() == sourceLinksOriginal.size());
0177   for (const auto &[a, b] : Acts::zip(sourceLinksRead, sourceLinksOriginal)) {
0178     BOOST_REQUIRE(a.geometryId() == b.geometryId());
0179     BOOST_REQUIRE(a.index() == b.index());
0180   }
0181 }