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