SAMURAI Framework Webinar

The meeting presented Samurai as a data-structure and software framework for adaptive Cartesian meshes, with a distinctive representation based on intervals and an algebra of sets. The central idea is to recover advantages of patch-based AMR, such as memory locality and easy neighbor operations, while avoiding excessive refinement and hierarchy overhead.

For Exa-MA, the most relevant conclusions are:

Loic Gouarin introduced Samurai as a framework developed mainly in the HPC@Maths team at CMAP / Ecole Polytechnique. The central contribution is a data structure for adaptive Cartesian meshes that makes operations between grids explicit and compact.

The presentation compared two broad AMR representations:

The talk also contrasted AMR and MRA. AMR typically uses heuristic indicators such as gradients or second derivatives. MRA uses wavelet-like detail coefficients obtained by projection and prediction, which gives an error-control-oriented criterion but is harder to express with classical AMR data structures.

The slides identified four Samurai design principles:

The core object is an interval of the form:

For a 2D adaptive Cartesian mesh, Samurai stores contiguous runs of cells along the x direction, level by level, together with y-intervals and offsets that identify where the associated x-intervals are stored. This gives a compact representation while keeping data spatially contiguous where possible.

The set operations exposed in Samurai include:

These operations express mesh manipulations and numerical supports without explicit tree traversal. For example, jump regions can be found through translation and intersection:

Projection between levels can be written in the same algebraic style:

The important conclusion is that Samurai exposes AMR topology as algebraic manipulation of interval sets, rather than as explicit patch hierarchy management.

Samurai already has MPI support. The algebra of sets is used to define exchanged data, especially ghost and interface regions, through mesh translations and intersections rather than explicit recomputation of interfaces.

Load balancing remains work in progress. Candidate strategies include space-filling curves, Hilbert and Morton orderings, diffusion-based approaches, METIS, and Scotch. For MRA, re-adaptation may be needed at each iteration in order not to break the multiresolution logic, which makes repeated load balancing a delicate cost.

The slides described a GPU proof of concept with two possible strategies:

The current status is preliminary. Kokkos is viewed as a likely portability layer once the GPU strategy is clearer. The Samurai team does not consider the current code ready for the immediate MI300A/Adastra Grand Challenge.

Several NumPEx interactions were presented.

A central discussion point was whether Samurai should be viewed as a complete discretization framework or as an AMR infrastructure with an API for other method frameworks.

Loic’s answer was that finite-volume methods are currently still inside Samurai, but method-specific layers should ultimately move outside. Samurai should manage the mesh, provide operators to manipulate it, and attach fields to it. Finite volume, lattice Boltzmann, DG, and potentially HDG should become external method modules.

This is important for Exa-MA because Samurai can be positioned as a topological/adaptive Cartesian mesh infrastructure on which specialized numerical methods are implemented.

Christophe asked whether Samurai has an explicit notion of mesh skeleton: facets, edges, coarse/fine interfaces, orientations, normals, and cell-face connectivity. Loic answered that Samurai does not precompute such structures in the same way as an unstructured mesh framework. Because Samurai is Cartesian, many relations can be recovered through translations and intersections.

For HDG, the global coupling is the trace space on faces or facets, while local volume problems are discontinuous and element-local. The set algebra should make it possible to define the required trace or skeleton sets, but there is no dedicated HDG skeleton abstraction yet.

The discussion also considered Samurai cells or patches as adaptive macro-subdomains connected through nonconforming interfaces. This suggests a possible Exa-MA direction:

This remains exploratory but is relevant for HDG, mortar methods, and domain decomposition.

Samurai is currently more a PETSc user than a PETSc contributor. However, AMR changes matrix structure and can degrade conditioning compared with uniform-grid problems. This opens a research direction around solver and preconditioner behavior for AMR-generated matrices.

The discussion mentioned PETSc finite-volume and time-stepping use, possible links with Composyx and HPDDM, algebraic multigrid versus geometric multigrid, and the possibility of HPDDM/GenEO-type coarse spaces for robustness. A possible second Samurai mini-app could therefore target WP3 solver and preconditioner questions.

The StarPU link is natural because Samurai already identifies computational regions through interval sets. The main difficulty is task granularity. Raw intervals may be too small to amortize task overhead, while levels, patches, subdomains, or expensive local physics kernels may provide enough work.

Christophe suggested that StarPU may become more relevant when local work is expensive, for example high-order methods, HDG local solvers, domain-decomposition subdomain solves, stiff local chemistry, or particle-like local kernels. This matches application contexts such as hydrogen-risk simulations with stiff chemistry or ONERA-related DSMC work.

The presentation showed or mentioned several Samurai use cases:

Samurai should be presented as a structured adaptive Cartesian mesh infrastructure based on interval compression and set algebra. It supports AMR/MRA, efficient mesh operations, field manipulation, MPI exchange regions, and future heterogeneous task execution.

Potential links with Feel should be framed carefully. Samurai should not replace the general Feel mesh and variational framework. A more credible path is to use Samurai as a Cartesian AMR topology backend for specific methods, or as a macro-topology for domain decomposition and local discretizations coupled through traces, mortars, or interface operators.