Physics 432, Physics of fluids: Assignment #1 Solutions

Transcription

1 Physics 432, Physics of fluids: Assignment #1 Solutions 1. This is an investigation of the two-dimensional draining bathtub problem described in lecture, where the tub has fluid level h, width 2L and drain width 2D. (a) Rewrite the order-of-magnitude prediction from lecture for the typical velocity in terms of the dimensionless variable u = u/u where U = gh, for the cases where Reynold s number R 1 and R 1. We want to test these predictions numerically in the following. In the inviscid limit, our prediction was u gh. This is the same as our unit of velocity U, so the dimensionless variable u is expected to be of order unity in this case. If viscosity is significant, then we expect u gh 2 /ν, which leads to u gh 3/2 /ν. This is the same as Reynold s number in this problem, so we predict u R. Hence we can write u R both for the cases where R 1 and when R 1. (b) Supposing that h = 15 cm, compute R for the fluids listed in Table 2.1 of the textbook, as well as for ketchup. gh 3/2 = cm 2 /s. Then R = , , , 101, 1.5 for the fluids in table 2.1, and for ketchup 0.3, taking ν = 6000 cm 2 /s. (c) Write a subroutine to compute the average value u y in the drain. Compute it for enough values of R < 1 to deduce the relation between u y and R. Does u y vary with R as predicted? Determine the constant of proportionality. subroutine average(uy,nx,ny,nd,u_avg) c returns average value of u_y on the lattice integer Nd,Nx,Ny,i,k real*8 uy(-nx:nx,0:ny), u_avg k=0 u_avg = 0 do i=-nd,nd u_avg = u_avg + uy(i,0) k=k+1 u_avg = u_avg/k Computing u y at R = 10 3, 10 2, 10 1 and 1, we find a linear result shown in fig. 1. It is fit by u y = R. Unfortunately it does not level off for large R as predicted. This is part of the more general problem that our program does not work at large R, as explored in the next part. (d) You will notice that strange results occur when R 1...

2 0.01 u y R Figure 1: Average value of u y at the drain, versus R. Show that with the proper rescalings, it can be written as t u + ( u ) u = p + R 1 2 u (1) Modify the program accordingly to incorporate the new version of the momentum equation (remember that that pressure discontinuity and its relaxation equation will also be changed). Show that unfortunately this doesn t fix the problem. We notice that at large R, there is an upward flow of fluid to the sides of the drain; see left graph of fig. 2. It is as though the fluid at the top wants to fall faster than it can get through the drain and so there is a backwash near the drain boundary. This doesn t seem physical. Figure 2: Left: spurious solution for u y at R = 40. Right: same, but in the modified program using eq. (1). Let u = u gh, x = hx, t = h/g t, p = ρgh p Then the equation takes the desired form. Thus we have to change the discontinuity in the pressure to p = 1 at the drain, instead of p = R as we had before, in subroutine init values. When we take the divergence of the momentum equation in these new variables, it gives 2 p = i u j j u i rather than 2 p = R i u j j u i as we had before, so we need to take this factor of R out of the relax subroutine. In subroutine evolve u, we need to change the lines

