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