The Crank-Nicholson method for a nonlinear diffusion equation

Transcription

1 > retart; with(plot): with(linearalgebra): with(arraytool): The Crank-Nicholon method for a nonlinear diffuion equation The purpoe of thi workheet i to olve a diffuion equation involving nonlinearitie numerically uing the Crank-Nicholon tencil. We tart with the following PDE, where the potential function i meant to be a nonlinear function of the unknown u(t,x): > potential := u -> u*(u-)-; pde := diff(u(t,x),t) = diff(u(t,x),x,x)+potential(u(t,x)); potential := u u ( u ) pde := = + t ( ) x To contruct the Crank-Nicholon tencil for thi PDE, we will make ue of the following procedure, a before: > centered_tencil := proc(r,n,{direction := patial}) local n, tencil, var, beta_ol: n := floor(n/): if (direction = patial) then: tencil := D[$r](u)(t,x) - add(beta[i]*u(t,x+i*h),i=-n..n); var := [u(t,x),eq(d[$i](u)(t,x),i=..n-)]; ele: tencil := D[$r](u)(t,x) - add(beta[i]*u(t+i*h,x),i=-n..n); var := [u(t,x),eq(d[$i](u)(t,x),i=..n-)]; fi: beta_ol := olve([coeff(collect(convert(erie(tencil,h,n),polynom),var,'ditributed'),var)]): tencil := ub(beta_ol,tencil); if (direction = patial) then: convert(tencil = convert(erie(tencil,h,n+),polynom),diff); ele: ub(h=,convert(tencil = convert(erie(tencil,h,n+),polynom),diff)); fi: oneided_tencil := proc(r,n,{direction := patial}) local tencil, var, beta_ol: if (direction = patial) then: tencil := D[$r](u)(t,x) - add(beta[i]*u(t,x+i*h),i=0..n-); var := [u(t,x),eq(d[$i](u)(t,x),i=..n-)]; ele: tencil := D[$r](u)(t,x) - add(beta[i]*u(t+i*h,x),i=0..n-); var := [u(t,x),eq(d[$i](u)(t,x),i=..n-)];

2 fi: beta_ol := olve([coeff(collect(convert(erie(tencil,h,n),polynom),var,'ditributed'),var)]): tencil := ub(beta_ol,tencil); if (direction = patial) then: convert(tencil = convert(erie(`leadterm`(tencil),h,n+),polynom),diff); ele: ub(h=,convert(tencil = convert(erie(`leadterm`(tencil),h,n+),polynom),diff)); fi: Our baic tencil for the derivative are a follow: > center_pace := iolate(lh(centered_tencil(,3)),diff(u(t,x),x,x)); forward_time := iolate(lh(oneided_tencil(,,direction=temporal)),diff(u(t,x),t)); backward_time := ub(=-,forward_time); center_pace := = u ( t, x h ) u ( t, x + h ) h h h + x forward_time := = + t backward_time := = t Subbing thee object into the PDE in variou combination give u the baic three tencil: > FTCS := ub(center_pace,forward_time,pde); BTCS := ub(center_pace,backward_time,t=t+,pde); CN := (FTCS+BTCS)/; CN := + u ( t +, x ) = FTCS := + = BTCS := + = u ( t +, x ) u ( t +, x ) u ( t +, x ) u ( t, x ) u ( t, x h ) u ( t, x + h ) + + ( ) h h h u ( t +, x h ) u ( t +, x ) u ( t +, x + h ) + + u ( t +, x ) ( u ( t +, x ) ) h h h u ( t, x h ) u ( t, x + h ) h h h ( ) u ( t +, x h ) u ( t +, x ) u ( t +, x + h ) h h h u ( t +, x ) ( u ( t +, x ) ) A before, only the FTCS tencil explicitly give u the future value of u baed on pat value. We will be working with the CN tencil, which wa hown to be unconditionally table for the linear problem and i econd order in both pace and time. We relabel the pat value of u a the element of an array V and the future value a the element of an array U: > Sub := [eq(u(t+,x-i*h)=u[j+i],i=-..),eq(u(t,x-i*h)=v[j+i],i=-..)]; Putting thee definition into the tencil, we get > CN := (lh-rh)(ub(sub,cn)); Sub := [ u ( t +, x + h ) = U, u ( t +, x ) = U j, u ( t +, x h ) = U, u ( t, x + h ) = V, = V j, u ( t, x h ) = V ] V j CN := U j V V j h h V h V j ( V ) U U j h h U h U j ( U )

