feat: Introduce the usage of the geomodel converters for the Muon System

Examples/Python/src/GeoModel.cpp

@@ -114,8 +114,8 @@ void addGeoModel(Context& ctx) {
     py::class_<Acts::GeoModelDetectorSurfaceFactory::Config>(f, "Config")
         .def(py::init<>())
         .def_readwrite(
-            "shapeConverters",
-            &Acts::GeoModelDetectorSurfaceFactory::Config::shapeConverters)
+            "convertSubVolumes",
+            &Acts::GeoModelDetectorSurfaceFactory::Config::convertSubVolumes)
         .def_readwrite("nameList",
                        &Acts::GeoModelDetectorSurfaceFactory::Config::nameList)
         .def_readwrite(

Examples/Scripts/Python/geomodel.py

@@ -29,6 +29,26 @@ def main():
         help="List of Queries for Published full phys volumes",
     )
 
+    p.add_argument(
+        "-n",
+        "--name-list",
+        type=str,
+        nargs="+",
+        default=[],
+        help="List of Name List for the Surface Factory",
+
+    )
+
+    p.add_argument(
+        "-ml",
+        "--material-list",
+        type=str,
+        nargs="+",
+        default=[],
+        help="List of Material List for the Surface Factory",
+
+    )
+
     p.add_argument(
         "--table-name",
         type=str,
@@ -56,6 +76,13 @@ def main():
         "-m", "--map", type=str, default="", help="Input file for the material map"
     )
 
+    p.add_argument(
+        "--convert-subvols",
+        help="Convert the children of the top level full phys vol",
+        action="store_true",
+        default=False,
+    )
+
     p.add_argument(
         "--output-svg",
         help="Write the surfaces to SVG files",
@@ -84,6 +111,13 @@ def main():
         default=False,
     )
 
+    p.add_argument(
+        "--enable-blueprint",
+        help="Enable the usage of the blueprint",
+        action="store_true",
+        default=False,
+    )
+
     args = p.parse_args()
 
     gContext = acts.GeometryContext()
@@ -98,11 +132,14 @@ def main():
     gmTree = acts.geomodel.readFromDb(args.input)
 
     gmFactoryConfig = gm.GeoModelDetectorSurfaceFactory.Config()
-    gmFactoryConfig.shapeConverters = [
-        gm.GeoBoxConverter(),
-        gm.GeoTrdConverter(),
-        gm.GeoIntersectionAnnulusConverter(),
-    ]
+    # gmFactoryConfig.shapeConverters = [
+    #     gm.GeoBoxConverter(),
+    #     gm.GeoTrdConverter(),
+    #     gm.GeoIntersectionAnnulusConverter(),
+    # ]
+    gmFactoryConfig.materialList = args.material_list
+    gmFactoryConfig.nameList = args.name_list
+    gmFactoryConfig.convertSubVolumes = args.convert_subvols
     gmFactory = gm.GeoModelDetectorSurfaceFactory(gmFactoryConfig, logLevel)
     # The options
     gmFactoryOptions = gm.GeoModelDetectorSurfaceFactory.Options()
@@ -115,77 +152,79 @@ def main():
     gmSurfaces = [ss[1] for ss in gmFactoryCache.sensitiveSurfaces]
 
     # Construct the building hierarchy
-    gmBlueprintConfig = gm.GeoModelBlueprintCreater.Config()
-    gmBlueprintConfig.detectorSurfaces = gmSurfaces
-    gmBlueprintConfig.kdtBinning = [acts.Binning.z, acts.Binning.r]
+    #if the blueprint is enabled
+    if args.enable_blueprint:
+        gmBlueprintConfig = gm.GeoModelBlueprintCreater.Config()
+        gmBlueprintConfig.detectorSurfaces = gmSurfaces
+        gmBlueprintConfig.kdtBinning = [acts.Binning.z, acts.Binning.r]
 
