MATH 450 / 550 Homework 1: Due Wednesday February 18, 2015

Transcription

1 MATH / Homework MATH / Homework : Due Wednesday February, Answer the following questions to the best of your ability. Solutions should be typed. Any plots or graphs should be included with the question (please include the questions in your typed solutions). General Problems. Consider the centered difference discretization of u + u + u =, u() = u() =. Solve this problem using the GMRES solver you have been given. Look at the error of each iteration of the GMRES algorithm. Implement your solution on different meshes with,,,... points. How does the performance of the algorithm depend on the mesh given? It will help to look at a semi-log plot of the residual. The following listing reflects the code that is needed in order to solve the problem that was stated. import sys import os import math from numpy import from pylab import import m a t p l o t l i b. pyplot as p l t from KSPSolvers import # S c r i p t S o l v e s : u xx + u x + u = with u ( ) = u ( ) =. m = ; # D i s c r i t i z a t i o n parameter. x =. # Domain L e f t End Point. xmmo =. # Domain Right End Point. h = (xmmo x ) / (m ); p r i n t h =, h ; # I n i t i a l i z e the needed v e c t o r s. A = z e r o s (m m, f l o a t ) ; A. shape=(m,m) u = z e r o s (m, f l o a t ) ; u. shape=(m, ) b = z e r o s (m, f l o a t ) ; b. shape=(m, ) x = z e r o s (m, f l o a t ) ; x. shape=(m, ) # Populate t h e System Matrix and RHS.

2 MATH / Homework A[, ] =. ; b [ ] =. ; # LHS Boundary c o n d i t i o n. A[m,m ] =. ; b [m ] =. ; # RHS Boundary c o n d i t i o n. x [ ] = x ; x [m ] = xmmo; # Boundary Values. f o r i in range (, ( l e n ( b ) )): # The main matrix system. A[ i, i ] = ((./(. h ) ) + (. / ( h h ) ) ) ; A[ i, i ] =. + (. / ( h h ) ) ; A[ i, i +] = ( (. / (. h ) ) (. / ( h h ) ) ) ; b [ i ] =. ; # The Problem Domain. x [ i ] = x + i h ; # Check System. p r i n t A =, A p r i n t b =, b # Our GMRES S o l v e r No P r e c o n d i t i o n i n g. System = gmres ( Matrix=A,RHS=b, x=u, Tol=e, maxits=l e n ( b ) ) u, error, t o t a l I t e r s = System. s o l v e ( ) # Pring out some i n f o r m a t i o n. #p r i n t S o l u t i o n : #p r i n t u =, u #p r i n t Check = #p r i n t A. dot ( u ) # P l o t t i n g the i n i t a l p r o f i l e. p l t. p l o t ( x, u, k ) #p l t. show ( ) FileName = Probuhm + s t r (m) +. pdf s a v e f i g ( s t r ( FileName ) ) # P l o t t i n g the i n i t a l p r o f i l e. p l t. p l o t ( e r r o r, k ) #p l t. show ( ) FileName = Proberrorm + s t r (m) +. pdf s a v e f i g ( s t r ( FileName ) ) # P l o t t i n g the i n i t a l p r o f i l e. p l t. semilogy ( e r r o r [ : ], k ) #p l t. show ( ) FileName = Problogerrm + s t r (m) +. pdf s a v e f i g ( s t r ( FileName ) ) #p r i n t e r r o r =, e r r o r ; p r i n t i t e r a t i o n s NO PC =, t o t a l I t e r s ;

3 MATH / Homework mesh final solution normal residual plot log of residual vs iteration n = n = n = n = n = n = n = Notice as the mesh is refined the solution looks smoother. Also note that the size of the residual is reduced with each iteration. It takes roughly n ( the size of the system )

4 MATH / Homework iterations for the algorithm to fully converge to the desired tolerance.. Determine all iterates x k that are generated when GMRES is used to solve the linear system Ax = b, where A = and b =, with initial guess x = R. Can you generate this example to n n linear systems of any dimension n > for which GMRES exhibits an analogous behavior? What happens when the initial guess is changed? Consider the matrix system Ax = b where A =, b = Solving the system by hand we obtain the vector: x = as the solution to the equation. If we apply the Matlab version of GMRES to this system by using the commands: Matlab returns the following out put: GMRES(A, b) gmres stopped at iteration without converging to the desired tolerance e- because the method stagnated. Thus, the GMRES algorithm that is built into Matlab checks to see if the residual was reduced during the GMRES iteration, if the residual was not reduced than the method is considered to be stagnating, and GMRES will not continue to progress toward a solution. The gmres algorithm given in class did not stop when the residual is not reduced after each iteration. Matlab found the solution in five iterations. We can examine this.

