Discontinuous finite element for advection equations

[nanguaxiaofendui]

Discontinuous finite element method is used to solve the equation▽u(x,y)+u(x,y)=f(x,y),domain is [0,1]×[0,1],the exact solution is uex=exp(x+y),using uex to get the f(x,y) and boundary condition(Dirichlet) .

When I use the second order, the error is greater than the first order. Can you tell me where I made a mistake? Are there any examples? Thank you very much.

my code :
// C++ include files that we need
#include
#include
#include <math.h>

#include "libmesh/tecplot_io.h"
// Basic include files needed for the mesh functionality.
#include "libmesh/libmesh.h"
#include "libmesh/mesh.h"
#include "libmesh/mesh_generation.h"
#include "libmesh/vtk_io.h"
#include "libmesh/exodusII_io.h"
#include "libmesh/linear_implicit_system.h"
#include "libmesh/equation_systems.h"

// Define the Finite Element object.
#include "libmesh/fe.h"

// Define Gauss quadrature rules.
#include "libmesh/quadrature_gauss.h"
#include "libmesh/quadrature_trap.h"

// Define useful datatypes for finite element
// matrix and vector components.
#include "libmesh/sparse_matrix.h"
#include "libmesh/numeric_vector.h"
#include "libmesh/dense_matrix.h"
#include "libmesh/dense_vector.h"
#include "libmesh/elem.h"
#include "libmesh/enum_solver_package.h"
// Define the DofMap, which handles degree of freedom
// indexing.
#include "libmesh/dof_map.h"
#include "libmesh/exact_error_estimator.h"
#include "libmesh/exact_solution.h"
#include "libmesh/exodusII_io.h"
// Bring in everything from the libMesh namespace
using namespace libMesh;

void assemble(EquationSystems& es, const std::string& system_name);
Number Exact_solution(const Point & p,
const Parameters &, // EquationSystem parameters, not needed
const std::string &, // sys_name, not needed
const std::string &); // unk_name, not needed);
Gradient Exact_derivative(const Point & p,
const Parameters &, // EquationSystems parameters, not needed
const std::string &, // sys_name, not needed
const std::string &); // unk_name, not needed);
// Function prototype for the exact solution.
Real exact_solution(const Real x, const Real y, const Real z = 0.);

int main(int argc, char** argv)
{
// Initialize libraries, like in example 2.
LibMeshInit init(argc, argv);

// This example requires a linear solver package.
libmesh_example_requires(libMesh::default_solver_package() != INVALID_SOLVER_PACKAGE,
    "--enable-petsc, --enable-trilinos, or --enable-eigen");

libMesh::out << "Running " << argv[0];

for (int i = 1; i < argc; i++)

    libMesh::out << " " << argv[i];

libMesh::out << std::endl << std::endl;

libmesh_example_requires(2 <= LIBMESH_DIM, "2D support");

Mesh mesh(init.comm());

MeshTools::Generation::build_square(mesh, 2, 2, 0, 1, 0, 1, QUAD4);

// Create an equation systems object.
EquationSystems equation_systems(mesh);

equation_systems.add_system<LinearImplicitSystem>("TEST");

equation_systems.get_system("TEST").add_variable("u", FIRST, MONOMIAL);

equation_systems.get_system("TEST").attach_assemble_function(assemble);
equation_systems.init();
equation_systems.parameters.set<Real>("Omega_1") = 1;
equation_systems.parameters.set<Real>("Omega_2") = 1;

equation_systems.get_system("TEST").solve();

ExactSolution exact_sol(equation_systems);

exact_sol.attach_exact_value(Exact_solution);

exact_sol.attach_exact_deriv(Exact_derivative);

// Compute the error.
exact_sol.compute_error("TEST", "u");

// Print out the error values
libMesh::out << "L2-Error is: "
<< exact_sol.l2_error("TEST", "u")
<< std::endl;
libMesh::out << "Initial H1-Error is: "
<< exact_sol.h1_error("TEST", "u")
<< std::endl;
equation_systems.get_system("TEST").solution;

#ifdef LIBMESH_HAVE_EXODUS_API
if (!FIRST) /* CONSTANT, MONOMIAL_VEC */
{
// Warn about trivial solution for CONSTANT approximations (Poisson must be at least C1)
libMesh::out << "\nWARNING: The elemental vector order is CONSTANT. The solution" << std::endl
<< "written out to 'out_constant.e' will be trivial." << std::endl;

    // Need to get string of variable names (vector components) for 'set_output_variables()'
    std::vector<std::string> varnames;
    equation_systems.build_variable_names(varnames);

    // Create ExodusII object with an unambiguous filename (indicating this solution is special)
    ExodusII_IO exo_ptr(mesh);
    exo_ptr.write("out_constant.e");
    exo_ptr.set_output_variables(varnames);
    exo_ptr.write_element_data(equation_systems);
}
else
    ExodusII_IO(mesh).write_equation_systems("out.e", equation_systems);

#endif
// All done.
return 0;
}

