Core/src/Material.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/GeometryContext.hpp"
0010 #include "Acts/Material/BinnedSurfaceMaterialAccumulater.hpp"
0011 #include "Acts/Material/HomogeneousSurfaceMaterial.hpp"
0012 #include "Acts/Material/IMaterialDecorator.hpp"
0013 #include "Acts/Material/ISurfaceMaterial.hpp"
0014 #include "Acts/Material/IVolumeMaterial.hpp"
0015 #include "Acts/Material/IntersectionMaterialAssigner.hpp"
0016 #include "Acts/Material/MaterialMapper.hpp"
0017 #include "Acts/Material/MaterialValidater.hpp"
0018 #include "Acts/Material/PropagatorMaterialAssigner.hpp"
0019 #include "Acts/Material/ProtoSurfaceMaterial.hpp"
0020 #include "Acts/Material/SurfaceMaterialMapper.hpp"
0021 #include "Acts/Material/VolumeMaterialMapper.hpp"
0022 #include "Acts/Utilities/Logger.hpp"
0023 #include "ActsPlugins/Json/ActsJson.hpp"
0024 #include "ActsPlugins/Json/MaterialMapJsonConverter.hpp"
0025 #include "ActsPython/Utilities/Helpers.hpp"
0026 #include "ActsPython/Utilities/Macros.hpp"
0027
0028 #include <array>
0029 #include <map>
0030 #include <memory>
0031 #include <tuple>
0032 #include <utility>
0033 #include <vector>
0034
0035 #include <pybind11/pybind11.h>
0036 #include <pybind11/stl.h>
0037
0038 namespace Acts {
0039 class TrackingGeometry;
0040 }  // namespace Acts
0041
0042 namespace py = pybind11;
0043 using namespace pybind11::literals;
0044
0045 using namespace Acts;
0046
0047 namespace ActsPython {
0048
0049 /// @brief Add the material bindings to a module.
0050 /// @param m the module to add the bindings to
0051 void addMaterial(py::module_& m) {
0052   {
0053     py::class_<ISurfaceMaterial, std::shared_ptr<ISurfaceMaterial>>(
0054         m, "ISurfaceMaterial")
0055         .def("toString", &ISurfaceMaterial::toString);
0056
0057     py::class_<ProtoGridSurfaceMaterial, ISurfaceMaterial,
0058                std::shared_ptr<ProtoGridSurfaceMaterial>>(
0059         m, "ProtoGridSurfaceMaterial");
0060
0061     py::class_<ProtoSurfaceMaterial, ISurfaceMaterial,
0062                std::shared_ptr<ProtoSurfaceMaterial>>(m,
0063                                                       "ProtoSurfaceMaterial");
0064
0065     py::class_<HomogeneousSurfaceMaterial, ISurfaceMaterial,
0066                std::shared_ptr<HomogeneousSurfaceMaterial>>(
0067         m, "HomogeneousSurfaceMaterial");
0068
0069     py::class_<IVolumeMaterial, std::shared_ptr<IVolumeMaterial>>(
0070         m, "IVolumeMaterial");
0071   }
0072
0073   {
0074     py::class_<IMaterialDecorator, std::shared_ptr<IMaterialDecorator>>(
0075         m, "IMaterialDecorator")
0076         .def("decorate", py::overload_cast<Surface&>(
0077                              &IMaterialDecorator::decorate, py::const_));
0078   }
0079
0080   {
0081     auto cls =
0082         py::class_<SurfaceMaterialMapper,
0083                    std::shared_ptr<SurfaceMaterialMapper>>(
0084             m, "SurfaceMaterialMapper")
0085             .def(py::init([](const SurfaceMaterialMapper::Config& config,
0086                              SurfaceMaterialMapper::StraightLinePropagator prop,
0087                              Logging::Level level) {
0088                    return std::make_shared<SurfaceMaterialMapper>(
0089                        config, std::move(prop),
0090                        getDefaultLogger("SurfaceMaterialMapper", level));
0091                  }),
0092                  py::arg("config"), py::arg("propagator"), py::arg("level"));
0093
0094     auto c = py::class_<SurfaceMaterialMapper::Config>(cls, "Config")
0095                  .def(py::init<>());
0096     ACTS_PYTHON_STRUCT(c, etaRange, emptyBinCorrection, mapperDebugOutput,
0097                        computeVariance);
0098   }
0099
0100   {
0101     auto cls =
0102         py::class_<VolumeMaterialMapper, std::shared_ptr<VolumeMaterialMapper>>(
0103             m, "VolumeMaterialMapper")
0104             .def(py::init([](const VolumeMaterialMapper::Config& config,
0105                              VolumeMaterialMapper::StraightLinePropagator prop,
0106                              Logging::Level level) {
0107                    return std::make_shared<VolumeMaterialMapper>(
0108                        config, std::move(prop),
0109                        getDefaultLogger("VolumeMaterialMapper", level));
0110                  }),
0111                  py::arg("config"), py::arg("propagator"), py::arg("level"));
0112
0113     auto c = py::class_<VolumeMaterialMapper::Config>(cls, "Config")
0114                  .def(py::init<>());
0115     ACTS_PYTHON_STRUCT(c, mappingStep);
0116   }
0117
0118   {
0119     py::class_<IAssignmentFinder, std::shared_ptr<IAssignmentFinder>>(
0120         m, "IAssignmentFinder");
0121   }
0122
0123   {
0124     auto isma =
0125         py::class_<IntersectionMaterialAssigner, IAssignmentFinder,
0126                    std::shared_ptr<IntersectionMaterialAssigner>>(
0127             m, "IntersectionMaterialAssigner")
0128             .def(py::init([](const IntersectionMaterialAssigner::Config& config,
0129                              Logging::Level level) {
0130                    return std::make_shared<IntersectionMaterialAssigner>(
0131                        config,
0132                        getDefaultLogger("IntersectionMaterialAssigner", level));
0133                  }),
0134                  py::arg("config"), py::arg("level"))
0135             .def("assignmentCandidates",
0136                  &IntersectionMaterialAssigner::assignmentCandidates);
0137
0138     auto c = py::class_<IntersectionMaterialAssigner::Config>(isma, "Config")
0139                  .def(py::init<>());
0140     ACTS_PYTHON_STRUCT(c, surfaces, trackingVolumes, detectorVolumes);
0141   }
0142
0143   {
0144     py::class_<ISurfaceMaterialAccumulater,
0145                std::shared_ptr<ISurfaceMaterialAccumulater>>(
0146         m, "ISurfaceMaterialAccumulater");
0147   }
0148
0149   {
0150     auto bsma =
0151         py::class_<BinnedSurfaceMaterialAccumulater,
0152                    ISurfaceMaterialAccumulater,
0153                    std::shared_ptr<BinnedSurfaceMaterialAccumulater>>(
0154             m, "BinnedSurfaceMaterialAccumulater")
0155             .def(
0156                 py::init(
0157                     [](const BinnedSurfaceMaterialAccumulater::Config& config,
0158                        Logging::Level level) {
0159                       return std::make_shared<BinnedSurfaceMaterialAccumulater>(
0160                           config,
0161                           getDefaultLogger("BinnedSurfaceMaterialAccumulater",
0162                                            level));
0163                     }),
0164                 py::arg("config"), py::arg("level"))
0165             .def("createState", &BinnedSurfaceMaterialAccumulater::createState)
0166             .def("accumulate", &BinnedSurfaceMaterialAccumulater::accumulate)
0167             .def("finalizeMaterial",
0168                  &BinnedSurfaceMaterialAccumulater::finalizeMaterial);
0169
0170     auto c =
0171         py::class_<BinnedSurfaceMaterialAccumulater::Config>(bsma, "Config")
0172             .def(py::init<>());
0173     ACTS_PYTHON_STRUCT(c, emptyBinCorrection, materialSurfaces);
0174   }
0175
0176   {
0177     auto mm = py::class_<MaterialMapper, std::shared_ptr<MaterialMapper>>(
0178                   m, "MaterialMapper")
0179                   .def(py::init([](const MaterialMapper::Config& config,
0180                                    Logging::Level level) {
0181                          return std::make_shared<MaterialMapper>(
0182                              config, getDefaultLogger("MaterialMapper", level));
0183                        }),
0184                        py::arg("config"), py::arg("level"));
0185
0186     auto c = py::class_<MaterialMapper::Config>(mm, "Config").def(py::init<>());
0187     ACTS_PYTHON_STRUCT(c, assignmentFinder, surfaceMaterialAccumulater);
0188   }
0189
0190   {
0191     auto mvc =
0192         py::class_<MaterialValidater, std::shared_ptr<MaterialValidater>>(
0193             m, "MaterialValidater")
0194             .def(py::init([](const MaterialValidater::Config& config,
0195                              Logging::Level level) {
0196                    return std::make_shared<MaterialValidater>(
0197                        config, getDefaultLogger("MaterialValidater", level));
0198                  }),
0199                  py::arg("config"), py::arg("level"))
0200             .def("recordMaterial", &MaterialValidater::recordMaterial);
0201
0202     auto c =
0203         py::class_<MaterialValidater::Config>(mvc, "Config").def(py::init<>());
0204     ACTS_PYTHON_STRUCT(c, materialAssigner);
0205   }
0206 }
0207
0208 }  // namespace ActsPython