src/Geometry/CuboidVolumeBuilder.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 #include "Acts/Geometry/CuboidVolumeBuilder.hpp"
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Geometry/BoundarySurfaceFace.hpp"
0013 #include "Acts/Geometry/CuboidVolumeBounds.hpp"
0014 #include "Acts/Geometry/Extent.hpp"
0015 #include "Acts/Geometry/LayerArrayCreator.hpp"
0016 #include "Acts/Geometry/LayerCreator.hpp"
0017 #include "Acts/Geometry/ProtoLayer.hpp"
0018 #include "Acts/Geometry/SurfaceArrayCreator.hpp"
0019 #include "Acts/Geometry/TrackingGeometry.hpp"
0020 #include "Acts/Geometry/TrackingVolume.hpp"
0021 #include "Acts/Geometry/Volume.hpp"
0022 #include "Acts/Surfaces/PlaneSurface.hpp"
0023 #include "Acts/Surfaces/RectangleBounds.hpp"
0024 #include "Acts/Surfaces/Surface.hpp"
0025 #include "Acts/Utilities/BinUtility.hpp"
0026 #include "Acts/Utilities/BinnedArrayXD.hpp"
0027 #include "Acts/Utilities/BinningData.hpp"
0028 #include "Acts/Utilities/Logger.hpp"
0029
0030 #include <algorithm>
0031 #include <limits>
0032 #include <stdexcept>
0033
0034 namespace Acts {
0035
0036 std::shared_ptr<const Surface> CuboidVolumeBuilder::buildSurface(
0037     const GeometryContext& /*gctx*/,
0038     const CuboidVolumeBuilder::SurfaceConfig& cfg) const {
0039   std::shared_ptr<PlaneSurface> surface;
0040
0041   // Build transformation
0042   Transform3 trafo(Transform3::Identity() * cfg.rotation);
0043   trafo.translation() = cfg.position;
0044
0045   // Create and store surface
0046   if (cfg.detElementConstructor) {
0047     surface = Surface::makeShared<PlaneSurface>(
0048         cfg.rBounds,
0049         *(cfg.detElementConstructor(trafo, cfg.rBounds, cfg.thickness)));
0050     surface->assignThickness(cfg.thickness);
0051   } else {
0052     surface = Surface::makeShared<PlaneSurface>(trafo, cfg.rBounds);
0053   }
0054   surface->assignSurfaceMaterial(cfg.surMat);
0055   return surface;
0056 }
0057
0058 std::shared_ptr<const Layer> CuboidVolumeBuilder::buildLayer(
0059     const GeometryContext& gctx, CuboidVolumeBuilder::LayerConfig& cfg) const {
0060   if (cfg.surfaces.empty() && cfg.surfaceCfg.empty()) {
0061     throw std::runtime_error{
0062         "Neither surfaces nor config to build surfaces was provided. Cannot "
0063         "proceed"};
0064   }
0065
0066   // Build the surface
0067   if (cfg.surfaces.empty()) {
0068     for (const auto& sCfg : cfg.surfaceCfg) {
0069       cfg.surfaces.push_back(buildSurface(gctx, sCfg));
0070     }
0071   }
0072   // Build transformation centered at the surface position
0073   Vector3 centroid{0., 0., 0.};
0074
0075   for (const auto& surface : cfg.surfaces) {
0076     centroid += surface->localToGlobalTransform(gctx).translation();
0077   }
0078
0079   centroid /= cfg.surfaces.size();
0080
0081   // In the case the layer configuration doesn't define the rotation of the
0082   // layer use the orientation of the first surface to define the layer rotation
0083   // in space.
0084   Transform3 trafo = Transform3::Identity();
0085   trafo.translation() = centroid;
0086   if (cfg.rotation) {
0087     trafo.linear() = *cfg.rotation;
0088   } else {
0089     trafo.linear() =
0090         cfg.surfaces.front()->localToGlobalTransform(gctx).rotation();
0091   }
0092
0093   LayerCreator::Config lCfg;
0094   lCfg.surfaceArrayCreator = std::make_shared<const SurfaceArrayCreator>();
0095   LayerCreator layerCreator(lCfg);
0096   ProtoLayer pl{gctx, cfg.surfaces};
0097   pl.envelope[AxisDirection::AxisX] = cfg.envelopeX;
0098   pl.envelope[AxisDirection::AxisY] = cfg.envelopeY;
0099   pl.envelope[AxisDirection::AxisZ] = cfg.envelopeZ;
0100   return layerCreator.planeLayer(gctx, cfg.surfaces, cfg.binsY, cfg.binsZ,
0101                                  cfg.binningDimension, pl, trafo);
0102 }
0103
0104 std::pair<double, double> CuboidVolumeBuilder::binningRange(
0105     const GeometryContext& gctx,
0106     const CuboidVolumeBuilder::VolumeConfig& cfg) const {
0107   // Construct return value
0108   std::pair<double, double> minMax = std::make_pair(
0109       std::numeric_limits<double>::max(), -std::numeric_limits<double>::max());
0110
0111   // Compute the min volume boundaries for computing the binning start
0112   // See
0113   // https://acts.readthedocs.io/en/latest/core/geometry/legacy/building.html
0114   // !! IMPORTANT !! The volume is assumed to be already rotated into the
0115   // telescope geometry
0116   Vector3 minVolumeBoundaries = cfg.position - 0.5 * cfg.length;
0117   Vector3 maxVolumeBoundaries = cfg.position + 0.5 * cfg.length;
0118
0119   // Compute first the min-max from the layers
0120
0121   for (const auto& layercfg : cfg.layerCfg) {
0122     // recreating the protolayer for each layer => slow, but only few sensors
0123     ProtoLayer pl{gctx, layercfg.surfaces};
0124     pl.envelope[cfg.binningDimension] = layercfg.envelopeX;
0125
0126     double surfacePosMin = pl.min(cfg.binningDimension);
0127     double surfacePosMax = pl.max(cfg.binningDimension);
0128
0129     // Test if new extreme is found and set it
0130     if (surfacePosMin < minMax.first) {
0131       minMax.first = surfacePosMin;
0132     }
0133     if (surfacePosMax > minMax.second) {
0134       minMax.second = surfacePosMax;
0135     }
0136   }
0137
0138   // Use the volume boundaries as limits for the binning
0139   minMax.first = std::min(
0140       minMax.first, minVolumeBoundaries(toUnderlying(cfg.binningDimension)));
0141   minMax.second = std::max(
0142       minMax.second, maxVolumeBoundaries(toUnderlying(cfg.binningDimension)));
0143
0144   return minMax;
0145 }
0146
0147 std::shared_ptr<TrackingVolume> CuboidVolumeBuilder::buildVolume(
0148     const GeometryContext& gctx, CuboidVolumeBuilder::VolumeConfig& cfg) const {
0149   // Build transformation
0150   Transform3 trafo(Transform3::Identity());
0151   trafo.translation() = cfg.position;
0152   // Set bounds
0153   auto bounds = std::make_shared<CuboidVolumeBounds>(
0154       cfg.length.x() * 0.5, cfg.length.y() * 0.5, cfg.length.z() * 0.5);
0155
0156   // Gather the layers
0157   LayerVector layVec;
0158   if (cfg.layers.empty()) {
0159     cfg.layers.reserve(cfg.layerCfg.size());
0160
0161     for (auto& layerCfg : cfg.layerCfg) {
0162       cfg.layers.push_back(buildLayer(gctx, layerCfg));
0163       layVec.push_back(cfg.layers.back());
0164     }
0165   } else {
0166     for (auto& lay : cfg.layers) {
0167       layVec.push_back(lay);
0168     }
0169   }
0170
0171   // Build layer array
0172   std::pair<double, double> minMax = binningRange(gctx, cfg);
0173   LayerArrayCreator::Config lacCnf;
0174   LayerArrayCreator layArrCreator(
0175       lacCnf, getDefaultLogger("LayerArrayCreator", Logging::INFO));
0176   std::unique_ptr<const LayerArray> layArr(
0177       layArrCreator.layerArray(gctx, layVec, minMax.first, minMax.second,
0178                                BinningType::arbitrary, cfg.binningDimension));
0179
0180   // Build confined volumes
0181   if (cfg.trackingVolumes.empty()) {
0182     for (VolumeConfig vc : cfg.volumeCfg) {
0183       cfg.trackingVolumes.push_back(buildVolume(gctx, vc));
0184     }
0185   }
0186
0187   std::shared_ptr<TrackingVolume> trackVolume;
0188   if (layVec.empty()) {
0189     // Build TrackingVolume
0190     trackVolume = std::make_shared<TrackingVolume>(
0191         trafo, bounds, cfg.volumeMaterial, nullptr, nullptr,
0192         cfg.trackingVolumes, cfg.name);
0193   } else {
0194     // Build TrackingVolume
0195     trackVolume = std::make_shared<TrackingVolume>(
0196         trafo, bounds, cfg.volumeMaterial, std::move(layArr), nullptr,
0197         cfg.trackingVolumes, cfg.name);
0198   }
0199   return trackVolume;
0200 }
0201
0202 MutableTrackingVolumePtr CuboidVolumeBuilder::trackingVolume(
0203     const GeometryContext& gctx, TrackingVolumePtr /*gctx*/,
0204     std::shared_ptr<const VolumeBounds> /*bounds*/) const {
0205   // Build volumes
0206   std::vector<std::shared_ptr<TrackingVolume>> volumes;
0207   volumes.reserve(m_cfg.volumeCfg.size());
0208   for (VolumeConfig volCfg : m_cfg.volumeCfg) {
0209     volumes.push_back(buildVolume(gctx, volCfg));
0210   }
0211
0212   // Sort the volumes vectors according to the center location, otherwise the
0213   // binning boundaries will fail
0214   std::ranges::sort(volumes, {},
0215                     [&](const auto& v) { return v->center(gctx).x(); });
0216
0217   // Glue volumes
0218   for (unsigned int i = 0; i < volumes.size() - 1; i++) {
0219     volumes[i + 1]->glueTrackingVolume(
0220         gctx, BoundarySurfaceFace::negativeFaceYZ, volumes[i].get(),
0221         BoundarySurfaceFace::positiveFaceYZ);
0222     volumes[i]->glueTrackingVolume(gctx, BoundarySurfaceFace::positiveFaceYZ,
0223                                    volumes[i + 1].get(),
0224                                    BoundarySurfaceFace::negativeFaceYZ);
0225   }
0226
0227   // Translation
0228   Transform3 trafo(Transform3::Identity());
0229   trafo.translation() = m_cfg.position;
0230
0231   // Size of the volume
0232   auto volumeBounds = std::make_shared<CuboidVolumeBounds>(
0233       m_cfg.length.x() * 0.5, m_cfg.length.y() * 0.5, m_cfg.length.z() * 0.5);
0234
0235   // Build vector of confined volumes
0236   std::vector<std::pair<TrackingVolumePtr, Vector3>> tapVec;
0237   tapVec.reserve(m_cfg.volumeCfg.size());
0238   for (auto& tVol : volumes) {
0239     tapVec.push_back(std::make_pair(tVol, tVol->center(gctx)));
0240   }
0241
0242   // Set bin boundaries along binning
0243   std::vector<float> binBoundaries;
0244   binBoundaries.push_back(volumes[0]->center(gctx).x() -
0245                           m_cfg.volumeCfg[0].length.x() * 0.5);
0246   for (std::size_t i = 0; i < volumes.size(); i++) {
0247     binBoundaries.push_back(volumes[i]->center(gctx).x() +
0248                             m_cfg.volumeCfg[i].length.x() * 0.5);
0249   }
0250
0251   // Build binning
0252   BinningData binData(BinningOption::open, AxisDirection::AxisX, binBoundaries);
0253   auto bu = std::make_unique<const BinUtility>(binData);
0254
0255   // Build TrackingVolume array
0256   std::shared_ptr<const TrackingVolumeArray> trVolArr(
0257       new BinnedArrayXD<TrackingVolumePtr>(tapVec, std::move(bu)));
0258
0259   // Create world volume
0260   MutableTrackingVolumePtr mtvp(std::make_shared<TrackingVolume>(
0261       trafo, volumeBounds, nullptr, nullptr, trVolArr,
0262       MutableTrackingVolumeVector{}, "World"));
0263
0264   return mtvp;
0265 }
0266
0267 }  // namespace Acts