Construct a structure that will contain:

• elements tags
• edges tags
• link between the edges and the elements
• normal associated to each edge & sign (for the elements)
• maybe integration related variables, e.g. Gauss points, jacobians etc
  All this should be done in a clear way that allows to easily understand how data is handled + the link between those variables

Make a rectangular mesh for the firsts tests

Probably a non-initialized vector or a problem for the index of a vector
File builFlux.cpp, around line 140:

gx[j] = -(factor*fx[element.offsetInU + j] + fx[frontOffsetInU + frontJ])/2 - C*element.edges[s].normal.first*(u[element.offsetInU + j] - valueAtBC())/2;
gy[j] = -(factor*fy[element.offsetInU + j] + fy[frontOffsetInU + frontJ])/2 - C*element.edges[s].normal.second*(u[element.offsetInU + j] - u[frontOffsetInU + frontJ])/2;

Implementation of a time integration solver for an equation of the type
du/dt = F(u(t)), where F depends on [M]^{-1} (i.e. matrices operations should be efficient). At least two types of solver:

• a simple forward explicit Euler method
• a Runge-Kutta method of order 4

Test on NIC4:

• git
• gmsh
• CMake
• execute a first code

Create a simple 2D mesh file that could be used for the first tests

Tests with different:

• number of elements
• number of GP
• order of SF
• mesh size
• time step
• physical problem (scalar linear flux, linearized wave equations, ...)

My computation of nEdge is WRONG.

Construction of the important blocks of the DG method

Represent the solution using gmsh functions

The code clearly needs to be cleaned and refactored, especially the readMesh function and the MeshParams structure. Some ideas:

• "Split" MeshParams into substructure to avoid using vector of vector of vector...
• Check if they are unneeded operations in readMesh, or if it could be split.
• Use OOP (class, ...)

Count the list of edges so that they can be used for the future code (+ connected elements)

Basic linear algebra operations should be handled easily, most particularly:

• storage of large matrices/vectors
• inversion of a block-diagonal matrix
• matrix-vector multiplication
  using an external library, most probably Eigen