Reuse mesh when saving to VTX

cpp/demo/interpolation-io/main.cpp

@@ -65,7 +65,7 @@ void interpolate_scalar(std::shared_ptr<mesh::Mesh<U>> mesh,
 #endif
 }
 
-// This function interpolations a function is a H(curl) finite element
+// This function interpolates a function in a H(curl) finite element
 // space. To visualise the function, it interpolates the H(curl) finite
 // element function in a discontinuous Lagrange space and outputs the
 // Lagrange finite element function to a VTX file for visualisation.

cpp/dolfinx/fem/utils.h

@@ -707,8 +707,8 @@ FunctionSpace<T> create_functionspace(
 
 /// @brief Create a FunctionSpace from UFC data.
 /// @param[in] fptr Pointer to a ufcx_function_space_create function.
-/// @param[in] function_name Name of a function whose function space to
-/// create. Function name is the name of Python variable for
+/// @param[in] function_name Name of a function whose function space is to
+/// create. Function name is the name of the Python variable for
 /// ufl.Coefficient, ufl.TrialFunction or ufl.TestFunction as defined in
 /// the UFL file.
 /// @param[in] mesh Mesh

cpp/dolfinx/io/ADIOS2Writers.h

@@ -780,8 +780,9 @@ void vtx_write_mesh(adios2::IO& io, adios2::Engine& engine,
 /// @param[in] engine The ADIOS2 engine object
 /// @param[in] V The function space
 template <std::floating_point T>
-void vtx_write_mesh_from_space(adios2::IO& io, adios2::Engine& engine,
-                               const fem::FunctionSpace<T>& V)
+std::pair<std::vector<std::int64_t>, std::vector<std::uint8_t>>
+vtx_write_mesh_from_space(adios2::IO& io, adios2::Engine& engine,
+                          const fem::FunctionSpace<T>& V)
 {
   auto mesh = V.mesh();
   assert(mesh);
@@ -839,9 +840,18 @@ void vtx_write_mesh_from_space(adios2::IO& io, adios2::Engine& engine,
   engine.Put(ghost, x_ghost.data());
 
   engine.PerformPuts();
+  return {std::move(x_id), std::move(x_ghost)};
 }
 } // namespace impl_vtx
 
+/// Mesh reuse policy
+enum class VTXMeshPolicy
+{
+  update, ///< Re-write the mesh to file upon every write of a fem::Function
+  reuse   ///< Write the mesh to file only the first time a fem::Function is
+          ///< written to file
+};
+
 /// @brief Writer for meshes and functions using the ADIOS2 VTX format,
 /// see
 /// https://adios2.readthedocs.io/en/latest/ecosystem/visualization.html#using-vtk-and-paraview.
@@ -865,7 +875,8 @@ class VTXWriter : public ADIOS2Writer
   VTXWriter(MPI_Comm comm, const std::filesystem::path& filename,
             std::shared_ptr<const mesh::Mesh<T>> mesh,
             std::string engine = "BPFile")
-      : ADIOS2Writer(comm, filename, "VTX mesh writer", engine), _mesh(mesh)
+      : ADIOS2Writer(comm, filename, "VTX mesh writer", engine), _mesh(mesh),
+        _mesh_reuse_policy(VTXMeshPolicy::update)
   {
     // Define VTK scheme attribute for mesh
     std::string vtk_scheme = impl_vtx::create_vtk_schema({}, {}).str();
@@ -883,12 +894,16 @@ class VTXWriter : public ADIOS2Writer
   /// element family and degree, and degree-of-freedom map (up to the
   /// blocksize) must be the same for all functions.
   /// @param[in] engine ADIOS2 engine type.
+  /// @param[in] mesh_policy Controls if the mesh is written to file at
+  /// the first time step only or is re-written (updated) at each time
+  /// step.
   /// @note This format supports arbitrary degree meshes.
   VTXWriter(MPI_Comm comm, const std::filesystem::path& filename,
-            const typename adios2_writer::U<T>& u,
-            std::string engine = "BPFile")
+            const typename adios2_writer::U<T>& u, std::string engine,
+            VTXMeshPolicy mesh_policy = VTXMeshPolicy::update)
       : ADIOS2Writer(comm, filename, "VTX function writer", engine),
-        _mesh(impl_adios2::extract_common_mesh<T>(u)), _u(u)
+        _mesh(impl_adios2::extract_common_mesh<T>(u)),
+        _mesh_reuse_policy(mesh_policy), _u(u)
   {
     if (u.empty())
       throw std::runtime_error("VTXWriter fem::Function list is empty.");
@@ -960,6 +975,27 @@ class VTXWriter : public ADIOS2Writer
     impl_adios2::define_attribute<std::string>(*_io, "vtk.xml", vtk_scheme);
   }
 
+  /// @brief Create a VTX writer for a list of fem::Functions using
+  /// the default ADIOS2 engine.
+  ///
+  /// This format supports arbitrary degree meshes.
+  ///
+  /// @param[in] comm The MPI communicator to open the file on
+  /// @param[in] filename Name of output file
+  /// @param[in] u List of functions. The functions must (1) share the
+  /// same mesh and (2) be (discontinuous) Lagrange functions. The
+  /// element family and degree must be the same for all functions.
+  /// @param[in] mesh_policy Controls if the mesh is written to file at
+  /// the first time step only or is re-written (updated) at each time
+  /// step.
+  /// @note This format supports arbitrary degree meshes.
+  VTXWriter(MPI_Comm comm, const std::filesystem::path& filename,
+            const typename adios2_writer::U<T>& u,
+            VTXMeshPolicy mesh_policy = VTXMeshPolicy::update)
+      : VTXWriter(comm, filename, u, "BPFile", mesh_policy)
+  {
+  }
+
   // Copy constructor
   VTXWriter(const VTXWriter&) = delete;
 
@@ -975,14 +1011,15 @@ class VTXWriter : public ADIOS2Writer
   // Copy assignment
   VTXWriter& operator=(const VTXWriter&) = delete;
 
-  /// @brief  Write data with a given time
-  /// @param[in] t The time step
+  /// @brief Write data with a given time stamp.
+  /// @param[in] t Time stamp to associate with output.
   void write(double t)
   {
     assert(_io);
-    assert(_engine);
     adios2::Variable var_step
         = impl_adios2::define_variable<double>(*_io, "step");
+
+    assert(_engine);
     _engine->BeginStep();
     _engine->template Put<double>(var_step, t);
 
@@ -991,18 +1028,37 @@ class VTXWriter : public ADIOS2Writer
       impl_vtx::vtx_write_mesh(*_io, *_engine, *_mesh);
     else
     {
-      // Write a single mesh for functions as they share finite element
-      std::visit(
-          [&](auto& u) {
-            impl_vtx::vtx_write_mesh_from_space(*_io, *_engine,
-                                                *u->function_space());
-          },
-          _u[0]);
+      if (_mesh_reuse_policy == VTXMeshPolicy::update
+          or !(_io->template InquireVariable<std::int64_t>("connectivity")))
+      {
+        // Write a single mesh for functions as they share finite
+        // element
+        std::tie(_x_id, _x_ghost) = std::visit(
+            [&](auto& u)
+            {
+              return impl_vtx::vtx_write_mesh_from_space(*_io, *_engine,
+                                                         *u->function_space());
+            },
+            _u[0]);
+      }
+      else
+      {
+        // Node global ids
+        adios2::Variable orig_id = impl_adios2::define_variable<std::int64_t>(
+            *_io, "vtkOriginalPointIds", {}, {}, {_x_id.size()});
+        _engine->Put(orig_id, _x_id.data());
+        adios2::Variable ghost = impl_adios2::define_variable<std::uint8_t>(
+            *_io, "vtkGhostType", {}, {}, {_x_ghost.size()});
+        _engine->Put(ghost, _x_ghost.data());
+        _engine->PerformPuts();
+      }
 
       // Write function data for each function to file
       for (auto& v : _u)
+      {
         std::visit(
             [&](auto& u) { impl_vtx::vtx_write_data(*_io, *_engine, *u); }, v);
+      }
     }
 
     _engine->EndStep();
@@ -1011,6 +1067,12 @@ class VTXWriter : public ADIOS2Writer
 private:
   std::shared_ptr<const mesh::Mesh<T>> _mesh;
   adios2_writer::U<T> _u;
+
+  // Control whether the mesh is written to file once or at every time
+  // step
+  VTXMeshPolicy _mesh_reuse_policy;
+  std::vector<std::int64_t> _x_id;
+  std::vector<std::uint8_t> _x_ghost;
 };
 
 /// Type deduction

python/dolfinx/fem/petsc.py

@@ -382,7 +382,7 @@ def assemble_matrix_mat(A: PETSc.Mat, a: Form, bcs: typing.List[DirichletBC] = [
 def assemble_matrix_nest(a: typing.List[typing.List[Form]],
                          bcs: typing.List[DirichletBC] = [], mat_types=[],
                          diagonal: float = 1.0, constants=None, coeffs=None) -> PETSc.Mat:
-    """Create a nested matrix and assembled bilinear forms into the matrix.
+    """Create a nested matrix and assemble bilinear forms into the matrix.
 
     Args:
         a: Rectangular (list-of-lists) array for bilinear forms.

python/dolfinx/io/__init__.py

@@ -15,5 +15,6 @@
 if _cpp.common.has_adios2:
     # FidesWriter and VTXWriter require ADIOS2
     from dolfinx.io.utils import (FidesMeshPolicy, FidesWriter,  # noqa: F401
-                                  VTXWriter)
-    __all__ = __all__ + ["FidesWriter", "VTXWriter", "FidesMeshPolicy"]
+                                  VTXMeshPolicy, VTXWriter)
+    __all__ = __all__ + ["FidesWriter", "VTXWriter", "FidesMeshPolicy",
+                         "VTXMeshPolicy"]

python/dolfinx/io/utils.py

@@ -37,8 +37,9 @@ def _extract_cpp_functions(functions: typing.Union[typing.List[Function], Functi
 
 # FidesWriter and VTXWriter require ADIOS2
 if _cpp.common.has_adios2:
-    from dolfinx.cpp.io import FidesMeshPolicy  # noqa F401
-    __all__ = __all__ + ["FidesWriter", "VTXWriter", "FidesMeshPolicy"]
+    from dolfinx.cpp.io import FidesMeshPolicy, VTXMeshPolicy  # noqa F401
+    __all__ = __all__ + ["FidesWriter", "VTXWriter", "FidesMeshPolicy",
+                         "VTXMeshPolicy"]
 
     class VTXWriter:
         """Writer for VTX files, using ADIOS2 to create the files.
@@ -54,7 +55,8 @@ class VTXWriter:
 
         def __init__(self, comm: _MPI.Comm, filename: typing.Union[str, Path],
                      output: typing.Union[Mesh, Function, typing.List[Function]],
-                     engine: str = "BPFile"):
+                     engine: str = "BPFile",
+                     mesh_policy: VTXMeshPolicy = VTXMeshPolicy.update):
             """Initialize a writer for outputting data in the VTX format.
 
             Args:
@@ -65,6 +67,11 @@ def __init__(self, comm: _MPI.Comm, filename: typing.Union[str, Path],
                     (discontinuous Lagrange Functions.
                 engine: ADIOS2 engine to use for output. See
                     ADIOS2 documentation for options.
+                mesh_policy: Controls if the mesh is written to file at
+                    the first time step only when a ``Function`` is
+                    written to file, or is re-written (updated) at each
+                    time step. Has an effect only for ``Function``
+                    output.
 
             Note:
                 All Functions for output must share the same mesh and
@@ -90,7 +97,7 @@ def __init__(self, comm: _MPI.Comm, filename: typing.Union[str, Path],
             except (NotImplementedError, TypeError, AttributeError):
                 # Input is a single function or a list of functions
                 self._cpp_object = _vtxwriter(comm, filename, _extract_cpp_functions(
-                    output), engine)   # type: ignore[arg-type]
+                    output), engine, mesh_policy)   # type: ignore[arg-type]
 
         def __enter__(self):
             return self

python/dolfinx/la.py

@@ -214,7 +214,7 @@ def norm(self, type=_cpp.la.Norm.l2) -> np.floating:
         """Compute a norm of the vector.
 
         Args:
-            type: Norm type to computed.
+            type: Norm type to compute.
 
         Returns:
             Computed norm.

python/dolfinx/wrappers/io.cpp

@@ -130,12 +130,13 @@ void declare_vtx_writer(nb::module_& m, std::string type)
                        const dolfinx::fem::Function<std::complex<float>, T>>,
                    std::shared_ptr<const dolfinx::fem::Function<
                        std::complex<double>, T>>>>& u,
-               std::string engine) {
+               std::string engine, dolfinx::io::VTXMeshPolicy policy) {
               new (self)
-                  dolfinx::io::VTXWriter<T>(comm.get(), filename, u, engine);
+                  dolfinx::io::VTXWriter<T>(comm.get(), filename, u, engine, policy);
             },
             nb::arg("comm"), nb::arg("filename"), nb::arg("u"),
-            nb::arg("engine"))
+            nb::arg("engine") = "BPFile",
+            nb::arg("policy") = dolfinx::io::VTXMeshPolicy::update)
         .def("close", [](dolfinx::io::VTXWriter<T>& self) { self.close(); })
         .def(
             "write",
@@ -338,6 +339,10 @@ void io(nb::module_& m)
   nb::enum_<dolfinx::io::FidesMeshPolicy>(m, "FidesMeshPolicy")
       .value("update", dolfinx::io::FidesMeshPolicy::update)
       .value("reuse", dolfinx::io::FidesMeshPolicy::reuse);
+
+  nb::enum_<dolfinx::io::VTXMeshPolicy>(m, "VTXMeshPolicy")
+      .value("update", dolfinx::io::VTXMeshPolicy::update)
+      .value("reuse", dolfinx::io::VTXMeshPolicy::reuse);
 #endif
 
   declare_vtx_writer<float>(m, "float32");