io/src/read_detector_description.cpp

0001 /** TRACCC library, part of the ACTS project (R&D line)
0002  *
0003  * (c) 2024 CERN for the benefit of the ACTS project
0004  *
0005  * Mozilla Public License Version 2.0
0006  */
0007
0008 // Library include(s).
0009 #include "traccc/io/read_detector_description.hpp"
0010
0011 #include "traccc/geometry/host_detector.hpp"
0012 #include "traccc/io/detector.hpp"
0013 #include "traccc/io/read_conditions_config.hpp"
0014 #include "traccc/io/read_detector.hpp"
0015 #include "traccc/io/read_digitization_config.hpp"
0016 #include "traccc/io/utils.hpp"
0017
0018 // Detray include(s)
0019 #include <detray/geometry/tracking_surface.hpp>
0020 #include <detray/utils/type_registry.hpp>
0021
0022 // VecMem include(s).
0023 #include <vecmem/memory/host_memory_resource.hpp>
0024
0025 // System include(s).
0026 #include <iterator>
0027 #include <set>
0028 #include <sstream>
0029 #include <stdexcept>
0030
0031 namespace {
0032
0033 void fill_digi_info(traccc::detector_design_description::host& det_desc,
0034                     const traccc::module_digitization_config& data) {
0035   det_desc.dimensions().back() = data.dimensions;
0036
0037   det_desc.bin_edges_x().back().assign(data.bin_edges[0].begin(),
0038                                        data.bin_edges[0].end());
0039
0040   det_desc.bin_edges_y().back().assign(data.bin_edges[1].begin(),
0041                                        data.bin_edges[1].end());
0042 }
0043
0044 template <typename detector_traits_t>
0045 void read_json_dd_impl(traccc::detector_design_description::host& det_desc,
0046                        traccc::detector_conditions_description::host& det_cond,
0047                        const traccc::host_detector& detector,
0048                        const traccc::digitization_config& digi,
0049                        const traccc::conditions_config& cond)
0050   requires(traccc::is_detector_traits<detector_traits_t>)
0051 {
0052   const typename detector_traits_t::host& detector_host =
0053       detector.as<detector_traits_t>();
0054
0055   det_desc.reserve(digi.size());
0056   det_cond.reserve(detector_host.surfaces().size());
0057
0058   int n_design = 0;
0059   for (const auto& digi_it : digi) {
0060     det_desc.resize(det_desc.size() + 1);
0061     det_desc.design_id().back() = n_design++;
0062     fill_digi_info(det_desc, digi_it);
0063   }
0064
0065   std::vector<int> module_to_design;
0066
0067   for (const auto& surface_desc : detector_host.surfaces()) {
0068     const traccc::geometry_id geom_id{surface_desc.source};
0069     const Acts::GeometryIdentifier acts_geom_id{geom_id};
0070
0071     if (acts_geom_id.sensitive() == 0) {
0072       continue;
0073     }
0074     // New module — add it to detector conditions description
0075     det_cond.resize(det_cond.size() + 1);
0076     det_cond.geometry_id().back() = surface_desc.identifier();
0077     det_cond.acts_geometry_id().back() = geom_id;
0078
0079     std::array<detray::dindex_type<traccc::default_algebra>, 2u> subspace = {0,
0080                                                                              1};
0081     using annulus_t = detray::mask<detray::annulus2D, traccc::default_algebra>;
0082     using mask_registry_t = typename detector_traits_t::host::masks;
0083     if constexpr (detray::types::contains<mask_registry_t, annulus_t>) {
0084       if (surface_desc.mask().id() ==
0085           detray::types::id<mask_registry_t, annulus_t>) {
0086         subspace = {1, 0};
0087       }
0088     }
0089     if (!digi.contains(acts_geom_id)) {
0090       std::ostringstream msg;
0091       msg << "Could not find digitization config for geometry ID: "
0092           << acts_geom_id;
0093       throw std::runtime_error(msg.str());
0094     } else {
0095       auto digi_it = digi.find(acts_geom_id);
0096       if (digi_it != digi.end()) {
0097         int idx = static_cast<int>(std::distance(digi.begin(), digi_it));
0098         det_desc.subspace()[static_cast<unsigned long>(idx)] = subspace;
0099         module_to_design.push_back(idx);
0100       }
0101     }
0102
0103     // Find the module's conditions configuration.
0104     const traccc::conditions_config::Iterator cond_it = cond.find(acts_geom_id);
0105     if (cond_it == cond.end()) {
0106       std::ostringstream msg;
0107       msg << "Could not find conditions config for geometry ID: "
0108           << acts_geom_id;
0109       throw std::runtime_error(msg.str());
0110     }
0111
0112     det_cond.measurement_translation().back() = cond_it->shift;
0113   }
0114
0115   det_cond.module_to_design_id().assign(module_to_design.begin(),
0116                                         module_to_design.end());
0117 }
0118
0119 void read_json_dd(traccc::detector_design_description::host& det_desc,
0120                   traccc::detector_conditions_description::host& det_cond,
0121                   std::string_view geometry_file,
0122                   const traccc::digitization_config& digi,
0123                   const traccc::conditions_config& cond) {
0124   // Construct a (temporary) Detray detector object from the geometry
0125   // configuration file.
0126   vecmem::host_memory_resource mr;
0127   traccc::host_detector detector;
0128   traccc::io::read_detector(detector, mr, geometry_file);
0129
0130   // TODO: Implement detector visitor!
0131   // Peek at the header to determine the kind of detector that is needed
0132   const auto header = detray::io::detail::deserialize_json_header(
0133       traccc::io::get_absolute_path(geometry_file));
0134
0135   if (header.detector == "Cylindrical detector from DD4hep blueprint") {
0136     read_json_dd_impl<traccc::odd_detector>(det_desc, det_cond, detector, digi,
0137                                             cond);
0138   } else if (header.detector == "detray_detector") {
0139     read_json_dd_impl<traccc::itk_detector>(det_desc, det_cond, detector, digi,
0140                                             cond);
0141   } else {
0142     // TODO: Warning here
0143     read_json_dd_impl<traccc::default_detector>(det_desc, det_cond, detector,
0144                                                 digi, cond);
0145   }
0146 }
0147
0148 }  // namespace
0149
0150 namespace traccc::io {
0151
0152 void read_detector_description(detector_design_description::host& det_desc,
0153                                detector_conditions_description::host& det_cond,
0154                                std::string_view geometry_file,
0155                                std::string_view digitization_file,
0156                                std::string_view conditions_file,
0157                                const data_format geometry_format,
0158                                const data_format digitization_format,
0159                                const data_format conditions_format) {
0160   // Read the digitization configuration.
0161   const digitization_config digi =
0162       read_digitization_config(digitization_file, digitization_format);
0163   const conditions_config cond =
0164       read_conditions_config(conditions_file, conditions_format);
0165   // Fill the detector description with the correct type of geometry file.
0166   switch (geometry_format) {
0167     case data_format::json:
0168       ::read_json_dd(det_desc, det_cond, geometry_file, digi, cond);
0169       break;
0170     default:
0171       throw std::invalid_argument("Unsupported geometry format.");
0172   }
0173 }
0174
0175 }  // namespace traccc::io