Anisotropic problem

Consider the test problem (3.8). This problem is the anisotropic convection-diffusion problem (1.12) and is characterised by an elliptic boundary layer close tox= 1. To solve this problem numerically, we use the two dimensional piecewise uniform Shishkin mesh (1.8) constructed in Section 1.4.3. We also require the constantsc∗, c∗from (1.20) and an initial solution. From (3.9), we have

c∗ = exp (−1), c∗ = 1.

N1 N/4 N/2 3N/4 ε/M 2 3 5 9 17 33 2 3 5 9 17 33 2 3 5 9 17 Iteration counts 10−1 1035 1035₁₀₃₅ 1037₁₀₃₅ 1046₁₀₃₇ 1066₁₀₄₈ 1122₁₁₂₂ 1922 1923₁₉₂₂ 1926₁₉₂₃ 1935₁₉₂₆ 1954₁₉₄₄ 1987₁₉₈₇ 2504 2505₂₅₀₄ 2509₂₅₀₆ 2518₂₅₁₄ 2531₂₅₃₁ 10−2 77 82₇₇ 87₇₇ 111₇₇ 169₉₁ 297₂₉₇ 151 155₁₅₁ 167₁₅₂ 203₁₆₂ 292₂₃₅ 463₄₆₃ 1231 1232₁₂₃₁ 1236₁₂₃₃ 1247₁₂₄₁ 1265₁₂₆₅ 10−3 16 49₁₆ 58₁₆ 107₂₁ 176₆₉ 313₃₁₃ 139 144₁₄₀ 160₁₄₂ 206₁₅₇ 311₂₄₉ 494₄₉₄ 1383 1384₁₃₈₃ 1388₁₃₈₅ 1398₁₃₉₃ 1415₁₄₁₅ 10−4 9 49₉ 58₁₀ 109₂₀ 179₆₉ 317₃₁₇ 144 149₁₄₅ 165₁₄₇ 212₁₆₃ 320₂₅₇ 505₅₀₅ 1419 1420₁₄₁₉ 1423₁₄₂₁ 1434₁₄₂₉ 1451₁₄₅₁ 10−5 9 49₉ 58₉ 109₂₀ 179₆₉ 318₃₁₈ 145 150₁₄₅ 166₁₄₈ 213₁₆₄ 321₂₅₈ 506₅₀₆ 1423 1424₁₄₂₃ 1427₁₄₂₅ 1438₁₄₃₃ 1455₁₄₅₅ 10−6 9 49₉ 58₉ 109₂₀ 179₆₉ 318₃₁₈ 145 150₁₄₅ 166₁₄₈ 213₁₆₄ 321₂₅₈ 506₅₀₆ 1423 1424₁₄₂₄ 1428₁₄₂₅ 1438₁₄₃₃ 1455₁₄₅₅

Execution times (seconds) 10−1 10086₁₁₉₁₆3767 ₅₉₄₉762 ₁₀₃₉246 137₂₆₅ 152₁₅₂ 6488 1417_{6914 1660}439 192₅₁₄ 163₂₀₀ 234₂₃₃ 867 274₈₁₁ 128₃₁₀ 110₁₃₄ 156₁₅₆ 10−2 839 252_{971 280}51 22₆₀ 23₂₂ 45₄₅ 505 ₅₂₇96 ₁₁₀26 16₂₉ 22₂₁ 54₅₄ 374 ₃₃₆95 ₁₀₈50 51₅₈ 78₇₈ 10−3 193 ₂₂₈75 22_{39 10}13 17₁₁ 41₄₁ 453 ₄₇₁70 17₇₉ 13₂₁ 22₂₀ 56₅₆ 330 ₂₉₀78 47₉₃ 54₆₀ 84₈₄ 10−4 121 ₁₂₈68 21₂₆ 13₉ 19₁₂ 42₄₂ 468 ₄₈₆57 15₆₂ 14₂₀ 24₂₂ 58₅₈ 259 ₂₃₀67 50₈₇ 57₆₅ 87₈₇ 10−5 115 ₁₂₅64 18₂₄ 10₈ 16₁₀ 40₄₀ 472 ₄₇₄39 11₄₂ 11₁₄ 21₁₈ 56₅₆ 172 ₁₅₄48 40₆₂ 50₅₄ 84₈₅ 10−6 115 ₁₂₀63 18₂₃ 10₈ 16₁₀ 40₄₀ 473 ₄₇₂35 10₃₈ 10₁₃ 20₁₇ 55₅₅ 155 ₁₃₉46 36₅₈ 49₅₂ 83₈₃

