Core/Detector/CuboidalDetectorHelperTests.cpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 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 <boost/test/unit_test.hpp>
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Detector/DetectorVolume.hpp"
0013 #include "Acts/Detector/PortalGenerators.hpp"
0014 #include "Acts/Detector/detail/CuboidalDetectorHelper.hpp"
0015 #include "Acts/Geometry/CuboidVolumeBounds.hpp"
0016 #include "Acts/Geometry/GeometryContext.hpp"
0017 #include "Acts/Navigation/SurfaceCandidatesUpdaters.hpp"
0018 #include "Acts/Utilities/BinningData.hpp"
0019 #include "Acts/Utilities/StringHelpers.hpp"
0020 #include "Acts/Visualization/GeometryView3D.hpp"
0021 #include "Acts/Visualization/ObjVisualization3D.hpp"
0022
0023 #include <array>
0024 #include <memory>
0025 #include <stdexcept>
0026
0027 auto portalGenerator = Acts::Experimental::defaultPortalGenerator();
0028 auto tContext = Acts::GeometryContext();
0029
0030 BOOST_AUTO_TEST_SUITE(Experimental)
0031
0032 BOOST_AUTO_TEST_CASE(CubicVolumeExceptions) {
0033   // A perfect box shape
0034   auto box = std::make_shared<Acts::CuboidVolumeBounds>(10, 10, 10);
0035
0036   // Create volume A
0037   auto volumeA = Acts::Experimental::DetectorVolumeFactory::construct(
0038       portalGenerator, tContext, "VolumeA", Acts::Transform3::Identity(), box,
0039       Acts::Experimental::tryAllPortals());
0040
0041   // Create volume B
0042   auto transformB = Acts::Transform3::Identity();
0043   transformB.prerotate(Acts::AngleAxis3(0.234, Acts::Vector3::UnitZ()));
0044
0045   auto volumeB = Acts::Experimental::DetectorVolumeFactory::construct(
0046       portalGenerator, tContext, "volumeB", transformB, box,
0047       Acts::Experimental::tryAllPortals());
0048   // Build the container
0049   std::vector<std::shared_ptr<Acts::Experimental::DetectorVolume>> volumes = {
0050       volumeA, volumeB};
0051
0052   BOOST_CHECK_THROW(
0053       Acts::Experimental::detail::CuboidalDetectorHelper::connect(
0054           tContext, volumes, Acts::binX, {}, Acts::Logging::VERBOSE),
0055       std::invalid_argument);
0056 }
0057
0058 BOOST_AUTO_TEST_CASE(SimpleBoxConnection) {
0059   std::array<Acts::BinningValue, 3> binningValues = {Acts::binX, Acts::binY,
0060                                                      Acts::binZ};
0061   for (auto bVal : binningValues) {
0062     // A perfect box shape
0063     auto box = std::make_shared<Acts::CuboidVolumeBounds>(10, 10, 10);
0064
0065     // Create volume A
0066     auto volumeA = Acts::Experimental::DetectorVolumeFactory::construct(
0067         portalGenerator, tContext, "VolumeA", Acts::Transform3::Identity(), box,
0068         Acts::Experimental::tryAllPortals());
0069
0070     // Move it into the bval direction
0071     auto transformB = Acts::Transform3::Identity();
0072
0073     Acts::Vector3 translation = Acts::Vector3::Zero();
0074     translation[bVal] = 20;
0075     transformB.pretranslate(translation);
0076     // Create volume B
0077     auto volumeB = Acts::Experimental::DetectorVolumeFactory::construct(
0078         portalGenerator, tContext, "VolumeB", transformB, box,
0079         Acts::Experimental::tryAllPortals());
0080     // Build the container
0081     std::vector<std::shared_ptr<Acts::Experimental::DetectorVolume>> volumes = {
0082         volumeA, volumeB};
0083     auto container =
0084         Acts::Experimental::detail::CuboidalDetectorHelper::connect(
0085             tContext, volumes, bVal, {}, Acts::Logging::VERBOSE);
0086
0087     // Check the container is constructed
0088     BOOST_CHECK(!container.empty());
0089
0090     Acts::ObjVisualization3D obj;
0091     Acts::GeometryView3D::drawDetectorVolume(obj, *volumeA, tContext);
0092     Acts::GeometryView3D::drawDetectorVolume(obj, *volumeB, tContext);
0093     obj.write("ConnectectBoxesRegular_" + Acts::binningValueNames()[bVal] +
0094               ".obj");
0095   }
0096 }
0097
0098 BOOST_AUTO_TEST_CASE(IrregularBoxConnectionInZ) {
0099   std::vector<Acts::BinningValue> binningValues = {Acts::binX, Acts::binY,
0100                                                    Acts::binZ};
0101
0102   using HlPos = std::array<Acts::ActsScalar, 2u>;
0103   using VolHlPos = std::array<HlPos, 3u>;
0104   using VolSetup = std::array<VolHlPos, 3u>;
0105
0106   VolHlPos cPA = {{{10., 0.}, {10., 0.}, {10., 0.}}};
0107   VolHlPos cPB = {{{20., 0.}, {20., 0.}, {20., 0.}}};
0108   VolHlPos sP = {{{10., -30.}, {30., 10.}, {90., 130.}}};
0109
0110   std::array<VolSetup, 3u> volSetups = {
0111       {{sP, cPA, cPB}, {cPB, sP, cPA}, {cPA, cPB, sP}}};
0112
0113   std::array<Acts::Transform3, 2u> transforms = {
0114       Acts::Transform3::Identity(),
0115       Acts::Transform3(Acts::Transform3::Identity())
0116           .prerotate(
0117               Acts::AngleAxis3(0.34, Acts::Vector3(1., 1., 1.).normalized()))};
0118
0119   // Try with arbitrary rotations
0120   for (auto [it, t] : Acts::enumerate(transforms)) {
0121     std::string trstr = it == 0 ? "" : "_rotated";
0122     auto rotation = t.rotation();
0123     // Try for all binning values
0124     for (auto bVal : binningValues) {
0125       auto [vsA, vsB, vsC] = volSetups[bVal];
0126
0127       // Three box shares with different length in Z
0128       auto boxA = std::make_shared<Acts::CuboidVolumeBounds>(
0129           vsA[0][0], vsB[0][0], vsC[0][0]);
0130       auto boxB = std::make_shared<Acts::CuboidVolumeBounds>(
0131           vsA[1][0], vsB[1][0], vsC[1][0]);
0132       auto boxC = std::make_shared<Acts::CuboidVolumeBounds>(
0133           vsA[2][0], vsB[2][0], vsC[2][0]);
0134
0135       auto transformA = Acts::Transform3::Identity();
0136       auto transformB = Acts::Transform3::Identity();
0137       auto transformC = Acts::Transform3::Identity();
0138
0139       transformA.pretranslate(Acts::Vector3(vsA[0][1], vsB[0][1], vsC[0][1]));
0140       transformB.pretranslate(Acts::Vector3(vsA[1][1], vsB[1][1], vsC[1][1]));
0141       transformC.pretranslate(Acts::Vector3(vsA[2][1], vsB[2][1], vsC[2][1]));
0142
0143       transformA.prerotate(rotation);
0144       transformB.prerotate(rotation);
0145       transformC.prerotate(rotation);
0146
0147       // Create volume A, B, C
0148       auto volumeA = Acts::Experimental::DetectorVolumeFactory::construct(
0149           portalGenerator, tContext, "VolumeA", transformA, boxA,
0150           Acts::Experimental::tryAllPortals());
0151       auto volumeB = Acts::Experimental::DetectorVolumeFactory::construct(
0152           portalGenerator, tContext, "VolumeB", transformB, boxB,
0153           Acts::Experimental::tryAllPortals());
0154       auto volumeC = Acts::Experimental::DetectorVolumeFactory::construct(
0155           portalGenerator, tContext, "VolumeC", transformC, boxC,
0156           Acts::Experimental::tryAllPortals());
0157
0158       // Build the container
0159       std::vector<std::shared_ptr<Acts::Experimental::DetectorVolume>> volumes =
0160           {volumeA, volumeB, volumeC};
0161       auto container =
0162           Acts::Experimental::detail::CuboidalDetectorHelper::connect(
0163               tContext, volumes, bVal, {}, Acts::Logging::VERBOSE);
0164
0165       // Check the container is constructed
0166       BOOST_CHECK(!container.empty());
0167
0168       Acts::ObjVisualization3D obj;
0169       Acts::GeometryView3D::drawDetectorVolume(obj, *volumeA, tContext);
0170       Acts::GeometryView3D::drawDetectorVolume(obj, *volumeB, tContext);
0171       Acts::GeometryView3D::drawDetectorVolume(obj, *volumeC, tContext);
0172       obj.write("ConnectectBoxesIrregular_" + Acts::binningValueNames()[bVal] +
0173                 trstr + ".obj");
0174     }
0175   }
0176 }
0177
0178 BOOST_AUTO_TEST_CASE(ContainerConnection) {
0179   // A perfect box shape
0180   auto box = std::make_shared<Acts::CuboidVolumeBounds>(10, 10, 10);
0181
0182   // Create an AB container
0183
0184   // Create volume A
0185   auto volumeA = Acts::Experimental::DetectorVolumeFactory::construct(
0186       portalGenerator, tContext, "VolumeA", Acts::Transform3::Identity(), box,
0187       Acts::Experimental::tryAllPortals());
0188
0189   // Move it into the bval direction
0190   auto transformB = Acts::Transform3::Identity();
0191   Acts::Vector3 translationB = Acts::Vector3::Zero();
0192   translationB[Acts::binX] = 20;
0193   transformB.pretranslate(translationB);
0194   // Create volume B
0195   auto volumeB = Acts::Experimental::DetectorVolumeFactory::construct(
0196       portalGenerator, tContext, "VolumeB", transformB, box,
0197       Acts::Experimental::tryAllPortals());
0198   // Build the container
0199   std::vector<std::shared_ptr<Acts::Experimental::DetectorVolume>> volumes = {
0200       volumeA, volumeB};
0201   auto containerAB =
0202       Acts::Experimental::detail::CuboidalDetectorHelper::connect(
0203           tContext, volumes, Acts::binX, {}, Acts::Logging::VERBOSE);
0204
0205   // Create a CD container
0206
0207   auto transformC = Acts::Transform3::Identity();
0208   Acts::Vector3 translationC = Acts::Vector3::Zero();
0209   translationC[Acts::binY] = 20;
0210   transformC.pretranslate(translationC);
0211
0212   auto volumeC = Acts::Experimental::DetectorVolumeFactory::construct(
0213       portalGenerator, tContext, "VolumeC", transformC, box,
0214       Acts::Experimental::tryAllPortals());
0215
0216   auto transformD = Acts::Transform3::Identity();
0217   Acts::Vector3 translationD = Acts::Vector3::Zero();
0218   translationD[Acts::binX] = 20;
0219   translationD[Acts::binY] = 20;
0220   transformD.pretranslate(translationD);
0221
0222   auto volumeD = Acts::Experimental::DetectorVolumeFactory::construct(
0223       portalGenerator, tContext, "VolumeD", transformD, box,
0224       Acts::Experimental::tryAllPortals());
0225
0226   volumes = {volumeC, volumeD};
0227   auto containerCD =
0228       Acts::Experimental::detail::CuboidalDetectorHelper::connect(
0229           tContext, volumes, Acts::binX, {}, Acts::Logging::VERBOSE);
0230
0231   auto containerABCD =
0232       Acts::Experimental::detail::CuboidalDetectorHelper::connect(
0233           tContext, {containerAB, containerCD}, Acts::binY, {},
0234           Acts::Logging::VERBOSE);
0235
0236   // Check the container is constructed
0237   BOOST_CHECK(!containerABCD.empty());
0238
0239   Acts::ObjVisualization3D obj;
0240   Acts::GeometryView3D::drawDetectorVolume(obj, *volumeA, tContext);
0241   Acts::GeometryView3D::drawDetectorVolume(obj, *volumeB, tContext);
0242   Acts::GeometryView3D::drawDetectorVolume(obj, *volumeC, tContext);
0243   Acts::GeometryView3D::drawDetectorVolume(obj, *volumeD, tContext);
0244
0245   obj.write("ConnectContainers_binX.obj");
0246 }
0247
0248 BOOST_AUTO_TEST_SUITE_END()