Test nested parameterisation and feed back to caller (#44)

Author: sethrj

src/G4VG.hh

@@ -81,12 +81,19 @@ struct Options
        g4pv->SetCopyNo(copy_no);
    }
  * \endcode
+ *
+ * For some applications (especially medical physics), a multi-level
+ * parameterisation can be used to create a 3-D array of voxels. VecGeom only
+ creates a single
+ * volume placement in this case, but it returns a reference to the placed
+ volume and the associated parameterisation.
  */
 struct Converted
 {
     using VGPlacedVolume = vecgeom::VPlacedVolume;
     using VecLv = std::vector<G4LogicalVolume const*>;
     using VecPv = std::vector<G4VPhysicalVolume const*>;
+    using PlacedVolumeId = unsigned int;
 
     //! World pointer (host) corresponding to input Geant4 world
     VGPlacedVolume* world{nullptr};
@@ -95,6 +102,8 @@ struct Converted
     VecLv logical_volumes;
     //! Geant4 PVs indexed by VecGeom PlacedVolume ID
     VecPv physical_volumes;
+    //! Encountered volumes that have unsupported nested parameterisations
+    VecPv nested_pv;
 };
 
 //---------------------------------------------------------------------------//

src/g4vg_impl/Converter.cc

@@ -13,6 +13,7 @@
 #include <G4LogicalVolumeStore.hh>
 #include <G4ReflectionFactory.hh>
 #include <G4ReplicaNavigation.hh>
+#include <G4VNestedParameterisation.hh>
 #include <G4VPVParameterisation.hh>
 #include <G4VPhysicalVolume.hh>
 #include <VecGeom/management/ReflFactory.h>
@@ -270,6 +271,7 @@ auto Converter::operator()(arg_type g4world) -> result_type
     result.world = world_pv;
     result.logical_volumes = convert_lv_->make_volume_map();
     result.physical_volumes = std::move(placed_volumes_);
+    result.nested_pv = std::move(nested_);
 
     G4VG_ENSURE(result.world);
     G4VG_ENSURE(!result.logical_volumes.empty());
@@ -336,11 +338,24 @@ auto Converter::build_with_daughters(G4LogicalVolume const* mother_g4lv)
             case EVolume::kParameterised:
                 // Place each paramterized instance of the daughter
                 G4VG_ASSERT(g4pv->GetParameterisation());
+                if (auto* nested = dynamic_cast<G4VNestedParameterisation*>(
+                        g4pv->GetParameterisation()))
+                {
+                    G4VG_LOG(warning)
+                        << "Encountered nested parameterisation '"
+                        << TypeDemangler<G4VNestedParameterisation>{}(*nested)
+                        << "' for physical volume '" << g4pv->GetName()
+                        << "' (corresponding LV: "
+                        << PrintableLV{g4pv->GetLogicalVolume()} << "): "
+                        << "only one instance will be placed, and "
+                           "solid/material changes will be ignored";
+                    nested_.push_back(g4pv);
+                }
                 place_daughter(g4pv, ParamUpdater{g4pv->GetParameterisation()});
                 break;
             default:
                 G4VG_LOG(error)
-                    << "Unsupported type '"
+                    << "Unsupported custom placement type '"
                     << TypeDemangler<G4VPhysicalVolume>{}(*g4pv)
                     << "' for physical volume '" << g4pv->GetName()
                     << "' (corresponding LV: "

src/g4vg_impl/Converter.hh

@@ -59,6 +59,7 @@ class Converter
     std::unique_ptr<LogicalVolumeConverter> convert_lv_;
     std::unordered_set<VGLogicalVolume const*> built_daughters_;
     VecPv placed_volumes_;
+    result_type::VecPv nested_;
 
     VGLogicalVolume* build_with_daughters(G4LogicalVolume const* mother_g4lv);
 };

test/Custom.test.cc

@@ -306,8 +306,7 @@ G4VPhysicalVolume* NestedReplicaParametrizationTest::build_world()
 
 TEST_F(NestedReplicaParametrizationTest, default_options)
 {
-    auto result = this->run(Options{});
-    result.print_ref();
+    auto result = this->run(Options{.verbose = true});
 
     TestResult ref;
     ref.lv_name = {
@@ -352,6 +351,7 @@ TEST_F(NestedReplicaParametrizationTest, default_options)
         1,
         0,
     };
+    ref.nested = {"voxel:8"};
 
     result.expect_eq(ref);
 }

test/TestBase.cc

@@ -9,6 +9,7 @@
 #include <G4LogicalVolume.hh>
 #include <G4Material.hh>
 #include <G4RunManager.hh>
+#include <G4VNestedParameterisation.hh>
 #include <VecGeom/management/GeoManager.h>
 #include <VecGeom/volumes/LogicalVolume.h>
 #include <VecGeom/volumes/PlacedVolume.h>
@@ -43,9 +44,12 @@ void TestResult::print_ref() const
          << repr(pv_name)
          << ";\n"
             "ref.copy_no = "
-         << repr(copy_no)
-         << ";\n"
-            "result.expect_eq(ref);\n"
+         << repr(copy_no) << ";\n";
+    if (!nested.empty())
+    {
+        cout << "ref.nested = " << repr(nested) << ";\n";
+    }
+    cout << "result.expect_eq(ref);\n"
             "/***** END REFERENCE RESULT *****/\n";
     // clang-format: on
 }
@@ -77,6 +81,7 @@ void TestResult::expect_eq(TestResult const& ref) const
     }
     EXPECT_EQ(pv_name, ref.pv_name) << repr(pv_name);
     EXPECT_EQ(copy_no, ref.copy_no) << repr(copy_no);
+    EXPECT_EQ(nested, ref.nested) << repr(nested);
 }
 
 //---------------------------------------------------------------------------//
@@ -202,6 +207,25 @@ void TestBase::run_impl(Options const& options, TestResult& result)
         // "stamped" instance of a replica/parameterised volume)
         result.copy_no.push_back(vgpv->GetCopyNo());
     }
+
+    // Process nested volume
+    for (auto* g4pv : converted.nested_pv)
+    {
+        ASSERT_TRUE(g4pv);
+        std::ostringstream os;
+
+        os << g4pv->GetName() << ':';
+        if (auto* nested = dynamic_cast<G4VNestedParameterisation*>(
+                g4pv->GetParameterisation()))
+        {
+            os << nested->GetNumberOfMaterials();
+        }
+        else
+        {
+            os << "ERROR";
+        }
+        result.nested.push_back(std::move(os).str());
+    }
 }
 
 //---------------------------------------------------------------------------//

test/TestBase.hh

@@ -25,6 +25,7 @@ struct TestResult
     std::vector<double> solid_capacity;
     std::vector<std::string> pv_name;
     std::vector<int> copy_no;
+    std::vector<std::string> nested;
 
     void print_ref() const;
     void expect_eq(TestResult const& reference) const;