Objective
Develop robust techniques for mesh generation, adaptive refinement, high-order discretization, and efficient time integration for multiphysics simulations.

Key Topics

Lead
CEA

Duration
Months 1–60

Description
WP1 focuses on the creation and adaptation of mesh representations and discretization techniques that reduce communication overhead and increase computational intensity—crucial features for exascale applications.

Arcane is a development environment for parallel numerical calculation codes. It supports the architectural aspects of a calculation code, such as data structures for meshing and parallelism, as well as more environment-related aspects such as dataset configuration.

CGAL is a software project that provides easy access to efficient and reliable geometric algorithms in the form of a C++ library.

Composyx is a linear algebra C++ library focused on composability. Its purpose is to allow the user to express a large pannel of algorithms using a high-level interface to range from laptop prototypes to many node supercomputer parallel computations.

Versatile and flexible numerical library that implements Block Krylov iterative schemes for the solution of linear systems of equations with multiple right-hand sides

This Library currently implements various variants of Block Krylov iterative solvers:

• BCG (Block Conjugate Gradient)
• BF-BCG (Breadown Free BCG)
• BGCR (Block Generalized Conjugate Residual)
• BGMRES (Block General Minimum Residual)
• IB-BGMRES (BGMRES with inexact breakdown)
• BGMRES-DR (BGMRES with deflated restarting)
• IB-BGMRES-DR (BGMRES with inexact breakdown and deflated restarting)
• IB-BGCRO-DR (Block Generalized Conjugate Residual Method with Inner Orthogonalization with inexact breakdown and deflated restarting)

A particular attention is paid to internal numerical kernels such as those associated with the least-square solution where block Incremental QR factorization variants are implemented.

Feel is an open-source, high-performance C framework for solving complex PDE and ODE-based mathematical models using advanced Galerkin methods (finite element, discontinuous Galerkin, and spectral methods) and efficient reduced-order modeling (ROM) techniques, including Reduced Basis (RB), Proper Orthogonal Decomposition (POD), and Empirical Interpolation Methods (EIM). It features specialized application toolboxes (CFD, CSM, FSI, thermoelectric, Maxwell), modern parallel computing with seamless Python integration (Pybind11), and extensive DevOps support (CI/CD, benchmarking, and containers). Feel++ is used in academia and industry for multiphysics simulations, inverse problems, uncertainty quantification, data assimilation, and machine learning applications.

Download Feel++ :

• For Spack
• For Guix
• For Docker
• For Apptainer

FreeFEM is a partial differential equation solver for non-linear multi-physics systems in 2D and 3D using the finite element method.

Problems involving partial differential equations from several branches of physics such as fluid-structure interactions require interpolations of data on several meshes and their manipulation within one program.

FreeFEM includes a fast interpolation algorithm and a language for the manipulation of data on multiple meshes. It is written in C++ and the FreeFEM language is a C++ idiom.

Hawen solves time-harmonic wave problems for acoustic and elastic media using the Hybridizable Discontinuous Galerkin (HDG) method for discretization. It combines mpi and OpenMP parallelism to solve large-scale applications such as Earth’s imaging and helioseismology.

It can handle the forward problem (propagation of waves) as well as the inverse problem (parameter identification).

HPDDM is an efficient implementation of various domain decomposition methods (DDM) such as one- and two-level Restricted Additive Schwarz (RAS) methods, the Finite Element Tearing and Interconnecting (FETI) method, and the Balancing Domain Decomposition (BDD) method.

MaHyCo is a inite volume code for solving hydrodynamic equations: Lagrangian or Eulerian simulations.

MUMPS is a high-performance software package for solving large sparse linear systems, supporting a wide range of matrix types and arithmetic precisions, with advanced features like parallel processing, iterative refinement, out-of-core computation, and interfaces for Fortran, C, Matlab, and Scilab.

PaStiX (Parallel Sparse matriX package) is a scientific library that provides a high performance parallel solver for very large sparse linear systems based on direct methods. Numerical algorithms are implemented in single or double precision (real or complex) using LLt, LDLt and LU with static pivoting (for non symmetric matrices having a symmetric pattern). This solver also provides some low-rank compression methods to reduce the memory footprint and/or the time-to-solution.

To know more about this software, please contact Christophe Prud’homme

PETSc, the Portable, Extensible Toolkit for Scientific Computation, pronounced PET-see, is for the scalable (parallel) solution of scientific applications modeled by partial differential equations (PDEs).

Qr_mumps is a software package for the solution of sparse, linear systems on multicore computers. It implements a direct solution method based on the QR factorization of the input matrix. Therefore, it is suited to solving sparse least-squares problems and to computing the minimum-norm solution of sparse, underdetermined problems. It can obviously be used for solving square problems in which case the stability provided by the use of orthogonal transformations comes at the cost of a higher operation count with respect to solvers based on, e.g., the LU factorization. Qr_mumps supports real and complex, single or double precision arithmetic.

The use of mesh adaptation methods in numerical simulation allows to drastically reduce the memory footprint and the computational costs. There are different kinds of methods: AMR patch-based, AMR cell-based, multiresolution cell-based or point-based, …

Different open source software is available to the community to manage mesh adaptation: AMReX for patch-based AMR, p4est and pablo for cell-based adaptation.

The strength of samurai is that it allows to implement all the above mentioned mesh adaptation methods from the same data structure. The mesh is represented as intervals and a set algebra allows to efficiently search for subsets among these intervals. Samurai also offers a flexible and pleasant interface to easily implement numerical methods.

TRUST is a thermalhydraulic software package for CFD simulations. This software was originally designed for conduction, incompressible single-phase, and Low Mach Number (LMN) flows with a robust Weakly-Compressible (WC) multi-species solver. However, a huge effort has been conducted recently, and now TRUST is able to simulate real compressible multi-phase flows.

The Uranie platform is an open-source framework developed at the Alternative Energies and Atomic Energy Commission (CEA), in the nuclear energy division, in order to deal with uncertainty propagation, surrogate models, optimisation issues, code calibration, etc. This platform benefits from both its dependencies and from personal developments, to offer an efficient data handling model, a C++ and Python interface, advanced graphi graphical tools, several parallelisation solutions, etc. These methods can then be applied to many kinds of code (considered as black boxes by Uranie) so to many fields of physics as well.