// This file is part of the ACTS project.

//

// Copyright (C) 2016 CERN for the benefit of the ACTS project

//

// This Source Code Form is subject to the terms of the Mozilla Public

// License, v. 2.0. If a copy of the MPL was not distributed with this

// file, You can obtain one at https://mozilla.org/MPL/2.0/.

// Must be on top to avoid some conflict between forward declare and typedef

// Needed until https://gitlab.cern.ch/GeoModelDev/GeoModel/-/merge_requests/351

// is deployed

// clang-format off

#include <GeoModelRead/ReadGeoModel.h>

// clang-format on

#include "Acts/Geometry/ITrackingGeometryBuilder.hpp"

#include "Acts/Surfaces/AnnulusBounds.hpp"

#include "Acts/Surfaces/DiscSurface.hpp"

#include "Acts/Surfaces/PlaneSurface.hpp"

#include "Acts/Surfaces/RectangleBounds.hpp"

#include "ActsPlugins/GeoModel/GeoModelConverters.hpp"

#include "ActsPlugins/GeoModel/GeoModelDetectorElement.hpp"

#include "ActsPlugins/GeoModel/GeoModelDetectorElementITk.hpp"

#include "ActsPlugins/GeoModel/GeoModelDetectorObjectFactory.hpp"

#include "ActsPlugins/GeoModel/GeoModelReader.hpp"

#include "ActsPlugins/GeoModel/GeoModelTree.hpp"

#include "ActsPlugins/GeoModel/IGeoShapeConverter.hpp"

#include "ActsPython/Utilities/Helpers.hpp"

#include "ActsPython/Utilities/Macros.hpp"

#include <string>

#include <GeoModelKernel/GeoFullPhysVol.h>

#include <GeoModelKernel/GeoVPhysVol.h>

#include <pybind11/pybind11.h>

#include <pybind11/stl.h>

namespace py = pybind11;

using namespace pybind11::literals;

PYBIND11_MODULE(ActsPluginsPythonBindingsGeoModel, gm) {

using namespace Acts;

using namespace ActsPython;

using namespace ActsPlugins;

// Basic bindings

{

py::class_<GeoModelTree::FpvConstLink>(gm, "GeoModelTree::FpvConstLink")

.def(py::init<>())

.def("get", &GeoModelTree::FpvConstLink::get,

py::return_value_policy::reference);

py::class_<GeoModelTree>(gm, "GeoModelTree").def(py::init<>());

gm.def("readFromDb", &GeoModelReader::readFromDb);

py::class_<GeoModelDetectorElement,

std::shared_ptr<GeoModelDetectorElement>>(

gm, "GeoModelDetectorElement")

.def("logVolName", &GeoModelDetectorElement::logVolName)

.def("databaseEntryName", &GeoModelDetectorElement::databaseEntryName)

.def("surface", [](GeoModelDetectorElement self) {

return self.surface().getSharedPtr();

});

py::class_<GeoModelDetectorElementITk,

std::shared_ptr<GeoModelDetectorElementITk>>(

gm, "GeoModelDetectorElementITk")

.def("surface", [](GeoModelDetectorElementITk& self) {

return self.surface().getSharedPtr();

});

gm.def("convertToItk", &GeoModelDetectorElementITk::convertFromGeomodel);

}

// Shape converters

{

py::class_<IGeoShapeConverter, std::shared_ptr<IGeoShapeConverter>>(

gm, "IGeoShapeConverter");

py::class_<GeoBoxConverter, IGeoShapeConverter,

std::shared_ptr<GeoBoxConverter>>(gm, "GeoBoxConverter")

.def(py::init<>())

.def("toSensitiveSurface", &GeoBoxConverter::toSensitiveSurface)

.def("toPassiveSurface", &GeoBoxConverter::toPassiveSurface);

py::class_<GeoTrdConverter, IGeoShapeConverter,

std::shared_ptr<GeoTrdConverter>>(gm, "GeoTrdConverter")

.def(py::init<>())

.def("toSensitiveSurface", &GeoTrdConverter::toSensitiveSurface)

.def("toPassiveSurface", &GeoTrdConverter::toPassiveSurface);

py::class_<GeoTubeConverter, IGeoShapeConverter,

std::shared_ptr<GeoTubeConverter>>(gm, "GeoTubeConverter")

.def(py::init<>())

.def("toSensitiveSurface", &GeoTubeConverter::toSensitiveSurface)

.def("toPassiveSurface", &GeoTubeConverter::toPassiveSurface);

py::class_<GeoUnionDoubleTrdConverter, IGeoShapeConverter,

std::shared_ptr<GeoUnionDoubleTrdConverter>>(

gm, "GeoUnionDoubleTrdConverter")

.def(py::init<>())

.def("toSensitiveSurface",

&GeoUnionDoubleTrdConverter::toSensitiveSurface)

.def("toPassiveSurface", &GeoUnionDoubleTrdConverter::toPassiveSurface);

py::class_<GeoIntersectionAnnulusConverter, IGeoShapeConverter,

std::shared_ptr<GeoIntersectionAnnulusConverter>>(

gm, "GeoIntersectionAnnulusConverter")

.def(py::init<>())

.def("toSensitiveSurface",

&GeoIntersectionAnnulusConverter::toSensitiveSurface)

.def("toPassiveSurface",

&GeoIntersectionAnnulusConverter::toPassiveSurface);

py::class_<GeoShiftConverter, IGeoShapeConverter,

std::shared_ptr<GeoShiftConverter>>(gm, "GeoShiftConverter")

.def(py::init<>())

.def("toSensitiveSurface", &GeoShiftConverter::toSensitiveSurface)

.def("toPassiveSurface", &GeoShiftConverter::toPassiveSurface);

}

// Volume factory

{

auto a =

py::class_<GeoModelDetectorObjectFactory,

std::shared_ptr<GeoModelDetectorObjectFactory>>(

gm, "GeoModelDetectorObjectFactory")

.def(py::init([](const GeoModelDetectorObjectFactory::Config& cfg,

Logging::Level level) {

return std::make_shared<GeoModelDetectorObjectFactory>(

cfg,

getDefaultLogger("GeoModelDetectorObjectFactory", level));

}))

.def("construct", &GeoModelDetectorObjectFactory::construct);

py::class_<GeoModelDetectorObjectFactory::Config>(a, "Config")

.def(py::init<>())

.def_readwrite(

"convertSubVolumes",

&GeoModelDetectorObjectFactory::Config::convertSubVolumes)

.def_readwrite("nameList",

&GeoModelDetectorObjectFactory::Config::nameList)

.def_readwrite("convertBox",

&GeoModelDetectorObjectFactory::Config::convertBox)

.def_readwrite("materialList",

&GeoModelDetectorObjectFactory::Config::materialList);

auto convVol = py::class_<GeoModelDetectorObjectFactory::ConvertedGeoVol>(

a, "ConvertedGeoVol");

ACTS_PYTHON_STRUCT(convVol, volume, fullPhysVol, name, surfaces);

py::class_<GeoModelDetectorObjectFactory::Cache>(a, "Cache")

.def(py::init<>())

.def_readwrite("sensitiveSurfaces",

&GeoModelDetectorObjectFactory::Cache::sensitiveSurfaces)

.def_readwrite("boundingBoxes",

&GeoModelDetectorObjectFactory::Cache::volumeBoxFPVs);

py::class_<GeoModelDetectorObjectFactory::Options>(a, "Options")

.def(py::init<>())

.def_readwrite("queries",

&GeoModelDetectorObjectFactory::Options::queries);

}

}