cpu/builders/material_map_builder.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 // Detray include(s)
0010 #include "detray/builders/material_map_builder.hpp"
0011
0012 #include "detray/builders/cuboid_portal_generator.hpp"
0013 #include "detray/builders/detector_builder.hpp"
0014 #include "detray/builders/material_map_factory.hpp"
0015 #include "detray/builders/surface_factory.hpp"
0016 #include "detray/builders/volume_builder.hpp"
0017 #include "detray/core/detector.hpp"
0018 #include "detray/definitions/indexing.hpp"
0019 #include "detray/utils/ranges.hpp"
0020
0021 // Detray test include(s)
0022 #include "detray/test/framework/types.hpp"
0023
0024 // Vecmem include(s)
0025 #include <vecmem/memory/host_memory_resource.hpp>
0026
0027 // GTest include(s)
0028 #include <gtest/gtest.h>
0029
0030 // System include(s)
0031 #include <limits>
0032 #include <memory>
0033 #include <vector>
0034
0035 using namespace detray;
0036
0037 namespace {
0038
0039 using scalar = test::scalar;
0040 using point3 = test::point3;
0041
0042 using metadata_t = test::default_metadata;
0043 using detector_t = detector<metadata_t>;
0044 using mat_id = typename detector_t::material::id;
0045 using bin_index_t = axis::multi_bin<2u>;
0046
0047 /// Add generate input material for material maps
0048 template <typename material_factory_t, concepts::scalar scalar_t>
0049 auto add_material_data(const material_factory_t& mat_factory, mat_id id,
0050                        std::size_t sf_index, scalar_t t,
0051                        material<scalar_t> mat = silicon<scalar_t>()) {
0052   typename material_factory_t::element_type::data_type mat_data{sf_index};
0053   std::vector<bin_index_t> m_bins{};
0054   std::vector<std::size_t> n_bins{5u, 10u};
0055   std::vector<std::vector<scalar_t>> axis_spans = {};
0056
0057   // Add material for every bin
0058   for (auto [i, j] : detray::views::cartesian_product{
0059            detray::views::iota{0u, 5u}, detray::views::iota{0u, 10u}}) {
0060     m_bins.push_back({i, j});
0061     mat_data.append(t, mat);
0062     t += 0.25f * unit<scalar_t>::mm;
0063   }
0064
0065   mat_factory->add_material(id, std::move(mat_data), std::move(n_bins),
0066                             std::move(axis_spans), std::move(m_bins));
0067 }
0068
0069 }  // anonymous namespace
0070
0071 /// Unittest: Test the construction of a collection of material maps
0072 TEST(detray_builders, material_map_factory) {
0073   using algebra_t = typename detector_t::algebra_type;
0074   using transform3 = dtransform3D<algebra_t>;
0075
0076   // Build rectangle surfaces with material slabs
0077   using rectangle_factory = surface_factory<detector_t, rectangle2D>;
0078   auto mat_factory =
0079       std::make_unique<material_map_factory<detector_t, bin_index_t>>(
0080           std::make_unique<rectangle_factory>());
0081
0082   EXPECT_EQ(mat_factory->size(), 0u);
0083   EXPECT_TRUE(mat_factory->materials().empty());
0084   EXPECT_TRUE(mat_factory->thickness().empty());
0085
0086   // Add material maps for a few rectangle surfaces
0087   mat_factory->push_back({surface_id::e_sensitive,
0088                           transform3(point3{0.f, 0.f, -1.f}), 1u,
0089                           std::vector<scalar>{10.f, 8.f}});
0090
0091   scalar t{1.f * unit<scalar>::mm};
0092   add_material_data(mat_factory, mat_id::e_rectangle2D_map, 0u, t,
0093                     silicon<scalar>());
0094
0095   mat_factory->push_back({surface_id::e_sensitive,
0096                           transform3(point3{0.f, 0.f, 1.f}), 1u,
0097                           std::vector<scalar>{20.f, 16.f}});
0098   t = 2.f * unit<scalar>::mm;
0099   add_material_data(mat_factory, mat_id::e_rectangle2D_map, 1u, t,
0100                     tungsten<scalar>());
0101
0102   // Pass the parameters for 'gold'
0103   mat_factory->push_back({surface_id::e_sensitive,
0104                           transform3(point3{0.f, 0.f, 1.f}), 1u,
0105                           std::vector<scalar>{20.f, 16.f}});
0106   t = 3.f * unit<scalar>::mm;
0107   add_material_data(
0108       mat_factory, mat_id::e_rectangle2D_map, 2u, t,
0109       {3.344f * unit<scalar>::mm, 101.6f * unit<scalar>::mm, 196.97f, 79,
0110        19.32f * unit<scalar>::g / (1.f * unit<scalar>::cm3),
0111        material_state::e_solid});
0112
0113   EXPECT_EQ(mat_factory->size(), 3u);
0114
0115   // Test the material data
0116   EXPECT_EQ(mat_factory->links().size(), 3u);
0117   EXPECT_EQ(mat_factory->thickness().at(0).size(), 50u);
0118   EXPECT_EQ(mat_factory->thickness().at(1).size(), 50u);
0119   EXPECT_EQ(mat_factory->thickness().at(2).size(), 50u);
0120   EXPECT_EQ(mat_factory->materials().at(0).front(), silicon<scalar>());
0121   EXPECT_EQ(mat_factory->materials().at(1).front(), tungsten<scalar>());
0122   EXPECT_EQ(mat_factory->materials().at(2).front(), gold<scalar>());
0123 }