# A Parallel Adaptive Newton-Krylov-Schwarz Method for 3D Compressible Inviscid Flow Simulations

Authors: Marzio Sala; Pénélope Leyland; Angelo Casagrande
Journal: Modelling and Simulation in Engineering
 (2013)

---

## Abstract

A parallel adaptive pseudo transient Newton-Krylov-Schwarz (αΨNKS) method for the solution of compressible flows is presented. Multidimensional upwind residual distribution schemes are used for space discretisation, while
an implicit time-marching scheme is employed for the discretisation of the (pseudo)time derivative. The linear system arising from the Newton method applied to the resulting nonlinear system is solved by the means of Krylov
iterations with Schwarz-type preconditioners. A scalable and efficient data structure for the αΨNKS procedure is presented. The main computational kernels are considered, and an extensive analysis is reported to compare the Krylov accelerators, the preconditioning techniques. Results, obtained on a distributed memory computer, are presented for 2D and 3D problems of aeronautical interest on unstructured grids.


---

## Body

## 1. Introduction

The aim of this paper is to provide an overview of the methods required for an efficient parallel solution of the compressible Euler equations (CEE) on unstructured 2D and 3D grids. The ingredients include space and time discretisation schemes for the underlying partial differential equations (PDEs), a nonlinear solver based on the Newton’s method, and a parallel Krylov accelerator with domain decomposition preconditioners.Nowadays, unstructured grids are of particular interest for industrial applications. With respect to structured grids, it is often easier to produce unstructured grids of good quality in domains of complex shape, especially if the unstructured grid generator can be coupled to a CAD system. This can provide—at least in principle—a fast process to solve the problem at hand, with minimal intervention of the user, once the geometry of the domain and the boundary conditions have been specified. However, such techniques imply an almost perfect geometric representation (CAD level) and automatic grid generation remains a challenge in computational engineering, especially for moving boundaries.The framework presented here can be successfully applied to the solution of sets of PDEs problems discretised on unstructured grids. The focus in this paper is restricted to the solution of the CEE. In particular, the space discretisation technique considered is based on the so-calledmultidimensional upwind residual distribution(MURD) schemes; see for instance [1–5]. These schemes are supposed to render higher accuracy and less spurious numerical anomalies. This is due to the fact that they take into account the multidirectionality of the wave structure, rather than being based upon a summation of one-dimensional Riemann problems, [6, 7]. Firstly developed for a scalar advection equation, MURD schemes have been extended to homogeneous flux hyperbolic systems such as the Euler equations. They can be interpreted as Petrov-Galerkin finite element methods, with compact-stencil basis functions. This turns out to be of particular advantage for their parallel implementation, since both first-order and second-order in space schemes share the same communication pattern.For compressible flow simulations, we will consider here the Euler equations. The steady state solutions are found as the steady-state of their time-dependent version. The time derivative is discretised using the backward Euler method. This leads to a nonlinear system to be solved at each time step. Hence, for these cases, time accuracy is not an issue. In fact, the pseudo-time derivative is added as a mean to obtain a “good” initial iterate for the Newton’s method (which can even diverge for initial iterates too far-away from the solution). Moreover, only few steps of the Newton’s method are considered, and the linear system with the Jacobian matrix is solved only approximatively.The Newton’s method for the solution of this nonlinear system results in a large, ill-conditioned linear system with the system’s Jacobian matrix. Direct methods appear to be too computationally expensive, especially in 3D. For our kind of applications, preconditioned iterative solvers of Krylov type are a prime choice and can also be associated with multigrid techniques, another challenging method, especially for compressible flow simulations. A possible way to derive the preconditioner is to adopt a domain decomposition approach [8, 9], and more in particular to use a Schwarz preconditioner. This means that the computational domain Ω is decomposed into M overlapping subdomains Ωi, i=1,…,M, such that ⋃i=1M‍Ωi¯=Ω¯. Then, a Dirichlet problem is solved in each subdomain. Since typically each subdomain is assigned to a different processor, this leads to a parallel preconditioner. Further, a coarse level is added, resulting in an overall—although cheap—communication among the subdomains. Here, to construct the coarse level, we consider algebraic procedures based on the concept of aggregation.The resulting framework is usually addressed to as the Newton-Krylov-Schwarz framework, a quite generic procedure that can be applied to nonlinear systems of PDEs [10–16]. The idea is to obtain (asymptotically) a second-order convergence in time through the Newton iterations and a reasonable parallelism thanks to the use of a Krylov solver complemented with a Schwarz-type preconditioner. The resulting algorithm will be addressed to as αΨNKS.For an efficient and scalable implementation ofαΨNKS methods, parallel codes have to be developed, extending their sequential counterparts. Data, like grid structures, the Jacobian matrix, state variable, and work vectors, must be partitioned among the processors in order to minimise the amount of intraprocessor communications. The definition of a distributed data structure, wellsuited for all the computational phases, is the first problem to be addressed. To that aim, all the main computational kernels of the αΨNKS algorithm are analysed, and suitable algorithms are presented and implemented in order to make use of as much local data as possible, thus minimising communication. Note that robust and accurate methods are necessary to treat the large variety of regimes which may typically arise in aeronautics which rely on solving the Euler equations. The interest of these techniques is that many software packages, such as PetSc and ISL++, offer these functionalities in a user-friendly way.The paper is organised as follows. Section2 describes the numerical solution of the compressible Euler equations and the αΨNKS scheme. In Section 3 the data structure used for parallelisation is introduced. Section 4 outlines the main computational kernels of the αΨNKS scheme. Section 5 gives some numerical results obtained on a SGI Origin 3800 for academic test cases as well as typical full aircraft problems. Although this machine is nowadays replaced by Linux clusters, the scaling of the results for multiple processor clusters is significant. Indeed, all techniques and results described here scale in exactly the same way on Linux clusters under MPI. Finally, Section 6 outlines the conclusions.


## 2. Numerical Solution of the Compressible Euler Equations

