Handle converted G4VPVParameterised/G4PVReplica volumes from G4VG in geometry checks (apt-sim#351)

The latest updates to G4VG allow Geant4 parametrised/replica volumes to
be converted to a VecGeom representation by direct placements. The need
for this comes from the Delta Assessment "B5" example that uses these
structures and for which there is no direct VecGeom equivalent except by
making a direct placement for each copy. That's supported as of [G4VG
1.0.3](https://github.com/celeritas-project/g4vg/releases/tag/v1.0.3),
but using this in AdePT and trying out B5 still leads to errors from
`AdePTG4Integration::visitGeometry`.

That's sort of expected as the translation between Geant4 and VecGeom
means that there will be N VecGeom placements for each replicated
volume, N corresponding to the total number of replicas. Consequently,
the checks in `visitGeometry` fail as:

1. The number of daughters in a given LV may be larger
2. Volume transformations may not match up as the original "parent"
volume in Geant4 is compared against some copy of the replicated volume
in VecGeom
    
The changes here address this, at least as far as the B5 geometry is
concerned:

1. The number of LV daughters on the Geant4 side are counted as the sum
of daughter multiplicities
   - For ordinary volumes this should be identical
- It should also work for a mix of daughters (some standard, some
parametrised), but this is untested.
2. The transformation problem is a bit hacky, though pretty much copies
what is done on the G4VG side:
- If the Geant4 PV provides a `G4VPVParametrisation`, use that to
transform it using the copy number of the compared VecGeom PV before
extracting the transform from the Geant4 PV
- If the Geant4 PV is a `G4PVReplica` use a `G4ReplicaNavigation` to do
the same as above.
- The hacky bit here is that use of this method requires a `const_cast`
on the Geant4 PV as the transform step is non-const...
- This does modify the underlying PV, but I think that's o.k (?) as it's
only relevant for the navigation stage.

Testing with a local build against B5 shows this to now run to
completion without error, but full validation has not been done yet
(that's probably best addressed separately).

Author: drbenmorgan

CMakeLists.txt

@@ -157,15 +157,16 @@ if(Geant4_FOUND)
     FetchContent_Declare(
       g4vg
       GIT_REPOSITORY https://github.com/celeritas-project/g4vg
-      GIT_TAG 638c273b744c7ac0fa865ddb15c161b853a4029b)
+      GIT_TAG f4308d392a502b7bd7468938f8d9a63198d3d866 # v1.0.3
+    )
     # G4VG builds static by default, so change this to shared to match current
     # way AdePT is built.
     # could also configure for PIC mode static.
     set(BUILD_SHARED_LIBS ON)
     FetchContent_MakeAvailable(g4vg)
     message(STATUS "Using FetchContent to build G4VG as part of AdePT")
   else()
-    find_package(G4VG 1.0.1 REQUIRED)
+    find_package(G4VG 1.0.3 REQUIRED)
     message(STATUS "Found G4VG: ${G4VG_DIR}")
   endif()
 endif()

src/AdePTGeant4Integration.cpp

@@ -17,6 +17,8 @@
 #include <G4FieldManager.hh>
 #include <G4RegionStore.hh>
 #include <G4TouchableHandle.hh>
+#include <G4PVReplica.hh>
+#include <G4ReplicaNavigation.hh>
 
 #include <G4HepEmState.hh>
 #include <G4HepEmData.hh>
@@ -183,16 +185,42 @@ void visitGeometry(G4VPhysicalVolume const *g4_pvol, vecgeom::VPlacedVolume cons
   const auto g4_lvol = g4_pvol->GetLogicalVolume();
   const auto vg_lvol = vg_pvol->GetLogicalVolume();
 
-  const size_t nd      = g4_lvol->GetNoDaughters();
+  // Geant4 Parameterised/Replica volumes are represented with direct placements in VecGeom
+  // To accurately compare the number of daughters, we need to sum multiplicity on Geant4 side
+  const size_t nd     = g4_lvol->GetNoDaughters();
+  size_t nd_converted = 0;
+  for (size_t daughter_id = 0; daughter_id < nd; ++daughter_id) {
+    const G4VPhysicalVolume *daughter_pvol = g4_lvol->GetDaughter(daughter_id);
+    nd_converted += daughter_pvol->GetMultiplicity();
+  }
+
   const auto daughters = vg_lvol->GetDaughters();
 
-  if (nd != daughters.size()) throw std::runtime_error("Fatal: CheckGeometry: Mismatch in number of daughters");
+  if (nd_converted != daughters.size())
+    throw std::runtime_error("Fatal: CheckGeometry: Mismatch in number of daughters");
+
   // Check if transformations are matching
+  // As above, with Parameterized/Replica volumes, we need to compare the transforms between
+  // the VG direct placement and that for the Parameterised/Replicated volume given the same copy
+  // number as that of the VG physical volume.
+  // NOTE:
+  // 1. Nasty const_cast as currently known way to get transform is to directly transform the
+  //    Geant4 phys vol before extracting, which is non-const....
+  // 2. ...this does modify the physical volume, but this is _probably_ o.k. as actual navigation
+  //    will reset things o.k.
+  if (G4VPVParameterisation *param = g4_pvol->GetParameterisation()) {
+    param->ComputeTransformation(vg_pvol->GetCopyNo(), const_cast<G4VPhysicalVolume *>(g4_pvol));
+  } else if (auto *replica = dynamic_cast<G4PVReplica *>(const_cast<G4VPhysicalVolume *>(g4_pvol))) {
+    G4ReplicaNavigation nav;
+    nav.ComputeTransformation(vg_pvol->GetCopyNo(), replica);
+  }
+
   const auto g4trans            = g4_pvol->GetTranslation();
   const G4RotationMatrix *g4rot = g4_pvol->GetRotation();
   G4RotationMatrix idrot;
   const auto vgtransformation = vg_pvol->GetTransformation();
   constexpr double epsil      = 1.e-8;
+
   for (int i = 0; i < 3; ++i) {
     if (std::abs(g4trans[i] - vgtransformation->Translation(i)) > epsil)
       throw std::runtime_error(