Next Article in Journal
Speed-Flow-Geometric Relationship for Urban Roads Network
Previous Article in Journal
An Integrated Photorefractive Analog Matrix-Vector Multiplier for Machine Learning
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

An Efficient Parallel Implementation of the Runge–Kutta Discontinuous Galerkin Method with Weighted Essentially Non-Oscillatory Limiters on Three-Dimensional Unstructured Meshes

School of Aeronautics Science and Engineering, Beihang University, 37 Xueyuan Road, Haidian District, Beijing 100191, China
*
Author to whom correspondence should be addressed.
Appl. Sci. 2022, 12(9), 4228; https://doi.org/10.3390/app12094228
Submission received: 16 March 2022 / Revised: 18 April 2022 / Accepted: 20 April 2022 / Published: 22 April 2022
(This article belongs to the Topic Engineering Mathematics)

Abstract

:
In computational fluid dynamics, high-order solvers suitable for three-dimensional unstructured meshes are attractive but are less developed than other methods. In this article, we provide the formulation and a parallel implementation of the Runge–Kutta discontinuous Galerkin finite element method with weighted essentially non-oscillatory limiters, which are compact and effective for suppressing numerical oscillations near discontinuities. In our experiments, high-order solvers do outperform their low-order counterparts in accuracy and the efficient parallel implementation makes the time cost affordable for large problems. Such high-order parallel solvers are efficient tools for solving conservative laws including the Euler system that models inviscid compressible flows.

1. Introduction

Most of the computational fluid dynamics (CFD) solvers currently used in aerospace engineering are based on schemes using finite volume (FV) methods, which are more suitable than schemes using finite difference (FD) methods for unstructured meshes. However, FV schemes usually have only second-order spatial accuracy, due to the difficulty of handling irregular local stencils, whose sizes grows rapidly as the order of accuracy increases. In high-order FV schemes, the local stencil of a cell is made up of the cell and the cell’s neighbors, and the neighbors’ neighbors, and so on. To ease the development of high-order schemes for unstructured meshes, it is better to use finite element (FE) methods whose local stencils are much more compact than those of FV schemes. One family of such compact high-order schemes suitable for unstructured meshes are called the discontinuous Galerkin (DG) methods, which assume continuous approximation in each cell (like classic FE methods), but allow discontinuities to exist on cell boundaries (like classic FV methods). Such an assumption gives scheme designers more freedom on choosing the basis for each cell, such as orthogonal functions which lead to modal DG methods, and Lagrange polynomials which lead to nodal DG methods [1]. The original DG method was introduced by Reed and Hill [2] for solving the neutron transport equation, which is a linear problem contains only first-order spatial derivatives. For nonlinear conservation laws, Chavent and Salzano [3] made the first attempt of using a DG method to discretize in space and using the explicit Euler method for time discretization. This scheme is second-order accurate in space but only first-order accurate in time. To improve the accuracy of time discretization, Cockburn and Shu [4] replace the first-order Euler method with a special second-order Runge–Kutta (RK) method [5,6], which is explicit and total variation diminishing (TVD). This is the first successful Runge–Kutta discontinuous Galerkin (RKDG) method, which is high-order accurate both in space and time, for scalar conservation laws. This RKDG method was soon extended to one-dimensional system case [7], multi-dimensional scalar case [8] and multi-dimensional system case [9], which includes the Euler system that models inviscid compressible flows. Nearly the same time (late 1990s), the DG methods were also extended to the Navier–Stokes system that governs viscous flows. Bassi and Rebay [10] made the first attempt to apply the DG idea to both the unknowns and their gradients for solving the Navier–Stokes equations. This method was then generalized by Cockburn and Shu [11] to the family of local discontinuous Galerkin (LDG) methods, which extends the RKDG methods from conversation laws to convection-dominated problems. One may refer to [12], which is a comprehensive review article on this topic. In the rest of this article, we will only study the RKDG methods for conservation laws that are purely hyperbolic. In Section 2.1 and Section 2.3, we will give a matrix formed formulation of the RKDG method for solving three-dimensional conservation law systems.
When solving hyperbolic problems, limiting procedures, or limiters for short, are necessary for suppressing numerical oscillations that might occur near discontinuities (known as the Gibbs phenomenon [13]). For FD and FV schemes, there is the monotonic upstream-centered scheme for conservation laws (MUSCL) [14,15,16,17], which could achieve third-order accuracy when used with caution. However, it is not directly applicable to FE schemes. Besides the RKDG formulations, there is another important contribution made by [8,9], which is proposing the generalized slope limiters for multi-dimensional problems. These minmod type limiters, together with TVD RK methods, makes the high-order solutions free from non-physical oscillation, but tend to reduce the order of accuracy in smooth regions. To overcome this drawback, the essentially non-oscillatory (ENO) [18] and weighted ENO (WENO) [19] limiting procedures were introduced. Both of them can maintain high-order accuracy in smooth regions but essentially suppress spurious oscillations near discontinuities. The first attempt of making such limiters suitable for unstructured meshes was to incorporate a WENO reconstruction procedure into high-order FV schemes [20]. Similar ideas were later adopted for DG methods [21,22] at the cost of sacrificing the compactness of DG methods. Compact versions of WENO limiters suitable for DG methods only occurred in the last ten years [23,24,25] and most of them are only formulated for two-dimensional meshes. In Section 2.2, we will give a unified formulation of some compact WENO limiters for both two- and three-dimensional RKDG methods on unstructured meshes.
The two-dimensional version of the algorithms described in Section 2.1, Section 2.2 and Section 2.3 has been proposed for nearly ten years, but few three-dimensional or real engineering applications have been reported so far. One reason is that the amount of computational resources cost by each cell grows rapidly as the order of accuracy or the dimension of space increases. Fortunately, both RKDG methods and WENO limiters use highly compact stencils and there is no global algebraic equation to be solved (as in FD and FV schemes). Based on these facts, parallel computing using domain decomposition can be applied for accelerating computation in a very natural way. Currently, we have not seen any parallel implementation of RKDG methods with WENO limiters for three-dimensional unstructured meshes. However, there are some frequently referenced works existing in the literature, which measured the parallel efficiencies of their DG methods. Biswas, Devine and Flaherty [26] performed some tests of their one- and two-dimensional DG solvers for linear scalar problems on uniform structured meshes. They achieved excellent parallel efficiencies, which were over 99 % for pure solution time (without I/O) and at least 89 % for total running time. Bey, Patra and Oden [27] tested their DG solvers for linear conservation laws on both structured (uniform) and unstructured ( h p -adaptive) meshes. They obtained nearly optimal speedups when the number of interior elements is sufficiently larger than that of subdomain boundary elements. Recently, Chalmers et al. [28] implemented their DG solver for two-dimensional Navier–Stokes equations using MPI/OpenMP hybrid parallelism and achieved good scalability on a uniform mesh with only quadrilateral elements. None of them show the parallel performance of DG solvers on three-dimensional unstructured meshes. In this article, we incorporate unstructured mesh partitioning and message passing into the algorithms and implement them on top of publicly available libraries to support parallel execution. To partition a three-dimensional unstructured mesh, we use the application programming interface (API) provided by the Metis library [29]. To send and receive messages, we use the message passing interface (MPI) [30], which is the de facto industry standard of distributed memory parallelization. We will give the details of these parallel programming techniques in Section 2.4.

