├── ReadMe.txt
├── lbm2d steady flow
    ├── lbm2dSteady_v4.cpp
    ├── lbm2dSteady_v5.cpp
    ├── lbm2dSteadyFlow.cpp
    ├── class lbm2dSteadyFlow2d
    │   ├── lbSteadyFlow.h
    │   └── main.cpp
    ├── lbm2dtest_v.cpp
    └── lbm2dtest_v2.cpp
├── README.md
└── lbSteadyFlowD3Q19
    ├── main.cpp
    ├── lbSteadyFlowD3Q19.h
    └── lbSteadyFlowD3Q19.cpp


/ReadMe.txt:
--------------------------------------------------------------------------------
1 | input file is *.sgn format, we can modify the code to adapt for different description.


--------------------------------------------------------------------------------
/lbm2d steady flow/lbm2dSteady_v4.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/higginsjia/LBM/HEAD/lbm2d steady flow/lbm2dSteady_v4.cpp


--------------------------------------------------------------------------------
/lbm2d steady flow/lbm2dSteady_v5.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/higginsjia/LBM/HEAD/lbm2d steady flow/lbm2dSteady_v5.cpp


--------------------------------------------------------------------------------
/lbm2d steady flow/lbm2dSteadyFlow.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/higginsjia/LBM/HEAD/lbm2d steady flow/lbm2dSteadyFlow.cpp


--------------------------------------------------------------------------------
/lbm2d steady flow/class lbm2dSteadyFlow2d/lbSteadyFlow.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/higginsjia/LBM/HEAD/lbm2d steady flow/class lbm2dSteadyFlow2d/lbSteadyFlow.h


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Lattice Boltzmann Method
 2 | Lattice Boltzmann Method (LBM) to simulate CFD problem coupled with mass and heat transfer.
 3 | ## Focus On
 4 | - Steady flow 2D
 5 | - Steady flow 3D
 6 | - Free surface flow
 7 | ## Current Model
 8 | - LES model
 9 | - Volume of fluid(VOF)
10 | - Level set 
11 | ## Future Work
12 | - GPU based method
13 | - Multi-grid or AMR
14 | - Other useful approach for optimization 
15 | 


--------------------------------------------------------------------------------
/lbm2d steady flow/class lbm2dSteadyFlow2d/main.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include "stdafx.h"
 4 | #include<iostream>
 5 | #include<math.h>
 6 | #include<fstream>
 7 | #include<string>
 8 | #include<iomanip>
 9 | #include<sstream>
10 | #include <algorithm>
11 | 
12 | 
13 | #include "lbSteadyFlow.h"
14 | using namespace std;
15 | 
16 | int _tmain(int argc, _TCHAR* argv[])
17 | {
18 | 	lbSteadyFlow2d A;
19 | 	
20 | 	int Nx = 50;
21 | 	int Ny = 100;
22 | 
23 | 	int in_x1 = 10;
24 | 	int in_x2 = 20;
25 | 
26 | 	int out_x1 = 35;
27 | 	int out_x2 = 47;
28 | 
29 | 	double dx = 0.01;
30 | 	double Uin[2] = { 0.0, -5.0 };
31 | 	double visc = 1.0e-6;
32 | 	double CS = 0.13;
33 | 
34 | 	A.setPhysicalParam(Nx, Ny, in_x1, in_x2, out_x1, out_x2, dx, visc, Uin, CS);
35 | 
36 | 	double* Ucur = (double*)malloc(sizeof(double)*Nx*Ny);
37 | 	double* Unex = (double*)malloc(sizeof(double)*Nx*Ny);
38 | 
39 | 	A.setMem();
40 | 
41 | 	A.init();
42 | 
43 | 	int MaxIter = 100000;
44 | 	int logIter = 1000;
45 | 	double velocityAccuracy = 1.0e-6;
46 | 
47 | 	for (int iter = 1; iter <= MaxIter; ++iter)
48 | 	{
49 | 
50 | 		A.getVelocityField(Ucur);
51 | 
52 | 		A.streamDFs();
53 | 
54 | 		A.calMarcoVar();
55 | 
56 | 		A.collideDFs();
57 | 
58 | 		A.treatDFsBoundary();
59 | 
60 | 		A.getVelocityField(Unex);
61 | 
62 | 		double u_err = 0.0;
63 | 		double u_sum = 0.0;
64 | 
65 | 		for (int i = 0; i < Nx*Ny; ++i)
66 | 		{
67 | 			u_err += fabs(Ucur[i] - Unex[i]);
68 | 			u_sum += Ucur[i];
69 | 		}
70 | 
71 | 		u_err /= u_sum;
72 | 
73 | 		if (iter % logIter == 0)
74 | 		{
75 | 
76 | 			printf("iter=%6d err=%e\n", iter,u_err);
77 | 		}
78 | 
79 | 		if (u_err<velocityAccuracy&&iter>logIter)
80 | 		{
81 | 			printf("iter=%6d err=%e\n", iter, u_err);
82 | 			break;
83 | 		}
84 | 
85 | 	}
86 | 
87 | 	A.Out_file(666);
88 | 	
89 | 	A.resetMem();
90 | 
91 | 
92 | 	return 0;
93 | }
94 | 
95 | 


--------------------------------------------------------------------------------
/lbSteadyFlowD3Q19/main.cpp:
--------------------------------------------------------------------------------
  1 | #include "stdafx.h"
  2 | #include "lbSteadyFlowD3Q19.h"
  3 | 
  4 | int _tmain(int argc, _TCHAR* argv[])
  5 | {
  6 | 	lbSteadyFlowD3Q19 A;
  7 | 
  8 | 	//char* sgnFileName = "castingWithRiser.sgn";
  9 | 	char* sgnFileName = "d3mm.sgn";
 10 | 
 11 | 	char* outputFileName = "D:\\output\\results.plt";
 12 | 
 13 | 	A.preReadSgn(sgnFileName);
 14 | 
 15 | 	A.setSgnMem();
 16 | 
 17 | 	A.readSgn(sgnFileName);
 18 | 
 19 | 	A.setMem();
 20 | 
 21 | 	A.initSimuParam();
 22 | 
 23 | 	A.initSimuVarValue();
 24 | 
 25 | 	A.initDfsValue();
 26 | 
 27 | 	const int gridSize = A.getSize();
 28 | 	double* curU = new double[gridSize];
 29 | 	double* nexU = new double[gridSize];
 30 | 
 31 | 	int MaxIter=100;
 32 | 	const int logIter = 5;
 33 | 	const int writeIter = 50;
 34 | 
 35 | 	cout << "input max iter num:\n";
 36 | 	cin >> MaxIter;
 37 | 
 38 | 	double velocityAccuracy = 1.0e-4;
 39 | 	cout << "input velocity accuracy:\n";
 40 | 	cin >> velocityAccuracy;
 41 | 	
 42 | 	double t_start = omp_get_wtime();
 43 | 
 44 | 	for (int iter = 0; iter <= MaxIter; ++iter)
 45 | 	{
 46 | 		A.getVelocityField(curU);
 47 | 
 48 | 		A.streamDfs();
 49 | 
 50 | 		A.calMarcoVar();
 51 | 
 52 | 		A.collideDfs();
 53 | 
 54 | 		A.treatDfsBoundary();
 55 | 
 56 | 		A.getVelocityField(nexU);
 57 | 
 58 | 		double u_err = 0.0;
 59 | 		double u_sum = 0.0;
 60 | 		for (int i = 0; i < gridSize; ++i)
 61 | 		{
 62 | 			u_err += fabs(curU[i] - nexU[i]);
 63 | 			u_sum += curU[i];
 64 | 		}
 65 | 
 66 | 		u_err /= u_sum;
 67 | 		if (u_sum == 0.0)
 68 | 			u_err= 1.0;
 69 | 
 70 | 		if (iter%logIter == 0)
 71 | 		{
 72 | 			printf("iter=%7d U err=%e\n", iter,u_err);
 73 | 		}
 74 | 
 75 | 		if (iter % writeIter == 0)
 76 | 		{
 77 | 			char chNameU[600] = "D:\\output\\steadyFlow";
 78 | 			char chTailerU[255] = ".plt";
 79 | 			char str_tmpU[255];
 80 | 			sprintf(str_tmpU, "%d", 10000+iter/writeIter);
 81 | 			strcat(chNameU, str_tmpU);
 82 | 			strcat(chNameU, chTailerU);
 83 | 
 84 | 			A.writeData(chNameU);
 85 | 		}
 86 | 		
 87 | 		if (u_err < velocityAccuracy)
 88 | 		{
 89 | 			printf("calculation finished:\niter=%7d U err=%e\n", iter, u_err);
 90 | 			break;
 91 | 		}
 92 | 	}
 93 | 	
 94 | 	double t_end = omp_get_wtime();
 95 | 
 96 | 	printf("solver time used: %6.2f s\n", t_end - t_start);
 97 | 
 98 | 	A.writeData(outputFileName);
 99 | 
100 | 	A.resetMem();
101 | 
102 | 	return 0;
103 | }


