Implement nested volumes (#141)

* make PopulateFromGeant4World dive into daughter volumes recursevily and extract Geant4 volume paths

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* process daughters first to preserve same volume ID as before

* avoid blank name for world_PV

* traverse the volumes just once and use the reverse mapping fNewPhysicalToGeant4PhysicalNameMap

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* fix filling of fPhysicalToPositionInWorldMap

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: AlvaroEzq

src/DetectorConstruction.cxx

@@ -241,10 +241,16 @@ G4VPhysicalVolume* DetectorConstruction::GetPhysicalVolume(const G4String& physi
     for (physicalVolume = physicalVolumeStore->begin(); physicalVolume != physicalVolumeStore->end();
          physicalVolume++) {
         auto name = (*physicalVolume)->GetName();
-        auto alternativeName = (G4String)geometryInfo.GetAlternativeNameFromGeant4PhysicalName(name);
-        if (name == physicalVolumeName || alternativeName == physicalVolumeName) {
+        if (name == physicalVolumeName) {
             return *physicalVolume;
         }
+        // physical volumes with the same Geant4 name are the same G4VPhysicalVolume pointer
+        auto alternativeNames = geometryInfo.GetAlternativeNamesFromGeant4PhysicalName(name);
+        for (const auto& alternativeName : alternativeNames) {
+            if ((G4String)alternativeName == physicalVolumeName) {
+                return *physicalVolume;
+            }
+        }
     }
 
     return nullptr;
@@ -312,40 +318,65 @@ void TRestGeant4GeometryInfo::PopulateFromGeant4World(const G4VPhysicalVolume* w
     auto detector = (DetectorConstruction*)G4RunManager::GetRunManager()->GetUserDetectorConstruction();
     TRestGeant4Metadata* restG4Metadata = detector->fSimulationManager->GetRestMetadata();
 
-    const size_t n = int(world->GetLogicalVolume()->GetNoDaughters());
-    for (size_t i = 0; i < n + 1; i++) {  // world is the + 1
-        G4VPhysicalVolume* volume;
-        if (i == n) {
-            volume = const_cast<G4VPhysicalVolume*>(world);
-        } else {
-            volume = world->GetLogicalVolume()->GetDaughter(i);
-        }
-        TString namePhysical = (TString)volume->GetName();
-        if (fGdmlNewPhysicalNames.size() > i) {
-            // it has been filled
-            fGeant4PhysicalNameToNewPhysicalNameMap[namePhysical] = fGdmlNewPhysicalNames[i];
-        }
-        TString physicalNewName = GetAlternativeNameFromGeant4PhysicalName(namePhysical);
-        TString nameLogical = (TString)volume->GetLogicalVolume()->GetName();
-        TString nameMaterial = (TString)volume->GetLogicalVolume()->GetMaterial()->GetName();
-        auto position = volume->GetTranslation();
-
-        fPhysicalToLogicalVolumeMap[physicalNewName] = nameLogical;
-        fLogicalToMaterialMap[nameLogical] = nameMaterial;
-        fLogicalToPhysicalMap[nameLogical].emplace_back(namePhysical);
-        fPhysicalToPositionInWorldMap[physicalNewName] = {position.x(), position.y(), position.z()};
-        InsertVolumeName(i, physicalNewName);
-
-        if (!fIsAssembly && GetAlternativeNameFromGeant4PhysicalName(namePhysical) != namePhysical) {
-            fIsAssembly = true;
-
-            const auto geant4MajorVersionNumber = restG4Metadata->GetGeant4VersionMajor();
-            if (geant4MajorVersionNumber < 11) {
-                cout << "User geometry consists of assembly which is not supported for this rest / Geant4 "
-                        "version combination. Please upgrade to Geant4 11.0.0 or more to use this feature"
-                     << endl;
-                // exit(1);
+    // Recursive function to traverse the nested volume geometry
+    std::function<void(const G4VPhysicalVolume*, size_t&, const G4String pathSoFar, const G4ThreeVector&)>
+        ProcessVolumeRecursively = [&](const G4VPhysicalVolume* volume, size_t& index,
+                                       const G4String pathSoFar, const G4ThreeVector& parentPosition) {
+            G4String currentPath = pathSoFar;
+            if (volume->GetName() != world->GetName()) {  // avoid all paths including 'world_PV/' at the
+                                                          // beginning
+                currentPath += (currentPath.empty() ? "" : fPathSeparator.Data()) + volume->GetName();
             }
-        }
-    }
+            G4ThreeVector positionInWorld = volume->GetTranslation() + parentPosition;
+
+            // First process the daughters to have the same order in volume IDs as before
+            G4LogicalVolume* logVol = volume->GetLogicalVolume();
+            for (size_t i = 0; i < logVol->GetNoDaughters(); ++i) {
+                G4VPhysicalVolume* daughter = logVol->GetDaughter(i);
+                ProcessVolumeRecursively(daughter, index, currentPath, positionInWorld);
+            }
+
+            // Process this volume
+            G4String namePhysical = volume->GetName();
+            TString physicalNewName = GetAlternativePathFromGeant4Path(currentPath);
+            if (namePhysical == world->GetName()) {
+                physicalNewName = namePhysical;  // avoid blank name for World_PV
+            }
+            fNewPhysicalToGeant4PhysicalNameMap[physicalNewName] = namePhysical;
+
+            TString nameLogical = (TString)volume->GetLogicalVolume()->GetName();
+            TString nameMaterial = (TString)volume->GetLogicalVolume()->GetMaterial()->GetName();
+            fPhysicalToLogicalVolumeMap[physicalNewName] = nameLogical;
+            fLogicalToMaterialMap[nameLogical] = nameMaterial;
+            fLogicalToPhysicalMap[nameLogical].emplace_back(namePhysical);
+            fPhysicalToPositionInWorldMap[physicalNewName] = {positionInWorld.x(), positionInWorld.y(),
+                                                              positionInWorld.z()};
+            InsertVolumeName(index, physicalNewName);
+            /*
+            std::cout << "Index: " << index << std::endl;
+            std::cout << "\tG4name: " << namePhysical << std::endl;
+            std::cout << "\tgdmlName: " << physicalNewName << std::endl;
+            std::cout << "\tLogical: " << nameLogical << std::endl;
+            std::cout << "\tMaterial: " << nameMaterial << std::endl;
+            std::cout << "\tPosition: (" << positionInWorld.x() << ", " << positionInWorld.y() << ", " <<
+            positionInWorld.z() << ")mm" << std::endl;
+            */
+            if (!fIsAssembly &&
+                GetAlternativeNameFromGeant4PhysicalName(namePhysical).Data() != namePhysical) {
+                fIsAssembly = true;
+                const auto geant4MajorVersionNumber = restG4Metadata->GetGeant4VersionMajor();
+                if (geant4MajorVersionNumber < 11) {
+                    cout
+                        << "User geometry consists of assembly which is not supported for this rest / Geant4 "
+                           "version combination. Please upgrade to Geant4 11.0.0 or more to use this feature"
+                        << endl;
+                    // exit(1);
+                }
+            }
+            ++index;
+        };
+
+    // Start recursion from world volume
+    size_t index = 0;
+    ProcessVolumeRecursively(world, index, "", G4ThreeVector(0, 0, 0));
 }