feat: GeoShapes to DetectorVolumes and GeoMaterial Converters

CMakeLists.txt

@@ -196,8 +196,8 @@ set(_acts_autodiff_version 0.6)
 set(_acts_boost_version 1.71.0)
 set(_acts_dd4hep_version 1.21)
 set(_acts_edm4hep_version 0.7)
-set(_acts_geomodel_version 4.6.0)
 set(_acts_eigen3_version 3.3.7)
+set(_acts_geomodel_version 5.6.0)
 set(_acts_podio_version 0.16)
 set(_acts_doxygen_version 1.9.4)
 set(_acts_hepmc3_version 3.2.1)
@@ -348,7 +348,8 @@ if(ACTS_BUILD_PLUGIN_JSON)
 endif()
 if(ACTS_BUILD_PLUGIN_GEOMODEL)
   if(ACTS_USE_SYSTEM_GEOMODEL)
-    find_package(GeoModel ${_acts_geomodel_version} REQUIRED CONFIG)
+    message(STATUS "Using system installation of GeoModel")
+    find_package(GeoModelIO ${_acts_geomodel_version} COMPONENTS GeoModelDBManager GeoModelRead REQUIRED CONFIG)
   else()
     add_subdirectory(thirdparty/GeoModel)
   endif()

Plugins/GeoModel/CMakeLists.txt