--------------------------------------------------------------------------------
/lbSteadyFlowD3Q19/lbSteadyFlowD3Q19.h:
--------------------------------------------------------------------------------
  1 | #ifndef _LBSTEADYFLOWD3Q19_H_
  2 | #define _LBSTEADYFLOWD3Q19_H_
  3 | 
  4 | #include "assert.h"
  5 | #include<iostream>
  6 | #include<math.h>
  7 | #include<fstream>
  8 | #include<string>
  9 | #include<iomanip>
 10 | #include<sstream>
 11 | #include <iostream>
 12 | #include "omp.h"
 13 | using namespace std;
 14 | 
 15 | //not show warning C4996, as we use fopen() function in writeData() 
 16 | #pragma warning(disable:4996) 
 17 | 
 18 | /*
 19 | 1. preReadSgn: get Nx, Ny, Nz
 20 | 2. setSgnMem: new mem for sgn
 21 | 3. readSgn: get info to sgn
 22 | 4. 
 23 | 
 24 | */
 25 | 
 26 | 
 27 | class lbSteadyFlowD3Q19
 28 | {
 29 | public:
 30 | 	lbSteadyFlowD3Q19();
 31 | 	~lbSteadyFlowD3Q19();
 32 | 
 33 | 	//pre-processing 
 34 | 	void preReadSgn(char* filename);
 35 | 	void setSgnMem();
 36 | 	void readSgn(char* filename);
 37 | 	void setMem();
 38 | 
 39 | 	//init
 40 | 	void initSimuParam();
 41 | 	void initSimuVarValue();
 42 | 	void initDfsValue();
 43 | 
 44 | 	//solver
 45 | 	void streamDfs();
 46 | 
 47 | 	void calMarcoVar();
 48 | 
 49 | 	void collideDfs();
 50 | 
 51 | 	void treatDfsBoundary();
 52 | 
 53 | 	void getVelocityField(double* velocityField);
 54 | 	int getSize();
 55 | 
 56 | 	double calFeq(double density, double velocity[3],int i);
 57 | 	double computeLocalRelaxationTime(double tau_, double stressTensorNorm, double smagConstant);
 58 | 
 59 | 	void resetMem();
 60 | 
 61 | 	
 62 | 
 63 | 	FILE *fp;
 64 | 	//post-processing
 65 | 	void writeData(const char* filename);
 66 | 
 67 | 	void Writechar(char t)
 68 | 	{
 69 | 		fwrite(&t, sizeof(char), 1, fp);
 70 | 	};
 71 | 
 72 | 	void Writeint(int t)
 73 | 	{
 74 | 		fwrite(&t, sizeof(int), 1, fp);
 75 | 	};
 76 | 
 77 | 	void Writeshort(short t)
 78 | 	{
 79 | 		fwrite(&t, sizeof(short), 1, fp);
 80 | 	};
 81 | 
 82 | 	void Writefloat(float t)
 83 | 	{
 84 | 		fwrite(&t, sizeof(float), 1, fp);
 85 | 	};
 86 | 
 87 | 	void Writedouble(double t)
 88 | 	{
 89 | 		fwrite(&t, sizeof(double), 1, fp);
 90 | 	};
 91 | 
 92 | 	void WriteNchar(char* chars, int length)
 93 | 	{
 94 | 		fwrite(chars, sizeof(char), length, fp);
 95 | 	};
 96 | 
 97 | 	void WriteString(char* str)
 98 | 	{
 99 | 		int t = 0;
100 | 		do
101 | 		{
102 | 			t = (*str);
103 | 			Writeint(t);
104 | 			str++;
105 | 		} while (t != 0);
106 | 	};
107 | 
108 | 	
109 | private:
110 | 
111 | 	double gridLength;
112 | 	double timeStep;
113 | 	double velocityScale;
114 | 
115 | 	int Nx;
116 | 	int Ny;
117 | 	int Nz;
118 | 
119 | 	double fluidViscosity;
120 | 	double phyInletVelocity[3];//unit: m/s
121 | 	double latticeInletVelocity[3];//unit: lb
122 | 
123 | 	double relaxationTime;
124 | 	double smagorinskyConstant;
125 | 	
126 | 	int FLUID;
127 | 	int INLET;
128 | 	int OUTLET;
129 | 	int NO_SLIP;
130 | 
131 | 	double* collideField;
132 | 	double* streamField;
133 | 
134 | 	int* flag;
135 | 	double* latticeUZ;
136 | 	double* latticeUY;
137 | 	double* latticeUX;
138 | 	double* latticeDensity;
139 | 
140 | 	short* sgn;
141 | 
142 | 	const int latticeDim = 19;
143 | 	static const double latticeWeight[19];
144 | 	static const int latticeVelocity[19][3];
145 | 
146 | 	//assist function for index
147 | 
148 | 	int cellIndex(int x, int y, int z);
149 | 	int funcIndex(int x, int y, int z, int i);
150 | };
151 | 
152 | 
153 | #endif