Table 5.3: Iteration counts and execution times of the monotone bdd algorithm for the

test problem (3.6), using the minimal and maximal overlap size above and below the line, respectively, forN = 128. N1 is the number of mesh points in thex-direction, where the

monotonebsur method is in use.

In Section 4.5.2, it is observed that for the monotone bsur method ω = 1 results in

the minimal iteration counts and execution times, leading to the conclusion thatω= 1 is optimal. All the following numerical experiments have ω= 1.

Using the execution times from Section 4.5.2, we compare the monotonebsurmethod

with the undecomposed method (M = 1) by calculating the serial acceleration. The serial acceleration is the execution time of the undecomposed method / by the execution time of the monotonebsurmethod. The results are displayed in Figure 5.5. Figure 5.5 shows

that for all values of N and ε the serial acceleration is significantly greater than one, indicating a very significant advantage in the monotone bsurmethod.

Figure 5.4: Serial acceleration of the monotone bdd algorithm, the monotone dd algo-

rithm and the monotonebsurmethod, for the test problem (3.6).

Figure 5.5: Serial acceleration of the monotonebsur method for the test problem (3.8).

To investigate the serial acceleration of the monotone bdd algorithm, we begin by

looking at the effect of varying the size of the first subdomain, which is the subdomain solved by the monotonebsurmethod. Tables 5.4, 5.5 and 5.6 display the iteration counts

and execution times of the monotone bdd algorithm forN = 32, N = 64 and N = 128,

respectively. N1 is the number of mesh points in the x-direction in the first subdomain.

The minimum execution times for each value of the parameter are displayed in bold. From these tables, we can see that for < 10−1 the execution times are minimal when the first subdomain contains half the mesh points in the x-direction. This occurs when

the monotone bsur method is used outside of the boundary layer and the monotone dd algorithm is used within the boundary layer. From these tables, it is also clear that

forN = 32,64 and 128 the execution times are minimal when the number of subdomains are 3,5 and 9, respectively. In all of the tables, we can also see that for each value ofN1

and M the iteration counts are the same for <10−4. This indicates that the monotone

bddalgorithm is parameter uniformly convergent with respect to its iteration counts.

Figure 5.6 displays the serial acceleration of the monotone bddalgorithm. From this

figure, it is clear that for all values ofN and, the monotonebddalgorithm gives a serial

acceleration greater than one. It is also apparent that asdecreases the serial acceleration of the monotonebdd algorithm increases.

Figure 5.7 displays the serial accelerations of the monotone bsurmethod, the mono-

tone dd algorithm and the monotone bdd algorithm. From this figure, it is clear that

the monotone dd algorithm results in the lowest serial acceleration. For ≥ 10−5, the

monotone bsur method results in the fastest acceleration, however, for < 10−5 the

monotonebdd algorithm results in the highest serial acceleration.

5.5.3 Numerical observations

For both of the anisotropic convection-diffusion problem and convection-diffusion prob- lem with parabolic layer, the monotone dd algorithm, the monotone bsur method and

the monotone bdd algorithm are parameter uniformly convergent with respect to their

iteration counts. The serial acceleration for both of the test problems is greater than one for all the three of the methods. This indicates an advantage using these methods. For both of the test problems, for sufficiently large values of ε the monotone bsur method

results in the highest serial acceleration. However, for εsufficiently small the monotone

bddalgorithm results in the highest serial acceleration.

5.6

Conclusions

In this chapter, we investigate the composite monotone domain decomposition algorithms based on the Jacobi, Gauss-Seidel, block Jacobi, block Gauss-Seidel methods and the one- and two-level domain decomposition algorithms. In Theorems 16 and 17, monotone convergence of the Jacobi domain decomposition algorithm and the Gauss-Seidel domain

