Reusing mesh when saving to Fides

cpp/dolfinx/io/ADIOS2Writers.cpp

@@ -716,16 +716,18 @@ void ADIOS2Writer::close()
 //-----------------------------------------------------------------------------
 FidesWriter::FidesWriter(MPI_Comm comm, const std::filesystem::path& filename,
                          std::shared_ptr<const mesh::Mesh> mesh)
-    : ADIOS2Writer(comm, filename, "Fides mesh writer", mesh)
+    : ADIOS2Writer(comm, filename, "Fides mesh writer", mesh),
+      _mesh_reuse_policy(MeshPolicy::update)
 {
   assert(_io);
   assert(mesh);
   fides_initialize_mesh_attributes(*_io, *mesh);
 }
 //-----------------------------------------------------------------------------
 FidesWriter::FidesWriter(MPI_Comm comm, const std::filesystem::path& filename,
-                         const ADIOS2Writer::U& u)
-    : ADIOS2Writer(comm, filename, "Fides function writer", u)
+                         const ADIOS2Writer::U& u, MeshPolicy policy)
+    : ADIOS2Writer(comm, filename, "Fides function writer", u),
+      _mesh_reuse_policy(policy)
 {
   if (u.empty())
     throw std::runtime_error("FidesWriter fem::Function list is empty");
@@ -800,7 +802,12 @@ void FidesWriter::write(double t)
   adios2::Variable<double> var_step = define_variable<double>(*_io, "step");
   _engine->Put<double>(var_step, t);
 
-  fides_write_mesh(*_io, *_engine, *_mesh);
+  if (auto v = _io->InquireVariable<std::int64_t>("connectivity");
+      !v or _mesh_reuse_policy == MeshPolicy::update)
+  {
+    fides_write_mesh(*_io, *_engine, *_mesh);
+  }
+
   for (auto& v : _u)
     std::visit([&](const auto& u) { fides_write_data(*_io, *_engine, *u); }, v);
 

cpp/dolfinx/io/ADIOS2Writers.h

@@ -112,9 +112,17 @@ class ADIOS2Writer
 class FidesWriter : public ADIOS2Writer
 {
 public:
-  /// @brief  Create Fides writer for a mesh.
-  /// @param[in] comm The MPI communicator to open the file on.
-  /// @param[in] filename Name of output file.
+  /// Mesh reuse policy
+  enum class MeshPolicy
+  {
+    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  Create Fides writer for a mesh
+  /// @param[in] comm The MPI communicator to open the file on
+  /// @param[in] filename Name of output file
   /// @param[in] mesh The mesh. The mesh must a degree 1 mesh.
   /// @note The mesh geometry can be updated between write steps but the
   /// topology should not be changed between write steps.
@@ -127,8 +135,12 @@ class FidesWriter : public ADIOS2Writer
   /// @param[in] u List of functions. The functions must (1) share the
   /// same mesh (degree 1) and (2) be degree 1 Lagrange. @note All
   /// functions in `u` must share the same Mesh
+  /// @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.
   FidesWriter(MPI_Comm comm, const std::filesystem::path& filename,
-              const ADIOS2Writer::U& u);
+              const ADIOS2Writer::U& u,
+              const MeshPolicy mesh_policy = MeshPolicy::update);
 
   // Copy constructor
   FidesWriter(const FidesWriter&) = delete;
@@ -148,6 +160,10 @@ class FidesWriter : public ADIOS2Writer
   /// @brief Write data with a given time
   /// @param[in] t The time step
   void write(double t);
+
+private:
+  // Control whether the mesh is written to file once or at every time step
+  MeshPolicy _mesh_reuse_policy;
 };
 
 /// @brief Writer for meshes and functions using the ADIOS2 VTX format,

python/dolfinx/wrappers/io.cpp

@@ -177,56 +177,58 @@ void io(py::module& m)
 
 #ifdef HAS_ADIOS2
   // dolfinx::io::FidesWriter
-  std::string pyclass_name = std::string("FidesWriter");
   py::class_<dolfinx::io::FidesWriter,
-             std::shared_ptr<dolfinx::io::FidesWriter>>(m, pyclass_name.c_str(),
-                                                        "FidesWriter object")
+             std::shared_ptr<dolfinx::io::FidesWriter>>
+      fides_writer(m, "FidesWriter", "FidesWriter object");
+
+  py::enum_<dolfinx::io::FidesWriter::MeshPolicy>(fides_writer, "MeshPolicy")
+      .value("update", dolfinx::io::FidesWriter::MeshPolicy::update)
+      .value("reuse", dolfinx::io::FidesWriter::MeshPolicy::reuse);
+
+  fides_writer
       .def(py::init(
-               [](const MPICommWrapper comm,
-                  const std::filesystem::path& filename,
+               [](MPICommWrapper comm, std::filesystem::path filename,
                   std::shared_ptr<const dolfinx::mesh::Mesh> mesh)
                {
                  return std::make_unique<dolfinx::io::FidesWriter>(
                      comm.get(), filename, mesh);
                }),
            py::arg("comm"), py::arg("filename"), py::arg("mesh"))
       .def(py::init(
-               [](const MPICommWrapper comm,
-                  const std::filesystem::path& filename,
+               [](MPICommWrapper comm, std::filesystem::path filename,
                   const std::vector<std::variant<
                       std::shared_ptr<const dolfinx::fem::Function<float>>,
                       std::shared_ptr<const dolfinx::fem::Function<double>>,
                       std::shared_ptr<
                           const dolfinx::fem::Function<std::complex<float>>>,
                       std::shared_ptr<const dolfinx::fem::Function<
-                          std::complex<double>>>>>& u)
+                          std::complex<double>>>>>& u,
+                  dolfinx::io::FidesWriter::MeshPolicy policy)
                {
-                 return std::make_unique<dolfinx::io::FidesWriter>(comm.get(),
-                                                                   filename, u);
+                 return std::make_unique<dolfinx::io::FidesWriter>(
+                     comm.get(), filename, u, policy);
                }),
-           py::arg("comm"), py::arg("filename"), py::arg("u"))
+           py::arg("comm"), py::arg("filename"), py::arg("u"),
+           py::arg("policy") = dolfinx::io::FidesWriter::MeshPolicy::update)
       .def("close", [](dolfinx::io::FidesWriter& self) { self.close(); })
       .def(
           "write",
           [](dolfinx::io::FidesWriter& self, double t) { self.write(t); },
           py::arg("t"));
 
   // dolfinx::io::VTXWriter
-  pyclass_name = std::string("VTXWriter");
   py::class_<dolfinx::io::VTXWriter, std::shared_ptr<dolfinx::io::VTXWriter>>(
-      m, pyclass_name.c_str(), "VTXWriter object")
+      m, "VTXWriter", "VTXWriter object")
       .def(py::init(
-               [](const MPICommWrapper comm,
-                  const std::filesystem::path& filename,
+               [](MPICommWrapper comm, std::filesystem::path filename,
                   std::shared_ptr<const dolfinx::mesh::Mesh> mesh)
                {
                  return std::make_unique<dolfinx::io::VTXWriter>(
                      comm.get(), filename, mesh);
                }),
            py::arg("comm"), py::arg("filename"), py::arg("mesh"))
       .def(py::init(
-               [](const MPICommWrapper comm,
-                  const std::filesystem::path& filename,
+               [](MPICommWrapper comm, std::filesystem::path filename,
                   const std::vector<std::variant<
                       std::shared_ptr<const dolfinx::fem::Function<float>>,
                       std::shared_ptr<const dolfinx::fem::Function<double>>,