Core/Material/AccumulatedMaterialSlabTests.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/Material/AccumulatedMaterialSlab.hpp"
0012 #include "Acts/Material/Material.hpp"
0013 #include "Acts/Material/MaterialSlab.hpp"
0014 #include "ActsTests/CommonHelpers/FloatComparisons.hpp"
0015 #include "ActsTests/CommonHelpers/PredefinedMaterials.hpp"
0016
0017 #include <limits>
0018 #include <utility>
0019
0020 using namespace Acts;
0021
0022 constexpr auto eps = std::numeric_limits<float>::epsilon();
0023
0024 namespace ActsTests {
0025
0026 BOOST_AUTO_TEST_SUITE(MaterialSuite)
0027
0028 BOOST_AUTO_TEST_CASE(Nothing) {
0029   AccumulatedMaterialSlab a;
0030   auto [average, trackCount] = a.totalAverage();
0031   // material is vacuum
0032   BOOST_CHECK(average.isVacuum());
0033   BOOST_CHECK_EQUAL(trackCount, 0u);
0034 }
0035
0036 // average three empty tracks which are ignored by default
0037 BOOST_AUTO_TEST_CASE(EmptyTracksIgnored) {
0038   AccumulatedMaterialSlab a;
0039   a.trackAverage();
0040   a.trackAverage();
0041   a.trackAverage();
0042   auto [average, trackCount] = a.totalAverage();
0043   BOOST_CHECK(average.isVacuum());
0044   BOOST_CHECK_EQUAL(trackCount, 0u);
0045 }
0046
0047 // average three empty tracks and do not ignore them
0048 BOOST_AUTO_TEST_CASE(EmptyTracks) {
0049   AccumulatedMaterialSlab a;
0050   a.trackAverage(true);
0051   a.trackAverage(true);
0052   a.trackAverage(true);
0053   auto [average, trackCount] = a.totalAverage();
0054   BOOST_CHECK(average.isVacuum());
0055   BOOST_CHECK_EQUAL(trackCount, 3u);
0056 }
0057
0058 BOOST_AUTO_TEST_CASE(MultipleIdenticalThicknessTrackSteps) {
0059   MaterialSlab unit = makeUnitSlab();
0060   AccumulatedMaterialSlab a;
0061   // accumulate three identical steps for one track
0062   {
0063     a.accumulate(unit);
0064     a.accumulate(unit);
0065     a.accumulate(unit);
0066     a.trackAverage();
0067     auto [average, trackCount] = a.totalAverage();
0068     BOOST_CHECK_EQUAL(trackCount, 1u);
0069     BOOST_CHECK_EQUAL(average.material(), unit.material());
0070     BOOST_CHECK_EQUAL(average.thickness(), 3 * unit.thickness());
0071     BOOST_CHECK_EQUAL(average.thicknessInX0(), 3.0f);
0072     BOOST_CHECK_EQUAL(average.thicknessInL0(), 3.0f);
0073   }
0074   // accumulate three identical steps for one additional track
0075   {
0076     a.accumulate(unit);
0077     a.accumulate(unit);
0078     a.accumulate(unit);
0079     a.trackAverage();
0080     auto [average, trackCount] = a.totalAverage();
0081     BOOST_CHECK_EQUAL(trackCount, 2u);
0082     // averages must stay the same since we added the same material again
0083     BOOST_CHECK_EQUAL(average.material(), unit.material());
0084     BOOST_CHECK_EQUAL(average.thickness(), 3 * unit.thickness());
0085     BOOST_CHECK_EQUAL(average.thicknessInX0(), 3.0f);
0086     BOOST_CHECK_EQUAL(average.thicknessInL0(), 3.0f);
0087   }
0088 }
0089
0090 // accumulate and average three tracks.
0091 // each track contributes the same material but each in different steps.
0092 BOOST_AUTO_TEST_CASE(MultipleDifferentThicknessTrackSteps) {
0093   MaterialSlab unit = makeUnitSlab();
0094   AccumulatedMaterialSlab a;
0095   // accumulate three identical steps
0096   {
0097     a.accumulate(unit);
0098     a.accumulate(unit);
0099     a.accumulate(unit);
0100     a.trackAverage();
0101     auto [average, trackCount] = a.totalAverage();
0102     BOOST_CHECK_EQUAL(trackCount, 1u);
0103     BOOST_CHECK_EQUAL(average.material(), unit.material());
0104     BOOST_CHECK_EQUAL(average.thickness(), 3 * unit.thickness());
0105     BOOST_CHECK_EQUAL(average.thicknessInX0(), 3.0f);
0106     BOOST_CHECK_EQUAL(average.thicknessInL0(), 3.0f);
0107   }
0108   // accumulate one step with thickness 1, one with thickness 2
0109   {
0110     MaterialSlab twice = unit;
0111     twice.scaleThickness(2);
0112     a.accumulate(unit);
0113     a.accumulate(twice);
0114     a.trackAverage();
0115     auto [average, trackCount] = a.totalAverage();
0116     BOOST_CHECK_EQUAL(trackCount, 2u);
0117     // averages must stay the same
0118     BOOST_CHECK_EQUAL(average.material(), unit.material());
0119     BOOST_CHECK_EQUAL(average.thickness(), 3 * unit.thickness());
0120     BOOST_CHECK_EQUAL(average.thicknessInX0(), 3.0f);
0121     BOOST_CHECK_EQUAL(average.thicknessInL0(), 3.0f);
0122   }
0123   // accumulate one step with thickness 3
0124   {
0125     MaterialSlab thrice = unit;
0126     thrice.scaleThickness(3);
0127     a.accumulate(thrice);
0128     a.trackAverage();
0129     auto [average, trackCount] = a.totalAverage();
0130     BOOST_CHECK_EQUAL(trackCount, 3u);
0131     // averages must stay the same
0132     BOOST_CHECK_EQUAL(average.material(), unit.material());
0133     BOOST_CHECK_EQUAL(average.thickness(), 3 * unit.thickness());
0134     BOOST_CHECK_EQUAL(average.thicknessInX0(), 3.0f);
0135     BOOST_CHECK_EQUAL(average.thicknessInL0(), 3.0f);
0136   }
0137 }
0138
0139 // average multiple tracks w/ one step each but different materials
0140 BOOST_AUTO_TEST_CASE(MultipleDifferentTracks) {
0141   MaterialSlab unit = makeUnitSlab();
0142   AccumulatedMaterialSlab a;
0143   // add material w/ given thickness
0144   {
0145     a.accumulate(unit);
0146     a.trackAverage();
0147     auto [average, trackCount] = a.totalAverage();
0148     BOOST_CHECK_EQUAL(trackCount, 1u);
0149     BOOST_CHECK_EQUAL(average.material(), unit.material());
0150     BOOST_CHECK_EQUAL(average.thickness(), unit.thickness());
0151     BOOST_CHECK_EQUAL(average.thicknessInX0(), unit.thicknessInX0());
0152     BOOST_CHECK_EQUAL(average.thicknessInL0(), unit.thicknessInL0());
0153   }
0154   // add material w/ given three times the initial thickness
0155   {
0156     MaterialSlab three = unit;
0157     three.scaleThickness(3);
0158     a.accumulate(three);
0159     a.trackAverage();
0160     auto [average, trackCount] = a.totalAverage();
0161     BOOST_CHECK_EQUAL(trackCount, 2);
0162     // average thickness should now be 2*initial, average material unchanged
0163     BOOST_CHECK_EQUAL(average.material(), unit.material());
0164     BOOST_CHECK_EQUAL(average.thickness(), 2 * unit.thickness());
0165     BOOST_CHECK_EQUAL(average.thicknessInX0(), 2 * unit.thicknessInX0());
0166     BOOST_CHECK_EQUAL(average.thicknessInL0(), 2 * unit.thicknessInL0());
0167   }
0168   // add vacuum w/ given the same thickness as the current average
0169   {
0170     MaterialSlab vac = MaterialSlab::Vacuum(2 * unit.thickness());
0171     // add vacuum twice to counteract the existing two tracks stored
0172     a.accumulate(vac);
0173     a.trackAverage();
0174     a.accumulate(vac);
0175     a.trackAverage();
0176     auto [average, trackCount] = a.totalAverage();
0177     BOOST_CHECK_EQUAL(trackCount, 4u);
0178     // average material density halved
0179     CHECK_CLOSE_REL(average.material().X0(), 2 * unit.material().X0(), eps);
0180     CHECK_CLOSE_REL(average.material().L0(), 2 * unit.material().L0(), eps);
0181     CHECK_CLOSE_REL(average.material().molarDensity(),
0182                     0.5f * unit.material().molarDensity(), eps);
0183     // average atom is still the same species
0184     CHECK_CLOSE_REL(average.material().Ar(), unit.material().Ar(), eps);
0185     // average atomic number proportional to the thickness
0186     CHECK_CLOSE_REL(average.material().Z(), 0.5 * unit.material().Z(), eps);
0187     // thickness in x0/l0 depends on density and thus halved as well
0188     BOOST_CHECK_EQUAL(average.thicknessInX0(), 1 * unit.thicknessInX0());
0189     BOOST_CHECK_EQUAL(average.thicknessInL0(), 1 * unit.thicknessInL0());
0190     // average real thickness stays the same
0191     BOOST_CHECK_EQUAL(average.thickness(), 2 * unit.thickness());
0192   }
0193 }
0194
0195 BOOST_AUTO_TEST_SUITE_END()
0196
0197 }  // namespace ActsTests