2. Methods

2.1. Spatial Discretization

The differential form of a conservation law system in a three-dimensional space could be written as
t U ̲ + x F x ̲ + y F y ̲ + z F z ̲ = O ̲
in which
  • t , x , y , z represent t , x , y , z , respectively;
  • U ̲ is a K × 1 matrix of unknowns, each row of which is a scalar function depending on position x and time t;
  • F μ ̲ (where μ = x , y , z ) is also a K × 1 matrix, which is the dot-product of the flux F ̲ (whose value depends on U ̲ ) and e μ (which is an unit vector along the positive direction of the μ -axis);
  • O ̲ is a K × 1 matrix of 0’s.
This differential equation could be turned into an integral equation, by multiplying both sides with an arbitrary function V ( x ) and integrating the product on an arbitrary control volume Ω :
Ω t U ̲ + · F ̲ V = O ̲ .
To weaken the smoothness requirements on F ̲ , we apply integral by parts and Gauss’s divergence theorem to it, which will lead to the weak form of Equation (1):
Ω t U ̲ F ̲ · V + Ω ν · F ̲ V = O ̲ ,
where ν is the outer normal unit vector of the control surface Ω (which is the boundary of Ω ).
To introduce spatial discretization for Equation (2), we choose the linear space spanned by polynomials up to the p-th degree over Ω , denoted as V p ( Ω ) , as the approximation space. Let ϕ ̲ ( x ) = ϕ 1 ( x ) ϕ L ( x ) be a basis of V p ( Ω ) , in this article, we choose
ϕ 1 ( x ) = 1 , ϕ 2 ( x ) ϕ 3 ( x ) ϕ 4 ( x ) = x x 0 y y 0 z z 0 , ϕ 5 ( x ) ϕ 6 ( x ) ϕ 7 ( x ) ϕ 8 ( x ) ϕ 9 ( x ) ϕ 10 ( x ) = ( x x 0 ) ( x x 0 ) ( x x 0 ) ( y y 0 ) ( x x 0 ) ( z z 0 ) ( y y 0 ) ( y y 0 ) ( y y 0 ) ( z z 0 ) ( z z 0 ) ( z z 0 ) , ,
in which ( x 0 , y 0 , z 0 ) is the geometric center of Ω . Then U ̲ and V could be approximated as
U ̲ ( x , t ) U ̲ h ( x , t ) = l = 1 L U ̲ ^ l ( t ) ϕ l ( x ) , V ( x ) V h ( x ) = l = 1 L V ^ l ϕ l ( x ) ,
where each U ̲ ^ l ( t ) is a K × 1 matrix of temporal functions, and each V ^ l is a constant number (which is arbitrary since V ( x ) is arbitrary). Substitute them into the weak form (Equation (1)), we obtain   
l V ^ l k Ω ϕ l ϕ k U ^ ̲ k t + Ω ϕ l · F ̲ U ̲ h + Ω ϕ l F ν ̲ U ̲ I h , U ̲ O h = O ̲
where ν · F ̲ = : F ν ̲ is the normal flux on Ω , whose value could be solved from U ̲ I h (the approximated inner-side state) and U ̲ O h (the approximated outer-side state). We implement this procedure as an independent module called the Riemann solver of the conservation law (Equation (1)), see [31] for details.
Recall the arbitrariness of V ^ l l = 1 L and adopt the inner-product notation
f | g : = Ω f ( x ) g ( x ) ,
we could turn Equation (3) into a system of ordinary differential equations:
d U ^ ̲ K × L d t = B ̲ K × L A ̲ L × L 1 = : R ̲ K × L
in which
U ^ ̲ ( t ) = U 1 | ϕ 1 U 1 | ϕ L U K | ϕ 1 U K | ϕ L K × L
is the matrix of temporal functions (which will be solved in Section 2.3), and
A ̲ = ϕ 1 | ϕ 1 ϕ 1 | ϕ L ϕ L | ϕ 1 ϕ L | ϕ L L × L
is a constant matrix for a given Ω , and
B ̲ = Ω F x ̲ F y ̲ F z ̲ K × 3 x ϕ ̲ y ϕ ̲ z ϕ ̲ 3 × L Ω F ν ̲ K × 1 ϕ ̲ 1 × L
is a variable matrix depending on U ^ ̲ , so is the residual matrix R ̲ = B ̲ A ̲ 1 . By applying the Gram–Schmidt orthonormalization to ϕ ̲ , the constant matrix A ̲ could be an identity matrix, which would lead to R ̲ = B ̲ . The integrals in B ̲ would be evaluated by Gaussian quadrature rules. For triangular and tetrahedral cells, we used the quadrature rules given in [32].

2.2. Limiting Procedures

The limiters we used in this article was originally designed by [23,24]. Zhong [23] gives the formulation for two-dimensional structured meshes, and Zhu [24] extends it for two-dimensional unstructured meshes. Here we present a unified formulation for both two- and three-dimensional unstructured meshes. To simplify subscripts, we denote ψ | E i (the restriction of function ψ on element E i ) as ψ i , and ψ E i (the average value of ψ on E i ) as ψ i . Let K i be the index set of E i ’s neighbors (those elements adjacent to E i ), and K i + : = K i i .

2.2.1. The ScalarWeno Limiter

