Python/src/Material.cpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2021 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/Geometry/GeometryContext.hpp"
0010 #include "Acts/MagneticField/MagneticFieldContext.hpp"
0011 #include "Acts/Material/BinnedSurfaceMaterialAccumulater.hpp"
0012 #include "Acts/Material/IMaterialDecorator.hpp"
0013 #include "Acts/Material/IntersectionMaterialAssigner.hpp"
0014 #include "Acts/Material/MaterialMapper.hpp"
0015 #include "Acts/Material/PropagatorMaterialAssigner.hpp"
0016 #include "Acts/Material/SurfaceMaterialMapper.hpp"
0017 #include "Acts/Material/VolumeMaterialMapper.hpp"
0018 #include "Acts/Plugins/Python/Utilities.hpp"
0019 #include "Acts/Utilities/Logger.hpp"
0020 #include "ActsExamples/Framework/ProcessCode.hpp"
0021 #include "ActsExamples/Io/Root/RootMaterialDecorator.hpp"
0022 #include "ActsExamples/MaterialMapping/CoreMaterialMapping.hpp"
0023 #include "ActsExamples/MaterialMapping/MappingMaterialDecorator.hpp"
0024 #include "ActsExamples/MaterialMapping/MaterialMapping.hpp"
0025
0026 #include <array>
0027 #include <map>
0028 #include <memory>
0029 #include <tuple>
0030 #include <utility>
0031 #include <vector>
0032
0033 #include <pybind11/pybind11.h>
0034 #include <pybind11/stl.h>
0035
0036 namespace Acts {
0037 class TrackingGeometry;
0038 }  // namespace Acts
0039 namespace ActsExamples {
0040 class IAlgorithm;
0041 }  // namespace ActsExamples
0042
0043 namespace py = pybind11;
0044 using namespace pybind11::literals;
0045
0046 using namespace ActsExamples;
0047
0048 namespace Acts::Python {
0049 void addMaterial(Context& ctx) {
0050   auto [m, mex] = ctx.get("main", "examples");
0051   {
0052     py::class_<Acts::IMaterialDecorator,
0053                std::shared_ptr<Acts::IMaterialDecorator>>(m,
0054                                                           "IMaterialDecorator");
0055   }
0056
0057   {
0058     auto rmd =
0059         py::class_<RootMaterialDecorator, Acts::IMaterialDecorator,
0060                    std::shared_ptr<RootMaterialDecorator>>(
0061             mex, "RootMaterialDecorator")
0062             .def(
0063                 py::init<RootMaterialDecorator::Config, Acts::Logging::Level>(),
0064                 py::arg("config"), py::arg("level"));
0065
0066     using Config = RootMaterialDecorator::Config;
0067     auto c = py::class_<Config>(rmd, "Config").def(py::init<>());
0068
0069     ACTS_PYTHON_STRUCT_BEGIN(c, Config);
0070     ACTS_PYTHON_MEMBER(voltag);
0071     ACTS_PYTHON_MEMBER(boutag);
0072     ACTS_PYTHON_MEMBER(laytag);
0073     ACTS_PYTHON_MEMBER(apptag);
0074     ACTS_PYTHON_MEMBER(sentag);
0075     ACTS_PYTHON_MEMBER(ntag);
0076     ACTS_PYTHON_MEMBER(vtag);
0077     ACTS_PYTHON_MEMBER(otag);
0078     ACTS_PYTHON_MEMBER(mintag);
0079     ACTS_PYTHON_MEMBER(maxtag);
0080     ACTS_PYTHON_MEMBER(ttag);
0081     ACTS_PYTHON_MEMBER(x0tag);
0082     ACTS_PYTHON_MEMBER(l0tag);
0083     ACTS_PYTHON_MEMBER(atag);
0084     ACTS_PYTHON_MEMBER(ztag);
0085     ACTS_PYTHON_MEMBER(rhotag);
0086     ACTS_PYTHON_MEMBER(fileName);
0087     ACTS_PYTHON_STRUCT_END();
0088   }
0089
0090   {
0091     py::class_<MappingMaterialDecorator, Acts::IMaterialDecorator,
0092                std::shared_ptr<MappingMaterialDecorator>>(
0093         m, "MappingMaterialDecorator")
0094         .def(py::init<const Acts::TrackingGeometry&, Acts::Logging::Level, bool,
0095                       bool>(),
0096              py::arg("tGeometry"), py::arg("level"),
0097              py::arg("clearSurfaceMaterial") = true,
0098              py::arg("clearVolumeMaterial") = true)
0099         .def("binningMap", &MappingMaterialDecorator::binningMap)
0100         .def("setBinningMap", &MappingMaterialDecorator::setBinningMap);
0101   }
0102
0103   {
0104     using Alg = ActsExamples::MaterialMapping;
0105
0106     auto alg = py::class_<Alg, ActsExamples::IAlgorithm, std::shared_ptr<Alg>>(
0107                    mex, "MaterialMapping")
0108                    .def(py::init<const Alg::Config&, Acts::Logging::Level>(),
0109                         py::arg("config"), py::arg("level"))
0110                    .def("scoringParameters", &Alg::scoringParameters)
0111                    .def_property_readonly("config", &Alg::config);
0112
0113     auto c = py::class_<Alg::Config>(alg, "Config")
0114                  .def(py::init<const Acts::GeometryContext&,
0115                                const Acts::MagneticFieldContext&>());
0116
0117     ACTS_PYTHON_STRUCT_BEGIN(c, Alg::Config);
0118     ACTS_PYTHON_MEMBER(inputMaterialTracks);
0119     ACTS_PYTHON_MEMBER(mappingMaterialCollection);
0120     ACTS_PYTHON_MEMBER(materialSurfaceMapper);
0121     ACTS_PYTHON_MEMBER(materialVolumeMapper);
0122     ACTS_PYTHON_MEMBER(materialWriters);
0123     ACTS_PYTHON_MEMBER(trackingGeometry);
0124     ACTS_PYTHON_MEMBER(geoContext);
0125     ACTS_PYTHON_MEMBER(magFieldContext);
0126     ACTS_PYTHON_STRUCT_END();
0127   }
0128
0129   {
0130     auto cls =
0131         py::class_<SurfaceMaterialMapper,
0132                    std::shared_ptr<SurfaceMaterialMapper>>(
0133             m, "SurfaceMaterialMapper")
0134             .def(py::init([](const SurfaceMaterialMapper::Config& config,
0135                              SurfaceMaterialMapper::StraightLinePropagator prop,
0136                              Acts::Logging::Level level) {
0137                    return std::make_shared<SurfaceMaterialMapper>(
0138                        config, std::move(prop),
0139                        getDefaultLogger("SurfaceMaterialMapper", level));
0140                  }),
0141                  py::arg("config"), py::arg("propagator"), py::arg("level"));
0142
0143     auto c = py::class_<SurfaceMaterialMapper::Config>(cls, "Config")
0144                  .def(py::init<>());
0145     ACTS_PYTHON_STRUCT_BEGIN(c, SurfaceMaterialMapper::Config);
0146     ACTS_PYTHON_MEMBER(etaRange);
0147     ACTS_PYTHON_MEMBER(emptyBinCorrection);
0148     ACTS_PYTHON_MEMBER(mapperDebugOutput);
0149     ACTS_PYTHON_MEMBER(computeVariance);
0150     ACTS_PYTHON_STRUCT_END();
0151   }
0152
0153   {
0154     auto cls =
0155         py::class_<VolumeMaterialMapper, std::shared_ptr<VolumeMaterialMapper>>(
0156             m, "VolumeMaterialMapper")
0157             .def(py::init([](const VolumeMaterialMapper::Config& config,
0158                              VolumeMaterialMapper::StraightLinePropagator prop,
0159                              Acts::Logging::Level level) {
0160                    return std::make_shared<VolumeMaterialMapper>(
0161                        config, std::move(prop),
0162                        getDefaultLogger("VolumeMaterialMapper", level));
0163                  }),
0164                  py::arg("config"), py::arg("propagator"), py::arg("level"));
0165
0166     auto c = py::class_<VolumeMaterialMapper::Config>(cls, "Config")
0167                  .def(py::init<>());
0168     ACTS_PYTHON_STRUCT_BEGIN(c, VolumeMaterialMapper::Config);
0169     ACTS_PYTHON_MEMBER(mappingStep);
0170     ACTS_PYTHON_STRUCT_END();
0171   }
0172
0173   {
0174     py::class_<Acts::IAssignmentFinder,
0175                std::shared_ptr<Acts::IAssignmentFinder>>(m,
0176                                                          "IAssignmentFinder");
0177   }
0178
0179   {
0180     auto isma =
0181         py::class_<Acts::IntersectionMaterialAssigner, Acts::IAssignmentFinder,
0182                    std::shared_ptr<Acts::IntersectionMaterialAssigner>>(
0183             m, "IntersectionMaterialAssigner")
0184             .def(py::init([](const Acts::IntersectionMaterialAssigner::Config&
0185                                  config,
0186                              Acts::Logging::Level level) {
0187                    return std::make_shared<Acts::IntersectionMaterialAssigner>(
0188                        config,
0189                        getDefaultLogger("IntersectionMaterialAssigner", level));
0190                  }),
0191                  py::arg("config"), py::arg("level"))
0192             .def("assignmentCandidates",
0193                  &Acts::IntersectionMaterialAssigner::assignmentCandidates);
0194
0195     auto c =
0196         py::class_<Acts::IntersectionMaterialAssigner::Config>(isma, "Config")
0197             .def(py::init<>());
0198     ACTS_PYTHON_STRUCT_BEGIN(c, Acts::IntersectionMaterialAssigner::Config);
0199     ACTS_PYTHON_MEMBER(surfaces);
0200     ACTS_PYTHON_MEMBER(trackingVolumes);
0201     ACTS_PYTHON_MEMBER(detectorVolumes);
0202     ACTS_PYTHON_STRUCT_END();
0203   }
0204
0205   {
0206     py::class_<Acts::ISurfaceMaterialAccumulater,
0207                std::shared_ptr<Acts::ISurfaceMaterialAccumulater>>(
0208         m, "ISurfaceMaterialAccumulater");
0209   }
0210
0211   {
0212     auto bsma =
0213         py::class_<BinnedSurfaceMaterialAccumulater,
0214                    ISurfaceMaterialAccumulater,
0215                    std::shared_ptr<BinnedSurfaceMaterialAccumulater>>(
0216             m, "BinnedSurfaceMaterialAccumulater")
0217             .def(
0218                 py::init(
0219                     [](const BinnedSurfaceMaterialAccumulater::Config& config,
0220                        Acts::Logging::Level level) {
0221                       return std::make_shared<BinnedSurfaceMaterialAccumulater>(
0222                           config,
0223                           getDefaultLogger("BinnedSurfaceMaterialAccumulater",
0224                                            level));
0225                     }),
0226                 py::arg("config"), py::arg("level"))
0227             .def("createState", &BinnedSurfaceMaterialAccumulater::createState)
0228             .def("accumulate", &BinnedSurfaceMaterialAccumulater::accumulate)
0229             .def("finalizeMaterial",
0230                  &BinnedSurfaceMaterialAccumulater::finalizeMaterial);
0231
0232     auto c =
0233         py::class_<BinnedSurfaceMaterialAccumulater::Config>(bsma, "Config")
0234             .def(py::init<>());
0235     ACTS_PYTHON_STRUCT_BEGIN(c, BinnedSurfaceMaterialAccumulater::Config);
0236     ACTS_PYTHON_MEMBER(emptyBinCorrection);
0237     ACTS_PYTHON_MEMBER(materialSurfaces);
0238     ACTS_PYTHON_STRUCT_END();
0239   }
0240
0241   {
0242     auto mm = py::class_<MaterialMapper, std::shared_ptr<MaterialMapper>>(
0243                   m, "MaterialMapper")
0244                   .def(py::init([](const MaterialMapper::Config& config,
0245                                    Acts::Logging::Level level) {
0246                          return std::make_shared<MaterialMapper>(
0247                              config, getDefaultLogger("MaterialMapper", level));
0248                        }),
0249                        py::arg("config"), py::arg("level"));
0250
0251     auto c = py::class_<MaterialMapper::Config>(mm, "Config").def(py::init<>());
0252     ACTS_PYTHON_STRUCT_BEGIN(c, MaterialMapper::Config);
0253     ACTS_PYTHON_MEMBER(assignmentFinder);
0254     ACTS_PYTHON_MEMBER(surfaceMaterialAccumulater);
0255     ACTS_PYTHON_STRUCT_END();
0256   }
0257
0258   {
0259     auto mmca = py::class_<CoreMaterialMapping, IAlgorithm,
0260                            std::shared_ptr<CoreMaterialMapping>>(
0261                     mex, "CoreMaterialMapping")
0262                     .def(py::init<const CoreMaterialMapping::Config&,
0263                                   Acts::Logging::Level>(),
0264                          py::arg("config"), py::arg("level"));
0265
0266     auto c = py::class_<CoreMaterialMapping::Config>(mmca, "Config")
0267                  .def(py::init<>());
0268     ACTS_PYTHON_STRUCT_BEGIN(c, CoreMaterialMapping::Config);
0269     ACTS_PYTHON_MEMBER(inputMaterialTracks);
0270     ACTS_PYTHON_MEMBER(mappedMaterialTracks);
0271     ACTS_PYTHON_MEMBER(unmappedMaterialTracks);
0272     ACTS_PYTHON_MEMBER(materialMapper);
0273     ACTS_PYTHON_MEMBER(materiaMaplWriters);
0274     ACTS_PYTHON_STRUCT_END();
0275   }
0276 }
0277
0278 }  // namespace Acts::Python