Python/src/Detector.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/TrackingGeometry.hpp"
0010 #include "Acts/Material/IMaterialDecorator.hpp"
0011 #include "Acts/Plugins/Python/Utilities.hpp"
0012 #include "Acts/Utilities/BinningType.hpp"
0013 #include "Acts/Utilities/Logger.hpp"
0014 #include "ActsExamples/ContextualDetector/AlignedDetector.hpp"
0015 #include "ActsExamples/Framework/IContextDecorator.hpp"
0016 #include "ActsExamples/GenericDetector/GenericDetector.hpp"
0017 #include "ActsExamples/TGeoDetector/TGeoDetector.hpp"
0018 #include "ActsExamples/TelescopeDetector/TelescopeDetector.hpp"
0019 #include "ActsExamples/Utilities/Options.hpp"
0020
0021 #include <array>
0022 #include <cstddef>
0023 #include <memory>
0024 #include <optional>
0025 #include <string>
0026 #include <tuple>
0027 #include <utility>
0028 #include <vector>
0029
0030 #include <pybind11/pybind11.h>
0031 #include <pybind11/stl.h>
0032
0033 namespace py = pybind11;
0034 using namespace ActsExamples;
0035
0036 namespace Acts::Python {
0037 void addDetector(Context& ctx) {
0038   auto [m, mex] = ctx.get("main", "examples");
0039   {
0040     py::class_<IContextDecorator, std::shared_ptr<IContextDecorator>>(
0041         mex, "IContextDecorator")
0042         .def("decorate", &IContextDecorator::decorate)
0043         .def("name", &IContextDecorator::name);
0044   }
0045
0046   {
0047     using Config = GenericDetector::Config;
0048
0049     auto gd = py::class_<GenericDetector, std::shared_ptr<GenericDetector>>(
0050                   mex, "GenericDetector")
0051                   .def(py::init<>())
0052                   .def("finalize",
0053                        py::overload_cast<
0054                            const Config&,
0055                            std::shared_ptr<const Acts::IMaterialDecorator>>(
0056                            &GenericDetector::finalize));
0057
0058     py::class_<Config>(gd, "Config")
0059         .def(py::init<>())
0060         .def_readwrite("buildLevel", &Config::buildLevel)
0061         .def_readwrite("surfaceLogLevel", &Config::surfaceLogLevel)
0062         .def_readwrite("layerLogLevel", &Config::layerLogLevel)
0063         .def_readwrite("volumeLogLevel", &Config::volumeLogLevel)
0064         .def_readwrite("buildProto", &Config::buildProto);
0065   }
0066
0067   {
0068     using TelescopeDetector = Telescope::TelescopeDetector;
0069     using Config = TelescopeDetector::Config;
0070
0071     auto td =
0072         py::class_<TelescopeDetector, std::shared_ptr<TelescopeDetector>>(
0073             mex, "TelescopeDetector")
0074             .def(py::init<>())
0075             .def("finalize",
0076                  py::overload_cast<
0077                      const Config&,
0078                      const std::shared_ptr<const Acts::IMaterialDecorator>&>(
0079                      &TelescopeDetector::finalize));
0080
0081     py::class_<Config>(td, "Config")
0082         .def(py::init<>())
0083         .def_readwrite("positions", &Config::positions)
0084         .def_readwrite("stereos", &Config::stereos)
0085         .def_readwrite("offsets", &Config::offsets)
0086         .def_readwrite("bounds", &Config::bounds)
0087         .def_readwrite("thickness", &Config::thickness)
0088         .def_readwrite("surfaceType", &Config::surfaceType)
0089         .def_readwrite("binValue", &Config::binValue);
0090   }
0091
0092   {
0093     using AlignedDetector = Contextual::AlignedDetector;
0094     using Config = AlignedDetector::Config;
0095
0096     auto d = py::class_<AlignedDetector, std::shared_ptr<AlignedDetector>>(
0097                  mex, "AlignedDetector")
0098                  .def(py::init<>())
0099                  .def("finalize",
0100                       py::overload_cast<
0101                           const Config&,
0102                           std::shared_ptr<const Acts::IMaterialDecorator>>(
0103                           &AlignedDetector::finalize));
0104
0105     auto c = py::class_<Config, GenericDetector::Config>(d, "Config")
0106                  .def(py::init<>());
0107     ACTS_PYTHON_STRUCT_BEGIN(c, Config);
0108     ACTS_PYTHON_MEMBER(seed);
0109     ACTS_PYTHON_MEMBER(iovSize);
0110     ACTS_PYTHON_MEMBER(flushSize);
0111     ACTS_PYTHON_MEMBER(doGarbageCollection);
0112     ACTS_PYTHON_MEMBER(sigmaInPlane);
0113     ACTS_PYTHON_MEMBER(sigmaOutPlane);
0114     ACTS_PYTHON_MEMBER(sigmaInRot);
0115     ACTS_PYTHON_MEMBER(sigmaOutRot);
0116     ACTS_PYTHON_MEMBER(firstIovNominal);
0117     ACTS_PYTHON_MEMBER(decoratorLogLevel);
0118     ACTS_PYTHON_MEMBER(mode);
0119     ACTS_PYTHON_STRUCT_END();
0120
0121     py::enum_<Config::Mode>(c, "Mode")
0122         .value("Internal", Config::Mode::Internal)
0123         .value("External", Config::Mode::External);
0124   }
0125
0126   {
0127     using Config = TGeoDetector::Config;
0128
0129     auto d = py::class_<TGeoDetector, std::shared_ptr<TGeoDetector>>(
0130                  mex, "TGeoDetector")
0131                  .def(py::init<>())
0132                  .def("finalize",
0133                       py::overload_cast<
0134                           const Config&,
0135                           std::shared_ptr<const Acts::IMaterialDecorator>>(
0136                           &TGeoDetector::finalize));
0137
0138     py::class_<Options::Interval>(mex, "Interval")
0139         .def(py::init<>())
0140         .def(py::init<std::optional<double>, std::optional<double>>())
0141         .def_readwrite("lower", &Options::Interval::lower)
0142         .def_readwrite("upper", &Options::Interval::upper);
0143
0144     auto c = py::class_<Config>(d, "Config").def(py::init<>());
0145
0146     c.def_property(
0147         "jsonFile", nullptr,
0148         [](Config& cfg, const std::string& file) { cfg.readJson(file); });
0149
0150     py::enum_<Config::SubVolume>(c, "SubVolume")
0151         .value("Negative", Config::SubVolume::Negative)
0152         .value("Central", Config::SubVolume::Central)
0153         .value("Positive", Config::SubVolume::Positive);
0154
0155     py::enum_<Acts::BinningType>(c, "BinningType")
0156         .value("equidistant", Acts::BinningType::equidistant)
0157         .value("arbitrary", Acts::BinningType::arbitrary);
0158
0159     auto volume = py::class_<Config::Volume>(c, "Volume").def(py::init<>());
0160     ACTS_PYTHON_STRUCT_BEGIN(volume, Config::Volume);
0161     ACTS_PYTHON_MEMBER(name);
0162     ACTS_PYTHON_MEMBER(binToleranceR);
0163     ACTS_PYTHON_MEMBER(binTolerancePhi);
0164     ACTS_PYTHON_MEMBER(binToleranceZ);
0165     ACTS_PYTHON_MEMBER(cylinderDiscSplit);
0166     ACTS_PYTHON_MEMBER(cylinderNZSegments);
0167     ACTS_PYTHON_MEMBER(cylinderNPhiSegments);
0168     ACTS_PYTHON_MEMBER(discNRSegments);
0169     ACTS_PYTHON_MEMBER(discNPhiSegments);
0170     ACTS_PYTHON_MEMBER(itkModuleSplit);
0171     ACTS_PYTHON_MEMBER(barrelMap);
0172     ACTS_PYTHON_MEMBER(discMap);
0173     ACTS_PYTHON_MEMBER(splitPatterns);
0174
0175     ACTS_PYTHON_MEMBER(layers);
0176     ACTS_PYTHON_MEMBER(subVolumeName);
0177     ACTS_PYTHON_MEMBER(sensitiveNames);
0178     ACTS_PYTHON_MEMBER(sensitiveAxes);
0179     ACTS_PYTHON_MEMBER(rRange);
0180     ACTS_PYTHON_MEMBER(zRange);
0181     ACTS_PYTHON_MEMBER(splitTolR);
0182     ACTS_PYTHON_MEMBER(splitTolZ);
0183     ACTS_PYTHON_MEMBER(binning0);
0184     ACTS_PYTHON_MEMBER(binning1);
0185     ACTS_PYTHON_STRUCT_END();
0186
0187     auto regTriplet = [&c](const std::string& name, auto v) {
0188       using type = decltype(v);
0189       py::class_<Config::LayerTriplet<type>>(c, name.c_str())
0190           .def(py::init<>())
0191           .def(py::init<type>())
0192           .def(py::init<type, type, type>())
0193           .def_readwrite("negative", &Config::LayerTriplet<type>::negative)
0194           .def_readwrite("central", &Config::LayerTriplet<type>::central)
0195           .def_readwrite("positive", &Config::LayerTriplet<type>::positive)
0196           .def("at", py::overload_cast<Config::SubVolume>(
0197                          &Config::LayerTriplet<type>::at));
0198     };
0199
0200     regTriplet("LayerTripletBool", true);
0201     regTriplet("LayerTripletString", std::string{""});
0202     regTriplet("LayerTripletVectorString", std::vector<std::string>{});
0203     regTriplet("LayerTripletInterval", Options::Interval{});
0204     regTriplet("LayerTripletDouble", double{5.5});
0205     regTriplet("LayerTripletVectorBinning",
0206                std::vector<std::pair<int, Acts::BinningType>>{});
0207
0208     ACTS_PYTHON_STRUCT_BEGIN(c, Config);
0209     ACTS_PYTHON_MEMBER(surfaceLogLevel);
0210     ACTS_PYTHON_MEMBER(layerLogLevel);
0211     ACTS_PYTHON_MEMBER(volumeLogLevel);
0212     ACTS_PYTHON_MEMBER(fileName);
0213     ACTS_PYTHON_MEMBER(buildBeamPipe);
0214     ACTS_PYTHON_MEMBER(beamPipeRadius);
0215     ACTS_PYTHON_MEMBER(beamPipeHalflengthZ);
0216     ACTS_PYTHON_MEMBER(beamPipeLayerThickness);
0217     ACTS_PYTHON_MEMBER(beamPipeEnvelopeR);
0218     ACTS_PYTHON_MEMBER(layerEnvelopeR);
0219     ACTS_PYTHON_MEMBER(unitScalor);
0220     ACTS_PYTHON_MEMBER(volumes);
0221     ACTS_PYTHON_STRUCT_END();
0222
0223     patchKwargsConstructor(c);
0224   }
0225 }
0226
0227 }  // namespace Acts::Python