To reconstruct a scalar-valued function ψ on E i , we first borrow the expression of ψ from E k to E i
ψ k i ( x ) : = ψ k ( x ) ψ k i + ψ i i
for each k K i + . The key idea of WENO limiters is to build a convex combination of these borrowed functions:   
ψ i new ( x ) : = k K i + w k i ψ k i ( x ) .
The non-negative weight w k i should be determined from the smoothness of ψ k i , so we then calculate the smoothness of ψ k i for each k K i :
β k i = | α | = 1 p l i 2 | α | | E i | E i | α | ψ k i x 1 α 1 x d α d 2 , | α | : = α 1 + + α d
in which | E i | : = E i 1 is the measure (i.e., “area” for d = 2 , “volume” for d = 3 ) of E i , and l i : = | E i | d is the approximated length of E i ’s edges. Once we have these β ’s, the weight for each ψ k i could be constructed as
w k i = w k i β k K i + w k i β , w k i β : = w k i ε 0 + β k i 2 ,
in which
w k i = ε 1 k i 1 j K i ε 1 k = i
are called the ideal weights. The ε ’s in Equations (9) and (10) are artificial parameters and we use ε 0 = 10 6 and ε 1 = 10 3 as suggested by [23,24]. This limiting procedure for scalar-valued functions is independent from the conservation laws to be solved, so it can be programmed as an independent module, which we would like to name as the ScalarWeno limiter.

2.2.2. The EigenWeno Limiter

For a conservation law system (Equation (1)), the value of the conservative variable U ̲ is a column matrix, for which the following limiter is recommended. The first step is to obtain the ν -split form of Equation (1) on the interface shared by E i and its neighbor E k (for each k K i ):
t U ̲ + ν F ν ̲ = O ̲ ,
where ν : = ν · is the directional derivative operator and F ν ̲ : = ν · F ̲ is the normal flux (as in Equation (3)). It can be treated as a one-dimensional conservation law system whose flux Jacobian can be approximated by the average value of U ̲ :
A ν ̲ = F ν ̲ U ̲ U ̲ i .
For a hyperbolic system, it is guaranteed that the K × K matrix A ν ̲ has K real eigenvalues and has the eigenvalue decomposition
A ν ̲ = R ̲ λ 1 λ K R ̲ 1 , R ̲ : = r 1 ̲ r K ̲ ,
where r k ̲ (the k-th column of R ̲ ) is an eigenvector corresponding to the k-th eigenvalue λ k (for k = 1 , , K ). Once obtaining the R ̲ , the original conservative variable U ̲ can be projected into the space spanned by the r ̲ ’s, which gives the characteristic variable
V ̲ : = R ̲ 1 U ̲ ,
The next step is then to apply the ScalarWeno limiter (Equations (6)–(10)) on each scalar component of V ̲ , which gives V ̲ new . After obtaining the reconstructed characteristic variable V ̲ new , it can be turned back into the original conservative variable
U ̲ k i new : = R ̲ V ̲ new ,
in which the subscript k i means that it is a function defined on E i , which is constructed with the help of E k . The final step is to weight these reconstructed conservative variables by the measure of the corresponding adjacent element:
U ̲ i new : = k K i U ̲ k i new | E k | k K i | E k | .
Since the eigenvalue decomposition (Equation (13)) plays a central role in this limiting procedure, we would like to name it as the EigenWeno limiter.

2.2.3. The LazyWeno Limiter

The EigenWeno limiter (Equations (11)–(16)) works well on two-dimensional meshes in [23,24] and on three-dimensional meshes in this article. However, it depends on the conservation law system to be solved and thus is not applicable if the eigenvalue decomposition (Equation (13)) is not easily computable, or the task is to design a limiter for general matrix-valued functions (not necessarily the conservative variable of a conservation law system). In either case, one could simply apply the ScalarWeno limiter (Equations (6)–(9)) to each scalar component of U ̲ , which is a matrix-valued function. Since this limiting procedure requires less derivation and computational resources, we would like to name it as the LazyWeno limiter.

2.3. Temporal Discretization

Equation (4) is a typical nonlinear ordinary differential equation system, which can be solved by various numerical methods, such as the Runge–Kutta methods (see [33]). However, to preserve the total variation diminishing (TVD) property of the solution, the method itself should be TVD [34] and some kind of limiters (already discussed in Section 2.2) should be carefully incorporated into it. In this article, we follow the practice of [23,24], which use the explicit third-order TVD Runge–Kutta method:
U ^ ̲ n + 1 / 3 = U ^ ̲ n + R ̲ n Δ t U ^ ̲ n + 2 / 3 = 3 4 U ^ ̲ n + 1 4 U ^ ̲ n + 1 / 3 + R ̲ n + 1 / 3 Δ t U ^ ̲ n + 1 U ^ ̲ n + 3 / 3 = 1 3 U ^ ̲ n + 2 3 U ^ ̲ n + 2 / 3 + R ̲ n + 2 / 3 Δ t
in which, integers in superscripts are the marks of time steps, and fractions in superscripts represent intermediate stages. The values of the right hand side (RHS) expressions are not guaranteed to be TVD, so limiting procedures must be applied before assigning them the the left hand side (LHS). To make it more clear, we introduce a nonlinear operator L (stands for limiter) into the RHS of Equation (17), which gives   
U ^ ̲ n + 1 / 3 = L U ^ ̲ n + R ̲ n Δ t U ^ ̲ n + 2 / 3 = L 3 4 U ^ ̲ n + 1 4 U ^ ̲ n + 1 / 3 + R ̲ n + 1 / 3 Δ t U ^ ̲ n + 1 U ^ ̲ n + 3 / 3 = L 1 3 U ^ ̲ n + 2 3 U ^ ̲ n + 2 / 3 + R ̲ n + 2 / 3 Δ t
This notation clearly emphasize the application of limiters.

2.4. Parallel Programming

