TGeoVGConverter: Introduce shape-type filtering for conversion process

- Added functions 'SelectShapeType()' and 'ExcludeShapeType()'. Conversion is
  performed only on selected shapes (if set), and excluded shapes are always
  skipped.

- TGeoVGShape: Disabled conversion for problematic edge cases not covered by
  exclusion: 'TGeoBBox' with shifted origin and 'TGeoScaledShape'.

Author: ihrivnac

geom/geom/inc/TVirtualGeoConverter.h

@@ -12,6 +12,7 @@
 #define ROOT_TVirtualGeoConverter
 
 #include "TObject.h"
+#include "TGeoShape.h"
 
 class TGeoManager;
 
@@ -25,6 +26,8 @@ class TVirtualGeoConverter : public TObject {
    ~TVirtualGeoConverter() override;
 
    virtual void ConvertGeometry() {}
+   virtual void SelectShapeType(TGeoShape::EShapeType) {}
+   virtual void ExcludeShapeType(TGeoShape::EShapeType) {}
    static TVirtualGeoConverter *Instance(TGeoManager *geom = nullptr);
    static void SetConverter(const TVirtualGeoConverter *conv);
    void SetGeometry(TGeoManager *geom) { fGeom = geom; }

geom/vecgeom/inc/TGeoVGConverter.h

@@ -22,13 +22,21 @@
 
 #include "TGeoManager.h"
 
+#include <set>
+
 class TGeoVGConverter : public TVirtualGeoConverter {
 public:
    TGeoVGConverter(TGeoManager *manager);
    ~TGeoVGConverter() override;
 
    void ConvertGeometry() override;
 
+   void SelectShapeType(TGeoShape::EShapeType) override;
+   void ExcludeShapeType(TGeoShape::EShapeType) override;
+
+   std::set<TGeoShape::EShapeType> fSelectedShapeTypes;
+   std::set<TGeoShape::EShapeType> fExcludedShapeTypes;
+
    ClassDefOverride(TGeoVGConverter, 0) // VecGeom geometry converter
 };
 

geom/vecgeom/src/TGeoVGConverter.cxx

@@ -16,7 +16,34 @@ Geometry converter to VecGeom
 
 #include "TGeoVGConverter.h"
 #include "TGeoVGShape.h"
+#include "TGeoBBox.h"
+#include "TClass.h"
 
+#include <iostream>
+
+namespace {
+
+Bool_t  isInSelection(const TGeoShape* shape,  const std::set<TGeoShape::EShapeType>& selection) {
+   for (auto element : selection) {
+
+      // Special treatment of TGeo::kGeoBox, which is base class for all other shapes
+      if (element == TGeoShape::kGeoBox) {
+         if (typeid(*shape) == typeid(TGeoBBox) ) {
+            return true;
+         } else {
+            continue;
+         }
+      }
+
+      // Just test bit for other shapes
+      if (shape->TestShapeBit(element)) {
+        return true;
+      }
+   }
+   return false;
+}
+
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 /// Default constructor.
@@ -48,14 +75,37 @@ void TGeoVGConverter::ConvertGeometry()
       nconverted++;
       top->SetShape(vgshape);
    }
+
+   // Uncomment to print info about selected/excluded shapes
+   // if ( ! fSelectedShapeTypes.empty()) {
+   //   printf("# %zu selected shape type for conversion \n", fSelectedShapeTypes.size());
+   // }
+   // if ( ! fExcludedShapeTypes.empty()) {
+   //   printf("# %zu shape types excluded from conversion \n", fExcludedShapeTypes.size());
+   // }
+
    // Now iterate the active geometry tree
    TGeoIterator next(fGeom->GetTopVolume());
    TGeoNode *node;
    while ((node = next.Next())) {
       TGeoVolume *vol = node->GetVolume();
-      // If shape not already converted, convert it
+      // Skip shape if already converted
       if (vol->GetShape()->IsVecGeom())
          continue;
+
+      // If fSelectedShapeTypes is not empty, convert only selected shapes
+      if ((! fSelectedShapeTypes.empty()) &&
+          (! isInSelection(vol->GetShape(), fSelectedShapeTypes))) {
+         printf("# Shape type %s is not selected for conversion\n", vol->GetShape()->IsA()->GetName());
+         continue;
+      }
+
+      // Skip shapes excluded from conversion
+      if (isInSelection(vol->GetShape(), fExcludedShapeTypes)) {
+         printf("# Shape type %s is excluded from conversion\n", vol->GetShape()->IsA()->GetName());
+         continue;
+      }
+
       // printf("Converting %s\n", vol->GetName());
       vgshape = TGeoVGShape::Create(vol->GetShape());
       if (vgshape) {
@@ -65,3 +115,20 @@ void TGeoVGConverter::ConvertGeometry()
    }
    printf("# Converted %d shapes to VecGeom ones\n", nconverted);
 }
+
+////////////////////////////////////////////////////////////////////////////////
+/// Select shape(s) for conversion.
+/// Conversion is performed only on selected shapes (if set)
+
+void TGeoVGConverter::SelectShapeType(TGeoShape::EShapeType shapeType)
+{
+   fSelectedShapeTypes.insert(shapeType);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Exclude shape(s) from conversion.
+
+void TGeoVGConverter::ExcludeShapeType(TGeoShape::EShapeType shapeType)
+{
+   fExcludedShapeTypes.insert(shapeType);
+}

geom/vecgeom/src/TGeoVGShape.cxx

@@ -138,7 +138,12 @@ vecgeom::cxx::VUnplacedVolume *TGeoVGShape::Convert(TGeoShape const *const shape
    // THE BOX
    if (shape->IsA() == TGeoBBox::Class()) {
       TGeoBBox const *const box = static_cast<TGeoBBox const *>(shape);
-      unplaced_volume = GeoManager::MakeInstance<UnplacedBox>(box->GetDX(), box->GetDY(), box->GetDZ());
+      if ((box->GetOrigin()[0] != 0.0) || (box->GetOrigin()[1] != 0.0) || (box->GetOrigin()[2] != 0.0)) {
+        // skip solids with shifted origin
+        printf("Unsupported box shape with shifted origin\n");
+      } else {
+        unplaced_volume = GeoManager::MakeInstance<UnplacedBox>(box->GetDX(), box->GetDY(), box->GetDZ());
+      }
    }
 
    // THE TUBE
@@ -288,14 +293,17 @@ vecgeom::cxx::VUnplacedVolume *TGeoVGShape::Convert(TGeoShape const *const shape
 
    // THE SCALED SHAPE
    if (shape->IsA() == TGeoScaledShape::Class()) {
-      TGeoScaledShape const *const p = static_cast<TGeoScaledShape const *>(shape);
-      // First convert the referenced shape
-      VUnplacedVolume *referenced_shape = Convert(p->GetShape());
-      if (!referenced_shape)
-         return nullptr;
-      const double *scale_root = p->GetScale()->GetScale();
-      unplaced_volume =
-         GeoManager::MakeInstance<UnplacedScaledShape>(referenced_shape, scale_root[0], scale_root[1], scale_root[2]);
+      // TGeoScaledShape const *const p = static_cast<TGeoScaledShape const *>(shape);
+      // // First convert the referenced shape
+      // VUnplacedVolume *referenced_shape = Convert(p->GetShape());
+      // if (!referenced_shape)
+      //    return nullptr;
+      // const double *scale_root = p->GetScale()->GetScale();
+      // unplaced_volume =
+      //    GeoManager::MakeInstance<UnplacedScaledShape>(referenced_shape, scale_root[0], scale_root[1], scale_root[2]);
+
+      // temporarily skip scaled solids which cannot be excluded via EShapeType selection
+      printf("Unsupported scaled shape\n");
    }
 
    // THE CUT TUBE