3 to read uxn(ix,iy) = ux(ix,iy) + dt*( - R*Dux - gpx + Lux) uyn(ix,iy) = uy(ix,iy) + dt*( - R*Duy - gpy + Luy) uxn(ix,iy) = ux(ix,iy) + dt*( - Dux - gpx + Lux/R) uyn(ix,iy) = uy(ix,iy) + dt*( - Duy - gpy + Luy/R) The result for R = 40 is shown in the right-hand side of fig. 2. In fact, our modifications make the problem less severe, but they don t fix it completely. (e) Assuming that h = 15 cm, L = 50 cm, D = 5 cm, and that ρ is the same as for water, are there any fluids in the list considered in (b) such that you can hope to apply this program? If so, estimate the time needed for the tub to drain for these fluids. We get reasonable results for R 1, so we could hope to apply this program for golden syrup and for ketchup. I find that u y = 0.1 for R = 1.5 and 0.02 for R = 0.3. We must multiply by gh to convert these to physical velocities. The flow through the drain, per unit length in the z direction, is φ = 2D u y, while the volume of water per length in the z direction is V = 2Lh. Then the time for the tub to drain is t = V φ = 2Lh 2D gh u y = { 12 s, R = s, R = 0.3 With the modified program from part (d) I find values that differ by 20% from these. (f) It is good to check whether the u = 0 condition is satisfied. The program comes with subroutines to compute and display u. Check it at the of an evolution. At first it might look small enough, but the question is, how small should it be? Find a criterion to determine whether the discrete approximation to u is really small compared to an appropriate quantity, and modify the routines so that it plots the ratio of u to this quantity. You should see that the result is not so impressive any more. This is why many computational fluid dynamics programs use conservative methods, that automatically enforce the divergence-free condition. A good criterion for whether the divergence is really small could be x u x + y u y x u x + y u y 1 (2) or something similar, that compares the sum of the terms to the typical value that either one is taking. To plot it, we should modify the routines divergence and display div so that they pass the individual terms approximating x u x and y u y rather than just the sum: subroutine divergence(ux,uy,nx,ny,dx,dy,dux,duy) c computes the divergence of velocity field integer Nx,Ny,ix,iy real*8 ux(-nx:nx,0:ny),uy(-nx:nx,0:ny),dx,dy, & dux(-nx+1:nx-1,1:ny-1),duy(-nx+1:nx-1,1:ny-1)

4 do ix=-nx+1,nx-1 do iy = 1,Ny-1 dux(ix,iy) = (ux(ix+1,iy)-ux(ix-1,iy))/(2*dx) duy(ix,iy) = (uy(ix,iy+1)-uy(ix,iy-1))/(2*dy) subroutine display_div(dux,duy,nx,ny) c to check the divergence of u, c creates data file for plotting by gnuplot. c Assumes preexisting files dp.gnu, ux,gnu, uy.gnu character*2 name integer Nx,Ny,ix,iy,sys real*8 dux(-nx+1:nx-1,1:ny-1),duy(-nx+1:nx-1,1:ny-1),div open(1,file= du.dat,status= unknown ) do ix = -Nx+1,Nx-1 do iy = 1,Ny-1 div = ( dux(ix,iy) + duy(ix,iy) ) & /( abs(dux(ix,iy))+abs(duy(ix,iy)) ) write(1,*) ix,iy,div write(1,*) close(1) sys = system( gnuplot du.gnu ) The result is shown for the case of R = 0.3 in fig. 3). It is not small as we would have hoped, showing the need for better algorithms such as finite-volume methods. Figure 3: Graph of (2) for the solution with R = 0.3 (g) In lecture it was noted that to get just the steady-state solution, it is possible to solve the whole system using relaxation. Make a new version of the relax subroutine so that the new values of u x and u y are given by the relaxation algorithm in the same loop

