Jeffrey E. Dahan
MEAE4960-h01
Term Project:
Analysis of the Flat Plate Boundary Layer
December 11, 1999
Rensselaer Polytechnic Institute at
Hartford
Notation Listing
u
v
U



f
F
a

a,b
h
N
t
j
m
w
k
fluid velocity in x direction
fluid velocity in y direction
full potential of fluid velocity in x direction
boundary layer thickness
non-dimensional distance
stream function
f()
F()
constant of homology
initial condition
endpoints
iteration step size
number of subintervals
independent variable in Runge-Kutta Algorithm
number of first order differential equations
maximum number of j
output approximations
numerical constituents of w
Table of Contents
Background ........................................................ 1
Theoretical Analysis .......................................... 2
The Runge-Kutta Method .................................. 3
Utilizing the Method .......................................... 5
Results Analysis ................................................. 7
Appendix A: Program Coding ........................... 8
Appendix B: Program Output.......................... 11
Appendix C: Blasius Data Table ..................... 13
Appendix D: Graphs ........................................ 14
Slides ................................................................ 16
References ........................................................ 21
Numerical Analysis For Engineering—Fall 1999
Term Project
Background
One of the most fundamental applications in fluid dynamics is the effect of the laminar
boundary layer over a flat plate. In 1908, H. Blasius, a student of Prandtl, was finally able to
obtain the solution to steady state, two-dimensional, zero pressure gradient flow over a flat plate
in the laminar flow regime. A brief synopsis of how Blasius obtained his solution is described
below, and may be found in most fluid dynamics textbooks. For these conditions, the governing
equations of motion for continuity and momentum respectively become:
u v

0
x y
[1]
u
u
 2u
u
v
v 2
x
y
y
[2]
With these given equations, upper and lower boundary conditions may be implemented. For flow
at zero distance from the wall, there is no fluidic motion. As the flow approaches and infinite
distance from the wall, the boundary effects approach zero, and the flow may achieve its full
potential U. Therefore, the boundary conditions may be written as:
at y  0, u  0
at y  , u  U
[3]
Now, introducing the stream function , satisfying equation 1, the velocity in the x and y
directions may be written as:
u

y
and v  

x
[4]
The distance moving away from the wall may be nondimensionalized using the solution to the
Navier Stokes equation and the boundary layer thickness  by:

y

y
U
x
[5]
Next, equation 4 is substituted into equation 2, yielding an equation only dependent upon :
f   

xU
[6]
Now, the component velocities in equation 4 are differentiated and substituted back into equation
2 to obtain the relation with f as the dependent variable, and  as the independent variable. This
relation is defined as the Blasius Equation:
2
d3 f
d2 f

f
0
d 3
d 2
1
[7]
Numerical Analysis For Engineering—Fall 1999
Term Project
with corresponding boundary conditions of:
at   0,
f  0,
at   ,
df
0
d
[8]
df
1
d
Theoretical Analysis
Equation 7 is a non-linear third order differential equation, transformed from two second
order partial differential equations (1 and 2) describing boundary layer growth over a flat plate.
Once Blasius obtained the third order relation, he encountered the problem of only having initial
conditions at the boundary for f and f’, and at infinity for f’. It was not until Howarth utilized
numerical methods as a means to solve the Blasius relation that more precise data could be
obtained.
Now, using Numerical Analysis, the Blasius relation using the Runge-Kutta Method for
systems of differential equations will be solved. First, three first order differential equations will
be used to describe the Blasius equation:
u1  f
u2  f '
u3  f ' '
u1 '  f '  u2
[9]
u 2 '  f ' '  u3
[10]
 u1u3
u3 '  f ' ' ' 
2
u4  f ' ' '
[11]
These three primed first order differential equations are to be entered into the Runge-Kutta
Method (Algorithm 5.7) in Maple V. However, this algorithm requires three boundary conditions
at one point, and there are only two conditions at  = 0 and one condition at    available.
Therefore, further analysis is necessary to solve the Blasius equation.
First, the Blasius relation (equation 7) is rewritten for convenience as:
[12]
2 f ' ' ' ff ' '  0
and a new relation F() is introduced. Now, f = aF(a) may be accurate only if F() is a
possible solution to equation 12, so that now 2F’’’+FF’’ = 0. In this case, a is defined as an
arbitrary constant of homology. It is simply a multiplier or constant which relates f to F by:
lim f '    a 2 lim F ' a   a 2 lim F ' a 
 
 
 
[13]
It is a known initial condition that as  , f’() = 1 Therefore, 1  a 2 lim F '   can be
 
rewritten as:
a   lim F '  
  


1
2
[14]
For the situation for 2F’’’+FF’’ = 0, the initial conditions are F(0) = 0, and F’(0) = 0. The third
2
Numerical Analysis For Engineering—Fall 1999
Term Project
initial condition at 0 is found by stating F’’(0) = 1. Also, taking another derivative of equation 13
will yield f’’(0) = a3F’’(0) = a3. Finally, equation 14 is substituted in to yield what will be the
third initial condition at  = 0 for 2f’’’+ff’’ = 0:
f ' ' 0  F '  

3
2
[15]
The Runge-Kutta Method is actually going to be used twice in order to obtain the
necessary results. The first run will utilize relations based on F since there are three known initial
conditions at  = 0. From that output, the third initial condition for the f relation at  = 0 is
obtained via equation 15.
The Runge-Kutta Method
The Runge-Kutta Method has been selected as a means to solve this differential equation
since it has high-order local truncation error for accuracy and error control. In addition, this
method makes it possible to avoid calculating the derivatives of f(t, y). In order to make use of
the Runge-Kutta Method, the higher order equations given by Blasius must be transformed into a
set of first order differential equations (equations 9, 10, 11). In the case of the Blasius equation,
there exist a fourth order equation which must be reworked to satisfy the first order initial value
condition given by:
du1
dt
du 2
dt
du3
dt
du 4
dt
 f1 t , u1 , u 2 , u3 , u 4 ,
 f 2 t , u1 , u 2 , u3 , u 4 ,
where for a  t  b,
u1 a   1 ,
 f 3 t , u1 , u 2 , u3 , u 4 ,
u3 a    3 ,
 f 4 t , u1 , u 2 , u3 , u 4 ,
u 2 a    2 ,
u 4 a    4
Ultimately, there should be just as many initial conditions to satisfy the same amount of first
order differential equations. In the case of Blasius, there are three first order equations, and only
two initial values at zero. However, there exists a value at infinity, which must be transformed
into a corresponding value at zero in order to solve the system (see explanation above).
The Runge-Kutta Method for Systems of Differential Equations Algorithm is carried out
by the following progression (as stated in Numerical Analysis textbook). First, the inputs a t b
are entered, with m equations — uj’ = fj(t, u1, u2,…, um), m approximations — uj(a) = j, and N
subintervals. The Algorithm will then output the approximations wj for each uj(t) for N + 1
values of t. The Runge-Kutta Method is coded via the following:
Step 1
Set h = (b - a)/N;
t = a.
 The step value h is defined by separating the two endpoints a and b by N
subintervals.
 t (independent variable) is initially defined as the first endpoint.
3
Numerical Analysis For Engineering—Fall 1999
Term Project
Step 2
For j = 1, 2,…, m set wj = j.
 j is defined as the number of first order differential equations.
 wj is the approximation set equal to each of the initial conditions j at the first
endpoint a.
Step 3
OUTPUT (t, w1, w2,…,wm).
 The required output at the first endpoint a is listed, based on the initial condition
values.
Step 4
For j = 1, 2,…, N do steps 5—11.
 The iterative looping is set by j iterations, involving carrying out steps 5—11.
Step 5
For j = 1, 2,…, m set
Step 6
For j = 1, 2,…, m set
k1, j  hf j t , w1 , w2 ,..., wm .
1
1
1
 h

k 2, j  hf j  t  , w1  k1,1 , w2  k1, 2 ,..., wm  k1,m .
2
2
2
 2

Step 7
For j = 1, 2,…, m set
1
1
1
 h

k3, j  hf j  t  , w1  k 2,1 , w2  k 2, 2 ,..., wm  k 2,m .
2
2
2
 2

Step 8
For j = 1, 2,…, m set
1
1
1
 h

k 4, j  hf j  t  , w1  k3,1 , w2  k3, 2 ,..., wm  k3,m .
2
2
2
 2

Step 9
For j = 1, 2,…, m set
wj  wj 

k
1, j
 2k 2, j  2k3, j  k 4, j 
6
The approximations wj are stepped according the obtained k values.
Step 10 Set t = a + ih
 t is stepped from the endpoint a by the step value h, i times.
Step 11 OUTPUT (t, w1, w2,…,wm).
 The obtained data is outputted until and the loop will continue to
completion m.
Step 12 STOP
4
Numerical Analysis For Engineering—Fall 1999
Term Project
Utilizing the Method
As described earlier, the Blasius equation is a fourth order differential equation, which
can be transformed into three first order differential equations. But, three initial conditions must
be provided at the endpoint a, which in this case is 0. Only two initial conditions are available.
The third must be obtained by knowing its value at the endpoint b. The three initial conditions
for F are known at 0. And by equation 15, the third initial condition for f can be obtained from
the output of F. Therefore, the Runge-Kutta Method will be utilized twice in Maple V, as well as
Excel.
The Maple inputs and code are listed below. The first run will use equations 9, 10, and
11, with initial conditions for the equation 2F’’’+FF’’ = 0: F(0) = 0, F’(0) = 0 and F’’(0) = 1. (I
have modified the Maple code to output the results to 10 decimal places). The inputs for maple
use y in place of u.
> alg057();
This is the Runge-Kutta Method for Systems of m equations
Input the number of equations
> 3
Input the function F[1](t,y1 ... y3) in terms of t and y1 ... y3
> y2
For example: y1-t^2+1
Input the function F[2](t,y1 ... y3) in terms of t and y1 ... y3
> y3
For example: y1-t^2+1
Input the function F[3](t,y1 ... y3) in terms of t and y1 ... y3
> -1*y1*y3/2
For example: y1-t^2+1
Input left and right endpoints separated by blank
> 0 8.5
Input the initial condition alpha[1]
> 0
Input the initial condition alpha[2]
> 0
Input the initial condition alpha[3]
> 1
Input a positive integer for the number of subintervals
> 15
Choice of output method:
1. Output to screen
2. Output to text file
Please enter 1 or 2
> 1
RUNGE-KUTTA METHOD FOR SYSTEMS OF DIFFERENTIAL EQUATIONS
T
7.500
7.750
8.000
8.250
8.500
W1
13.1555886800
13.6769399000
14.1982911200
14.7196423400
15.2409935600
W2
2.0854048370
2.0854048370
2.0854048370
2.0854048370
2.0854048370
W3
.0000000025
.0000000007
.0000000002
.0000000001
.0000000000
5
Numerical Analysis For Engineering—Fall 1999
Term Project
As can be seen, W3 (F’’) approaches 0 for a value of t at 8.5. Now that F’(8.5) has been
obtained, it is taken the –3/2 power in order to fix third initial condition at zero (equation 15).
Therefore, f’’(0) = 2.0854048370^(-3/2) = .3320573386. Now, the second run through Maple
may be made using the Runge-Kutta Method:
> alg057();
This is the Runge-Kutta Method for Systems of m equations
Input the number of equations
> 3
Input the function F[1](t,y1 ... y3) in terms of t and y1 ... y3
> y2
For example: y1-t^2+1
Input the function F[2](t,y1 ... y3) in terms of t and y1 ... y3
> y3
For example: y1-t^2+1
Input the function F[3](t,y1 ... y3) in terms of t and y1 ... y3
> -1*y1*y3/2
For example: y1-t^2+1
Input left and right endpoints separated by blank
> 0 12
Input the initial condition alpha[1]
> 0
Input the initial condition alpha[2]
> 0
Input the initial condition alpha[3]
> 0.3320573386
Input a positive integer for the number of subintervals
> 48
Choice of output method:
1. Output to screen
2. Output to text file
Please enter 1 or 2
> 1
RUNGE-KUTTA METHOD FOR SYSTEMS OF DIFFERENTIAL EQUATIONS
T
10.500
10.750
11.000
11.250
W1
8.7792118340
9.0292116980
9.2792115620
9.5292114260
W2
.9999994497
.9999994498
.9999994498
.9999994498
W3
.0000000012
.0000000004
.0000000001
.0000000000
As can be seen in the excerpt of the Maple output, f’ approaches 1 and f’’ reaches zero at an
accuracy of ten decimal places. The complete output is listed in the Appendix.
Next, using the coding as described by the Runge-Kutta explanation, an Excel
Spreadsheet was formed, also yielding results to ten decimal places. Again, two runs were
necessary: one run to determine the initial condition; and the second run to obtain the Blasius
output data for comparison. For both scenarios, a small step size h = 0.05 was used in order to
better pinpoint the necessary convergence. The Excel inputs and output excerpts are listed for the
first run below:
6
Numerical Analysis For Engineering—Fall 1999
t
7.85
7.90
7.95
8.00
F
13.8854818703
13.9897523286
14.0940227870
14.1982932453
F'
2.0854091666
2.0854091666
2.0854091666
2.0854091666
Term Project
F'’
0.0000000001
0.0000000000
0.0000000000
0.0000000000
f'’(0) = F’()
0.3320573386
0.3320573386
0.3320573386
0.3320573386
F’’ converges to 0 at ten decimal places. Therefore, the initial condition f’’ can be obtained, and
plugged into the next Excel run:
t
9.70
9.75
9.80
9.85
9.90
f
7.9792123838
8.0292123837
8.0792123836
8.1292123836
8.1792123836
f'
0.9999999967
0.9999999980
0.9999999990
0.9999999999
1.0000000006
f'’
0.0000000286
0.0000000234
0.0000000191
0.0000000156
0.0000000127
f' converges to its upper limit of 1.0 at approximately t = 9.86. The complete Excel output
resides in the Appendix.
Results Analysis
The Maple V output differs from that of the Excel output. For the preliminary run for
each, F’’(0) was successfully obtained. However, this occurred in Maple at t = 8.5 while in Excel
at t = 7.90. The second run, which obtained the Blasius output, also yielded discrepancies. In
Maple, f’ converges to 0.9999994498 at t = 10.75. All values beyond 10.75 still produce f’ =
0.9999994498. This is a strange anomaly, and after looking into the matter, I was not able to
determine the cause. The Excel output, on the other hand, has a convergence of f’  1.0 at
roughly t = 9.86.
An accuracy of ten decimal places was chosen since most fluid textbooks only list the
Blasius output to four or five decimal places. However, if the desired accuracy is reduced to four
decimal places, both outputs correspond precisely to the table listed in Introduction to Fluid
Mechanics (see references). These differences across different mathematics programs may be the
reason why an accuracy of four or five decimal places is selected. The original table for the
fluids textbook may be found in the Appendix.
Graphs of 2f’’’+ff’’=0 and 2F’’’+FF’’=0 are plotted using the corresponding Maple
outputs. As previously explained, f and F differ by a constant a, which is reinforced by the
similarity of the graphs. For the same value of , the stream function axis varies only by constant
a since the contours are identical. These graphs are located in Appendix D.
7
Numerical Analysis For Engineering—Fall 1999
Term Project
Appendix A: Program Coding
Maple V: Algorithm 5.7—Runge-Kutta Method
> restart;
> # RUNGE-KUTTA FOR SYSTEMS OF DIFFERENTIAL EQUATIONS ALGORITHM 5.7
> #
> # TO APPROXIMATE THE SOLUTION OF THE MTH-ORDER SYSTEM OF FIRST> # ORDER INITIAL-VALUE PROBLEMS
> #
UJ' = FJ( T, U1, U2, ..., UM ), J = 1, 2, ..., M
> #
A <= T <= B, UJ(A) = ALPHAJ, J = 1, 2, ..., M
> # AT (N+1) EQUALLY SPACED NUMBERS IN THE INTERVAL [A,B].
> #
> # INPUT:
ENDPOINTS A,B; NUMBER OF EQUATIONS M; INITIAL
> #
CONDITIONS ALPHA1, ..., ALPHAM; INTEGER N.
> #
> # OUTPUT: APPROXIMATION WJ TO UJ(T) AT THE (N+1) VALUES OF T.
> alg057 := proc() local OK, M, I, F, A, B, ALPHA, N, FLAG, NAME, OUP,
H, T, J, W, L, K;
> printf(`This is the Runge-Kutta Method for Systems of m
equations\n`);
> OK := FALSE;
> while OK = FALSE do
> printf(`Input the number of equations\n`);
> M := scanf(`%d`)[1];
> if M <= 0 then
> printf(`Number must be a positive integer\n`);
> else
> OK := TRUE;
> fi;
> od;
> for I from 1 to M do
> printf(`Input the function F[%d](t,y1 ... y%d) in terms of t and y1
... y%d\n`, I,M,M);
> printf(`For example: y1-t^2+1`);
> F[I] := scanf(`%a`)[1];
> F[I] := unapply(F[I],t,evaln(y.(1..M)));
> od;
> OK := FALSE;
> while OK = FALSE do
> printf(`Input left and right endpoints separated by blank\n`);
> A := scanf(`%f`)[1];
> B := scanf(`%f`)[1];
> if A >= B then
> printf(`Left endpoint must be less than right endpoint\n`);
> else
> OK := TRUE;
> fi;
> od;
> for I from 1 to M do
> printf(`Input the initial condition alpha[%d]\n`, I);
> ALPHA[I] := scanf(`%f`)[1];
> od;
> OK := FALSE;
> while OK = FALSE do
> printf(`Input a positive integer for the number of subintervals\n`);
8
Numerical Analysis For Engineering—Fall 1999
Term Project
> N := scanf(`%d`)[1];
> if N <= 0 then
> printf(`Number must be a positive integer\n`);
> else
> OK := TRUE;
> fi;
> od;
> if OK = TRUE then
> printf(`Choice of output method:\n`);
> printf(`1. Output to screen\n`);
> printf(`2. Output to text file\n`);
> printf(`Please enter 1 or 2\n`);
> FLAG := scanf(`%d`)[1];
> if FLAG = 2 then
> printf(`Input the file name in the form - drive:\\name.ext\n`);
> printf(`For example
A:\\OUTPUT.DTA\n`);
> NAME := scanf(`%s`)[1];
> OUP := fopen(NAME,WRITE,TEXT);
> else
> OUP := default;
> fi;
> fprintf(OUP, `RUNGE-KUTTA METHOD FOR SYSTEMS OF DIFFERENTIAL
EQUATIONS\n\n`);
> fprintf(OUP, `
T`);
> for I from 1 to M do
> fprintf(OUP, `
W%d`, I);
> od;
STEP 1
> H := (B-A)/N;
> T := A;
STEP 2
> for J from 1 to M do
> W[J] := ALPHA[J];
> od;
STEP 3
> fprintf(OUP, `\n%5.3f`, T);
> for I from 1 to M do
> fprintf(OUP, ` %11.10f`, W[I]);
> od;
> fprintf(OUP, `\n`);
STEP 4
> for L from 1 to N do
STEP 5
> for J from 1 to M do
> K[1,J] := H*F[J](T,seq(W[i],i=1..M));
> od;
STEP 6
> for J from 1 to M do
> K[2,J] := H*F[J](T+H/2.0,seq(W[i]+K[1,i]/2.0,i=1..M));
> od;
STEP 7
> for J from 1 to M do
> K[3,J] := H*F[J](T+H/2.0,seq(W[i]+K[2,i]/2.0,i=1..M));
> od;
STEP 8
> for J from 1 to M do
9
Numerical Analysis For Engineering—Fall 1999
> K[4,J] := H*F[J](T+H,seq(W[i]+K[3,i],i=1..M));
> od;
STEP 9
> for J from 1 to M do
> W[J] := W[J]+(K[1,J]+2.0*K[2,J]+2.0*K[3,J]+K[4,J])/6.0;
> od;
STEP 10
> T := A+L*H;
STEP 11
> fprintf(OUP, `%5.3f`, T);
> for I from 1 to M do
> fprintf(OUP, ` %11.10f`, W[I]);
> od;
> fprintf(OUP, `\n`);
> od;
STEP 12
> if OUP <> default then
> fclose(OUP):
> printf(`Output file %s created sucessfully`,NAME);
> fi;
> fi;
> RETURN(0);
> end;
Excel Coding—Runge-Kutta Method
***See blas1.xls and blas2.xls***
10
Term Project
Numerical Analysis For Engineering—Fall 1999
Term Project
Appendix B: Program Output
Maple V: Algorithm 5.7—Runge-Kutta Method
1st run to determine f’’(0) from F’()
T
0.000
.250
.500
.750
1.000
1.250
1.500
1.750
2.000
2.250
2.500
2.750
3.000
3.250
3.500
3.750
4.000
4.250
4.500
4.750
5.000
5.250
5.500
5.750
6.000
6.250
6.500
6.750
7.000
7.250
7.500
7.750
8.000
8.250
8.500
W1
0.0000000000
.0312500000
.1248781349
.2802798174
.4959152818
.7689446291
1.0950292500
1.4683723480
1.8820284900
2.3284407830
2.8000919880
3.2901180080
3.7927498560
4.3035150990
4.8192093390
5.3377069770
5.8577004060
6.3784424630
6.8995360210
7.4207844670
7.9420970030
8.4634344660
8.9847810530
9.5061307900
10.0274815500
10.5488326400
11.0701838200
11.5915350200
12.1128862400
12.6342374600
13.1555886800
13.6769399000
14.1982911200
14.7196423400
15.2409935600
W2
0.0000000000
.2499186199
.4987018291
.7434790715
.9796967328
1.2016184740
1.4031520920
1.5789065230
1.7252384100
1.8409771290
1.9275855190
1.9887103820
2.0293039250
2.0546318280
2.0694646570
2.0776137740
2.0818132300
2.0838433990
2.0847644930
2.0851569620
2.0853141680
2.0853734460
2.0853945280
2.0854016160
2.0854038760
2.0854045630
2.0854047620
2.0854048170
2.0854048320
2.0854048360
2.0854048370
2.0854048370
2.0854048370
2.0854048370
2.0854048370
W3
1.0000000000
.9986991882
.9896437018
.9655157619
.9203634559
.8509020082
.7577309984
.6458580193
.5240408302
.4029181684
.2924997843
.1999513608
.1284703668
.0774905465
.0438516352
.0232768010
.0115909624
.0054170690
.0023778234
.0009813720
.0003813898
.0001398425
.0000485012
.0000159632
.0000050062
.0000015035
.0000004350
.0000001221
.0000000335
.0000000091
.0000000025
.0000000007
.0000000002
.0000000001
.0000000000
Excel Output—Runge-Kutta Method
***See blas1.xls and blas2.xls***
11
Numerical Analysis For Engineering—Fall 1999
Term Project
Maple V: Algorithm 5.7—Runge-Kutta Method
2nd run to obtain Blasius output
T
W1
W2
0.000 0.0000000000 0.000000000
.250
.0103767918 .0830053615
.500
.0414937151 .1658852424
.750
.0932836832 .2483187896
1.000
.1655734687 .3297799174
1.250
.2580345680 .4095570450
1.500
.3701409392 .4867889189
1.750
.5011379638 .5605186814
2.000
.6500271209 .6297649696
2.250
.8155700549 .6936047326
2.500
.9963138834 .7512585319
2.750 1.1906369160 .8021664948
3.000 1.3968109260 .8460429130
3.250 1.6130733810 .8829002322
3.500 1.8377013710 .9130384553
3.750 2.0690787560 .9370024781
4.000 2.3057494770 .9555157816
4.250 2.5464525770 .9694026040
4.500 2.7901376760 .9795113610
4.750 3.0359625960 .9866498651
5.000 3.2832769870 .9915388259
5.250 3.5315968610 .9947855676
5.500 3.7805749020 .9968760704
5.750 4.0299706570 .9981810289
6.000 4.2796234380 .9989707475
6.250 4.5294295470 .9994340627
6.500 4.7793243320 .9996975848
6.750 5.0292688390 .9998428997
7.000 5.2792403770 .9999205922
7.250 5.5292261630 .9999608688
7.500 5.7792192310 .9999811164
7.750 6.0292159070 .9999909879
8.000 6.2792143180 .9999956560
8.250 6.5292135390 .9999977974
8.500 6.7792131260 .9999987506
8.750 7.0292128740 .9999991623
9.000 7.2792126900 .9999993349
9.250 7.5292125330 .9999994053
9.500 7.7792123890 .9999994331
9.750 8.0292122490 .9999994437
10.000 8.2792121100 .9999994478
10.250 8.5292119720 .9999994493
10.500 8.7792118340 .9999994497
10.750 9.0292116980 .9999994498
11.000 9.2792115620 .9999994498
11.250 9.5292114260 .9999994498
11.500 9.7792112900 .9999994498
11.750 10.0292111500 .9999994498
12.000 10.2792110100 .9999994498
12
W3
.3320573386
.3319138148
.3309109915
.3282057746
.3230072258
.3146331616
.3025807223
.2865995080
.2667519050
.2434438396
.2174121008
.1896620894
.1613610767
.1337036378
.1077739363
.0844309099
.0642364563
.0474355287
.0339845322
.0236145668
.0159113636
.0103944994
.0065831407
.0040418406
.0024056849
.0013880966
.0007764955
.0004211349
.0002214621
.0001129312
.0000558488
.0000267891
.0000124657
.0000056283
.0000024662
.0000010490
.0000004333
.0000001738
.0000000678
.0000000257
.0000000095
.0000000034
.0000000012
.0000000004
.0000000001
.0000000000
.0000000000
.0000000000
.0000000000
Numerical Analysis For Engineering—Fall 1999
Term Project
Appendix C: Blasius Data Table
Table 9.1 p.418—Introduction to Fluid Mechanics (Fox, McDonald)
Table 9.1

0.0
0.5
1.0
1.5
2.0
2.5
3.0
3.5
4.0
4.5
5.0
5.5
6.0
6.5
7.0
7.5
8.0
The Function f() for the Laminar Boundary
Layer along a Flat Plate at Zero Incidence
f
0.0000
0.0415
0.1656
0.3702
0.6501
0.9964
1.3969
1.8377
2.3058
2.7902
3.2833
3.7806
4.2797
4.7794
5.2793
5.7793
6.2792
f'
0.0000
0.1659
0.3298
0.4868
0.6298
0.7512
0.8460
0.9130
0.9555
0.9795
0.9915
0.9968
0.9989
0.9997
0.9999
1.0000
1.0000
13
f'’
0.3321
0.3309
0.3230
0.3026
0.2668
0.2174
0.1614
0.1078
0.0643
0.0341
0.0160
0.0067
0.0025
0.0008
0.0003
0.0001
0.0000
Numerical Analysis For Engineering—Fall 1999
Term Project
Non Dimensional Stream Functions vs Non Dimensional Distance for 2f'''+ff''=0
7.0
6.0
Stream Functions
5.0
4.0
3.0
2.0
1.0
0.0
0.0
1.0
2.0
3.0
4.0
5.0

f
f'
14
f''
6.0
7.0
8.0
Numerical Analysis For Engineering—Fall 1999
Term Project
Non Dimensional Stream Functions vs Non Dimensional Distance for 2F'''+FF''=0
16.0
14.0
Stream Functions
12.0
10.0
8.0
6.0
4.0
2.0
0.0
0.0
1.0
2.0
3.0
4.0
5.0

F
F'
15
F''
6.0
7.0
8.0
Numerical Analysis For Engineering—Fall 1999
Term Project
Slides—Flat Plate Boundary Layer
Blasius Derivation
Continuity, Momentum:
Blasius Equation:
u v

0
x y
2 f ' ' ' ff ' '  0
u
u
 2u
v
v 2
x
y
y
u
2F ' ' 'FF ' '  0
Constant of Homology:
Boundary Conditions:
lim f '    a 2 lim F ' a   a 2 lim F ' a 
at y  0, u  0
at y  , u  U
 

y
y
y


and v  
U
x
 
1  a 2 lim F '  
 
Stream Function:
u
 

x
f   

1
2

3
2
a   lim F '  
  


xU
f ' ' 0  F '  
First Order Differential Equations:
Blasius Equation:
2
u1  f
d3 f
d2 f

f
0
d 3
d 2
u2  f '
u3  f ' '
Boundary Conditions:
at   0,
f  0,
at   ,
u4  f ' ' '
df
0
d
df
1
d
16
u1 '  f '  u2
u 2 '  f ' '  u3
u3 '  f ' ' ' 
 u1u3
2
Numerical Analysis For Engineering—Fall 1999
Term Project
Algorithm:
Runge-Kutta Method:
du1
dt
du 2
dt
du3
dt
du 4
dt
 f1 t , u1 , u 2 , u3 , u 4 ,
 f 2 t , u1 , u 2 , u3 , u 4 ,
where for a  t  b,
u1 a   1 ,
 f 3 t , u1 , u 2 , u3 , u 4 ,
u3 a    3 ,
 f 4 t , u1 , u 2 , u3 , u 4 ,
Step 1 Set h = (b - a)/N;
t = a.
Step 2 For j = 1, 2,…, m set wj = j.
Step 3 OUTPUT (t, w1, w2,…,wm).
Step 4 For j = 1, 2,…, N do following:
For j = 1, 2,…, m set:
k1, j  hf j t , w1 , w2 ,..., wm .
1
1
1
 h

k 2, j  hf j  t  , w1  k1,1 , w2  k1, 2 ,..., wm  k1,m .
2
2
2
 2

1
1
1
 h

k3, j  hf j  t  , w1  k 2,1 , w2  k 2, 2 ,..., wm  k 2,m .
2
2
2
 2

u 2 a    2 ,
u 4 a    4
1
1
1
 h

k 4, j  hf j  t  , w1  k3,1 , w2  k3, 2 ,..., wm  k3,m .
2
2
2
 2

k  2k2, j  2k3, j  k4, j 
w j  w j  1, j
6
Step 12
17
Step 10 Set t = a + ih
Step 11 OUTPUT (t, w1, w2,…,wm).
STOP
Numerical Analysis For Engineering—Fall 1999
Term Project
2F ' ' 'FF ' '  0
2 f ' ' ' ff ' '  0
> alg057();
This is the Runge-Kutta Method for Systems of m equations
Input the number of equations
> 3
Input the function F[1](t,y1 ... y3) in terms of t and y1
... y3
> y2
For example: y1-t^2+1
Input the function F[2](t,y1 ... y3) in terms of t and y1
... y3
> y3
For example: y1-t^2+1
Input the function F[3](t,y1 ... y3) in terms of t and y1
... y3
> -1*y1*y3/2
For example: y1-t^2+1
Input left and right endpoints separated by blank
> 0 8.5
Input the initial condition alpha[1]
> 0
Input the initial condition alpha[2]
> 0
Input the initial condition alpha[3]
> 1
Input a positive integer for the number of subintervals
> 15
Choice of output method:
1. Output to screen
2. Output to text file
Please enter 1 or 2
> 1
RUNGE-KUTTA METHOD FOR SYS. OF DIFFERENTIAL EQUATIONS
T
W1
W2
W3
7.500 13.1555886800 2.0854048370 .0000000025
7.750 13.6769399000 2.0854048370 .0000000007
8.000 14.1982911200 2.0854048370 .0000000002
8.250 14.7196423400 2.0854048370 .0000000001
8.500 15.2409935600 2.0854048370 .0000000000
18
> alg057();
This is the Runge-Kutta Method for Systems of m
equations
Input the number of equations
> 3
Input the function F[1](t,y1 ... y3) in terms of t and
y1 ... y3
> y2
For example: y1-t^2+1
Input the function F[2](t,y1 ... y3) in terms of t and
y1 ... y3
> y3
For example: y1-t^2+1
Input the function F[3](t,y1 ... y3) in terms of t and
y1 ... y3
> -1*y1*y3/2
For example: y1-t^2+1
Input left and right endpoints separated by blank
> 0 12
Input the initial condition alpha[1]
> 0
Input the initial condition alpha[2]
> 0
Input the initial condition alpha[3]
> 0.3320573386
Input a positive integer for the number of subintervals
> 48
Choice of output method:
1. Output to screen
2. Output to text file
Please enter 1 or 2
> 1
RUNGE-KUTTA METHOD FOR SYS. OF DIFFERENTIAL EQUATIONS
T
W1
W2
W3
10.500 8.7792118340 .9999994497 .0000000012
10.750 9.0292116980 .9999994498 .0000000004
11.000 9.2792115620 .9999994498 .0000000001
11.250 9.5292114260 .9999994498 .0000000000
Numerical Analysis For Engineering—Fall 1999
Table 9.1
Term Project
The Function f() for the Laminar Boundary
Layer along a Flat Plate at Zero Incidence
f
f'
f'’

0.0
0.0000 0.0000 0.3321
0.5
0.0415 0.1659 0.3309
1.0
0.1656 0.3298 0.3230
1.5
0.3702 0.4868 0.3026
2.0
0.6501 0.6298 0.2668
2.5
0.9964 0.7512 0.2174
3.0
1.3969 0.8460 0.1614
3.5
1.8377 0.9130 0.1078
4.0
2.3058 0.9555 0.0643
4.5
2.7902 0.9795 0.0341
5.0
3.2833 0.9915 0.0160
5.5
3.7806 0.9968 0.0067
6.0
4.2797 0.9989 0.0025
6.5
4.7794 0.9997 0.0008
7.0
5.2793 0.9999 0.0003
7.5
5.7793 1.0000 0.0001
8.0
6.2792 1.0000 0.0000
19
Numerical Analysis For Engineering—Fall 1999
Term Project
Non Dimensional Stream Functions vs Non Dimensional Distance for 2f'''+ff''=0
7.0
6.0
Stream Functions
5.0
4.0
3.0
2.0
1.0
0.0
0.0
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0

f
f'
f''
Non Dimensional Stream Functions vs Non Dimensional Distance for 2F'''+FF''=0
16.0
14.0
Stream Functions
12.0
10.0
8.0
6.0
4.0
2.0
0.0
0.0
1.0
2.0
3.0
4.0
5.0

F
F'
20
F''
6.0
7.0
8.0
Numerical Analysis For Engineering—Fall 1999
Term Project
References
1. Burden, R., and Faires, J.D., Numerical Analysis Sixth Ed., Brooks/Cole Publishing Company,
Pacific Grove, CA, 1997.
2. Fox, Robert W., and McDonald, Alan T., Introduction to Fluid Mechanics Fourth Edition,
John Wiley & Sons, Inc., New York, NY, 1992.
3. DeWitt, David P., and Incropera, Frank P., Fundamentals of Heat and Mass Transfer Fourth
Edition, John Wiley & Sons, Inc., New York, NY, 1996.
4. White, Frank M., Fluid Mechanics, Third Edition, McGraw-Hill, Inc., New York, NY, 1994.
5. Rosenhead, L., Laminar Boundary Layers, Dover Publications, New York, NY, 1988.
21