The compressible Euler equations describing nonviscous and nonheat conducting compressible fluid flows in a domainΩ⊂ℝ3 can be written as
(1)∂w∂t+∂F1(w)∂x1+∂F2(w)∂x2+∂F3(w)∂x3=0,
where w=(ρ,ρu1,ρu2,ρu3,ρe) is the vector of conservative variables. For the applications of interest, (1) are posed on a bounded domain and completed by appropriate boundary conditions and initial condition w(t=0)=w0 (see for instance [17]).In (1), ρ is the density, u1,  u2, and u3 are the x1-,  x2-, and x3-components of the velocity vector v, and e is the specific total energy. The quantities Fi=(ρui,ρv+δi,jp,ρuih),  i∈{1,2,3} are homogeneous functions of w, called fluxes. Here δi,j is the Kronecker symbol, p is the (static) pressure, and h is the specific enthalpy. The gas is considered to be a calorically perfect gas [18, Chapter 2], therefore
(2)e(T)=CvT,h(T)=CpT,
with Cv and Cp being the specific heat coefficient at constant volume and constant pressure, respectively.The space discretisation of (1) is conducted using MURD schemes, which are based on the quasilinear form as
(3)∂w∂t+G1(w)∂w∂x1+G2(w)∂w∂x2+G3(w)∂w∂x3=0,
with
(4)Gi(w)=∂Fi∂w.The basis idea of MURD schemes is to compute theresidual at element level, defined as
(5)R(T)(w)=∫T‍{G1(w)∂w∂x1+G2(w)∂w∂x2+G3(w)∂w∂x3}dT.
Then, the main idea is to redistribute this quantity to the nodes of the element, according to the choice of the scheme.We will not describe MURD schemes, referring the reader to, for example, [19–24] and the references therein. Here, we just give a very broad overview of the schemes.At their beginning, MURD schemes have been developed for scalar equations. The extension to system schemes is straightforward if the system is diagonalisable. In this case, scalar schemes can be used for each scalar equation of the diagonalised system. For nondiagonalisable systems, like the CEE, three main orientations are identified. One consists in the formal extension of the scalar scheme. This leads, for instance, to the system N-scheme [4]. A second orientation was introduced by Roe in 1986 [25] and consists in decomposing the initial residual as a sum of simple wave solutions. The last one, initially proposed by Deconinck and coworkers, see [26], is an elliptic/hyperbolic splitting, which decompose the CEE into an acoustic subsystem of three equations (for 3D problems), plus two advection equations, one of them being the entropy advection. The last approach is followed here. It was shown in [27] that this decomposition can lead to numerical methods with minimal spurious entropy production.MURD schemes are targeted to the solution of advection-dominated systems on unstructured grids because they are not constructed by concentrating on any particular direction of the grid. An advantage is that, at least for scalar equations, one can construct a fully second-order accurate scheme on triangular grids with a very compact stencil: only the nodes in the triangle are used in the evaluation of the fluctuation. Note that these schemes can be interpreted as Petrov-Galerkin finite-element schemes, see [28, Section 4.1].The spatial discretisation of (1) results in a system of nonlinear equations of type
(6)SdUdt+R(U)=0,
with a convenient initial condition U(t=0)=U0. In (6), S is a nonsingular (lumped) mass matrix. In particular, we seek for the the steady-state solution of system (6), which will be one of the roots of
(7)R(U)=0.
Note that the Newton method applied directly to system (7) does not suffice, since an initial iterate sufficiently near to the root is generally not available. This is particularly true for complex flows containing shock waves and contact discontinuities, like the ones considered in this paper. Framing the steady-state equation into a time-dependent setting constitutes a sort of continuation process, which can be considered as an attempt to widen the domain of convergence of Newton method, or as a procedure to obtain sufficiently close starting points.System (6) is discretised using a backward Euler scheme. Starting from a given U0, the solution at the pseudotime step k=1,2,… is found by solving the nonlinear system of equations
(8)SUk-Uk-1δk+R(Uk)=0
or, equivalently,
(9)Sδk-1Uk-Sδk-1Uk-1+R(Uk)=0,
where δk is the time increment at step k.A strategy for the definition ofδk is needed. As a general rule, one should keep the time step small until all the main flow features are well resolved, then large time steps may be taken near to obtain superlinear or quadratic convergence of Newton’s method. In this paper we have adopted the so-called exponential rule [29], that is,
(10)δk=min{δ0×(σ)k,CFLmax},
where δ0 is the initial time step and σ>1 is a prescribed growing factor. Other strategies have been proposed in the literature, like the so-called switched evolution relation rule (see [29]) or the expert rule (see [30]).A Newton iteration at time levelk for the solution of (9) would then read
(11)Uk,l=Uk,l-1+[Sδk-1+∂R∂U(Uk,l-1)]-1×(-Sδk-1Uk,l-1-R(Uk,l-1)+Sδk-1Uk-1)
with l=0,1,… being the index associated to the Newton procedure, and Uk,0=Uk-1. The Newton iteration should stop when either a certain tolerance level is reached, or after a fixed number of iterations. Although it is possible in principle to take more Newton correction iterates, convergence results from [31] show that, for steady-state computations, quadratic convergence can be eventually achieved using only one step of process (11), provided that a suitable time-step evolution strategy for δk is found. Therefore, in the following we are supposed to take just one Newton iteration. This leads to the following linear problem:
(12)Uk=Uk-1+[Sδk-1+∂R∂U(Uk-1)]-1(-R(Uk-1))
that can be written, dropping the index k, as
(13)Au=f,
where A∈ℝn×n and u,f∈ℝn. More precisely,
(14)A=[Sδk-1+∂R∂U(Uk-1)],u=(Uk-Uk-1),f=-R(Uk-1).A preliminary analysis of the memory requirements and the computational time required by for directLU techniques suggests the use of an iterative solver of Krylov type for the solution of (13).The problem with iterative methods is that their convergence rate depends on the spectral properties of the coefficient matrix, in particular the condition numberκ(A)=∥A∥·∥A-1∥, where ∥·∥ is a matrix norm. To obtain a more favourable condition number, one can solve the modified system P-1Ax=P-1f, where P is a nonsingular matrix. P should approximate A-1 as closely as possible, so that κ(P-1A)≪κ(A), while still being reasonably cheap to compute both in memory and CPU time requirements. Also, it should be optimal, that is, κ(P-1A) does not depend on the problem dimension, and scalable, that is, κ(P-1A) does not depend on the number of processor used. Indeed, one of the main aims of a preconditioner is to transform the system into a system such that the matrix P-1A is close to an identity matrix.Many parallel preconditioners have been proposed in the literature. Here, we have resorted to preconditioners based on thedomain decomposition (DD) approach. The basic idea of DD methods is to decompose the computational domain Ω into M smaller parts Ωi, i=1,…,M, called subdomains, such that ⋃i=1MΩi¯=Ω¯. Next, the original problem can be reformulated within each subdomain Ωi, of smaller size. This family of subproblems is coupled one to the other through the values of the unknown solution at subdomain interface. This coupling is then removed at the expense of introducing an iterative process which involves, at each step, solutions on the Ωi with additional interface conditions on ∂Ωi∖∂Ω.We will focus on overlapping domain decomposition methods, also known asSchwarz methods. In these methods, the computational domain is subdivided into overlapping subdomains, and local Dirichlet-type problems are then solved on each subdomain. The communication between the solutions on the different subdomains is here guaranteed by the overlapping region.These DD methods are usually rather inefficient when used as solvers of the linear problem; however, they can be reformulated as efficient parallel preconditioners. To express the preconditioner, we need to fix some notation. LetRi:Ω→Ωi be a rectangular matrix which returns a vector defined on the nodes internal to Ωi from a global vector defined on Ω, Ai=RiARiT the local matrix, and finally Bi=RiTAi-1Ri the correction on subdomain Ωi. Using this notation, the one-level (additive) Schwarz method can be written as
(15)PS-1=∑i=1M‍Bi.This preconditioner is particularly well suited for the class of problems considered here. It is quite easy to implement and has reduced memory requirements. However, sincePS acts only locally, its scalability is hindered by the weak coupling between far away subdomains. Its performances degrade rapidly as the number of subdomains increases.This behaviour is typical of all one-level preconditioners, which, by construction, are composed only by local corrections on the subdomains. In fact, all the state-of-art DD preconditioners consist of local correction and a global components. The local part, acting at the subdomain level, captures the strong couplings that appear between neighbouring subdomains, while the global part provide an overall—although inexpensive—communication among the subdomains. The global component is usually referred to as a “coarse space correction,” since it is usually defined on a space that is coarse with respect to the fine space containing the solution. The complexity of this auxiliary problem is much lower than that of the original problem, and its role is to diffuse information among the subdomains. In an analogous manner to multigrid methods, this coarse space is used to correct the “smooth” part of the error, whereas the local preconditioner is used to dump the “high-frequency” part of the error.In all generality, the global correction term has the formB0=R0TA0-1R0, where A0 corresponds to the discretisation of the original PDE problem on a coarse space V0, and R0 is the restriction operator from the fine space to the coarse space. The resulting preconditioner reads as
(16)PC,add-1=B0+PS-1=∑i=0M‍Bi.
This preconditioner is fully additive since all the corrections on the subdomains and on the coarse space are added together. Alternatively, an hybrid preconditioner can be used as
(17)PC,hybrid-1=PS-1+B0-PS-1AB0.
Roughly speaking, preconditioner (17) is called hybrid because the corrections on the subdomains are treated in an additive way (the term PS-1+B0), as well as in a multiplicative way (the term PS-1AB0). For more details, the reader is referred to [9].The key element to obtain a scalable and efficient preconditioner is the proper definition of the coarse space. The general approach is to discretise the original problem on a coarse grid. However, the construction of the coarse grid and of the corresponding restriction operatorR0 can be difficult or computationally expensive for problems defined on unstructured grids in domain of complex shape, as typical in aeronautical applications. For this reason, here we consider agglomeration procedures to construct the coarse matrix for a two-level Schwarz preconditioner. The procedure is completely algebraic and very wellsuited for unstructured grids.We now detail the procedure used to define the coarse spaceV0, referring the reader for more details to [28, 32]. Our approach is based on the concept of  aggregation [33–35]. On each subdomain Ωi we build n0,i  aggregatesϑi,s, i=1,…,M, s=1,…,n0,i. An aggregate is a set of contiguous vertices, see a 2D examples in Figure 1. The value n0=∑i=1M‍n0,i represents the dimension of the coarse space. This means that we split the degrees of freedom n0 among the M subdomains, for example, simply setting n0,i=n0/M. Finally, inside Ωi, each aggregate is associated to a vector ηs,i, s=1,…,n0,i, whose elements are built following the rule
(18)ηs,i(k)={1ifkbelongstoϑs,i0otherwise.Figure 1
Examples of aggregates for a 2D domain. The nodes marked with “■,” “○”, and “⬤” belong to three different aggregates.The algorithm uses a simple procedure to build the operatorsR0 and R0T and to form the coarse matrix as
(19)A0=R0AR0T.
For a comparison between the definition of the coarse space using a coarse grid and using aggregation, the reader is referred to [36], or [28, Chapter 3], where the authors compare the two approaches for a model problem.


## 3. Definition of the Distributed Data Structure

The development of a scalable parallelαΨNKS code requires the definition of an efficient distributed data structure. This data structure must efficiently handle the preconditioning phase, which is probably the most important aspect of the αΨNKS solver, as well as all the other computational kernels of the scheme.Throughout our description, we make the following assumptions.(i)
The parallel computer is of multiple instruction multiple data (MIMD) architecture.(ii)
The parallel computer is assumed to use distributed memory architecture. In fact, this is not a restriction at all since it can be emulated on almost every type of parallel computers including shared memory computers.(iii)
Communications are achieved using a message passing interface, like MPI [37]. This is not a limitation since message passing libraries are currently available on almost every type of architecture.We also suppose that the starting grid, of moderate size, say, up to a million of elements for an inviscid solution, has been generated on a sequential computer. More refined grids will be obtained by the means of parallel adaptation techniques, as described in paper [38].The first step is the partition of the grid among theM processors. To that aim, we have used the k-way graph partitioning algorithms [39]. Given a graph G=(V,E) with |V|=n, we partition V into k subsets V1,V2,…,Vk such that Vi∩Vj=∅, |Vi|=n/k on average, and ⋃i‍Vi=V, and the number of edges of E whose incident vertexes belong to different subsets is minimised. A k-way partition is commonly represented by a partition vector p of length n, such that for every vertex v∈V, P[v] is an integer between 1 and k, indicating the partition to which vertex v belongs to. Given a partition P, the number of edges whose incident vertexes belong to different subsets i is called the edge-cut of the partition.Thek-way algorithm can be used to decompose the direct graph or the dual graph of the grid, leading to vertex-oriented (VO) or element-oriented (EO) decompositions. In the former, each vertex of the grid is assigned to a different processor, while in the latter the decomposition is at element wise. A numerical comparison between the two approaches for the compressible Euler equations using explicit time-marching scheme can be found in [40], while results concerning implicit time-marching schemes can be found in [41].We have followed a VO decomposition. As a result of the VO decomposition, each vertex of the computational grid is assigned to a unique processor, whereas there exist elements shared by more processors. These elements are calledcut elements—since their edges have been intersected—and they form a layer of elements that actually belong to more than one processor. The cut elements are stored on all processors which have at least one node of the element in their update set. For example, in Figure 2 the shaded elements are stored on both processor P1 and processor P2. The nodes assigned to processor i form its update set, whose size is ni. Clearly, ∑i=1M‍ni=n, n being the global dimension of the problem. The nodes belonging to the subdomain, but not to the update set, are called external nodes. The size of this set is nE,i.Figure 2
Vertex-oriented decomposition. Example of the overlapping stripe and respective mapping onto processorsp and q, update and external nodes. For processor P1, “○” represents the internal nodes, “□” the border nodes, and “■” the external nodes. For processor P2, “⬤” represents the internal nodes, “■” the border nodes, and “□” the external nodes.From the point of view of the parallel application, grid generation and graph partitioning result inM input files [40]; each input file contains a list of elements (grid connectivity and spatial coordinates of each vertex) and a list of the (physical) boundary nodes, grouped in the so-called patches. Each patch corresponds to a part of the boundary, like, for instance, the nacelle, the wing, or the symmetry plane, on which the same boundary conditions are imposed. The grid is represented in terms of element-based data structure. Also, a local-to-global mapping must be provided, to enable communication among the processors.After convergence of theαΨNKS solver, each processor writes the solution corresponding to its update set as a part of the global data. Often, these partitioned data are merged into a single file for global solution analysis and visualisation. However, certain packages also work directly on the partitioned solution and can also monitor the solution. We will not consider automatic visualisation issues in the following, since we have used stand-alone software tools.


## 4.αΨNKS Solver Main Operations Analysis

The main computational kernels of our solver are as follows:(1)
construction of the distributed matrix;(2)
vector updates and AXPY operations;(3)
vector-vector products;(4)
matrix-vector products;(5)
application of the preconditioner.In this section we analyse these operations.Let us focus on theconstruction of the distributed matrix. As typical, the finite-element matrix is constructed by looping over all the elements of the local grid, to compute the elemental matrix A(T), corresponding to each element T. On processor i, the contribution of A(T) will be considered only if the corresponding row is contained in the update set of i. This means that A is constructed in a distributed way, that is, each row of A is stored on a unique processor. In an analogous way, every vector, say u, is distributed: each processor will store only ui, the vector composed by the components of u which correspond to its update set, and of size ni.AnAXPY operations (i.e., u←u+αv for u and v two given vectors and α a given real number) are done as follows. First, one has to verify that all processors have the same value of α; then, for all the elements of the local vector ui, one do ui←ui+αvi. Apart from the synchronisation of the value of α (step which is often avoided), no communication occurs in vector updates and AXPY operations.Thevector-vector productβ=〈u,v〉 on processor i reads as follows: (1) compute the local value βi=〈ui,vi〉; (2) sum up the local contributions of all the processors: β=∑i=1M‍βi. Note that communication is required only in the second step. Before computing the final value of β, all processors must have finished the computations in the first step. For this reason, vector-vector product always act, in a parallel environment as synchronisation points and require, global communications.In thematrix-vector product  y=Ax, a processor i computes only the elements of y in its update set, that is, in yi. Hence, the local parallel matrix-vector product reads as
(20)yi=Aixi+AE,ixE,i,
where xi and xE,i are the values of x corresponding to its update and external set, respectively, Ai is the submatrix representing the influence of update nodes on themselves, while AE,i, the action of external nodes on update ones.From (20), the steps required to perform the parallel matrix product are (1) the exchange of boundary data, that is, the update the value of the external nodes xE,i; (2) the computation of the the local matrix-vector product yi=Aixi; (3) the computation of the external matrix-vector product yi←yi+AE,ixE,i.Steps (1) and (2) can be overlapped. Note that an efficient implementation of step (1) is particularly important to obtain a scalable matrix-vector product. As a general rule, data to be sent to a processor should be packed and sent using only one MPI call to avoid latency problems occurring within the network. However, since the grid discretisation is unstructured, it is not trivial to determine the owner of an external set and, moreover, all the nodes belonging to a certain processor are not necessarily stored contiguously in the vectorxE,i. This operation of packing data into a buffer creates contiguous messages from irregularly spaced data structure and requires a preprocessing of the matrix, plus the definition of a certain number of data structures.We want to underline the fact that for both first-order and second-order MURD schemes, the computational stencil of a generic vertexi is compact, that is, it only depends on information from vertexes that are one edge-distance away in the grid structure. Therefore, the Jacobian matrix will have nonzero elements only for the contributions corresponding to the first-order neighbouring nodes even for second-order schemes. This simplifies considerably the communication and allows the use of the same data structure for first-order and second space discretisation schemes.Finally, let us consider theapplication of the Schwarz preconditioner. Using the VO decomposition outlined in Section 3, it is particularly easy to implement a one-level Schwarz preconditioner PS with minimal overlap, that is, with an overlap among the subdomains of one element only. Referring again to Figure 2, the overlapping region among the subdomains is represented by the elements in shaded colour.On processori, the computation of the preconditioned residual z=PS-1r simply reads as
(21)zi=Ai-1ri.
Matrix Ai is already stored and formed in the local memory of processor i. Note that Schwarz preconditioners with wider overlaps will require communication. In general, the optimal amount of overlap is clearly a compromise between the effectiveness of the preconditioner and its computational complexity. For this class of problems, we have found it convenient to use the minimal overlap version. This is equivalent to a block-Jacobi procedure, where the blocks have size ni. An ILU(0) or BILU(0) factorisation (using a reverse Cuthill-McKee reorder) of the block matrices gives satisfactory results (in terms of CPU times) with respect to other “richer” incomplete factorisations [41]. In fact, compared with other variants, ILU(0) is computationally fast and memory efficient.Now, let us focus on the two-level Schwarz preconditioner described in Section2, with a coarse space based on aggregation. We show that this preconditioner makes use of information at subdomain level. To obtain a representation of matrix R0, we order the set of nodes putting before the nodes in Ω1, and then the nodes of the domain subdomains in the other subdomains. Analogously, we order the degree of freedom of V0. As a result, R0T∈ℝn0×n has the following block structure:
(22)R0T=[η1,1T0⋯0η2,1T0⋯0⋮0⋯0ηn0,1,1T0⋯00η1,2T⋯0⋮⋮⋱⋮0ηn0,2,2T⋯0⋮⋮⋱⋮00⋯η1,pT⋮⋮⋱⋮00⋯ηn0,pT].Note that each vectorηs,i can be constructed at the subdomain level, using only the local information about the grid of Ωi (hence no communications). Very often, the graph of the local matrix Ai can furnish the information required to produce the aggregates, and henceforth grid data are not required by the algorithm. This is notably the case of finite-element codes with ℙ1 basis function, as used in this paper. Note moreover that the vectors ηs,i are not explicitly required by the algorithm. We use one integer vector p, so that pi represents the (local) degree of freedom associated to the aggregate ϑs,i. The vector p will be of size ni+nE,i. First, communications occur to exchange the actual values of pE,i among the processors. Then, in the aggregation procedure to compute the coarse matrix as in (19), no communication will be required to compute, on each subdomain, the rows of A0 corresponding to the degree of freedom of V0 contained in that subdomain.


## 5. Numerical Results

In this section theαΨNKS solver presented previously is validated. The underlying Euler code we have used is called THOR, developed within the BRITE-EURAM project IDeMAS. The basic code was provided by the project co-ordinator, the von Karman Institute VKI (Belgium), and includes contributions from the partners, DASSAULT AVIATION (France), ALENIA (Italy), DASA/EADS (Germany), INRIA (France), and EPFL (Switzerland). THOR involves several high-level numerical schemes aiming to produce highly accurate multidimensional upwinding techniques, see [5]. The graph partitioning is based on the public domain software METIS [42] and its parallel counterpart ParMETIS [43]. The linear systems involved are solved using the library AZTEC [44], developed at the Sandia National Laboratories (USA). The Schwarz algorithms and the Krylov solvers have been implemented by the authors.The numerical results have been obtained on a SGI-Origin 3800, equipped with 128 MIPS R14000 500 Mhz processors. Each processor has 512 Mbytes of RAM, with 32 Kbytes and 8 Kbytes of first level and second level cache memory, respectively. This type of machine can be replaced by Linux cluster-type machines, the results being significant for both types of architectures. The parallel communication paradigm used is MPI [37].Three test cases taken of aeronautical interest have been selected to illustrate the variation of the performance with the various parameters within the algorithm and validate the fullαΨNKS cycle.In all the numerical tests,PS indicates the one-level Schwarz preconditioner, with ILU(0) factorisations and minimal overlap among the subdomains. PC,hybrid denotes the two-level Schwarz preconditioner, as detailed in Section 2. The local dimension of the coarse space (i.e., the number of aggregates assigned to each processor) is n0/M. The coarse problem is solved redundantly on each processor, using a direct LU decomposition.


### 5.1. Falcon Aircraft atM∞=0.45 and α=1°

We have studied the influence of the Krylov accelerator on a small 3D test case, namely, a Falcon aircraft with a computational grid composed of 45387 nodes and 255944 elements, with flight conditions ofM∞=0.45 and α=1°. This test case is representative of a complete aeronautical configuration of an industrial airplane, with body, wing, and nacelles. This is the only subsonic test case. The mesh is quite coarse, and we have used this test case to validate the Krylov accelerators and the basic properties of the preconditioners (see also [23, 45] for a more extensive analysis on this subject).Slip boundary conditions are imposed on the airplane. Since the problem is symmetric, as well as the boundary conditions, the mesh is represented by half a sphere, where we have imposed far-field and symmetry-plane boundary conditions. Referring to equation (10), we have used CFL0=1.0, σ=2, and CFLmax=106. For this test case, only the first-order N-scheme for systems was used, since the aim of this test case was to validate the choice of the Krylov accelerator.Figure3 reports the norm of the residual (scaled by the norm of the initial residual) versus the linear system solver iterations, for the 10th time step. The accelerators considered are, Bi-CGSTAB, CGS, TFQMR, GMRES(25), and GMRES(60). The preconditioner is PS.Figure 3
FALCON aircraft. Convergence history at the 10th time level using 32 processors and various Krylov accelerators.Figure4 reports the iterations to converge to a tolerance on the relative residual of 10-5 at each time iteration, using PS, PC,add, and PC,hybrid. From the figure, it is evident that the CFL number has a strong influence on the iterations to converge. In fact, as the CFL number increases, the linear system becomes more skew-symmetric and less diagonal-dominant, and hence more iterations are required to converge to the desired accuracy. Note that, for low values of the CFL number, the number of iterations to converge is almost the same with one-level and two-level methods. This may suggest to adapt the preconditioner for the problem to be solved, introducing the coarse problem only for certain values of the CFL number.Figure 4
FALCON aircraft. Iterations to converge at each time iterations, usingPS, PC,add and PC,hybrid, and 16 processors. n0 denotes the dimension of the coarse space for the aggregates.For any combination of solver and preconditioner, convergence of the linear system solver is reached at any time step. GMRES is slightly faster than the other methods; it takes more iterations to converge, but the single iteration is faster, since it requires only one matrix-vector product, instead of two as in the other methods. However, it is quite sensitive to the dimension of the Krylov space, especially as the number of processor used in the computation increases. The convergence history at the 10th time step (when the CFL number is 10240) reveals that TFQMR has a quite erratic convergence, while the one provided by CGS is (unexpectedly) quite regular. Bi-CGSTAB performs quite well but it is still erratic. The differences among the Krylov accelerators are particularly evident as the number of processors grows. This may reflect the fact that the Schwarz preconditioners with no coarse correction worsen their performances with many subdomains.As a result of this analysis, GMRES appear to be the most interesting among the iterative schemes for our class of problems. This confirms what was already pointed out in [23]. The only drawback of GMRES is represented by the memory requirements. Therefore, if it is the case to use Krylov subspaces of “low” dimension, one may consider other iterative schemes, like TFQMR or Bi-CGSTAB.The results also show a reasonable scalability as illustrated in Figure5. The whole convergence process is autoregulating; however, in general, 20–200 linear system iterations are performed 4 to 16 time levels as illustrated in Figure 6.Figure 5
FALCON aircraft. Relative speedup curves taken at the 10th time level.Figure 6
FALCON aircraft. Comparison of number of iterations per time level for 32 processors.


### 5.2. X29 Aircraft atM∞=0.75 and α=5°

The next test case is a X29 experimental aircraft, flying at almost transonic speed. It represents the experimental Grumman Model 712, designated X-29A by the USAF, a single-seat jet aircraft fitted with a wing mounted at the rear of the fuselage, swept forward at35°, and with canards just behind the cockpit. The flight conditions are M∞=0.75, α=5°. Equation (10) is used, with CFL0=0.2, σ=2, CFLmax=1000.The initial grid is composed by 136767 nodes and 726713 elements. The first-order N-scheme for systems was used on the nonadapted grid, while a second-order blended scheme was used on the adapted grids. In all the computations, the Jacobian matrix is formed starting from first-order space approximation to save computational time, because the evaluation of second order distribution residual is more time consuming with respect to first-order method.In Table1, the cost of the following adaptation sequence is reported. The complete solution is required at least 8 hours on 16 processors, and less than one hour on 64 processors. This result is mainly due to the specific architecture of the SGI-Origin, which allows a processor to use (when required) the memory of another processor. This is notably the case of the X29 test case when run with only 16 processors, due to the size of the problem; while by using 64 processors, then only the local processor memory was used.Table 1
X29 aircraft. Time for successive adaptations using 8 and 16 processors.
78 secs.
Grid derefinement/refinement
First cycle𝒯(1) 2 cycles
M
=
8
690 secs.
Regularisation and optimisation
132 secs.
Overheads
854 secs.
Grid derefinement/refinement
Final Grid𝒯(3) 2 cycles
M
=
16
2860 secs.
Regularisation and optimisation
1002 secs.
OverheadsTheαΨNKS cycle is as follows. Starting from an initial grid 𝒯(0), 2 steps of refinement and derefinement and structural optimisation gave the grid 𝒯(1). Then smoothing optimisation is performed on 𝒯(1) to obtain 𝒯(2). Then on 𝒯(2) large scale, refinement and optimisation gave a final grid of 1.47 million nodes and 8.7 million elements, 𝒯(3), which is a very interesting performance test case.The effect of the smoothing optimisation can be seen in Figure7. Figure 8 details the solutions on these first refinements. The mesh refinement criteria taken here are segment length and Mach gradients and are detailed in [38].X29 aircraft. Before and after optimisation and smoothing. In particular, the symmetry plane grid on the left picture shows an excessive neighbour number elements. This is no longer present in the right picture, after optimisation and smoothing.
(a)
(b)X29 aircraft. Zoom over part of the refinement and Mach number distribution on the body for the gridℳ1.
(a)
(b)A comparison of iterations to converge and CPU times is reported in Table2 for the first 14 iterations of the αΨNKS procedure. In the table, iters indicates the sum of Krylov iterations at each backward Euler time step, and CPU time the sum of the (elapsed) CPU times (in seconds) to solve the Jacobian linear system. More detailed results about one-level and two-level Schwarz preconditioners are reported in Table 3. As previously noted, the CFL number has a strong influence on the convergence. One may note that PC,hybrid performs better than PC,add. For small problems, large dimension of V0 have to be preferred, while bigger problems required a fine tuning of n0/M to obtain the best numerical results.Table 2
X29 aircraft. Comparison ofPS and PC,hybrid using different number of processors for the non-adapted grid, is made up of 136767 nodes and 726713 elements. Both CPU-time and iterations refer to the first 14 time iterations of the backward Euler method. For the coarse correction n0/M=4.
M
=
8
M
=
16
M
=
32
M
=
64
iters
P
S
270
310
369
347
P
C
,
hybrid
—
199
210
171
(
P
S
-
P
C
,
hybrid
)
/
P
C
,
hybrid
*
100
—
55.7
75.1
102.9
CPU-time
P
S
4995.1
1461.2
451.6
202.9
P
C
,
hybrid
—
1253.3
434.3
189.1
(
P
S
-
P
C
,
hybrid
)
/
P
C
,
hybrid
*
100
—
16.58
3.98
7.29Table 3
X29 aircraft. Comparison among different preconditioners for different values of the CFL number. 16, 32 and 64 processors have been used in the computations.
Time Level
CFL
M
Prec
iters
CPU-time
10
102.4
32
P
S
29
33.26
14
1000.0
32
P
S
84
54.79
10
102.4
64
P
S
33
15.57
14
1000.0
64
P
S
90
25.28
10
102.4
16
P
C
,
hybrid, n0/M=4
16
96.69
14
1000.0
16
P
C
,
hybrid, n0/M=4
51
117.64
10
102.4
32
P
C
,
hybrid, n0/M=4
16
31.38
14
1000.0
32
P
C
,
hybrid, n0/M=4
39
37.93
10
102.4
64
P
C
,
hybrid, n0/M=1
20
13.53
14
1000.0
64
P
C
,
hybrid, n0/M=1
79
23.46
10
102.4
64
P
C
,
hybrid, n0/M=4
15
14.77
14
1000.0
64
P
C
,
hybrid, n0/M=4
35
19.45
10
102.4
64
P
C
,
hybrid, n0/M=8
15
12.93
14
1000.0
64
P
C
,
hybrid, n0/M=8
35
16.86
10
102.4
64
P
C
,
hybrid, n0/M=16
15
14.05
14
1000.0
64
P
C
,
hybrid, n0/M=16
35
18.82It is worth to note that the efficiency of thePC,hybrid preconditioner clearly outperforms PS in terms of iterations, while as concerns CPU-times there is an improvement of about 10%. This is due to the following facts: (i)
PC,hybrid requires a matrix-vector product to be performed, and this is computationally expensive;(ii)
the solution of the coarse problem requires intensive communications among the processors.


### 5.3. ONERA M6 Wing atM∞=0.84 and α=3.06°

The last test case is an ONERA M6 wing atM∞=0.84 and α=3.06°. It represents a ONERA M6 wing, a widely used test case for 3D flows from subsonic to transonic regimes. The selected transonic case is M∞=0.84 and α=3.06, which results in several shock waves over the wing. In the flow-field, a shock originates at approximatively 80% of the wing span. A second leading-edge shock is caused by the 30% sweep angle of the M6 wing. Near the tip of the wing, a lambda-shock structure is observed.The first-order N-scheme for systems is used to obtain the solution on the first (nonadapted) grid, while the second-order blended scheme is used for the adapted grids. As for the X29 test case, the Jacobian matrix is formed using the first-order scheme.The far field is represented by a half sphere with a radius of 12.5 root-chord length. TheαΨNKS procedure has been performed as follows. The starting nonoptimised grid is composed by 94493 nodes and 666569 elements, and an initial constant solution is used. Then, two steps of refining are performed. Each adaptation phase corresponds to at least two passes of adaptation (refinement coarsening and optimisation). The final grid (after two adaptation cycles) is composed by 585725 nodes and 3477090 elements.The pressure coefficient at 20% of the wing span is reported in Figure9. The picture on the left shows the improvement from first-order to second-order schemes. Second-order scheme captures the first shock wave, near the leading edge, with much greater precision than first-order schemes. The over- and under-shoots are sensibly reduced by using adapted grids, as one can notice from the picture on the right.ONERA M6 wing. Pressure coefficient at 20% of wing span, using first-order and second-order schemes on a nonadapted grid (a), and second-order schemes on nonadapted and adapted grid (b).
(a)
(b)An analysis of the flow field on the upper part of the wing is reported in Figure10, while Figure 11 reports the nonadapted grid and the adapted grid.ONERA M6 wing. From left to right, Mach number contours for: a first-order solution and a second-order solution on the nonadapted grid, and a second-order solution on the adapted grid.
(a)
(b)
(c)ONERA M6 wing. Nonadapted grid (a) and adapted grid (b).
(a)
(b)As regards the convergence of theαΨNKS scheme, as one can seen from Figure 12 that in the case of 16 processors, the first-order N-scheme rapidly converges to steady-state solution very rapidly. In this phase, CFL0=10, σ=2.0, CFLmax=106, and analytical Jacobian are used. These initial iterations are needed to place the shocks in a more or less correct position, so that they do not have to move consistently when second-order schemes are employed. For second-order schemes, we have used CFL0=0.2, σ=2.0, and CFLmax=1000.Figure 12
ONERA M6 wing. Convergence history of theαΨNKS scheme. On the x-axes, CPU time, in seconds. On the y-axes, the logarithm of the (Euclidean) norm of the density residual.As already reported in [23, 46], the iterative convergence of second-order schemes is poor; basically, for nonadapted meshes, the L2 density residuals stagnate around 2 to 3 orders of magnitude, where the residual is compared to the first iteration. The situation is slightly improved on adapted meshes, even if it was not possible to reduce the residual more than a certain factor, here about 10-5 with respect to the first iteration on the nonadapted grid.


## 5.1. Falcon Aircraft atM∞=0.45 and α=1°

We have studied the influence of the Krylov accelerator on a small 3D test case, namely, a Falcon aircraft with a computational grid composed of 45387 nodes and 255944 elements, with flight conditions ofM∞=0.45 and α=1°. This test case is representative of a complete aeronautical configuration of an industrial airplane, with body, wing, and nacelles. This is the only subsonic test case. The mesh is quite coarse, and we have used this test case to validate the Krylov accelerators and the basic properties of the preconditioners (see also [23, 45] for a more extensive analysis on this subject).Slip boundary conditions are imposed on the airplane. Since the problem is symmetric, as well as the boundary conditions, the mesh is represented by half a sphere, where we have imposed far-field and symmetry-plane boundary conditions. Referring to equation (10), we have used CFL0=1.0, σ=2, and CFLmax=106. For this test case, only the first-order N-scheme for systems was used, since the aim of this test case was to validate the choice of the Krylov accelerator.Figure3 reports the norm of the residual (scaled by the norm of the initial residual) versus the linear system solver iterations, for the 10th time step. The accelerators considered are, Bi-CGSTAB, CGS, TFQMR, GMRES(25), and GMRES(60). The preconditioner is PS.Figure 3
FALCON aircraft. Convergence history at the 10th time level using 32 processors and various Krylov accelerators.Figure4 reports the iterations to converge to a tolerance on the relative residual of 10-5 at each time iteration, using PS, PC,add, and PC,hybrid. From the figure, it is evident that the CFL number has a strong influence on the iterations to converge. In fact, as the CFL number increases, the linear system becomes more skew-symmetric and less diagonal-dominant, and hence more iterations are required to converge to the desired accuracy. Note that, for low values of the CFL number, the number of iterations to converge is almost the same with one-level and two-level methods. This may suggest to adapt the preconditioner for the problem to be solved, introducing the coarse problem only for certain values of the CFL number.Figure 4
FALCON aircraft. Iterations to converge at each time iterations, usingPS, PC,add and PC,hybrid, and 16 processors. n0 denotes the dimension of the coarse space for the aggregates.For any combination of solver and preconditioner, convergence of the linear system solver is reached at any time step. GMRES is slightly faster than the other methods; it takes more iterations to converge, but the single iteration is faster, since it requires only one matrix-vector product, instead of two as in the other methods. However, it is quite sensitive to the dimension of the Krylov space, especially as the number of processor used in the computation increases. The convergence history at the 10th time step (when the CFL number is 10240) reveals that TFQMR has a quite erratic convergence, while the one provided by CGS is (unexpectedly) quite regular. Bi-CGSTAB performs quite well but it is still erratic. The differences among the Krylov accelerators are particularly evident as the number of processors grows. This may reflect the fact that the Schwarz preconditioners with no coarse correction worsen their performances with many subdomains.As a result of this analysis, GMRES appear to be the most interesting among the iterative schemes for our class of problems. This confirms what was already pointed out in [23]. The only drawback of GMRES is represented by the memory requirements. Therefore, if it is the case to use Krylov subspaces of “low” dimension, one may consider other iterative schemes, like TFQMR or Bi-CGSTAB.The results also show a reasonable scalability as illustrated in Figure5. The whole convergence process is autoregulating; however, in general, 20–200 linear system iterations are performed 4 to 16 time levels as illustrated in Figure 6.Figure 5
FALCON aircraft. Relative speedup curves taken at the 10th time level.Figure 6
FALCON aircraft. Comparison of number of iterations per time level for 32 processors.


## 5.2. X29 Aircraft atM∞=0.75 and α=5°

The next test case is a X29 experimental aircraft, flying at almost transonic speed. It represents the experimental Grumman Model 712, designated X-29A by the USAF, a single-seat jet aircraft fitted with a wing mounted at the rear of the fuselage, swept forward at35°, and with canards just behind the cockpit. The flight conditions are M∞=0.75, α=5°. Equation (10) is used, with CFL0=0.2, σ=2, CFLmax=1000.The initial grid is composed by 136767 nodes and 726713 elements. The first-order N-scheme for systems was used on the nonadapted grid, while a second-order blended scheme was used on the adapted grids. In all the computations, the Jacobian matrix is formed starting from first-order space approximation to save computational time, because the evaluation of second order distribution residual is more time consuming with respect to first-order method.In Table1, the cost of the following adaptation sequence is reported. The complete solution is required at least 8 hours on 16 processors, and less than one hour on 64 processors. This result is mainly due to the specific architecture of the SGI-Origin, which allows a processor to use (when required) the memory of another processor. This is notably the case of the X29 test case when run with only 16 processors, due to the size of the problem; while by using 64 processors, then only the local processor memory was used.Table 1
X29 aircraft. Time for successive adaptations using 8 and 16 processors.
78 secs.
Grid derefinement/refinement
First cycle𝒯(1) 2 cycles
M
=
8
690 secs.
Regularisation and optimisation
132 secs.
Overheads
854 secs.
Grid derefinement/refinement
Final Grid𝒯(3) 2 cycles
M
=
16
2860 secs.
Regularisation and optimisation
1002 secs.
OverheadsTheαΨNKS cycle is as follows. Starting from an initial grid 𝒯(0), 2 steps of refinement and derefinement and structural optimisation gave the grid 𝒯(1). Then smoothing optimisation is performed on 𝒯(1) to obtain 𝒯(2). Then on 𝒯(2) large scale, refinement and optimisation gave a final grid of 1.47 million nodes and 8.7 million elements, 𝒯(3), which is a very interesting performance test case.The effect of the smoothing optimisation can be seen in Figure7. Figure 8 details the solutions on these first refinements. The mesh refinement criteria taken here are segment length and Mach gradients and are detailed in [38].X29 aircraft. Before and after optimisation and smoothing. In particular, the symmetry plane grid on the left picture shows an excessive neighbour number elements. This is no longer present in the right picture, after optimisation and smoothing.
(a)
(b)X29 aircraft. Zoom over part of the refinement and Mach number distribution on the body for the gridℳ1.
(a)
(b)A comparison of iterations to converge and CPU times is reported in Table2 for the first 14 iterations of the αΨNKS procedure. In the table, iters indicates the sum of Krylov iterations at each backward Euler time step, and CPU time the sum of the (elapsed) CPU times (in seconds) to solve the Jacobian linear system. More detailed results about one-level and two-level Schwarz preconditioners are reported in Table 3. As previously noted, the CFL number has a strong influence on the convergence. One may note that PC,hybrid performs better than PC,add. For small problems, large dimension of V0 have to be preferred, while bigger problems required a fine tuning of n0/M to obtain the best numerical results.Table 2
X29 aircraft. Comparison ofPS and PC,hybrid using different number of processors for the non-adapted grid, is made up of 136767 nodes and 726713 elements. Both CPU-time and iterations refer to the first 14 time iterations of the backward Euler method. For the coarse correction n0/M=4.
M
=
8
M
=
16
M
=
32
M
=
64
iters
P
S
270
310
369
347
P
C
,
hybrid
—
199
210
171
(
P
S
-
P
C
,
hybrid
)
/
P
C
,
hybrid
*
100
—
55.7
75.1
102.9
CPU-time
P
S
4995.1
1461.2
451.6
202.9
P
C
,
hybrid
—
1253.3
434.3
189.1
(
P
S
-
P
C
,
hybrid
)
/
P
C
,
hybrid
*
100
—
16.58
3.98
7.29Table 3
X29 aircraft. Comparison among different preconditioners for different values of the CFL number. 16, 32 and 64 processors have been used in the computations.
Time Level
CFL
M
Prec
iters
CPU-time
10
102.4
32
P
S
29
33.26
14
1000.0
32
P
S
84
54.79
10
102.4
64
P
S
33
15.57
14
1000.0
64
P
S
90
25.28
10
102.4
16
P
C
,
hybrid, n0/M=4
16
96.69
14
1000.0
16
P
C
,
hybrid, n0/M=4
51
117.64
10
102.4
32
P
C
,
hybrid, n0/M=4
16
31.38
14
1000.0
32
P
C
,
hybrid, n0/M=4
39
37.93
10
102.4
64
P
C
,
hybrid, n0/M=1
20
13.53
14
1000.0
64
P
C
,
hybrid, n0/M=1
79
23.46
10
102.4
64
P
C
,
hybrid, n0/M=4
15
14.77
14
1000.0
64
P
C
,
hybrid, n0/M=4
35
19.45
10
102.4
64
P
C
,
hybrid, n0/M=8
15
12.93
14
1000.0
64
P
C
,
hybrid, n0/M=8
35
16.86
10
102.4
64
P
C
,
hybrid, n0/M=16
15
14.05
14
1000.0
64
P
C
,
hybrid, n0/M=16
35
18.82It is worth to note that the efficiency of thePC,hybrid preconditioner clearly outperforms PS in terms of iterations, while as concerns CPU-times there is an improvement of about 10%. This is due to the following facts: (i)
PC,hybrid requires a matrix-vector product to be performed, and this is computationally expensive;(ii)
the solution of the coarse problem requires intensive communications among the processors.


## 5.3. ONERA M6 Wing atM∞=0.84 and α=3.06°

The last test case is an ONERA M6 wing atM∞=0.84 and α=3.06°. It represents a ONERA M6 wing, a widely used test case for 3D flows from subsonic to transonic regimes. The selected transonic case is M∞=0.84 and α=3.06, which results in several shock waves over the wing. In the flow-field, a shock originates at approximatively 80% of the wing span. A second leading-edge shock is caused by the 30% sweep angle of the M6 wing. Near the tip of the wing, a lambda-shock structure is observed.The first-order N-scheme for systems is used to obtain the solution on the first (nonadapted) grid, while the second-order blended scheme is used for the adapted grids. As for the X29 test case, the Jacobian matrix is formed using the first-order scheme.The far field is represented by a half sphere with a radius of 12.5 root-chord length. TheαΨNKS procedure has been performed as follows. The starting nonoptimised grid is composed by 94493 nodes and 666569 elements, and an initial constant solution is used. Then, two steps of refining are performed. Each adaptation phase corresponds to at least two passes of adaptation (refinement coarsening and optimisation). The final grid (after two adaptation cycles) is composed by 585725 nodes and 3477090 elements.The pressure coefficient at 20% of the wing span is reported in Figure9. The picture on the left shows the improvement from first-order to second-order schemes. Second-order scheme captures the first shock wave, near the leading edge, with much greater precision than first-order schemes. The over- and under-shoots are sensibly reduced by using adapted grids, as one can notice from the picture on the right.ONERA M6 wing. Pressure coefficient at 20% of wing span, using first-order and second-order schemes on a nonadapted grid (a), and second-order schemes on nonadapted and adapted grid (b).
(a)
(b)An analysis of the flow field on the upper part of the wing is reported in Figure10, while Figure 11 reports the nonadapted grid and the adapted grid.ONERA M6 wing. From left to right, Mach number contours for: a first-order solution and a second-order solution on the nonadapted grid, and a second-order solution on the adapted grid.
(a)
(b)
(c)ONERA M6 wing. Nonadapted grid (a) and adapted grid (b).
(a)
(b)As regards the convergence of theαΨNKS scheme, as one can seen from Figure 12 that in the case of 16 processors, the first-order N-scheme rapidly converges to steady-state solution very rapidly. In this phase, CFL0=10, σ=2.0, CFLmax=106, and analytical Jacobian are used. These initial iterations are needed to place the shocks in a more or less correct position, so that they do not have to move consistently when second-order schemes are employed. For second-order schemes, we have used CFL0=0.2, σ=2.0, and CFLmax=1000.Figure 12
ONERA M6 wing. Convergence history of theαΨNKS scheme. On the x-axes, CPU time, in seconds. On the y-axes, the logarithm of the (Euclidean) norm of the density residual.As already reported in [23, 46], the iterative convergence of second-order schemes is poor; basically, for nonadapted meshes, the L2 density residuals stagnate around 2 to 3 orders of magnitude, where the residual is compared to the first iteration. The situation is slightly improved on adapted meshes, even if it was not possible to reduce the residual more than a certain factor, here about 10-5 with respect to the first iteration on the nonadapted grid.


## 6. Conclusions

Multidimensional upwind schemes have reached a certain degree of maturity for the solution of the steady-state compressible Euler equations on unstructured grids made up of triangles (in 2D) and tetrahedrons (in 3D). They can be used for complex aerodynamic flows, in the subsonic, transonic, and supersonic regime. Nevertheless, it is clear that the the full potential of the approach may be revealed only if these methods could effectively lead to scalable parallel codes. In particular, this requires, among others, the definition and the implementation of a scalable preconditioner and of a parallel grid adaption technique to improve the solution accuracy whilst optimising the computational resources. To that aim, we have here presented the adaptive pseudotransient Newton-Krylov-Schwarz framework.Most parallel implementation of MURD schemes are based on one-level Schwarz preconditioner and do not include automatically grid adaptation procedure. This paper aims to present a complete framework which couples these two aspects with the characteristic aspects of MURD schemes.The main kernels of this algorithm have been analysed. A data structure, based on a vertex-oriented decomposition of the grid, has been described. This data structure allows an efficient implementation of all the main computational kernels. Of particular importance is the definition of the preconditioner. One-level and two-level Schwarz preconditioners have been presented. The coarse matrix is constructed automatically and for any computational grid with no input from the user (except for the matrixA and the dimension of the coarse space). This simplicity has its roots mainly in the way the restriction and interpolation operators are defined. The results show an improvement of performance with respect to the one-level Schwarz method, which is the preconditioner usually adopted in the literature for multidimensional upwind residual distribution schemes.Numerical results, obtained on distributed memory computers, are presented for large scale computations in the sense of complexity and mesh adaptation on parallel machines. Results show that the conjunction of the Krylov-Schwarz approach with a grid adaptation procedure leads to an effective solution of the compressible Euler equations on unstructured grids. The same techniques apply to the Navier-Stokes system of equations solved by similar equivalent finite-volume techniques on unstructured grids [18, 47].



---

*Source: 694354-2013-01-14.xml*