Allow specifying attribute name when reading meshtag

cpp/dolfinx/io/XDMFFile.cpp

@@ -322,8 +322,9 @@ template void XDMFFile::write_meshtags(const mesh::MeshTags<std::int32_t>&,
 /// @endcond
 //-----------------------------------------------------------------------------
 mesh::MeshTags<std::int32_t>
-XDMFFile::read_meshtags(const mesh::Mesh<double>& mesh, std::string name,
-                        std::string xpath)
+XDMFFile::read_meshtags_by_name(const mesh::Mesh<double>& mesh,
+                                std::string name, std::string attribute_name,
+                                std::string xpath)
 {
   spdlog::info("XDMF read meshtags ({})", name);
   pugi::xml_node node = _xml_doc->select_node(xpath.c_str()).node();
@@ -336,8 +337,29 @@ XDMFFile::read_meshtags(const mesh::Mesh<double>& mesh, std::string name,
 
   const auto [entities, eshape] = read_topology_data(name, xpath);
 
-  pugi::xml_node values_data_node
-      = grid_node.child("Attribute").child("DataItem");
+  pugi::xml_node attribute_node = grid_node.child("Attribute");
+  pugi::xml_node values_data_node = attribute_node.child("DataItem");
+  if (not attribute_name.empty())
+  {
+    bool found = false;
+    for (; attribute_node;
+         attribute_node = attribute_node.next_sibling("Attribute"))
+    {
+      pugi::xml_attribute hint;
+      pugi::xml_attribute name = attribute_node.attribute("Name", hint);
+      if (std::string(name.value()) == attribute_name)
+      {
+        values_data_node = attribute_node.child("DataItem");
+        found = true;
+        break;
+      }
+    }
+    if (not found)
+    {
+      throw std::runtime_error("Attribute with name '" + attribute_name
+                               + "' not found.");
+    }
+  }
   const std::vector values = xdmf_utils::get_dataset<std::int32_t>(
       _comm.comm(), values_data_node, _h5_id);
 
@@ -376,6 +398,13 @@ XDMFFile::read_meshtags(const mesh::Mesh<double>& mesh, std::string name,
   return meshtags;
 }
 //-----------------------------------------------------------------------------
+mesh::MeshTags<std::int32_t>
+XDMFFile::read_meshtags(const mesh::Mesh<double>& mesh, std::string name,
+                        std::string xpath)
+{
+  return read_meshtags_by_name(mesh, name, "", xpath);
+}
+//-----------------------------------------------------------------------------
 std::pair<mesh::CellType, int> XDMFFile::read_cell_type(std::string grid_name,
                                                         std::string xpath)
 {

cpp/dolfinx/io/XDMFFile.h

@@ -164,6 +164,16 @@ class XDMFFile
                       const mesh::Geometry<T>& x, std::string geometry_xpath,
                       std::string xpath = "/Xdmf/Domain");
 
+  /// Read MeshTags by name
+  /// @param[in] mesh The Mesh that the data is defined on
+  /// @param[in] name
+  /// @param[in] attribute_name The name of the attribute to read
+  /// @param[in] xpath XPath where MeshTags Grid is stored in file
+  mesh::MeshTags<std::int32_t>
+  read_meshtags_by_name(const mesh::Mesh<double>& mesh, std::string name,
+                        std::string attribute_name,
+                        std::string xpath = "/Xdmf/Domain");
+
   /// Read MeshTags
   /// @param[in] mesh The Mesh that the data is defined on
   /// @param[in] name

python/dolfinx/io/utils.py

@@ -276,10 +276,13 @@ def read_mesh(
         )
         return Mesh(msh, domain)
 
-    def read_meshtags(self, mesh, name, xpath="/Xdmf/Domain"):
-        mt = super().read_meshtags(mesh._cpp_object, name, xpath)
+    def read_meshtags_by_name(self, mesh, name, attribute_name, xpath="/Xdmf/Domain"):
+        mt = super().read_meshtags_by_name(mesh._cpp_object, name, attribute_name, xpath)
         return MeshTags(mt)
 
+    def read_meshtags(self, mesh, name, xpath="/Xdmf/Domain"):
+        return self.read_meshtags_by_name(mesh, name, "", xpath)
+
 
 def distribute_entity_data(
     mesh: Mesh, entity_dim: int, entities: npt.NDArray[np.int64], values: np.ndarray

python/dolfinx/wrappers/io.cpp

@@ -142,8 +142,9 @@ void declare_vtx_writer(nb::module_& m, std::string type)
             nb::arg("policy") = dolfinx::io::VTXMeshPolicy::update)
         .def("close", [](dolfinx::io::VTXWriter<T>& self) { self.close(); })
         .def(
-            "write", [](dolfinx::io::VTXWriter<T>& self, double t)
-            { self.write(t); }, nb::arg("t"));
+            "write",
+            [](dolfinx::io::VTXWriter<T>& self, double t) { self.write(t); },
+            nb::arg("t"));
   }
 
   {
@@ -182,8 +183,9 @@ void declare_vtx_writer(nb::module_& m, std::string type)
             nb::arg("policy") = dolfinx::io::FidesMeshPolicy::update)
         .def("close", [](dolfinx::io::FidesWriter<T>& self) { self.close(); })
         .def(
-            "write", [](dolfinx::io::FidesWriter<T>& self, double t)
-            { self.write(t); }, nb::arg("t"));
+            "write",
+            [](dolfinx::io::FidesWriter<T>& self, double t) { self.write(t); },
+            nb::arg("t"));
   }
 #endif
 }
@@ -310,13 +312,19 @@ void io(nb::module_& m)
            nb::arg("name") = "mesh", nb::arg("xpath") = "/Xdmf/Domain")
       .def("read_meshtags", &dolfinx::io::XDMFFile::read_meshtags,
            nb::arg("mesh"), nb::arg("name"), nb::arg("xpath") = "/Xdmf/Domain")
+      .def("read_meshtags_by_name",
+           &dolfinx::io::XDMFFile::read_meshtags_by_name, nb::arg("mesh"),
+           nb::arg("name"), nb::arg("attribute_name"),
+           nb::arg("xpath") = "/Xdmf/Domain")
       .def("write_information", &dolfinx::io::XDMFFile::write_information,
            nb::arg("name"), nb::arg("value"), nb::arg("xpath") = "/Xdmf/Domain")
       .def("read_information", &dolfinx::io::XDMFFile::read_information,
            nb::arg("name"), nb::arg("xpath") = "/Xdmf/Domain")
       .def_prop_ro(
-          "comm", [](dolfinx::io::XDMFFile& self)
-          { return MPICommWrapper(self.comm()); }, nb::keep_alive<0, 1>());
+          "comm",
+          [](dolfinx::io::XDMFFile& self)
+          { return MPICommWrapper(self.comm()); },
+          nb::keep_alive<0, 1>());
 
   xdmf_real_fn<float>(xdmf_file);
   xdmf_real_fn<double>(xdmf_file);