Core/Material/AccumulatedSurfaceMaterialTests.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/AccumulatedMaterialSlab.hpp"
0013 #include "Acts/Material/AccumulatedSurfaceMaterial.hpp"
0014 #include "Acts/Material/Material.hpp"
0015 #include "Acts/Material/MaterialSlab.hpp"
0016 #include "Acts/Utilities/BinUtility.hpp"
0017 #include "Acts/Utilities/BinningType.hpp"
0018
0019 #include <array>
0020 #include <cstddef>
0021 #include <memory>
0022 #include <vector>
0023
0024 using namespace Acts;
0025
0026 namespace ActsTest {
0027
0028 BOOST_AUTO_TEST_SUITE(MaterialSuite)
0029
0030 /// Test the constructors
0031 BOOST_AUTO_TEST_CASE(AccumulatedSurfaceMaterial_construction_test) {
0032   // Test:
0033   // HomogeneousSurfaceMaterial accumulation
0034   AccumulatedSurfaceMaterial material0D{};
0035   auto accMat0D = material0D.accumulatedMaterial();
0036   BOOST_CHECK_EQUAL(accMat0D.size(), 1u);
0037   BOOST_CHECK_EQUAL(accMat0D[0].size(), 1u);
0038   BOOST_CHECK_EQUAL(material0D.splitFactor(), 0.);
0039
0040   // Test:
0041   // BinsSurfaceMaterial accumulation - 1D
0042   BinUtility binUtility1D(10, -5., 5., open, AxisDirection::AxisX);
0043   AccumulatedSurfaceMaterial material1D{binUtility1D};
0044   auto accMat1D = material1D.accumulatedMaterial();
0045   BOOST_CHECK_EQUAL(accMat1D.size(), 1u);
0046   BOOST_CHECK_EQUAL(accMat1D[0].size(), 10u);
0047
0048   // Test:
0049   // BinsSurfaceMaterial accumulation - 2D
0050   BinUtility binUtility2D(10, -5., 5., open, AxisDirection::AxisX);
0051   binUtility2D += BinUtility(20, -10., 10., open, AxisDirection::AxisY);
0052   AccumulatedSurfaceMaterial material2D{binUtility2D};
0053   auto accMat2D = material2D.accumulatedMaterial();
0054   BOOST_CHECK_EQUAL(accMat2D.size(), 20u);
0055   for (std::size_t ib = 0; ib < accMat2D.size(); ++ib) {
0056     BOOST_CHECK_EQUAL(accMat2D[ib].size(), 10u);
0057   }
0058 }
0059
0060 /// Test the filling and conversion
0061 BOOST_AUTO_TEST_CASE(AccumulatedSurfaceMaterial_fill_convert_0D) {
0062   Material mat = Material::fromMolarDensity(1., 1., 1., 1., 1.);
0063   MaterialSlab one(mat, 1.);
0064   MaterialSlab two(mat, 2.);
0065
0066   AccumulatedSurfaceMaterial material0D{};
0067   const std::vector<std::array<std::size_t, 3>> bin;
0068   // assign 2 one steps
0069   material0D.accumulate(Vector2{0., 0.}, one);
0070   material0D.accumulate(Vector2{0., 0.}, one);
0071   material0D.trackVariance(bin, one);
0072   material0D.trackAverage();
0073   // assign 1 double step
0074   material0D.accumulate(Vector3(0., 0., 0.), two);
0075   material0D.trackVariance(bin, one);
0076   material0D.trackAverage();
0077   // get the single matrix
0078   auto accMat0D = material0D.accumulatedMaterial();
0079   auto accMatProp0D = accMat0D[0][0];
0080   auto [matProp0D, trackCount] = accMatProp0D.totalAverage();
0081   auto [matVar0D, trackCount2] = accMatProp0D.totalVariance();
0082
0083   BOOST_CHECK_EQUAL(matVar0D, 0.0);
0084   BOOST_CHECK_EQUAL(matProp0D.thicknessInX0(), two.thicknessInX0());
0085   BOOST_CHECK_EQUAL(trackCount, trackCount2);
0086   BOOST_CHECK_EQUAL(trackCount, 2u);
0087 }
0088
0089 /// Test the filling and conversion
0090 BOOST_AUTO_TEST_CASE(AccumulatedSurfaceMaterial_fill_convert_1D) {
0091   Material mat = Material::fromMolarDensity(1., 1., 1., 1., 1.);
0092   MaterialSlab one(mat, 1.);
0093   MaterialSlab two(mat, 2.);
0094   MaterialSlab three(mat, 3.);
0095   MaterialSlab four(mat, 4.);
0096
0097   // BinsSurfaceMaterial accumulation - 2D
0098   BinUtility binUtility2D(2, -1., 1., open, AxisDirection::AxisX);
0099   binUtility2D += BinUtility(2, -1., 1., open, AxisDirection::AxisY);
0100   AccumulatedSurfaceMaterial material2D{binUtility2D};
0101   const std::vector<std::array<std::size_t, 3>> bin;
0102
0103   // assign in the different bins
0104   // event 0
0105   material2D.accumulate(Vector2{-0.5, -0.5}, one);
0106   material2D.accumulate(Vector2{0.5, -0.5}, two);
0107   material2D.accumulate(Vector2{-0.5, 0.5}, three);
0108   material2D.accumulate(Vector2{0.5, 0.5}, four);
0109   material2D.trackVariance(bin, one);
0110   material2D.trackAverage();
0111   // event 1
0112   material2D.accumulate(Vector2{0.5, -0.5}, two);
0113   material2D.accumulate(Vector2{-0.5, 0.5}, three);
0114   material2D.accumulate(Vector2{0.5, 0.5}, four);
0115   material2D.trackVariance(bin, one);
0116   material2D.trackAverage();
0117   // event 2
0118   material2D.accumulate(Vector2{-0.5, 0.5}, three);
0119   material2D.accumulate(Vector2{0.5, 0.5}, four);
0120   material2D.trackVariance(bin, one);
0121   material2D.trackAverage();
0122   // event 2
0123   material2D.accumulate(Vector2{0.5, 0.5}, four);
0124   material2D.trackVariance(bin, one);
0125   material2D.trackAverage();
0126   // get the single matrix
0127   auto accMat2D = material2D.accumulatedMaterial();
0128   // the accumulated properties
0129   auto [accMatProp00, trackCount00] = accMat2D[0][0].totalAverage();
0130   auto [accMatProp01, trackCount01] = accMat2D[0][1].totalAverage();
0131   auto [accMatProp10, trackCount10] = accMat2D[1][0].totalAverage();
0132   auto [accMatProp11, trackCount11] = accMat2D[1][1].totalAverage();
0133
0134   auto [matVar00, trackCount200] = accMat2D[0][0].totalVariance();
0135   auto [matVar01, trackCount201] = accMat2D[0][1].totalVariance();
0136   auto [matVar10, trackCount210] = accMat2D[1][0].totalVariance();
0137   auto [matVar11, trackCount211] = accMat2D[1][1].totalVariance();
0138
0139   BOOST_CHECK_EQUAL(accMatProp00.thicknessInX0(), one.thicknessInX0());
0140   BOOST_CHECK_EQUAL(accMatProp01.thicknessInX0(), two.thicknessInX0());
0141   BOOST_CHECK_EQUAL(accMatProp10.thicknessInX0(), three.thicknessInX0());
0142   BOOST_CHECK_EQUAL(accMatProp11.thicknessInX0(), four.thicknessInX0());
0143
0144   BOOST_CHECK_EQUAL(matVar11, 0.0);
0145   BOOST_CHECK_EQUAL(matVar11, 0.0);
0146   BOOST_CHECK_EQUAL(matVar11, 0.0);
0147   BOOST_CHECK_EQUAL(matVar11, 0.0);
0148
0149   BOOST_CHECK_EQUAL(trackCount00, trackCount200);
0150   BOOST_CHECK_EQUAL(trackCount01, trackCount201);
0151   BOOST_CHECK_EQUAL(trackCount10, trackCount210);
0152   BOOST_CHECK_EQUAL(trackCount11, trackCount211);
0153
0154   BOOST_CHECK_EQUAL(trackCount00, 1u);
0155   BOOST_CHECK_EQUAL(trackCount01, 2u);
0156   BOOST_CHECK_EQUAL(trackCount10, 3u);
0157   BOOST_CHECK_EQUAL(trackCount11, 4u);
0158 }
0159
0160 /// Test the variance
0161 BOOST_AUTO_TEST_CASE(AccumulatedSurfaceMaterial_variance_0D) {
0162   Material mat1 = Material::fromMolarDensity(1.0 / 3, 1., 1., 1., 1.);
0163   Material mat2 = Material::fromMolarDensity(1, 1., 1., 1., 1.);
0164   Material matAvg = Material::fromMolarDensity(0.5, 1., 1., 1., 1.);
0165
0166   MaterialSlab one(mat1, 1.);
0167   MaterialSlab two(mat2, 1.);
0168   MaterialSlab avg(matAvg, 1.);
0169
0170   AccumulatedSurfaceMaterial material0D{};
0171   const std::vector<std::array<std::size_t, 3>> bin;
0172   // assign 2 one steps
0173   material0D.accumulate(Vector2{0., 0.}, one);
0174   material0D.trackVariance(bin, avg);
0175   material0D.trackAverage();
0176   // assign 1 double step
0177   material0D.accumulate(Vector3(0., 0., 0.), two);
0178   material0D.trackVariance(bin, avg);
0179   material0D.trackAverage();
0180   // get the single matrix
0181   auto accMat0D = material0D.accumulatedMaterial();
0182   auto accMatProp0D = accMat0D[0][0];
0183   auto [matProp0D, trackCount] = accMatProp0D.totalAverage();
0184   auto [matVar0D, trackCount2] = accMatProp0D.totalVariance();
0185
0186   BOOST_CHECK_EQUAL(matVar0D, 1.0);
0187   BOOST_CHECK_EQUAL(matProp0D.thicknessInX0(), avg.thicknessInX0());
0188   BOOST_CHECK_EQUAL(trackCount, trackCount2);
0189   BOOST_CHECK_EQUAL(trackCount, 2u);
0190 }
0191
0192 BOOST_AUTO_TEST_SUITE_END()
0193
0194 }  // namespace ActsTest