--------------------------------------------------------------------------------
/lbm2d steady flow/lbm2dtest_v.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | 修改边界条件或平衡分布函数等 
  3 | */
  4 | #include "stdafx.h"
  5 | #include<iostream>
  6 | #include<math.h>
  7 | #include<fstream>
  8 | #include<string>
  9 | #include<iomanip>
 10 | #include<sstream>
 11 | #include <algorithm>
 12 | #include "omp.h"
 13 | using namespace std;
 14 | 
 15 | 
 16 | 
 17 | /*
 18 | #pragma omp parallel for
 19 | 
 20 | */
 21 | #define Nx 40
 22 | #define Ny 40
 23 | 
 24 | #define IN_X1 8
 25 | #define IN_X2 18
 26 | #define OUT_X1 25
 27 | #define OUT_X2 36
 28 | 
 29 | #define MaxIter 100000
 30 | #define LogStep 1000
 31 | const double w[9] = { 4.0 / 9.0, 1.0 / 9.0, 1.0 / 9.0, 1.0 / 9.0, 1.0 / 9.0, 1.0 / 36.0, 1.0 / 36.0, 1.0 / 36.0, 1.0 / 36.0 };
 32 | const double cx[9] = { 0.0, 1.0, 0.0, -1.0, 0.0, 1.0, -1.0, -1.0, 1.0 };
 33 | const double cy[9] = { 0.0, 0.0, 1.0, 0.0, -1.0, 1.0, 1.0, -1.0, -1.0 };
 34 | const int inv[9] = { 0, 3, 4, 1, 2, 7, 8, 5, 6 };
 35 | 
 36 | const double tau = 0.501;
 37 | const double omega = 1.0 / tau;
 38 | const double Uin = 0.05;
 39 | 
 40 | const int boundary = 1;
 41 | const int inlet = 3;
 42 | const int fluid = 0;
 43 | const int outlet = 4;
 44 | 
 45 | double f_old[Nx][Ny][9], f_new[Nx][Ny][9];
 46 | double u[Nx][Ny], v[Nx][Ny], rho[Nx][Ny];
 47 | int flag[Nx][Ny];
 48 | 
 49 | void init();
 50 | double feq(double rho_, double u_, double v_, int k);
 51 | void evolute();
 52 | void Out_file(int m);
 53 | double computeLocalRelaxationTime(double tau_, double stressTensorNorm, double smagConstant)
 54 | {
 55 | 	const double viscosity = (tau_ - 0.5) / 3.0;
 56 | 	const double smagSqr = smagConstant * smagConstant;
 57 | 	const double stress =
 58 | 		(std::sqrt(viscosity * viscosity + 18.0 * smagSqr * stressTensorNorm) - viscosity) /
 59 | 		(6.0 * smagSqr);
 60 | 
 61 | 	return 3.0 * (viscosity + smagSqr * stress) + 0.5;
 62 | }
 63 | void calMeanVelocity();
 64 | int _tmain(int argc, _TCHAR* argv[])
 65 | {
 66 | 	init();
 67 | 
 68 | 	for (int i = 0; i<=MaxIter; i++)
 69 | 	{
 70 | 		evolute();
 71 | 		if (i%LogStep == 0)
 72 | 		{
 73 | 			printf("iter=%6d  ", i);
 74 | 			calMeanVelocity();
 75 | 		}
 76 | 		
 77 | 	}
 78 | 
 79 | 	Out_file(999);
 80 | 
 81 | 	return 0;
 82 | }
 83 | 
 84 | 
 85 | void init()
 86 | {
 87 | 	int i, j, k;
 88 | 	//set flag
 89 | 
 90 | 	for (i = 0; i<Nx; i++)
 91 | 	for (j = 0; j<Ny; j++)
 92 | 	{
 93 | 		if ((i == 0 || i == Nx - 1 || j == 0 || j == Ny - 1))
 94 | 			flag[i][j] = boundary;
 95 | 		else if ((i >= IN_X1 && (i <= IN_X2)) && j == Ny - 2)
 96 | 			flag[i][j] = inlet;
 97 | 		else if ((i >= OUT_X1) && (i <= OUT_X2) && (j == 1))
 98 | 			flag[i][j] = outlet;
 99 | 		else
100 | 			flag[i][j] = fluid;
101 | 	}//for
102 | 	//
103 | 	//set initial value
104 | 	printf("init flag\n");
105 | 
106 | #pragma omp parallel for
107 | 	for (i = 0; i<Nx; i++)
108 | 	for (j = 0; j<Ny; j++)
109 | 	{
110 | 		u[i][j] = 0.0;
111 | 		v[i][j] = 0.0;
112 | 		rho[i][j] = 1.0;
113 | 		for (k = 0; k <= 8; k++)
114 | 		{
115 | 			f_old[i][j][k] = w[k];
116 | 			f_new[i][j][k] = f_old[i][j][k];
117 | 		}
118 | 	}
119 | 	printf("init Dfs\n");
120 | 
121 | }
122 | 
123 | 
124 | void calMeanVelocity()
125 | {
126 | 	int i, j;
127 | 	double sumU = 0.0;
128 | 
129 | 	for (i = 1; i <Nx - 1; i++)
130 | 	for (j = 1; j < Ny - 1; j++)
131 | 	{
132 | 		if (flag[i][j] != boundary)
133 | 		{
134 | 			u[i][j] = 0.0;
135 | 			v[i][j] = 0.0;
136 | 			rho[i][j] = 0.0;
137 | 			for (int k = 0; k <= 8; k++)
138 | 			{
139 | 				rho[i][j] += f_new[i][j][k];
140 | 				u[i][j] += cx[k] * f_new[i][j][k];
141 | 				v[i][j] += cy[k] * f_new[i][j][k];
142 | 			}
143 | 
144 | 			sumU += sqrt(u[i][j] * u[i][j] + v[i][j] * v[i][j]);
145 | 
146 | 
147 | 		}
148 | 	}
149 | 
150 | 	sumU /= (double)(Nx*Ny);
151 | 	printf("MeanU=%e\n", sumU);
152 | 
153 | }
154 | 
155 | double feq(double rho_, double u_, double v_, int k)
156 | {
157 | 	double t1 = u_* u_ + v_ * v_;
158 | 	double t2 = u_ * cx[k] + v_ * cy[k];
159 | 	return w[k] * (rho_ + 3.0*t2 + 4.50*t2*t2 - 1.50*t1);
160 | }
161 | 
162 | void evolute()
163 | {
164 | 	int i, j, k;
165 | 	//stream in fluid zone
166 | //#pragma omp parallel for
167 | 	for (i = 0; i <Nx; i++)
168 | 	for (j = 0; j <Ny; j++)
169 | 	{
170 | 		if (flag[i][j] == fluid)
171 | 		{
172 | 			for (k = 0; k <= 8; k++)
173 | 			{
174 | 				int inv_ = inv[k];
175 | 					f_new[i][j][k] = f_old[i + (int)cx[inv_]][j + (int)cy[inv_]][k];
176 | 			}
177 | 		}
178 | 	}
179 | 
180 | 	//calculate macroscopic var
181 | #pragma omp parallel for
182 | 	for (i = 0; i <Nx ; i++)
183 | 	for (j = 0; j <Ny ; j++)
184 | 	{
185 | 			u[i][j] = 0.0;v[i][j] = 0.0;rho[i][j] = 0.0;
186 | 
187 | 			for (k = 0; k <= 8; k++){
188 | 				rho[i][j] += f_new[i][j][k];
189 | 				u[i][j] += cx[k] * f_new[i][j][k];
190 | 				v[i][j] += cy[k] * f_new[i][j][k];
191 | 			}
192 | 
193 | 			if (flag[i][j] == inlet)
194 | 			{
195 | 				rho[i][j] = rho[i][j - 1];
196 | 				u[i][j] = 0.0;
197 | 				v[i][j] = -Uin;
198 | 			}
199 | 			if (flag[i][j] == outlet)
200 | 			{
201 | 				u[i][j] = u[i][j + 1];
202 | 				v[i][j] = v[i][j + 1];
203 | 				rho[i][j] = 1.0;// rho[i][j + 1];
204 | 				
205 | 			}
206 | 			if (flag[i][j] == boundary)
207 | 			{
208 | 				u[i][j] = 0.0;
209 | 				v[i][j] = 0.0;
210 | 			}
211 | 
212 | 			double pi_xx, pi_xy, pi_yy;
213 | 			pi_xx = 0.0;
214 | 			pi_xy = 0.0;
215 | 			pi_yy = 0.0;
216 | 			for (int it = 0; it < 9; ++it)
217 | 			{
218 | 				double fi_ = f_new[i][j][it];
219 | 				double f_eq = feq(rho[i][j], u[i][j], v[i][j], it);
220 | 				pi_xx += cx[it] * cx[it] * (fi_ - f_eq);
221 | 				pi_xy += cx[it] * cy[it] * (fi_ - f_eq);
222 | 				pi_yy += cy[it] * cy[it] * (fi_ - f_eq);
223 | 
224 | 			}
225 | 			double stress = pi_xx*pi_xx + pi_xy*pi_xy*2.0 + pi_yy*pi_yy;
226 | 			double ss_stress = std::sqrt(stress);
227 | 			double ome = computeLocalRelaxationTime(tau, ss_stress, 0.12);
228 | 			double omegaC = 1.0 /ome;
229 | 
230 | 			double omega_les = omegaC;
231 | 
232 | 			for (k = 0; k <= 8; k++)
233 | 				f_old[i][j][k] = (1.0 - omega_les)*f_new[i][j][k]
234 | 					+ omega_les*feq(rho[i][j], u[i][j], v[i][j], k);
235 | 
236 | 			//treat boundary for Dfs
237 | 			if (flag[i][j] == inlet)
238 | 			{
239 | 
240 | 				for (int k = 0; k < 9; ++k)
241 | 				{
242 | 					if (flag[i + (int)cx[k]][j + (int)cy[k]] == fluid)
243 | 						f_old[i][j][k] = feq(rho[i][j], u[i][j], v[i][j], k) +
244 | 						f_old[i + (int)cx[k]][j + (int)cy[k]][k] -
245 | 						feq(rho[i + (int)cx[k]][j + (int)cy[k]],
246 | 						u[i + (int)cx[k]][j + (int)cy[k]],
247 | 						v[i + (int)cx[k]][j + (int)cy[k]],
248 | 						k);
249 | 				}
250 | 			}
251 | 
252 | 			if (flag[i][j] == outlet)
253 | 			{
254 | 				rho[i][j] = 1.0;
255 | 				for (int k = 0; k < 9; ++k)
256 | 				{
257 | 					if (flag[i + (int)cx[k]][j + (int)cy[k]] == fluid)
258 | 						f_old[i][j][k] = feq(rho[i][j], u[i][j], v[i][j], k) +
259 | 						f_old[i + (int)cx[k]][j + (int)cy[k]][k] -
260 | 						feq(rho[i + (int)cx[k]][j + (int)cy[k]],
261 | 						u[i + (int)cx[k]][j + (int)cy[k]],
262 | 						v[i + (int)cx[k]][j + (int)cy[k]],
263 | 						k);
264 | 				}
265 | 			}
266 | 
267 | 			if (flag[i][j] == boundary)
268 | 			{
269 | 				//rho[i][j] = 1.0;
270 | 				int ip = i + (int)cx[i];
271 | 				int jp = j + (int)cy[i];
272 | 
273 | 				if (i >= 0 && i < Nx&&j >= 0 && j < Ny)
274 | 				{
275 | 					if (flag[i + (int)cx[k]][j + (int)cy[k]] == fluid)
276 | 						f_old[i][j][k] = feq(rho[i + (int)cx[k]][j + (int)cy[k]], 0.0, 0.0, k)+
277 | 						f_old[i + (int)cx[k]][j + (int)cy[k]][k] -
278 | 						feq(rho[i + (int)cx[k]][j + (int)cy[k]],
279 | 						u[i + (int)cx[k]][j + (int)cy[k]],
280 | 						v[i + (int)cx[k]][j + (int)cy[k]],
281 | 						k);
282 | 						
283 | 				}
284 | 			}
285 | 
286 | 
287 | 	}
288 | 
289 | 
290 | 	
291 | 
292 | 	//
293 | 
294 | 
295 | }
296 | 
297 | void Out_file(int m)
298 | {
299 | 	ostringstream name;
300 | 	name << "D:\\output\\cavityA_" << setfill('0') << setw(8) << m << ".plt";
301 | 	ofstream out(name.str().c_str());
302 | 	out << "Title=\"LBM Lid Driven Flow\"\n"
303 | 		<< "VARIABLES=X,Y,U,V,UV,Bound,Rho\n"
304 | 		<< "ZONE T= \"BOX\", I= "
305 | 		<< Nx  << ", J=" << Ny  << ", F=POINT" << endl;
306 | 	int i, j;
307 | 	for (j = 0; j <Ny ; j++)
308 | 	for (i = 0; i <Nx ; i++)
309 | 	{
310 | 
311 | 		out << double(i) << " " << double(j) << " "
312 | 			<< u[i][j] << " " << v[i][j] << " " << sqrt(u[i][j] * u[i][j] + v[i][j] * v[i][j]) << " " << flag[i][j] << " " << rho[i][j] << endl;
313 | 	}
314 | 	printf("write file end.\n");
315 | }
316 | 


