Back to home page

sPhenix code displayed by LXR
 
 

    

File indexing completed on 2025-08-06 08:11:23 

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2024 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 http://mozilla.org/MPL/2.0/.
0008 
0009 #include <boost/test/unit_test.hpp>
0010 
0011 #include "Acts/Material/GridSurfaceMaterial.hpp"
0012 #include "Acts/Material/Material.hpp"
0013 #include "Acts/Material/MaterialSlab.hpp"
0014 #include "Acts/Utilities/GridAxisGenerators.hpp"
0015 #include "Acts/Utilities/VectorHelpers.hpp"
0016 
0017 #include <vector>
0018 
0019 // this is a global access to the x coordinate
0020 class GlobalAccessX final : public Acts::GridAccess::IGlobalToGridLocal {
0021  public:
0022   std::array<Acts::ActsScalar, 1u> g2X(const Acts::Vector3& global) const {
0023     return {global.x()};
0024   }
0025 };
0026 
0027 class LocalAccessX final : public Acts::GridAccess::IBoundToGridLocal {
0028  public:
0029   std::array<Acts::ActsScalar, 1u> l2X(const Acts::Vector2& local) const {
0030     return {local.x()};
0031   }
0032 };
0033 
0034 class GlobalToZPhi final : public Acts::GridAccess::IGlobalToGridLocal {
0035  public:
0036   Acts::ActsScalar zShift = 0.;
0037 
0038   GlobalToZPhi(Acts::ActsScalar shift) : zShift(shift) {}
0039 
0040   std::array<Acts::ActsScalar, 2u> g2ZPhi(const Acts::Vector3& global) const {
0041     return {global.z() + zShift, Acts::VectorHelpers::phi(global)};
0042   }
0043 };
0044 
0045 // Local on cylinder surface is rPhi, z
0046 class LocalToZPhi final : public Acts::GridAccess::IBoundToGridLocal {
0047  public:
0048   Acts::ActsScalar radius = 1.;
0049 
0050   LocalToZPhi(Acts::ActsScalar r) : radius(r) {}
0051 
0052   std::array<Acts::ActsScalar, 2u> l2ZPhi(const Acts::Vector2& local) const {
0053     return {local[1u], local[0u] / radius};
0054   }
0055 };
0056 
0057 BOOST_AUTO_TEST_SUITE(Material)
0058 
0059 // This test covers some wrongly configured cases
0060 BOOST_AUTO_TEST_CASE(GridIndexedMaterial_invalid_bound2Grid_Unconnected) {
0061   std::vector<Acts::MaterialSlab> material;
0062 
0063   using EqBound = Acts::GridAxisGenerators::EqBound;
0064   using EqGrid = EqBound::grid_type<std::size_t>;
0065   using Point = EqGrid::point_t;
0066 
0067   EqBound eqBound{{0., 5.}, 5};
0068   EqGrid eqGrid{eqBound()};
0069 
0070   Acts::IndexedSurfaceMaterial<EqGrid>::BoundToGridLocalDelegate bToX;
0071 
0072   auto globalX = std::make_unique<const GlobalAccessX>();
0073   Acts::IndexedSurfaceMaterial<EqGrid>::GlobalToGridLocalDelegate gToX;
0074   gToX.connect<&GlobalAccessX::g2X>(std::move(globalX));
0075 
0076   BOOST_CHECK_THROW(
0077       auto ism = Acts::IndexedSurfaceMaterial<EqGrid>(
0078           std::move(eqGrid), Acts::IndexedMaterialAccessor{std::move(material)},
0079           std::move(bToX), std::move(gToX)),
0080       std::invalid_argument);
0081 }
0082 
0083 // This test covers some wrongly configured cases
0084 BOOST_AUTO_TEST_CASE(GridIndexedMaterial_invalid_global2Grid_Unconnected) {
0085   std::vector<Acts::MaterialSlab> material;
0086 
0087   using EqBound = Acts::GridAxisGenerators::EqBound;
0088   using EqGrid = EqBound::grid_type<std::size_t>;
0089   using Point = EqGrid::point_t;
0090 
0091   EqBound eqBound{{0., 5.}, 5};
0092   EqGrid eqGrid{eqBound()};
0093 
0094   auto localX = std::make_unique<const LocalAccessX>();
0095   Acts::IndexedSurfaceMaterial<EqGrid>::BoundToGridLocalDelegate bToX;
0096   bToX.connect<&LocalAccessX::l2X>(std::move(localX));
0097 
0098   Acts::IndexedSurfaceMaterial<EqGrid>::GlobalToGridLocalDelegate gToX;
0099 
0100   BOOST_CHECK_THROW(
0101       auto ism = Acts::IndexedSurfaceMaterial<EqGrid>(
0102           std::move(eqGrid), Acts::IndexedMaterialAccessor{std::move(material)},
0103           std::move(bToX), std::move(gToX)),
0104       std::invalid_argument);
0105 }
0106 
0107 // This test covers the locally indexed grid material in 1D
0108 BOOST_AUTO_TEST_CASE(GridIndexedMaterial1D) {
0109   std::vector<Acts::MaterialSlab> material;
0110   material.emplace_back(Acts::Material(), 0.0);  // vacuum
0111   material.emplace_back(
0112       Acts::Material::fromMolarDensity(1.0, 2.0, 3.0, 4.0, 5.0), 1.0);
0113   material.emplace_back(
0114       Acts::Material::fromMolarDensity(11.0, 12.0, 13.0, 14.0, 15.0), 2.0);
0115   material.emplace_back(
0116       Acts::Material::fromMolarDensity(21.0, 22.0, 23.0, 24.0, 25.0), 3.0);
0117 
0118   using EqBound = Acts::GridAxisGenerators::EqBound;
0119   using EqGrid = EqBound::grid_type<std::size_t>;
0120   using Point = EqGrid::point_t;
0121 
0122   EqBound eqBound{{0., 5.}, 5};
0123   EqGrid eqGrid{eqBound()};
0124 
0125   eqGrid.atPosition(Point{0.5}) = 1u;  // material 1
0126   eqGrid.atPosition(Point{1.5}) = 0u;  // vacuum
0127   eqGrid.atPosition(Point{2.5}) = 2u;  // material 2
0128   eqGrid.atPosition(Point{3.5}) = 2u;  // material 2
0129   eqGrid.atPosition(Point{4.5}) = 3u;  // material 3
0130 
0131   auto localX = std::make_unique<const LocalAccessX>();
0132   Acts::IndexedSurfaceMaterial<EqGrid>::BoundToGridLocalDelegate bToX;
0133   bToX.connect<&LocalAccessX::l2X>(std::move(localX));
0134 
0135   auto globalX = std::make_unique<const GlobalAccessX>();
0136   Acts::IndexedSurfaceMaterial<EqGrid>::GlobalToGridLocalDelegate gToX;
0137   gToX.connect<&GlobalAccessX::g2X>(std::move(globalX));
0138 
0139   Acts::IndexedSurfaceMaterial<EqGrid> ism(
0140       std::move(eqGrid), Acts::IndexedMaterialAccessor{std::move(material)},
0141       std::move(bToX), std::move(gToX));
0142 
0143   // Global access test
0144   Acts::Vector3 g0(0.5, 0., 0.);
0145   Acts::Vector3 g1(1.5, 0., 0.);
0146   Acts::Vector3 g2(2.5, 0., 0.);
0147   Acts::Vector3 g3(3.5, 0., 0.);
0148   Acts::Vector3 g4(4.5, 0., 0.);
0149 
0150   const Acts::MaterialSlab& mg0 = ism.materialSlab(g0);
0151   const Acts::MaterialSlab& mg1 = ism.materialSlab(g1);
0152   const Acts::MaterialSlab& mg2 = ism.materialSlab(g2);
0153   const Acts::MaterialSlab& mg3 = ism.materialSlab(g3);
0154   const Acts::MaterialSlab& mg4 = ism.materialSlab(g4);
0155 
0156   BOOST_CHECK_EQUAL(mg0.material().X0(), 1.);
0157   BOOST_CHECK(!mg1.material());
0158   BOOST_CHECK_EQUAL(mg2.material().X0(), 11.);
0159   BOOST_CHECK_EQUAL(mg3.material().X0(), 11.);
0160   BOOST_CHECK_EQUAL(mg4.material().X0(), 21.);
0161 
0162   // Local access test
0163   Acts::Vector2 l0(0.5, 0.);
0164   Acts::Vector2 l1(1.5, 0.);
0165   Acts::Vector2 l2(2.5, 0.);
0166   Acts::Vector2 l3(3.5, 0.);
0167   Acts::Vector2 l4(4.5, 0.);
0168 
0169   const Acts::MaterialSlab& ml0 = ism.materialSlab(l0);
0170   const Acts::MaterialSlab& ml1 = ism.materialSlab(l1);
0171   const Acts::MaterialSlab& ml2 = ism.materialSlab(l2);
0172   const Acts::MaterialSlab& ml3 = ism.materialSlab(l3);
0173   const Acts::MaterialSlab& ml4 = ism.materialSlab(l4);
0174 
0175   BOOST_CHECK_EQUAL(ml0.material().X0(), 1.);
0176   BOOST_CHECK(!ml1.material());
0177   BOOST_CHECK_EQUAL(ml2.material().X0(), 11.);
0178   BOOST_CHECK_EQUAL(ml3.material().X0(), 11.);
0179   BOOST_CHECK_EQUAL(ml4.material().X0(), 21.);
0180 
0181   // Now scale it - and access again
0182   ism *= 2.;
0183   const Acts::MaterialSlab& sml0 = ism.materialSlab(l0);
0184   const Acts::MaterialSlab& sml1 = ism.materialSlab(l1);
0185   const Acts::MaterialSlab& sml2 = ism.materialSlab(l2);
0186   const Acts::MaterialSlab& sml3 = ism.materialSlab(l3);
0187   const Acts::MaterialSlab& sml4 = ism.materialSlab(l4);
0188 
0189   BOOST_CHECK_EQUAL(sml0.thickness(), 2.);
0190   BOOST_CHECK(!sml1.material());
0191   BOOST_CHECK_EQUAL(sml2.thickness(), 4.);
0192   BOOST_CHECK_EQUAL(sml3.thickness(), 4.);
0193   BOOST_CHECK_EQUAL(sml4.thickness(), 6.);
0194 }
0195 
0196 // This test covers the locally indexed grid material in 2D
0197 BOOST_AUTO_TEST_CASE(GridIndexedMaterial2D) {
0198   std::vector<Acts::MaterialSlab> material;
0199   material.emplace_back(Acts::Material(), 1.0);  // vacuum
0200   material.emplace_back(
0201       Acts::Material::fromMolarDensity(1.0, 2.0, 3.0, 4.0, 5.0), 1.0);
0202   material.emplace_back(
0203       Acts::Material::fromMolarDensity(11.0, 12.0, 13.0, 14.0, 15.0), 1.0);
0204   material.emplace_back(
0205       Acts::Material::fromMolarDensity(21.0, 22.0, 23.0, 24.0, 25.0), 1.0);
0206 
0207   using EqBoundEqClosed = Acts::GridAxisGenerators::EqBoundEqClosed;
0208   using EqEqGrid = EqBoundEqClosed::grid_type<std::size_t>;
0209   using Point = EqEqGrid::point_t;
0210 
0211   EqBoundEqClosed eqeqBound{{-1., 1.}, 2, {-M_PI, M_PI}, 4};
0212   EqEqGrid eqeqGrid{eqeqBound()};
0213 
0214   eqeqGrid.atPosition(Point{-0.5, -M_PI * 0.75}) = 1u;  // material 1
0215   eqeqGrid.atPosition(Point{-0.5, -M_PI * 0.25}) = 1u;  // material 1
0216   eqeqGrid.atPosition(Point{-0.5, M_PI * 0.25}) = 0u;   // vacuum
0217   eqeqGrid.atPosition(Point{-0.5, M_PI * 0.75}) = 2u;   // material 2
0218 
0219   eqeqGrid.atPosition(Point{0.5, -M_PI * 0.75}) = 0u;  // vacuum
0220   eqeqGrid.atPosition(Point{0.5, -M_PI * 0.25}) = 3u;  // material 3
0221   eqeqGrid.atPosition(Point{0.5, M_PI * 0.25}) = 3u;   // material 3
0222   eqeqGrid.atPosition(Point{0.5, M_PI * 0.75}) = 0u;   // vacuum
0223 
0224   // With radius 20
0225   auto boundToGrid = std::make_unique<const LocalToZPhi>(20.);
0226   Acts::IndexedSurfaceMaterial<EqEqGrid>::BoundToGridLocalDelegate bToZPhi;
0227   bToZPhi.connect<&LocalToZPhi::l2ZPhi>(std::move(boundToGrid));
0228 
0229   // With z shift 10
0230   auto globalToGrid = std::make_unique<const GlobalToZPhi>(10.);
0231   Acts::IndexedSurfaceMaterial<EqEqGrid>::GlobalToGridLocalDelegate gToZphi;
0232   gToZphi.connect<&GlobalToZPhi::g2ZPhi>(std::move(globalToGrid));
0233 
0234   // Create the indexed material grid
0235   Acts::IndexedSurfaceMaterial<EqEqGrid> ism(
0236       std::move(eqeqGrid), Acts::IndexedMaterialAccessor{std::move(material)},
0237       std::move(bToZPhi), std::move(gToZphi));
0238 
0239   // Global access test, both should give material 1
0240   Acts::Vector3 g0(-0.5, -0.5, -10.5);
0241   const Acts::MaterialSlab& mg0 = ism.materialSlab(g0);
0242   BOOST_CHECK_EQUAL(mg0.material().X0(), 1.);
0243 
0244   Acts::Vector3 g1(0.5, -0.5, -11.5);  // checking out of bound access
0245   const Acts::MaterialSlab& mg1 = ism.materialSlab(g1);
0246   BOOST_CHECK_EQUAL(mg1.material().X0(), 1.);
0247 
0248   Acts::Vector3 g2(0.5, 0.5, -10.5);
0249   const Acts::MaterialSlab& mg2 = ism.materialSlab(g2);
0250   BOOST_CHECK(!mg2.material());  // vacuum
0251 
0252   Acts::Vector3 g3(0.5, 0.5,
0253                    -9.5);  // should be material 3, same phi but different z
0254   const Acts::MaterialSlab& mg3 = ism.materialSlab(g3);
0255   BOOST_CHECK_EQUAL(mg3.material().X0(), 21.);
0256 }
0257 
0258 // This test covers the globally indexed grid material with non-shared material
0259 BOOST_AUTO_TEST_CASE(GridGloballyIndexedMaterialNonShared) {
0260   auto material = std::make_shared<std::vector<Acts::MaterialSlab>>();
0261 
0262   material->emplace_back(Acts::Material(), 0.0);  // vacuum
0263   material->emplace_back(
0264       Acts::Material::fromMolarDensity(1.0, 2.0, 3.0, 4.0, 5.0), 1.0);
0265   material->emplace_back(
0266       Acts::Material::fromMolarDensity(11.0, 12.0, 13.0, 14.0, 15.0), 2.0);
0267   material->emplace_back(
0268       Acts::Material::fromMolarDensity(21.0, 22.0, 23.0, 24.0, 25.0), 3.0);
0269   material->emplace_back(
0270       Acts::Material::fromMolarDensity(31.0, 22.0, 23.0, 24.0, 25.0), 4.0);
0271 
0272   using EqBound = Acts::GridAxisGenerators::EqBound;
0273   using EqGrid = EqBound::grid_type<std::size_t>;
0274   using Point = EqGrid::point_t;
0275 
0276   EqBound eqBound{{0., 5.}, 5};
0277   EqGrid eqGrid{eqBound()};
0278 
0279   eqGrid.atPosition(Point{0.5}) = 1u;  // material 1
0280   eqGrid.atPosition(Point{1.5}) = 0u;  // vacuum
0281   eqGrid.atPosition(Point{2.5}) = 2u;  // material 2
0282   eqGrid.atPosition(Point{3.5}) = 2u;  // material 2
0283   eqGrid.atPosition(Point{4.5}) = 3u;  // material 3
0284 
0285   auto localX = std::make_unique<const LocalAccessX>();
0286   Acts::IndexedSurfaceMaterial<EqGrid>::BoundToGridLocalDelegate bToX;
0287   bToX.connect<&LocalAccessX::l2X>(std::move(localX));
0288 
0289   auto globalX = std::make_unique<const GlobalAccessX>();
0290   Acts::IndexedSurfaceMaterial<EqGrid>::GlobalToGridLocalDelegate gToX;
0291   gToX.connect<&GlobalAccessX::g2X>(std::move(globalX));
0292 
0293   Acts::GloballyIndexedSurfaceMaterial<EqGrid> ism(
0294       std::move(eqGrid), Acts::GloballyIndexedMaterialAccessor{material, false},
0295       std::move(bToX), std::move(gToX));
0296 
0297   // Local access test
0298   Acts::Vector2 l0(0.5, 0.);
0299   Acts::Vector2 l1(1.5, 0.);
0300   Acts::Vector2 l2(2.5, 0.);
0301   Acts::Vector2 l3(3.5, 0.);
0302   Acts::Vector2 l4(4.5, 0.);
0303 
0304   const Acts::MaterialSlab& ml0 = ism.materialSlab(l0);
0305   const Acts::MaterialSlab& ml1 = ism.materialSlab(l1);
0306   const Acts::MaterialSlab& ml2 = ism.materialSlab(l2);
0307   const Acts::MaterialSlab& ml3 = ism.materialSlab(l3);
0308   const Acts::MaterialSlab& ml4 = ism.materialSlab(l4);
0309 
0310   BOOST_CHECK_EQUAL(ml0.material().X0(), 1.);
0311   BOOST_CHECK(!ml1.material());
0312   BOOST_CHECK_EQUAL(ml2.material().X0(), 11.);
0313   BOOST_CHECK_EQUAL(ml3.material().X0(), 11.);
0314   BOOST_CHECK_EQUAL(ml4.material().X0(), 21.);
0315 
0316   EqBound eqBound1{{0., 5.}, 1};
0317   EqGrid eqGrid1{eqBound1()};
0318 
0319   auto localX1 = std::make_unique<const LocalAccessX>();
0320   Acts::IndexedSurfaceMaterial<EqGrid>::BoundToGridLocalDelegate bToX1;
0321   bToX1.connect<&LocalAccessX::l2X>(std::move(localX1));
0322 
0323   auto globalX1 = std::make_unique<const GlobalAccessX>();
0324   Acts::IndexedSurfaceMaterial<EqGrid>::GlobalToGridLocalDelegate gToX1;
0325   gToX1.connect<&GlobalAccessX::g2X>(std::move(globalX1));
0326 
0327   eqGrid1.atPosition(Point{2.5}) = 4u;  // material 4
0328 
0329   Acts::GloballyIndexedSurfaceMaterial<EqGrid> ism1(
0330       std::move(eqGrid1),
0331       Acts::GloballyIndexedMaterialAccessor{material, false}, std::move(bToX1),
0332       std::move(gToX1));
0333 
0334   Acts::Vector2 l0g1(2.5, 0.);
0335   const Acts::MaterialSlab& ml0g1 = ism1.materialSlab(l0g1);
0336   BOOST_CHECK_EQUAL(ml0g1.material().X0(), 31.);
0337 
0338   // Scale
0339   ism1 *= 2.;
0340   const Acts::MaterialSlab& sml0g1 = ism1.materialSlab(l0g1);
0341   BOOST_CHECK_EQUAL(sml0g1.thickness(), 8.);
0342 
0343   // First one stays unscaled
0344   const Acts::MaterialSlab& sml0 = ism.materialSlab(l0);
0345   BOOST_CHECK_EQUAL(sml0.thickness(), 1.);
0346 }
0347 
0348 // This test covers the globally indexed grid material with shared
0349 BOOST_AUTO_TEST_CASE(GridGloballyIndexedMaterialShared) {
0350   auto material = std::make_shared<std::vector<Acts::MaterialSlab>>();
0351 
0352   material->emplace_back(Acts::Material(), 0.0);  // vacuum
0353   material->emplace_back(
0354       Acts::Material::fromMolarDensity(1.0, 2.0, 3.0, 4.0, 5.0), 1.0);
0355 
0356   using EqBound = Acts::GridAxisGenerators::EqBound;
0357   using EqGrid = EqBound::grid_type<std::size_t>;
0358   using Point = EqGrid::point_t;
0359 
0360   EqBound eqBound0{{0., 5.}, 1};
0361   EqGrid eqGrid0{eqBound0()};
0362 
0363   eqGrid0.atPosition(Point{2.5}) = 1u;  // material 1
0364   auto localX0 = std::make_unique<const LocalAccessX>();
0365   Acts::IndexedSurfaceMaterial<EqGrid>::BoundToGridLocalDelegate bToX0;
0366   bToX0.connect<&LocalAccessX::l2X>(std::move(localX0));
0367 
0368   auto globalX0 = std::make_unique<const GlobalAccessX>();
0369   Acts::IndexedSurfaceMaterial<EqGrid>::GlobalToGridLocalDelegate gToX0;
0370   gToX0.connect<&GlobalAccessX::g2X>(std::move(globalX0));
0371 
0372   Acts::GloballyIndexedSurfaceMaterial<EqGrid> ism0(
0373       std::move(eqGrid0), Acts::GloballyIndexedMaterialAccessor{material, true},
0374       std::move(bToX0), std::move(gToX0));
0375 
0376   EqBound eqBound1{{0., 5.}, 1};
0377   EqGrid eqGrid1{eqBound1()};
0378 
0379   eqGrid1.atPosition(Point{2.5}) = 1u;  // material 1
0380   auto localX1 = std::make_unique<const LocalAccessX>();
0381   Acts::IndexedSurfaceMaterial<EqGrid>::BoundToGridLocalDelegate bToX1;
0382   bToX1.connect<&LocalAccessX::l2X>(std::move(localX1));
0383 
0384   auto globalX1 = std::make_unique<const GlobalAccessX>();
0385   Acts::IndexedSurfaceMaterial<EqGrid>::GlobalToGridLocalDelegate gToX1;
0386   gToX1.connect<&GlobalAccessX::g2X>(std::move(globalX1));
0387 
0388   Acts::GloballyIndexedSurfaceMaterial<EqGrid> ism1(
0389       std::move(eqGrid1), Acts::GloballyIndexedMaterialAccessor{material, true},
0390       std::move(bToX1), std::move(gToX1));
0391 
0392   Acts::Vector2 l0(2.5, 0.);
0393 
0394   // check grid material 0
0395   const Acts::MaterialSlab& ml0 = ism0.materialSlab(l0);
0396   BOOST_CHECK_EQUAL(ml0.material().X0(), 1.);
0397 
0398   const Acts::MaterialSlab& ml0g1 = ism1.materialSlab(l0);
0399   BOOST_CHECK_EQUAL(ml0g1.material().X0(), 1.);
0400 
0401   // scaling shared material should throw a std::invalid_argument
0402   BOOST_CHECK_THROW(ism1 *= 2., std::invalid_argument);
0403 }
0404 
0405 // This test covers the grid material (non-indexed accessor)
0406 //
0407 // In this setup, the material is not indexed, but filled directly
0408 // into the grid structure.
0409 BOOST_AUTO_TEST_CASE(GridSurfaceMaterialTests) {
0410   using EqBound = Acts::GridAxisGenerators::EqBound;
0411   using EqGrid = EqBound::grid_type<Acts::MaterialSlab>;
0412   using Point = EqGrid::point_t;
0413 
0414   EqBound eqBound{{0., 5.}, 5};
0415   EqGrid eqGrid{eqBound()};
0416 
0417   eqGrid.atPosition(Point{0.5}) = Acts::MaterialSlab(Acts::Material(), 0.0);
0418   eqGrid.atPosition(Point{1.5}) = Acts::MaterialSlab(Acts::Material(), 1.0);
0419   eqGrid.atPosition(Point{2.5}) = Acts::MaterialSlab(Acts::Material(), 2.0);
0420   eqGrid.atPosition(Point{3.5}) = Acts::MaterialSlab(Acts::Material(), 3.0);
0421   eqGrid.atPosition(Point{4.5}) = Acts::MaterialSlab(Acts::Material(), 4.0);
0422 
0423   auto localX = std::make_unique<const LocalAccessX>();
0424   Acts::IndexedSurfaceMaterial<EqGrid>::BoundToGridLocalDelegate bToX;
0425   bToX.connect<&LocalAccessX::l2X>(std::move(localX));
0426 
0427   auto globalX = std::make_unique<const GlobalAccessX>();
0428   Acts::IndexedSurfaceMaterial<EqGrid>::GlobalToGridLocalDelegate gToX;
0429   gToX.connect<&GlobalAccessX::g2X>(std::move(globalX));
0430 
0431   Acts::GridSurfaceMaterial<EqGrid> gsm(std::move(eqGrid),
0432                                         Acts::GridMaterialAccessor{},
0433                                         std::move(bToX), std::move(gToX));
0434 
0435   // Global access test
0436   Acts::Vector3 g0(0.5, 0., 0.);
0437   Acts::Vector3 g1(1.5, 0., 0.);
0438   Acts::Vector3 g2(2.5, 0., 0.);
0439   Acts::Vector3 g3(3.5, 0., 0.);
0440   Acts::Vector3 g4(4.5, 0., 0.);
0441 
0442   const Acts::MaterialSlab& mg0 = gsm.materialSlab(g0);
0443   const Acts::MaterialSlab& mg1 = gsm.materialSlab(g1);
0444   const Acts::MaterialSlab& mg2 = gsm.materialSlab(g2);
0445   const Acts::MaterialSlab& mg3 = gsm.materialSlab(g3);
0446   const Acts::MaterialSlab& mg4 = gsm.materialSlab(g4);
0447 
0448   BOOST_CHECK_EQUAL(mg0.thickness(), 0.);
0449   BOOST_CHECK_EQUAL(mg1.thickness(), 1.);
0450   BOOST_CHECK_EQUAL(mg2.thickness(), 2.);
0451   BOOST_CHECK_EQUAL(mg3.thickness(), 3.);
0452   BOOST_CHECK_EQUAL(mg4.thickness(), 4.);
0453 
0454   // Local access test
0455   Acts::Vector2 l0(0.5, 0.);
0456   Acts::Vector2 l1(1.5, 0.);
0457   Acts::Vector2 l2(2.5, 0.);
0458   Acts::Vector2 l3(3.5, 0.);
0459   Acts::Vector2 l4(4.5, 0.);
0460 
0461   const Acts::MaterialSlab& ml0 = gsm.materialSlab(l0);
0462   const Acts::MaterialSlab& ml1 = gsm.materialSlab(l1);
0463   const Acts::MaterialSlab& ml2 = gsm.materialSlab(l2);
0464   const Acts::MaterialSlab& ml3 = gsm.materialSlab(l3);
0465   const Acts::MaterialSlab& ml4 = gsm.materialSlab(l4);
0466 
0467   BOOST_CHECK_EQUAL(ml0.thickness(), 0.);
0468   BOOST_CHECK_EQUAL(ml1.thickness(), 1.);
0469   BOOST_CHECK_EQUAL(ml2.thickness(), 2.);
0470   BOOST_CHECK_EQUAL(ml3.thickness(), 3.);
0471   BOOST_CHECK_EQUAL(ml4.thickness(), 4.);
0472 
0473   // Now scale it - and access again
0474   gsm *= 2.;
0475 
0476   const Acts::MaterialSlab& sml0 = gsm.materialSlab(l0);
0477   const Acts::MaterialSlab& sml1 = gsm.materialSlab(l1);
0478   const Acts::MaterialSlab& sml2 = gsm.materialSlab(l2);
0479   const Acts::MaterialSlab& sml3 = gsm.materialSlab(l3);
0480   const Acts::MaterialSlab& sml4 = gsm.materialSlab(l4);
0481 
0482   BOOST_CHECK_EQUAL(sml0.thickness(), 0.);
0483   BOOST_CHECK_EQUAL(sml1.thickness(), 2.);
0484   BOOST_CHECK_EQUAL(sml2.thickness(), 4.);
0485   BOOST_CHECK_EQUAL(sml3.thickness(), 6.);
0486   BOOST_CHECK_EQUAL(sml4.thickness(), 8.);
0487 }
0488 
0489 BOOST_AUTO_TEST_SUITE_END()
[ 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!