General concepts » I/O in Rodin

Loading Meshes

Meshes can be loaded from files in supported formats using the Mesh::load() method. The file format must be explicitly specified via IO::FileFormat:

#include <Rodin/Geometry.h>

using namespace Rodin;
using namespace Rodin::Geometry;

int main()
{
  Mesh mesh;

  // Load MFEM format
  mesh.load("domain.mesh", IO::FileFormat::MFEM);

  // Load MEDIT format (commonly used with MMG)
  mesh.load("domain.mesh", IO::FileFormat::MEDIT);

  return 0;
}

Saving Meshes

Meshes can be saved in any of the supported formats:

Mesh mesh;
mesh = mesh.UniformGrid(Polytope::Type::Triangle, {16, 16});

// Save in MFEM format
mesh.save("output.mesh", IO::FileFormat::MFEM);

// Save in MEDIT format
mesh.save("output.mesh", IO::FileFormat::MEDIT);

Format Conversion

A common workflow is to convert meshes between formats. For example, loading a MEDIT mesh (from MMG) and saving it in MFEM format:

Mesh mesh;
mesh.load("input.mesh", IO::FileFormat::MEDIT);
mesh.save("output.mesh", IO::FileFormat::MFEM);

Why Use XDMF?

XDMF has several advantages over other formats:

• Efficient: Uses HDF5 for binary storage, leading to compact files and fast read/write
• Scalable: Supports very large datasets without excessive memory usage
• ParaView compatible: Directly loadable in ParaView for advanced 3D visualization
• Time series: Built-in support for time-dependent data with temporal collections
• Multiple fields: Export several grid functions (velocity, pressure, temperature, etc.) in a single output

Basic XDMF Usage

The simplest use case is to export a mesh and solution at a single time step:

#include <Rodin/Geometry.h>
#include <Rodin/Variational.h>
#include <Rodin/IO/XDMF.h>

using namespace Rodin;
using namespace Rodin::Geometry;
using namespace Rodin::Variational;

int main()
{
  Mesh mesh;
  mesh = mesh.UniformGrid(Polytope::Type::Triangle, {16, 16});
  mesh.getConnectivity().compute(1, 2);

  P1 Vh(mesh);
  TrialFunction u(Vh);
  TestFunction  v(Vh);

  // ... solve a problem ...

  // Export to XDMF for visualization in ParaView
  IO::XDMF xdmf("MySimulation");
  xdmf.grid().setMesh(mesh).add("u", u.getSolution());
  xdmf.write();

  return 0;
}

This produces:

• MySimulation.xdmf — XML metadata file (open this in ParaView)
• MySimulation.*.h5 — HDF5 data files with mesh and field data

Time-Dependent Output

One of the most powerful features of XDMF is its ability to record time-evolving data. Use write(time) to record snapshots at different time values:

#include <Rodin/Geometry.h>
#include <Rodin/Variational.h>
#include <Rodin/IO/XDMF.h>
#include <Rodin/Math/Constants.h>

using namespace Rodin;
using namespace Rodin::Geometry;
using namespace Rodin::Variational;

int main()
{
  const Real dt = 0.05;
  const size_t Nt = 40;
  const size_t Nc = 32;

  // Create mesh
  Mesh mesh;
  mesh = mesh.UniformGrid(Polytope::Type::Triangle, { Nc, Nc });
  mesh.scale(1.0 / (Nc - 1));

  // Create finite element space (vector-valued, 2 components)
  P1 fes(mesh, 2);

  // Evolving field
  GridFunction u(fes);
  u.setName("u");

  // Setup XDMF writer
  IO::XDMF xdmf("TimeEvolution");
  auto grid = xdmf.grid();
  grid.setMesh(mesh);
  grid.add(u);   // register the vector field

  // Time loop
  for (size_t k = 0; k < Nt; ++k)
  {
    const Real t = k * dt;

    // Update the field at current time
    u = [t](const Geometry::Point& p)
    {
      const Real x = p.x();
      const Real y = p.y();
      return Math::Vector<Real>{{
        std::sin(2.0 * Math::Constants::pi() * (x + t)),
        std::cos(2.0 * Math::Constants::pi() * (y - t))
      }};
    };

    // Write snapshot at time t
    xdmf.write(t);
  }

  return 0;
}

When opened in ParaView, this produces a time slider that lets you animate the field evolution.

Multiple Fields

You can export several fields (scalar, vector) at once:

IO::XDMF xdmf("MultiField");
auto grid = xdmf.grid();
grid.setMesh(mesh);
grid.add("velocity", velocity);
grid.add("pressure", pressure);
grid.add("temperature", temperature);
xdmf.write(t);

Multiple Grids

You can also work with multiple named grids, each with its own mesh and attributes:

IO::XDMF xdmf("MultiGrid");

auto fluidGrid = xdmf.grid("Fluid");
fluidGrid.setMesh(fluidMesh);
fluidGrid.add("velocity", velocity);

auto solidGrid = xdmf.grid("Solid");
solidGrid.setMesh(solidMesh);
solidGrid.add("displacement", displacement);

xdmf.write(t);

Viewing XDMF Files in ParaView

To visualize XDMF output in ParaView:

1. Open ParaView
2. Click File → Open and select the .xdmf file
3. Click Apply in the Properties panel
4. Select the field to display from the dropdown menu
5. For time-dependent data, use the play/timeline controls to animate

Using MMG

MMG is used for mesh adaptation and optimization. MMG uses the MEDIT format, which Rodin supports natively:

Mesh mesh;
mesh.load("mmg_output.mesh", IO::FileFormat::MEDIT);

See the MMG examples for more details on using Rodin's MMG integration.