--------------------------------------------------------------------------------
/lbm2d steady flow/lbm2dtest_v2.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | 修改边界条件或平衡分布函数等 
  3 | */
  4 | #include "stdafx.h"
  5 | #include<iostream>
  6 | #include<math.h>
  7 | #include<fstream>
  8 | #include<string>
  9 | #include<iomanip>
 10 | #include<sstream>
 11 | #include <algorithm>
 12 | #include "omp.h"
 13 | using namespace std;
 14 | 
 15 | 
 16 | 
 17 | /*
 18 | #pragma omp parallel for
 19 | 
 20 | */
 21 | #define Nx 40
 22 | #define Ny 40
 23 | 
 24 | #define IN_X1 15
 25 | #define IN_X2 21
 26 | #define OUT_X1 2
 27 | #define OUT_X2 38
 28 | 
 29 | #define MaxIter 50000
 30 | #define LogStep 1000
 31 | const double w[9] = { 4.0 / 9.0, 1.0 / 9.0, 1.0 / 9.0, 1.0 / 9.0, 1.0 / 9.0, 1.0 / 36.0, 1.0 / 36.0, 1.0 / 36.0, 1.0 / 36.0 };
 32 | const double cx[9] = { 0.0, 1.0, 0.0, -1.0, 0.0, 1.0, -1.0, -1.0, 1.0 };
 33 | const double cy[9] = { 0.0, 0.0, 1.0, 0.0, -1.0, 1.0, 1.0, -1.0, -1.0 };
 34 | const int inv[9] = { 0, 3, 4, 1, 2, 7, 8, 5, 6 };
 35 | 
 36 | const double tau = 0.501;
 37 | const double omega = 1.0 / tau;
 38 | const double Uin = 0.05;
 39 | 
 40 | const int boundary = 1;
 41 | const int inlet = 3;
 42 | const int fluid = 0;
 43 | const int outlet = 4;
 44 | 
 45 | double f_old[Nx][Ny][9], f_new[Nx][Ny][9];
 46 | double u[Nx][Ny], v[Nx][Ny], rho[Nx][Ny];
 47 | int flag[Nx][Ny];
 48 | 
 49 | void init();
 50 | double feq(double rho_, double u_, double v_, int k);
 51 | void evolute();
 52 | void Out_file(int m);
 53 | double computeLocalRelaxationTime(double tau_, double stressTensorNorm, double smagConstant)
 54 | {
 55 | 	const double viscosity = (tau_ - 0.5) / 3.0;
 56 | 	const double smagSqr = smagConstant * smagConstant;
 57 | 	const double stress =
 58 | 		(std::sqrt(viscosity * viscosity + 18.0 * smagSqr * stressTensorNorm) - viscosity) /
 59 | 		(6.0 * smagSqr);
 60 | 
 61 | 	return 3.0 * (viscosity + smagSqr * stress) + 0.5;
 62 | }
 63 | void calMeanVelocity();
 64 | int _tmain(int argc, _TCHAR* argv[])
 65 | {
 66 | 	init();
 67 | 
 68 | 	for (int i = 0; i<=MaxIter; i++)
 69 | 	{
 70 | 		evolute();
 71 | 		if (i%LogStep == 0)
 72 | 		{
 73 | 			printf("iter=%6d  ", i);
 74 | 			calMeanVelocity();
 75 | 		}
 76 | 		
 77 | 	}
 78 | 
 79 | 	Out_file(999);
 80 | 
 81 | 	return 0;
 82 | }
 83 | 
 84 | 
 85 | void init()
 86 | {
 87 | 	int i, j, k;
 88 | 	//set flag
 89 | 
 90 | 	for (i = 0; i<Nx; i++)
 91 | 	for (j = 0; j<Ny; j++)
 92 | 	{
 93 | 		if ((i == 0 || i == Nx - 1 || j == 0 || j == Ny - 1))
 94 | 			flag[i][j] = boundary;
 95 | 		else if ((i >= IN_X1 && (i <= IN_X2)) && j == Ny - 2)
 96 | 			flag[i][j] = inlet;
 97 | 		else if ((i >= OUT_X1) && (i <= OUT_X2) && (j == 0))
 98 | 			flag[i][j] = outlet;
 99 | 		else
100 | 			flag[i][j] = fluid;
101 | 	}//for
102 | 	//
103 | 	//set initial value
104 | 	printf("init flag\n");
105 | 
106 | #pragma omp parallel for
107 | 	for (i = 0; i<Nx; i++)
108 | 	for (j = 0; j<Ny; j++)
109 | 	{
110 | 		u[i][j] = 0.0;
111 | 		v[i][j] = 0.0;
112 | 		rho[i][j] = 1.0;
113 | 		for (k = 0; k <= 8; k++)
114 | 		{
115 | 			f_old[i][j][k] = w[k];
116 | 			f_new[i][j][k] = f_old[i][j][k];
117 | 		}
118 | 	}
119 | 	printf("init Dfs\n");
120 | 
121 | }
122 | 
123 | 
124 | void calMeanVelocity()
125 | {
126 | 	int i, j;
127 | 	double sumU = 0.0;
128 | 
129 | 	for (i = 1; i <Nx - 1; i++)
130 | 	for (j = 1; j < Ny - 1; j++)
131 | 	{
132 | 		if (flag[i][j] != boundary)
133 | 		{
134 | 			u[i][j] = 0.0;
135 | 			v[i][j] = 0.0;
136 | 			rho[i][j] = 0.0;
137 | 			for (int k = 0; k <= 8; k++)
138 | 			{
139 | 				rho[i][j] += f_new[i][j][k];
140 | 				u[i][j] += cx[k] * f_new[i][j][k];
141 | 				v[i][j] += cy[k] * f_new[i][j][k];
142 | 			}
143 | 
144 | 			sumU += sqrt(u[i][j] * u[i][j] + v[i][j] * v[i][j]);
145 | 
146 | 
147 | 		}
148 | 	}
149 | 
150 | 	sumU /= (double)(Nx*Ny);
151 | 	printf("MeanU=%e\n", sumU);
152 | 
153 | }
154 | 
155 | double feq(double rho_, double u_, double v_, int k)
156 | {
157 | 	double t1 = u_* u_ + v_ * v_;
158 | 	double t2 = u_ * cx[k] + v_ * cy[k];
159 | 	return w[k] * (rho_ + 3.0*t2 + 4.50*t2*t2 - 1.50*t1);
160 | }
161 | 
162 | void evolute()
163 | {
164 | 	int i, j, k;
165 | 	//stream in fluid zone
166 | //#pragma omp parallel for
167 | 	for (i = 0; i <Nx; i++)
168 | 	for (j = 0; j <Ny; j++)
169 | 	{
170 | 		if (flag[i][j] == fluid)
171 | 		{
172 | 			for (k = 0; k <= 8; k++)
173 | 			{
174 | 				int inv_ = inv[k];
175 | 					f_new[i][j][k] = f_old[i + (int)cx[inv_]][j + (int)cy[inv_]][k];
176 | 			}
177 | 		}
178 | 	}
179 | 
180 | 	//calculate macroscopic var
181 | #pragma omp parallel for
182 | 	for (i = 0; i <Nx ; i++)
183 | 	for (j = 0; j <Ny ; j++)
184 | 	{
185 | 			u[i][j] = 0.0;v[i][j] = 0.0;rho[i][j] = 0.0;
186 | 
187 | 			for (k = 0; k <= 8; k++){
188 | 				rho[i][j] += f_new[i][j][k];
189 | 				u[i][j] += cx[k] * f_new[i][j][k];
190 | 				v[i][j] += cy[k] * f_new[i][j][k];
191 | 			}
192 | 
193 | 			if (flag[i][j] == inlet)
194 | 			{
195 | 				rho[i][j] = rho[i][j - 1];
196 | 				u[i][j] = 0.0;
197 | 				v[i][j] = -Uin;
198 | 			}
199 | 			if (flag[i][j] == outlet)
200 | 			{
201 | 				u[i][j] = u[i][j + 1];
202 | 				v[i][j] = v[i][j + 1];
203 | 				rho[i][j] = 1.0;// rho[i][j + 1];
204 | 				
205 | 			}
206 | 			if (flag[i][j] == boundary)
207 | 			{
208 | 				u[i][j] = 0.0;
209 | 				v[i][j] = 0.0;
210 | 			}
211 | 
212 | 			double pi_xx, pi_xy, pi_yy;
213 | 			pi_xx = 0.0;
214 | 			pi_xy = 0.0;
215 | 			pi_yy = 0.0;
216 | 			for (int it = 0; it < 9; ++it)
217 | 			{
218 | 				double fi_ = f_new[i][j][it];
219 | 				double f_eq = feq(rho[i][j], u[i][j], v[i][j], it);
220 | 				pi_xx += cx[it] * cx[it] * (fi_ - f_eq);
221 | 				pi_xy += cx[it] * cy[it] * (fi_ - f_eq);
222 | 				pi_yy += cy[it] * cy[it] * (fi_ - f_eq);
223 | 
224 | 			}
225 | 			double stress = pi_xx*pi_xx + pi_xy*pi_xy*2.0 + pi_yy*pi_yy;
226 | 			double ss_stress = std::sqrt(stress);
227 | 			double ome = computeLocalRelaxationTime(tau, ss_stress, 0.12);
228 | 			double omegaC = 1.0 /ome;
229 | 
230 | 			double omega_les = omegaC;
231 | 
232 | 			for (k = 0; k <= 8; k++)
233 | 				f_old[i][j][k] = (1.0 - omega_les)*f_new[i][j][k]
234 | 					+ omega_les*feq(rho[i][j], u[i][j], v[i][j], k);
235 | 
236 | 			//treat boundary for Dfs
237 | 			if (flag[i][j] == inlet)
238 | 			{
239 | 
240 | 				for (int k = 0; k < 9; ++k)
241 | 				{
242 | 					if (flag[i + (int)cx[k]][j + (int)cy[k]] == fluid)
243 | 						f_old[i][j][k] = feq(rho[i][j], u[i][j], v[i][j], k) +
244 | 						f_old[i + (int)cx[k]][j + (int)cy[k]][k] -
245 | 						feq(rho[i + (int)cx[k]][j + (int)cy[k]],
246 | 						u[i + (int)cx[k]][j + (int)cy[k]],
247 | 						v[i + (int)cx[k]][j + (int)cy[k]],
248 | 						k);
249 | 				}
250 | 			}
251 | 
252 | 			if (flag[i][j] == outlet)
253 | 			{
254 | 				rho[i][j] = 1.0;
255 | 				for (int k = 0; k < 9; ++k)
256 | 				{
257 | 					//if (flag[i + (int)cx[k]][j + (int)cy[k]] == fluid)
258 | 						f_old[i][j][k] = feq(rho[i][j], u[i][j], v[i][j], k) +
259 | 						f_old[i + (int)cx[k]][j + (int)cy[k]][k] -
260 | 						feq(rho[i + (int)cx[k]][j + (int)cy[k]],
261 | 						u[i + (int)cx[k]][j + (int)cy[k]],
262 | 						v[i + (int)cx[k]][j + (int)cy[k]],
263 | 						k);
264 | 				}
265 | 			}
266 | 
267 | 			if (flag[i][j] == boundary)
268 | 			{
269 | 				//rho[i][j] = 1.0;
270 | 				int ip = i + (int)cx[i];
271 | 				int jp = j + (int)cy[i];
272 | 
273 | 				if (i >= 0 && i < Nx&&j >= 0 && j < Ny)
274 | 				{
275 | 					if (flag[i + (int)cx[k]][j + (int)cy[k]] == fluid)
276 | 						f_old[i][j][k] = feq(rho[i + (int)cx[k]][j + (int)cy[k]], 0.0, 0.0, k) +
277 | 						f_old[i + (int)cx[k]][j + (int)cy[k]][k] -
278 | 						feq(rho[i + (int)cx[k]][j + (int)cy[k]],
279 | 						u[i + (int)cx[k]][j + (int)cy[k]],
280 | 						v[i + (int)cx[k]][j + (int)cy[k]],
281 | 						k);
282 | 				}
283 | 			}
284 | 
285 | 
286 | 	}
287 | 
288 | 
289 | 	
290 | 
291 | 	//
292 | 
293 | 
294 | }
295 | 
296 | void Out_file(int m)
297 | {
298 | 	ostringstream name;
299 | 	name << "D:\\output\\cavityA_" << setfill('0') << setw(8) << m << ".plt";
300 | 	ofstream out(name.str().c_str());
301 | 	out << "Title=\"LBM Lid Driven Flow\"\n"
302 | 		<< "VARIABLES=X,Y,U,V,UV,Bound,Rho\n"
303 | 		<< "ZONE T= \"BOX\", I= "
304 | 		<< Nx - 2 << ", J=" << Ny - 2 << ", F=POINT" << endl;
305 | 	int i, j;
306 | 	for (j = 1; j <Ny - 1; j++)
307 | 	for (i = 1; i <Nx - 1; i++)
308 | 	{
309 | 
310 | 		out << double(i) << " " << double(j) << " "
311 | 			<< u[i][j] << " " << v[i][j] << " " << sqrt(u[i][j] * u[i][j] + v[i][j] * v[i][j]) << " " << flag[i][j] << " " << rho[i][j] << endl;
312 | 	}
313 | 	printf("write file end.\n");
314 | }
315 | 