5 that updates the pressure. (The time loop in this case is no longer necessary and you can set Nt = 1 in the main program.) Check whether the result is the same as in the previous method. Note that this one is much more efficient. We add the equations for the Laplacian of u and solve them by over-relaxation simultaneously with p. subroutine relax2(ux,uy,p,nx,ny,dx,dy) c over-relaxation routine to solve Laplace equation for pressure c checks for convergence of average pressure to tolerance conv real*8 h,l,dx,dy,r,d,w/1.4d0/, S, ptot, lastptot integer Nx,Ny, Nitmax/ /, ix, iy, it, Nd real*8 ux(-nx:nx,0:ny),uy(-nx:nx,0:ny),p(-nx:nx,0:ny),pnew real*8 uxn,uyn,gpx,gpy,dux,duy real*8 conv/1.d-3/, C, dxdy,dydx common/rb/r common/ndb/nd ptot = 0.d0 dxdy = dx/dy dydx = dy/dx C = (dxdy + dydx)/2 do it = 1,Nitmax lastptot = ptot ptot = 0.d0 do ix = -Nx+1,Nx-1 do iy = 1,Ny-1 S = R*( (uy(ix+1,iy)-uy(ix-1,iy))*(ux(ix,iy+1)-ux(ix,iy-1)) & -(ux(ix+1,iy)-ux(ix-1,iy))*(uy(ix,iy+1)-uy(ix,iy-1)) )/8 pnew = ( dydx*(p(ix+1,iy) + p(ix-1,iy)) & + dxdy*(p(ix,iy+1) + p(ix,iy-1)) )/(4*C) - S/C gpx = (p(ix+1,iy)-p(ix-1,iy))/(2*dx) gpy = (p(ix,iy+1)-p(ix,iy-1))/(2*dy)! pressure gradient uxn = ( dydx*(ux(ix+1,iy) + ux(ix-1,iy)) & + dxdy*(ux(ix,iy+1) + ux(ix,iy-1)) )/(4*C) & - dx*dy*(gpx)/(4*c) uyn = ( dydx*(uy(ix+1,iy) + uy(ix-1,iy)) & + dxdy*(uy(ix,iy+1) + uy(ix,iy-1)) )/(4*C) & - dx*dy*(gpy)/(4*c) p(ix,iy) = w*pnew + (1-w)*p(ix,iy) ux(ix,iy) = w*uxn + (1-w)*ux(ix,iy) uy(ix,iy) = w*uyn + (1-w)*uy(ix,iy)

6 ptot = ptot +p(ix,iy) do ix=-nd,nd! maintain Neumann b.c. over drain ux(ix,0) = ux(ix,1) uy(ix,0) = uy(ix,1) if (it.gt.1.and.abs(1.d0 -ptot/lastptot).lt.conv) return write(6,*) convergence not achieved in relax stop The graphs of the solution look the same as for the previous algorithm, but careful comparison shows differences. When we redo part (c), we find that u y = R, which differs by 20% from our previous result. Notice that we have not tested convergence with respect to taking x, y 0. Experimentation shows that our lattice is still rather coarse and we should take it to be larger to get more accurate predictions. Doubling the number of lattice points in each direction causes the two methods to converge toward u y = 0.07 R. The time-depent method starts getting very slow for such large lattices. 2. Look at the toy model problem of eq. (8.10) of the textbook (also discussed in lecture). Write a program to solve this problem using the relaxation technique. (This is much simpler than the previous problem because there is only one dimension.) Compare how the algorithm works for large values of ɛ relative to small ones. (Do not start with a guess that is very good.) To graph your results you can use a gnuplot command similar to those in the previous problem, but replace the splot command ( splot stands for surface plot) with the command plot filename with lines. The filename (referring to the file generated by your fortran program) must be within single quotes. You can plot multiple curves on a single graph by the command plot filename1 w lines, filename2 w lines,... Here is my code: integer M,Nd,i,j,k, Niter,sys,system, Nskip/1000/,M1 parameter (M=1000,Niter=20000,M1=M+1) real*8 u(0:m1),y(0:m1),eps,a,unew,w/1.4/ a = 1.d0/M1 eps = 1.d-2 c initial guess do i = 0,M1 y(i) = i*a u(i) = 1.d0-y(i)