@@ -3,6 +3,7 @@ include(FetchContent)
 add_library(
   ActsPluginGeoModel SHARED
   src/GeoModelConversionError.cpp
+  src/GeoModelToDetVol.cpp
   src/GeoModelReader.cpp
   src/GeoModelDetectorElement.cpp
   src/GeoModelDetectorSurfaceFactory.cpp
@@ -19,7 +20,7 @@ target_include_directories(
     $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 target_link_libraries(
     ActsPluginGeoModel
-  PUBLIC ActsCore GeoModelKernel GeoModelIO::GeoModelDBManager GeoModelIO::GeoModelRead)
+  PUBLIC ActsCore GeoModelCore::GeoModelKernel GeoModelIO::GeoModelDBManager GeoModelIO::GeoModelRead)
 
 install(
   TARGETS ActsPluginGeoModel

Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelToDetVol.hpp

@@ -0,0 +1,26 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 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 http://mozilla.org/MPL/2.0/.
+#pragma once
+
+#include "Acts/Detector/DetectorVolume.hpp"
+
+class GeoShape;
+
+namespace Acts {
+
+namespace GeoModel {
+/// @brief Convert a GeoModel shape to a DetectorVolume
+///
+/// @param shape the GeoModel shape
+/// @param transform the transform to be applied
+/// @return the DetectorVolume
+std::shared_ptr<Experimental::DetectorVolume> convertVolume(
+    const GeometryContext& context, const GeoShape& shape,
+    const std::string& name, const Transform3& transform);
+}  // namespace GeoModel
+}  // namespace Acts

Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelTree.hpp

@@ -18,7 +18,7 @@ namespace Acts {
 
 struct GeoModelTree {
   std::shared_ptr<GeoModelIO::ReadGeoModel> geoReader = nullptr;
-  GeoVPhysVol* worldVolume = nullptr;
+  const GeoVPhysVol* worldVolume = nullptr;
   std::string worldVolumeName = "World";
 };
 }  // namespace Acts

Plugins/GeoModel/src/GeoModelToDetVol.cpp

@@ -0,0 +1,197 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 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 http://mozilla.org/MPL/2.0/.
+
+#include "Acts/Plugins/GeoModel/GeoModelToDetVol.hpp"
+
+#include "Acts/Detector/GeometryIdGenerator.hpp"
+#include "Acts/Detector/PortalGenerators.hpp"
+#include "Acts/Geometry/CuboidVolumeBounds.hpp"
+#include "Acts/Geometry/CutoutCylinderVolumeBounds.hpp"
+#include "Acts/Geometry/CylinderVolumeBounds.hpp"
+#include "Acts/Geometry/GeometryIdentifier.hpp"
+#include "Acts/Geometry/TrapezoidVolumeBounds.hpp"
+#include "Acts/Navigation/InternalNavigation.hpp"
+
+#include <GeoModelKernel/GeoBox.h>
+#include <GeoModelKernel/GeoPcon.h>
+#include <GeoModelKernel/GeoShapeShift.h>
+#include <GeoModelKernel/GeoShapeSubtraction.h>
+#include <GeoModelKernel/GeoShapeUnion.h>
+#include <GeoModelKernel/GeoSimplePolygonBrep.h>
+#include <GeoModelKernel/GeoTrd.h>
+#include <GeoModelKernel/GeoTube.h>
+#include <GeoModelKernel/GeoTubs.h>
+
+namespace Acts {
+namespace GeoModel {
+std::shared_ptr<Experimental::DetectorVolume> convertVolume(
+    const GeometryContext& context, const GeoShape& shape,
+    const std::string& name, const Transform3& transform) {
+  auto portalGenerator = Experimental::defaultPortalAndSubPortalGenerator();
+  if (shape.typeID() == GeoTube::getClassTypeID()) {
+    const GeoTube& tube = static_cast<const GeoTube&>(shape);
+    std::shared_ptr<CylinderVolumeBounds> bounds =
+        std::make_shared<CylinderVolumeBounds>(tube.getRMin(), tube.getRMax(),
+                                               tube.getZHalfLength());
+    return Experimental::DetectorVolumeFactory::construct(
+        portalGenerator, context, name, transform, bounds,
+        Experimental::tryAllPortalsAndSurfaces());
+  } else if (shape.typeID() == GeoTubs::getClassTypeID()) {
+    const GeoTubs& tubs = static_cast<const GeoTubs&>(shape);
+    std::shared_ptr<CylinderVolumeBounds> bounds =
+        std::make_shared<CylinderVolumeBounds>(tubs.getRMin(), tubs.getRMax(),
+                                               tubs.getZHalfLength(),
+                                               tubs.getDPhi() / 2);
+    Acts::Transform3 newTransform = Acts::Transform3::Identity();
+    newTransform.translate(transform.translation());
+    newTransform.rotate(Eigen::AngleAxisd(tubs.getSPhi() + 0.5 * tubs.getDPhi(),
+                                          Acts::Vector3::UnitZ()));
+    return Experimental::DetectorVolumeFactory::construct(
+        portalGenerator, context, name, newTransform, bounds,
+        Experimental::tryAllPortalsAndSurfaces());
+  } else if (shape.typeID() == GeoBox::getClassTypeID()) {
+    const GeoBox& box = static_cast<const GeoBox&>(shape);
+    std::shared_ptr<CuboidVolumeBounds> bounds =
+        std::make_shared<CuboidVolumeBounds>(
+            box.getXHalfLength(), box.getYHalfLength(), box.getZHalfLength());
+    return Experimental::DetectorVolumeFactory::construct(
+        portalGenerator, context, name, transform, bounds,
+        Experimental::tryAllPortalsAndSurfaces());
+  } else if (shape.typeID() == GeoSimplePolygonBrep::getClassTypeID()) {
+    // Will change this in the future
+    double xmin{0};
+    double xmax{0};
+    double ymin{0};
+    double ymax{0};
+    double zmin{0};
+    double zmax{0};
+    const GeoSimplePolygonBrep& brep =
+        static_cast<const GeoSimplePolygonBrep&>(shape);
+    brep.extent(xmin, ymin, zmin, xmax, ymax, zmax);
+    std::shared_ptr<CuboidVolumeBounds> bounds =
+        std::make_shared<CuboidVolumeBounds>(xmax - xmin, ymax - ymin,
+                                             zmax - zmin);
+    return Experimental::DetectorVolumeFactory::construct(
+        portalGenerator, context, name, transform, bounds,
+        Experimental::tryAllPortalsAndSurfaces());
+  } else if (shape.typeID() == GeoTrd::getClassTypeID()) {
+    const GeoTrd& trd = static_cast<const GeoTrd&>(shape);
+    float x1 = trd.getXHalfLength1();
+    float x2 = trd.getXHalfLength2();
+    float y1 = trd.getYHalfLength1();
+    float y2 = trd.getYHalfLength2();
+    float z = trd.getZHalfLength();
+    if (y1 == y2) {
+      if (x1 <= x2) {
+        // y axis in ACTS is z axis in geomodel
+        std::shared_ptr<TrapezoidVolumeBounds> bounds =
+            std::make_shared<TrapezoidVolumeBounds>(x1, x2, z, y1);
+        auto rotationAngle = M_PI / 2;
+        Acts::Transform3 newTransform = Acts::Transform3::Identity();
+        newTransform.translate(transform.translation());
+        newTransform.rotate(
+            Eigen::AngleAxisd(rotationAngle, Acts::Vector3::UnitX()));
+        return Experimental::DetectorVolumeFactory::construct(
+            portalGenerator, context, name, newTransform, bounds,
+            Experimental::tryAllPortalsAndSurfaces());
+      } else {
+        std::shared_ptr<TrapezoidVolumeBounds> bounds =
+            std::make_shared<TrapezoidVolumeBounds>(x2, x1, z, y1);
+        auto rotationAngle = M_PI;
+        Acts::Transform3 newTransform = Acts::Transform3::Identity();
+        newTransform.translate(transform.translation());
+        newTransform.rotate(
+            Eigen::AngleAxisd(rotationAngle, Acts::Vector3::UnitY()) *
+            Eigen::AngleAxisd(rotationAngle, Acts::Vector3::UnitZ()));
+        return Experimental::DetectorVolumeFactory::construct(
+            portalGenerator, context, name, newTransform, bounds,
+            Experimental::tryAllPortalsAndSurfaces());
+      }
+    } else if (x1 == x2) {
+      if (y1 < y2) {
+        std::shared_ptr<TrapezoidVolumeBounds> bounds =
+            std::make_shared<TrapezoidVolumeBounds>(y1, y2, z, x1);
+        auto rotationAngle = M_PI / 2;
+        Acts::Transform3 newTransform = Acts::Transform3::Identity();
+        newTransform.translate(transform.translation());
+        newTransform.rotate(
+            Eigen::AngleAxisd(rotationAngle, Acts::Vector3::UnitZ()) *
+            Eigen::AngleAxisd(rotationAngle, Acts::Vector3::UnitX()));
+        return Experimental::DetectorVolumeFactory::construct(
+            portalGenerator, context, name, newTransform, bounds,
+            Experimental::tryAllPortalsAndSurfaces());
+      } else {
+        std::shared_ptr<TrapezoidVolumeBounds> bounds =
+            std::make_shared<TrapezoidVolumeBounds>(y2, y1, z, x1);
+        auto rotationAngle = M_PI;
+        Acts::Transform3 newTransform = Acts::Transform3::Identity();
+        newTransform.translate(transform.translation());
+        newTransform.rotate(
+            Eigen::AngleAxisd(rotationAngle, Acts::Vector3::UnitX()) *
+            Eigen::AngleAxisd(rotationAngle / 2, Acts::Vector3::UnitZ()) *
+            Eigen::AngleAxisd(rotationAngle / 2, Acts::Vector3::UnitX()));
+        return Experimental::DetectorVolumeFactory::construct(
+            portalGenerator, context, name, newTransform, bounds,
+            Experimental::tryAllPortalsAndSurfaces());
+      }
+    } else {
+      throw std::runtime_error("FATAL: Translating GeoTrd to ACTS failed");
+    }
+  } else if (shape.typeID() == GeoShapeUnion::getClassTypeID()) {
+    // Get the bounding box of the union
+    double xmin{0};
+    double xmax{0};
+    double ymin{0};
+    double ymax{0};
+    double zmin{0};
+    double zmax{0};
+    const GeoShapeUnion& unionShape = static_cast<const GeoShapeUnion&>(shape);
+    unionShape.extent(xmin, ymin, zmin, xmax, ymax, zmax);
+    std::shared_ptr<CuboidVolumeBounds> bounds =
+        std::make_shared<CuboidVolumeBounds>(xmax - xmin, ymax - ymin,
+                                             zmax - zmin);
+    return Experimental::DetectorVolumeFactory::construct(
+        portalGenerator, context, name, transform, bounds,
+        Experimental::tryAllPortalsAndSurfaces());
+  } else if (shape.typeID() == GeoShapeSubtraction::getClassTypeID()) {
+    // Go down the left side (opA) of the subtraction until we reach a normal
+    // shape
+    const GeoShapeSubtraction& subtractionShape =
+        static_cast<const GeoShapeSubtraction&>(shape);
+    const GeoShape* shapeA = subtractionShape.getOpA();
+    return convertVolume(context, *shapeA, name, transform);
+  } else if (shape.typeID() == GeoPcon::getClassTypeID()) {
+    // Will change in future, get bounding box for now
+    double xmin{0};
+    double xmax{0};
+    double ymin{0};
+    double ymax{0};
+    double zmin{0};
+    double zmax{0};
+    const GeoPcon& pcon = static_cast<const GeoPcon&>(shape);
+    pcon.extent(xmin, ymin, zmin, xmax, ymax, zmax);
+    std::shared_ptr<CuboidVolumeBounds> bounds =
+        std::make_shared<CuboidVolumeBounds>(xmax - xmin, ymax - ymin,
+                                             zmax - zmin);
+    return Experimental::DetectorVolumeFactory::construct(
+        portalGenerator, context, name, transform, bounds,
+        Experimental::tryAllPortalsAndSurfaces());
+  }
+  if (shape.typeID() == GeoShapeShift::getClassTypeID()) {
+    const GeoShapeShift& shiftShape = static_cast<const GeoShapeShift&>(shape);
+    const GeoShape* shapeOp = shiftShape.getOp();
+    Acts::Transform3 newTransform = Acts::Transform3::Identity();
+    newTransform.translate(transform.translation());
+    newTransform.rotate(transform.rotation());
+    newTransform.translate(shiftShape.getX().translation());
+    return convertVolume(context, *shapeOp, name, newTransform);
+  }
+  throw std::runtime_error("Unknown shape type: " + shape.type());
+}
+}  // namespace GeoModel
+}  // namespace Acts

cmake/ActsConfig.cmake.in

@@ -67,6 +67,9 @@ endif()
 if(PluginTGeo IN_LIST Acts_COMPONENTS)
   find_dependency(ROOT @ROOT_VERSION@ CONFIG EXACT)
 endif()
+if(PluginGeoModel IN_LIST Acts_COMPONENTS)
+  find_dependency(GeoModelIO @GeoModelIO_VERSION@ CONFIG EXACT)
+endif()
 if(PluginActSVG IN_LIST Acts_COMPONENTS)
   find_dependency(actsvg @actsvg_VERSION@ CONFIG EXACT)
 endif()