void assemble(EquationSystems& es,
const std::string& libmesh_dbg_var(system_name))
{
libmesh_assert_equal_to(system_name, "TEST");

const MeshBase& mesh = es.get_mesh();

const unsigned int dim = mesh.mesh_dimension();

LinearImplicitSystem& system = es.get_system<LinearImplicitSystem>("TEST");
Real Omega_1= es.parameters.get<Real>("Omega_1");
Real Omega_2= es.parameters.get<Real>("Omega_2");
const DofMap& dof_map = system.get_dof_map();

FEType fe_type = dof_map.variable_type(0);

std::unique_ptr<FEBase> fe(FEBase::build(dim, fe_type));
QGauss qrule(dim, FIFTH);
fe->attach_quadrature_rule(&qrule);

std::unique_ptr<FEBase> fe_face(FEBase::build(dim, fe_type));
std::unique_ptr<FEBase> fe_neighbor_face(FEBase::build(dim, fe_type));
QGauss qface(dim - 1, FIFTH);
fe_face->attach_quadrature_rule(&qface);
fe_neighbor_face->attach_quadrature_rule(&qface);

const auto& JxW = fe->get_JxW();
// element integration points
const auto& xyz = fe->get_xyz();
// The element shape function values evaluated at the quadrature points
const auto& phi = fe->get_phi();
// The element shape function gradients evaluated at the quadrature points.
const auto& dphi = fe->get_dphi();
// face integration points
const auto& face_xyz = fe_face->get_xyz();
// Face shape function values
const auto& phi_face = fe_face->get_phi();
// Face shape function gradients
const auto& dphi_face = fe_face->get_dphi();
// Neighbor shape function values
const auto& phi_neighbor = fe_neighbor_face->get_phi();
// Neighbor face shape function gradients
const auto& dphi_neighbor = fe_neighbor_face->get_dphi();
// face normals
const auto& normals = fe_face->get_normals();
// face JxW
const auto& JxW_face = fe_face->get_JxW();

DenseMatrix<Number> Ke;
DenseMatrix<Number> He;
DenseVector<Number> Fe;

std::vector<dof_id_type> dof_indices;
std::vector<dof_id_type> dof_indices_neighbor;

// The global system matrix
SparseMatrix<Number>& matrix = system.get_system_matrix();

for (const auto& elem : mesh.active_local_element_ptr_range())
{
    dof_map.dof_indices(elem, dof_indices);
    const unsigned int n_dofs = cast_int<unsigned int>(dof_indices.size());

    fe->reinit(elem);
    libmesh_assert_equal_to(n_dofs, phi.size());

    Ke.resize(n_dofs, n_dofs);
    Fe.resize(n_dofs);
    
    for (unsigned int qp = 0; qp < qrule.n_points(); qp++)
    {
        for (unsigned int i = 0; i != n_dofs; i++)
            for (unsigned int j = 0; j != n_dofs; j++)
            {
                Ke(i, j) += -Omega_1 * JxW[qp] * phi[j][qp] * dphi[i][qp](0);
                Ke(i, j) += -Omega_2 * JxW[qp] * phi[j][qp] * dphi[i][qp](1);
                Ke(i, j) += JxW[qp] * phi[j][qp] * phi[i][qp];
            }
        const Real x = xyz[qp](0);
        const Real y = xyz[qp](1);
        const Real z = xyz[qp](2);
        const Real f = 3 * exact_solution(x, y);
        for (unsigned int i = 0; i != n_dofs; i++)
            Fe(i) += JxW[qp] * f * phi[i][qp];
    }
    // upwind format
    for (auto side : elem->side_index_range())
    {
        fe_face->reinit(elem, side);
        const auto elem_id = elem->id();
        if (!(elem->neighbor_ptr(side))) {//outter boundary
            if ((Omega_1*normals[1](0) + Omega_2*normals[1](1)) < 0.0) {//get boundary
                for (unsigned int qp = 0; qp < qface.n_points(); qp++)
                    for (std::size_t i = 0; i < dof_indices.size(); i++) {
                        Fe(i) += -JxW_face[qp] * exact_solution(xyz[qp](0), xyz[qp](1)) * 
                        (Omega_1*normals[qp](0) + Omega_2*normals[qp](1)) * phi_face[i][qp];
                    }
            }
            else {//no boundary
                for (unsigned int qp = 0; qp < qface.n_points(); qp++)
                    for (std::size_t i = 0; i < dof_indices.size(); i++)
                        for (std::size_t j = 0; j < dof_indices.size(); j++) {
                            Ke(i, j) += JxW_face[qp] * phi_face[j][qp] * 
                            (Omega_1*normals[qp](0) + Omega_2*normals[qp](1)) * phi_face[i][qp];
                        }
            }
        }
        else // inner boundary
        {
            const Elem* neighbor = elem->neighbor_ptr(side);
            const auto elem_id = elem->id();
            const auto neighbor_id = neighbor->id();

            dof_map.dof_indices(neighbor, dof_indices_neighbor);
            // Make sure we have the matching quadrature points on face and neighbor
            std::vector<Point> neighbor_xyz;
            FEMap::inverse_map(elem->dim(), neighbor, face_xyz, neighbor_xyz);
            fe_neighbor_face->reinit(neighbor, &neighbor_xyz);
            if ((Omega_1*normals[1](0) + Omega_2*normals[1](1)) < 0.0) {//neighbor
            He.resize(n_dofs, n_dofs);
                for (unsigned int qp = 0; qp < qface.n_points(); qp++)
                    for (std::size_t i = 0; i < dof_indices.size(); i++)
                        for (std::size_t j = 0; j < dof_indices.size(); j++) {
                            He(i, j) += JxW_face[qp] * phi_neighbor[j][qp] * 
                            (Omega_1*normals[qp](0) + Omega_2*normals[qp](1)) * phi_face[i][qp];
                        }
            matrix.add_matrix(He, dof_indices, dof_indices_neighbor);
            }
            else {
                for (unsigned int qp = 0; qp < qface.n_points(); qp++)
                    for (std::size_t i = 0; i < dof_indices.size(); i++)
                        for (std::size_t j = 0; j < dof_indices.size(); j++) {
                            Ke(i, j) += JxW_face[qp] * phi_face[j][qp] * 
                            (Omega_1*normals[qp](0) + Omega_2*normals[qp](1)) * phi_face[i][qp];
                        }
            }
        }
    }
    dof_map.constrain_element_matrix_and_vector(Ke, Fe, dof_indices);

    matrix.add_matrix(Ke, dof_indices);
    system.rhs->add_vector(Fe, dof_indices);
}

}
Number Exact_solution(const Point & p,
const Parameters &, // parameters, not needed
const std::string &, // sys_name, not needed
const std::string &) // unk_name, not needed
{
return exp(p(0)+p(1));
}

Gradient Exact_derivative(const Point & p,
const Parameters &, // parameters, not needed
const std::string &, // sys_name, not needed
const std::string &) // unk_name, not needed
{
// Gradient value to be returned.
Gradient gradu;

gradu(0) = exp(p(0)+p(1));
gradu(1) = exp(p(0)+p(1));

return gradu;
}
Real exact_solution(const Real x,
const Real y,
const Real z = 0.)
{
return exp(x + y);
}

[nanguaxiaofendui]

I've seen my mistake, thank you！