Naive implementation of the Burgers equation

In this part, we will implement a naive finite volume scheme to solve the one-dimensional inviscid Burgers equation. While this implementation is straightforward, we will see in later sections how to improve it to handle multi-resolution meshes correctly. We will use the Burgers equation as a demonstration. This equation is a fundamental partial differential equation that models various physical phenomena, including fluid dynamics and traffic flow. The inviscid Burgers equation is given by:

\frac{\partial u}{\partial t} + \frac{1}{2} \frac{\partial u^2}{\partial x} = 0.

(1)

How to start

If you have not already done so, activate the conda environment created in the Setup Instructions:

conda activate samurai-practical-session

For each step, we give you two main files, copy these two files into a new folder:

practical_session/material/step_name/CMakeLists.txt
practical_session/material/step_name/main.cpp

Then, create a build folder and compile the code as follows:

cmake -S . -B build
cmake --build build
cd build
./samurai_setup_test

We recommend changing the executable name in the CMakeLists.txt file to avoid confusion with the setup test and to keep track of your work at each step.

Finite volume scheme¶

We will use the simplest finite volume scheme to solve the Burgers equation. The domain is discretized into control volumes (cells), and the solution is approximated by its average value within each cell. The update formula for the cell average $u_i$ at time step $n+1$ is given by:

u_i^{n+1} = u_i^n - \frac{\Delta t}{\Delta x} \left( F(u_{i+1/2}^n) - F(u_{i-1/2}^n) \right),

(2)

where $u_i^n$ represents the cell average of $u$ in the cell $i$ at time step $n$ , $\Delta t$ is the time step size, and $\Delta x$ is the cell size. We use a Forward Euler method here to discretize time for simplicity. However, more complex time schemes can be used, as we will show at the end of this practical session. $F(u_{i+1/2}^n)$ is the numerical flux function, which we will define using the upwind flux. For simplicity, we will assume that the velocity is always positive (upwind scheme). The flux at the right interface of cell $i$ is determined by the left state:

F(u_{i+1/2}) = \frac{1}{2} u_i^2

(3)

Exercise 1

A code skeleton is provided in material/02-naive-burgers/main.cpp to help you get started. Complete the implementation of the naive finite volume scheme for the inviscid Burgers equation.

Ensure that you have correctly implemented the flux calculation by visualizing the evolution of the solution over time using the following command:

python /path/to/read_mesh.py burgers_1d_ --field u --start 0 --end 340 --wait 10

Mesh adaptation¶

It is time to adapt the mesh according to the solution. We will use the multi-resolution capabilities of samurai to do so. We will not go into the theoretical details of multi-resolution here, but you can refer to Thomas Bellotti’s thesis in chapter 2 for more information.

Adding the adaptation step performed by the multi-resolution framework of samurai is straightforward. You simply need to follow these steps:

Include the multi-resolution adaptation header:

#include <samurai/mr/adapt.hpp>

Before the time loop, define the multi-resolution configuration:

auto MRadaptation = samurai::make_MRAdapt(u);
auto mra_config   = samurai::mra_config().epsilon(1e-3).relative_detail(false);

Inside the time loop, before updating the solution, call the adaptation function and resize the solution field:

MRadaptation(mra_config);
unp1.resize();

You can visualize the adapted mesh and the solution evolution over time using the same command as before. If you add the command-line option --save-debug-fields when running your program, samurai will save additional fields that can help you understand how the mesh is adapted over time, such as levels and coordinates.

If you want to visualize these additional fields, you can use the following command:

python /path/to/read_mesh.py burgers_1d_ --field levels u --start 0 --end 340 --wait 10

Conclusion¶

In this part, you implemented a naive finite volume scheme for the inviscid Burgers equation using samurai. You learned how to set up the problem, implement the finite volume update, and adapt the mesh using samurai’s multi-resolution capabilities.

However, this naive implementation has several issues. Most notably, we do not compute the flux correctly at interfaces between cells of different refinement levels. To understand why this is problematic, consider the conservation property of finite volume schemes.

In a proper finite volume scheme, conservation requires that the flux leaving one cell exactly equals the flux entering its neighbor. This ensures that mass (or any conserved quantity) is neither created nor destroyed at cell interfaces. Mathematically, for two adjacent cells sharing an interface, the flux balance must satisfy:

F_{\text{left}} = - F_{\text{right}}.

(4)

At multi-resolution interfaces, the naive approach breaks down because it uses ghost cells to compute fluxes. Consider the diagram above:

At level $l$ (coarse): To compute the flux $F_{i-1/2}^l$ on the right side of the real cell $u_{i-1}^l$ , we need a neighbor. Since the actual neighbor consists of fine cells at level $l+1$ , we create a ghost cell $\tilde{u}_i^l$ (shown in pink with dashed borders).
At level $l+1$ (fine): Similarly, to compute the flux $F_{j-1/2}^{l+1}$ on the left side of the real cell $u_{j-1}^{l+1}$ , we need a neighbor. Since the actual neighbor is a coarse cell at level $l$ , we create a ghost cell $\tilde{u}_{j-2}^{l+1}$ .

The problem is that these two fluxes are computed at the same physical interface (shown by the red vertical line), but using different cell and ghost values.

The ghost values are constructed differently on each side, leading to inconsistent flux evaluations. This breaks conservation and can cause numerical errors, spurious oscillations, or even instabilities.

In the next section, we will address this by implementing samurai’s flux mechanism, which properly accounts for the multi-resolution mesh structure and ensures conservation at all interfaces.

Hands-on samurai

First steps

Hands-on samurai

Flux mechanism in samurai