-    gmBlueprintOptions = gm.GeoModelBlueprintCreater.Options()
-    gmBlueprintOptions.table = args.table_name
-    gmBlueprintOptions.topEntry = args.top_node
-    if len(args.top_node_bounds) > 0:
-        gmBlueprintOptions.topBoundsOverride = args.top_node_bounds
+        gmBlueprintOptions = gm.GeoModelBlueprintCreater.Options()
+        gmBlueprintOptions.table = args.table_name
+        gmBlueprintOptions.topEntry = args.top_node
+        if len(args.top_node_bounds) > 0:
+            gmBlueprintOptions.topBoundsOverride = args.top_node_bounds
 
-    gmBlueprintCreater = gm.GeoModelBlueprintCreater(gmBlueprintConfig, logLevel)
-    gmBlueprint = gmBlueprintCreater.create(gContext, gmTree, gmBlueprintOptions)
+        gmBlueprintCreater = gm.GeoModelBlueprintCreater(gmBlueprintConfig, logLevel)
+        gmBlueprint = gmBlueprintCreater.create(gContext, gmTree, gmBlueprintOptions)
 
-    gmCylindricalBuilder = gmBlueprint.convertToBuilder(logLevel)
+        gmCylindricalBuilder = gmBlueprint.convertToBuilder(logLevel)
 
     # Top level geo id generator
-    gmGeoIdConfig = GeometryIdGenerator.Config()
-    gmGeoIdGenerator = GeometryIdGenerator(
-        gmGeoIdConfig, "GeoModelGeoIdGenerator", logLevel
-    )
+        gmGeoIdConfig = GeometryIdGenerator.Config()
+        gmGeoIdGenerator = GeometryIdGenerator(
+            gmGeoIdConfig, "GeoModelGeoIdGenerator", logLevel
+        )
 