--------------------------------------------------------------------------------
/lbSteadyFlowD3Q19/lbSteadyFlowD3Q19.cpp:
--------------------------------------------------------------------------------
  1 | #include "lbSteadyFlowD3Q19.h"
  2 | 
  3 | 
  4 | int lbSteadyFlowD3Q19::cellIndex(int x, int y, int z)
  5 | {
  6 | 	assert(x >= 0 && x < Nx);
  7 | 	assert(y >= 0 && y < Ny);
  8 | 	assert(z >= 0 && z < Nz);
  9 | 
 10 | 	//check index according to the max index equal N-1
 11 | 	return z + y*Nz + x*Ny*Nz;
 12 | }
 13 | 
 14 | int lbSteadyFlowD3Q19::funcIndex(int x, int y, int z, int i)
 15 | {
 16 | 	assert(x >= 0 && x < Nx);
 17 | 	assert(y >= 0 && y < Ny);
 18 | 	assert(z >= 0 && z < Nz);
 19 | 	assert(i >= 0 && i < latticeDim);
 20 | 
 21 | 	//check index carefully
 22 | 	return (z + y*Nz + x*Ny*Nz)*latticeDim + i;
 23 | }
 24 | 
 25 | void lbSteadyFlowD3Q19::preReadSgn(char* filename)
 26 | {
 27 | //empty
 28 | }
 29 | 
 30 | void lbSteadyFlowD3Q19::setSgnMem()
 31 | {
 32 | 	const int cellNum = Nx*Ny*Nz;
 33 | 	sgn = new short[cellNum];
 34 | 	memset(sgn, 0, sizeof(short)*cellNum);
 35 | }
 36 | 
 37 | void lbSteadyFlowD3Q19::readSgn(char* filename)
 38 | {
 39 | //empty	
 40 | }
 41 | 
 42 | void lbSteadyFlowD3Q19::setMem()
 43 | {
 44 | 	const int cellNum = Nx*Ny*Nz;
 45 | 	const int DfNum = cellNum*latticeDim;
 46 | 
 47 | 	collideField = new double[DfNum];
 48 | 	streamField = new double[DfNum];
 49 | 
 50 | 	flag = new int[cellNum];
 51 | 	latticeUX = new double[cellNum];
 52 | 	latticeUY = new double[cellNum];
 53 | 	latticeUZ = new double[cellNum];
 54 | 	latticeDensity = new double[cellNum];
 55 | 
 56 | 	memset(collideField, 0, sizeof(double)*DfNum);
 57 | 	memset(streamField, 0, sizeof(double)*DfNum);
 58 | 
 59 | 	memset(flag, 0, sizeof(int)*cellNum);
 60 | 	memset(latticeUX, 0, sizeof(double)*cellNum);
 61 | 	memset(latticeUY, 0, sizeof(double)*cellNum);
 62 | 	memset(latticeUZ, 0, sizeof(double)*cellNum);
 63 | 	memset(latticeDensity, 0, sizeof(double)*cellNum);
 64 | 
 65 | }
 66 | 
 67 | void lbSteadyFlowD3Q19::resetMem()
 68 | {
 69 | 	delete[] collideField;
 70 | 	delete[] streamField;
 71 | 
 72 | 	delete[] flag;
 73 | 	delete[] latticeUX;
 74 | 	delete[] latticeUY;
 75 | 	delete[] latticeUZ;
 76 | 	delete[] latticeDensity;
 77 | 
 78 | 	delete[] sgn;
 79 | }
 80 | 
 81 | void lbSteadyFlowD3Q19::initSimuParam()
 82 | {
 83 | 	velocityScale = 100.0;
 84 | 	timeStep = gridLength / velocityScale;
 85 | 
 86 | 
 87 | 	//we should set phyInletU
 88 | 	for (int i = 0; i < 3; ++i)
 89 | 		latticeInletVelocity[i] = phyInletVelocity[i] / velocityScale;
 90 | 
 91 | 	relaxationTime = 3.0*fluidViscosity*timeStep / gridLength / gridLength + 0.5;
 92 | 
 93 | 
 94 | 	printf("inlet velocity physical=(%6.4f,%6.4f,%6.4f)m/s\n",
 95 | 		phyInletVelocity[0], phyInletVelocity[1], phyInletVelocity[2]);
 96 | 
 97 | 	printf("inlet velocity LB=(%6.4f,%6.4f,%6.4f)\n\n",
 98 | 		latticeInletVelocity[0], latticeInletVelocity[1], latticeInletVelocity[2]);
 99 | 
100 | 	printf("grid size=%6.4f m\ntime step=%e s\n\n",
101 | 		gridLength, timeStep);
102 | 
103 | 	printf("fluid viscosity=%e m2/s\ntau=%e\nLES constant=%4.3f\n\n",
104 | 		fluidViscosity, relaxationTime, smagorinskyConstant);
105 | 
106 | 
107 | 
108 | 
109 | }
110 | 
111 | void lbSteadyFlowD3Q19::initSimuVarValue()
112 | {
113 | 	//first we set cell type
114 | 	const int cellNum = Nx*Ny*Nz;
115 | 	int inletNumFirst = 0;//log inlet node num, sometimes no inlet cell is set in sgn grid
116 | 	for (int i = 0; i < cellNum; ++i)
117 | 	{
118 | 		const int curSgn = sgn[i];
119 | 		if (curSgn % 100 == 0 && curSgn != 100)
120 | 			flag[i] = FLUID;
121 | 		else if (curSgn == 100)
122 | 		{
123 | 			flag[i] = INLET;
124 | 			inletNumFirst++;
125 | 		}
126 | 		else
127 | 			flag[i] = NO_SLIP;
128 | 	}
129 | 
130 | 	if (inletNumFirst == 0)
131 | 	{
132 | 		printf("no inlet cell is set!\n");
133 | 
134 | 		//now we find inlet as top fluid cell
135 | 		int findInlet = false;
136 | 		int inletPosZ;
137 | 		for (int z = Nz - 1; z >= 0 && !findInlet; z--)
138 | 		for (int x = 0; x < Nx&&!findInlet; ++x)
139 | 		for (int y = 0; y < Ny&&!findInlet; ++y)
140 | 		{
141 | 			const int idx = cellIndex(x, y, z);
142 | 			if (sgn[idx] % 100 == 0)
143 | 			{
144 | 				inletPosZ = z;
145 | 				findInlet = true;
146 | 			}
147 | 		}
148 | 		//now we set inlet cell on top fluid cell
149 | 		for (int x = 0; x < Nx; ++x)
150 | 		for (int y = 0; y < Ny; ++y)
151 | 		{
152 | 			const int z = inletPosZ;
153 | 			const int idx = cellIndex(x, y, z);
154 | 			if (sgn[idx] % 100 == 0)
155 | 				flag[idx] = INLET;
156 | 		}
157 | 	}
158 | 
159 | 	//now the riser is set as fluid, we set outlet according to sgn
160 | 
161 | 	int findTopRiser = false;
162 | 	int topRiserZ;
163 | 	for (int z = Nz - 1; z >= 0 && !findTopRiser; z--)
164 | 	for (int x = 0; x < Nx&&!findTopRiser; ++x)
165 | 	for (int y = 0; y < Ny&&!findTopRiser; ++y)
166 | 	{
167 | 		const int idx = cellIndex(x, y, z);
168 | 
169 | 		if (sgn[idx] == 4000)
170 | 		{
171 | 			topRiserZ = z;
172 | 			findTopRiser = true;
173 | 		}
174 | 	}
175 | 
176 | 	printf("riser top z index=%d\n", topRiserZ);
177 | 
178 | 	int outletNum = 0;
179 | 	for (int x = 0; x < Nx; ++x)
180 | 	for (int y = 0; y < Ny; ++y)
181 | 	{
182 | 		int z = topRiserZ;
183 | 		const int idx = cellIndex(x, y, z);
184 | 		if (sgn[idx] == 4000)
185 | 		{
186 | 			flag[idx] = OUTLET;
187 | 			outletNum++;
188 | 		}
189 | 	}
190 | 
191 | 	printf("outlet node num is %d\n", outletNum);
192 | 
193 | 	//now we cal inlet z index and count total num of diff type cell
194 | 	int inletIndexZ;
195 | 	int inletNumber = 0;
196 | 	int outletNumber = 0;
197 | 	int fluidNumber = 0;
198 | 	int noSlipNumber = 0;
199 | 
200 | 	for (int x = 0; x < Nx; ++x)
201 | 	for (int y = 0; y < Ny; ++y)
202 | 	for (int z = 0; z < Nz; ++z)
203 | 	{
204 | 		const int idx = cellIndex(x, y, z);
205 | 		const int curFlag = flag[idx];
206 | 		if (curFlag == FLUID)
207 | 			fluidNumber++;
208 | 		else if (curFlag == INLET)
209 | 		{
210 | 			inletNumber++;
211 | 			inletIndexZ = z;
212 | 		}
213 | 		else if (curFlag == OUTLET)
214 | 			outletNumber++;
215 | 		else if (curFlag == NO_SLIP)
216 | 			noSlipNumber++;
217 | 	}
218 | 	int totalNum = inletNumber + outletNumber + noSlipNumber + fluidNumber;
219 | 	printf("cell type count:\n");
220 | 	printf("inlet=%d\noutlet=%d\nnoSlip=%d\nfluid=%d\ncell sum=%d\n",
221 | 		inletNumber, outletNumber, noSlipNumber, fluidNumber, totalNum);
222 | 	printf("inlet Z index=%d\n", inletIndexZ);
223 | 
224 | 	if (totalNum == Nx*Ny*Nz)
225 | 		printf("cell type sum right.\n");
226 | 	else
227 | 		printf("cell type sum WRONG!\n");
228 | }
229 | 
230 | void lbSteadyFlowD3Q19::writeData(const char* filename)
231 | {
232 | 	int varnum = 10;
233 | 	fp = fopen(filename, "wb");
234 | 	assert(fp != NULL);
235 | 	WriteNchar("#!TDV102", 8);
236 | 	Writeint(1);
237 | 	WriteString("");//The TITLE.
238 | 
239 | 	Writeint(varnum);//Number of variables (NumVar) in the datafile.
240 | 
241 | 	WriteString("I");
242 | 	WriteString("J");
243 | 	WriteString("K");
244 | 
245 | 	WriteString("U");
246 | 	WriteString("V");
247 | 	WriteString("W");
248 | 
249 | 	WriteString("Velovity");
250 | 	WriteString("VOF");
251 | 	WriteString("Pressure");
252 | 	WriteString("CellType");
253 | 
254 | 	//WriteString("mat");
255 | 
256 | 	Writefloat(299.0);
257 | 	WriteString("ZONE 001");//Zone name.
258 | 	Writeint(-1);
259 | 	Writeint(0);//Zone type: ordered
260 | 	Writedouble(0.0);
261 | 	Writefloat(0.0);
262 | 
263 | 	Writeint(Nx);
264 | 	Writeint(Ny);
265 | 	Writeint(Nz);
266 | 
267 | 	Writeint(0);
268 | 	Writefloat(357.0);
269 | 	Writefloat(299.0);
270 | 	for (int it = 0; it<varnum; it++)
271 | 	{
272 | 		Writeint(1);//Variable data format, 1=Float
273 | 	}
274 | 	Writeint(0);
275 | 	Writeint(-1);
276 | 
277 | 
278 | 	//write i,j,k
279 | 	//X index
280 | 	for (int z = 0; z < Nz; ++z)
281 | 	for (int y = 0; y < Ny; ++y)
282 | 	for (int x = 0; x < Nx; ++x)
283 | 	{
284 | 		Writefloat((float)x);
285 | 	}
286 | 
287 | 	//Y index
288 | 	for (int z = 0; z < Nz; ++z)
289 | 	for (int y = 0; y < Ny; ++y)
290 | 	for (int x = 0; x < Nx; ++x)
291 | 	{
292 | 		Writefloat((float)y);
293 | 	}
294 | 
295 | 	//Z index
296 | 	for (int z = 0; z < Nz; ++z)
297 | 	for (int y = 0; y < Ny; ++y)
298 | 	for (int x = 0; x < Nx; ++x)
299 | 	{
300 | 		Writefloat((float)z);
301 | 
302 | 	}
303 | 
304 | 	//Ux
305 | 	for (int z = 0; z < Nz; ++z)
306 | 	for (int y = 0; y < Ny; ++y)
307 | 	for (int x = 0; x < Nx; ++x)
308 | 	{
309 | 		const int idx = cellIndex(x, y, z);
310 | 		Writefloat((float)(velocityScale *latticeUX[idx]));
311 | 	}
312 | 
313 | 	//Uy
314 | 	for (int z = 0; z < Nz; ++z)
315 | 	for (int y = 0; y < Ny; ++y)
316 | 	for (int x = 0; x < Nx; ++x)
317 | 	{
318 | 		const int idx = cellIndex(x, y, z);
319 | 		Writefloat((float)(velocityScale* latticeUY[idx]));
320 | 	}
321 | 
322 | 	//Uz
323 | 	for (int z = 0; z < Nz; ++z)
324 | 	for (int y = 0; y < Ny; ++y)
325 | 	for (int x = 0; x < Nx; ++x)
326 | 	{
327 | 		const int idx = cellIndex(x, y, z);
328 | 		Writefloat((float)(velocityScale* latticeUZ[idx]));
329 | 	}
330 | 
331 | 	//UU
332 | 	for (int z = 0; z < Nz; ++z)
333 | 	for (int y = 0; y < Ny; ++y)
334 | 	for (int x = 0; x < Nx; ++x)
335 | 	{
336 | 		const int idx = cellIndex(x, y, z);
337 | 		double uMag = sqrt(
338 | 			latticeUX[idx] * latticeUX[idx] +
339 | 			latticeUY[idx] * latticeUY[idx] +
340 | 			latticeUZ[idx] * latticeUZ[idx]);
341 | 
342 | 		Writefloat((float)(velocityScale*uMag));
343 | 	}
344 | 
345 | 	for (int z = 0; z < Nz; ++z)
346 | 	for (int y = 0; y < Ny; ++y)
347 | 	for (int x = 0; x < Nx; ++x)
348 | 	{
349 | 		const int idx = cellIndex(x, y, z);
350 | 		Writefloat((float)1.0f);
351 | 	}
352 | 
353 | 	for (int z = 0; z < Nz; ++z)
354 | 	for (int y = 0; y < Ny; ++y)
355 | 	for (int x = 0; x < Nx; ++x)
356 | 	{
357 | 		const int idx = cellIndex(x, y, z);
358 | 		Writefloat((float)latticeDensity[idx]);
359 | 	}
360 | 
361 | 	for (int z = 0; z < Nz; ++z)
362 | 	for (int y = 0; y < Ny; ++y)
363 | 	for (int x = 0; x < Nx; ++x)
364 | 	{
365 | 		const int idx = cellIndex(x, y, z);
366 | 		Writefloat((float)flag[idx]);
367 | 	}
368 | 
369 | 	printf("write data finished.\n");
370 | 
371 | 	fclose(fp);
372 | }
373 | 
374 | void lbSteadyFlowD3Q19::initDfsValue()
375 | {
376 | 	printf("init DFs begin.\n");
377 | 
378 | 	for (int x = 0; x < Nx; ++x)
379 | 	for (int y = 0; y < Ny; ++y)
380 | 	for (int z = 0; z < Nz; ++z)
381 | 	{
382 | 		const int cellIdx = cellIndex(x, y, z);
383 | 
384 | 		latticeUX[cellIdx] = 0.0;
385 | 		latticeUY[cellIdx] = 0.0;
386 | 		latticeUZ[cellIdx] = 0.0;
387 | 
388 | 		latticeDensity[cellIdx] = 1.0;//set 1.0 check here
389 | 
390 | 		for (int i = 0; i < latticeDim; ++i)
391 | 		{
392 | 			const int idx = funcIndex(x, y, z, i);
393 | 
394 | 			streamField[idx] = latticeWeight[i];
395 | 			collideField[idx] = latticeWeight[i];
396 | 		}
397 | 	}
398 | 
399 | 	printf("init DFs finished.\n");
400 | }
401 | 
402 | void lbSteadyFlowD3Q19::streamDfs()
403 | {
404 | #pragma omp parallel for
405 | 	for (int x = 0; x < Nx; ++x)
406 | 	for (int y = 0; y < Ny; ++y)
407 | 	for (int z = 0; z < Nz; ++z)
408 | 	{
409 | 		if (flag[cellIndex(x, y, z)] == FLUID)
410 | 		{
411 | 			for (int i = 0; i < latticeDim; ++i)
412 | 			{
413 | 				const int inv = latticeDim - 1 - i;
414 | 				const int cellX = funcIndex(x, y, z, i);
415 | 				const int cellXsubCi = funcIndex(
416 | 					x + latticeVelocity[inv][0],
417 | 					y + latticeVelocity[inv][1],
418 | 					z + latticeVelocity[inv][2],
419 | 					i);
420 | 
421 | 				streamField[cellX] = collideField[cellXsubCi];
422 | 			}
423 | 		}
424 | 	}
425 | #define USE_COPY_
426 | #ifdef USE_COPY_
427 | #pragma omp parallel for
428 | 	for (int x = 0; x < Nx; ++x)
429 | 	for (int y = 0; y < Ny; ++y)
430 | 	for (int z = 0; z < Nz; ++z)
431 | 	for (int i = 0; i < latticeDim; ++i)
432 | 	{
433 | 		const int dfIndex = funcIndex(x, y, z, i);
434 | 		collideField[dfIndex] = streamField[dfIndex];
435 | 	}
436 | #else
437 | 
438 | 	double* SW;
439 | 
440 | 	SW = collideField;
441 | 	collideField = streamField;
442 | 	streamField = SW;
443 | 
444 | #endif
445 | }
446 | 
447 | void lbSteadyFlowD3Q19::calMarcoVar()
448 | {
449 | #pragma omp parallel for
450 | 	for (int x = 0; x < Nx; ++x)
451 | 	for (int y = 0; y < Ny; ++y)
452 | 	for (int z = 0; z < Nz; ++z)
453 | 	{
454 | 		const int curCell = cellIndex(x, y, z);
455 | 
456 | 		latticeUX[curCell] = 0.0;
457 | 		latticeUY[curCell] = 0.0;
458 | 		latticeUZ[curCell] = 0.0;
459 | 		latticeDensity[curCell] = 0.0;
460 | 
461 | 		for (int i = 0; i < latticeDim; ++i)
462 | 		{
463 | 			const double fi = collideField[funcIndex(x, y, z, i)];
464 | 
465 | 			latticeDensity[curCell] += fi;
466 | 			latticeUX[curCell] += (double)latticeVelocity[i][0] * fi;//check here
467 | 			latticeUY[curCell] += (double)latticeVelocity[i][1] * fi;
468 | 			latticeUZ[curCell] += (double)latticeVelocity[i][2] * fi;
469 | 		}
470 | 
471 | 		if (flag[curCell] == INLET)
472 | 		{
473 | 			//here we define Z negative inlet velocity,  thus the z-1 near cell is fluid
474 | 			//in the future version, we will find the nearby fluid cell 
475 | 			//and set density value as near fluid cell
476 | 			latticeDensity[curCell] = latticeDensity[cellIndex(x, y, z - 1)];
477 | 			latticeUX[curCell] = latticeInletVelocity[0];
478 | 			latticeUY[curCell] = latticeInletVelocity[1];
479 | 			latticeUZ[curCell] = latticeInletVelocity[2];
480 | 
481 | 		}
482 | 		else if (flag[curCell] == OUTLET)
483 | 		{
484 | 			//here we have the same set direction for outlet 
485 | 			//the outlet is at the top of the fluid cell
486 | 			//as for density we will set in DFs treatment function 
487 | 			latticeUX[curCell] = latticeUX[cellIndex(x, y, z - 1)];
488 | 			latticeUY[curCell] = latticeUY[cellIndex(x, y, z - 1)];
489 | 			latticeUZ[curCell] = latticeUZ[cellIndex(x, y, z - 1)];
490 | 		}
491 | 		else if (flag[curCell] == NO_SLIP)
492 | 		{
493 | 			latticeUX[curCell] = 0.0;
494 | 			latticeUY[curCell] = 0.0;
495 | 			latticeUZ[curCell] = 0.0;
496 | 		}
497 | 
498 | 	}
499 | 
500 | 
501 | }
502 | 
503 | void lbSteadyFlowD3Q19::collideDfs()
504 | {
505 | #pragma omp parallel for
506 | 	for (int x = 0; x < Nx; ++x)
507 | 	for (int y = 0; y < Ny; ++y)
508 | 	for (int z = 0; z < Nz; ++z)
509 | 	{
510 | 		const int curCell = cellIndex(x, y, z);
511 | 		if (flag[curCell] == FLUID)
512 | 		{
513 | 			//now we compuate norm stress 
514 | 			double curVelocity[3] = { latticeUX[curCell], latticeUY[curCell], latticeUZ[curCell] };
515 | 
516 | 			double stress = 0.0;
517 | 			for (int alpha = 0; alpha < 3; ++alpha)
518 | 			for (int beta = 0; beta < 3; ++beta)
519 | 			{
520 | 				double elem = 0.0;
521 | 				for (int i = 0; i < latticeDim; ++i)
522 | 				{
523 | 					double feq = calFeq(latticeDensity[curCell], curVelocity, i);
524 | 					double fi = collideField[funcIndex(x, y, z, i)];
525 | 
526 | 					elem += (double)latticeVelocity[i][alpha] * (double)latticeVelocity[i][beta] * (fi - feq);
527 | 				}
528 | 
529 | 				stress += elem*elem;
530 | 			}
531 | 
532 | 			stress = sqrt(stress);
533 | 
534 | 			//now we compute relaxation time
535 | 			double tauLES =
536 | 				computeLocalRelaxationTime(relaxationTime, stress, smagorinskyConstant);
537 | 
538 | 			double omegaLES = 1.0 / tauLES;
539 | 
540 | 			//now we compute collide Dfs
541 | 			for (int i = 0; i < latticeDim; ++i)
542 | 			{
543 | 				const int idx = funcIndex(x, y, z, i);
544 | 
545 | 				collideField[idx] = (1.0 - omegaLES)*collideField[idx] +
546 | 					omegaLES*calFeq(latticeDensity[curCell], curVelocity, i);
547 | 			}
548 | 		}
549 | 	}
550 | 
551 | }
552 | 
553 | void lbSteadyFlowD3Q19::treatDfsBoundary()
554 | {
555 | #pragma omp parallel for
556 | 	for (int x = 0; x < Nx; ++x)
557 | 	for (int y = 0; y < Ny; ++y)
558 | 	for (int z = 0; z < Nz; ++z)
559 | 	{
560 | 		const int curCell = cellIndex(x, y, z);
561 | 
562 | 		if (flag[curCell] == INLET)
563 | 		{
564 | 			for (int i = 0; i < latticeDim; ++i)
565 | 			{
566 | 				const int Xci = x + latticeVelocity[i][0];
567 | 				const int Yci = y + latticeVelocity[i][1];
568 | 				const int Zci = z + latticeVelocity[i][2];
569 | 
570 | 				const int nearIdx = cellIndex(Xci, Yci, Zci);
571 | 				double curU[3] = { latticeUX[curCell], latticeUY[curCell], latticeUZ[curCell] };
572 | 				double nearU[3] = { latticeUX[nearIdx], latticeUY[nearIdx], latticeUZ[nearIdx] };
573 | 
574 | 				if (flag[nearIdx] == FLUID)
575 | 				{
576 | 					collideField[funcIndex(x, y, z, i)] =
577 | 						calFeq(latticeDensity[curCell], curU, i) +
578 | 						collideField[funcIndex(Xci, Yci, Zci, i)] - calFeq(latticeDensity[nearIdx], nearU, i);
579 | 				}
580 | 
581 | 			}//for i=0-Q
582 | 		}//if inlet
583 | 
584 | 		if (flag[curCell] == OUTLET)
585 | 		{
586 | 			latticeDensity[curCell] = 1.0;//here we set density equal 1.0 as atm pressure
587 | 
588 | 			for (int i = 0; i < latticeDim; ++i)
589 | 			{
590 | 				const int Xci = x + latticeVelocity[i][0];
591 | 				const int Yci = y + latticeVelocity[i][1];
592 | 				const int Zci = z + latticeVelocity[i][2];
593 | 
594 | 				const int nearIdx = cellIndex(Xci, Yci, Zci);
595 | 				double curU[3] = { latticeUX[curCell], latticeUY[curCell], latticeUZ[curCell] };
596 | 				double nearU[3] = { latticeUX[nearIdx], latticeUY[nearIdx], latticeUZ[nearIdx] };
597 | 
598 | 				if (flag[nearIdx] == FLUID)
599 | 				{
600 | 					collideField[funcIndex(x, y, z, i)] =
601 | 						calFeq(latticeDensity[curCell], curU, i) +
602 | 						collideField[funcIndex(Xci, Yci, Zci, i)] - calFeq(latticeDensity[nearIdx], nearU, i);
603 | 				}
604 | 
605 | 			}//for i=0-Q
606 | 		}
607 | 
608 | 
609 | 		if (flag[curCell] == NO_SLIP)
610 | 		{
611 | 			for (int i = 0; i < latticeDim; ++i)
612 | 			{
613 | 				const int Xci = x + latticeVelocity[i][0];
614 | 				const int Yci = y + latticeVelocity[i][1];
615 | 				const int Zci = z + latticeVelocity[i][2];
616 | 
617 | 				if (Xci >= 0 && Xci < Nx&&Yci >= 0 && Yci < Ny&&Zci >= 0 && Zci < Nz)
618 | 				{
619 | 					const int nearIdx = cellIndex(Xci, Yci, Zci);
620 | 					double curU[3] = { 0.0, 0.0, 0.0 };
621 | 					double nearU[3] = { latticeUX[nearIdx], latticeUY[nearIdx], latticeUZ[nearIdx] };
622 | 
623 | 					if (flag[nearIdx] == FLUID)
624 | 					{
625 | 						collideField[funcIndex(x, y, z, i)] =
626 | 							calFeq(latticeDensity[nearIdx], curU, i) +
627 | 							collideField[funcIndex(Xci, Yci, Zci, i)] - calFeq(latticeDensity[nearIdx], nearU, i);
628 | 					}
629 | 				}
630 | 			}//for i=0-Q
631 | 		}
632 | 
633 | 	}
634 | 
635 | }
636 | 
637 | double lbSteadyFlowD3Q19::calFeq(double density, double velocity[3], int i)
638 | {
639 | 	double cu =
640 | 		latticeVelocity[i][0] * velocity[0] +
641 | 		latticeVelocity[i][1] * velocity[1] +
642 | 		latticeVelocity[i][2] * velocity[2];
643 | 
644 | 	double uu =
645 | 		velocity[0] * velocity[0] +
646 | 		velocity[1] * velocity[1] +
647 | 		velocity[2] * velocity[2];
648 | 
649 | 	double feq = latticeWeight[i] * (density + 3.0*cu + 4.5*cu*cu - 1.5*uu);
650 | 
651 | 	return feq;
652 | }
653 | 
654 | double lbSteadyFlowD3Q19::computeLocalRelaxationTime(double tau_, double stressTensorNorm, double smagConstant)
655 | {
656 | 	const double viscosity = (tau_ - 0.5) / 3.0;
657 | 	const double smagSqr = smagConstant * smagConstant;
658 | 	const double stress =
659 | 		(std::sqrt(viscosity * viscosity + 18.0 * smagSqr * stressTensorNorm) - viscosity) /
660 | 		(6.0 * smagSqr);
661 | 
662 | 	return 3.0 * (viscosity + smagSqr * stress) + 0.5;
663 | }
664 | 
665 | void lbSteadyFlowD3Q19::getVelocityField(double* velocityField)
666 | {
667 | #pragma omp parallel for
668 | 	for (int i = 0; i < Nx*Ny*Nz; ++i)
669 | 	{
670 | 		velocityField[i] = sqrt(
671 | 			latticeUX[i] * latticeUX[i] +
672 | 			latticeUY[i] * latticeUY[i] +
673 | 			latticeUZ[i] * latticeUZ[i]);
674 | 	}
675 | 
676 | }
677 | 
678 | int lbSteadyFlowD3Q19::getSize()
679 | {
680 | 	return Nx*Ny*Nz;
681 | }
682 | 
683 | lbSteadyFlowD3Q19::lbSteadyFlowD3Q19()
684 | {
685 | 	phyInletVelocity[0] = 0.0;
686 | 	phyInletVelocity[1] = 0.0;
687 | 	phyInletVelocity[2] = -5.0;
688 | 
689 | 	smagorinskyConstant = 0.12;
690 | 	fluidViscosity = 1.0e-6;
691 | 	gridLength = 0.01;
692 | 
693 | 	FLUID = 0;
694 | 	INLET = 1;
695 | 	OUTLET = 2;
696 | 	NO_SLIP = 3;
697 | 
698 | 	//fp = NULL;
699 | }
700 | 
701 | lbSteadyFlowD3Q19::~lbSteadyFlowD3Q19()
702 | {
703 | }
704 | 
705 | const double lbSteadyFlowD3Q19::latticeWeight[19] =
706 | { (1. / 36), (1. / 36), (2. / 36), (1. / 36), (1. / 36),
707 | (1. / 36), (2. / 36), (1. / 36), (2. / 36), (12. / 36),
708 | (2. / 36), (1. / 36), (2. / 36), (1. / 36), (1. / 36),
709 | (1. / 36), (2. / 36), (1. / 36), (1. / 36) };
710 | 
711 | const int lbSteadyFlowD3Q19::latticeVelocity[19][3] = {
712 | 	{ 0, -1, -1 }, { -1, 0, -1 }, { 0, 0, -1 }, { 1, 0, -1 }, { 0, 1, -1 },
713 | 	{ -1, -1, 0 }, { 0, -1, 0 }, { 1, -1, 0 }, { -1, 0, 0 }, { 0, 0, 0 },
714 | 	{ 1, 0, 0 }, { -1, 1, 0 }, { 0, 1, 0 }, { 1, 1, 0 }, { 0, -1, 1 },
715 | 	{ -1, 0, 1 }, { 0, 0, 1 }, { 1, 0, 1 }, { 0, 1, 1 } };
716 | 


--------------------------------------------------------------------------------