N1 N/4 N/2 3N/4 ε/M 2 3 5 9 2 3 5 9 2 3 5 Iteration counts 10−1 55 55₅₅ 55₅₅ 56₅₆ 75 75₇₅ 75₇₅ 75₇₅ 84 84₈₄ 84₈₄ 10−2 10 16₁₀ 19₁₀ 27₂₇ 30 31₃₀ 37₃₅ 45₄₅ 115 116₁₁₅ 116₁₁₆ 10−3 7 18₇ 22₉ 33₃₃ 35 37₃₅ 46₄₂ 57₅₇ 144 146₁₄₅ 146₁₄₆ 10−4 6 18₆ 23₉ 33₃₃ 35 38₃₆ 47₄₃ 59₅₉ 148 150₁₄₉ 150₁₅₀ 10−5 6 18₆ 23₉ 34₃₄ 35 38₃₆ 47₄₃ 59₅₉ 149 150₁₅₀ 151₁₅₁ 10−6 6 18₆ 23₉ 34₃₄ 35 ₃₆38 47₄₃ 59₅₉ 149 150₁₅₀ 151₁₅₁

Execution times (seconds)

10−1 2.75 0₂._.91_{81 0}0_..50₉₁ 0₀._.40₃₉ 1.07 ₁0._.0951 0₀._.34₄₃ 0_0..₃₆37 0.24 0₀._.18₂₂ 0₀._.22₂₁ 10−2 0.59 0₀._.29_{73 0}0_..24₂₈ 0₀._.26₂₆ 0.20 ₀0._.2112 0₀._.11₁₃ 0_0..₁₄14 0.21 0₀._.18₂₀ 0₀._.20₁₉ 10−3 0.42 0₀._.21₅₃ 0_0..22₂₉ 0₀._.34₃₃ 0.15 0₀._.09₁₅ 0₀._.09₁₀ 0_0..₁₄15 0.21 0₀._.19₂₁ 0₀._.22₂₁ 10−4 0.35 0₀._.17₄₇ 0_0..21₂₈ 0₀._.32₃₁ 0.10 0₀._.07₁₁ 0₀._.08₀₈ 0_0..₁₄14 0.18 0₀._.17₁₉ 0₀._.22₂₁ 10−5 0.35 0₀._.15₄₄ 0_0..21₂₇ 0₀._.33₃₂ 0.09 0₀._.06₁₀ 0₀._.08₀₈ 0_0..₁₃13 0.15 0₀._.16₁₆ 0₀._.21₂₀ 10−6 0.35 0₀._.13₄₄ 0_0..20₂₆ 0₀._.30₃₀ 0.08 0₀._.06₀₉ 0₀._.07₀₇ 0_0..₁₃13 0.12 0₀._.14₁₅ 0₀._.19₁₉

Table 5.4: Iteration counts and execution times of the monotone bdd algorithm for the

test problem (3.8), using the minimal and maximal overlap size above and below the line, respectively, for N = 32. N1 is the number of mesh points in the x-direction, where the

monotone bsur method is in use.

N1 N/4 N/2 3N/4 ε/M 2 3 5 9 17 2 3 5 9 17 2 3 5 9 Iteration counts 10−1 165 165₁₆₅ 166₁₆₅ 167₁₆₆ 170₁₇₀ 234 ₂₃₄234 234₂₃₄ 235₂₃₅ 236₂₃₆ 266 266₂₆₆ 267₂₆₇ 267₂₆₇ 10−2 18 22₁₈ 26₁₈ 43₁₈ 71₇₁ 48 ₄₈49 55₅₀ 74₆₃ 107₁₀₇ 287 288₂₈₈ 290₂₈₉ 292₂₉₂ 10−3 8 26₈ 32₈ 56₂₂ 94₉₄ 59 ₆₀62 72₆₃ 99₈₅ 143₁₄₃ 380 381₃₈₀ 384₃₈₃ 387₃₈₇ 10−4 6 27₆ 33₇ 59₂₂ 97₉₇ 61 ₆₂64 75₆₅ 103₈₈ 148₁₄₈ 394 395₃₉₅ 399₃₉₇ 402₄₀₂ 10−5 6 27₆ 33₇ 59₂₂ 98₉₈ 62 ₆₂65 76₆₅ 104₈₉ 149₁₄₉ 396 397₃₉₆ 400₃₉₉ 404₄₀₄ 10−6 6 27₆ 33₇ 59₂₂ 98₉₈ 62 ₆₂65 76₆₅ 104₈₉ 149₁₄₉ 396 397₃₉₆ 400₃₉₉ 404₄₀₄

