From 3204a49d3042de546b8a62e369779ca7a4fe30b2 Mon Sep 17 00:00:00 2001 From: Wolfgang Bangerth Date: Mon, 31 Aug 2015 18:35:17 -0500 Subject: [PATCH] Update step-6 results section in a few places. --- examples/step-6/doc/results.dox | 33 ++++++++++++++++++++++----------- 1 file changed, 22 insertions(+), 11 deletions(-) diff --git a/examples/step-6/doc/results.dox b/examples/step-6/doc/results.dox index 01c87dbc30..c7453fbfef 100644 --- a/examples/step-6/doc/results.dox +++ b/examples/step-6/doc/results.dox @@ -167,6 +167,9 @@ the call to DoFHandler::clear().

Possibilities for extensions

+

Solvers and preconditioners

+ + One thing that is always worth playing around with if one solves problems of appreciable size (much bigger than the one we have here) is to try different solvers or preconditioners. In the current case, @@ -203,8 +206,8 @@ thresholding or strengthening of the diagonal. Using these various different preconditioners, we can compare the number of CG iterations needed (available through the -solver_control.last_step() call, see @ref step_4 -"step-4") as well as CPU time needed (using the Timer class, +solver_control.last_step() call, see +step-4) as well as CPU time needed (using the Timer class, discussed, for example, in step-12) and get the following results (left: iterations; right: CPU time): @@ -226,7 +229,7 @@ O}(N^{1/2})$ and because each iteration requires around ${\cal O}(N)$ operations the total CPU time grows like ${\cal O}(N^{3/2})$ (for the few smallest meshes, the CPU time is so small that it doesn't record). Note that even though it is the simplest -method, Jacobi is the fastest for this problem. +method, Jacobi is the fastest for this problem. The situation changes slightly when the finite element is not a bi-quadratic one as set in the constructor of this program, but a @@ -247,7 +250,11 @@ bi-linear one. If one makes this change, the results are as follows: In other words, while the increase in iterations and CPU time is as before, Jacobi is now the method that requires the most iterations; it is still the fastest one, however, owing to the simplicity of the -operations it has to perform. +operations it has to perform. This is not to say that Jacobi +is actually a good preconditioner -- for problems of appreciable size, it is +definitely not, and other methods will be substantially better -- but really +only that it is fast because its implementation is so simple that it can +compensate for a larger number of iterations. The message to take away from this is not that simplicity in preconditioners is always best. While this may be true for the current @@ -258,15 +265,19 @@ lead to an increase in the number of iterations as the number $N$ of degrees of freedom grows, for example ${\cal O}(N^\alpha)$; this, in turn, leads to a total growth in effort as ${\cal O}(N^{1+\alpha})$ since each iteration takes ${\cal O}(N)$ work. This behavior is -undesirable, we would really like to solve linear systems with $N$ +undesirable: we would really like to solve linear systems with $N$ unknowns in a total of ${\cal O}(N)$ work; there is a class -of preconditioners that can achieve this, namely geometric (@ref -step_16 "step-16") or algebraic (step-31) multigrid +of preconditioners that can achieve this, namely geometric (step-16) +or algebraic multigrid (step-31, step-40, and several others) preconditioners. They are, however, significantly more complex than -the preconditioners outlined above. Finally, the last message to take -home is that today (in 2008), linear systems with 100,000 unknowns are +the preconditioners outlined above. + +Finally, the last message to take +home is that when the data shown above was generated (in 2008), linear +systems with 100,000 unknowns are easily solved on a desktop machine in well under 10 seconds, making the solution of relatively simple 2d problems even to very high accuracy not that big a task as it used to be even in the recent -past. Of course, the situation for 3d problems is entirely different. - +past. At the time, the situation for 3d problems was entirely different, +but even that has changed substantially in the intervening time -- though +solving problems in 3d to high accuracy remains a challenge. -- 2.39.5