Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-10-16 08:04:14 

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/AccumulatedVolumeMaterial.hpp"
0013 #include "Acts/Material/Material.hpp"
0014 #include "Acts/Material/MaterialGridHelper.hpp"
0015 #include "Acts/Material/MaterialSlab.hpp"
0016 #include "Acts/Utilities/Axis.hpp"
0017 #include "Acts/Utilities/AxisDefinitions.hpp"
0018 #include "Acts/Utilities/BinUtility.hpp"
0019 #include "Acts/Utilities/BinningType.hpp"
0020 #include "Acts/Utilities/Grid.hpp"
0021 #include "ActsTests/CommonHelpers/FloatComparisons.hpp"
0022 
0023 #include <cmath>
0024 #include <functional>
0025 #include <memory>
0026 #include <numbers>
0027 #include <utility>
0028 #include <vector>
0029 
0030 using namespace Acts;
0031 
0032 namespace ActsTests {
0033 
0034 using EAxis = Axis<AxisType::Equidistant>;
0035 using Grid2D = Grid<AccumulatedVolumeMaterial, EAxis, EAxis>;
0036 using Grid3D = Grid<AccumulatedVolumeMaterial, EAxis, EAxis, EAxis>;
0037 using MaterialGrid2D = Grid<Material::ParametersVector, EAxis, EAxis>;
0038 using MaterialGrid3D = Grid<Material::ParametersVector, EAxis, EAxis, EAxis>;
0039 
0040 BOOST_AUTO_TEST_SUITE(MaterialSuite)
0041 
0042 /// @brief Various test for the Material in the case of a Cuboid volume and 2D
0043 /// Grid
0044 BOOST_AUTO_TEST_CASE(Square_Grid_test) {
0045   BinUtility bu(7, -3., 3., open, AxisDirection::AxisX);
0046   bu += BinUtility(3, -2., 2., open, AxisDirection::AxisY);
0047   auto bd = bu.binningData();
0048   std::function<Vector2(Vector3)> transfoGlobalToLocal;
0049 
0050   Grid2D Grid = createGrid2D(bu, transfoGlobalToLocal);
0051 
0052   // Test Global To Local transform
0053   Vector3 pos(1., 2., 3.);
0054   Vector2 pos_2d(1., 2.);
0055   BOOST_CHECK_EQUAL(pos_2d, transfoGlobalToLocal(pos));
0056 
0057   // Test Grid
0058   BOOST_CHECK_EQUAL(Grid.dimensions(), 2);
0059 
0060   BOOST_CHECK_EQUAL(Grid.numLocalBins()[0], bd[0].bins());
0061   BOOST_CHECK_EQUAL(Grid.numLocalBins()[1], bd[1].bins());
0062 
0063   BOOST_CHECK_EQUAL(Grid.minPosition()[0], bd[0].min);
0064   BOOST_CHECK_EQUAL(Grid.minPosition()[1], bd[1].min);
0065 
0066   float max1 = bd[0].max + std::abs(bd[0].max - bd[0].min) / (bd[0].bins() - 1);
0067   float max2 = bd[1].max + std::abs(bd[1].max - bd[1].min) / (bd[1].bins() - 1);
0068 
0069   BOOST_CHECK_EQUAL(Grid.maxPosition()[0], max1);
0070   BOOST_CHECK_EQUAL(Grid.maxPosition()[1], max2);
0071 
0072   // Test pos to index
0073   Grid2D::index_t index1 = {1, 1};
0074   Grid2D::index_t index2 = {7, 2};
0075   Grid2D::index_t index3 = {1, 3};
0076 
0077   Vector3 pos1 = {-2.6, -1.5, -0.7};
0078   Vector3 pos2 = {2.8, 0, 0.2};
0079   Vector3 pos3 = {-2.7, 1.8, 0.8};
0080 
0081   for (int i = 0; i < 2; i++) {
0082     BOOST_CHECK_EQUAL(
0083         Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(pos1))[i],
0084         index1[i]);
0085     BOOST_CHECK_EQUAL(
0086         Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(pos2))[i],
0087         index2[i]);
0088     BOOST_CHECK_EQUAL(
0089         Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(pos3))[i],
0090         index3[i]);
0091   }
0092   // Test material mapping
0093 
0094   std::vector<Vector3> vectPos1;
0095   vectPos1.push_back(pos1);
0096   std::vector<Vector3> vectPos2;
0097   vectPos2.push_back(pos2);
0098   std::vector<Vector3> vectPos3;
0099   vectPos3.push_back(pos3);
0100 
0101   std::vector<std::pair<MaterialSlab, std::vector<Vector3>>> matRecord;
0102   Material mat1 = Material::fromMolarDensity(1., 2., 3., 4., 5.);
0103   Material mat2 = Material::fromMolarDensity(6., 7., 8., 9., 10.);
0104   Material vacuum = Material::Vacuum();
0105 
0106   MaterialSlab matprop1(mat1, 1);
0107   MaterialSlab matprop2(mat2, 1);
0108 
0109   matRecord.clear();
0110   matRecord.push_back(std::make_pair(matprop1, vectPos1));
0111   matRecord.push_back(std::make_pair(matprop2, vectPos2));
0112 
0113   // Walk over each property
0114   for (const auto& rm : matRecord) {
0115     // Walk over each point associated with the properties
0116     for (const auto& point : rm.second) {
0117       // Search for fitting grid point and accumulate
0118       Grid2D::index_t index =
0119           Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(point));
0120       Grid.atLocalBins(index).accumulate(rm.first);
0121     }
0122   }
0123 
0124   MaterialGrid2D matMap = mapMaterialPoints(Grid);
0125 
0126   CHECK_CLOSE_REL(matMap.atLocalBins(index1), mat1.parameters(), 1e-4);
0127   CHECK_CLOSE_REL(matMap.atLocalBins(index2), mat2.parameters(), 1e-4);
0128   BOOST_CHECK_EQUAL(matMap.atLocalBins(index3), vacuum.parameters());
0129 }
0130 
0131 /// @brief Various test for the Material in the case of a Cylindrical volume
0132 /// with a 2D grid
0133 BOOST_AUTO_TEST_CASE(PhiZ_Grid_test) {
0134   BinUtility bu(2, -2., 2., open, AxisDirection::AxisZ);
0135   bu += BinUtility(3, -std::numbers::pi, std::numbers::pi, closed,
0136                    AxisDirection::AxisPhi);
0137   auto bd = bu.binningData();
0138   std::function<Vector2(Vector3)> transfoGlobalToLocal;
0139 
0140   Grid2D Grid = createGrid2D(bu, transfoGlobalToLocal);
0141 
0142   // Test Global To Local transform
0143   Vector3 pos(1., 2., 3.);
0144 
0145   CHECK_CLOSE_REL(transfoGlobalToLocal(pos)[1], atan2(2, 1), 1e-4);
0146   CHECK_CLOSE_REL(transfoGlobalToLocal(pos)[0], 3, 1e-4);
0147 
0148   // Test Grid
0149   BOOST_CHECK_EQUAL(Grid.dimensions(), 2);
0150 
0151   BOOST_CHECK_EQUAL(Grid.numLocalBins()[0], bd[0].bins());
0152   BOOST_CHECK_EQUAL(Grid.numLocalBins()[1], bd[1].bins());
0153 
0154   BOOST_CHECK_EQUAL(Grid.minPosition()[0], bd[0].min);
0155   BOOST_CHECK_EQUAL(Grid.minPosition()[1], bd[1].min);
0156 
0157   float max1 = bd[0].max + std::abs(bd[0].max - bd[0].min) / (bd[0].bins() - 1);
0158   float max2 = bd[1].max + std::abs(bd[1].max - bd[1].min) / (bd[1].bins() - 1);
0159 
0160   BOOST_CHECK_EQUAL(Grid.maxPosition()[0], max1);
0161   BOOST_CHECK_EQUAL(Grid.maxPosition()[1], max2);
0162 
0163   // Test pos to index
0164   Grid2D::index_t index1 = {1, 1};
0165   Grid2D::index_t index2 = {1, 2};
0166   Grid2D::index_t index3 = {2, 3};
0167 
0168   Vector3 pos1 = {-0.2, -1, -1};
0169   Vector3 pos2 = {3.6, 0., -1.5};
0170   Vector3 pos3 = {-1, 0.3, 0.8};
0171 
0172   for (int i = 0; i < 2; i++) {
0173     BOOST_CHECK_EQUAL(
0174         Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(pos1))[i],
0175         index1[i]);
0176     BOOST_CHECK_EQUAL(
0177         Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(pos2))[i],
0178         index2[i]);
0179     BOOST_CHECK_EQUAL(
0180         Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(pos3))[i],
0181         index3[i]);
0182   }
0183 
0184   // Test material mapping
0185   std::vector<Vector3> vectPos1;
0186   vectPos1.push_back(pos1);
0187   std::vector<Vector3> vectPos2;
0188   vectPos2.push_back(pos2);
0189   std::vector<Vector3> vectPos3;
0190   vectPos3.push_back(pos3);
0191 
0192   std::vector<std::pair<MaterialSlab, std::vector<Vector3>>> matRecord;
0193   Material mat1 = Material::fromMolarDensity(1., 2., 3., 4., 5.);
0194   Material mat2 = Material::fromMolarDensity(6., 7., 8., 9., 10.);
0195   Material vacuum = Material::Vacuum();
0196 
0197   MaterialSlab matprop1(mat1, 1);
0198   MaterialSlab matprop2(mat2, 1);
0199 
0200   matRecord.clear();
0201   matRecord.push_back(std::make_pair(matprop1, vectPos1));
0202   matRecord.push_back(std::make_pair(matprop2, vectPos2));
0203 
0204   // Walk over each property
0205   for (const auto& rm : matRecord) {
0206     // Walk over each point associated with the properties
0207     for (const auto& point : rm.second) {
0208       // Search for fitting grid point and accumulate
0209       Grid2D::index_t index =
0210           Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(point));
0211       Grid.atLocalBins(index).accumulate(rm.first);
0212     }
0213   }
0214 
0215   MaterialGrid2D matMap = mapMaterialPoints(Grid);
0216 
0217   CHECK_CLOSE_REL(matMap.atLocalBins(index1), mat1.parameters(), 1e-4);
0218   CHECK_CLOSE_REL(matMap.atLocalBins(index2), mat2.parameters(), 1e-4);
0219   BOOST_CHECK_EQUAL(matMap.atLocalBins(index3), vacuum.parameters());
0220 }
0221 
0222 /// @brief Various test for the Material in the case of a Cuboid volume
0223 BOOST_AUTO_TEST_CASE(Cubic_Grid_test) {
0224   BinUtility bu(7, -3., 3., open, AxisDirection::AxisX);
0225   bu += BinUtility(3, -2., 2., open, AxisDirection::AxisY);
0226   bu += BinUtility(2, -1., 1., open, AxisDirection::AxisZ);
0227   auto bd = bu.binningData();
0228   std::function<Vector3(Vector3)> transfoGlobalToLocal;
0229 
0230   Grid3D Grid = createGrid3D(bu, transfoGlobalToLocal);
0231 
0232   // Test Global To Local transform
0233   Vector3 pos(1., 2., 3.);
0234   BOOST_CHECK_EQUAL(pos, transfoGlobalToLocal(pos));
0235 
0236   // Test Grid
0237   BOOST_CHECK_EQUAL(Grid.dimensions(), 3);
0238 
0239   BOOST_CHECK_EQUAL(Grid.numLocalBins()[0], bd[0].bins());
0240   BOOST_CHECK_EQUAL(Grid.numLocalBins()[1], bd[1].bins());
0241   BOOST_CHECK_EQUAL(Grid.numLocalBins()[2], bd[2].bins());
0242 
0243   BOOST_CHECK_EQUAL(Grid.minPosition()[0], bd[0].min);
0244   BOOST_CHECK_EQUAL(Grid.minPosition()[1], bd[1].min);
0245   BOOST_CHECK_EQUAL(Grid.minPosition()[2], bd[2].min);
0246 
0247   float max1 = bd[0].max + std::abs(bd[0].max - bd[0].min) / (bd[0].bins() - 1);
0248   float max2 = bd[1].max + std::abs(bd[1].max - bd[1].min) / (bd[1].bins() - 1);
0249   float max3 = bd[2].max + std::abs(bd[2].max - bd[2].min) / (bd[2].bins() - 1);
0250 
0251   BOOST_CHECK_EQUAL(Grid.maxPosition()[0], max1);
0252   BOOST_CHECK_EQUAL(Grid.maxPosition()[1], max2);
0253   BOOST_CHECK_EQUAL(Grid.maxPosition()[2], max3);
0254 
0255   // Test pos to index
0256   Grid3D::index_t index1 = {1, 1, 1};
0257   Grid3D::index_t index2 = {7, 2, 2};
0258   Grid3D::index_t index3 = {1, 3, 2};
0259 
0260   Vector3 pos1 = {-2.6, -1.5, -0.7};
0261   Vector3 pos2 = {2.8, 0, 0.2};
0262   Vector3 pos3 = {-2.7, 1.8, 0.8};
0263 
0264   for (int i = 0; i < 3; i++) {
0265     BOOST_CHECK_EQUAL(
0266         Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(pos1))[i],
0267         index1[i]);
0268     BOOST_CHECK_EQUAL(
0269         Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(pos2))[i],
0270         index2[i]);
0271     BOOST_CHECK_EQUAL(
0272         Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(pos3))[i],
0273         index3[i]);
0274   }
0275   // Test material mapping
0276   std::vector<Vector3> vectPos1;
0277   vectPos1.push_back(pos1);
0278   std::vector<Vector3> vectPos2;
0279   vectPos2.push_back(pos2);
0280   std::vector<Vector3> vectPos3;
0281   vectPos3.push_back(pos3);
0282 
0283   std::vector<std::pair<MaterialSlab, std::vector<Vector3>>> matRecord;
0284   Material mat1 = Material::fromMolarDensity(1., 2., 3., 4., 5.);
0285   Material mat2 = Material::fromMolarDensity(6., 7., 8., 9., 10.);
0286   Material vacuum = Material::Vacuum();
0287 
0288   MaterialSlab matprop1(mat1, 1);
0289   MaterialSlab matprop2(mat2, 1);
0290 
0291   matRecord.clear();
0292   matRecord.push_back(std::make_pair(matprop1, vectPos1));
0293   matRecord.push_back(std::make_pair(matprop2, vectPos2));
0294 
0295   // Walk over each property
0296   for (const auto& rm : matRecord) {
0297     // Walk over each point associated with the properties
0298     for (const auto& point : rm.second) {
0299       // Search for fitting grid point and accumulate
0300       Grid3D::index_t index =
0301           Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(point));
0302       Grid.atLocalBins(index).accumulate(rm.first);
0303     }
0304   }
0305 
0306   MaterialGrid3D matMap = mapMaterialPoints(Grid);
0307 
0308   CHECK_CLOSE_REL(matMap.atLocalBins(index1), mat1.parameters(), 1e-4);
0309   CHECK_CLOSE_REL(matMap.atLocalBins(index2), mat2.parameters(), 1e-4);
0310   BOOST_CHECK_EQUAL(matMap.atLocalBins(index3), vacuum.parameters());
0311 }
0312 
0313 /// @brief Various test for the Material in the case of a Cylindrical volume
0314 BOOST_AUTO_TEST_CASE(Cylindrical_Grid_test) {
0315   BinUtility bu(4, 1., 4., open, AxisDirection::AxisR);
0316   bu += BinUtility(3, -std::numbers::pi, std::numbers::pi, closed,
0317                    AxisDirection::AxisPhi);
0318   bu += BinUtility(2, -2., 2., open, AxisDirection::AxisZ);
0319   auto bd = bu.binningData();
0320   std::function<Vector3(Vector3)> transfoGlobalToLocal;
0321 
0322   Grid3D Grid = createGrid3D(bu, transfoGlobalToLocal);
0323 
0324   // Test Global To Local transform
0325   Vector3 pos(1., 2., 3.);
0326 
0327   CHECK_CLOSE_REL(transfoGlobalToLocal(pos)[0], sqrt(5), 1e-4);
0328   CHECK_CLOSE_REL(transfoGlobalToLocal(pos)[1], atan2(2, 1), 1e-4);
0329   CHECK_CLOSE_REL(transfoGlobalToLocal(pos)[2], 3, 1e-4);
0330 
0331   // Test Grid
0332   BOOST_CHECK_EQUAL(Grid.dimensions(), 3);
0333 
0334   BOOST_CHECK_EQUAL(Grid.numLocalBins()[0], bd[0].bins());
0335   BOOST_CHECK_EQUAL(Grid.numLocalBins()[1], bd[1].bins());
0336   BOOST_CHECK_EQUAL(Grid.numLocalBins()[2], bd[2].bins());
0337 
0338   BOOST_CHECK_EQUAL(Grid.minPosition()[0], bd[0].min);
0339   BOOST_CHECK_EQUAL(Grid.minPosition()[1], bd[1].min);
0340   BOOST_CHECK_EQUAL(Grid.minPosition()[2], bd[2].min);
0341 
0342   float max1 = bd[0].max + std::abs(bd[0].max - bd[0].min) / (bd[0].bins() - 1);
0343   float max2 = bd[1].max + std::abs(bd[1].max - bd[1].min) / (bd[1].bins() - 1);
0344   float max3 = bd[2].max + std::abs(bd[2].max - bd[2].min) / (bd[2].bins() - 1);
0345 
0346   BOOST_CHECK_EQUAL(Grid.maxPosition()[0], max1);
0347   BOOST_CHECK_EQUAL(Grid.maxPosition()[1], max2);
0348   BOOST_CHECK_EQUAL(Grid.maxPosition()[2], max3);
0349 
0350   // Test pos to index
0351   Grid3D::index_t index1 = {1, 1, 1};
0352   Grid3D::index_t index2 = {4, 2, 1};
0353   Grid3D::index_t index3 = {1, 3, 2};
0354 
0355   Vector3 pos1 = {-0.2, -1, -1};
0356   Vector3 pos2 = {3.6, 0., -1.5};
0357   Vector3 pos3 = {-1, 0.3, 0.8};
0358 
0359   for (int i = 0; i < 3; i++) {
0360     BOOST_CHECK_EQUAL(
0361         Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(pos1))[i],
0362         index1[i]);
0363     BOOST_CHECK_EQUAL(
0364         Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(pos2))[i],
0365         index2[i]);
0366     BOOST_CHECK_EQUAL(
0367         Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(pos3))[i],
0368         index3[i]);
0369   }
0370 
0371   // Test material mapping
0372   std::vector<Vector3> vectPos1;
0373   vectPos1.push_back(pos1);
0374   std::vector<Vector3> vectPos2;
0375   vectPos2.push_back(pos2);
0376   std::vector<Vector3> vectPos3;
0377   vectPos3.push_back(pos3);
0378 
0379   std::vector<std::pair<MaterialSlab, std::vector<Vector3>>> matRecord;
0380   Material mat1 = Material::fromMolarDensity(1., 2., 3., 4., 5.);
0381   Material mat2 = Material::fromMolarDensity(6., 7., 8., 9., 10.);
0382   Material vacuum = Material::Vacuum();
0383 
0384   MaterialSlab matprop1(mat1, 1);
0385   MaterialSlab matprop2(mat2, 1);
0386 
0387   matRecord.clear();
0388   matRecord.push_back(std::make_pair(matprop1, vectPos1));
0389   matRecord.push_back(std::make_pair(matprop2, vectPos2));
0390 
0391   // Walk over each property
0392   for (const auto& rm : matRecord) {
0393     // Walk over each point associated with the properties
0394     for (const auto& point : rm.second) {
0395       // Search for fitting grid point and accumulate
0396       Grid3D::index_t index =
0397           Grid.localBinsFromLowerLeftEdge(transfoGlobalToLocal(point));
0398       Grid.atLocalBins(index).accumulate(rm.first);
0399     }
0400   }
0401 
0402   MaterialGrid3D matMap = mapMaterialPoints(Grid);
0403 
0404   CHECK_CLOSE_REL(matMap.atLocalBins(index1), mat1.parameters(), 1e-4);
0405   CHECK_CLOSE_REL(matMap.atLocalBins(index2), mat2.parameters(), 1e-4);
0406   BOOST_CHECK_EQUAL(matMap.atLocalBins(index3), vacuum.parameters());
0407 }
0408 
0409 BOOST_AUTO_TEST_SUITE_END()
0410 
0411 }  // namespace ActsTests
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!