Key exercise 1 INF5620

Transcription

1 Key exercise 1 INF5620 Matias Holte kjetimh@student.matnat.uio.no 13. mars Key exercise 1 The task was to implement a python program solving the 2D wave equation with damping, variable wave velocity, and du/dn=0 boundary conditions, on a rectangle-shaped domain with uniform mesh partition. domain The domain was set to in x and y direction, with maximum time = 19. Then a mesh of variable size was put on top of the domain. wave velocity The wave velocity was set to 1 in most of the domain, except a small square-shaped subdomain in the middle, where the velocity was considerably smaller initial contidion As initial condition, we chose u(x, y, 0) = cos(pi x) for x < 1/2 and u = 0 otherwise. In other words, a wave travelling in x direction. damping A damping constant β 0 was chosen, dampening the waves. 1.1 Mathematical equation The wave equation reads: 2 u t 2 + β u t = ( c(x, y) u ) + ( c(x, y) u ) + f(x, y) x x y y In addition we have the boundary conditions: u(x, y, 0) = I(x, y) u n = 0 1

2 1.2 Finite differences We use these finite differences 2 u u(x, y, t + t) 2u(x, y, t) + u(x, y, t t) t 2 = t 2 u u(x, y, t + t) u(x, y, t t) = ( t 2 t c(x, y) u ) c(x + x/2, y) u(x + x/2, y, t) c(x x/2, y) u(x x/2, y, t) = x x x x c(x + x/2, y)(u(x + x, y, t) u(x, y, t)) = x 2 c(x x/2, y)(u(x, y, t) u(x x, y, t) ( c(x, y) u ) = y y = And boundary conditions x 2 c(x, y + y/2) u(x, y + y/2, t) c(x, y y/2) u(x, y y/2, t) y y c(x, y + y/2)(u(x, y + y, t) u(x, y, t)) y 2 c(x, y y/2)(u(x, y, t) u(x, y y, t)) y 2 u(x, y, dt) = u(x, y, dt) u( dx, y, t) = u(dx, y, t) u(xmax + dx, y, t) = u(xmax dx, y, t) u(x, dy, t) = u(x, dy, t) u(x, ymax + dy, t) = u(x, ymax dy, t) 2 Benchmarks In order to test the speed of the solution, timing functions were added at the beginning and end of the solver function. Additionally, storage of everything but the last 3 timesteps was disabled, and plotting too. In other words, just the actual calculations contributed to the time. In each test, the number of points in x, y and time direction is given. The total number of points calculated is the product of these, ranging from 8100 to Note that the numbers include the ghost nodes at the edge, but the asymptotic size is the same 2

3 nx ny nt initialization solver total time s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s s 3 The python program 1 #!/ usr/bin/env python 2 3 from future import d i v i s i o n # d i s a b l e i n t e g e r d i v i s i o n 4 import sys 5 from s c i t o o l s import easyviz 6 from s c i t o o l s. numpyutils import * 7 from s c i t o o l s. a l l import * 8 import numpy as np 9 import time 10 import os, s h u t i l def ic_vec ( I, f, u, um, xv, yv, Cx2, Cy2, dt, cxp, cxm, cyp, cym, cxa, cya ) : 14 " " " 15 i n i t i a l i z e with f i r s t 2 timesteps. With time = 0, use i n i t i a l condition 16 given by function I ( ), when time = dt, the s t a t e i s equal to time = dt 17 we can thus combine the two timesteps and divide everything by 2 18 Note t h a t we ignore damping in t h i s f i r s t timestep I = function taking two coordinates and returning a valu e 21 f = function in equation, ignored f o r now 3

4 22 u = current timestep = 0 23 um = previous timestep = dt 24 xv, yv = p o s i t i o n of points 25 Cx2, Cy2 = f a c t o r s due to grid s i z e 26 dt = time step 27 c [ xy ] [ pma] = wave speed in [ xy ] d i r e c t i o n, at o f f s e t [ plus minus both ] " " " 29 nx, ny = xv. shape [0] 1, yv. shape [1] 1 30 dt2 = dt * dt 31 u [ :, : ] = I ( xv, yv ) 32 um[ 1 : nx, 1 : ny ] = u [ 1 : nx, 1 : ny ] + \ * Cx2 * ( cxm * u [ 0 : nx 1,1:ny ] ( cxa ) * u [ 1 : nx, 1 : ny ] + cxp * u [ 2 : nx + 1, 1 : ny ] ) + \ * Cy2 * ( cym * u [ 1 : nx, 0 : ny 1] ( cya ) * u [ 1 : nx, 1 : ny ] + cyp * u [ 1 : nx, 2 : ny +1]) 35 # * dt * * 2 * f ( xv [ 1 : nx, : ], yv [ :, 1 : ny ], 0. 0 ) 36 um = bc_vec (um, nx +1, ny +1) 37 return u, um def scheme_vec ( f, up, u,um, xv, yv, t, Cx2, Cy2, dt, b, cxp, cxm, cyp, cym, cxa, cya ) : 40 " " " 41 c a l c u l a t e next step, given the current and previous timestep up = next timestep, the one we c a l c u l a t e 44 b = damping f a c t o r 45 t = current time ( might be needed in f ( ) ) 46 r e s t of parameters are equal to ic_vec 47 " " " 48 nx, ny = xv. shape [0] 1, yv. shape [1] 1 49 up [ 1 : nx, 1 : ny ] = ( um[ 1 : nx, 1 : ny ] + 2 * u [ 1 : nx, 1 : ny ] + \ 50 Cx2 * ( cxm * u [ 0 : nx 1,1:ny ] ( cxa ) * u [ 1 : nx, 1 : ny ] + cxp * u [ 2 : nx + 1, 1 : ny ] ) + \ 51 Cy2 * ( cym * u [ 1 : nx, 0 : ny 1] ( cya ) * u [ 1 : nx, 1 : ny ] + cyp * u [ 1 : nx, 2 : ny +1]) + \ 52 b * um[ 1 : nx, 1 : ny ] * dt/2 \ 53 # + dt * * 2 * f ( xv [ 1 : nx, : ], yv [ :, 1 : ny ], t +dt ) 54 ) /(1+b * dt /2) 55 return up def bc_vec ( up, nx, ny ) : 4

5 58 59 add border conditions to matrix by updating the edges of 60 the up matrix. nx and ny are the dimentions of the matrix. 61 The border values are a l s o c a l l e d ghost nodes, because they 62 are outside the domain and only included to avoid s p e c i a l 63 cases in the ic_vec ( ) and scheme_vec ( ) f u n c t i o n s 64 ( I HATE s p e c i a l cases ) # ze r o border 67 # up [ 1, : ] = 0 68 # up [ :, 1 ] = 0 69 # up[ nx 2,:] = 0 70 # up [ :, ny 2] = 0 71 # return up # zero d e r i v a t i v e at border 74 up [ 0, : ] = up [ 2, : ] 75 up [ :, 0 ] = up [ :, 2 ] 76 up[ nx 1,:] = up[ nx 3,:] 77 up [ :, ny 1] = up [ :, ny 3] 78 return up def s o l v e r ( I, f, C, Lx, Ly, Lt, nx, ny, dt, b, benchmark=false ) : 82 " " " 83 I n i t i a l i z e v a r i a b l e s used in the s o l v e r. 84 May a l s o c a l l d i f f e r e n t schemes ( not implemented ) I, f,c = f u n c t i o n s in the equation 87 Lx, Ly, Lt = length of domain in x, y and time d i r e c t i o n 88 nx, ny = number of nodes in x, y d i r e c t i o n 89 dt = timestep 90 b = beta parameter 91 benchmark = don t save s olution, and output debug i n f o 92 " " " 93 i f benchmark : 94 t0 = time. time ( ) 95 dx = Lx/ f l o a t ( nx ) 5

6 96 dy = Ly/ f l o a t ( ny ) # grid i s nx * ny squares => ( ( nx+1) * ( ny+1) ) corners 99 # in addition we need two squares e x t r a f o r the ghost ( edge ) squares 100 nx, ny = nx+3,ny x = l i n s p a c e ( dx, Lx+dx, nx ) # grid points in x d ir 102 y = l i n s p a c e ( dy, Ly+dy, ny ) # grid points in y d ir 103 xv = x [ :, None ] 104 yv = y [ None, : ] # precompute f a c t o r s caused by the function C 107 cxp = C( xv [ 1 : nx 1,:]+ dx/2,yv [ :, 1 : ny 1]) 108 cxm = C( xv [ 1 : nx 1,:] dx/2,yv [ :, 1 : ny 1]) 109 cyp = C( xv [ 1 : nx 1, : ], yv [ :, 1 : ny 1]+dy/2) 110 cym = C( xv [ 1 : nx 1, : ], yv [ :, 1 : ny 1] dy/2) 111 cxa = cxm+cxp 112 cya = cym+cyp # find max time step i f i n v a l i d ( non p o s i t i v e ) 115 i f dt <= 0 : 116 dt = (1/ f l o a t ( cxp. max ( ) ) ) * (1/ s q r t (1/ dx * * 2 + 1/ dy * * 2 ) ) 117 Cx2 = ( dt/dx ) * * 2 ; Cy2 = ( dt/dy ) * * 2 # help v a r i a b l e s up = zeros ( ( nx, ny ) ) # s o l u t i o n array 120 u = up. copy ( ) # s o l u t i o n at t dt 121 um = up. copy ( ) # s o l u t i o n at t 2 * dt t = u,um = ic_vec ( I, f, u,um, xv, yv, Cx2, Cy2, dt, cxp, cxm, cyp, cym, cxa, cya ) U = [ ] 127 i f benchmark : 128 t1 = time. time ( ) 129 e l s e : 130 U. append ( u. copy ( ) ) while t <= Lt : 133 t += dt 6

7 134 # update a l l inner points 135 up = scheme_vec ( f, up, u, um, xv, yv, t, Cx2, Cy2, dt, b, cxp, cxm, cyp, cym, cxa, cya ) 136 # update border points 137 up = bc_vec ( up, nx, ny ) 138 # update data s t r u c t u r e s f o r next step : 139 um, u, up = u, up, um 140 # save s o l u t i o n 141 i f not benchmark : 142 U. append ( u. copy ( ) ) 143 i f benchmark : 144 t2 = time. time ( ) 145 p r i n t " " " Test with nx = %d, ny = %d, nt = %d : i n i t : %3.5 f s, s o l v e r %3.5 f s, t o t a l %3.5 f " " " % ( nx, ny, Lt/dt, t1 t0, t2 t1, t2 t0 ) 146 return x, y,u def small_mesh ( ) : 149 # Lx, Ly, nx, ny, dt 150 return ( 2 0, 1 0, 6, 6, 1 ) def medium_mesh ( ) : 153 # Lx, Ly, nx, ny, dt 154 return ( 2 0, 1 0, 2 0, 1 0, 0. 5 ) def large_mesh ( ) : 157 # Lx, Ly, nx, ny dt, 158 return ( 2 0, 1 0, 5 0, 2 5, 0. 1 ) def huge_mesh ( ) : 161 # Lx, Ly, nx, ny dt, 162 return ( 2 0, 1 0, 1 0 0, 5 0, ) def benchmark1_mesh ( ) : 165 # Lx, Ly, nx, ny dt, 166 return ( 2 0, 1 0, 1 0 0, 1 0 0, ) def benchmark2_mesh ( ) : 169 # Lx, Ly, nx, ny dt, 170 return ( 2 0, 1 0, 3 0 0, 3 0 0, ) def benchmark3_mesh ( ) : 173 # Lx, Ly, nx, ny dt, 174 return ( 2 0, 1 0, , , ) 7

8 def benchmark4_mesh ( ) : 177 # Lx, Ly, nx, ny dt, 178 return ( 2 0, 1 0, , , ) def t e s t _ c o n s t a n t ( mesh= small, nt = 100) : 181 Lx, Ly, nx, ny, dt = eval ( mesh+" _mesh " ) ( ) 182 Lt = dt * nt 183 beta = # constant i n i t i a l function gives constant s o l u t i o n always 186 def I ( x, y ) : 187 return def f ( x, y, t ) : 190 return def C( x, y ) : 193 return * ( x>=4) * ( x <=6) * ( y>=4) * ( y<=6) x, y,u = s o l v e r ( I, f, C, Lx, Ly, Lt, nx, ny, dt, beta ) 196 return x, y,u def test_wave ( mesh= small, beta =0, Lt =19) : # t h i s i s the h a l f cosine i n i t i a l wave 201 def I ( x, y ) : 202 return np. cos ( np. pi * x ) * ( x < 0. 5 ) def f ( x, y, t ) : 205 return def C( x, y ) : 208 return * ( x>=3) * ( x<=7) * ( y>=3) * ( y<=7) Lx, Ly, nx, ny, dt = eval ( mesh+" _mesh " ) ( ) 211 x, y,u = s o l v e r ( I, f, C, Lx, Ly, Lt, nx, ny, dt, beta ) 212 return ( x, y,u) def test_benchmark ( mesh= benchmark1, beta =0, nt =100) : 215 " " " Test code designed f o r benchmarking 216 instead of s p e c i f y i n g the f i n a l time, we s p e c i f y the 8

9 217 number of time points. And we turn o f f 218 graphics and s t o r i n g of r e s u l t s " " " def I ( x, y ) : 221 return np. cos ( np. pi * x ) * ( x < 0. 5 ) def f ( x, y, t ) : 224 return def C( x, y ) : 227 return * ( x>=3) * ( x<=7) * ( y>=3) * ( y<=7) Lx, Ly, nx, ny, dt = eval ( mesh+" _mesh " ) ( ) 230 Lt = dt * nt 231 s o l v e r ( I, f, C, Lx, Ly, Lt, nx, ny, dt, beta, benchmark=true ) def v i s u a l i z e ( x, y,u) : 234 " " " p l o t s o l u t i o n as an animated s u r f a c e p l o t " " " 235 x, y = x [1: 1], y [1: 1] 236 xd, yd = np. meshgrid ( x, y ) 237 xd = xd. T 238 yd = yd. T 239 f o r i in xrange ( len (U) 1) : 240 h = easyviz. s u r f c ( xd, yd,u[ i ][1: 1,1: 1], zmin = 1,zmax=1) 241 time. s leep (. 1 ) def makemovie ( x, y,u, filename= t e s t, tmpfolder=./tmp/ ) : 244 " " " s t o r e s o l u t i o n as a movie f i l e. Name of f i l e w i l l be 245 filename given as argument +. g i f e xtension " " " 246 xnew, ynew = np. meshgrid ( x, y ) 247 xnew = xnew. T 248 ynew = ynew. T 249 frame_counter = name = filename +. g i f 252 zmi= 1;zma=1 253 t r y : 254 os. mkdir ( tmpfolder ) 255 except : 256 p r i n t " Folder %s not empty! " % tmpfolder 9

10 257 e x i t ( ) f o r i in xrange ( len (U) ) : 260 tmp = _%04d. png % frame_counter 261 tmpname = tmpfolder + filename + tmp 262 h = easyviz. s u r f c ( xnew, ynew,u[ i ], zmin=zmi, zmax =zma, hardcopy=tmpname, view = ( 6 0, 1 0 ),show= F alse ) 263 p r i n t " frame number %d " % frame_counter 264 frame_counter += t m p f i l e s = tmpfolder + filename + _ *. png 267 movie ( tmpfiles, 268 encoder = convert, 269 fps = 10, # frames per second 270 o u t p u t _ f i l e = name ) 271 s h u t i l. rmtree ( tmpfolder ) i f name == main : 274 # p o s s i b l e meshes : small, medium, large, huge, benchmark[1 4] 275 x, y,u = test_wave ( mesh= l a r g e, beta =. 2, Lt =19) 276 # v i s u a l i z e ( x, y,u) 277 # makemovie ( x, y,u, filename =" l a r g e " ) 278 test_benchmark ( mesh= benchmark1, beta =0, nt =1000) 10