3 When we ue thi in an actual algorithn, the V' will be known and the U' will be unknown. Oberve that ince the potential wa nonlinear, the U' appear nonlinearly in thi equation. Previouly, the U' all appeared linearly, and the above wa jut one component of the matrix equation A.U=B. We can convert CN into a linear equation by defining: > Linearization := eq(u[j+i] = U0[j+i] + epilon*du[j+i],i=-..); Linearization := U = U0 + εdu, U j = U0 j + εdu j, U = U0 + εdu In thi formula, U0[j] i a gue for the value of U[j] and epilon*du[j] i the error in that gue. We'll ubtitute thi into CN, and then expand the reulting expreion to linear order in epilon (after the erie ha been calculated, we et epilon = ): > CN_linear := ub(linearization,cn): CN_linear := erie(cn_linear,epilon,): CN_linear := convert(cn_linear,polynom): CN_linear := implify(ub(epilon=,cn_linear)): CN_linear := (lh-rh)(expand(iolate(cn_linear,du[j]))): CN_linear := (CN_linear=0)-ub(eq(dU[j+i]=0,i=-..),CN_linear); du CN_linear du + V j h := + du h h + U0 j h h h + U0 j h j = + U0 j h h h + U0 j h h h + U0 j h h V j h V V j V + + h h + U0 j h h h + U0 j h h h + U0 j h h h + U0 j h h h + U0 j h V j U0 j h U0 U0 j h h h + U0 j h h h + U0 j h h h + U0 j h U0 j h h h + U0 j h h h + U0 j h U0 h h + U0 j h On the LHS of CN linear are the new unknown du[j] and on the right are the known V[j] and U0[j]. So, given a gue U0 for the olution U of the CN tencil, thi give u a linear ytem for the error in the gue du. After the ytem i olved for du, we obtain a better gue for U from U0 + du. We can then iterate the procedure a number of time to futher refine our olution. Thi i Newton' method for olving a nonlinear ytem of M equation with M unknown. We can illutrate tucture of the linear ytem for du by defining two function q and b: > q_def := q(u0[j],,h) = coeff(lh(cn_linear),du[j+]); CN_linear := implify(algub(iolate(q_def,h^),cn_linear)): b_def := b(u0,v,j,,h) = rh(cn_linear); q_def :=,, h ) = h h + U0 j h b_def := b ( U0, V, j,, h ) = ( U0 j V j V j + V j + U0 j + U0 j + 4 ( ) q U0 j,, h V,, h ) 8V j,, h ) V,, h ) U0 + + U0,, h ) V,, h ) U0 j + 4V j,, h ) U0 j V,, h ) U0 j U0,, h ) U0 j U0,, h ) U0 j j,, h ) V j,, h ) + V,, h ) + V,, h ) + U0 j,, h ) + U0,, h ) + U0,, h ) ) ( + U0 j ) In tern if thee two function, the CN linear tencil look a little impler: > CN_linear := lh(cn_linear) = lh(b_def); CN_linear := du,, h ) + du,, h ) + du j = b ( U0, V, j,, h )

