Algorithms/MaterialMapping/MaterialMappingTests.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 <boost/test/unit_test.hpp>
0010
0011 #include "Acts/Material/BinnedSurfaceMaterialAccumulator.hpp"
0012 #include "Acts/Material/IntersectionMaterialAssigner.hpp"
0013 #include "Acts/Material/ProtoSurfaceMaterial.hpp"
0014 #include "Acts/Surfaces/CylinderSurface.hpp"
0015 #include "ActsExamples/Framework/Sequencer.hpp"
0016 #include "ActsExamples/MaterialMapping/MaterialMapping.hpp"
0017
0018 using namespace Acts;
0019 using namespace ActsExamples;
0020
0021 namespace {
0022 class RecordingWriter final : public IMaterialWriter {
0023  public:
0024   void writeMaterial(const TrackingGeometryMaterial& material) override {
0025     ++calls;
0026     result = material;
0027   }
0028   unsigned int calls = 0;
0029   TrackingGeometryMaterial result;
0030 };
0031 class EmptyMaterialTracks final : public IAlgorithm {
0032  public:
0033   EmptyMaterialTracks() : IAlgorithm("EmptyMaterialTracks") {
0034     m_output.initialize("material_tracks");
0035   }
0036
0037   ProcessCode execute(const AlgorithmContext& context) const override {
0038     m_output(context, {});
0039     return ProcessCode::SUCCESS;
0040   }
0041
0042  private:
0043   WriteDataHandle<std::unordered_map<std::size_t, RecordedMaterialTrack>>
0044       m_output{this, "MaterialTracks"};
0045 };
0046 }  // namespace
0047
0048 BOOST_AUTO_TEST_CASE(FinalizedMaterialIsAvailableBeforeDestruction) {
0049   auto surface =
0050       Surface::makeShared<CylinderSurface>(Transform3::Identity(), 30., 100.);
0051   surface->assignGeometryId(GeometryIdentifier().withSensitive(1));
0052   surface->assignSurfaceMaterial(std::make_shared<ProtoGridSurfaceMaterial>(
0053       MultiAxisSpec2D(
0054           {AxisSpec::DeferredEquidistant(1), AxisSpec::DeferredEquidistant(1)}),
0055       MappingType::Default, "cylinder"));
0056   BinnedSurfaceMaterialAccumulator::Config accumulatorConfig;
0057   accumulatorConfig.materialSurfaces = {surface.get()};
0058   MaterialMapper::Config mapperConfig;
0059   mapperConfig.assignmentFinder =
0060       std::make_shared<IntersectionMaterialAssigner>(
0061           IntersectionMaterialAssigner::Config{});
0062   mapperConfig.surfaceMaterialAccumulator =
0063       std::make_shared<BinnedSurfaceMaterialAccumulator>(accumulatorConfig);
0064   MaterialMapping::Config config;
0065   config.materialMapper = std::make_shared<MaterialMapper>(mapperConfig);
0066   auto writer = std::make_shared<RecordingWriter>();
0067   config.materialWriters = {writer};
0068   {
0069     auto mapping = std::make_shared<MaterialMapping>(config);
0070     BOOST_CHECK_THROW(mapping->material(), std::logic_error);
0071     Sequencer::Config sequenceConfig;
0072     sequenceConfig.events = 1;
0073     sequenceConfig.numThreads = 1;
0074     sequenceConfig.trackFpes = false;
0075     Sequencer sequencer(sequenceConfig);
0076     sequencer.addAlgorithm(std::make_shared<EmptyMaterialTracks>());
0077     sequencer.addAlgorithm(mapping);
0078     BOOST_CHECK_EQUAL(sequencer.run(), EXIT_SUCCESS);
0079     BOOST_CHECK_EQUAL(writer->calls, 1);
0080     BOOST_REQUIRE_EQUAL(mapping->material().keyedSurfaces.size(), 1);
0081     BOOST_CHECK(mapping->material().keyedSurfaces.at("cylinder").material ==
0082                 writer->result.keyedSurfaces.at("cylinder").material);
0083   }
0084   BOOST_CHECK_EQUAL(writer->calls, 1);
0085   // An algorithm that never ran must not finalize or write during destruction.
0086   {
0087     MaterialMapping unused(config);
0088   }
0089   BOOST_CHECK_EQUAL(writer->calls, 1);
0090 }