2
$\begingroup$

I am seeking the optimal method for implementing DG on a parallel system. For my research, I come across two types of problems.

For the first problem, I am solving a time-independent (steady-state) boundary value problem. I end up with the stiffness matrix multiplied by the vector of my unknowns equal to the vector of the volume-integrated source function. In this case, it seems to me I have to solve the system as a whole since the surface fluxes are implicit on the neighbor solution.

For the second problem, I am solving a time-dependent initial value problem. After applying an explicit time discretization scheme, I end up with the mass matrix which I must invert and multiply to the vector of the stiffness matrix multiplied by the solution vector of the previous time step plus my volume-integrated source terms. In this case, it seems to me I do not have to solve the system as a whole since the surface fluxes in the last time step are known and can be passed to each local system as needed.

I currently solve both scenarios globally. Instead, is it possible to solve both scenarios locally over each cell? This to me would seem to greatly improve parallel efficiency (via domain decomposition) versus trying to solve a global system (though some parallelism can be achieved using Trilinos or another library to do the sparse matrix operations).

Thanks!

$\endgroup$
1
$\begingroup$

Solving a time-dependent problem problem with DG is typically very fast for hyperbolic problems (diffusion-type problems can be tougher due to the CFL condition), and is the subject of a large part of Hesthaven/Warburton's book "Nodal Discontinuous Galerkin Methods". This is inherently parallel, and can be made very memory efficient and scalable (see Warburton's papers on nodal DG on GPUs, for example).

Solving the implicit/steady state equation is more subtle, or at least has way more options. Using an iterative method to solve the DG system (CG for symmetric, positive-definite operators, or GMRES in general) and a good preconditioner are usually the approach to achieving good parallel scalability. Some preconditioners are more scalable/effective than others, and the optimal choice of preconditioner may depend on the details of your problem and hardware.

Some popular DG preconditioners include overlapping/non-overlapping additive Schwarz methods with some coarse grid solver and algebraic or geometric multigrid. Black-box algebraic solvers like ILU or Sparse Approximate Inverse (SPAI) methods can also do well, though their scalability is a bit more variable.

You mentioned Domain Decomposition (DD); an interesting note is that for DG, non-overlapping Schwarz methods correspond fairly closely to standard DD methods with specific transmission conditions (see this paper by Gander and Hajian).

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.