7 c c & boundary conditions u(0) = 0.d0 u(m1) = 2.d0 iterations do k=0, Niter open(1,file= u1d.dat,status= unknown ) do j=0,m1 if (j.ne.0.and.j.ne.m1) then unew = 0.5d0*(u(j+1) + u(j-1)) + a/eps*(u(j+1) - u(j-1))/4 - a**2/(2*eps) u(j) = w*unew + (1-w)*u(j) if if (Nskip*(k/Nskip).eq.k) write(1,*) u(j),y(j) write(1,*) close(1) sys = system( xmgrace u1d.dat ) open(1,file= exact.dat,status= unknown ) do i=0,m1 write(1,*) y(i) + (1-exp(-y(i)/eps))/(1-exp(-1/eps)), y(i) close(1) Notice I am using over-relaxation, which one can verify does help to speed up the convergence significantly. I used a different plotting program, xmgrace, which I prefer for 1D plots. The results are shown for ɛ = 0.01 and ɛ = 1 in fig. 4. Here I deliberately chose a very bad initial guess to make the algorithm work hard, since we wanted to test it. Some results of intermediate iterations are shown to indicate the speed of convergence. I was surprised by the fact that convergence is actually much faster for smaller rather than larger ɛ!. This must have something to do with the fact that the driving force which is causing changes in the solution between iterations is small when ɛ As an example of a situation that could arise in a finite-volume numerical approach, consider the 2D control volume shown in fig. 5. Let the coordinates be (s, t) such that the lower right corner of the volume is at the origin, as shown, and the nodes are at halfinteger values. Show that inside the square with the vertices hosting velocities u 1,..., u 4, linear interpolation gives u(s, t) = ( 1 2 s)( 1 2 t) u 1 + (s )( 1 2 t) u 2 + (s )(t ) u 3 + ( 1 2 s)( t) u 4 Using this, evaluate the flux of fluid through the surface e 1. Once you have this result, it is easy to write down the net flux through the remaining surfaces e 2, w 1, w 2, and also through the top and bottom surfaces. What constraint does fluid conservation in the control volume place on the velocities at the nodes? A simpler interpolation scheme is often used, in which for a given face, one only interpolates in the direction perpicular to that face, and ignores all but the closest two nodes. How does your result look in

8 1 ε = 0.01 initial guess 1 ε = 1 initial guess y exact solution y ,000 40,000 exact solution u u Figure 4: Relaxation solutions for the 1D toy problem with ɛ = 0.01 (left) and ɛ = 1 (right). Intermediate results are labeled by the iteration number; they converge to the exact result. that case? (A nice feature of this method is that it also works for highly irregular and nonuniform lattices, where the corresponding results would be less trivial.) u 6 u 7 u 8 w 2 e 2 u5 w 1 u 4 e 1 u 3 (s,t)=(0,0) u 0 u 1 u 2 Figure 5: A control volume in a finite-volume numerical setup. To prove the formula, simply evaluate it at the points (s, t) = (± 1, ± 1 ), where the 2 2 variables u 1,..., u 4 live. It is easy to see that it gives the right values at those points. Thus the coefficients of each u i in the interpolation formula are correctly determined. For the surface e 1, the flux (to the right) is given by φ e1 = 1 2 Then by geometric comparison, 0 u x (0, t)dt = 1 16 (ux 1 + u x 2) (ux 3 + u x 4) φ e2 = 1 16 (ux 7 + u x 8) (ux 3 + u x 4) φ w1 = 1 16 (ux 0 + u x 1) (ux 4 + u x 5) φ w2 = 1 16 (ux 6 + u x 7) (ux 4 + u x 5) The total flux out of the control volume through the the vertical walls is φ e1 + φ e2 φ w1 φ w2 = 3 8 (ux 3 u x 5) (ux 2 u x 0 + u x 8 u x 6)

9 Then it is easy to see that the corresponding expression for the outward flux through the horizontal walls is φ n φ s = 3 8 (uy 7 u y 1) (uy 6 u y 0 + u y 8 u y 2) Our contraint is that the sum of these two quantities vanishes. In the simpler interpolation scheme, we have φ e = 1 2 (ux 3 + u x 4), φ w = 1 2 (ux 4 + u x 5), φ n = 1 2 (uy 4 + u y 7), φ s = 1 2 (uy 1 + u y 4). Then the constraint becomes u x 3 u x 5 + u y 7 u y 4 = 0 which you recognize as a discrete approximation to the vanishing of the divergence.