5 MATH / Homework solution by looking at the history of residual norms after each iteration. Starting out the residual is ; thus, the GMRES algorithm is started, and after each of the first iterations we have a residual norm of. Then on the fifth iteration we see the first reduction in the residual norm, where it drops to zero. Why does GMRES take so many iterations to achieve a solution. To get a real good feel for this we can examine the GMRES algorithm from class by hand: Set up: Here we use the starting initial guess in our case x = [ ] T to find the starting residual. Several other quantities are also computed: ρ = r =, β = and k = Since our residual norm is not zero we need to find a search direction: v = r = r Iteration : Compute a second search direction. v = Av = For j = : h, = v T v = [ ] and since h, = then v will remain unchanged. h, = v v = Thus, the Hessenburg matrix is currently: H = = =

6 MATH / Homework and again v remains unchanged. We now minimize the value of the quantity: βe H y where Thus, we are minimizing: e = y This quantity will be minimized when y is the zero vector, and hence: = ρ = Hence we progress to iteration without a reduction in the residual. Continuing through the algorithm we obtain the following sequence of Hessenburg Matrices and Search Directions: iteration = H = iteration = H = iteration = H = iteration = H = iteration = H =

7 MATH / Homework v iteration = v = iteration = v = iteration = v = iteration = v = iteration = v = After each iteration we make no progress in the reduction of the error residual until iteration. Here we have a search direction that will allow for a nonzero y vector to be found. We should note that as we progress through the algorithm the columns of the Hessenburg matrix are forming our original A matrix. It takes iteration to find the solution because of the order in which the algorithm progress through search directions. The search direction we need just happens to be the last orthogonal search direction left for the algorithm to look in. If we pass the algorithm a different initial guess. We see that the algorithm may take fewer iterations. Note we could generalize this to any size system following the pattern in the given system matrix. In this case when given a zero vector as the initial guess the algorithm will continue to stall until system reaches the nth iterate at which point it will obtain the solution it is searching for. Graduate Students. Consider preconditioning the system given in the first general homework problem. Specifically use the preconditioning matrix M on your system matrix in Ax = b where the precondition map M is defined by: (Mf) = f, (Mf)() = (Mf)() =. That is, precondition with a solver for the high-order term in the differential equation using the correct boundary conditions. Implementation of the system will then look like: MAx = Mb Complete the study using the same meshes as suggested above. Note here we use a second order discritization of the second derivative operator. Following the work done in problem one above it can be seen that we obtain a matrix that can be populated using the following loop: M[, ] =. ; M[m,m ] =. ; # P r e c o n d i t i o n e r f o r i in range (, ( l e n (b) )): # P r e c o n d i t i o n e r. M[ i, i ] = (./(h h ) ) ; 7

8 MATH / Homework M[ i, i ] = (. / ( h h ) ) ; M[ i, i +] = (./(h h ) ) ; In order to get the full effect of this preconditioning we consider the inverse of this matrix as a preconditioner. This is implemented in the code as: # ======================================================================= # Our GMRES S o l v e r With P r e c o n d i t i o n i n g. # ======================================================================= SystemP = gmres ( Matrix=l i n a l g. inv (M). dot (A),RHS=l i n a l g. inv (M). dot ( b ), x=up up, errorp, t o t a l I t e r s p = SystemP. s o l v e ( ) The following table illustrates the number of iterations needed by the GMRES algorithm to achieve the provided residual size tolerance. Mesh n = n = n = n = No PC 9 9 With PC Note that with the preconditioning the algorithm converges iterations each time for the meshes considered which is in-contrast to the unpreconditioned case where the number of steps increases proportionally to the size of the system solved. The following figure showcases the final approximated solution on each of the different meshes considered, as well as looks at the different ways of observing the size of the residual in the algorithm as it progresses. Note that the size of the residual is always going down.

9 MATH / Homework mesh final solution normal residual plot log of residual vs iteration n = n = n = n = In all cases it can be seen that the preconditioned case achieves the required residual tolerance for algorithm termination much faster that when GMRES is run without the preconditioner. 9