4 Here i what the linear ytem look like when there are M = 4 interior node: > U0 := 'U0': V := 'V': du := 'du': eq := 'eq': M := 4: V[0] := 0: V[M+] := 0: U0[0] := 0: U0[M+] := 0: du[0] := 0: du[m+] := 0: for i from to M do: eq[i] := eval(ub(j=i,cn_linear)): od; eq := du q ( U0,, h ) + du = b ( U0, V,,, h ) eq := du 3 q ( U0,, h ) + du q ( U0,, h ) + du = b ( U0, V,,, h ) eq 3 := du 4 q ( U0 3,, h ) + du q ( U0 3,, h ) + du 3 = b ( U0, V, 3,, h ) eq 4 := du 3 q ( U0 4,, h ) + du 4 = b ( U0, V, 4,, h ) Thee M equation form a linear ytem of M unknown du[j]. Viewing thi a a matrix equation A.dU = B, we can determine A and B uing the GenerateMatrix command from the LinearAlgebra package: > A,B := GenerateMatrix(convert(eq,lit),[eq(dU[j],j=..M)]): A; B; q ( U0,, h ) 0 0 q ( U0,, h ) q ( U0,, h ) 0 0 q ( U0 3,, h ) q ( U0 3,, h ) 0 0 q ( U0 4,, h ) b ( U0, V,,, h ) b ( U0, V,,, h ) b ( U0, V, 3,, h ) b ( U0, V, 4,, h ) We ee that in order to obtain du, we need to olve a tridiagonal matrix equation. The following procedure take the array of pat value V, a gue for the future value U0, and the time and pacetep h and return the matrix A and > AA := proc(u0,v,,h) local qu0, M, A, B: qu0 := map(x->q(x,,h),u0): M := rh(arraydim(u0))-; A := BandMatrix([convert(qU0[..M],lit),[$M],convert(qU0[..M-],lit)],,M);

5 B := Vector(..M,[eq(b(U0,V,i,,h),i=..M)]): A,B: Notice that for thi procedure to actually return A and B a floating poing object, q and b need to be defined a procedure. > q := unapply(rh(q_def),u0[j],,h): b := unapply(rh(b_def),u0,v,j,,h): Here i the procedure that actually implement Newton' method. Taking the pat field value V,, h and the number of patial node, it implement Newton' method to olve the nonlinear ytem for the future field value U. It decide to top the iteration when the average magnitude of the element of the du vector are le than a mall parameter ep. Note that we invoke the LinearSolve command with the SpareIterative method to peed thing up a little. > Newton := proc(v,,h,m) local U, i, du, CONTINUE, ep, err: U := Array(0..M+,datatype=float): U[..M] := V[..M]: # our initial gue i U = V CONTINUE := true: ep := e-3: # the parameter that fixe when the Newton iteration top for i from to 50 while (CONTINUE) do: # we're going to do a maximum of 50 iteration du := LinearSolve(AA(U,V,,h), method='spareiterative'): # obtain the du from the gue U by olving the linear ytem generated by AA err := qrt((du.du)/m): # calculate the root-mean-quare value of the component of du if (err < ep) then CONTINUE := fale fi: # decide if err i mall enough to top iterating U[..M] := U[..M] + du: # update the gue by adding du od: U: Here i the main calculation: > CN_evolve := proc(f,x,t,,h) local N, M, x, XX, V, p, A, i, B, U, q: N := round(t/): # the number of timetep M := round(x/h) - : # the number of pacetep x := j -> -X/ + j*h: XX := Array(0..M+,[eq(x(j),j=0..M+)],datatype=float): # define Array of x value for plotting V := Array(0..M+,[eq(f(x(j)),j=0..M+)],datatype=float): # initial data p[0] := plot(littool[tranpoe](convert (Concatenate(,XX,V),litlit)),axe=boxed): # firt frame of the movie for i from to N do: # loop over timetep V[..M] := Newton(V,,h,M)[..M]: # Newton iteration to evolve field value p[i] := plot(littool[tranpoe](convert (Concatenate(,XX,V),litlit)),axe=boxed): # ith frame of the movie od: diplay(convert(p,lit),inequence=true): # prepare movie output Chooe initial data and parameter to tet the code: > f_ := x -> /coh(0*x);

6 X_ := ; T_ := ; _ := 0.0; h_ := 0.5; f_ := x X_ := T_ := _ := 0.0 ( ) coh 0x h_ := 0.5 movie i the output of our code, while movie i the output of pdolve/numeric for the ame problem: > movie := CN_evolve(f_,X_,T_,_,h_): pd := pdolve(pde,[u(0,x)=f_(x),u(t,-x_/)=0,u(t,x_/)=0],numeric,timetep=_,pacetep=h_): movie := pd:-animate(t=0..t_,axe=boxed,frame=round(t_/_)+,tyle=point,color=blue): We diplay the movie imultaneouly to compare reult. The pdolve anwer i in point while our code i the line. > diplay([movie,movie]);

7 > >