Execution times (seconds) 10−1 82.8 ₁₂₄59.1_.4 14₇₆._.5_{0 16}8._.8₉ 6₆._.3₃ 61.7 21₆₆._.0_{4 21}9.8_.5 6₈._.3_{9 5}5_..9₉ 8.6 ₉5._.2₇ 3₄._.5₈ 3₃._.4₄ 10−2 15.0 ₂₂5.7_.9 5₈._.6_{8 4}4._.7₈ 5_5..₀0 9.6 2₉._.4_{5 2}1._.3₉ 1_1..₄2 1₁._.9₉ 6.6 3₆._.3_{8 3}2._.4₁ 2₂._.8₈ 10−3 5.6 ₈3_..3₂ 4₃._.2_{6 4}4_..7₆ 8₈._.8₇ 3.3 1₃._.4₄ 0₁._.69 ₁1_..1₁ 2₂._.2₂ 5.9 3₆._.0_{0 3}2._.5₀ 3₃._.3₃ 10−4 4.1 ₆2_..7₅ 3₃._.2_{5 4}4_..4₄ 7₇._.7₇ 2.4 1₂._.0₅ 0₁._.27 ₁1_..0₀ 2₂._.2₂ 4.5 2₄._.5_{7 2}2._.4₈ 3₃._.3₃ 10−5 4.3 ₆2_..2₅ 3₃._.5_{5 4}4_..4₀ 8₈._.2₂ 2.0 0₂._.8₁ 0₁._.06 ₀0_..9₉ 2₂._.1₁ 3.0 1₃._.9_{2 2}2._.1₃ 3₃._.1₁ 10−6 4.4 ₆2_..0₄ 3₃._.4_{5 3}4_..7₉ 8₈._.1₁ 1.8 0₁._.7₉ 0₀._.96 ₀0_..9₉ 2₂._.0₀ 2.3 1₂._.7_{6 2}2._.0₂ 3₃._.0₀

Table 5.5: Iteration counts and execution times of the monotone bdd algorithm for the

test problem (3.8), using the minimal and maximal overlap size above and below the line, respectively, for N = 64. N1 is the number of mesh points in the x-direction, where the

monotonebsur method is in use.

decomposition algorithm, respectively, is proven. In Theorem 18, the convergence of these two algorithms is compared and proven that the Gauss-Seidel domain decomposition algorithm is the fastest.

In Theorems 19 and 21, monotone convergence of the block Jacobi domain decomposi- tion algorithm and the block Gauss-Seidel domain decomposition algorithm, respectively, is proven. In Theorem 20, the point and block Jacobi domain decomposition algorithms are compared, and it is shown that the block Jacobi domain decomposition algorithm con- verges faster. In Theorem 22, the point and block Gauss-Seidel domain decomposition algorithms are compared, and it is shown that the block Gauss-Seidel domain decompo-

