feat: generalized conversion of FullPhysicalVolume

Plugins/GeoModel/CMakeLists.txt

@@ -13,6 +13,7 @@ add_library(
     src/detail/GeoBoxConverter.cpp
     src/detail/GeoTrdConverter.cpp
     src/detail/GeoTubeConverter.cpp
+    src/detail/GeoPolygonConverter.cpp
     src/detail/GeoShiftConverter.cpp
     src/detail/GeoIntersectionAnnulusConverter.cpp
     src/detail/GeoModelBinningHelper.cpp

Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelConverters.hpp

@@ -15,6 +15,7 @@
 #include "Acts/Plugins/GeoModel/detail/GenericGeoShapeConverter.hpp"
 #include "Acts/Plugins/GeoModel/detail/GeoBoxConverter.hpp"
 #include "Acts/Plugins/GeoModel/detail/GeoIntersectionAnnulusConverter.hpp"
+#include "Acts/Plugins/GeoModel/detail/GeoPolygonConverter.hpp"
 #include "Acts/Plugins/GeoModel/detail/GeoShiftConverter.hpp"
 #include "Acts/Plugins/GeoModel/detail/GeoTrdConverter.hpp"
 #include "Acts/Plugins/GeoModel/detail/GeoTubeConverter.hpp"
@@ -37,6 +38,9 @@ namespace Acts {
 using GeoBoxConverter =
     detail::GenericGeoShapeConverter<GeoBox, detail::GeoBoxConverter>;
 
+using GeoPolygonConverter =
+    detail::GenericGeoShapeConverter<GeoSimplePolygonBrep,
+                                     detail::GeoPolygonConverter>;
 /// @brief A dedicated converter for GeoInterseciton that describe annulus bounds
 ///
 /// This is very much tailored to the AnnulusBounds class
@@ -83,6 +87,8 @@ inline std::shared_ptr<const IGeoShapeConverter> geoShapesConverters(
            std::make_shared<GeoShiftConverter>()},
           {GeoTrd::getClassTypeID(), std::make_shared<GeoTrdConverter>()},
           {GeoTube::getClassTypeID(), std::make_shared<GeoTubeConverter>()},
+          {GeoSimplePolygonBrep::getClassTypeID(),
+           std::make_shared<GeoPolygonConverter>()},
           {GeoShapeUnion::getClassTypeID(),
            std::make_shared<GeoUnionDoubleTrdConverter>()}};
   auto itr = converters.find(geoShapeId);

Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelToDetectorVolume.hpp

@@ -20,6 +20,7 @@ namespace Acts::GeoModel {
 /// @param shape the GeoModel shape
 /// @param transform the transform to be applied
 /// @return the DetectorVolume
+Volume package(const Transform3& trf, const GeoShape& shape);
 std::shared_ptr<Experimental::DetectorVolume> convertVolume(
     const GeometryContext& context, const GeoShape& shape,
     const std::string& name, const GeoTrf::Transform3D& transform,

Plugins/GeoModel/include/Acts/Plugins/GeoModel/detail/GeoPolygonConverter.hpp

@@ -0,0 +1,34 @@
+// 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/Definitions/Algebra.hpp"
+#include "Acts/Plugins/GeoModel/GeoModelDetectorElement.hpp"
+#include "Acts/Utilities/Result.hpp"
+
+#include <memory>
+#include <tuple>
+
+#include <GeoModelKernel/GeoSimplePolygonBrep.h>
+
+namespace Acts::detail {
+struct GeoPolygonConverter {
+  /// @brief Convert a GeoBox to a detector element and surface
+  ///
+  /// @param geoFPV The full physical volume to convert (contains shape)
+  /// @param geoBox The GeoBox to convert
+  /// @param absTransform from the GeoPhysVol
+  /// @param bool sensitive
+  ///
+  /// @return The detector element and surface
+  Result<GeoModelSensitiveSurface> operator()(
+      const PVConstLink& geoPV, const GeoSimplePolygonBrep& geoPolygon,
+      const Transform3& absTransform, bool sensitive) const;
+};
+}  // namespace Acts::detail

Plugins/GeoModel/src/GeoModelDetectorObjectFactory.cpp

@@ -139,13 +139,14 @@ Acts::GeoModelDetectorObjectFactory::findAllSubVolumes(const PVConstLink &vol) {
   }
   return sensitives;
 }
+
 bool Acts::GeoModelDetectorObjectFactory::convertBox(std::string name) {
   auto convB = std::any_of(
       m_cfg.convertBox.begin(), m_cfg.convertBox.end(),
       [&](const auto &n) { return name.find(n) != std::string::npos; });
-  // return (name.find(m_cfg.convertBox) != std::string::npos);
   return convB;
 }
+
 void Acts::GeoModelDetectorObjectFactory::convertFpv(
     const std::string &name, GeoFullPhysVol *fpv, Cache &cache,
     const GeometryContext &gctx) {
@@ -154,37 +155,37 @@ void Acts::GeoModelDetectorObjectFactory::convertFpv(
   // get children
   std::vector<GeoChildNodeWithTrf> subvolumes =
       getChildrenWithRef(physVol, false);
-  if (!subvolumes.empty()) {
-    // vector containing all subvolumes to be converted to surfaces
-    std::vector<GeoChildNodeWithTrf> surfaces = findAllSubVolumes(physVol);
-    std::vector<GeoModelSensitiveSurface> sensitives;
-
-    for (const auto &surface : surfaces) {
-      const Transform3 &transform =
-          fpv->getAbsoluteTransform() * surface.transform;
-      convertSensitive(surface.volume, transform, sensitives);
-    }
-    cache.sensitiveSurfaces.insert(cache.sensitiveSurfaces.end(),
-                                   sensitives.begin(), sensitives.end());
-    if (convertBox(name)) {
-      const GeoLogVol *logVol =
-          physVol->getLogVol();  // get logVol for the shape of the volume
-      const GeoShape *shape = logVol->getShape();  // get shape
-      const Acts::Transform3 &fpvtransform = fpv->getAbsoluteTransform(nullptr);
-
-      // convert bounding boxes with surfaces inside
-      std::shared_ptr<Experimental::DetectorVolume> box =
-          Acts::GeoModel::convertVolume(gctx, *shape, name, fpvtransform,
-                                        sensitives);
-      cache.boundingBoxes.push_back(box);
-    }
-  } else {
+  // vector containing all subvolumes to be converted to surfaces
+  std::vector<GeoChildNodeWithTrf> surfaces = findAllSubVolumes(physVol);
+  std::vector<GeoModelSensitiveSurface> sensitives;
+
+  for (const auto &surface : surfaces) {
+    const Transform3 &transform =
+        fpv->getAbsoluteTransform() * surface.transform;
+    convertSensitive(surface.volume, transform, sensitives);
+  }
+  cache.sensitiveSurfaces.insert(cache.sensitiveSurfaces.end(),
+                                 sensitives.begin(), sensitives.end());
+  if (convertBox(name)) {
+    const GeoLogVol *logVol =
+        physVol->getLogVol();  // get logVol for the shape of the volume
+    const GeoShape *shape = logVol->getShape();  // get shape
+    const Acts::Transform3 &fpvtransform = fpv->getAbsoluteTransform(nullptr);
+
+    // convert bounding boxes with surfaces inside
+    std::shared_ptr<Experimental::DetectorVolume> box =
+        Acts::GeoModel::convertVolume(gctx, *shape, name, fpvtransform,
+                                      sensitives);
+    cache.boundingBoxes.push_back(box);
+  }
+  // If fpv has no subs and should not be converted to volume convert to surface
+  else if (subvolumes.empty()) {
     // convert fpvs to surfaces
     const Transform3 &transform = fpv->getAbsoluteTransform();
     convertSensitive(fpv, transform, cache.sensitiveSurfaces);
   }
 }
-// lambda to determine if object fits query
+// function to determine if object fits query
 bool Acts::GeoModelDetectorObjectFactory::matches(const std::string &name,
                                                   const PVConstLink &physvol) {
   if (m_cfg.nameList.empty() && m_cfg.materialList.empty()) {

Plugins/GeoModel/src/GeoModelToDetectorVolume.cpp

@@ -29,62 +29,23 @@
 #include <GeoModelKernel/GeoTubs.h>
 
 namespace Acts::GeoModel {
-
-std::shared_ptr<Experimental::DetectorVolume> convertVolume(
-    const GeometryContext& context, const GeoShape& shape,
-    const std::string& name, const GeoTrf::Transform3D& transform,
-    const std::vector<GeoModelSensitiveSurface>& sensitives) {
-  // dummy volume for conversion with surfaces
-  std::vector<std::shared_ptr<Acts::Experimental::DetectorVolume>> a;
-
-  // type conversion from GeoModelSensitiveSurface to Surface
-  std::vector<std::shared_ptr<Surface>> sensSurfaces(sensitives.size());
-  std::transform(sensitives.begin(), sensitives.end(), sensSurfaces.begin(),
-                 [](const std::tuple<std::shared_ptr<GeoModelDetectorElement>,
-                                     std::shared_ptr<Surface>>& t) {
-                   return std::get<1>(t);
-                 });
-  auto portalGenerator = Experimental::defaultPortalAndSubPortalGenerator();
+Volume package(const Transform3& trf, const GeoShape& shape) {
+  std::shared_ptr<const VolumeBounds> bounds;
+  GeoTrf::Transform3D newTrf = trf;
   if (shape.typeID() == GeoTube::getClassTypeID()) {
     const GeoTube* tube = dynamic_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());
+    bounds = std::make_shared<CylinderVolumeBounds>(
+        tube->getRMin(), tube->getRMax(), tube->getZHalfLength());
   } else if (shape.typeID() == GeoTubs::getClassTypeID()) {
     const GeoTubs* tubs = dynamic_cast<const GeoTubs*>(&shape);
-    std::shared_ptr<CylinderVolumeBounds> bounds =
-        std::make_shared<CylinderVolumeBounds>(tubs->getRMin(), tubs->getRMax(),
-                                               tubs->getZHalfLength(),
-                                               tubs->getDPhi() / 2);
-    GeoTrf::Transform3D newTransform =
-        transform * GeoTrf::RotateZ3D(tubs->getSPhi() + 0.5 * tubs->getDPhi());
-    return Experimental::DetectorVolumeFactory::construct(
-        portalGenerator, context, name, newTransform, bounds,
-        Experimental::tryAllPortalsAndSurfaces());
+    bounds = std::make_shared<CylinderVolumeBounds>(
+        tubs->getRMin(), tubs->getRMax(), tubs->getZHalfLength(),
+        tubs->getDPhi() / 2);
+    newTrf = trf * GeoTrf::RotateZ3D(tubs->getSPhi() + 0.5 * tubs->getDPhi());
   } else if (shape.typeID() == GeoBox::getClassTypeID()) {
-    // TODO do the surfaces
     const GeoBox* box = dynamic_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, sensSurfaces, a,
-        Experimental::tryNoVolumes(), Experimental::tryAllPortalsAndSurfaces());
-  } else if (shape.typeID() == GeoSimplePolygonBrep::getClassTypeID()) {
-    const GeoSimplePolygonBrep* brep =
-        dynamic_cast<const GeoSimplePolygonBrep*>(&shape);
-    double xmin{0}, xmax{0}, ymin{0}, ymax{0}, zmin{0}, zmax{0};
-    brep->extent(xmin, ymin, zmin, xmax, ymax, zmax);
-    std::shared_ptr<CuboidVolumeBounds> bounds =
-        std::make_shared<CuboidVolumeBounds>(
-            (xmax - xmin) / 2, (ymax - ymin) / 2, (zmax - zmin) / 2);
-    return Experimental::DetectorVolumeFactory::construct(
-        portalGenerator, context, name, transform, bounds,
-        Experimental::tryAllPortalsAndSurfaces());
+    bounds = std::make_shared<const CuboidVolumeBounds>(
+        box->getXHalfLength(), box->getYHalfLength(), box->getZHalfLength());
   } else if (shape.typeID() == GeoTrd::getClassTypeID()) {
     const GeoTrd* trd = dynamic_cast<const GeoTrd*>(&shape);
     double x1 = trd->getXHalfLength1();
@@ -96,93 +57,94 @@ std::shared_ptr<Experimental::DetectorVolume> convertVolume(
     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);
+        bounds = std::make_shared<TrapezoidVolumeBounds>(x1, x2, z, y1);
         constexpr double rotationAngle = M_PI / 2;
-        GeoTrf::Transform3D newTransform =
-            transform * GeoTrf::RotateX3D(rotationAngle);
-        return Experimental::DetectorVolumeFactory::construct(
-            portalGenerator, context, name, newTransform, bounds, sensSurfaces,
-            a, Experimental::tryNoVolumes(),
-            Experimental::tryAllPortalsAndSurfaces());
+        newTrf = trf * GeoTrf::RotateX3D(rotationAngle);
       } else {
-        std::shared_ptr<TrapezoidVolumeBounds> bounds =
-            std::make_shared<TrapezoidVolumeBounds>(x2, x1, z, y1);
+        bounds = std::make_shared<TrapezoidVolumeBounds>(x2, x1, z, y1);
         constexpr double rotationAngle = M_PI;
-        GeoTrf::Transform3D newTransform = transform *
-                                           GeoTrf::RotateY3D(rotationAngle) *
-                                           GeoTrf::RotateZ3D(rotationAngle);
-        return Experimental::DetectorVolumeFactory::construct(
-            portalGenerator, context, name, newTransform, bounds, sensSurfaces,
-            a, Experimental::tryNoVolumes(),
-            Experimental::tryAllPortalsAndSurfaces());
+        newTrf = trf * GeoTrf::RotateY3D(rotationAngle) *
+                 GeoTrf::RotateZ3D(rotationAngle);
       }
     } else if (x1 == x2) {
       if (y1 < y2) {
-        std::shared_ptr<TrapezoidVolumeBounds> bounds =
-            std::make_shared<TrapezoidVolumeBounds>(y1, y2, z, x1);
+        bounds = std::make_shared<TrapezoidVolumeBounds>(y1, y2, z, x1);
         auto rotationAngle = M_PI / 2;
-        GeoTrf::Transform3D newTransform = transform *
-                                           GeoTrf::RotateZ3D(rotationAngle) *
-                                           GeoTrf::RotateX3D(rotationAngle);
-        return Experimental::DetectorVolumeFactory::construct(
-            portalGenerator, context, name, newTransform, bounds, sensSurfaces,
-            a, Experimental::tryNoVolumes(),
-            Experimental::tryAllPortalsAndSurfaces());
+        newTrf = trf * GeoTrf::RotateZ3D(rotationAngle) *
+                 GeoTrf::RotateX3D(rotationAngle);
       } else {
-        std::shared_ptr<TrapezoidVolumeBounds> bounds =
-            std::make_shared<TrapezoidVolumeBounds>(y2, y1, z, x1);
+        bounds = std::make_shared<TrapezoidVolumeBounds>(y2, y1, z, x1);
         auto rotationAngle = M_PI;
-        GeoTrf::Transform3D newTransform =
-            transform * GeoTrf::RotateX3D(rotationAngle) *
-            GeoTrf::RotateZ3D(rotationAngle / 2) *
-            GeoTrf::RotateX3D(rotationAngle / 2);
-        return Experimental::DetectorVolumeFactory::construct(
-            portalGenerator, context, name, newTransform, bounds, sensSurfaces,
-            a, Experimental::tryNoVolumes(),
-            Experimental::tryAllPortalsAndSurfaces());
+        newTrf = trf * GeoTrf::RotateX3D(rotationAngle) *
+                 GeoTrf::RotateZ3D(rotationAngle / 2) *
+                 GeoTrf::RotateX3D(rotationAngle / 2);
       }
     } else {
       throw std::runtime_error("FATAL: Translating GeoTrd to ACTS failed");
     }
-  } else if (shape.typeID() == GeoShapeUnion::getClassTypeID()) {
+  }
+
+  else if (shape.typeID() == GeoShapeUnion::getClassTypeID()) {
     const GeoShapeUnion* unionShape =
         dynamic_cast<const GeoShapeUnion*>(&shape);
     double xmin{0}, xmax{0}, ymin{0}, ymax{0}, zmin{0}, zmax{0};
     unionShape->extent(xmin, ymin, zmin, xmax, ymax, zmax);
-    std::shared_ptr<CuboidVolumeBounds> bounds =
-        std::make_shared<CuboidVolumeBounds>(
-            (xmax - xmin) / 2, (ymax - ymin) / 2, (zmax - zmin) / 2);
-    return Experimental::DetectorVolumeFactory::construct(
-        portalGenerator, context, name, transform, bounds,
-        Experimental::tryAllPortalsAndSurfaces());
+    bounds = std::make_shared<CuboidVolumeBounds>(
+        (xmax - xmin) / 2, (ymax - ymin) / 2, (zmax - zmin) / 2);
   } else if (shape.typeID() == GeoShapeSubtraction::getClassTypeID()) {
     // Go down the left side (opA) of the subtraction until we reach a normal
     // shape
     const GeoShapeSubtraction* subtractionShape =
         dynamic_cast<const GeoShapeSubtraction*>(&shape);
     const GeoShape* shapeA = subtractionShape->getOpA();
-    return convertVolume(context, *shapeA, name, transform, sensitives);
+    return package(trf, *shapeA);
+  } else if (shape.typeID() == GeoShapeSubtraction::getClassTypeID()) {
+    // Go down the left side (opA) of the subtraction until we reach a normal
+    // shape
+    const GeoShapeSubtraction* subtractionShape =
+        dynamic_cast<const GeoShapeSubtraction*>(&shape);
+    const GeoShape* shapeA = subtractionShape->getOpA();
+    return package(trf, *shapeA);
   } else if (shape.typeID() == GeoPcon::getClassTypeID()) {
     // Will change in future, get bounding box for now
     double xmin{0}, xmax{0}, ymin{0}, ymax{0}, zmin{0}, zmax{0};
     const GeoPcon* pcon = dynamic_cast<const GeoPcon*>(&shape);
     pcon->extent(xmin, ymin, zmin, xmax, ymax, zmax);
-    std::shared_ptr<CuboidVolumeBounds> bounds =
-        std::make_shared<CuboidVolumeBounds>(
-            (xmax - xmin) / 2, (ymax - ymin) / 2, (zmax - zmin) / 2);
-    return Experimental::DetectorVolumeFactory::construct(
-        portalGenerator, context, name, transform, bounds,
-        Experimental::tryAllPortalsAndSurfaces());
-  }
-  if (shape.typeID() == GeoShapeShift::getClassTypeID()) {
+    bounds = std::make_shared<CuboidVolumeBounds>(
+        (xmax - xmin) / 2, (ymax - ymin) / 2, (zmax - zmin) / 2);
+  } else if (shape.typeID() == GeoShapeShift::getClassTypeID()) {
     const GeoShapeShift* shiftShape =
         dynamic_cast<const GeoShapeShift*>(&shape);
     const GeoShape* shapeOp = shiftShape->getOp();
-    GeoTrf::Transform3D newTransform = transform * shiftShape->getX();
-    return convertVolume(context, *shapeOp, name, newTransform, sensitives);
+    newTrf = trf * shiftShape->getX();
+    return package(trf, *shapeOp);
+  } else {
+    throw std::runtime_error("FATAL: Unsupported GeoModel shape");
   }
-  throw std::runtime_error("FATAL: Unsupported GeoModel shape");
+
+  Volume vol = Volume(newTrf, bounds);
+  return vol;
+}
+
+std::shared_ptr<Experimental::DetectorVolume> convertVolume(
+    const GeometryContext& context, const GeoShape& shape,
+    const std::string& name, const GeoTrf::Transform3D& transform,
+    const std::vector<GeoModelSensitiveSurface>& sensitives) {
+  // type conversion from GeoModelSensitiveSurface to Surface
+  std::vector<std::shared_ptr<Surface>> sensSurfaces(sensitives.size());
+  std::transform(sensitives.begin(), sensitives.end(), sensSurfaces.begin(),
+                 [](const std::tuple<std::shared_ptr<GeoModelDetectorElement>,
+                                     std::shared_ptr<Surface>>& t) {
+                   return std::get<1>(t);
+                 });
+  auto portalGenerator = Experimental::defaultPortalAndSubPortalGenerator();
+  Volume vol = package(transform, shape);
+  return Experimental::DetectorVolumeFactory::construct(
+      portalGenerator, context, name, vol.transform(),
+      std::const_pointer_cast<VolumeBounds>(vol.volumeBoundsPtr()),
+      sensSurfaces,
+      std::vector<std::shared_ptr<Acts::Experimental::DetectorVolume>>{},
+      Experimental::tryNoVolumes(), Experimental::tryAllPortalsAndSurfaces());
 }
 
 }  // namespace Acts::GeoModel