src/Detector/MultiWireStructureBuilder.cpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2022-2023 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 "Acts/Detector/MultiWireStructureBuilder.hpp"
0010
0011 #include "Acts/Detector/DetectorComponents.hpp"
0012 #include "Acts/Detector/DetectorVolumeBuilder.hpp"
0013 #include "Acts/Detector/LayerStructureBuilder.hpp"
0014 #include "Acts/Detector/ProtoBinning.hpp"
0015 #include "Acts/Detector/VolumeStructureBuilder.hpp"
0016 #include "Acts/Detector/detail/IndexedSurfacesGenerator.hpp"
0017 #include "Acts/Detector/detail/ReferenceGenerators.hpp"
0018 #include "Acts/Detector/interface/IExternalStructureBuilder.hpp"
0019 #include "Acts/Detector/interface/IInternalStructureBuilder.hpp"
0020 #include "Acts/Geometry/GeometryContext.hpp"
0021 #include "Acts/Geometry/VolumeBounds.hpp"
0022 #include "Acts/Navigation/DetectorVolumeFinders.hpp"
0023 #include "Acts/Navigation/SurfaceCandidatesUpdaters.hpp"
0024 #include "Acts/Utilities/GridAxisGenerators.hpp"
0025 #include "Acts/Utilities/Logger.hpp"
0026
0027 #include <algorithm>
0028 #include <functional>
0029 #include <iostream>
0030 #include <string>
0031 #include <vector>
0032
0033 class MultiWireInternalStructureBuilder
0034     : public Acts::Experimental::IInternalStructureBuilder {
0035  public:
0036   struct Config {
0037     /// The internal surfaces
0038     std::vector<std::shared_ptr<Acts::Surface>> iSurfaces;
0039
0040     /// Definition of Binning
0041     std::vector<Acts::Experimental::ProtoBinning> binning;
0042
0043     /// Extra information, mainly for screen output
0044     std::string auxiliary = "";
0045
0046     /// The transform into the local binning schema
0047     Acts::Transform3 transform = Acts::Transform3::Identity();
0048   };
0049
0050   // Constructor
0051
0052   MultiWireInternalStructureBuilder(
0053       const Config& cfg,
0054       std::unique_ptr<const Acts::Logger> mlogger = Acts::getDefaultLogger(
0055           "MUltiWireInternalBuilder", Acts::Logging::INFO))
0056       : Acts::Experimental::IInternalStructureBuilder(),
0057         m_cfg(cfg),
0058         m_logger(std::move(mlogger)) {}
0059
0060   Acts::Experimental::InternalStructure construct(
0061       const Acts::GeometryContext& gctx) const final {
0062     if (!m_cfg.auxiliary.empty()) {
0063       ACTS_DEBUG(m_cfg.auxiliary);
0064     }
0065
0066     Acts::Experimental::DetectorVolumeUpdater internalVolumeUpdater =
0067         Acts::Experimental::tryNoVolumes();
0068     // Create the indexed surfaces
0069     auto internalSurfaces = m_cfg.iSurfaces;
0070     Acts::Experimental::detail::IndexedSurfacesGenerator<
0071         decltype(internalSurfaces), Acts::Experimental::MultiLayerSurfacesImpl>
0072         isg{internalSurfaces,
0073             {},
0074             {m_cfg.binning[0u].binValue, m_cfg.binning[1u].binValue},
0075             {m_cfg.binning[0u].expansion, m_cfg.binning[1u].expansion},
0076             m_cfg.transform};
0077     Acts::Experimental::detail::CenterReferenceGenerator rGenerator;
0078     Acts::GridAxisGenerators::EqBoundEqBound aGenerator{
0079         {m_cfg.binning[0u].edges.front(), m_cfg.binning[0u].edges.back()},
0080         m_cfg.binning[0u].edges.size() - 1,
0081         {m_cfg.binning[1u].edges.front(), m_cfg.binning[1u].edges.back()},
0082         m_cfg.binning[1u].edges.size() - 1};
0083
0084     auto sfCandidatesUpdater = isg(gctx, aGenerator, rGenerator);
0085
0086     return {internalSurfaces,
0087             {},
0088             std::move(sfCandidatesUpdater),
0089             std::move(internalVolumeUpdater)};
0090   }
0091
0092  private:
0093   /// Configuration object
0094   Config m_cfg;
0095
0096   /// Private access method to the logger
0097   const Acts::Logger& logger() const { return *m_logger; }
0098
0099   /// logging instance
0100   std::unique_ptr<const Acts::Logger> m_logger;
0101 };
0102
0103 Acts::Experimental::MultiWireStructureBuilder::MultiWireStructureBuilder(
0104     const Acts::Experimental::MultiWireStructureBuilder::Config& config,
0105     std::unique_ptr<const Acts::Logger> logger)
0106     : mCfg(config), mLogger(std::move(logger)) {
0107   // check if the surfaces are set
0108   if (mCfg.mlSurfaces.empty()) {
0109     throw std::invalid_argument(
0110         "MultiWireStructureBuilder: No surfaces are given");
0111   } else if (mCfg.mlBinning.size() != 2u) {
0112     throw ::std::invalid_argument(
0113         "MultiWireStructureBuilder: Invalid binning provided");
0114   }
0115 }
0116
0117 Acts::Experimental::DetectorComponent
0118 Acts::Experimental::MultiWireStructureBuilder::construct(
0119     const Acts::GeometryContext& gctx) {
0120   // Configure the external structure builder for the internal structure
0121   Acts::Experimental::VolumeStructureBuilder::Config vsConfig;
0122   vsConfig.boundsType = Acts::VolumeBounds::eTrapezoid;
0123   vsConfig.transform = mCfg.transform;
0124   vsConfig.boundValues = mCfg.mlBounds;
0125   vsConfig.auxiliary = "Construct External Structure";
0126
0127   // Configure the internal structure builder for the internal structure
0128   MultiWireInternalStructureBuilder::Config iConfig;
0129   iConfig.iSurfaces = mCfg.mlSurfaces;
0130   iConfig.binning = mCfg.mlBinning;
0131   iConfig.transform = mCfg.transform.inverse();
0132   iConfig.auxiliary = "Construct Internal Structure";
0133
0134   Acts::Experimental::DetectorVolumeBuilder::Config dvConfig;
0135   dvConfig.auxiliary = "Construct Detector Volume";
0136   dvConfig.name = mCfg.name;
0137   dvConfig.internalsBuilder =
0138       std::make_shared<MultiWireInternalStructureBuilder>(
0139           iConfig,
0140           Acts::getDefaultLogger("MultiWire Internal Structure Builder",
0141                                  Acts::Logging::VERBOSE));
0142   dvConfig.externalsBuilder =
0143       std::make_shared<Acts::Experimental::VolumeStructureBuilder>(
0144           vsConfig, Acts::getDefaultLogger("VolumeStructureBuilder",
0145                                            Acts::Logging::VERBOSE));
0146   auto dvBuilder = std::make_shared<Acts::Experimental::DetectorVolumeBuilder>(
0147       dvConfig,
0148       Acts::getDefaultLogger("DetectorVolumeBuilder", Acts::Logging::VERBOSE));
0149
0150   auto dvComponent = dvBuilder->construct(gctx);
0151
0152   return dvComponent;
0153 }