N1 N/4 N/2 3N/4 ε/M 2 3 5 9 17 33 2 3 5 9 17 33 2 3 5 9 17 Iteration counts 10−1 520 520₅₂₀ 520₅₂₀ 521₅₂₀ 525₅₂₂ 534₅₃₄ 752 752₇₅₂ 752₇₅₂ 753₇₅₂ 756₇₅₅ 759₇₅₉ 866 866₈₆₆ 867₈₆₆ 868₈₆₇ 870₈₇₀ 10−2 44 44₄₄ 44₄₄ 63₄₄ 104₄₄ 185₁₈₅ 82 82₈₂ 88₈₂ 112₈₇ 170₁₃₂ 279₂₇₉ 745 745₇₄₅ 747₇₄₆ 752₇₅₀ 759₇₅₉ 10−3 11 39₁₁ 48₁₁ 84₁₆ 138₅₅ 245₂₄₅ 100 104₁₀₀ 116₁₀₂ 152₁₁₂ 234₁₈₄ 377₃₇₇ 1009 1010₁₀₁₀ 1013₁₀₁₁ 1021₁₀₁₇ 1036₁₀₃₆ 10−4 7 40₇ 49₇ 88₁₇ 144₅₇ 254₂₅₄ 106 110₁₀₆ 123₁₀₈ 161₁₂₀ 247₁₉₅ 394₃₉₄ 1057 1058₁₀₅₇ 1061₁₀₅₈ 1070₁₀₆₅ 1085₁₀₈₅ 10−5 6 40₆ 49₇ 88₁₇ 145₅₇ 255₂₅₅ 106 111₁₀₇ 124₁₀₈ 162₁₂₀ 248₁₉₆ 396₃₉₆ 1062 1063₁₀₆₂ 1066₁₀₆₄ 1075₁₀₇₀ 1091₁₀₉₁ 10−6 6 40₆ 49₇ 88₁₇ 145₅₇ 256₂₅₆ 106 111₁₀₇ 124₁₀₉ 162₁₂₁ 248₁₉₆ 396₃₉₆ 1063 1063₁₀₆₃ 1066₁₀₆₄ 1076₁₀₇₁ 1091₁₀₉₁ 10−6 6 40₆ 49₇ 88₁₇ 145₅₇ 256₂₅₆ 106 111₁₀₇ 124₁₀₉ 162₁₂₁ 248₁₉₆ 396₇₂₉ 1063 1063₁₀₆₃ 1066₁₀₆₄ 1076₁₀₇₁ 1091₁₁₅₁

Execution times (seconds)

10−1 8851₁₀₉₄₁5143 1109_{5831 1829}231 127₂₈₀ 98₉₇ 6692 1903_{7027 2104}402 158_{350 130}96 102₁₀₂ 961 206_{893 187}87 55₇₄ 60₆₀ 10−2 985 ₁₂₅₁456 105_{837 163}72 89₇₅ 79₇₉ 507 132_{562 170}23 14₂₈ 15₁₅ 32₃₂ 586 ₅₅₀99 ₁₁₉47 35₄₅ 46₄₆ 10−3 273 157_{361 182}72 58₅₇ 103₈₄ 163₁₆₃ 404 ₃₄₈40 13₅₀ 10₁₆ 16₁₄ 40₄₀ 242 ₂₅₈79 42₉₄ 39₄₆ 57₅₈ 10−4 164 ₂₁₃94 41₉₄ 45₄₆ 94₇₆ 166₁₆₆ 365 ₃₆₂30 10_{35 12}8 15₁₃ 40₄₀ 200 ₂₀₄58 35₇₀ 38₄₂ 58₅₉ 10−5 137 ₁₇₇76 42₈₉ 42₄₃ 89₇₀ 158₁₅₈ 355 ₃₅₅22 ₂₆7 7₉ 14₁₂ 39₃₉ 124 ₁₂₅36 27₄₅ 34₃₇ 56₅₇ 10−6 137 ₁₇₉72 45₉₀ 42₄₂ 84₇₃ 160₁₆₀ 356 ₃₅₀20 ₂₄7 7₉ 14₁₂ 39₃₉ 90 31₉₃ 25₄₀ 34₃₅ 56₅₆

Table 5.6: Iteration counts and execution times of the monotone bdd algorithm for the test problem (3.8), using the minimal and maximal overlap size above and below the line, respectively, forN = 128. N1 is the number of mesh points in thex-direction, where the

monotone bsur method is in use.

sition algorithm converges faster. In Theorem 23, the convergence of the Gauss-Seidel and block Gauss-Seidel domain decomposition algorithms is compared and proven that the Gauss-Seidel domain decomposition algorithm converges faster.

The two-level composite monotone domain decomposition algorithms are constructed. The parrallisable nature of these algorithms are discussed.

