[WIP] put all recursive meshes in Iteration::meshes

Doesn't really work due to legacy definition of Iteration::meshes, maybe
introduce sth like Iteration::all_meshes()

Author: franzpoeschel

include/openPMD/CustomHierarchy.hpp

@@ -228,10 +228,21 @@ class CustomHierarchy : public ConversibleContainer<CustomHierarchy>
     CustomHierarchy();
     CustomHierarchy(NoInit);
 
-    void read(internal::MeshesParticlesPath const &);
+    inline void setData(std::shared_ptr<Data_t> data)
+    {
+        m_customHierarchyData = data;
+        Container_t::setData(std::move(data));
+    }
+
+    void read(
+        internal::MeshesParticlesPath const &,
+        Container<Mesh> meshes,
+        Container<ParticleSpecies> particles);
     void read(
         internal::MeshesParticlesPath const &,
-        std::vector<std::string> &currentPath);
+        std::vector<std::string> &currentPath,
+        Container<Mesh> meshes,
+        Container<ParticleSpecies> particles);
 
     void flush_internal(
         internal::FlushParams const &,

src/CustomHierarchy.cpp

@@ -376,15 +376,45 @@ void CustomHierarchy::readParticleSpecies(
     }
 }
 
-void CustomHierarchy::read(internal::MeshesParticlesPath const &mpp)
+void CustomHierarchy::read(
+    internal::MeshesParticlesPath const &mpp,
+    Container<Mesh> meshes,
+    Container<ParticleSpecies> particles)
 {
     std::vector<std::string> currentPath;
-    read(mpp, currentPath);
+    read(mpp, currentPath, meshes, particles);
 }
 
+namespace
+{
+    template <typename T>
+    void add_to_meshes_particles_view(
+        std::vector<std::string> const &currentPath,
+        std::string const &defaultMeshesParticlesPath,
+        Container<T> &meshesOrParticles,
+        std::string const &name,
+        T &meshOrParticle)
+    {
+        if (currentPath.empty())
+        {
+            throw std::runtime_error(
+                "Meshes or particles cannot be part of the root group.");
+        }
+        auto concatenatedName = concatWithSep(currentPath, "/");
+        concatenatedName.append(1, '/').append(name);
+        meshesOrParticles[concatenatedName] = meshOrParticle;
+        if (concatenatedName == defaultMeshesParticlesPath + '/' + name)
+        {
+            meshesOrParticles[name] = meshOrParticle;
+        }
+    }
+} // namespace
+
 void CustomHierarchy::read(
     internal::MeshesParticlesPath const &mpp,
-    std::vector<std::string> &currentPath)
+    std::vector<std::string> &currentPath,
+    Container<Mesh> meshes,
+    Container<ParticleSpecies> particles)
 {
     /*
      * Convention for CustomHierarchy::flush and CustomHierarchy::read:
@@ -416,7 +446,7 @@ void CustomHierarchy::read(
             currentPath.emplace_back(path);
             try
             {
-                subpath.read(mpp, currentPath);
+                subpath.read(mpp, currentPath, meshes, particles);
             }
             catch (error::ReadError const &err)
             {
@@ -442,6 +472,12 @@ void CustomHierarchy::read(
             try
             {
                 readNonscalarMesh(meshesMap, path);
+                add_to_meshes_particles_view(
+                    currentPath,
+                    mpp.m_defaultMeshesPath,
+                    meshes,
+                    path,
+                    meshesMap[path]);
             }
             catch (error::ReadError const &err)
             {
@@ -451,12 +487,19 @@ void CustomHierarchy::read(
                           << err.what() << std::endl;
                 meshesMap.forget(path);
             }
+
             break;
         }
         case internal::ContainedType::Particle: {
             try
             {
                 readParticleSpecies(particlesMap, path);
+                add_to_meshes_particles_view(
+                    currentPath,
+                    mpp.m_defaultParticlesPath,
+                    particles,
+                    path,
+                    particlesMap[path]);
             }
             catch (error::ReadError const &err)
             {
@@ -514,12 +557,18 @@ void CustomHierarchy::read(
             try
             {
                 readScalarMesh(meshesMap, path);
+                add_to_meshes_particles_view(
+                    currentPath,
+                    mpp.m_defaultMeshesPath,
+                    meshes,
+                    path,
+                    meshesMap[path]);
             }
             catch (error::ReadError const &err)
             {
-                std::cerr << "Cannot read scalar mesh at location '"
+                std::cerr << "Cannot read mesh at location '"
                           << myPath().openPMDPath() << "/" << path
-                          << "' and will skip it due to read error:\n"
+                          << "' and will skip them due to read error:\n"
                           << err.what() << std::endl;
                 meshesMap.forget(path);
             }

src/Iteration.cpp

@@ -411,9 +411,9 @@ void Iteration::sync_meshes_and_particles_from_alias_to_subgroups(
             {
                 if (auxiliary::contains(name, '/'))
                 {
-                    throw std::runtime_error(
-                        "Unimplemented: Multi-level paths in "
-                        "Iteration::meshes/Iteration::particles");
+                    // throw std::runtime_error(
+                    //     "Unimplemented: Multi-level paths in "
+                    //     "Iteration::meshes/Iteration::particles");
                 }
                 if (auto it = container.find(name); it != container.end())
                 {
@@ -609,9 +609,7 @@ void Iteration::read_impl(std::string const &groupPath)
     //   hasMeshes <-> meshesPath is defined
 
     internal::MeshesParticlesPath mpp(s.meshesPaths(), s.particlesPaths());
-    CustomHierarchy::read(mpp);
-
-    sync_meshes_and_particles_from_subgroups_to_alias(mpp);
+    CustomHierarchy::read(mpp, meshes, particles);
 
 #ifdef openPMD_USE_INVASIVE_TESTS
     if (containsAttribute("__openPMD_internal_fail"))