Plugins/Root/RootMaterialMapIoTests.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/unit_test.hpp>
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Material/BinnedSurfaceMaterial.hpp"
0013 #include "Acts/Material/HomogeneousSurfaceMaterial.hpp"
0014 #include "Acts/Material/Material.hpp"
0015 #include "Acts/Material/MaterialSlab.hpp"
0016 #include "Acts/Plugins/Root/RootMaterialMapIo.hpp"
0017 #include "Acts/Surfaces/PlaneSurface.hpp"
0018 #include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
0019 #include "Acts/Utilities/BinUtility.hpp"
0020
0021 #include <memory>
0022 #include <tuple>
0023 #include <vector>
0024
0025 #include "TFile.h"
0026
0027 using namespace Acts;
0028
0029 using IdentifiedMaterial =
0030     std::tuple<GeometryIdentifier, std::shared_ptr<ISurfaceMaterial>>;
0031
0032 std::vector<IdentifiedMaterial> createHomogeneousSurfaceMaterial() {
0033   std::size_t nMaterials = 100;
0034
0035   std::vector<IdentifiedMaterial> homogeneousMaterials;
0036   homogeneousMaterials.reserve(nMaterials);
0037   for (std::size_t i = 0; i < nMaterials; ++i) {
0038     // construct the material properties from arguments
0039     Material mat = Material::fromMolarDensity(
0040         1. + i * 0.5, 2. + i * 0.5, 3. + i * 0.5, 4. + i * 0.5, 5. + i * 0.5);
0041     MaterialSlab mp(mat, 0.1);
0042     auto hMaterial = std::make_shared<HomogeneousSurfaceMaterial>(mp);
0043     auto geoID = GeometryIdentifier().withVolume(1).withSensitive(i + 1);
0044     homogeneousMaterials.push_back({geoID, hMaterial});
0045   }
0046   return homogeneousMaterials;
0047 }
0048
0049 std::vector<IdentifiedMaterial> createBinnedSurfaceMaterial() {
0050   std::size_t nMaterials = 100;
0051
0052   std::vector<IdentifiedMaterial> binnedMaterials;
0053   binnedMaterials.reserve(nMaterials);
0054   for (std::size_t i = 0; i < nMaterials; ++i) {
0055     // construct the material properties from arguments
0056
0057     BinUtility xyBinning(100, -1., 1., open, AxisDirection::AxisX);
0058     xyBinning += BinUtility(50, -3., 3., open, AxisDirection::AxisY);
0059
0060     std::vector<std::vector<MaterialSlab>> materialMatrix;
0061     for (std::size_t j = 0; j < xyBinning.bins(1); ++j) {
0062       std::vector<MaterialSlab> materialRow;
0063       for (std::size_t k = 0; k < xyBinning.bins(0); ++k) {
0064         // Create a material slab with some arbitrary properties
0065         Material mat = Material::fromMolarDensity(
0066             i + j * 1. + k * 0.5, i + j * 2 + k * 0.5, i + j * 3. + k * 0.5,
0067             i + j * 4. + k * 0.5, i + j * 5. + k * 0.5);
0068         MaterialSlab mp(mat, 0.1);
0069         materialRow.push_back(mp);
0070       }
0071       materialMatrix.push_back(materialRow);
0072     }
0073     auto binnedMaterial =
0074         std::make_shared<BinnedSurfaceMaterial>(xyBinning, materialMatrix);
0075     auto geoID = GeometryIdentifier().withVolume(2).withSensitive(i + 1);
0076     binnedMaterials.push_back({geoID, binnedMaterial});
0077   }
0078   return binnedMaterials;
0079 }
0080
0081 BOOST_AUTO_TEST_SUITE(RootMaterialMapIoTests)
0082
0083 BOOST_AUTO_TEST_CASE(RootMaterialMapIoHomogeneousReadWrite) {
0084   auto surfaceMaterials = createHomogeneousSurfaceMaterial();
0085
0086   auto rFile =
0087       TFile::Open("RootMaterialMapIoHomogeneousTests.root", "RECREATE");
0088   rFile->cd();
0089   BOOST_REQUIRE(rFile != nullptr);
0090
0091   // Create the accessor
0092   RootMaterialMapIo::Config cfg;
0093   RootMaterialMapIo accessor(cfg);
0094   RootMaterialMapIo::Options options;
0095
0096   for (const auto& [geoID, sMaterial] : surfaceMaterials) {
0097     accessor.write(*rFile, geoID, *sMaterial, options);
0098   }
0099
0100   rFile->Write();
0101   rFile->Close();
0102
0103   // Let's read it back
0104   auto iFile = TFile::Open("RootMaterialMapIoHomogeneousTests.root", "READ");
0105   BOOST_REQUIRE(iFile != nullptr);
0106
0107   auto [surfaceMapsRead, volumeMapsRead] = accessor.read(*iFile, options);
0108   BOOST_REQUIRE_EQUAL(surfaceMapsRead.size(), surfaceMaterials.size());
0109   BOOST_REQUIRE_EQUAL(volumeMapsRead.size(), 0);
0110
0111   Vector3 accessorPosition(0., 0., 0.);
0112
0113   for (const auto& [geoID, sMaterial] : surfaceMaterials) {
0114     auto it = surfaceMapsRead.find(geoID);
0115     BOOST_REQUIRE(it != surfaceMapsRead.end());
0116     const auto& readMaterial = it->second;
0117     BOOST_REQUIRE(readMaterial != nullptr);
0118     const auto* hMaterial =
0119         dynamic_cast<const HomogeneousSurfaceMaterial*>(readMaterial.get());
0120     BOOST_REQUIRE(hMaterial != nullptr);
0121     BOOST_CHECK_CLOSE(hMaterial->materialSlab(accessorPosition).material().X0(),
0122                       sMaterial->materialSlab(accessorPosition).material().X0(),
0123                       1e-6);
0124     BOOST_CHECK_CLOSE(hMaterial->materialSlab(accessorPosition).material().L0(),
0125                       sMaterial->materialSlab(accessorPosition).material().L0(),
0126                       1e-6);
0127   }
0128 }
0129
0130 BOOST_AUTO_TEST_CASE(RootMaterialMapIoBinnedReadWrite) {
0131   auto surfaceMaterials = createBinnedSurfaceMaterial();
0132
0133   auto rFile = TFile::Open("RootMaterialMapIoBinnedTests.root", "RECREATE");
0134   rFile->cd();
0135   BOOST_REQUIRE(rFile != nullptr);
0136
0137   // Create the accessor
0138   RootMaterialMapIo::Config cfg;
0139   RootMaterialMapIo accessor(cfg);
0140   RootMaterialMapIo::Options options;
0141
0142   for (const auto& [geoID, sMaterial] : surfaceMaterials) {
0143     accessor.write(*rFile, geoID, *sMaterial, options);
0144   }
0145
0146   rFile->Write();
0147   rFile->Close();
0148
0149   // Let's read it back
0150   auto iFile = TFile::Open("RootMaterialMapIoBinnedTests.root", "READ");
0151   BOOST_REQUIRE(iFile != nullptr);
0152   auto [surfaceMapsRead, volumeMapsRead] = accessor.read(*iFile, options);
0153   BOOST_REQUIRE_EQUAL(surfaceMapsRead.size(), surfaceMaterials.size());
0154   BOOST_REQUIRE_EQUAL(volumeMapsRead.size(), 0);
0155
0156   // Compare
0157   for (const auto& [refGeoID, refSMaterial] : surfaceMaterials) {
0158     auto binnedReferenceMaterial =
0159         dynamic_cast<const BinnedSurfaceMaterial*>(refSMaterial.get());
0160
0161     BOOST_REQUIRE(binnedReferenceMaterial != nullptr);
0162
0163     auto it = surfaceMapsRead.find(refGeoID);
0164     BOOST_REQUIRE(it != surfaceMapsRead.end());
0165     const auto& readMaterial = it->second;
0166     BOOST_REQUIRE(readMaterial != nullptr);
0167     const auto* binnedMaterial =
0168         dynamic_cast<const BinnedSurfaceMaterial*>(readMaterial.get());
0169     BOOST_REQUIRE(binnedMaterial != nullptr);
0170
0171     // Check the binning
0172     BOOST_CHECK_EQUAL(binnedMaterial->binUtility().bins(0),
0173                       binnedReferenceMaterial->binUtility().bins(0));
0174     BOOST_CHECK_EQUAL(binnedMaterial->binUtility().bins(1),
0175                       binnedReferenceMaterial->binUtility().bins(1));
0176
0177     // Compare the material matrix
0178     const auto& materialMatrix = binnedMaterial->fullMaterial();
0179     const auto& referenceMaterialMatrix =
0180         binnedReferenceMaterial->fullMaterial();
0181
0182     BOOST_REQUIRE_EQUAL(materialMatrix.size(), referenceMaterialMatrix.size());
0183     for (std::size_t i = 0; i < materialMatrix.size(); ++i) {
0184       BOOST_REQUIRE_EQUAL(materialMatrix[i].size(),
0185                           referenceMaterialMatrix[i].size());
0186       for (std::size_t j = 0; j < materialMatrix[i].size(); ++j) {
0187         const auto& mat = materialMatrix[i][j];
0188         const auto& refMat = referenceMaterialMatrix[i][j];
0189         BOOST_CHECK_CLOSE(mat.material().X0(), refMat.material().X0(), 1e-6);
0190         BOOST_CHECK_CLOSE(mat.material().L0(), refMat.material().L0(), 1e-6);
0191         BOOST_CHECK_CLOSE(mat.material().Ar(), refMat.material().Ar(), 1e-6);
0192         BOOST_CHECK_CLOSE(mat.material().Z(), refMat.material().Z(), 1e-6);
0193         BOOST_CHECK_CLOSE(mat.thickness(), refMat.thickness(), 1e-6);
0194       }
0195     }
0196   }
0197
0198   // Create the accessor - writing with indexed material
0199   RootMaterialMapIo::Config cfgIndexed;
0200   RootMaterialMapIo accessorIndexed(cfgIndexed);
0201
0202   RootMaterialMapIo::Options optionsIndexed;
0203   optionsIndexed.indexedMaterial = true;
0204
0205   rFile = TFile::Open("RootMaterialMapIoBinnedIndexedTests.root", "RECREATE");
0206   rFile->cd();
0207   BOOST_REQUIRE(rFile != nullptr);
0208
0209   for (const auto& [geoID, sMaterial] : surfaceMaterials) {
0210     accessorIndexed.write(*rFile, geoID, *sMaterial, optionsIndexed);
0211   }
0212
0213   rFile->Write();
0214   rFile->Close();
0215
0216   // Let's read it back
0217   iFile = TFile::Open("RootMaterialMapIoBinnedIndexedTests.root", "READ");
0218   BOOST_REQUIRE(iFile != nullptr);
0219   auto [surfaceMapsIndexedRead, volumeMapsIndexedRead] =
0220       accessorIndexed.read(*iFile, optionsIndexed);
0221   BOOST_REQUIRE_EQUAL(surfaceMapsIndexedRead.size(), surfaceMaterials.size());
0222   BOOST_REQUIRE_EQUAL(volumeMapsIndexedRead.size(), 0);
0223
0224   // Compare
0225   for (const auto& [refGeoID, refSMaterial] : surfaceMaterials) {
0226     auto binnedReferenceMaterial =
0227         dynamic_cast<const BinnedSurfaceMaterial*>(refSMaterial.get());
0228     BOOST_REQUIRE(binnedReferenceMaterial != nullptr);
0229     auto it = surfaceMapsIndexedRead.find(refGeoID);
0230     BOOST_REQUIRE(it != surfaceMapsIndexedRead.end());
0231     const auto& readMaterial = it->second;
0232     BOOST_REQUIRE(readMaterial != nullptr);
0233     const auto* binnedMaterial =
0234         dynamic_cast<const BinnedSurfaceMaterial*>(readMaterial.get());
0235     BOOST_REQUIRE(binnedMaterial != nullptr);
0236     // Check the binning
0237     BOOST_CHECK_EQUAL(binnedMaterial->binUtility().bins(0),
0238                       binnedReferenceMaterial->binUtility().bins(0));
0239     BOOST_CHECK_EQUAL(binnedMaterial->binUtility().bins(1),
0240                       binnedReferenceMaterial->binUtility().bins(1));
0241     // Compare the material matrix
0242     const auto& materialMatrix = binnedMaterial->fullMaterial();
0243     const auto& referenceMaterialMatrix =
0244         binnedReferenceMaterial->fullMaterial();
0245     BOOST_REQUIRE_EQUAL(materialMatrix.size(), referenceMaterialMatrix.size());
0246     for (std::size_t i = 0; i < materialMatrix.size(); ++i) {
0247       BOOST_REQUIRE_EQUAL(materialMatrix[i].size(),
0248                           referenceMaterialMatrix[i].size());
0249       for (std::size_t j = 0; j < materialMatrix[i].size(); ++j) {
0250         const auto& mat = materialMatrix[i][j];
0251         const auto& refMat = referenceMaterialMatrix[i][j];
0252         BOOST_CHECK_CLOSE(mat.material().X0(), refMat.material().X0(), 1e-6);
0253         BOOST_CHECK_CLOSE(mat.material().L0(), refMat.material().L0(), 1e-6);
0254         BOOST_CHECK_CLOSE(mat.material().Ar(), refMat.material().Ar(), 1e-6);
0255         BOOST_CHECK_CLOSE(mat.material().Z(), refMat.material().Z(), 1e-6);
0256         BOOST_CHECK_CLOSE(mat.thickness(), refMat.thickness(), 1e-6);
0257       }
0258     }
0259   }
0260 }
0261
0262 BOOST_AUTO_TEST_SUITE_END()