As the theoretical results indicate that the block Gauss-Seidel domain decomposition algorithm has the fastest convergence, we apply this algorithm to the two test prob- lems: the convection-diffusion problem with parabolic boundary layers and the anisotropic

Figure 5.7: Serial acceleration of the monotone bdd algorithm, the monotone dd algo-

rithm and the monotonebsurmethod for the test problem (3.8).

convection-diffusion problem. For both of the test problems, the block Gauss-Seidel do- main decomposition algorithm convergesε-uniformly with respect to its iteration counts. The numerical experiments are compared to the numerical experiments in Chapters 3 and 4. The numerical experiments on the test problems show that for sufficiently large values of ε, the monotone bsur method from Chapter 4 results in the highest serial ac-

celeration. However, for εsufficiently small the composite monotone block Gauss-Seidel domain decomposition algorithm results in the highest serial acceleration.

Multigrid methods

In this chapter, we construct three monotone multigrid methods: the monotone multigrid method, the block monotone multigrid method and the two-level monotone multigrid algorithm. The monotone multigrid method, the block monotone multigrid method and the two-level monotone multigrid algorithm use the monotone successive underrelaxation method, the monotone block successive relaxation method and the monotone domain decomposition algorithm, respectively, for the smoothing part. All three methods use the full approximation scheme (FAS) from [27] for the course correction part. Monotone convergence of these algorithms is proven and numerical experiments are presented.

6.1

Introduction

Multigrid methods are accepted as fast efficient solvers, especially for elliptic problems. They consist of the two parts: the smoother which reduces the high frequency components in the error between numerical and exact solutions and the coarse correction based on the fact that the smooth error can be well represented on coarser meshes. The standard multigrid methods have shown to be unsatisfactory when applied to singularly perturbed problems [38].

A modified multigrid method is applied to linear singularly perturbed convection- diffusion equations in [38]. In [41], the monotone multigrid method is applied to nonlinear elliptic boundary value problems, and its monotone convergence is proven. In [3] and [71], a monotone multigrid method for nonlinear elliptic problems where the prolongation parameter is determined adaptively, is presented. The prolongation parameter ρ(_kn) is

chosen as large as possible from the solution of

[Ak+Fk0vk]z(p) =fk− Lkvk, ρ(kn)(p) =

z(p) ek(p)

, p∈Ωk (6.1)

where Ak and Fkvk are the linear and nonlinear terms, respectively, ofLvk and ek(p) is

the prolongated error of the approximation on the mesh Ωk−1. The course grid correction

to the approximation is given by

w_k(n)=v(_kn,t1)+ρ(_kn)e(_kn). From (6.1), we have

w(_kn)(p) =v_k(n,t1)(p) +z(p).

From here and (6.1), we can see that the course grid correctionw(_kn)(p) does not receive any information from the approximation on the meshes Ωk−1 and hence, there is no reason

to find approximations on different meshes and, hence, this method is not a multigrid method.

In this chapter, we construct three monotone multigrid methods: the monotone multi- grid method uses the monotone successive under-relaxation (sur) method for the smooth-

ing part; the block monotone multigrid method uses the block monotone successive under- relaxation (bsur) method for the smoothing part; the monotone multigrid algorithm uses the monotone domain decomposition algorithm from Chapter 3 for the smoothing part. All the three monotone multigrid methods use the full approximation scheme (FAS) from [27] for the course correction part. The advantages of the monotone multigrid methods are that they solve only linear discrete systems at each iterative step and converge glob- ally. Numerical results show that the monotone multigrid methods converge uniformly in the perturbation parameter.

In Section 6.2, we construct the monotone multigrid method and prove monotone convergence of the method. Numerical experiments are presented in Section 6.2.1 for the convection-diffusion problem with parabolic layers and the anisotropic convection- diffusion problem. In Section 6.3, we construct the monotone multigrid method and prove monotone convergence of the method. Numerical experiments are presented in Section 6.3.1. In Section 6.4, the two-level monotone multigrid algorithm is constructed, and monotone convergence of the algorithm is proven. Numerical experiments for two test problems are presented in Section 6.4.1.