-    # Create the detector builder
-    gmDetectorConfig = DetectorBuilder.Config()
-    gmDetectorConfig.name = args.top_node + "_DetectorBuilder"
-    gmDetectorConfig.builder = gmCylindricalBuilder
-    gmDetectorConfig.geoIdGenerator = gmGeoIdGenerator
-    gmDetectorConfig.materialDecorator = materialDecorator
-    gmDetectorConfig.auxiliary = (
+        # Create the detector builder
+        gmDetectorConfig = DetectorBuilder.Config()
+        gmDetectorConfig.name = args.top_node + "_DetectorBuilder"
+        gmDetectorConfig.builder = gmCylindricalBuilder
+        gmDetectorConfig.geoIdGenerator = gmGeoIdGenerator
+        gmDetectorConfig.materialDecorator = materialDecorator
+        gmDetectorConfig.auxiliary = (
         "GeoModel based Acts::Detector from '" + args.input + "'"
-    )
-
-    gmDetectorBuilder = DetectorBuilder(gmDetectorConfig, args.top_node, logLevel)
-    detector = gmDetectorBuilder.construct(gContext)
-
-    materialSurfaces = detector.extractMaterialSurfaces()
-    print("Found ", len(materialSurfaces), " material surfaces")
-
-    # Output the detector to SVG
-    if args.output_svg:
-        surfaceStyle = acts.svg.Style()
-        surfaceStyle.fillColor = [5, 150, 245]
-        surfaceStyle.fillOpacity = 0.5
-
-        surfaceOptions = acts.svg.SurfaceOptions()
-        surfaceOptions.style = surfaceStyle
-
-        viewRange = acts.Extent([])
-        volumeOptions = acts.svg.DetectorVolumeOptions()
-        volumeOptions.surfaceOptions = surfaceOptions
-
-        xyRange = acts.Extent([[acts.Binning.z, [-50, 50]]])
-        zrRange = acts.Extent([[acts.Binning.phi, [-0.8, 0.8]]])
-
-        acts.svg.viewDetector(
-            gContext,
-            detector,
-            args.top_node,
-            [[ivol, volumeOptions] for ivol in range(detector.numberVolumes())],
-            [
-                ["xy", ["sensitives", "portals"], xyRange],
-                ["zr", ["", "", "materials"], zrRange],
-            ],
-            args.output + "_detector",
         )
 
-        # Output the internal navigation to SVG
-        if args.output_internals_svg:
-            for vol in detector.volumes():
-                acts.svg.viewInternalNavigation(
-                    gContext, vol, [66, 111, 245, 245, 203, 66, 0.8], "/;:"
-                )
+        gmDetectorBuilder = DetectorBuilder(gmDetectorConfig, args.top_node, logLevel)
+        detector = gmDetectorBuilder.construct(gContext)
+
+        materialSurfaces = detector.extractMaterialSurfaces()
+        print("Found ", len(materialSurfaces), " material surfaces")
+
+        # Output the detector to SVG
+        if args.output_svg:
+            surfaceStyle = acts.svg.Style()
+            surfaceStyle.fillColor = [5, 150, 245]
+            surfaceStyle.fillOpacity = 0.5
+
+            surfaceOptions = acts.svg.SurfaceOptions()
+            surfaceOptions.style = surfaceStyle
+
+            viewRange = acts.Extent([])
+            volumeOptions = acts.svg.DetectorVolumeOptions()
+            volumeOptions.surfaceOptions = surfaceOptions
+
+            xyRange = acts.Extent([[acts.Binning.z, [-50, 50]]])
+            zrRange = acts.Extent([[acts.Binning.phi, [-0.8, 0.8]]])
+
+            acts.svg.viewDetector(
+                gContext,
+                detector,
+                args.top_node,
+                [[ivol, volumeOptions] for ivol in range(detector.numberVolumes())],
+                [
+                    ["xy", ["sensitives", "portals"], xyRange],
+                    ["zr", ["", "", "materials"], zrRange],
+                ],
+                args.output + "_detector",
+            )
+
+            # Output the internal navigation to SVG
+            if args.output_internals_svg:
+                for vol in detector.volumes():
+                    acts.svg.viewInternalNavigation(
+                        gContext, vol, [66, 111, 245, 245, 203, 66, 0.8], "/;:"
+                    )
 
     # Output the surface to an OBJ file
     if args.output_obj:

Plugins/GeoModel/CMakeLists.txt

@@ -22,7 +22,7 @@ target_include_directories(
     $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 target_link_libraries(
     ActsPluginGeoModel
-  PUBLIC ActsCore GeoModelKernel GeoModelIO::GeoModelDBManager GeoModelIO::GeoModelRead)
+  PUBLIC ActsCore GeoModelKernel GeoModelCore::GeoModelHelpers GeoModelIO::GeoModelDBManager GeoModelIO::GeoModelRead)
 
 install(
   TARGETS ActsPluginGeoModel

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

@@ -21,6 +21,7 @@
 #include "Acts/Plugins/GeoModel/detail/GeoUnionDoubleTrdConverter.hpp"
 #include "Acts/Utilities/Result.hpp"
 
+#include <map>
 #include <memory>
 #include <tuple>
 
@@ -68,4 +69,24 @@ using GeoUnionDoubleTrdConverter =
     detail::GenericGeoShapeConverter<GeoShapeUnion,
                                      detail::GeoUnionDoubleTrdConverter>;
 
+/// @brief The map that maps the converters with the shapes
+
+std::shared_ptr<const IGeoShapeConverter> GeoShapesConverters(int geoShapeId) {
+  using ConverterLookUpMap =
+      std::map<int, std::shared_ptr<const IGeoShapeConverter>>;
+
+  static const ConverterLookUpMap converters{
+      {GeoBox::getClassTypeID(), std::make_shared<GeoBoxConverter>()},
+      {GeoShapeIntersection::getClassTypeID(),
+       std::make_shared<GeoIntersectionAnnulusConverter>()},
+      {GeoShapeShift::getClassTypeID(), std::make_shared<GeoShiftConverter>()},
+      {GeoTrd::getClassTypeID(), std::make_shared<GeoTrdConverter>()},
+      {GeoTube::getClassTypeID(), std::make_shared<GeoTubeConverter>()},
+      {GeoShapeUnion::getClassTypeID(),
+       std::make_shared<GeoUnionDoubleTrdConverter>()}};
+  ConverterLookUpMap::const_iterator itr = converters.find(geoShapeId);
+
+  return itr != converters.end() ? itr->second : nullptr;
+};
+
 }  // namespace Acts

Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelDetectorElement.hpp

@@ -15,7 +15,10 @@
 
 #include <memory>
 
+#include <GeoModelKernel/GeoFullPhysVol.h>
+
 class GeoFullPhysVol;
+class GeoVPhysVol;
 
 namespace Acts {
 
@@ -48,9 +51,8 @@ class GeoModelDetectorElement : public DetectorElementBase {
   /// @return a shared pointer to an instance of the detector element
   template <typename SurfaceType, typename BoundsType>
   static std::shared_ptr<GeoModelDetectorElement> createDetectorElement(
-      const GeoFullPhysVol& geoPhysVol,
-      const std::shared_ptr<BoundsType> bounds, const Transform3& sfTransform,
-      ActsScalar thickness) {
+      PVConstLink geoPhysVol, const std::shared_ptr<BoundsType> bounds,
+      const Transform3& sfTransform, ActsScalar thickness) {
     // First create the detector element with a nullptr
     auto detElement = std::make_shared<GeoModelDetectorElement>(
         geoPhysVol, nullptr, sfTransform, thickness);
@@ -65,7 +67,7 @@ class GeoModelDetectorElement : public DetectorElementBase {
   /// @param surface the representing surface
   /// @param sfTransform the surface transform
   /// @param thickness the thickness of the detector element
-  GeoModelDetectorElement(const GeoFullPhysVol& geoPhysVol,
+  GeoModelDetectorElement(PVConstLink geoPhysVol,
                           std::shared_ptr<Surface> surface,
                           const Transform3& sfTransform, ActsScalar thickness);
 
@@ -84,7 +86,7 @@ class GeoModelDetectorElement : public DetectorElementBase {
   ActsScalar thickness() const override;
 
   /// @return to the Geant4 physical volume
-  const GeoFullPhysVol& physicalVolume() const;
+  PVConstLink physicalVolume() const;
 
  private:
   /// Attach a surface
@@ -95,7 +97,7 @@ class GeoModelDetectorElement : public DetectorElementBase {
   }
 
   /// The GeoModel full physical volume
-  const GeoFullPhysVol* m_geoPhysVol{nullptr};
+  PVConstLink m_geoPhysVol{nullptr};
   /// The surface
   std::shared_ptr<Surface> m_surface;
   /// The global transformation before the volume

Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelDetectorSurfaceFactory.hpp

@@ -18,6 +18,8 @@
 #include <tuple>
 #include <vector>
 
+#include <GeoModelHelpers/getChildNodesWithTrf.h>
+
 class GeoShape;
 class GeoFullPhysVol;
 
@@ -38,12 +40,16 @@ class GeoModelDetectorSurfaceFactory {
 
   // Configuration struct for the Detector surface factory
   struct Config {
-    /// The shape converters to be use
-    std::vector<std::shared_ptr<const IGeoShapeConverter>> shapeConverters = {};
-    /// List for names to match
+    // /// The shape converters to be use
+    // std::vector<std::shared_ptr<const IGeoShapeConverter>> shapeConverters =
+    // {};
+    // /// List for names to match
     std::vector<std::string> nameList;
-    /// List for materials to match
+    // /// List for materials to match
     std::vector<std::string> materialList;
+
+    /// boolean flag to build subvolumes
+    bool convertSubVolumes = false;
   };
 
   /// Nested cache that records the conversion status
@@ -88,6 +94,24 @@ class GeoModelDetectorSurfaceFactory {
 
   /// Private access to the logger
   const Logger& logger() const { return *m_logger; }
+
+  /// Private helper method that does the conversion to surfaces
+  ///
+  /// @param geoPV the pointer to the physical volume
+  /// @param transform the transform to the global frame
+  /// @param sensitives the vector which we fill with the converted surfaces
+  void convertSensitive(
+      PVConstLink geoPV, const Acts::Transform3& transform,
+      std::vector<Acts::GeoModelSensitiveSurface>& sensitives);
+
+  /// Private helper method that finds the subvolumes from the top-level full
+  /// physical volume
+  ///
+  /// @param geoPV the pointer to the physical volume
+  /// @param matchFunc the function that checks if the volume matches the name and material requirements
+  std::vector<GeoChildNodeWithTrf> findAllSubVolumes(
+      PVConstLink geoPV,
+      std::function<bool(std::string, PVConstLink)> matchFunc);
 };
 
 }  // 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;
+  PVConstLink worldVolume{nullptr};
   std::string worldVolumeName = "World";
 };
 }  // namespace Acts