Both the flux integrals (Equation (5)) in the DG method and the function borrowing (Equation (6)) in WENO limiters put a requirement on each cell to access its neighbors in 𝒪 (1) time, which is not supported by commonly used mesh formats. For this reason, we do not partition the input mesh directly using the METIS_PartMeshDual(...) function as in traditional finite element methods, but convert the mesh to its dual graph by the METIS_MeshToDual(...) function, and then partition the graph using the METIS_PartGraphKway(...) function. The METIS_MeshToDual(...) function stores the cell adjacency information in dynamically allocated arrays pointed by raw pointers, which should then be the released exactly once by some caller in the call stack. To avoid memory bugs, we suggest to wrap such raw pointers into some smart pointers, such as those provided by the standard library of modern C++ [35].
Once we obtain the partitioning, each part of the mesh should then be load by a process, which holds and updates local data sequentially and shares data on inter-part boundaries with neighbors when necessary. This is a typical scenario of the distributed memory parallelization, which achieves acceleration by solving relatively equal-sized subproblems simultaneously on multiple cores. Compared with this, the shared memory parallelization, which provides a global memory address space shared by multiple threads, is generally easier to program but less scalable. The price we paid for scalability is the explicit management of message passing for sharing data between processes. Thanks to the publicly available implementations of the MPI standard, such as MPICH (https://www.mpich.org) and Open-MPI (https://www.open-mpi.org),  the code for doing this is much simpler than it used to be. To improve readability and maintainability of our code, we wrap these communication operations in functions names as ShareSomething(...), which share the same code structure:
  • For each destination, put the data to be sent into a sending buffer and register a request of sending by calling the MPI_Isend(...) function.
  • For each source, allocate a receiving buffer for the data to be received and register a request of receiving by calling the MPI_Irecv(...) function.
  • Performed other computations that can be conducted without communications.
  • Block the process until all its requests complete by calling the the MPI_Waitall(...) function.
The third step is optional but may help to improve parallel efficiency, since it allows computations to overlap with communications.

3. Results

In this section, we give the results of various numerical experiments to show the accuracy and performance of the methods described in Section 2. Even though all these experiments can be carried out on one- or two-dimensional structured meshes, we intentionally solve them on three-dimensional unstructured meshes. In this way, the applicability of our solvers for real engineering problems could be demonstrated.

3.1. Linear Conservation Laws

The first group of problems to be solved is the linear version of Equation (1):
t U ̲ + A x ̲ x U ̲ + A y ̲ y U ̲ + A z ̲ z U ̲ = O ̲
with certain boundary and initial conditions. These problems are mathematically simple in the sense that they can be solved analytically. The existence of analytic solutions gives us a good way to measure the accuracy of our numerical solvers. In this subsection, we use tetrahedral meshes generated in a [ 0 , 4 ] × [ 0 , 1 ] × [ 0 , 0.5 ] box.

3.1.1. Scalar Case

This is the simplest case of Equation (19):
Problem 1.
In Equation (19), let U ̲ consists only one component and each A ̲ consists a single number:
U ̲ ( x , t ) = U ( x , y , z , t ) , A x ̲ = 10 , A y ̲ = A z ̲ = 0 .
The following boundary conditions
U ̲ ( x = 0 , y , z , t ) = 10 = : U ̲ L , U ̲ ( x = 4 , y , z , t ) = + 10 = : U ̲ R ,
and the initial condition
U ̲ ( x , y , z , t = 0 ) = U ̲ L
are applied.
The analytic solution of Problem 1 is:
U ̲ ( x , y , z , t ) = U ̲ L x 4 < 10 t U ̲ R x 4 > 10 t
which can be interpreted as a left-running plane wave, whose profile is a jump initially positioned at the right end ( x = 4 ). To compare the accuracy of various schemes, we plot the meshes and the numerical solutions at the same moment ( t = 0.2 ) in Figure 1, Figure 2, Figure 3 and Figure 4. The white-colored regions in these figures are continuous transition layers, which are inevitable due to the dissipation of numerical schemes. The thickness of such transition layer, however, can then be used as an indicator of the scheme’s accuracy. Ideally, the thickness should be infinitesimal, as in the analytic solution. The differences between these results are more obvious in Figure 5 and Figure 6, in which we plot the values on 1001 uniformly distributed sample points along the longitudinal axis (on which y = 0.5 and z = 0.25 ) for each solver.
In Table 1, we show the measured error and time cost of each solver/mesh pair. The seconds consumed by first-order solutions are somewhat exaggerated, since we use the same high-order quadrature rules for both first- and third-order solvers, which is necessary to integrate non-constant errors. If we did not have to measure the errors, then low-order numerical integrators could be used, which might save some time.
The following conclusions can be drawn from both Figure 1, Figure 2, Figure 3, Figure 4, Figure 5 and Figure 6 and Table 1:
  • Both mesh refinement (decreasing h) and order increment (increasing p) can help to improve accuracy.
  • The solver of the highest order ( p = 3 ) on the coarsest ( h 2 2 ) mesh defeats the solver of the lowest order ( p = 1 ) on the finest ( h 2 5 ) mesh in accuracy but saves quite a lot of time.
  • High-order schemes are better than low-order ones in the sense of getting the same level of accuracy with less time cost.

3.1.2. System Case

Problem 2.
In Equation (19), let U ̲ consists two components and each A ̲ be a 2 × 2 matrix:
U ̲ ( x , t ) = U 1 ( x , y , z , t ) U 2 ( x , y , z , t ) , A x ̲ = 6 2 2 6 , A y ̲ = A z ̲ = 0 0 0 0 ,
The following boundary conditions
U ̲ ( x = 0 , y , z , t ) = 0 0 = : U ̲ L , U ̲ ( x = 4 , y , z , t ) = 12 4 = : U ̲ R ,
and the initial condition
U ̲ ( x , y , z , t = 0 ) = U ̲ R
are applied.
To solve this problem analytically, we first obtain the eigenvalue decomposition of A x ̲ , which is
6 2 2 6 A x ̲ = 1 1 1 1 R x ̲ 8 4 Λ x ̲ 1 / 2 1 / 2 1 / 2 1 / 2 ( R x ̲ ) 1
By introducing the characteristic variable V ̲ : = ( R x ̲ ) 1 U ̲ , which means
V 1 V 2 : = 1 / 2 1 / 2 1 / 2 1 / 2 U 1 U 2 = 1 2 U 1 U 2 U 1 + U 2 ,
the boundary conditions become
V ̲ L = ( R x ̲ ) 1 U ̲ L = 0 0 , V ̲ R = ( R x ̲ ) 1 U ̲ R = 8 4 ,
and the system can be decoupled:
t + 8 x t + 4 x V 1 V 2 = 0 0 .
We can then solve these two scalar problems independently, which gives
V 1 ( x , y , z , t ) = 0 x < 8 t 8 x > 8 t , V 2 ( x , y , z , t ) = 0 x < 4 t 4 x > 4 t .
The solution of Problem 2 can be obtained by U ̲ = R x ̲ V ̲ , which gives
U ̲ ( x , t ) = V 2 + V 1 V 2 V 1 = U ̲ L x / t < 4 U ̲ M x / t ( 4 , 8 ) U ̲ R x / t > 8 ,
where
U ̲ L = 0 0 , U ̲ M = 4 4 , U ̲ R = 12 4 .
With this analytic solution, we can evaluate the accuracy of our numerical solvers. Four solver–limiter pairs are tested on the same mesh ( h 2 3 ) used in Figure 1.
We plot the contour of U ̲ ( x , y , z , t = 0.3 ) with the underlying mesh in Figure 7 and Figure 8 and compare the results along the longitudinal axis at t = 0.3 with the analytic solution in Figure 9 and Figure 10. It is clear that both LazyWeno and EigenWeno (see Section 2.2) can essentially suppress non-physical oscillations in each component. Figure 11 shows that higher-order ( p = 3 ) solvers still outperforms lower-order ( p = 2 ) solvers in accuracy and the EigenWeno limiter generally works better than its LazyWeno counterpart. For this reason, we will use EigenWeno limiters exclusively in the rest of this section.

3.2. Inviscid Compressible Flows

The second group of problems to be solved is the three-dimensional Euler system:
t ρ ρ u x ρ u y ρ u z ρ e 0 + x ρ u x ρ u x u x + p ρ u y u x ρ u z u x ρ h 0 u x + y ρ u y ρ u x u y ρ u y u y + p ρ u z u y ρ h 0 u y + z ρ u z ρ u x u z ρ u y u z ρ u z u z + p ρ h 0 u z = 0 0 0 0 0
with certain boundary and initial conditions. These problems are genuinely nonlinear which cannot be solved analytically in general. However, their exact or high-order solutions in lower-dimensional spaces are well known in CFD studies, which can still be used to test our three-dimensional solvers.
For this system, the A ν ̲ defined in Equation (12) depends on U ̲ , so do the R ̲ 1 in Equation (14) and the R ̲ in Equation (15). Fortunately, these matrices can be explicitly formulated:
R ̲ ( U ̲ ) = 1 1 0 0 1 u x a ν x u x σ x π x u x + a ν x u y a ν y u y σ y π y u y + a ν y u z a ν z u z σ z π z u z + a ν z h 0 u ν a u x 2 + u y 2 + u z 2 2 u σ u π h 0 + u ν a , u ν u σ u π = ν x σ x π x ν y σ y π y ν z σ z π z 1 u x u y u z ,
L ̲ ( U ̲ ) = 1 2 B 2 + u ν a 1 2 B 1 u x + ν x a 1 2 B 1 u y + ν y a 1 2 B 1 u z + ν z a 1 2 B 1 1 B 2 B 1 u x B 1 u y B 1 u z B 1 u σ σ x σ y σ z 0 u π π x π y π z 0 1 2 B 2 u ν a 1 2 B 1 u x ν x a 1 2 B 1 u y ν y a 1 2 B 1 u z ν z a 1 2 B 1 ,
in which B 1 : = ( γ 1 ) / a 2 and B 2 : = B 1 ( u ν 2 + u σ 2 + u π 2 ) .

3.2.1. Shock Tube Problems

These problems are usually defined as one-dimensional problems, but we treat them as three-dimensional ones. All these problems are considered in a [ 0.0 , 5.0 ] × [ 0.0 , 1.0 ] × [ 0.0 , 0.5 ] box with all boundaries closed but the left and right ends open. Although no analytic solutions exist, we can still use the method described in [31], which solves nonlinear algebraic equations numerically, to obtain their exact solutions. To test the numerical methods described in Section 2, we use the unstructured hexahedral mesh in Figure 12, in which h 1 / 10 .
Problem 3
(Sod). Solve the Euler system (Equation (21)) for t [ 0.0 , 1.0 ] with the initial condition
ρ u v s . w p t = 0 = 1.000 0.000 0.000 0.000 1.000 x < 2 0.125 0.000 0.000 0.000 0.100 x > 2
Problem 4
(Lax). Solve the Euler system (Equation (21)) for t [ 0.0 , 0.6 ] with the initial condition
ρ u v s . w p t = 0 = 0.445 0.698 0.000 0.000 3.528 x < 2 0.500 0.000 0.000 0.000 0.571 x > 2
Problem 5
(Vacuum). Solve the Euler system (Equation (21)) for t [ 0.0 , 0.3 ] with the initial condition
ρ u v s . w p t = 0 = 1.0 4.0 0.0 0.0 0.4 x < 2 1.0 + 4.0 0.0 0.0 0.4 x > 2
In Figure 13, Figure 14 and Figure 15, we plot the density contours given by the same third-order solver with an EigenWeno limiter. In Figure 13, Figure 14, Figure 15, Figure 16, Figure 17 and Figure 18, we plot the density distributions along the longitudinal axis (on which y = 0.5 and z = 0.25 ) of the box. All these results show that higher-order ( p = 3 ) solvers with EigenWeno limiters are better than lower-order ( p = 1 ) solvers at capturing discontinuities (shocks, contacts, expansions), which may occur frequently in compressible flows.

3.2.2. Double Mach Reflection Problem

This is a classical two-dimensional problem originally proposed in [36], which we redefine here as a three-dimensional one:
Problem 6.
Solve the Euler system (Equation (21)) in the region defined in Figure 19, in which x 0 = 1 / 6 . The initial condition is given as a moving shock wave:
ρ u v s . w p t = 0 = 1.4 0.0 0.0 0.0 1.0 y < 3 ( x x 0 ) 8.0 u A v A 0.0 116.5 y > 3 ( x x 0 ) ,
in which u A = 4.125 3 and v A = 4.125 are the velocity components after the shock wave. The boundary conditions are given as following:
  • The x = 0 surface is open as an inlet;
  • The x = 4 surface and the x < x 0 part of the y = 0 surface are open as outlets;
  • The x > x 0 part of the y = 0 surface is closed as a solid wall;
  • The y = 1 surface has the following prescribed state:
ρ u v s . w p = 1.4 0.0 0.0 0.0 1.0 1 < 3 ( x ( x 0 + u A t ) ) 8.0 u A v A 0.0 116.5 1 > 3 ( x ( x 0 + u A t ) ) ,
which is consistent with the initial condition (Equation (22)).
As a common practice, we plot the density contour at t = 0.2 in a [ 0 , 3 ] × [ 0 , 1 ] rectangle (on the z = 0 surface) for each solver in Figure 20, Figure 21 and Figure 22. It is clear that as the accuracy order increases, the thickness of each discontinuity decreases and the rolled-up vortex structure becomes more clear.
Before concluding this section, we provide the measured performance of our third-order solver that produces Figure 22 in Table 2, in which
  • P means the number of processes (one process per core).
  • T n means the wall clock time to finish the first n step.
  • P T m + m T n m is the core time per step. The total core time of all steps is often used as an index for charging by high performance computing centers.
Since parallel I/O operations require many collective communications, we write one frame every 100 steps. Thus, the difference between the values in the last two columns is the amortized core time of writing per step. We have to admit that this cost is growing as the number of cores increases. If the number of cores keeps increasing, this may be a bottleneck of maintaining scalability.
The community of parallel computing usually use the speedup (S) and efficiency (E) defined as
S = T serial T parallel , E = S P × 100 % ,
to assess the performance a parallel program. We follow this practice, calculate these values based on the measured data given in Table 2 and plot them in Figure 23 and Figure 24. These figures show again that the I/O operations have adverse effects on the parallel performance.
The efficiency values given in Figure 24 fluctuate around 90 % , which are not as good as those above 99 % in [26]. One source of such gap is the imperfect load balancing of our tests. Since we are using a three-dimensional unstructured mesh, it can hardly be partitioned uniformly, which is an N P -hard problem. On the other hand, their meshes are one- and two-dimensional structured, on which uniform partitioning can be trivially achieved. Figure 25 gives the distribution of cells of the 100-part mesh partitioning (Figure 26) used in this section, which shows a 3 % fluctuation.

4. Discussion

In this article, we have formulated the RKDG methods and the WENO limiters for three-dimensional unstructured meshes. The algorithms have been implemented on top of the MPI standard, which supports distributed memory parallelization. The numerical experiments have shown that increasing a solver’s accuracy order helps more to produce better results than just refining the mesh it uses. The efficient parallel implementation has made the time cost affordable for large problems, as long as the solvers can be executed on sufficiently large number of cores. Extending the methods to Navier–Stokes equations and applications of these high-order parallel solvers to real engineering problems are ongoing works. Further optimization of the parallel I/O module may be conducted to achieve better parallel performance.

Author Contributions

Conceptualization, W.P. and S.L.; methodology, W.P.; software, W.P. and Y.J.; validation, W.P. and Y.J.; formal analysis, W.P. and Y.J.; investigation, W.P.; resources, W.P.; data curation, W.P.; writing—original draft preparation, W.P.; writing—review and editing, W.P., Y.J. and S.L.; visualization, W.P.; supervision, S.L.; project administration, S.L.; funding acquisition, S.L. All authors have read and agreed to the published version of the manuscript.

Funding

This research was funded by the National High-tech R&D Program of China (863 Program) grant number 2012AA112201.

Institutional Review Board Statement

Not applicable.

Informed Consent Statement

Not applicable.

Data Availability Statement

The data presented in this article are all generated from the source code publicly available in our Git repository https://github.com/pvc1989/miniCFD accessed on 15 March 2022 (or the mirror site https://gitee.com/pvc1989/miniCFD, accessed on 15 March 2022).

Acknowledgments

The authors would like to express the deepest appreciation to Zhou Yukai for his professional assistance with typesetting and graphing.

Conflicts of Interest

The authors declare no conflict of interest. The funders had no role in the design of the study; in the collection, analyses, or interpretation of data; in the writing of the manuscript; or in the decision to publish the results.

References

  1. Hesthaven, J.S.; Warburton, T. Nodal Discontinuous Galerkin Methods; Springer: New York, NY, USA, 2008. [Google Scholar] [CrossRef] [Green Version]
  2. Reed, W.H.; Hill, T.R. Triangular Mesh Methods for the Neutron Transport Equation; Technical Report LA-UR-73-479; Los Alamos Scientific Lab.: Los Alamos, NM, USA, 1973. [Google Scholar]
  3. Chavent, G.; Salzano, G. A finite-element method for the 1-D water flooding problem with gravity. J. Comput. Phys. 1982, 45, 307–344. [Google Scholar] [CrossRef]
  4. Cockburn, B.; Shu, C.W. The Runge-Kutta local projection P1-discontinuous-Galerkin finite element method for scalar conservation laws. In Proceedings of the 1st National Fluid Dynamics Conference, Cincinnati, OH, USA, 25–28 July 1988; American Institute of Aeronautics and Astronautics: Reston, VA, USA, 1988. [Google Scholar] [CrossRef] [Green Version]
  5. Shu, C.W.; Osher, S. Efficient implementation of essentially non-oscillatory shock-capturing schemes. J. Comput. Phys. 1988, 77, 439–471. [Google Scholar] [CrossRef] [Green Version]
  6. Shu, C.W.; Osher, S. Efficient implementation of essentially non-oscillatory shock-capturing schemes, II. J. Comput. Phys. 1989, 83, 32–78. [Google Scholar] [CrossRef]
  7. Cockburn, B.; Lin, S.Y.; Shu, C.W. TVB Runge-Kutta local projection discontinuous Galerkin finite element method for conservation laws III: One-dimensional systems. J. Comput. Phys. 1989, 84, 90–113. [Google Scholar] [CrossRef] [Green Version]
  8. Cockburn, B.; Hou, S.; Shu, C.W. The Runge-Kutta local projection discontinuous Galerkin finite element method for conservation laws. IV. The multidimensional case. Math. Comput. 1990, 54, 545–581. [Google Scholar] [CrossRef] [Green Version]
  9. Cockburn, B. An introduction to the Discontinuous Galerkin method for convection-dominated problems. In Lecture Notes in Mathematics; Springer: Berlin/Heidelberg, Germany, 1998; pp. 150–268. [Google Scholar] [CrossRef]
  10. Bassi, F.; Rebay, S. A High-Order Accurate Discontinuous Finite Element Method for the Numerical Solution of the Compressible Navier–Stokes Equations. J. Comput. Phys. 1997, 131, 267–279. [Google Scholar] [CrossRef]
  11. Cockburn, B.; Shu, C.W. The Local Discontinuous Galerkin Method for Time-Dependent Convection-Diffusion Systems. SIAM J. Numer. Anal. 1998, 35, 2440–2463. [Google Scholar] [CrossRef]
  12. Cockburn, B.; Shu, C.W. Runge–Kutta Discontinuous Galerkin Methods for Convection-Dominated Problems. J. Sci. Comput. 2001, 16, 173–261. [Google Scholar] [CrossRef]
  13. Gottlieb, D.; Shu, C.W. On the Gibbs Phenomenon and Its Resolution. SIAM Rev. 1997, 39, 644–668. [Google Scholar] [CrossRef] [Green Version]
  14. Leer, B.V. Towards the ultimate conservative difference scheme III. Upstream-centered finite-difference schemes for ideal compressible flow. J. Comput. Phys. 1977, 23, 263–275. [Google Scholar] [CrossRef]
  15. Leer, B.V. Towards the ultimate conservative difference scheme. IV. A new approach to numerical convection. J. Comput. Phys. 1977, 23, 276–299. [Google Scholar] [CrossRef]
  16. van Leer, B. Towards the ultimate conservative difference scheme. V. A second-order sequel to Godunov’s method. J. Comput. Phys. 1979, 32, 101–136. [Google Scholar] [CrossRef]
  17. van Leer, B.; Nishikawa, H. Towards the ultimate understanding of MUSCL: Pitfalls in achieving third-order accuracy. J. Comput. Phys. 2021, 446, 110640. [Google Scholar] [CrossRef]
  18. Harten, A.; Engquist, B.; Osher, S.; Chakravarthy, S.R. Uniformly High Order Accurate Essentially Non-oscillatory Schemes, III. J. Comput. Phys. 1997, 131, 3–47. [Google Scholar] [CrossRef]
  19. Jiang, G.S.; Shu, C.W. Efficient Implementation of Weighted ENO Schemes. J. Comput. Phys. 1996, 126, 202–228. [Google Scholar] [CrossRef] [Green Version]
  20. Hu, C.; Shu, C.W. Weighted Essentially Non-oscillatory Schemes on Triangular Meshes. J. Comput. Phys. 1999, 150, 97–127. [Google Scholar] [CrossRef] [Green Version]
  21. Qiu, J.; Shu, C.W. Runge–Kutta Discontinuous Galerkin Method Using WENO Limiters. SIAM J. Sci. Comput. 2005, 26, 907–929. [Google Scholar] [CrossRef]
  22. Zhu, J.; Qiu, J.; Shu, C.W.; Dumbser, M. Runge–Kutta discontinuous Galerkin method using WENO limiters II: Unstructured meshes. J. Comput. Phys. 2008, 227, 4330–4353. [Google Scholar] [CrossRef]
  23. Zhong, X.; Shu, C.W. A simple weighted essentially nonoscillatory limiter for Runge–Kutta discontinuous Galerkin methods. J. Comput. Phys. 2013, 232, 397–415. [Google Scholar] [CrossRef]
  24. Zhu, J.; Zhong, X.; Shu, C.W.; Qiu, J. Runge–Kutta discontinuous Galerkin method using a new type of WENO limiters on unstructured meshes. J. Comput. Phys. 2013, 248, 200–220. [Google Scholar] [CrossRef]
  25. Mazaheri, A.; Shu, C.W.; Perrier, V. Bounded and compact weighted essentially nonoscillatory limiters for discontinuous Galerkin schemes: Triangular elements. J. Comput. Phys. 2019, 395, 461–488. [Google Scholar] [CrossRef]
  26. Biswas, R.; Devine, K.D.; Flaherty, J.E. Parallel, adaptive finite element methods for conservation laws. Appl. Numer. Math. 1994, 14, 255–283. [Google Scholar] [CrossRef]
  27. Bey, K.S.; Patra, A.; Oden, J.T. hp-version discontinuous Galerkin methods for hyperbolic conservation laws: A parallel adaptive strategy. Int. J. Numer. Methods Eng. 1995, 38, 3889–3908. [Google Scholar] [CrossRef]
  28. Chalmers, N.; Agbaglah, G.; Chrust, M.; Mavriplis, C. A parallel hp-adaptive high order discontinuous Galerkin method for the incompressible Navier-Stokes equations. J. Comput. Phys. X 2019, 2, 100023. [Google Scholar] [CrossRef]
  29. Karypis, G.; Kumar, V. A Fast and High Quality Multilevel Scheme for Partitioning Irregular Graphs. SIAM J. Sci. Comput. 1998, 20, 359–392. [Google Scholar] [CrossRef]
  30. Message Passing Interface Forum. MPI: A Message-Passing Interface Standard, 4th ed.; University of Tennessee: Knoxville, TN, USA, 2021. [Google Scholar]
  31. Toro, E.F. Riemann Solvers and Numerical Methods for Fluid Dynamics; Springer: Berlin/Heidelberg, Germany, 2009. [Google Scholar] [CrossRef]
  32. Zhang, L.; Cui, T.; Liu, H. A Set of Symmetric Quadrature Rules on Triangles and Tetrahedra. J. Comput. Math. 2009, 27, 89–96. [Google Scholar]
  33. Quarteroni, A.; Sacco, R.; Saleri, F. Numerical Mathematics; Springer: New York, NY, USA, 2007. [Google Scholar] [CrossRef] [Green Version]
  34. Gottlieb, S.; Shu, C.W. Total variation diminishing Runge-Kutta schemes. Math. Comput. 1998, 67, 73–85. [Google Scholar] [CrossRef] [Green Version]
  35. Meyers, S. Effective Modern C++; O’Reilly Media, Inc.: Sebastopol, CA, USA, 2015. [Google Scholar]
  36. Woodward, P.; Colella, P. The numerical simulation of two-dimensional fluid flow with strong shocks. J. Comput. Phys. 1984, 54, 115–173. [Google Scholar] [CrossRef]
Figure 1. Third-order solution of Problem 1 on medium ( h 2 3 ) cells.
Figure 1. Third-order solution of Problem 1 on medium ( h 2 3 ) cells.
Applsci 12 04228 g001
Figure 2. First-order solution of Problem 1 on small ( h 2 4 ) cells.
Figure 2. First-order solution of Problem 1 on small ( h 2 4 ) cells.
Applsci 12 04228 g002
Figure 3. First-order solution of Problem 1 on tiny ( h 2 5 ) cells.
Figure 3. First-order solution of Problem 1 on tiny ( h 2 5 ) cells.
Applsci 12 04228 g003
Figure 4. Third-order solution of Problem 1 on big ( h 2 2 ) cells.
Figure 4. Third-order solution of Problem 1 on big ( h 2 2 ) cells.
Applsci 12 04228 g004
Figure 5. Comparison between solutions of Problem 1 given by running the same solver on different meshes.
Figure 5. Comparison between solutions of Problem 1 given by running the same solver on different meshes.
Applsci 12 04228 g005
Figure 6. Comparison between solutions of Problem 1 given by running different solvers on the same mesh.
Figure 6. Comparison between solutions of Problem 1 given by running different solvers on the same mesh.
Applsci 12 04228 g006
Figure 7. Third-order solution of U 1 ( t = 0.3 ) in Problem 2.
Figure 7. Third-order solution of U 1 ( t = 0.3 ) in Problem 2.
Applsci 12 04228 g007
Figure 8. Third-order solution of U 2 ( t = 0.3 ) in Problem 2.
Figure 8. Third-order solution of U 2 ( t = 0.3 ) in Problem 2.
Applsci 12 04228 g008
Figure 9. Comparison between solutions of U 1 ( t = 0.3 ) in Problem 2.
Figure 9. Comparison between solutions of U 1 ( t = 0.3 ) in Problem 2.
Applsci 12 04228 g009
Figure 10. Comparison between solutions of U 2 ( t = 0.3 ) in Problem 2.
Figure 10. Comparison between solutions of U 2 ( t = 0.3 ) in Problem 2.
Applsci 12 04228 g010
Figure 11. Comparison between absolute errors of numerical solutions in Figure 9 and Figure 10.
Figure 11. Comparison between absolute errors of numerical solutions in Figure 9 and Figure 10.
Applsci 12 04228 g011
Figure 12. Mesh for Problems 3–5.
Figure 12. Mesh for Problems 3–5.
Applsci 12 04228 g012
Figure 13. Third-order solution of ρ ( t = 1.0 ) in Problem 3.
Figure 13. Third-order solution of ρ ( t = 1.0 ) in Problem 3.
Applsci 12 04228 g013
Figure 14. Third-order solution of ρ ( t = 0.6 ) in Problem 4.
Figure 14. Third-order solution of ρ ( t = 0.6 ) in Problem 4.
Applsci 12 04228 g014
Figure 15. Third-order solution of ρ ( t = 0.3 ) in Problem 5.
Figure 15. Third-order solution of ρ ( t = 0.3 ) in Problem 5.
Applsci 12 04228 g015
Figure 16. Comparison between solutions of ρ ( t = 1.0 ) in Problem 3.
Figure 16. Comparison between solutions of ρ ( t = 1.0 ) in Problem 3.
Applsci 12 04228 g016
Figure 17. Comparison between solutions of ρ ( t = 0.5 ) in Problem 4.
Figure 17. Comparison between solutions of ρ ( t = 0.5 ) in Problem 4.
Applsci 12 04228 g017
Figure 18. Comparison between solutions of ρ ( t = 0.3 ) in Problem 5.
Figure 18. Comparison between solutions of ρ ( t = 0.3 ) in Problem 5.
Applsci 12 04228 g018
Figure 19. A schematic diagram of Problem 6. The rectangle bounded by four dashed lines and a solid line is the computational domain. The thick red line represents the initial shock wave, which is at an angle of π / 3 relative to the x-axis.
Figure 19. A schematic diagram of Problem 6. The rectangle bounded by four dashed lines and a solid line is the computational domain. The thick red line represents the initial shock wave, which is at an angle of π / 3 relative to the x-axis.
Applsci 12 04228 g019
Figure 20. First-order solution of ρ ( x , y , z = 0 , t = 0.2 ) in Problem 6 ( h 1 / 200 ).
Figure 20. First-order solution of ρ ( x , y , z = 0 , t = 0.2 ) in Problem 6 ( h 1 / 200 ).
Applsci 12 04228 g020
Figure 21. Second-order solution of ρ ( x , y , z = 0 , t = 0.2 ) in Problem 6 ( h 1 / 200 ).
Figure 21. Second-order solution of ρ ( x , y , z = 0 , t = 0.2 ) in Problem 6 ( h 1 / 200 ).
Applsci 12 04228 g021
Figure 22. Third-order solution of ρ ( x , y , z = 0 , t = 0.2 ) in Problem 6 ( h 1 / 200 ).
Figure 22. Third-order solution of ρ ( x , y , z = 0 , t = 0.2 ) in Problem 6 ( h 1 / 200 ).
Applsci 12 04228 g022
Figure 23. Speedup of the third-order solver for generating Figure 22.
Figure 23. Speedup of the third-order solver for generating Figure 22.
Applsci 12 04228 g023
Figure 24. Parallel efficiency of the third-order solver for generating Figure 22.
Figure 24. Parallel efficiency of the third-order solver for generating Figure 22.
Applsci 12 04228 g024
Figure 25. Distribution of cells in the mesh partitioning given in Figure 26.
Figure 25. Distribution of cells in the mesh partitioning given in Figure 26.
Applsci 12 04228 g025
Figure 26. A 100-part mesh partitioning of the unstructured mesh used for generating Figure 20, Figure 21 and Figure 22.
Figure 26. A 100-part mesh partitioning of the unstructured mesh used for generating Figure 20, Figure 21 and Figure 22.
Applsci 12 04228 g026
Table 1. Accuracy and time cost of each solver–mesh (ph) pair.
Table 1. Accuracy and time cost of each solver–mesh (ph) pair.
L 1 -Error with Respect to the Analytic Solution
h 2 2 2 3 2 4 2 5
p
12.8582.0951.5241.108
21.2580.7710.4630.275
31.0210.5900.341
Time Cost (in Seconds) Measured on a Single Core Whose Main Frequency Is 2.7 GHz
h 2 2 2 3 2 4 2 5
p
10.3731.12916.533306.293
21.58014.894253.8214986.391
34.14761.425906.914
Table 2. Performance of the same solver running on different number of cores.
Table 2. Performance of the same solver running on different number of cores.
P T 100 T 199 T 200 P T 199 T 100 99 P T 200 T 100 100
117,652.235,324.535,519.3178.508178.671
20960.4431912.3651926.584192.307193.228
40491.070971.710983.933194.198197.145
60335.651666.548676.930200.544204.767
80251.548494.541504.951196.358202.722
100202.789397.641408.126196.820205.337
Publisher’s Note: MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations.

Share and Cite

MDPI and ACS Style

Pei, W.; Jiang, Y.; Li, S. An Efficient Parallel Implementation of the Runge–Kutta Discontinuous Galerkin Method with Weighted Essentially Non-Oscillatory Limiters on Three-Dimensional Unstructured Meshes. Appl. Sci. 2022, 12, 4228. https://doi.org/10.3390/app12094228

AMA Style

Pei W, Jiang Y, Li S. An Efficient Parallel Implementation of the Runge–Kutta Discontinuous Galerkin Method with Weighted Essentially Non-Oscillatory Limiters on Three-Dimensional Unstructured Meshes. Applied Sciences. 2022; 12(9):4228. https://doi.org/10.3390/app12094228

Chicago/Turabian Style

Pei, Weicheng, Yuyan Jiang, and Shu Li. 2022. "An Efficient Parallel Implementation of the Runge–Kutta Discontinuous Galerkin Method with Weighted Essentially Non-Oscillatory Limiters on Three-Dimensional Unstructured Meshes" Applied Sciences 12, no. 9: 4228. https://doi.org/10.3390/app12094228

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop