Term Project

Computational Fluid Dynamics

Prof. S.Saidi

Sharif University of Technology International Campus Kish Island

Students name: Aliakbar kabir

Students ID.: 89250861

Winter 2012
 1. Definitions

First step of solving the problem is to describe the definitions of the

problem requirement, to have better understanding of the problem.

1.1. Staggered Grid

The solution procedure for the transport of a general property developed

in without presenting pressure will of course be enlisted to solve the
momentum equations. Matters are, however, not completely straightforward
since there are problems associated with the pressure source terms of the
momentum equations that need special treatment.

The finite volume method starts, as always, with the discretization of the
flow domain and of the relevant transport equations. First we need to decide
where to store the velocities. It seems logical to define these at the same
locations as the scalar variables such as pressure, temperature etc. However,
if the velocities and pressures are both defined at the nodes of an ordinary
control volume a highly non-uniform pressure field can act like a uniform
field in the discretized momentum equations. This can be demonstrated with
the simple two-dimensional situation shown in Figure 1.1, where a uniform
grid is used for simplicity.

Fig. 1.1 A 'checker-board' pressure fiel

Let us assume that we have somehow obtained a highly irregular 'checker-

board' pressure field with values as shown in Figure 1.1.

1|Page
 If the pressures at 'e' and 'w' are obtained by linear interpolation the
pressure gradient term dp/dx in the u-momentum equation is given by

1.1.1

Similarly, the pressure gradient dp/dy for the v-momentum equation is

evaluated as:

1.1.2

The pressure at the central node (P) does not appear in (1.1.1) and (1.1.2).
Substituting the appropriate values from the 'checker-board' pressure field in
Figure 1.1 into formulae (1.1.1-1.1.2) we find that all the discretized
gradients are zero at all the nodal points even though the pressure field
exhibits spatial oscillations in both directions.

As a result, this pressure field would give the same (zero) momentum
source in the discretized equations as a uniform pressure field. This behavior
is obviously nonphysical.

It is clear that, if the velocities are defined at the scalar grid nodes, the
influence of pressure is not properly represented in the discretized
momentum equations. A remedy for this problem is to use a staggered grid
for the velocity components (Harlow and Welch, 1965). The idea is to
evaluate scalar variables, such as pressure, density, temperature etc., at
ordinary nodal points but to calculate velocity components on staggered grids
centered on the cell faces. The arrangement for a two-dimensional flow
calculation is shown in Figure 1.2.

2|Page
 The scalar variables, including pressure, are stored at the nodes marked ().
The velocities are defined at the (scalar) cell faces in between the nodes and
are indicated by arrows. Horizontal ( ) arrows indicate the locations for u-
velocities and vertical ( ) ones denote those for v-velocities. In addition to the
E,W, N,S notation Figure 1.2 also introduces a new system of notation based
on a numbering of grid lines and cell faces.

For the moment we continue to use the original E, W, N, S notation the u-

velocities are stored at scalar cell faces e and w and the v-velocities at
faces 'n' and 's'.

Fig. 1.2

We observe that the control volumes for u and v are different from the
scalar control volumes and different from each other. The scalar control
volumes are sometimes referred to as the pressure control volumes because,
as we shall see later, the discretized continuity equation is turned into a
pressure correction equation, which is evaluated on scalar control volumes.

3|Page
 In the staggered grid arrangement, the pressure nodes coincide with the
cell faces of the u-control volume. The pressure gradient term dp/dx is given
by

1.1.3

Where , is the width of the u-control volume. Similarly dp/dy for the v-control
volume shown is given by

1.1.4

where , is width of the v-control volume.

If we consider the 'checker-board' pressure field again, substitution of the

appropriate nodal pressure values into equations (1.1.3) and (1.1.4) now
yields very significant non-zero pressure gradient terms. The staggering of
the velocity avoids the unrealistic behavior of the discretized momentum
equation for spatially oscillating pressures like the 'checker-board' field. A
further advantage of the staggered grid arrangement is that it generates
velocities at exactly the locations where they are required for the scalar
transport convection diffusion - computations. Hence, no interpolation is
needed to calculate velocities at the scalar cell faces.

1.2. SIMPLE Family Algorithm

The acronym SIMPLE stands for Semi-Implicit Method for Pressure-

Linked Equations. The algorithm was originally put forward by Patankar and
Spalding (1972) and is essentially a guess-and-correct procedure for the
calculation of pressure on the staggered grid arrangement introduced above.
The method is illustrated by considering the two-dimensional laminar steady
flow equations in Cartesian co-ordinates. The SIMPLE algorithm gives a
method of calculating pressure and velocities. The method is iterative and
when other scalars are coupled to the momentum equations, the calculation
needs to be done sequentially.
4|Page
 1.3. SIMPLER

The SIMPLER (SIMPLE Revised) algorithm of Patankar (1980) is an

improved version of SIMPLE. In this algorithm the discretized continuity
equation:

1.3.1

is used to derive a discretized equation for pressure, instead of a

pressure correction equation as in SIMPLE. Thus the intermediate pressure
field is obtained directly without the use of a correction. Velocities are,
however, still obtained through the velocity corrections of SIMPLE.

1.3.2

1.3.3

1.3.4

1.3.5

1.3.6

The discretized momentum equations are re-arranged as:

5|Page
 1.3.7

1.3.8

In the SIMPLER algorithm pseudo-velocities and are now defined as

follows:

1.3.9

1.3.10

Equations (1.3.7) and (1.3.8) can now be written as:

1.3.11

1.3.12

The definition for d, introduced in (1.3.6), is applied in (1.3.11-1.3.12).

Substituting for and , from these equations into the discretized
continuity equation (1.3.1), using similar forms for and results in:

1.3.13

Equation (1.3.13) may be re-arranged to give a discretized pressure

equation:

6|Page
 1.3.14

Note that the coefficients of equation (1.3.14) are the same as those in the
discretized pressure correction equation, with the difference that the source
term b is evaluated using the pseudo-velocities. Subsequently, the discretized
momentum equations:

are solved using the pressure field obtained above. This yields the velocity
components u* and v*. The velocity correction equations (1.3.2-1.3.5) are
used in the SIMPLER algorithm to obtain corrected velocities. Therefore, the
p'-equation

must also be solved to obtain the pressure corrections needed for the
velocity corrections. The full sequence of operations is described in Figure
1.3.1.

7|Page
Fig 1.3.1

8|Page
 2. Assessment of the hybrid differencing scheme

The hybrid difference scheme exploits the favorable properties of the upwind and
central differencing schemes. It switches to the upwind differencing when the central
differencing produces inaccurate results at high Pe numbers. The scheme is fully
conservative and since the coefficients are always positive it is unconditionally bounded.
It satisfies the transportiveness requirement by using an upwind formulation for large
values of Peclet number. The scheme produces physically realistic solutions and is highly
stable when compared with the higher order schemes.

Hybrid differencing has been widely used in various computational fluid dynamics
(CFD) procedures and has proved to be very useful for predicting practical flows. The
disadvantage is that the accuracy in terms of Taylor series truncation error is only first-
order.

2.1. Hybrid differencing scheme for multi-dimensional convection-

diffusion

The hybrid differencing scheme can easily be extended to two- and three
dimensional problems by repeated application of the derivation in each new coordinate
direction. The discretized equation that covers all cases is given by:

with central coefficient

and the coefficients of this equation for the hybrid differencing scheme are as
follows:

9|Page
 In the above expressions the values of F and D are calculated with the following
formulae:

10 | P a g e
3. Results

Part B: Cavity Problem

o Grid of cavity problem

11 | P a g e
o Residual-Iteration Plot

12 | P a g e
o Velocity and Pressure Contour

Pressure contour

U-component

13 | P a g e
 V-component

Velocity contour with u-v Vectors

14 | P a g e
 U-component with Stream lines

Part C: Channel Problem

o Pressure Grid

15 | P a g e
o Residual-Iteration Plots

16 | P a g e
o Velocity and Pressure Contour

Pressure Contour

17 | P a g e
U-Component

V-Component

18 | P a g e
o Velocity Profiles along the Symmetry Line at Different Levels

19 | P a g e
o Pressure Drop

Pressure Drop along X-axis

20 | P a g e
4. Code
4.1. Main code
// Kabir.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "Mesh.h"
#include "discrete_func.h"
#include "assemblage.h"
#include "Solver.h"
#include "Results.h"
mesh u_mesh,v_mesh,p_mesh,mesh;
FILE *pp;
int Nx,Ny,i,j=0,k,n_repeat,n_p,n_v,n_run,project;
double *p_prine;
double *u_prine;
double *v_prine;
double
L,H,Rx,Ry,U0,u,v,rho,vis,eror_u,eror_v,eror_p,alfa_p,alfa_u,max_u_pr=1,max_v_pr=1,b_prin1=1,ma
x_b_pr,r_b,u_prin1=1,v_prin1=1;

int _tmain(int argc, _TCHAR* argv[])

{
pp=fopen("E:\Residuals.dat","wb");

if (pp==NULL)
{
printf("Cannot open file.\n");
exit(1);
}
project=2;
if (project==1)
{
L=1;
H=1;
Nx=30;
Ny=30;
n_run=0;
Rx=1;
Ry=1;
rho=23;
vis=1;
U0=1;
n_p=5;
n_v=20;
n_repeat=50000;
alfa_p=.3;
alfa_u=.6;
}
else if(project==2)
{
L=5;
H=1;
Nx=60;
Ny=15;
n_run=0;
Rx=1;
Ry=1;
rho=1;
vis=.01;
U0=1.8;
n_p=30;
n_v=6;
n_repeat=12000;
alfa_p=.5;
alfa_u=1;

p_mesh=p_mesh.mesh_generate(L,H,Rx,Ry,Nx,Ny);

21 | P a g e
 v_mesh=v_mesh.v_mesh_generate(p_mesh,Nx,Ny);
u_mesh=v_mesh.u_mesh_generate(p_mesh,Nx,Ny);
p_prine=new double[p_mesh.n_cv];
v_prine=new double[p_mesh.n_cv];
u_prine=new double[p_mesh.n_cv];

fprintf(pp,"%s\t%s\t%s\t%s\t%s\t\n","variables=","\"repeat\"","\"continuity\"","\"u-
velocity\"","\"v-velocity\"");

//initial guess//

for (i=0;i<p_mesh.n_cv;i++)
{
u_mesh.cvs[i].phi=0;
v_mesh.cvs[i].phi=0;
p_mesh.cvs[i].phi=0;
u_mesh.cvs[i].temp=.1;
v_mesh.cvs[i].temp=.1;
p_mesh.cvs[i].temp=.1;
p_prine[i]=0;

//end initial guess//

///set_bc//

if (project==1)
{
std::cout<<"Project=Cavity\n";
for (i=0;i<p_mesh.n_bface;i++)
{
if ((i>=2*Nx)&&(i<4*Nx))
{
u_mesh.bfaces[i].phi=U0;
p_mesh.bfaces[i].phi=0;
v_mesh.bfaces[i].phi=0;
}
else
{
u_mesh.bfaces[i].phi=0;
p_mesh.bfaces[i].phi=0;
v_mesh.bfaces[i].phi=0;
}
}
}
else if (project==2)
{
std::cout<<"Project=Channel\n";
for (i=0;i<p_mesh.n_bface;i++)
{
if ((i>4*Nx-1) && i<(4*Nx+2*Ny))
{

//std::cout<<i<<"\t"<<u_mesh.bfaces[i].x<<"\t"<<u_mesh.bfaces[i].x<<"\n";
u_mesh.bfaces[i].phi=U0;
p_mesh.bfaces[i].phi=0;
v_mesh.bfaces[i].phi=0;
}
else
{
u_mesh.bfaces[i].phi=0;
p_mesh.bfaces[i].phi=0;
v_mesh.bfaces[i].phi=0;
}
}

}
///end set_bc///

for(k=0;k<n_repeat;k++)
{
if (project==2)
{
for (i=4*Nx+2*Ny;i<4*Nx+4*Ny;i++)
{

22 | P a g e
 u_mesh.bfaces[i].phi=u_mesh.cvs[u_mesh.bfaces[i].c1].phi;
}
}
//Loop for solving//
n_run=n_run+1;
for (i=0;i<p_mesh.n_cv;i++)
{
u_mesh.cvs[i].a=0;
u_mesh.cvs[i].ae=0;
u_mesh.cvs[i].aw=0;
u_mesh.cvs[i].as=0;
u_mesh.cvs[i].an=0;
u_mesh.cvs[i].b=0;
v_mesh.cvs[i].a=0;
v_mesh.cvs[i].ae=0;
v_mesh.cvs[i].aw=0;
v_mesh.cvs[i].as=0;
v_mesh.cvs[i].an=0;
v_mesh.cvs[i].b=0;
p_mesh.cvs[i].a=0;
p_mesh.cvs[i].ae=0;
p_mesh.cvs[i].aw=0;
p_mesh.cvs[i].as=0;
p_mesh.cvs[i].an=0;
p_mesh.cvs[i].b=0;
p_prine[i]=0;
}
Flux_calculate(p_mesh,u_mesh,v_mesh,rho,vis);
A_assemblage_momentom(p_mesh,u_mesh,v_mesh);
b_assemblage_momntom_velocity(p_mesh,u_mesh,v_mesh);
//std::cout<<"Solution Converged !";
for (i=0;i<p_mesh.n_cv;i++)
{
u_mesh.cvs[i].d=u_mesh.cvs[i].dy/u_mesh.cvs[i].a;
v_mesh.cvs[i].d=v_mesh.cvs[i].dx/v_mesh.cvs[i].a;

//Calculating Pseudo Velocties//

pseudo(u_mesh.cvs,2*Nx,u_mesh.n_cv,1);
pseudo(v_mesh.cvs,2*Nx,v_mesh.n_cv,1);

//Calculating Intermediate Pressure

A_assemblage_continuity(p_mesh,u_mesh,v_mesh,rho);
b_assemblage_continuity(p_mesh,u_mesh,v_mesh,rho);
eror_p=cv_PDMA(p_mesh.cvs,p_mesh.n_cv,2*Nx,1e-8,n_p,1e-7);
for (i=0;i<p_mesh.n_cv;i++)
{
u_mesh.cvs[i].a=0;
u_mesh.cvs[i].ae=0;
u_mesh.cvs[i].aw=0;
u_mesh.cvs[i].as=0;
u_mesh.cvs[i].an=0;
u_mesh.cvs[i].b=0;
v_mesh.cvs[i].a=0;
v_mesh.cvs[i].ae=0;
v_mesh.cvs[i].aw=0;
v_mesh.cvs[i].as=0;
v_mesh.cvs[i].an=0;
v_mesh.cvs[i].b=0;
p_mesh.cvs[i].a=0;
p_mesh.cvs[i].ae=0;
p_mesh.cvs[i].aw=0;
p_mesh.cvs[i].as=0;
p_mesh.cvs[i].an=0;
p_mesh.cvs[i].b=0;
p_prine[i]=0;
}
for (i=0;i<p_mesh.n_cv;i++)
{
u_mesh.cvs[i].phi=u_mesh.cvs[i].temp;
v_mesh.cvs[i].phi=v_mesh.cvs[i].temp;
}
Flux_calculate(p_mesh,u_mesh,v_mesh,rho,vis);
A_assemblage_momentom(p_mesh,u_mesh,v_mesh);
b_assemblage_momntom_velocity(p_mesh,u_mesh,v_mesh);

23 | P a g e
 b_assemblage_momntom_pressure(p_mesh,u_mesh,v_mesh);
//std::cout<<"Solution Converged !";
for (i=0;i<p_mesh.n_cv;i++)
{
u_mesh.cvs[i].d=u_mesh.cvs[i].dy/u_mesh.cvs[i].a;
v_mesh.cvs[i].d=v_mesh.cvs[i].dx/v_mesh.cvs[i].a;

//Calculating Pseudo Velocties//

eror_u=cv_PDMA(u_mesh.cvs,p_mesh.n_cv,2*Nx,.4,n_v,1e-3);
eror_v=cv_PDMA(v_mesh.cvs,v_mesh.n_cv,2*Nx,.4,n_v,1e-3);

A_assemblage_continuity(p_mesh,u_mesh,v_mesh,rho);
b_assemblage_continuity(p_mesh,u_mesh,v_mesh,rho);
eror_p=PDMA(p_mesh.cvs,p_prine,v_mesh.n_cv,2*p_mesh.Nx,.3,n_p,1);

fprintf(pp,"%d\t%e\t%e\t%e\t\n",k,r_b,max_u_pr/u_prin1,max_v_pr/v_prin1);

for (i=2*Nx;i<p_mesh.n_cv;i++)
{
v_prine[i]=v_mesh.cvs[i].d*(p_prine[i-2*Nx]-p_prine[i]);
v_mesh.cvs[i].phi=v_mesh.cvs[i].phi+v_prine[i];
v_mesh.cvs[i].phi=alfa_u*v_mesh.cvs[i].phi+(1-
alfa_u)*v_mesh.cvs[i].temp;
v_mesh.cvs[i].temp=v_mesh.cvs[i].phi;
}
for (i=0;i<p_mesh.n_cv;i++)
{
if (i%(p_mesh.Nx*2)!=0)
{
u_prine[i]=u_mesh.cvs[i].d*(p_prine[i-1]-p_prine[i]);
u_mesh.cvs[i].phi=u_mesh.cvs[i].phi+u_prine[i];
u_mesh.cvs[i].phi=alfa_u*u_mesh.cvs[i].phi+(1-
alfa_u)*u_mesh.cvs[i].temp;
u_mesh.cvs[i].temp=u_mesh.cvs[i].phi;
}
}
for (i=0;i<p_mesh.n_cv;i++)
{
p_mesh.cvs[i].phi=p_mesh.cvs[i].phi+alfa_p*p_prine[i];
p_mesh.cvs[i].phi=(1-
alfa_p)*p_mesh.cvs[i].temp+alfa_p*p_mesh.cvs[i].phi;
p_mesh.cvs[i].temp=p_mesh.cvs[i].phi;
}

max_u_pr=max(u_prine,u_mesh.n_cv-u_mesh.Ny*2);
max_v_pr=max(v_prine,v_mesh.n_cv-v_mesh.Nx*2);
max_b_pr=max2(p_mesh.cvs,p_mesh.n_cv-1);
r_b=max_b_pr/b_prin1;
if (n_run==3)
{
b_prin1=max2(p_mesh.cvs,p_mesh.n_cv);
u_prin1=max(u_prine,u_mesh.n_cv-u_mesh.Ny*2);
v_prin1=max(v_prine,v_mesh.n_cv-v_mesh.Nx*2);
}

fprintf(pp,"%d\t%e\t%e\t%e\t\n",k,r_b,max_u_pr/u_prin1,max_v_pr/v_prin1);

if ((max_u_pr/U0<1e-3)&&(max_v_pr<1e-3)&&(r_b)<1e-5)
{
std::cout<<"Solution Converged !";
std::cin>>j;
break;
}
if(n_run%10==0)
{
std::cout<<n_run;
std::cout<<" Continuity Err = "<<r_b<<" Err_u =
"<<max_u_pr/u_prin1<<" \n ";
}

24 | P a g e
 }

contour(u_mesh,v_mesh,p_mesh,"E:\contour.dat");
plot_u(u_mesh,"E:\plot_u.dat");
plot_v(v_mesh,"E:\plot_v.dat");

fclose(pp);

return 0;
}

4.2. Subroutines
4.2.1. Assemblage
int Ar(int i,int j,int n)
{
return (i*n+j);
};

void A_assemblage_momentom(mesh& p_mesh,mesh& u_mesh,mesh& v_mesh)

{
int i,j;

// ifaces assemblage
for (i=0;i<u_mesh.n_iface;i++)
{

if(u_mesh.ifaces[i].sit=='v')
{
if ((u_mesh.ifaces[i].Pe>2)||(u_mesh.ifaces[i].Pe==0))
{

u_mesh.cvs[u_mesh.ifaces[i].c1].a=
u_mesh.cvs[u_mesh.ifaces[i].c1].a+
(u_mesh.ifaces[i].D+u_mesh.ifaces[i].F)*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c1].ae=
u_mesh.cvs[u_mesh.ifaces[i].c1].ae-
u_mesh.ifaces[i].D*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c2].aw=
u_mesh.cvs[u_mesh.ifaces[i].c2].aw-
(u_mesh.ifaces[i].D+u_mesh.ifaces[i].F)*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c2].a=
u_mesh.cvs[u_mesh.ifaces[i].c2].a+
(u_mesh.ifaces[i].D)*u_mesh.ifaces[i].A;
}
else if(u_mesh.ifaces[i].Pe<-2)
{
u_mesh.cvs[u_mesh.ifaces[i].c1].a=
u_mesh.cvs[u_mesh.ifaces[i].c1].a+
(u_mesh.ifaces[i].D)*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c1].ae=
u_mesh.cvs[u_mesh.ifaces[i].c1].ae+
(u_mesh.ifaces[i].F-u_mesh.ifaces[i].D)*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c2].aw=
u_mesh.cvs[u_mesh.ifaces[i].c2].aw-
u_mesh.ifaces[i].D*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c2].a=
u_mesh.cvs[u_mesh.ifaces[i].c2].a+
(u_mesh.ifaces[i].D-u_mesh.ifaces[i].F)*u_mesh.ifaces[i].A;
}
else

25 | P a g e
 {
u_mesh.cvs[u_mesh.ifaces[i].c1].a=
u_mesh.cvs[u_mesh.ifaces[i].c1].a+

(u_mesh.ifaces[i].D+u_mesh.ifaces[i].F*(0.5+1/u_mesh.ifaces[i].Pe))*u_mesh.ifaces[i].A
;
u_mesh.cvs[u_mesh.ifaces[i].c1].ae=
u_mesh.cvs[u_mesh.ifaces[i].c1].ae+
(-u_mesh.ifaces[i].D+u_mesh.ifaces[i].F*(0.5-
1/u_mesh.ifaces[i].Pe))*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c2].aw=
u_mesh.cvs[u_mesh.ifaces[i].c2].aw-

(u_mesh.ifaces[i].D+u_mesh.ifaces[i].F*(0.5+1/u_mesh.ifaces[i].Pe))*u_mesh.ifaces[i].A
;
u_mesh.cvs[u_mesh.ifaces[i].c2].a=
u_mesh.cvs[u_mesh.ifaces[i].c2].a+
(u_mesh.ifaces[i].D-u_mesh.ifaces[i].F*(0.5-
1/u_mesh.ifaces[i].Pe))*u_mesh.ifaces[i].A;

}
}
else if (u_mesh.ifaces[i].sit=='h')
{
if((u_mesh.ifaces[i].Pe>2)||(u_mesh.ifaces[i].Pe==0))
{
u_mesh.cvs[u_mesh.ifaces[i].c1].a=
u_mesh.cvs[u_mesh.ifaces[i].c1].a+
(u_mesh.ifaces[i].D+u_mesh.ifaces[i].F)*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c1].an=
u_mesh.cvs[u_mesh.ifaces[i].c1].an-
u_mesh.ifaces[i].D*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c2].as=
u_mesh.cvs[u_mesh.ifaces[i].c2].as-
(u_mesh.ifaces[i].D+u_mesh.ifaces[i].F)*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c2].a=
u_mesh.cvs[u_mesh.ifaces[i].c2].a+
(u_mesh.ifaces[i].D)*u_mesh.ifaces[i].A;
}
else if(u_mesh.ifaces[i].Pe<-2)
{
u_mesh.cvs[u_mesh.ifaces[i].c1].a=
u_mesh.cvs[u_mesh.ifaces[i].c1].a+
(u_mesh.ifaces[i].D)*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c1].an=
u_mesh.cvs[u_mesh.ifaces[i].c1].an+
(u_mesh.ifaces[i].F-u_mesh.ifaces[i].D)*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c2].as=
u_mesh.cvs[u_mesh.ifaces[i].c2].as-
u_mesh.ifaces[i].D*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c2].a=
u_mesh.cvs[u_mesh.ifaces[i].c2].a+
(u_mesh.ifaces[i].D-u_mesh.ifaces[i].F)*u_mesh.ifaces[i].A;
}
else
{
u_mesh.cvs[u_mesh.ifaces[i].c1].a=
u_mesh.cvs[u_mesh.ifaces[i].c1].a+

(u_mesh.ifaces[i].D+u_mesh.ifaces[i].F*(0.5+1/u_mesh.ifaces[i].Pe))*u_mesh.ifaces[i].A
;
u_mesh.cvs[u_mesh.ifaces[i].c1].an=
u_mesh.cvs[u_mesh.ifaces[i].c1].an+
(-u_mesh.ifaces[i].D+u_mesh.ifaces[i].F*(0.5-
1/u_mesh.ifaces[i].Pe))*u_mesh.ifaces[i].A;
u_mesh.cvs[u_mesh.ifaces[i].c2].as=
u_mesh.cvs[u_mesh.ifaces[i].c2].as-

(u_mesh.ifaces[i].D+u_mesh.ifaces[i].F*(0.5+1/u_mesh.ifaces[i].Pe))*u_mesh.ifaces[i].A
;
u_mesh.cvs[u_mesh.ifaces[i].c2].a=
u_mesh.cvs[u_mesh.ifaces[i].c2].a+
(u_mesh.ifaces[i].D-u_mesh.ifaces[i].F*(0.5-
1/u_mesh.ifaces[i].Pe))*u_mesh.ifaces[i].A;

}
}

26 | P a g e
 }

for (i=0;i<v_mesh.n_iface;i++)
{
if(v_mesh.ifaces[i].sit=='v')
{
if((v_mesh.ifaces[i].Pe>2)||(v_mesh.ifaces[i].Pe==0))
{
v_mesh.cvs[v_mesh.ifaces[i].c1].a=
v_mesh.cvs[v_mesh.ifaces[i].c1].a+
(v_mesh.ifaces[i].D+v_mesh.ifaces[i].F)*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c1].ae=
v_mesh.cvs[v_mesh.ifaces[i].c1].ae-
v_mesh.ifaces[i].D*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c2].aw=
v_mesh.cvs[v_mesh.ifaces[i].c2].aw-
(v_mesh.ifaces[i].D+v_mesh.ifaces[i].F)*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c2].a=
v_mesh.cvs[v_mesh.ifaces[i].c2].a+
(v_mesh.ifaces[i].D)*v_mesh.ifaces[i].A;
}
else if(v_mesh.ifaces[i].Pe<-2)
{
v_mesh.cvs[v_mesh.ifaces[i].c1].a=
v_mesh.cvs[v_mesh.ifaces[i].c1].a+
(v_mesh.ifaces[i].D)*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c1].ae=
v_mesh.cvs[v_mesh.ifaces[i].c1].ae+
(v_mesh.ifaces[i].F-v_mesh.ifaces[i].D)*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c2].aw=
v_mesh.cvs[v_mesh.ifaces[i].c2].aw-
v_mesh.ifaces[i].D*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c2].a=
v_mesh.cvs[v_mesh.ifaces[i].c2].a+
(v_mesh.ifaces[i].D-v_mesh.ifaces[i].F)*v_mesh.ifaces[i].A;
}
else
{
v_mesh.cvs[v_mesh.ifaces[i].c1].a=
v_mesh.cvs[v_mesh.ifaces[i].c1].a+

(v_mesh.ifaces[i].D+v_mesh.ifaces[i].F*(0.5+1/v_mesh.ifaces[i].Pe))*v_mesh.ifaces[i].A
;
v_mesh.cvs[v_mesh.ifaces[i].c1].ae=
v_mesh.cvs[v_mesh.ifaces[i].c1].ae+
(-v_mesh.ifaces[i].D+v_mesh.ifaces[i].F*(0.5-
1/v_mesh.ifaces[i].Pe))*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c2].aw=
v_mesh.cvs[v_mesh.ifaces[i].c2].aw-

(v_mesh.ifaces[i].D+v_mesh.ifaces[i].F*(0.5+1/v_mesh.ifaces[i].Pe))*v_mesh.ifaces[i].A
;
v_mesh.cvs[v_mesh.ifaces[i].c2].a=
v_mesh.cvs[v_mesh.ifaces[i].c2].a+
(v_mesh.ifaces[i].D-v_mesh.ifaces[i].F*(0.5-
1/v_mesh.ifaces[i].Pe))*v_mesh.ifaces[i].A;

}
}
else if (v_mesh.ifaces[i].sit=='h')
{
if((v_mesh.ifaces[i].Pe>2)||(v_mesh.ifaces[i].Pe==0))
{

v_mesh.cvs[v_mesh.ifaces[i].c1].a=
v_mesh.cvs[v_mesh.ifaces[i].c1].a+
(v_mesh.ifaces[i].D+v_mesh.ifaces[i].F)*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c1].an=
v_mesh.cvs[v_mesh.ifaces[i].c1].an-
v_mesh.ifaces[i].D*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c2].as=
v_mesh.cvs[v_mesh.ifaces[i].c2].as-

27 | P a g e
 (v_mesh.ifaces[i].D+v_mesh.ifaces[i].F)*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c2].a=
v_mesh.cvs[v_mesh.ifaces[i].c2].a+
(v_mesh.ifaces[i].D)*v_mesh.ifaces[i].A;
}
else if(v_mesh.ifaces[i].Pe<-2)
{
v_mesh.cvs[v_mesh.ifaces[i].c1].a=
v_mesh.cvs[v_mesh.ifaces[i].c1].a+
(v_mesh.ifaces[i].D)*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c1].an=
v_mesh.cvs[v_mesh.ifaces[i].c1].an+
(v_mesh.ifaces[i].F-v_mesh.ifaces[i].D)*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c2].as=
v_mesh.cvs[v_mesh.ifaces[i].c2].as-
v_mesh.ifaces[i].D*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c2].a=
v_mesh.cvs[v_mesh.ifaces[i].c2].a+
(v_mesh.ifaces[i].D-v_mesh.ifaces[i].F)*v_mesh.ifaces[i].A;
}
else
{
v_mesh.cvs[v_mesh.ifaces[i].c1].a=
v_mesh.cvs[v_mesh.ifaces[i].c1].a+

(v_mesh.ifaces[i].D+v_mesh.ifaces[i].F*(0.5+1/v_mesh.ifaces[i].Pe))*v_mesh.ifaces[i].A
;
v_mesh.cvs[v_mesh.ifaces[i].c1].an=
v_mesh.cvs[v_mesh.ifaces[i].c1].an+
(-v_mesh.ifaces[i].D+v_mesh.ifaces[i].F*(0.5-
1/v_mesh.ifaces[i].Pe))*v_mesh.ifaces[i].A;
v_mesh.cvs[v_mesh.ifaces[i].c2].as=
v_mesh.cvs[v_mesh.ifaces[i].c2].as-

(v_mesh.ifaces[i].D+v_mesh.ifaces[i].F*(0.5+1/v_mesh.ifaces[i].Pe))*v_mesh.ifaces[i].A
;
v_mesh.cvs[v_mesh.ifaces[i].c2].a=
v_mesh.cvs[v_mesh.ifaces[i].c2].a+
(v_mesh.ifaces[i].D-v_mesh.ifaces[i].F*(0.5-
1/v_mesh.ifaces[i].Pe))*v_mesh.ifaces[i].A;

}
}

// bfaces assemblage

