Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-12-16 09:25:32 

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/Geometry/CylinderVolumeBounds.hpp"
0012 #include "Acts/Geometry/TrackingVolume.hpp"
0013 #include "Acts/Material/BinnedSurfaceMaterial.hpp"
0014 #include "Acts/Material/HomogeneousSurfaceMaterial.hpp"
0015 #include "Acts/Surfaces/PlaneSurface.hpp"
0016 #include "Acts/Surfaces/RectangleBounds.hpp"
0017 #include "Acts/Surfaces/Surface.hpp"
0018 #include "Acts/Utilities/Logger.hpp"
0019 #include "ActsPlugins/Detray/DetrayPayloadConverter.hpp"
0020 #include "ActsTests/CommonHelpers/FloatComparisons.hpp"
0021 
0022 #include <detray/io/frontend/payloads.hpp>
0023 
0024 auto logger = Acts::getDefaultLogger("Test", Acts::Logging::INFO);
0025 
0026 using namespace Acts;
0027 using namespace ActsPlugins;
0028 
0029 namespace ActsTests {
0030 
0031 BOOST_AUTO_TEST_SUITE(DetrayMaterialConversion)
0032 
0033 // These tests check the conversion to the payload objects, the full test
0034 auto materialSlab12345 =
0035     Acts::MaterialSlab(Acts::Material::fromMolarDensity(1, 2, 3, 4, 5), 1.);
0036 
0037 auto materialSlab678910 =
0038     Acts::MaterialSlab(Acts::Material::fromMolarDensity(6, 7, 8, 9, 10), 2.);
0039 
0040 auto materialSlab54321 =
0041     Acts::MaterialSlab(Acts::Material::fromMolarDensity(5, 4, 3, 2, 1), 3.);
0042 
0043 auto materialSlab109876 =
0044     Acts::MaterialSlab(Acts::Material::fromMolarDensity(10, 9, 8, 7, 6), 4.);
0045 
0046 // We can only test material slabs via the homogeneous material conversion
0047 // because we don't (want to) export the material slab conversion in core
0048 BOOST_AUTO_TEST_CASE(MaterialSlabTest) {
0049   auto logger = Acts::getDefaultLogger("DetrayMaterialConverterTests",
0050                                        Acts::Logging::INFO);
0051 
0052   HomogeneousSurfaceMaterial slab(materialSlab12345);
0053   auto detrayMaterial =
0054       DetrayPayloadConverter::convertHomogeneousSurfaceMaterial(slab);
0055 
0056   // Convert the material slab
0057   detray::io::material_slab_payload payload =
0058       std::get<detray::io::material_slab_payload>(*detrayMaterial);
0059 
0060   // Material type should be set to slab
0061   BOOST_CHECK(payload.type ==
0062               detray::io::material_slab_payload::mat_type::slab);
0063   // Thickness should be set to one
0064   CHECK_CLOSE_ABS(payload.thickness, 1.,
0065                   std::numeric_limits<double>::epsilon());
0066   // Index in collection not set at this simple conversion
0067   BOOST_CHECK(!payload.index_in_coll.has_value());
0068   // Material parameters in detray are (x0, l0, ar, z, mass_density,
0069   // molar_density, solid/liquid/etc. flag ... ignored currently)
0070   CHECK_CLOSE_ABS(payload.mat.params.at(0u), 1.,
0071                   std::numeric_limits<double>::epsilon());
0072   CHECK_CLOSE_ABS(payload.mat.params.at(1u), 2.,
0073                   std::numeric_limits<double>::epsilon());
0074   CHECK_CLOSE_ABS(payload.mat.params.at(2u), 3.,
0075                   std::numeric_limits<double>::epsilon());
0076   CHECK_CLOSE_ABS(payload.mat.params.at(3u), 4.,
0077                   std::numeric_limits<double>::epsilon());
0078   BOOST_CHECK_NE(payload.mat.params.at(4u), payload.mat.params.at(5u));
0079   CHECK_CLOSE_ABS(payload.mat.params.at(5u), 5.,
0080                   std::numeric_limits<double>::epsilon());
0081   CHECK_CLOSE_ABS(payload.mat.params.at(6u), 0.,
0082                   std::numeric_limits<double>::epsilon());
0083 }
0084 
0085 BOOST_AUTO_TEST_CASE(HomogeneousMaterialTest) {
0086   GeometryContext gctx;
0087 
0088   // Create a transform
0089   Transform3 transform = Transform3::Identity();
0090   transform.pretranslate(Vector3(1., 2., 3.));
0091 
0092   // Create a volume with some surfaces that have material
0093   auto cvlBounds = std::make_shared<CylinderVolumeBounds>(5., 10., 10.);
0094   auto volume =
0095       std::make_shared<TrackingVolume>(transform, cvlBounds, "TestVolume");
0096 
0097   // Create a surface with material
0098   auto bounds = std::make_shared<RectangleBounds>(5., 10.);
0099   auto surface = Surface::makeShared<PlaneSurface>(transform, bounds);
0100 
0101   // Create material
0102   Material mat = Material::fromMassDensity(1.0, 2.0, 3.0, 4.0, 5.0);
0103   MaterialSlab slab(mat, 1.5);  // thickness of 1.5
0104   auto surfaceMaterial = std::make_shared<HomogeneousSurfaceMaterial>(slab);
0105   surface->assignSurfaceMaterial(surfaceMaterial);
0106 
0107   // Add surface to volume
0108   volume->addSurface(surface);
0109 
0110   // Convert material
0111 
0112   auto detrayMaterial =
0113       *DetrayPayloadConverter::convertHomogeneousSurfaceMaterial(
0114           *surfaceMaterial);
0115 
0116   auto* slabPayload =
0117       std::get_if<detray::io::material_slab_payload>(&detrayMaterial);
0118   BOOST_REQUIRE_NE(slabPayload, nullptr);
0119 
0120   // Check material parameters
0121   CHECK_CLOSE_ABS(slabPayload->mat.params.at(0u), mat.X0(), 1e-10);  // X0
0122   CHECK_CLOSE_ABS(slabPayload->mat.params.at(1u), mat.L0(), 1e-10);  // L0
0123   CHECK_CLOSE_ABS(slabPayload->mat.params.at(2u), mat.Ar(), 1e-10);  // Ar
0124   CHECK_CLOSE_ABS(slabPayload->mat.params.at(3u), mat.Z(), 1e-10);   // Z
0125   CHECK_CLOSE_ABS(slabPayload->mat.params.at(4u), mat.massDensity(),
0126                   1e-10);  // mass density
0127   CHECK_CLOSE_ABS(slabPayload->mat.params.at(5u), mat.molarDensity(),
0128                   1e-10);  // molar density
0129   CHECK_CLOSE_ABS(slabPayload->thickness, slab.thickness(),
0130                   1e-10);  // thickness
0131 
0132   // These will not be set by the conversion, the material doesn't know which
0133   // surface it's on
0134   BOOST_CHECK_EQUAL(slabPayload->surface.link,
0135                     std::numeric_limits<std::size_t>::max());
0136   BOOST_CHECK(!slabPayload->index_in_coll.has_value());
0137 }
0138 
0139 detray::io::grid_payload<detray::io::material_slab_payload,
0140                          detray::io::material_id>
0141 unpackGrid(const DetrayPayloadConverter::DetraySurfaceMaterial& material) {
0142   if (auto* grid = std::get_if<detray::io::grid_payload<
0143           detray::io::material_slab_payload, detray::io::material_id>>(
0144           &material)) {
0145     return *grid;
0146   }
0147   BOOST_FAIL("Not a grid payload");
0148   return {};
0149 }
0150 
0151 BOOST_AUTO_TEST_CASE(DetrayBinnedMaterialConversionX) {
0152   // Create a binned material in 4 bins in x direction
0153   Acts::BinUtility binUtility(4u, -2., 2., Acts::BinningOption::open,
0154                               Acts::AxisDirection::AxisX);
0155 
0156   std::vector<Acts::MaterialSlab> materialSlabs = {
0157       materialSlab12345, materialSlab678910, materialSlab54321,
0158       materialSlab109876};
0159 
0160   auto binnedMaterial = Acts::BinnedSurfaceMaterial(
0161       binUtility, {materialSlabs}, 0., Acts::MappingType::Default);
0162 
0163   detray::io::grid_payload<detray::io::material_slab_payload,
0164                            detray::io::material_id>
0165       payload =
0166           unpackGrid(*DetrayPayloadConverter::convertBinnedSurfaceMaterial(
0167               binnedMaterial));
0168 
0169   // Check the payload
0170   // - we fake 2D always for detray to minimize the number of containers
0171   // - four material payloads in the grid
0172   BOOST_CHECK_EQUAL(payload.axes.size(), 2u);
0173   BOOST_CHECK_EQUAL(payload.bins.size(), 4u);
0174   BOOST_CHECK(!payload.transform.has_value());
0175   BOOST_CHECK(payload.grid_link.type ==
0176               detray::io::material_id::rectangle2_map);
0177   // x-axis
0178   BOOST_CHECK(payload.axes.at(0u).label == detray::axis::label::e_x);
0179   BOOST_CHECK_EQUAL(payload.axes.at(0u).bins, 4u);
0180   CHECK_CLOSE_ABS(payload.axes.at(0u).edges.at(0u), -2.,
0181                   std::numeric_limits<double>::epsilon());
0182   CHECK_CLOSE_ABS(payload.axes.at(0u).edges.at(1u), 2.,
0183                   std::numeric_limits<double>::epsilon());
0184   BOOST_CHECK(payload.axes.at(0u).binning == detray::axis::binning::e_regular);
0185   BOOST_CHECK(payload.axes.at(0u).bounds == detray::axis::bounds::e_closed);
0186   // axis is dummy
0187   BOOST_CHECK(payload.axes.at(1u).label == detray::axis::label::e_y);
0188   BOOST_CHECK_EQUAL(payload.axes.at(1u).bins, 1u);
0189 
0190   // Check the local indices
0191   BOOST_CHECK_EQUAL(payload.bins.at(0u).loc_index.size(), 2u);
0192 
0193   // Bins should be : [0,0], [1,0], [2,0], [3,0]
0194   //
0195   // [0,0] - materialSlab12345
0196   BOOST_CHECK_EQUAL(payload.bins.at(0u).loc_index.at(0), 0u);
0197   BOOST_CHECK_EQUAL(payload.bins.at(0u).loc_index.at(1), 0u);
0198   BOOST_CHECK_EQUAL(payload.bins.at(0u).content.at(0u).mat.params.at(0u), 1.);
0199   // [1,0] - materialSlab678910
0200   BOOST_CHECK_EQUAL(payload.bins.at(1u).loc_index.at(0), 1u);
0201   BOOST_CHECK_EQUAL(payload.bins.at(1u).loc_index.at(1), 0u);
0202   BOOST_CHECK_EQUAL(payload.bins.at(1u).content.at(0u).mat.params.at(0u), 6.);
0203   // [2,0] - materialSlab54321
0204   BOOST_CHECK_EQUAL(payload.bins.at(2u).loc_index.at(0), 2u);
0205   BOOST_CHECK_EQUAL(payload.bins.at(2u).loc_index.at(1), 0u);
0206   BOOST_CHECK_EQUAL(payload.bins.at(2u).content.at(0u).mat.params.at(0u), 5.);
0207   // [3,0] - materialSlab109876
0208   BOOST_CHECK_EQUAL(payload.bins.at(3u).loc_index.at(0), 3u);
0209   BOOST_CHECK_EQUAL(payload.bins.at(3u).loc_index.at(1), 0u);
0210   BOOST_CHECK_EQUAL(payload.bins.at(3u).content.at(0u).mat.params.at(0u), 10.);
0211 }
0212 
0213 BOOST_AUTO_TEST_CASE(DetrayBinnedMaterialConversionY) {
0214   // Create a binned material in 4 bins in y direction
0215   Acts::BinUtility binUtility(4u, -2., 2., Acts::BinningOption::open,
0216                               Acts::AxisDirection::AxisY);
0217 
0218   std::vector<Acts::MaterialSlab> materialSlabs = {
0219       materialSlab12345, materialSlab678910, materialSlab54321,
0220       materialSlab109876};
0221 
0222   auto binnedMaterial = Acts::BinnedSurfaceMaterial(
0223       binUtility, {materialSlabs}, 0., Acts::MappingType::Default);
0224 
0225   detray::io::grid_payload<detray::io::material_slab_payload,
0226                            detray::io::material_id>
0227       payload =
0228           unpackGrid(*DetrayPayloadConverter::convertBinnedSurfaceMaterial(
0229               binnedMaterial));
0230 
0231   // Check the payload
0232   // - we fake 2D always for detray to minimize the number of containers
0233   // - four material payloads in the grid
0234   BOOST_CHECK_EQUAL(payload.axes.size(), 2u);
0235   BOOST_CHECK_EQUAL(payload.bins.size(), 4u);
0236   BOOST_CHECK(!payload.transform.has_value());
0237   BOOST_CHECK(payload.grid_link.type ==
0238               detray::io::material_id::rectangle2_map);
0239   // x-axis
0240   BOOST_CHECK(payload.axes.at(0u).label == detray::axis::label::e_x);
0241   BOOST_CHECK_EQUAL(payload.axes.at(0u).bins, 1u);
0242   // y-axis
0243   BOOST_CHECK(payload.axes.at(1u).label == detray::axis::label::e_y);
0244   BOOST_CHECK_EQUAL(payload.axes.at(1u).bins, 4u);
0245   CHECK_CLOSE_ABS(payload.axes.at(1u).edges.at(0u), -2.,
0246                   std::numeric_limits<double>::epsilon());
0247   CHECK_CLOSE_ABS(payload.axes.at(1u).edges.at(1u), 2.,
0248                   std::numeric_limits<double>::epsilon());
0249   BOOST_CHECK(payload.axes.at(1u).binning == detray::axis::binning::e_regular);
0250   BOOST_CHECK(payload.axes.at(1u).bounds == detray::axis::bounds::e_closed);
0251 
0252   // Check the local indices
0253   BOOST_CHECK_EQUAL(payload.bins.at(0u).loc_index.size(), 2u);
0254 
0255   // Bins should be : [0,0], [0,1], [0,2], [0,3]
0256   //
0257   // [0, 0] - materialSlab12345
0258   BOOST_CHECK_EQUAL(payload.bins.at(0u).loc_index.at(0), 0u);
0259   BOOST_CHECK_EQUAL(payload.bins.at(0u).loc_index.at(1), 0u);
0260   BOOST_CHECK_EQUAL(payload.bins.at(0u).content.at(0u).mat.params.at(0u), 1.);
0261   // [0, 1]  - materialSlab678910
0262   BOOST_CHECK_EQUAL(payload.bins.at(1u).loc_index.at(0), 0u);
0263   BOOST_CHECK_EQUAL(payload.bins.at(1u).loc_index.at(1), 1u);
0264   BOOST_CHECK_EQUAL(payload.bins.at(1u).content.at(0u).mat.params.at(0u), 6.);
0265   // [0, 2] - materialSlab54321
0266   BOOST_CHECK_EQUAL(payload.bins.at(2u).loc_index.at(0), 0u);
0267   BOOST_CHECK_EQUAL(payload.bins.at(2u).loc_index.at(1), 2u);
0268   BOOST_CHECK_EQUAL(payload.bins.at(2u).content.at(0u).mat.params.at(0u), 5.);
0269   // [0, 3] - materialSlab109876
0270   BOOST_CHECK_EQUAL(payload.bins.at(3u).loc_index.at(0), 0u);
0271   BOOST_CHECK_EQUAL(payload.bins.at(3u).loc_index.at(1), 3u);
0272   BOOST_CHECK_EQUAL(payload.bins.at(3u).content.at(0u).mat.params.at(0u), 10.);
0273 }
0274 
0275 BOOST_AUTO_TEST_CASE(DetrayBinnedMaterialConversionXY) {
0276   // Create a binned material in 2 x2  bins in x-y direction
0277   Acts::BinUtility binUtility(2u, -1., 1., Acts::BinningOption::open,
0278                               Acts::AxisDirection::AxisX);
0279   binUtility += Acts::BinUtility(2u, -2., 2., Acts::BinningOption::open,
0280                                  Acts::AxisDirection::AxisY);
0281 
0282   std::vector<Acts::MaterialSlab> materialSlabs0 = {materialSlab12345,
0283                                                     materialSlab678910};
0284   std::vector<Acts::MaterialSlab> materialSlabs1 = {materialSlab54321,
0285                                                     materialSlab109876};
0286 
0287   auto binnedMaterial =
0288       Acts::BinnedSurfaceMaterial(binUtility, {materialSlabs0, materialSlabs1},
0289                                   0., Acts::MappingType::Default);
0290 
0291   detray::io::grid_payload<detray::io::material_slab_payload,
0292                            detray::io::material_id>
0293       payload =
0294           unpackGrid(*DetrayPayloadConverter::convertBinnedSurfaceMaterial(
0295               binnedMaterial));
0296 
0297   // Check the payload
0298   BOOST_CHECK_EQUAL(payload.axes.size(), 2u);
0299   BOOST_CHECK(payload.grid_link.type ==
0300               detray::io::material_id::rectangle2_map);
0301   //  The axis are real x-y
0302   BOOST_CHECK(payload.axes.at(0u).label == detray::axis::label::e_x);
0303   BOOST_CHECK(payload.axes.at(1u).label == detray::axis::label::e_y);
0304   BOOST_CHECK_EQUAL(payload.bins.size(), 4u);
0305   BOOST_CHECK(!payload.transform.has_value());
0306   // 2 bins in x, 2 bins in y
0307   BOOST_CHECK_EQUAL(payload.axes.at(0u).bins, 2u);
0308   BOOST_CHECK_EQUAL(payload.axes.at(1u).bins, 2u);
0309 
0310   // Check the local indices
0311   BOOST_CHECK_EQUAL(payload.bins.at(0u).loc_index.size(), 2u);
0312 
0313   // Bins should be : [0,0], [1,0], [0,1], [1,1]
0314   //
0315   // [0, 0] - materialSlab12345
0316   BOOST_CHECK_EQUAL(payload.bins.at(0u).loc_index.at(0), 0u);
0317   BOOST_CHECK_EQUAL(payload.bins.at(0u).loc_index.at(1), 0u);
0318   BOOST_CHECK_EQUAL(payload.bins.at(0u).content.at(0u).mat.params.at(0u), 1.);
0319   // [0, 1]  - materialSlab678910
0320   BOOST_CHECK_EQUAL(payload.bins.at(1u).loc_index.at(0), 1u);
0321   BOOST_CHECK_EQUAL(payload.bins.at(1u).loc_index.at(1), 0u);
0322   BOOST_CHECK_EQUAL(payload.bins.at(1u).content.at(0u).mat.params.at(0u), 6.);
0323   // [1, 0] - materialSlab54321
0324   BOOST_CHECK_EQUAL(payload.bins.at(2u).loc_index.at(0), 0u);
0325   BOOST_CHECK_EQUAL(payload.bins.at(2u).loc_index.at(1), 1u);
0326   BOOST_CHECK_EQUAL(payload.bins.at(2u).content.at(0u).mat.params.at(0u), 5.);
0327   // [1, 1] - materialSlab109876
0328   BOOST_CHECK_EQUAL(payload.bins.at(3u).loc_index.at(0), 1u);
0329   BOOST_CHECK_EQUAL(payload.bins.at(3u).loc_index.at(1), 1u);
0330   BOOST_CHECK_EQUAL(payload.bins.at(3u).content.at(0u).mat.params.at(0u), 10.);
0331 }
0332 
0333 BOOST_AUTO_TEST_CASE(DetrayBinnedMaterialConversionR) {
0334   // Create a binned material in 4 bins (irregularly) in r direction
0335   std::vector<float> binEdges = {0., 5., 10., 15., 20.};
0336   Acts::BinUtility binUtility(binEdges, Acts::BinningOption::open,
0337                               Acts::AxisDirection::AxisR);
0338 
0339   std::vector<Acts::MaterialSlab> materialSlabs = {
0340       materialSlab12345, materialSlab678910, materialSlab54321,
0341       materialSlab109876};
0342 
0343   auto binnedMaterial = Acts::BinnedSurfaceMaterial(
0344       binUtility, {materialSlabs}, 0., Acts::MappingType::Default);
0345   detray::io::grid_payload<detray::io::material_slab_payload,
0346                            detray::io::material_id>
0347       payload =
0348           unpackGrid(*DetrayPayloadConverter::convertBinnedSurfaceMaterial(
0349               binnedMaterial));
0350 
0351   // Check the payload
0352   // - we fake 2D always for detray to minimize the number of containers
0353   // - four material payloads in the grid
0354   BOOST_CHECK_EQUAL(payload.axes.size(), 2u);
0355   BOOST_CHECK_EQUAL(payload.bins.size(), 4u);
0356   BOOST_CHECK(!payload.transform.has_value());
0357   BOOST_CHECK(payload.grid_link.type == detray::io::material_id::ring2_map);
0358   // first axis is r axis
0359   BOOST_CHECK(payload.axes.at(0u).label == detray::axis::label::e_r);
0360   BOOST_CHECK_EQUAL(payload.axes.at(0u).bins, 4u);
0361   BOOST_CHECK_EQUAL(payload.axes.at(0u).edges.size(), 5);
0362   CHECK_CLOSE_ABS(payload.axes.at(0u).edges.front(), 0.,
0363                   std::numeric_limits<double>::epsilon());
0364   CHECK_CLOSE_ABS(payload.axes.at(0u).edges.back(), 20.,
0365                   std::numeric_limits<double>::epsilon());
0366   BOOST_CHECK(payload.axes.at(0u).binning ==
0367               detray::axis::binning::e_irregular);
0368   BOOST_CHECK(payload.axes.at(0u).bounds == detray::axis::bounds::e_closed);
0369   // 2nd-axis is dummy
0370   BOOST_CHECK(payload.axes.at(1u).label == detray::axis::label::e_phi);
0371   BOOST_CHECK(payload.axes.at(1u).bounds == detray::axis::bounds::e_circular);
0372 }
0373 
0374 BOOST_AUTO_TEST_CASE(DetrayBinnedMaterialConversionRPhi) {
0375   // Create a binned material in 2 bins - irregularly in r, 2 bins in phi
0376   std::vector<float> binEdges = {0., 5., 20.};
0377   Acts::BinUtility binUtility(binEdges, Acts::BinningOption::open,
0378                               Acts::AxisDirection::AxisR);
0379   binUtility += Acts::BinUtility(2u, -std::numbers::pi, std::numbers::pi,
0380                                  Acts::BinningOption::closed,
0381                                  Acts::AxisDirection::AxisPhi);
0382 
0383   std::vector<Acts::MaterialSlab> materialSlabs0 = {materialSlab12345,
0384                                                     materialSlab678910};
0385   std::vector<Acts::MaterialSlab> materialSlabs1 = {materialSlab54321,
0386                                                     materialSlab109876};
0387 
0388   auto binnedMaterial =
0389       Acts::BinnedSurfaceMaterial(binUtility, {materialSlabs0, materialSlabs1},
0390                                   0., Acts::MappingType::Default);
0391 
0392   detray::io::grid_payload<detray::io::material_slab_payload,
0393                            detray::io::material_id>
0394       payload =
0395           unpackGrid(*DetrayPayloadConverter::convertBinnedSurfaceMaterial(
0396               binnedMaterial));
0397 
0398   // Check the payload
0399   BOOST_CHECK_EQUAL(payload.axes.size(), 2u);
0400   BOOST_CHECK_EQUAL(payload.bins.size(), 4u);
0401   BOOST_CHECK(!payload.transform.has_value());
0402   BOOST_CHECK(payload.grid_link.type == detray::io::material_id::ring2_map);
0403   // 2 bins irregularly in r
0404   BOOST_CHECK(payload.axes.at(0u).label == detray::axis::label::e_r);
0405   BOOST_CHECK_EQUAL(payload.axes.at(0u).bins, 2u);
0406   BOOST_CHECK(payload.axes.at(0u).bounds == detray::axis::bounds::e_closed);
0407   BOOST_CHECK(payload.axes.at(0u).binning ==
0408               detray::axis::binning::e_irregular);
0409   // 2bins regularly in phi
0410   BOOST_CHECK(payload.axes.at(1u).label == detray::axis::label::e_phi);
0411   BOOST_CHECK_EQUAL(payload.axes.at(1u).bins, 2u);
0412   BOOST_CHECK(payload.axes.at(1u).bounds == detray::axis::bounds::e_circular);
0413 }
0414 
0415 BOOST_AUTO_TEST_CASE(DetrayBinnedMaterialConversionZ) {
0416   // Create a binned material in 4 bins in x direction
0417   std::vector<float> binEdges = {-20, 0, 25, 50, 100};
0418   Acts::BinUtility binUtility(binEdges, Acts::BinningOption::open,
0419                               Acts::AxisDirection::AxisZ);
0420 
0421   std::vector<Acts::MaterialSlab> materialSlabs = {
0422       materialSlab12345, materialSlab678910, materialSlab54321,
0423       materialSlab109876};
0424 
0425   auto binnedMaterial = Acts::BinnedSurfaceMaterial(
0426       binUtility, {materialSlabs}, 0., Acts::MappingType::Default);
0427 
0428   detray::io::grid_payload<detray::io::material_slab_payload,
0429                            detray::io::material_id>
0430       payload =
0431           unpackGrid(*DetrayPayloadConverter::convertBinnedSurfaceMaterial(
0432               binnedMaterial));
0433 
0434   // Check the payload
0435   BOOST_CHECK_EQUAL(payload.axes.size(), 2u);
0436   BOOST_CHECK_EQUAL(payload.bins.size(), 4u);
0437   BOOST_CHECK(!payload.transform.has_value());
0438   BOOST_CHECK(payload.grid_link.type ==
0439               detray::io::material_id::concentric_cylinder2_map);
0440   // 1st-axis is dummy
0441   BOOST_CHECK(payload.axes.at(0u).label == detray::axis::label::e_phi);
0442   BOOST_CHECK(payload.axes.at(0u).bounds == detray::axis::bounds::e_circular);
0443   BOOST_CHECK_EQUAL(payload.axes.at(0u).bins, 1u);
0444   // second axis is z axis
0445   BOOST_CHECK(payload.axes.at(1u).label == detray::axis::label::e_z);
0446   BOOST_CHECK_EQUAL(payload.axes.at(1u).bins, 4u);
0447   BOOST_CHECK_EQUAL(payload.axes.at(1u).edges.size(), 5);
0448   CHECK_CLOSE_ABS(payload.axes.at(1u).edges.front(), -20.,
0449                   std::numeric_limits<double>::epsilon());
0450   CHECK_CLOSE_ABS(payload.axes.at(1u).edges.back(), 100.,
0451                   std::numeric_limits<double>::epsilon());
0452   BOOST_CHECK(payload.axes.at(1u).binning ==
0453               detray::axis::binning::e_irregular);
0454   BOOST_CHECK(payload.axes.at(1u).bounds == detray::axis::bounds::e_closed);
0455 }
0456 
0457 BOOST_AUTO_TEST_CASE(DetrayBinnedMaterialConversionZPhi) {
0458   // Create a binned material in 2 x2  bins in x-y direction
0459   Acts::BinUtility binUtility(2u, -1., 1., Acts::BinningOption::open,
0460                               Acts::AxisDirection::AxisZ);
0461   binUtility += Acts::BinUtility(2u, -std::numbers::pi, std::numbers::pi,
0462                                  Acts::BinningOption::closed,
0463                                  Acts::AxisDirection::AxisPhi);
0464 
0465   std::vector<Acts::MaterialSlab> materialSlabs0 = {materialSlab12345,
0466                                                     materialSlab678910};
0467   std::vector<Acts::MaterialSlab> materialSlabs1 = {materialSlab54321,
0468                                                     materialSlab109876};
0469 
0470   auto binnedMaterial =
0471       Acts::BinnedSurfaceMaterial(binUtility, {materialSlabs0, materialSlabs1},
0472                                   0., Acts::MappingType::Default);
0473 
0474   detray::io::grid_payload<detray::io::material_slab_payload,
0475                            detray::io::material_id>
0476       payload =
0477           unpackGrid(*DetrayPayloadConverter::convertBinnedSurfaceMaterial(
0478               binnedMaterial));
0479 
0480   // Check the payload
0481   BOOST_CHECK_EQUAL(payload.axes.size(), 2u);
0482   BOOST_CHECK(payload.grid_link.type ==
0483               detray::io::material_id::concentric_cylinder2_map);
0484   //  The axis are real aphi-z
0485   BOOST_CHECK(payload.axes.at(0u).label == detray::axis::label::e_phi);
0486   BOOST_CHECK(payload.axes.at(1u).label == detray::axis::label::e_z);
0487   BOOST_CHECK_EQUAL(payload.bins.size(), 4u);
0488   BOOST_CHECK(!payload.transform.has_value());
0489 }
0490 
0491 BOOST_AUTO_TEST_CASE(DetrayBinnedMaterialConversionInvalid) {
0492   // Create a binned material in 4 bins in x direction
0493   Acts::BinUtility binUtility(2u, -1., 1., Acts::BinningOption::open,
0494                               Acts::AxisDirection::AxisR);
0495   binUtility += Acts::BinUtility(2u, -2., 2., Acts::BinningOption::open,
0496                                  Acts::AxisDirection::AxisEta);
0497 
0498   std::vector<Acts::MaterialSlab> materialSlabs0 = {materialSlab12345,
0499                                                     materialSlab678910};
0500   std::vector<Acts::MaterialSlab> materialSlabs1 = {materialSlab54321,
0501                                                     materialSlab109876};
0502 
0503   auto binnedMaterial =
0504       Acts::BinnedSurfaceMaterial(binUtility, {materialSlabs0, materialSlabs1},
0505                                   0., Acts::MappingType::Default);
0506 
0507   BOOST_CHECK_THROW(
0508       DetrayPayloadConverter::convertBinnedSurfaceMaterial(binnedMaterial),
0509       std::invalid_argument);
0510 }
0511 
0512 BOOST_AUTO_TEST_SUITE_END()
0513 
0514 }  // 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!