for (i=0;i<u_mesh.n_bface;i++)
{
u_mesh.cvs[u_mesh.bfaces[i].c1].a=
u_mesh.cvs[u_mesh.bfaces[i].c1].a+
u_mesh.bfaces[i].D*u_mesh.bfaces[i].A;
v_mesh.cvs[v_mesh.bfaces[i].c1].a=
v_mesh.cvs[v_mesh.bfaces[i].c1].a+
v_mesh.bfaces[i].D*v_mesh.bfaces[i].A;

28 | P a g e
void b_assemblage_momntom_velocity(mesh& p_mesh,mesh& u_mesh,mesh& v_mesh)
{
int i,j;
for (i=0;i<u_mesh.n_bface;i++)
{
u_mesh.cvs[u_mesh.bfaces[i].c1].b=u_mesh.cvs[u_mesh.bfaces[i].c1].b+
(u_mesh.bfaces[i].D)*u_mesh.bfaces[i].A*u_mesh.bfaces[i].phi;
u_mesh.cvs[u_mesh.bfaces[i].c1].b=u_mesh.cvs[u_mesh.bfaces[i].c1].b+
u_mesh.bfaces[i].F*u_mesh.bfaces[i].phi;
v_mesh.cvs[v_mesh.bfaces[i].c1].b=v_mesh.cvs[v_mesh.bfaces[i].c1].b+
v_mesh.bfaces[i].F*v_mesh.bfaces[i].phi;
}

}
void b_assemblage_momntom_pressure(mesh& p_mesh,mesh& u_mesh,mesh& v_mesh)
{
int i,j;

for(i=0;i<p_mesh.n_iface;i++)
{
if (p_mesh.ifaces[i].sit=='v')

u_mesh.cvs[u_mesh.ifaces[i].c2].b=u_mesh.cvs[u_mesh.ifaces[i].c2].b+u_mesh.ifaces[i].A

*(p_mesh.cvs[p_mesh.ifaces[i].c1].phi
-
p_mesh.cvs[p_mesh.ifaces[i].c2].phi);
else

v_mesh.cvs[v_mesh.ifaces[i].c2].b=v_mesh.cvs[v_mesh.ifaces[i].c2].b+v_mesh.ifaces[i].A

*(p_mesh.cvs[p_mesh.ifaces[i].c1].phi
-
p_mesh.cvs[p_mesh.ifaces[i].c2].phi);

}
void b_assemblage_continuity(mesh& p_mesh,mesh& u_mesh,mesh& v_mesh,double rho)
{
int i,j;
// in this lines d must change.
for (i=0;i<p_mesh.n_iface;i++)
{
if (p_mesh.ifaces[i].sit=='v')
{

p_mesh.cvs[p_mesh.ifaces[i].c1].b=p_mesh.cvs[p_mesh.ifaces[i].c1].b-
rho*p_mesh.ifaces[i].A*(u_mesh.cvs[u_mesh.ifaces[i].c2].phi-
(u_mesh.cvs[u_mesh.ifaces[i].c2].phi-
u_mesh.cvs[u_mesh.ifaces[i].c1].phi)
/u_mesh.ifaces[i].ds*p_mesh.ifaces[i].dxc);
p_mesh.cvs[p_mesh.ifaces[i].c2].b=p_mesh.cvs[p_mesh.ifaces[i].c2].b+
rho*p_mesh.ifaces[i].A*(u_mesh.cvs[u_mesh.ifaces[i].c2].phi-
(u_mesh.cvs[u_mesh.ifaces[i].c2].phi-
u_mesh.cvs[u_mesh.ifaces[i].c1].phi)
/u_mesh.ifaces[i].ds*p_mesh.ifaces[i].dxc);
}
else
{

p_mesh.cvs[p_mesh.ifaces[i].c1].b=p_mesh.cvs[p_mesh.ifaces[i].c1].b-
rho*p_mesh.ifaces[i].A*(v_mesh.cvs[v_mesh.ifaces[i].c2].phi-
(v_mesh.cvs[v_mesh.ifaces[i].c2].phi-
v_mesh.cvs[v_mesh.ifaces[i].c1].phi)
/v_mesh.ifaces[i].ds*p_mesh.ifaces[i].dxc);
p_mesh.cvs[p_mesh.ifaces[i].c2].b=p_mesh.cvs[p_mesh.ifaces[i].c2].b+
rho*p_mesh.ifaces[i].A*(v_mesh.cvs[v_mesh.ifaces[i].c2].phi-
(v_mesh.cvs[v_mesh.ifaces[i].c2].phi-
v_mesh.cvs[v_mesh.ifaces[i].c1].phi)
/v_mesh.ifaces[i].ds*p_mesh.ifaces[i].dxc);

29 | P a g e
 }
}

for (i=0;i<u_mesh.n_bface;i++)
{
p_mesh.cvs[p_mesh.bfaces[i].c1].b=p_mesh.cvs[p_mesh.bfaces[i].c1].b+
p_mesh.bfaces[i].F;
}

void A_assemblage_continuity(mesh& p_mesh,mesh& u_mesh,mesh& v_mesh,double rho)

{
int i,j;
// in this lines d must change.
for (i=0;i<p_mesh.n_iface;i++)
{
if (p_mesh.ifaces[i].sit=='v')
{
p_mesh.cvs[p_mesh.ifaces[i].c1].a=
p_mesh.cvs[p_mesh.ifaces[i].c1].a+
rho*p_mesh.ifaces[i].A*(u_mesh.cvs[u_mesh.ifaces[i].c2].d-
(u_mesh.cvs[u_mesh.ifaces[i].c2].d-u_mesh.cvs[u_mesh.ifaces[i].c1].d)
/u_mesh.ifaces[i].ds*p_mesh.ifaces[i].dxc);

p_mesh.cvs[p_mesh.ifaces[i].c1].ae=
p_mesh.cvs[p_mesh.ifaces[i].c1].ae-
rho*p_mesh.ifaces[i].A*(u_mesh.cvs[u_mesh.ifaces[i].c2].d-
(u_mesh.cvs[u_mesh.ifaces[i].c2].d-u_mesh.cvs[u_mesh.ifaces[i].c1].d)
/u_mesh.ifaces[i].ds*p_mesh.ifaces[i].dxc);
p_mesh.cvs[p_mesh.ifaces[i].c2].aw=
p_mesh.cvs[p_mesh.ifaces[i].c2].aw-
rho*p_mesh.ifaces[i].A*(u_mesh.cvs[u_mesh.ifaces[i].c2].d-
(u_mesh.cvs[u_mesh.ifaces[i].c2].d-u_mesh.cvs[u_mesh.ifaces[i].c1].d)
/u_mesh.ifaces[i].ds*p_mesh.ifaces[i].dxc);
p_mesh.cvs[p_mesh.ifaces[i].c2].a=
p_mesh.cvs[p_mesh.ifaces[i].c2].a+
rho*p_mesh.ifaces[i].A*(u_mesh.cvs[u_mesh.ifaces[i].c2].d-
(u_mesh.cvs[u_mesh.ifaces[i].c2].d-u_mesh.cvs[u_mesh.ifaces[i].c1].d)
/u_mesh.ifaces[i].ds*p_mesh.ifaces[i].dxc);

}
else
{
p_mesh.cvs[p_mesh.ifaces[i].c1].a=
p_mesh.cvs[p_mesh.ifaces[i].c1].a+
rho*p_mesh.ifaces[i].A*(v_mesh.cvs[v_mesh.ifaces[i].c2].d-
(v_mesh.cvs[v_mesh.ifaces[i].c2].d-v_mesh.cvs[v_mesh.ifaces[i].c1].d)
/v_mesh.ifaces[i].ds*p_mesh.ifaces[i].dxc);

p_mesh.cvs[p_mesh.ifaces[i].c1].an=
p_mesh.cvs[p_mesh.ifaces[i].c1].an-
rho*p_mesh.ifaces[i].A*(v_mesh.cvs[v_mesh.ifaces[i].c2].d-
(v_mesh.cvs[v_mesh.ifaces[i].c2].d-v_mesh.cvs[v_mesh.ifaces[i].c1].d)
/v_mesh.ifaces[i].ds*p_mesh.ifaces[i].dxc);
p_mesh.cvs[p_mesh.ifaces[i].c2].as=
p_mesh.cvs[p_mesh.ifaces[i].c2].as-
rho*p_mesh.ifaces[i].A*(v_mesh.cvs[v_mesh.ifaces[i].c2].d-
(v_mesh.cvs[v_mesh.ifaces[i].c2].d-v_mesh.cvs[v_mesh.ifaces[i].c1].d)
/v_mesh.ifaces[i].ds*p_mesh.ifaces[i].dxc);
p_mesh.cvs[p_mesh.ifaces[i].c2].a=
p_mesh.cvs[p_mesh.ifaces[i].c2].a+
rho*p_mesh.ifaces[i].A*(v_mesh.cvs[v_mesh.ifaces[i].c2].d-
(v_mesh.cvs[v_mesh.ifaces[i].c2].d-v_mesh.cvs[v_mesh.ifaces[i].c1].d)
/v_mesh.ifaces[i].ds*p_mesh.ifaces[i].dxc);

}
}

30 | P a g e
 4.2.2. Mesh Generator
#pragma once
#include "math.h"
#include <stdlib.h>
#include <stdio.h>
#include <cstdlib>
#include <iostream>

class Mesh
{

Mesh(void);
~Mesh(void);

};

class iface
{
public:
int c1;
int c2;
double d1;
double d2;
double A;
double dxc;
double ds;
char sit;
double x;
double y;
double dA;
double dB;
double F;
double D;
double Pe;
double p;
double d;
};
class bface
{
public:
int c1;
double d1;
double A;
double ds;
char sit;
double x;
double y;
double phi;
double u;
double v;
double dA;
double dB;
double F;
double D;
};
class Cv
{
public:
double dx;
double dy;
double P_A;
double v;
double x;
double y;
double phi;

31 | P a g e
 double dphidx;
double dphidy;
double d;
double ae;
double aw;
double as;
double an;
double a;
double b;
double stream;
double temp;
};

class mesh
{
public:

int n_iface;
int n_bface;
int n_cv;
int Nx;
int Ny;
iface *ifaces;
bface *bfaces;
Cv *cvs;
Cv *cv_p;
Cv *cv_v;
Cv *cv_u;

/// Function

// p_mesh_generation
public:mesh mesh_generate(double L,double H,double Rx,double Ry,int Nx,int Ny)
{
int i,j=0,k=0;
double dx1,s1=0,dy1;
for (i=0;i<Nx;i++)
s1=pow(Rx,i)+s1;
dx1=L/(2*s1);
s1=0;
for (i=0;i<Ny;i++)
s1=pow(Ry,i)+s1;
dy1=H/(2*s1);
mesh obj_mesh;
obj_mesh.n_iface=((2*Nx-1)*2*Ny+2*Nx*(2*Ny-1));
obj_mesh.n_bface=4*(Nx+Ny);
obj_mesh.n_cv=Nx*Ny*4;
obj_mesh.Nx=Nx;
obj_mesh.Ny=Ny;
obj_mesh.ifaces=new iface[obj_mesh.n_iface];
obj_mesh.bfaces=new bface[obj_mesh.n_bface];
obj_mesh.cvs=new Cv[obj_mesh.n_cv];
j=0;
k=0;
for(i=0;i<(2*Nx-1)*2*Ny;i++)
{
obj_mesh.ifaces[i].c1=i+k;
obj_mesh.ifaces[i].c2=i+k+1;
obj_mesh.ifaces[i].sit='v';
if (j==0)
{
obj_mesh.ifaces[i].x=-L/2+dx1*pow(Rx,Nx-1);
j=j+1;
if (k==0)
obj_mesh.ifaces[i].y=-H/2+dy1*pow(Ry,Ny-1)/2.0;
else if (k<=Ny-1)
obj_mesh.ifaces[i].y=obj_mesh.ifaces[i-1].y+dy1*(pow(Ry,Ny-
k)+pow(Ry,Ny-k-1))/2.0;
else if (k==Ny)
obj_mesh.ifaces[i].y=-obj_mesh.ifaces[i-2*(Nx-1)].y;
else
obj_mesh.ifaces[i].y=obj_mesh.ifaces[i-1].y+dy1*(pow(Ry,k-Ny-
1)+pow(Ry,k-Ny))/2.0;
}
else if (j<=Nx-1)
{

32 | P a g e
 obj_mesh.ifaces[i].x=obj_mesh.ifaces[i-1].x+dx1*pow(Rx,Nx-1-j);
obj_mesh.ifaces[i].y=obj_mesh.ifaces[i-1].y;
j=j+1;
}
else if (j<2*Nx-2)
{
obj_mesh.ifaces[i].x=obj_mesh.ifaces[i-1].x+dx1*pow(Rx,j-Nx);
obj_mesh.ifaces[i].y=obj_mesh.ifaces[i-1].y;
j=j+1;

}
else if (j==2*Nx-2)
{
obj_mesh.ifaces[i].x=obj_mesh.ifaces[i-1].x+dx1*pow(Rx,j-Nx);
obj_mesh.ifaces[i].y=obj_mesh.ifaces[i-1].y;
j=0;
k=k+1;
}

///////////////// Horizontal ifaces/////////////

k=0;
j=0;
int p=0;

for(i=(2*Nx-1)*2*Ny;i<(2*Nx-1)*2*Ny+2*Nx*(2*Ny-1);i++)
{
obj_mesh.ifaces[i].c1=p;
obj_mesh.ifaces[i].c2=p+2*Nx;
obj_mesh.ifaces[i].sit='h';
p=p+1;

if (j==0)
{
obj_mesh.ifaces[i].x=-L/2+dx1*pow(Rx,Nx-1)/2.0;
j=j+1;
if (k==0)
obj_mesh.ifaces[i].y=-H/2+dy1*pow(Ry,Ny-1);
else if (k<=Ny-1)
obj_mesh.ifaces[i].y=obj_mesh.ifaces[i-1].y+dy1*pow(Ry,Ny-1-k);
else
obj_mesh.ifaces[i].y=obj_mesh.ifaces[i-1].y+dy1*pow(Ry,k-Ny);

}
else if (j<=Nx-1)
{
obj_mesh.ifaces[i].x=obj_mesh.ifaces[i-1].x+dx1*(pow(Rx,Nx-1-
j)+pow(Rx,Nx-j))/2.0;
obj_mesh.ifaces[i].y=obj_mesh.ifaces[i-1].y;
j=j+1;
}
else if (j==Nx)
{
obj_mesh.ifaces[i].x=-obj_mesh.ifaces[i-1].x;
obj_mesh.ifaces[i].y=obj_mesh.ifaces[i-1].y;
j=j+1;
}
else if (j<2*Nx-1)
{
obj_mesh.ifaces[i].x=obj_mesh.ifaces[i-1].x+dx1*(pow(Rx,j-Nx-
1)+pow(Rx,j-Nx))/2.0;
obj_mesh.ifaces[i].y=obj_mesh.ifaces[i-1].y;
j=j+1;
}
else if (j==2*Nx-1)
{
obj_mesh.ifaces[i].x=obj_mesh.ifaces[i-1].x+dx1*(pow(Rx,j-Nx-
1)+pow(Rx,j-Nx))/2.0;
obj_mesh.ifaces[i].y=obj_mesh.ifaces[i-1].y;
j=0;
k=k+1;
}

33 | P a g e
 }

/////////////////////////////bfaces
j=0;
k=0;
for(i=0;i<2*Nx;i++)
{
obj_mesh.bfaces[i].c1=i;
obj_mesh.bfaces[i+2*Nx].c1=(2*Ny-1)*2*Nx+i;
obj_mesh.bfaces[i].y=-H/2;
obj_mesh.bfaces[i+2*Nx].y=H/2;
obj_mesh.bfaces[i].sit='h';
obj_mesh.bfaces[i+2*Nx].sit='h';
if (j==0)
{
obj_mesh.bfaces[i].x=-L/2+dx1*pow(Rx,Nx-1)/2.0;
obj_mesh.bfaces[i+2*Nx].x=-L/2+dx1*pow(Rx,Nx-1)/2.0;
j=j+1;
}
else if (j<=Nx-1)
{
obj_mesh.bfaces[i].x=obj_mesh.bfaces[i-1].x+dx1*(pow(Rx,Nx-1-
j)+pow(Rx,Nx-j))/2.0;
obj_mesh.bfaces[i+2*Nx].x=obj_mesh.bfaces[i-1].x+dx1*(pow(Rx,Nx-1-
j)+pow(Rx,Nx-j))/2.0;
j=j+1;
}
else if(j==Nx)
{
obj_mesh.bfaces[i].x=-obj_mesh.bfaces[i-1].x;
obj_mesh.bfaces[i+2*Nx].x=-obj_mesh.bfaces[i-1].x;
j=j+1;

}
else if (j<=2*Nx-1)
{
obj_mesh.bfaces[i].x=obj_mesh.bfaces[i-1].x+dx1*(pow(Rx,j-Nx-
1)+pow(Rx,j-Nx))/2.0;
obj_mesh.bfaces[i+2*Nx].x=obj_mesh.bfaces[i-1].x+dx1*(pow(Rx,j-Nx-
1)+pow(Rx,j-Nx))/2.0;
j=j+1;
}

j=0;
k=0;
for(i=4*Nx;i<4*Nx+2*Ny;i++)
{
obj_mesh.bfaces[i].c1=2*j*Nx;
obj_mesh.bfaces[i+2*Ny].c1=2*(j+1)*Nx-1;
obj_mesh.bfaces[i].x=-L/2;
obj_mesh.bfaces[i+2*Ny].x=L/2;
obj_mesh.bfaces[i].sit='v';
obj_mesh.bfaces[i+2*Ny].sit='v';
if (j==0)
{
obj_mesh.bfaces[i].y=-H/2+dy1*pow(Ry,Ny-1)/2.0;
obj_mesh.bfaces[i+2*Ny].y=-H/2+dy1*pow(Ry,Ny-1)/2.0;
j=j+1;
}
else if (j<=Ny-1)
{
obj_mesh.bfaces[i].y=obj_mesh.bfaces[i-1].y+dy1*(pow(Ry,Ny-1-
j)+pow(Ry,Ny-j))/2.0;
obj_mesh.bfaces[i+2*Ny].y=obj_mesh.bfaces[i-1].y+dy1*(pow(Ry,Ny-1-
j)+pow(Ry,Ny-j))/2.0;
j=j+1;
}
else if (j==Ny)
{
obj_mesh.bfaces[i].y=-obj_mesh.bfaces[i-1].y;
obj_mesh.bfaces[i+2*Ny].y=-obj_mesh.bfaces[i-1].y;
j=j+1;

34 | P a g e
 }
else if (j<=2*Ny-1)
{
obj_mesh.bfaces[i].y=obj_mesh.bfaces[i-1].y+dy1*(pow(Ry,j-Ny-
1)+pow(Ry,j-Ny))/2.0;
obj_mesh.bfaces[i+2*Ny].y=obj_mesh.bfaces[i-1].y+dy1*(pow(Ry,j-Ny-
1)+pow(Ry,j-Ny))/2.0;
j=j+1;
}

/////////////////CVS////////////////
j=0;
k=0;
i=0;
for(i=0;i<obj_mesh.n_cv;i++)
{

if (j==0)
{
obj_mesh.cvs[i].x=-L/2+dx1*pow(Rx,Nx-1)/2.0;
j=j+1;
if (k==0)
obj_mesh.cvs[i].y=-H/2+dy1*pow(Ry,Ny-1)/2.0;
else if (k<=Ny-1)
obj_mesh.cvs[i].y=obj_mesh.cvs[i-1].y+dy1*(pow(Ry,Ny-1-
k)+pow(Ry,Ny-k))/2.0;
else if(k==Ny)
obj_mesh.cvs[i].y=-obj_mesh.cvs[i-1].y;
else
obj_mesh.cvs[i].y=obj_mesh.cvs[i-1].y+dy1*(pow(Ry,k-Ny-
1)+pow(Ry,k-Ny))/2.0;
}
else if (j<=Nx-1)
{
obj_mesh.cvs[i].x=obj_mesh.cvs[i-1].x+dx1*(pow(Rx,Nx-1-j)+pow(Rx,Nx-
j))/2.0;
obj_mesh.cvs[i].y=obj_mesh.cvs[i-1].y;
j=j+1;
}
else if (j==Nx)
{
obj_mesh.cvs[i].x=-obj_mesh.cvs[i-1].x;
obj_mesh.cvs[i].y=obj_mesh.cvs[i-1].y;
j=j+1;

else if (j<2*Nx-1)
{
obj_mesh.cvs[i].x=obj_mesh.cvs[i-1].x+dx1*(pow(Rx,j-Nx-1)+pow(Rx,j-
Nx))/2.0;
obj_mesh.cvs[i].y=obj_mesh.cvs[i-1].y;
j=j+1;
}
else if (j==2*Nx-1)
{
obj_mesh.cvs[i].x=obj_mesh.cvs[i-1].x+dx1*(pow(Rx,j-Nx-1)+pow(Rx,j-
Nx))/2.0;
obj_mesh.cvs[i].y=obj_mesh.cvs[i-1].y;
j=0;
k=k+1;
}

k=1;
p=0;

for (i=0;i<obj_mesh.n_cv;i++)
{

p=p+1;
if (p==2*Nx)

35 | P a g e
 {
obj_mesh.cvs[i].dx=dx1*pow(Rx,p-Nx-1);
p=0;
}
else if (p>Nx)
obj_mesh.cvs[i].dx=dx1*pow(Rx,p-Nx-1);
else if (p<=Nx)
obj_mesh.cvs[i].dx=dx1*pow(Rx,Nx-p);

if (k<=Ny)
obj_mesh.cvs[i].dy=dy1*pow(Ry,Ny-k);
else
obj_mesh.cvs[i].dy=dy1*pow(Ry,k-Ny-1);
if (p==0)
k=k+1;

}
for (i=0;i<obj_mesh.n_cv;i++)
{
obj_mesh.cvs[i].v=obj_mesh.cvs[i].dx*obj_mesh.cvs[i].dy;
obj_mesh.cvs[i].P_A=2*(obj_mesh.cvs[i].dx+obj_mesh.cvs[i].dy);
}

for (i=0;i<(2*Nx-1)*2*Ny;i++)
{
obj_mesh.ifaces[i].A=obj_mesh.cvs[obj_mesh.ifaces[i].c1].dy;
obj_mesh.ifaces[i].d1=obj_mesh.ifaces[i].x-
obj_mesh.cvs[obj_mesh.ifaces[i].c1].x;
obj_mesh.ifaces[i].d2=obj_mesh.ifaces[i].x-
obj_mesh.cvs[obj_mesh.ifaces[i].c2].x;

obj_mesh.ifaces[i].dxc=(obj_mesh.cvs[obj_mesh.ifaces[i].c1].x+obj_mesh.cvs[obj_mesh.if
aces[i].c2].x)/2.0-obj_mesh.ifaces[i].x;
obj_mesh.ifaces[i].ds=abs(obj_mesh.ifaces[i].d1)+abs(obj_mesh.ifaces[i].d2);
}
for (i=(2*Nx-1)*2*Ny;i<(2*Nx-1)*2*Ny+2*Nx*(2*Ny-1);i++)
{
obj_mesh.ifaces[i].A=obj_mesh.cvs[obj_mesh.ifaces[i].c1].dx;
obj_mesh.ifaces[i].d1=obj_mesh.ifaces[i].y-
obj_mesh.cvs[obj_mesh.ifaces[i].c1].y;
obj_mesh.ifaces[i].d2=obj_mesh.ifaces[i].y-
obj_mesh.cvs[obj_mesh.ifaces[i].c2].y;

obj_mesh.ifaces[i].dxc=(obj_mesh.cvs[obj_mesh.ifaces[i].c1].y+obj_mesh.cvs[obj_mesh.if
aces[i].c2].y)/2.0-obj_mesh.ifaces[i].y;
obj_mesh.ifaces[i].ds=abs(obj_mesh.ifaces[i].d1)+abs(obj_mesh.ifaces[i].d2);
}

for(i=0;i<4*Nx;i++)
{
obj_mesh.bfaces[i].A=obj_mesh.cvs[obj_mesh.bfaces[i].c1].dx;
obj_mesh.bfaces[i].d1=obj_mesh.bfaces[i].y-
obj_mesh.cvs[obj_mesh.bfaces[i].c1].y;
obj_mesh.bfaces[i].ds=abs(obj_mesh.bfaces[i].d1);
}
for(i=4*Nx;i<4*Nx+4*Ny;i++)
{
obj_mesh.bfaces[i].A=obj_mesh.cvs[obj_mesh.bfaces[i].c1].dy;
obj_mesh.bfaces[i].d1=obj_mesh.bfaces[i].x-
obj_mesh.cvs[obj_mesh.bfaces[i].c1].x;
obj_mesh.bfaces[i].ds=abs(obj_mesh.bfaces[i].d1);
}

return obj_mesh;

};

//End Mesh Generation ////

36 | P a g e
//Start U_mesh//

public: mesh u_mesh_generate(mesh p_mesh,int Nx,int Ny)

{
int i,j,k=0;
mesh u_mesh;
u_mesh.ifaces=new iface[p_mesh.n_iface];
u_mesh.bfaces=new bface[p_mesh.n_bface];
u_mesh.cvs=new Cv[p_mesh.n_cv];
u_mesh.n_bface=p_mesh.n_bface;
u_mesh.n_cv=p_mesh.n_cv;
u_mesh.n_iface=p_mesh.n_iface;
u_mesh.Nx=p_mesh.Nx;
u_mesh.Ny=p_mesh.Ny;
for (i=0;i<p_mesh.n_cv;i++)
{
k=k+1;
if (k==1)
{
u_mesh.cvs[i].x=p_mesh.cvs[i].x-p_mesh.cvs[i].dx/2.0;
u_mesh.cvs[i].dx=p_mesh.cvs[i].dx;

}
else if (k<=2*Nx)
{
u_mesh.cvs[i].dx=p_mesh.cvs[i].dx-(p_mesh.cvs[i].dx-
p_mesh.cvs[i-1].dx)/2.0;
u_mesh.cvs[i].x=p_mesh.cvs[i].x-u_mesh.cvs[i].dx/2.0;
if (k==2*Nx)
k=0;
}
u_mesh.cvs[i].dy=p_mesh.cvs[i].dy;
u_mesh.cvs[i].y=p_mesh.cvs[i].y;
u_mesh.cvs[i].v=u_mesh.cvs[i].dx*u_mesh.cvs[i].dy;
u_mesh.cvs[i].P_A=2*(u_mesh.cvs[i].dx+u_mesh.cvs[i].dy);
}

for (i=0;i<p_mesh.n_iface;i++)
{
u_mesh.ifaces[i].c1=p_mesh.ifaces[i].c1;
u_mesh.ifaces[i].c2=p_mesh.ifaces[i].c2;
u_mesh.ifaces[i].y=p_mesh.ifaces[i].y;
u_mesh.ifaces[i].sit=p_mesh.ifaces[i].sit;

if (i<(2*Nx-1)*2*Ny)
{
u_mesh.ifaces[i].x=p_mesh.ifaces[i].x-
p_mesh.ifaces[i].d1;
u_mesh.ifaces[i].A=p_mesh.ifaces[i].A;
u_mesh.ifaces[i].d1=u_mesh.ifaces[i].x-
u_mesh.cvs[u_mesh.ifaces[i].c1].x;
u_mesh.ifaces[i].d2=u_mesh.ifaces[i].x-
u_mesh.cvs[u_mesh.ifaces[i].c2].x;

u_mesh.ifaces[i].ds=abs(u_mesh.ifaces[i].d1)+abs(u_mesh.ifaces[i].d2);

u_mesh.ifaces[i].dxc=(u_mesh.cvs[u_mesh.ifaces[i].c1].x+u_mesh.cvs[u_mesh.ifaces[i].c2
].x)/2.0-u_mesh.ifaces[i].x;
}
else
{
u_mesh.ifaces[i].x=u_mesh.cvs[u_mesh.ifaces[i].c1].x;
u_mesh.ifaces[i].A=u_mesh.cvs[u_mesh.ifaces[i].c1].dx;
u_mesh.ifaces[i].d1=p_mesh.ifaces[i].d1;
u_mesh.ifaces[i].d2=p_mesh.ifaces[i].d2;
u_mesh.ifaces[i].ds=p_mesh.ifaces[i].ds;
u_mesh.ifaces[i].dxc=p_mesh.ifaces[i].dxc;

}
}
for (j=0;j<p_mesh.n_bface;j++)
{
u_mesh.bfaces[j].c1=p_mesh.bfaces[j].c1;
u_mesh.bfaces[j].sit=p_mesh.bfaces[j].sit ;
u_mesh.bfaces[j].y=p_mesh.bfaces[j].y;

37 | P a g e
 if (u_mesh.bfaces[j].sit=='v')
{
u_mesh.bfaces[j].A=p_mesh.bfaces[j].A;
u_mesh.bfaces[j].x=p_mesh.bfaces[j].x-
p_mesh.cvs[p_mesh.bfaces[j].c1].dx/2.0;
u_mesh.bfaces[j].d1=u_mesh.bfaces[j].x-
u_mesh.cvs[u_mesh.bfaces[j].c1].x;
}
else
{
u_mesh.bfaces[j].A=u_mesh.cvs[u_mesh.bfaces[j].c1].dx;
u_mesh.bfaces[j].d1=p_mesh.bfaces[j].d1;
u_mesh.bfaces[j].x=u_mesh.cvs[u_mesh.bfaces[j].c1].x;

}
u_mesh.bfaces[j].ds=abs(u_mesh.bfaces[j].d1);

}
return u_mesh;

//Start v_mesh//

public: mesh v_mesh_generate(mesh p_mesh,int Nx,int Ny)

{
int i,j,k=0;
mesh v_mesh;
v_mesh.ifaces=new iface[p_mesh.n_iface];
v_mesh.bfaces=new bface[p_mesh.n_bface];
v_mesh.cvs=new Cv[p_mesh.n_cv];
v_mesh.n_bface=p_mesh.n_bface;
v_mesh.n_cv=p_mesh.n_cv;
v_mesh.n_iface=p_mesh.n_iface;
v_mesh.Nx=p_mesh.Nx;
v_mesh.Ny=p_mesh.Ny;
for (i=0;i<p_mesh.n_cv;i++)
{
if (i<2*Nx)
{
v_mesh.cvs[i].y=p_mesh.cvs[i].y-p_mesh.cvs[i].dy/2.0;
v_mesh.cvs[i].dy=p_mesh.cvs[i].dy;

}
else if (i<=2*Ny*2*Nx)
{
v_mesh.cvs[i].dy=p_mesh.cvs[i].dy-(p_mesh.cvs[i].dy-
p_mesh.cvs[i-2*Nx].dy)/2.0;
v_mesh.cvs[i].y=p_mesh.cvs[i].y-v_mesh.cvs[i].dy/2.0;
}
v_mesh.cvs[i].dx=p_mesh.cvs[i].dx;
v_mesh.cvs[i].x=p_mesh.cvs[i].x;
v_mesh.cvs[i].v=v_mesh.cvs[i].dx*v_mesh.cvs[i].dy;
v_mesh.cvs[i].P_A=2*(v_mesh.cvs[i].dx+v_mesh.cvs[i].dy);
}

for (i=0;i<p_mesh.n_iface;i++)
{
v_mesh.ifaces[i].c1=p_mesh.ifaces[i].c1;
v_mesh.ifaces[i].c2=p_mesh.ifaces[i].c2;
v_mesh.ifaces[i].x=p_mesh.ifaces[i].x;
v_mesh.ifaces[i].sit=p_mesh.ifaces[i].sit;

if (i>=(2*Nx-1)*2*Ny)
{
v_mesh.ifaces[i].y=p_mesh.ifaces[i].y-
p_mesh.ifaces[i].d1;
v_mesh.ifaces[i].A=p_mesh.ifaces[i].A;
v_mesh.ifaces[i].d1=v_mesh.ifaces[i].y-
v_mesh.cvs[v_mesh.ifaces[i].c1].y;
v_mesh.ifaces[i].d2=v_mesh.ifaces[i].y-
v_mesh.cvs[v_mesh.ifaces[i].c2].y;

v_mesh.ifaces[i].ds=abs(v_mesh.ifaces[i].d1)+abs(v_mesh.ifaces[i].d2);

38 | P a g e
 v_mesh.ifaces[i].dxc=(v_mesh.cvs[v_mesh.ifaces[i].c1].y+v_mesh.cvs[v_mesh.ifaces[i].c2
].y)/2.0-v_mesh.ifaces[i].y;
}
else
{
v_mesh.ifaces[i].y=v_mesh.cvs[v_mesh.ifaces[i].c1].y;
v_mesh.ifaces[i].A=v_mesh.cvs[v_mesh.ifaces[i].c1].dy;
v_mesh.ifaces[i].d1=p_mesh.ifaces[i].d1;
v_mesh.ifaces[i].d2=p_mesh.ifaces[i].d2;
v_mesh.ifaces[i].ds=p_mesh.ifaces[i].ds;
v_mesh.ifaces[i].dxc=p_mesh.ifaces[i].dxc;

}
for (j=0;j<p_mesh.n_bface;j++)
{
v_mesh.bfaces[j].x=p_mesh.bfaces[j].x;
v_mesh.bfaces[j].sit=p_mesh.bfaces[j].sit;
v_mesh.bfaces[j].c1=p_mesh.bfaces[j].c1;

if (v_mesh.bfaces[j].sit=='v')
{

v_mesh.bfaces[j].y=v_mesh.cvs[v_mesh.bfaces[j].c1].y;

v_mesh.bfaces[j].A=v_mesh.cvs[p_mesh.bfaces[j].c1].dy;
v_mesh.bfaces[j].d1=p_mesh.bfaces[j].d1;
}
else
{
v_mesh.bfaces[j].y=p_mesh.bfaces[j].y-
p_mesh.cvs[p_mesh.bfaces[j].c1].dy/2.0;
v_mesh.bfaces[j].d1=v_mesh.bfaces[j].y-
v_mesh.cvs[v_mesh.bfaces[j].c1].y;

v_mesh.bfaces[j].A=v_mesh.cvs[p_mesh.bfaces[j].c1].dx;
}
v_mesh.bfaces[j].ds=abs(v_mesh.bfaces[j].d1);

}
}

return v_mesh;

// drawing mesh//
public:void draw_mesh(mesh obj_mesh,char s[])
{
int i,j,k,t,f=0,n;
FILE *fp;
fp=fopen(s,"wb");
fprintf(fp,"%s%s\n","title=","\"Cavity_mesh\"");
fprintf(fp,"%s%s\t%s\n","variables=","\"x\"","\"y\"");
fprintf(fp,"%s%d\t%s%d\n","zone
i=",2*obj_mesh.Nx+1,"j=",2*obj_mesh.Ny+1);
k=4*obj_mesh.Nx;
t=4*obj_mesh.Nx+2*Ny;
for (i=0;i<2*obj_mesh.Ny;i++)
{
fprintf(fp,"%f\t%f\n",obj_mesh.bfaces[k].x,obj_mesh.bfaces[k].y-
obj_mesh.bfaces[k].A/2.0);
for (j=0;j<2*obj_mesh.Nx-1;j++)

39 | P a g e
 {

fprintf(fp,"%f\t%f\n",obj_mesh.ifaces[f].x,obj_mesh.ifaces[f].y-
obj_mesh.ifaces[f].A/2.0);
f=f+1;
}
fprintf(fp,"%f\t%f\n",obj_mesh.bfaces[t].x,obj_mesh.bfaces[t].y-
obj_mesh.bfaces[t].A/2.0);
t=t+1;
k=k+1;

}
n=f-2*Nx+1;
fprintf(fp,"%f\t%f\n",obj_mesh.bfaces[k-1].x,obj_mesh.bfaces[k-
1].y+obj_mesh.bfaces[k-1].A/2.0);
for (j=0;j<2*obj_mesh.Nx-1;j++)
{

fprintf(fp,"%f\t%f\n",obj_mesh.ifaces[n].x,obj_mesh.ifaces[n].y+obj_mesh.ifaces[n].A/2
.0);
n=n+1;
}
fprintf(fp,"%f\t%f\n",obj_mesh.bfaces[t-1].x,obj_mesh.bfaces[t-
1].y+obj_mesh.bfaces[t-1].A/2.0);

fclose(fp);

};
class matrix
{
public:
double *row;
};

4.2.3. Result Maker

void contour(mesh u,mesh v,mesh p,char a[])

{
FILE *fp;
fp=fopen(a,"wt");
fprintf(fp,"%s%s\n","title=","\"Cavity_mesh\"");

fprintf(fp,"%s%s\t%s\t%s\t%s\t%s\t%s\n","variables=","\"x\"","\"y\"","\"u\"","\"v\"","
\"p\"","\"Residual\"");
fprintf(fp,"%s%d\t%s%d\n","zone i=",2*p.Nx+2,"j=",2*p.Ny+2);
int i,j,k;
j=4*p.Nx;
k=4*p.Nx+2*p.Ny;
fprintf(fp,"%e\t%e\t%e\t%e\t%e\t\%e\t\n",p.bfaces[0].x-
p.bfaces[0].A/2.0,p.bfaces[0].y,u.bfaces[0].phi,v.bfaces[0].phi,
p.cvs[p.bfaces[0].c1].phi,0);
for(i=0;i<p.Nx*2;i++)

fprintf(fp,"%e\t%e\t%e\t%e\t%e\t\%e\t\n",p.bfaces[i].x,p.bfaces[i].y,u.bfaces[i].phi,v
.bfaces[i].phi,p.cvs[p.bfaces[i].c1].phi,0);
fprintf(fp,"%e\t%e\t%e\t%e\t%e\t\%e\t\n",p.bfaces[2*p.Nx-1].x+p.bfaces[2*p.Nx-
1].A/2.0,

40 | P a g e
 p.bfaces[2*p.Nx-1].y,u.bfaces[2*p.Nx-1].phi,v.bfaces[2*p.Nx-
1].phi,p.cvs[p.bfaces[2*p.Nx-1].c1].phi,0);

for (i=0;i<p.n_cv;i++)
{
if (i%(p.Nx*2)==0)
{
fprintf(fp,"%e\t%e\t%e\t%e\t%e\t\%e\t\n",p.bfaces[j].x,p.bfaces[j].y
,u.bfaces[j].phi,v.bfaces[j].phi,p.cvs[i].phi,0);
j=j+1;
}

fprintf(fp,"%e\t%e\t%e\t%e\t%e\t\%e\t\n",p.cvs[i].x,p.cvs[i].y
,u.cvs[i].phi,v.cvs[i].phi,p.cvs[i].phi,abs(p.cvs[i].b));

if (i%(p.Nx*2)==p.Nx*2-1)
{
fprintf(fp,"%e\t%e\t%e\t%e\t%e\t\%e\t\n",p.bfaces[k].x,p.bfaces[k].y
,u.bfaces[k].phi,v.bfaces[k].phi,p.cvs[i].phi,0);
k=k+1;
}
}
fprintf(fp,"%e\t%e\t%e\t%e\t%e\t\%e\t\n",p.bfaces[2*p.Nx].x-
p.bfaces[p.Nx*2].A/2,p.bfaces[p.Nx*2].y,
u.bfaces[p.Nx*2].phi,v.bfaces[p.Nx*2].phi,p.cvs[p.bfaces[p.Nx*2].c1].phi,0.0);
for(i=2*p.Nx ;i<p.Nx*4;i++)

fprintf(fp,"%e\t%e\t%e\t%e\t\t%e\t\%e\t\n",p.bfaces[i].x,p.bfaces[i].y,u.bfaces[i].phi
,v.bfaces[i].phi,p.cvs[p.bfaces[i].c1].phi,0.0);
fprintf(fp,"%e\t%e\t%e\t%e\t%e\t\%e\t\n",p.bfaces[4*p.Nx-1].x+p.bfaces[p.Nx*4-
1].A/2,p.bfaces[p.Nx*4-1].y,
u.bfaces[p.Nx*4-1].phi,v.bfaces[p.Nx*4-1].phi,p.cvs[p.bfaces[p.Nx*4-
1].c1].phi,0.0);

fclose(fp);
}

void plot_u(mesh u,char a[])

{
FILE *fp;
fp=fopen(a,"wt");
fprintf(fp,"%s%s\n","title=","\"profect\"");
fprintf(fp,"%s\t%s\t%s\t\n","variables=","\"x\"","\"u\"");
fprintf(fp,"%s%d\t%s\n","zone I=",2*u.Ny,"F=POINT" );
int i;
for(i=u.Nx;i<u.n_cv;i+=2*u.Nx)
fprintf(fp,"%e\t%e\n",u.cvs[i].y,u.cvs[i].phi);

fclose(fp);
}
void plot_v(mesh v,char a[])
{
FILE *fp;
fp=fopen(a,"wt");
fprintf(fp,"%s%s\n","title=","\"Cavity_mesh\"");
fprintf(fp,"%s\t%s\t%s\t\n","variables=","\"x\"","\"u\"");
fprintf(fp,"%s%d\t%s\n","zone I=",2*v.Ny,"F=POINT" );
int i;
for(i=2*v.Nx*v.Ny ;i<2*v.Nx*(v.Ny+1);i++)
fprintf(fp,"%e\t%e\n",v.cvs[i].x,v.cvs[i].phi);

fclose(fp);
}

4.2.4. Solver

int Ar1(int i,int j,int n)

{

41 | P a g e
 return (i*n+j);
};

double max(double p[],int n)

{
int i;
double max;
max=p[0];
for(i=1;i<n;i++)
{
if(p[i]>max)
max=p[i];
}
return max;
}
double max2(Cv *cv,int n)
{
int i;
double max;
max=cv[0].b;;
for(i=1;i<n;i++)
{
if(cv[i].b>max)
max=cv[i].b;
}
return max;
}
double Mean(double p[],int n)
{
int i;
double mean;
mean=0;
for(i=1;i<n;i++)
{
mean=mean+abs(p[i]);
}
mean=mean/n;
return mean;
}
double Mean2(Cv *cv,int n)
{
int i;
double mean;
mean=0;
for(i=1;i<n;i++)
{
mean=mean+abs(cv[i].b);
}
mean=mean/n;
return mean;
}

double gause(Cv *cv,double *x,int n,int m,double alfa,int r,double err)

{
int i,j,k;
double temp,S,*Err,maxErr;
Err=new double[n];

for(j=0;j<r;j++)
{

for (i=0;i<n;i++)
{
S=0;
temp=x[i];
if (cv[i].ae!=0)
S=S+cv[i].ae*x[i+1];
if (cv[i].aw!=0)
S=S+cv[i].aw*x[i-1];
if (cv[i].as!=0)
S=S+cv[i].as*x[i-m];
if (cv[i].an!=0)
S=S+cv[i].an*x[i+m];

42 | P a g e
 x[i]=(1-alfa)*x[i]+alfa*(cv[i].b-S)/cv[i].a;
Err[i]=abs(x[i]-temp);

}
maxErr=max(Err,n);
if((maxErr<err))
break;

}
return maxErr;
}
double gause2(Cv *cv,int n,int m,double alfa,int r,double err)
{
int i,j,k;
double temp,S,*Err,maxErr;
Err=new double[n];

for(j=0;j<r;j++)
{

for (i=0;i<n;i++)
{
S=0;
temp=cv[i].phi;
if (cv[i].ae!=0)
S=S+cv[i].ae*cv[i+1].phi;
if (cv[i].aw!=0)
S=S+cv[i].aw*cv[i-1].phi;
if (cv[i].as!=0)
S=S+cv[i].as*cv[i-m].phi;
if (cv[i].an!=0)
S=S+cv[i].an*cv[i+m].phi;

cv[i].phi=(1-alfa)*cv[i].phi+alfa*(cv[i].b-S)/cv[i].a;
Err[i]=abs(cv[i].phi-temp);

}
maxErr=max(Err,n);
if((maxErr<err))
break;

}
return maxErr;
}
void solve_gause_ele(double A[],double b[],double *x,int n)
{
int i,j,k;
double sum;
for(k=0;k<=n-2;k++)
{
for(i=k+1;i<=n-1;i++)
{
for(j=n-1;j>=k+1;j--)
{
A[Ar1(i,j,n)]=A[Ar1(i,j,n)]-
A[Ar1(k,j,n)]*A[Ar1(i,k,n)]/A[Ar1(k,k,n)];
}
b[i]=b[i]-A[Ar1(i,k,n)]/A[Ar1(k,k,n)]*b[k];
}
}
x[n-1]=b[n-1]/A[Ar1(n-1,n-1,n)];
for(i=n-2;i>=0;i--)
{
sum=0;
for( j=n-1;j>=i+1;j--)
{
sum=A[Ar1(i,j,n)]*x[j]+sum;
}
x[i]=(b[i]-sum)/A[Ar1(i,i,n)];
}
}

int solve_gause_ele2(double A[],double b[],Cv *x,int n)

{

43 | P a g e
 int i,j,k;
double sum;
for(k=0;k<=n-2;k++)
{
for(i=k+1;i<=n-1;i++)
{
for(j=n-1;j>=k+1;j--)
{
A[Ar1(i,j,n)]=A[Ar1(i,j,n)]-
A[Ar1(k,j,n)]*A[Ar1(i,k,n)]/A[Ar1(k,k,n)];
}
b[i]=b[i]-A[Ar1(i,k,n)]/A[Ar1(k,k,n)]*b[k];
}
}
x[n-1].phi=b[n-1]/A[Ar1(n-1,n-1,n)];
for(i=n-2;i>=0;i--)
{
sum=0;
for( j=n-1;j>=i+1;j--)
{
sum=A[Ar1(i,j,n)]*x[j].phi+sum;
}
x[i].phi=(b[i]-sum)/A[Ar1(i,i,n)];
}
return 0;
}

double PDMA(Cv *cv ,double *x,int n,int m,double alfa,int r,double err)
{
// m=row nuber in mesh
// n=row number*column nuber
double *a,*c;
double temp,*Err,maxErr;
Err=new double[n];
int i,j;
a=new double[n];
c=new double[n];
for(j=0;j<r;j++)
{
a[0]=-cv[0].ae/cv[0].a;
c[0]=(cv[0].b-cv[0].an*x[m])/cv[0].a;
for(i=1;i<m;i++)
{
a[i]=-cv[i].ae/(cv[i].a+cv[i].aw*a[i-1]);
c[i]=(-cv[i].aw*c[i-1]+cv[i].b-cv[i].an*x[i+m])/(cv[i].a+cv[i].aw*a[i-1]);
}
for(i=m;i<n-m;i++)
{
a[i]=(-cv[i].ae)/(cv[i].a+cv[i].aw*a[i-1]);
c[i]=(-cv[i].aw*c[i-1]+cv[i].b-cv[i].an*x[i+m]-cv[i].as*x[i-
m])/(cv[i].a+cv[i].aw*a[i-1]);
}
for(i=n-m;i<n;i++)
{
a[i]=(-cv[i].ae)/(cv[i].a+cv[i].aw*a[i-1]);
c[i]=(-cv[i].aw*c[i-1]+cv[i].b-cv[i].as*x[i-m])/(cv[i].a+cv[i].aw*a[i-1]);
}
temp=x[n-1];
x[n-1]=(1-alfa)*temp+alfa*c[n-1];
Err[n-1]=abs(x[n-1]-temp);
for(i=n-2;i>=0;i--)
{
temp=x[i];
x[i]=(1-alfa)*temp+alfa*(a[i]*x[i+1]+c[i]);
Err[i]=abs((x[i]-temp)/temp);
}
maxErr=max(Err,n);
if((maxErr<err))
break;
// else if (maxErr>1e6)
// break;
}
delete(a);
delete(Err);
delete(c);
return maxErr;

44 | P a g e
}

double cv_PDMA(Cv *cv,int n,int m,double alfa,int r,double err)

{

// m=row nuber in mesh

// n=row number*column nuber
double *a,*c;
double temp,*Err,maxErr;
Err=new double[n];
int i,j;
a=new double[n];
c=new double[n];
for(j=0;j<r;j++)
{
a[0]=-cv[0].ae/cv[0].a;
c[0]=(cv[0].b-cv[0].an*cv[m].phi)/cv[0].a;
for(i=1;i<m;i++)
{
a[i]=-cv[i].ae/(cv[i].a+cv[i].aw*a[i-1]);
c[i]=(-cv[i].aw*c[i-1]+cv[i].b-cv[i].an*cv[i+m].phi)/(cv[i].a+cv[i].aw*a[i-1]);
}
for(i=m;i<n-m;i++)
{
a[i]=(-cv[i].ae)/(cv[i].a+cv[i].aw*a[i-1]);
c[i]=(-cv[i].aw*c[i-1]+cv[i].b-cv[i].an*cv[i+m].phi-cv[i].as*cv[i-
m].phi)/(cv[i].a+cv[i].aw*a[i-1]);
}
for(i=n-m;i<n;i++)
{
a[i]=(-cv[i].ae)/(cv[i].a+cv[i].aw*a[i-1]);
c[i]=(-cv[i].aw*c[i-1]+cv[i].b-cv[i].as*cv[i-m].phi)/(cv[i].a+cv[i].aw*a[i-1]);
}
temp=cv[n-1].phi;
cv[n-1].phi=(1-alfa)*temp+alfa*c[n-1];
Err[n-1]=abs(cv[n-1].phi-temp);
for(i=n-2;i>=0;i--)
{
temp=cv[i].phi;
cv[i].phi=(1-alfa)*temp+alfa*(a[i]*cv[i+1].phi+c[i]);
Err[i]=abs((cv[i].phi-temp)/temp);
}
maxErr=max(Err,n);
if((maxErr<err))
break;
// else if (maxErr>1e3)
// break;
}
// for(i=0;i<m;i++)
// cv[i].phi=0;
delete(a);
delete(Err);
delete(c);
return maxErr;

void pseudo(Cv *cv,int m,int n,double alfa)

{
int i,j;
double sum;
for (i=0;i<n;i++)
{
sum=cv[i].b;
if (cv[i].ae!=0)
sum=sum-cv[i].ae*cv[i+1].phi;
if (cv[i].aw!=0)
sum=sum-cv[i].aw*cv[i-1].phi;
if (cv[i].an!=0)
sum=sum-cv[i].an*cv[i+m].phi;
if (cv[i].as!=0)
sum=sum-cv[i].as*cv[i-m].phi;
cv[i].phi=alfa*(sum/cv[i].a)+(1-alfa)*cv[i].phi;
}
}

45 | P a g e
 4.2.5. Discretize Function

double mean1(double p1,double p2,double p3,double p4,double a,double L)

{
return (p1+p3+a/L*(p4-p3+p2-p1))/2.0;
}

void Flux_calculate(mesh& p_mesh,mesh& u_mesh,mesh& v_mesh,double rho,double vis)

{
int i;
for (i=0;i<p_mesh.n_iface;i++)
{
u_mesh.ifaces[i].D=vis/u_mesh.ifaces[i].ds;
v_mesh.ifaces[i].D=vis/v_mesh.ifaces[i].ds;
if (p_mesh.ifaces[i].sit=='v')
{

u_mesh.ifaces[i].F=rho*(u_mesh.cvs[u_mesh.ifaces[i].c1].phi
+(abs(u_mesh.ifaces[i].d1/u_mesh.ifaces[i].ds))*
(u_mesh.cvs[u_mesh.ifaces[i].c2].phi-
u_mesh.cvs[u_mesh.ifaces[i].c1].phi));
if(i<2*u_mesh.Nx-1)
{
v_mesh.ifaces[i].F=rho*
((u_mesh.cvs[u_mesh.ifaces[i].c2].phi-
(u_mesh.cvs[u_mesh.ifaces[i].c2].phi-
u_mesh.cvs[u_mesh.ifaces[i].c1].phi)

/u_mesh.ifaces[i].ds*v_mesh.ifaces[i].dxc))/2.00;

}
else
{
v_mesh.ifaces[i].F=rho*
((u_mesh.cvs[u_mesh.ifaces[i].c2].phi-
(u_mesh.cvs[u_mesh.ifaces[i].c2].phi-
u_mesh.cvs[u_mesh.ifaces[i].c1].phi)

/u_mesh.ifaces[i].ds*v_mesh.ifaces[i].dxc)+
(u_mesh.cvs[u_mesh.ifaces[i].c2-
2*u_mesh.Nx].phi-
(u_mesh.cvs[u_mesh.ifaces[i].c2-
2*u_mesh.Nx].phi-u_mesh.cvs[u_mesh.ifaces[i].c1-2*u_mesh.Nx].phi)

/u_mesh.ifaces[i].ds*v_mesh.ifaces[i].dxc))/2.00;

}
else if (p_mesh.ifaces[i].sit=='h')
{

v_mesh.ifaces[i].F=rho*(v_mesh.cvs[v_mesh.ifaces[i].c1].phi
+(abs(v_mesh.ifaces[i].d1/v_mesh.ifaces[i].ds))*
(v_mesh.cvs[v_mesh.ifaces[i].c2].phi-
v_mesh.cvs[v_mesh.ifaces[i].c1].phi));
if (i%(2*u_mesh.Nx)==0)
{
u_mesh.ifaces[i].F=rho*
((v_mesh.cvs[v_mesh.ifaces[i].c2].phi-
(v_mesh.cvs[v_mesh.ifaces[i].c2].phi-
v_mesh.cvs[v_mesh.ifaces[i].c1].phi)

/v_mesh.ifaces[i].ds*u_mesh.ifaces[i].dxc))/2.00;

}
else

46 | P a g e
 {
u_mesh.ifaces[i].F=rho*
((v_mesh.cvs[v_mesh.ifaces[i].c2].phi-
(v_mesh.cvs[v_mesh.ifaces[i].c2].phi-
v_mesh.cvs[v_mesh.ifaces[i].c1].phi)

/v_mesh.ifaces[i].ds*u_mesh.ifaces[i].dxc)+
(v_mesh.cvs[v_mesh.ifaces[i].c2-1].phi-
(v_mesh.cvs[v_mesh.ifaces[i].c2-1].phi-
v_mesh.cvs[v_mesh.ifaces[i].c1-1].phi)

/v_mesh.ifaces[i].ds*u_mesh.ifaces[i].dxc))/2.00;

}
u_mesh.ifaces[i].Pe=u_mesh.ifaces[i].F/u_mesh.ifaces[i].D;

v_mesh.ifaces[i].Pe=v_mesh.ifaces[i].F/v_mesh.ifaces[i].D;

//std::cout<<v_mesh.ifaces[i].gama<<"\n";

// D and F for bfaces//

for (i=0;i<p_mesh.n_bface;i++)
{
p_mesh.bfaces[i].D=vis/p_mesh.bfaces[i].ds;
u_mesh.bfaces[i].D=vis/u_mesh.bfaces[i].ds;
v_mesh.bfaces[i].D=vis/v_mesh.bfaces[i].ds;
p_mesh.bfaces[i].F=0;
if (u_mesh.bfaces[i].sit=='v')
{
if (u_mesh.bfaces[i].x<0)
{

u_mesh.bfaces[i].F=rho*u_mesh.bfaces[i].A*u_mesh.bfaces[i].phi;

v_mesh.bfaces[i].F=rho*u_mesh.bfaces[i].A*u_mesh.bfaces[i].phi;

p_mesh.bfaces[i].F=rho*u_mesh.bfaces[i].A*u_mesh.bfaces[i].phi;
}
else
{
u_mesh.bfaces[i].F=-
rho*u_mesh.bfaces[i].A*u_mesh.bfaces[i].phi;
v_mesh.bfaces[i].F=-
rho*u_mesh.bfaces[i].A*u_mesh.bfaces[i].phi;
p_mesh.bfaces[i].F=-
rho*u_mesh.bfaces[i].A*u_mesh.bfaces[i].phi;
}
}
else
{
if (u_mesh.bfaces[i].x<0)
{

u_mesh.bfaces[i].F=rho*u_mesh.bfaces[i].A*v_mesh.bfaces[i].phi;

v_mesh.bfaces[i].F=rho*u_mesh.bfaces[i].A*v_mesh.bfaces[i].phi;

p_mesh.bfaces[i].F=rho*u_mesh.bfaces[i].A*v_mesh.bfaces[i].phi;
}
else
{
u_mesh.bfaces[i].F=-
rho*u_mesh.bfaces[i].A*v_mesh.bfaces[i].phi;
v_mesh.bfaces[i].F=-
rho*u_mesh.bfaces[i].A*v_mesh.bfaces[i].phi;
p_mesh.bfaces[i].F=-
rho*u_mesh.bfaces[i].A*v_mesh.bfaces[i].phi;
}

}
}

47 | P a g e
}

48 | P a g e