OilfieldToolsNet/LBPM
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Updated CPU branch

Browse Source
This commit is contained in:
James McClure
2014-01-27 11:43:24 -05:00
parent 32cacd8afd
commit 42338802c5
16 changed files with 5921 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

771
cpu/Color.cpp
View File

@@ -1,10 +1,18 @@
#include <math.h> #include <math.h>
extern void InitDenColor(char *ID, double *Den, double *Phi, double das, double dbs, int N) extern "C" void dvc_InitDenColor(char *ID, double *Den, double *Phi, double das, double dbs, int Nx, int Ny, int Nz, int S)
{ {
int n; int i,j,k,n,N;
N = Nx*Ny*Nz;
for (n=0; n<N; n++){ for (n=0; n<N; n++){
//.......Back out the 3-D indices for node n..............
k = n/(Nx*Ny);
j = (n-Nx*Ny*k)/Nx;
i = n-Nx*Ny*k-Nx*j;
if ( ID[n] == 1){ if ( ID[n] == 1){
Den[2*n] = 1.0; Den[2*n] = 1.0;
Den[2*n+1] = 0.0; Den[2*n+1] = 0.0;
@@ -20,46 +28,53 @@ extern void InitDenColor(char *ID, double *Den, double *Phi, double das, double
Den[2*n+1] = dbs; Den[2*n+1] = dbs;
Phi[n] = (das-dbs)/(das+dbs); Phi[n] = (das-dbs)/(das+dbs);
} }
if (i == 0 || j == 0 || k == 0 || i == Nx-1 || j == Ny-1 || k == Nz-1){
Den[2*n] = 0.0;
Den[2*n+1] = 0.0;
}
} }
} }
extern void InitD3Q19(char *ID, double *f_even, double *f_odd, int Nx, int Ny, int Nz) extern "C" void dvc_InitDenColorDistance(char *ID, double *Den, double *Phi, double *Distance,
double das, double dbs, double beta, double xp, int Nx, int Ny, int Nz, int S)
{ {
int n,N; int i,j,k,n,N;
double d;
N = Nx*Ny*Nz; N = Nx*Ny*Nz;
for (n=0; n<N; n++){ for (n=0; n<N; n++){
if (ID[n] > 0){
f_even[n] = 0.3333333333333333; //.......Back out the 3-D indices for node n..............
f_odd[n] = 0.055555555555555555; //double(100*n)+1.f; k = n/(Nx*Ny);
f_even[N+n] = 0.055555555555555555; //double(100*n)+2.f; j = (n-Nx*Ny*k)/Nx;
f_odd[N+n] = 0.055555555555555555; //double(100*n)+3.f; i = n-Nx*Ny*k-Nx*j;
f_even[2*N+n] = 0.055555555555555555; //double(100*n)+4.f;
f_odd[2*N+n] = 0.055555555555555555; //double(100*n)+5.f; if ( ID[n] == 1){
f_even[3*N+n] = 0.055555555555555555; //double(100*n)+6.f; Den[2*n] = 1.0;
f_odd[3*N+n] = 0.0277777777777778; //double(100*n)+7.f; Den[2*n+1] = 0.0;
f_even[4*N+n] = 0.0277777777777778; //double(100*n)+8.f; Phi[n] = 1.0;
f_odd[4*N+n] = 0.0277777777777778; //double(100*n)+9.f; }
f_even[5*N+n] = 0.0277777777777778; //double(100*n)+10.f; else if ( ID[n] == 2){
f_odd[5*N+n] = 0.0277777777777778; //double(100*n)+11.f; Den[2*n] = 0.0;
f_even[6*N+n] = 0.0277777777777778; //double(100*n)+12.f; Den[2*n+1] = 1.0;
f_odd[6*N+n] = 0.0277777777777778; //double(100*n)+13.f; Phi[n] = -1.0;
f_even[7*N+n] = 0.0277777777777778; //double(100*n)+14.f;
f_odd[7*N+n] = 0.0277777777777778; //double(100*n)+15.f;
f_even[8*N+n] = 0.0277777777777778; //double(100*n)+16.f;
f_odd[8*N+n] = 0.0277777777777778; //double(100*n)+17.f;
f_even[9*N+n] = 0.0277777777777778; //double(100*n)+18.f;
} }
else{ else{
for(int q=0; q<9; q++){ Den[2*n] = das;
f_even[q*N+n] = -1.0; Den[2*n+1] = dbs;
f_odd[q*N+n] = -1.0; Phi[n] = (das-dbs)/(das+dbs);
} d = fabs(Distance[n]);
f_even[9*N+n] = -1.0; Phi[n] = (2.f*(exp(-2.f*beta*(d+xp)))/(1.f+exp(-2.f*beta*(d+xp))) - 1.f);
}
if (i == 0 || j == 0 || k == 0 || i == Nx-1 || j == Ny-1 || k == Nz-1){
Den[2*n] = 0.0;
Den[2*n+1] = 0.0;
} }
} }
} }
extern void Compute_VELOCITY(char *ID, double *disteven, double *distodd, double *vel, int Nx, int Ny, int Nz)
extern "C" void dvc_Compute_VELOCITY(char *ID, double *disteven, double *distodd, double *vel, int Nx, int Ny, int Nz, int S)
{ {
int n,N; int n,N;
// distributions // distributions
@@ -70,7 +85,6 @@ extern void Compute_VELOCITY(char *ID, double *disteven, double *distodd, double
N = Nx*Ny*Nz; N = Nx*Ny*Nz;
for (n=0; n<N; n++){ for (n=0; n<N; n++){
if (ID[n] > 0){ if (ID[n] > 0){
//........................................................................ //........................................................................
// Registers to store the distributions // Registers to store the distributions
@@ -108,10 +122,54 @@ extern void Compute_VELOCITY(char *ID, double *disteven, double *distodd, double
} }
} }
extern "C" void dvc_ComputePressureD3Q19(char *ID, double *disteven, double *distodd, double *Pressure,
int Nx, int Ny, int Nz, int S)
{
int n,N;
// distributions
double f0,f1,f2,f3,f4,f5,f6,f7,f8,f9;
double f10,f11,f12,f13,f14,f15,f16,f17,f18;
N = Nx*Ny*Nz;
for (n=0; n<N; n++){
if (ID[n] > 0){
//........................................................................
// Registers to store the distributions
//........................................................................
f0 = disteven[n];
f2 = disteven[N+n];
f4 = disteven[2*N+n];
f6 = disteven[3*N+n];
f8 = disteven[4*N+n];
f10 = disteven[5*N+n];
f12 = disteven[6*N+n];
f14 = disteven[7*N+n];
f16 = disteven[8*N+n];
f18 = disteven[9*N+n];
//........................................................................
f1 = distodd[n];
f3 = distodd[1*N+n];
f5 = distodd[2*N+n];
f7 = distodd[3*N+n];
f9 = distodd[4*N+n];
f11 = distodd[5*N+n];
f13 = distodd[6*N+n];
f15 = distodd[7*N+n];
f17 = distodd[8*N+n];
//.................Compute the velocity...................................
Pressure[n] = 0.3333333333333333*(f0+f2+f1+f4+f3+f6+f5+f8+f7+f10+
f9+f12+f11+f14+f13+f16+f15+f18+f17);
}
}
}
//************************************************************************* //*************************************************************************
//************************************************************************* //*************************************************************************
extern void PressureBC_inlet(double *disteven, double *distodd, double din, extern "C" void dvc_PressureBC_inlet(double *disteven, double *distodd, double din,
int Nx, int Ny, int Nz) int Nx, int Ny, int Nz, int S)
{ {
int n,N; int n,N;
// distributions // distributions
@@ -161,13 +219,13 @@ extern void PressureBC_inlet(double *disteven, double *distodd, double din,
// Determine the outlet flow velocity // Determine the outlet flow velocity
uz = 1.0 - (f0+f4+f3+f2+f1+f8+f7+f9+ f10 + uz = 1.0 - (f0+f4+f3+f2+f1+f8+f7+f9+ f10 +
2*(f5+ f15+f18+f11+f14))/din; 2*(f5+ f15+f18+f11+f14))/din;
// Set the unknown distributions: // Set the unknown distributions:
f6 = f5 + 0.3333333333333333*din*uz; f6 = f5 + 0.3333333333333333*din*uz;
f16 = f15 + 0.1666666666666667*din*uz; f16 = f15 + 0.1666666666666667*din*uz;
f17 = f16 + f4 - f3-f15+f18+f8-f7 +f9-f10; f17 = f16 + f4 - f3-f15+f18+f8-f7 +f9-f10;
f12= (din*uz+f5+ f15+f18+f11+f14-f6-f16-f17-f2+f1-f14+f11-f8+f7+f9-f10)*0.5; f12= (din*uz+f5+ f15+f18+f11+f14-f6-f16-f17-f2+f1-f14+f11-f8+f7+f9-f10)*0.5;
f13= din*uz+f5+ f15+f18+f11+f14-f6-f16-f17-f12; f13= din*uz+f5+ f15+f18+f11+f14-f6-f16-f17-f12;
//........Store in "opposite" memory location.......... //........Store in "opposite" memory location..........
disteven[3*N+n] = f6; disteven[3*N+n] = f6;
@@ -179,8 +237,8 @@ extern void PressureBC_inlet(double *disteven, double *distodd, double din,
} }
} }
extern void PressureBC_outlet(double *disteven, double *distodd, double dout, extern "C" void dvc_PressureBC_outlet(double *disteven, double *distodd, double dout,
int Nx, int Ny, int Nz, int S, int outlet) int Nx, int Ny, int Nz, int S, int outlet)
{ {
int n,N; int n,N;
// distributions // distributions
@@ -191,7 +249,7 @@ extern void PressureBC_outlet(double *disteven, double *distodd, double dout,
N = Nx*Ny*Nz; N = Nx*Ny*Nz;
// Loop over the boundary - threadblocks delineated by start...finish // Loop over the boundary - threadblocks delineated by start...finish
for ( n=0; n<N; n++){ for (n=outlet; n<N; n++){
//........................................................................ //........................................................................
// Read distributions from "opposite" memory convention // Read distributions from "opposite" memory convention
@@ -246,7 +304,7 @@ extern void PressureBC_outlet(double *disteven, double *distodd, double dout,
} }
} }
//************************************************************************* //*************************************************************************
extern void ComputeColorGradient(char *ID, double *phi, double *ColorGrad, int Nx, int Ny, int Nz) extern "C" void dvc_ComputeColorGradient(char *ID, double *phi, double *ColorGrad, int Nx, int Ny, int Nz, int S)
{ {
int n,N,i,j,k,nn; int n,N,i,j,k,nn;
// distributions // distributions
@@ -259,7 +317,8 @@ extern void ComputeColorGradient(char *ID, double *phi, double *ColorGrad, int N
N = Nx*Ny*Nz; N = Nx*Ny*Nz;
for ( n=0; n<N; n++){ for (n=0; n<N; n++){
//.......Back out the 3-D indices for node n.............. //.......Back out the 3-D indices for node n..............
k = n/(Nx*Ny); k = n/(Nx*Ny);
j = (n-Nx*Ny*k)/Nx; j = (n-Nx*Ny*k)/Nx;
@@ -365,16 +424,16 @@ extern void ComputeColorGradient(char *ID, double *phi, double *ColorGrad, int N
// ny = ny/C; // ny = ny/C;
// nz = nz/C; // nz = nz/C;
//...Store the Color Gradient.................... //...Store the Color Gradient....................
ColorGrad[3*n] = nx; ColorGrad[n] = nx;
ColorGrad[3*n+1] = ny; ColorGrad[N+n] = ny;
ColorGrad[3*n+2] = nz; ColorGrad[2*N+n] = nz;
//............................................... //...............................................
} }
} }
//************************************************************************* //*************************************************************************
extern void ColorCollide( char *ID, double *disteven, double *distodd, double *ColorGrad, extern "C" void dvc_ColorCollide( char *ID, double *disteven, double *distodd, double *ColorGrad,
double *Velocity, int Nx, int Ny, int Nz, double rlx_setA, double rlx_setB, double *Velocity, int Nx, int Ny, int Nz, int S,double rlx_setA, double rlx_setB,
double alpha, double beta, double Fx, double Fy, double Fz, bool pBC) double alpha, double beta, double Fx, double Fy, double Fz, bool pBC)
{ {
int n,N; int n,N;
@@ -390,15 +449,16 @@ extern void ColorCollide( char *ID, double *disteven, double *distodd, double *C
N = Nx*Ny*Nz; N = Nx*Ny*Nz;
char id; char id;
for ( n=0; n<N; n++){ for (n=0; n<N; n++){
id = ID[n]; id = ID[n];
if (id > 0){ if (id > 0){
// Retrieve the color gradient // Retrieve the color gradient
nx = ColorGrad[3*n]; nx = ColorGrad[n];
ny = ColorGrad[3*n+1]; ny = ColorGrad[N+n];
nz = ColorGrad[3*n+2]; nz = ColorGrad[2*N+n];
//...........Normalize the Color Gradient................................. //...........Normalize the Color Gradient.................................
C = sqrt(nx*nx+ny*ny+nz*nz); C = sqrt(nx*nx+ny*ny+nz*nz);
nx = nx/C; nx = nx/C;
@@ -474,57 +534,464 @@ extern void ColorCollide( char *ID, double *disteven, double *distodd, double *C
//.................inverse transformation...................................................... //.................inverse transformation......................................................
f0 = 0.05263157894736842*rho-0.012531328320802*m1+0.04761904761904762*m2; f0 = 0.05263157894736842*rho-0.012531328320802*m1+0.04761904761904762*m2;
f1 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2 f1 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2
+0.1*(jx-m4)+0.0555555555555555555555555*(m9-m10); +0.1*(jx-m4)+0.0555555555555555555555555*(m9-m10);
f2 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2 f2 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2
+0.1*(m4-jx)+0.0555555555555555555555555*(m9-m10); +0.1*(m4-jx)+0.0555555555555555555555555*(m9-m10);
f3 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2 f3 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2
+0.1*(jy-m6)+0.02777777777777778*(m10-m9)+0.08333333333333333*(m11-m12); +0.1*(jy-m6)+0.02777777777777778*(m10-m9)+0.08333333333333333*(m11-m12);
f4 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2 f4 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2
+0.1*(m6-jy)+0.02777777777777778*(m10-m9)+0.08333333333333333*(m11-m12); +0.1*(m6-jy)+0.02777777777777778*(m10-m9)+0.08333333333333333*(m11-m12);
f5 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2 f5 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2
+0.1*(jz-m8)+0.02777777777777778*(m10-m9)+0.08333333333333333*(m12-m11); +0.1*(jz-m8)+0.02777777777777778*(m10-m9)+0.08333333333333333*(m12-m11);
f6 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2 f6 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2
+0.1*(m8-jz)+0.02777777777777778*(m10-m9)+0.08333333333333333*(m12-m11); +0.1*(m8-jz)+0.02777777777777778*(m10-m9)+0.08333333333333333*(m12-m11);
f7 = 0.05263157894736842*rho+0.003341687552213868*m1+0.003968253968253968*m2+0.1*(jx+jy)+0.025*(m4+m6) f7 = 0.05263157894736842*rho+0.003341687552213868*m1+0.003968253968253968*m2+0.1*(jx+jy)+0.025*(m4+m6)
+0.02777777777777778*m9+0.01388888888888889*m10+0.08333333333333333*m11 +0.02777777777777778*m9+0.01388888888888889*m10+0.08333333333333333*m11
+0.04166666666666666*m12+0.25*m13+0.125*(m16-m17); +0.04166666666666666*m12+0.25*m13+0.125*(m16-m17);
f8 = 0.05263157894736842*rho+0.003341687552213868*m1+0.003968253968253968*m2-0.1*(jx+jy)-0.025*(m4+m6) f8 = 0.05263157894736842*rho+0.003341687552213868*m1+0.003968253968253968*m2-0.1*(jx+jy)-0.025*(m4+m6)
+0.02777777777777778*m9+0.01388888888888889*m10+0.08333333333333333*m11 +0.02777777777777778*m9+0.01388888888888889*m10+0.08333333333333333*m11
+0.04166666666666666*m12+0.25*m13+0.125*(m17-m16); +0.04166666666666666*m12+0.25*m13+0.125*(m17-m16);
f9 = 0.05263157894736842*rho+0.003341687552213868*m1+0.003968253968253968*m2+0.1*(jx-jy)+0.025*(m4-m6) f9 = 0.05263157894736842*rho+0.003341687552213868*m1+0.003968253968253968*m2+0.1*(jx-jy)+0.025*(m4-m6)
+0.02777777777777778*m9+0.01388888888888889*m10+0.08333333333333333*m11 +0.02777777777777778*m9+0.01388888888888889*m10+0.08333333333333333*m11
+0.04166666666666666*m12-0.25*m13+0.125*(m16+m17); +0.04166666666666666*m12-0.25*m13+0.125*(m16+m17);
f10 = 0.05263157894736842*rho+0.003341687552213868*m1+0.003968253968253968*m2+0.1*(jy-jx)+0.025*(m6-m4) f10 = 0.05263157894736842*rho+0.003341687552213868*m1+0.003968253968253968*m2+0.1*(jy-jx)+0.025*(m6-m4)
+0.02777777777777778*m9+0.01388888888888889*m10+0.08333333333333333*m11 +0.02777777777777778*m9+0.01388888888888889*m10+0.08333333333333333*m11
+0.04166666666666666*m12-0.25*m13-0.125*(m16+m17); +0.04166666666666666*m12-0.25*m13-0.125*(m16+m17);
f11 = 0.05263157894736842*rho+0.003341687552213868*m1 f11 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2+0.1*(jx+jz)+0.025*(m4+m8) +0.003968253968253968*m2+0.1*(jx+jz)+0.025*(m4+m8)
+0.02777777777777778*m9+0.01388888888888889*m10-0.08333333333333333*m11 +0.02777777777777778*m9+0.01388888888888889*m10-0.08333333333333333*m11
-0.04166666666666666*m12+0.25*m15+0.125*(m18-m16); -0.04166666666666666*m12+0.25*m15+0.125*(m18-m16);
f12 = 0.05263157894736842*rho+0.003341687552213868*m1 f12 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2-0.1*(jx+jz)-0.025*(m4+m8) +0.003968253968253968*m2-0.1*(jx+jz)-0.025*(m4+m8)
+0.02777777777777778*m9+0.01388888888888889*m10-0.08333333333333333*m11 +0.02777777777777778*m9+0.01388888888888889*m10-0.08333333333333333*m11
-0.04166666666666666*m12+0.25*m15+0.125*(m16-m18); -0.04166666666666666*m12+0.25*m15+0.125*(m16-m18);
f13 = 0.05263157894736842*rho+0.003341687552213868*m1 f13 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2+0.1*(jx-jz)+0.025*(m4-m8) +0.003968253968253968*m2+0.1*(jx-jz)+0.025*(m4-m8)
+0.02777777777777778*m9+0.01388888888888889*m10-0.08333333333333333*m11 +0.02777777777777778*m9+0.01388888888888889*m10-0.08333333333333333*m11
-0.04166666666666666*m12-0.25*m15-0.125*(m16+m18); -0.04166666666666666*m12-0.25*m15-0.125*(m16+m18);
f14 = 0.05263157894736842*rho+0.003341687552213868*m1 f14 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2+0.1*(jz-jx)+0.025*(m8-m4) +0.003968253968253968*m2+0.1*(jz-jx)+0.025*(m8-m4)
+0.02777777777777778*m9+0.01388888888888889*m10-0.08333333333333333*m11 +0.02777777777777778*m9+0.01388888888888889*m10-0.08333333333333333*m11
-0.04166666666666666*m12-0.25*m15+0.125*(m16+m18); -0.04166666666666666*m12-0.25*m15+0.125*(m16+m18);
f15 = 0.05263157894736842*rho+0.003341687552213868*m1 f15 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2+0.1*(jy+jz)+0.025*(m6+m8) +0.003968253968253968*m2+0.1*(jy+jz)+0.025*(m6+m8)
-0.0555555555555555555555555*m9-0.02777777777777778*m10+0.25*m14+0.125*(m17-m18); -0.0555555555555555555555555*m9-0.02777777777777778*m10+0.25*m14+0.125*(m17-m18);
f16 = 0.05263157894736842*rho+0.003341687552213868*m1 f16 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2-0.1*(jy+jz)-0.025*(m6+m8) +0.003968253968253968*m2-0.1*(jy+jz)-0.025*(m6+m8)
-0.0555555555555555555555555*m9-0.02777777777777778*m10+0.25*m14+0.125*(m18-m17); -0.0555555555555555555555555*m9-0.02777777777777778*m10+0.25*m14+0.125*(m18-m17);
f17 = 0.05263157894736842*rho+0.003341687552213868*m1 f17 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2+0.1*(jy-jz)+0.025*(m6-m8) +0.003968253968253968*m2+0.1*(jy-jz)+0.025*(m6-m8)
-0.0555555555555555555555555*m9-0.02777777777777778*m10-0.25*m14+0.125*(m17+m18); -0.0555555555555555555555555*m9-0.02777777777777778*m10-0.25*m14+0.125*(m17+m18);
f18 = 0.05263157894736842*rho+0.003341687552213868*m1 f18 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2+0.1*(jz-jy)+0.025*(m8-m6) +0.003968253968253968*m2+0.1*(jz-jy)+0.025*(m8-m6)
-0.0555555555555555555555555*m9-0.02777777777777778*m10-0.25*m14-0.125*(m17+m18); -0.0555555555555555555555555*m9-0.02777777777777778*m10-0.25*m14-0.125*(m17+m18);
//.......................................................................................................
// incorporate external force
f1 += 0.16666666*Fx;
f2 -= 0.16666666*Fx;
f3 += 0.16666666*Fy;
f4 -= 0.16666666*Fy;
f5 += 0.16666666*Fz;
f6 -= 0.16666666*Fz;
f7 += 0.08333333333*(Fx+Fy);
f8 -= 0.08333333333*(Fx+Fy);
f9 += 0.08333333333*(Fx-Fy);
f10 -= 0.08333333333*(Fx-Fy);
f11 += 0.08333333333*(Fx+Fz);
f12 -= 0.08333333333*(Fx+Fz);
f13 += 0.08333333333*(Fx-Fz);
f14 -= 0.08333333333*(Fx-Fz);
f15 += 0.08333333333*(Fy+Fz);
f16 -= 0.08333333333*(Fy+Fz);
f17 += 0.08333333333*(Fy-Fz);
f18 -= 0.08333333333*(Fy-Fz);
//*********** WRITE UPDATED VALUES TO MEMORY ******************
// Write the updated distributions
//....EVEN.....................................
disteven[n] = f0;
disteven[N+n] = f2;
disteven[2*N+n] = f4;
disteven[3*N+n] = f6;
disteven[4*N+n] = f8;
disteven[5*N+n] = f10;
disteven[6*N+n] = f12;
disteven[7*N+n] = f14;
disteven[8*N+n] = f16;
disteven[9*N+n] = f18;
//....ODD......................................
distodd[n] = f1;
distodd[N+n] = f3;
distodd[2*N+n] = f5;
distodd[3*N+n] = f7;
distodd[4*N+n] = f9;
distodd[5*N+n] = f11;
distodd[6*N+n] = f13;
distodd[7*N+n] = f15;
distodd[8*N+n] = f17;
//...Store the Velocity..........................
Velocity[3*n] = jx;
Velocity[3*n+1] = jy;
Velocity[3*n+2] = jz;
//...Store the Color Gradient....................
// ColorGrad[3*n] = nx*C;
// ColorGrad[3*n+1] = ny*C;
// ColorGrad[3*n+2] = nz*C;
//...............................................
//***************************************************************
} // check if n is in the solid
} // loop over n
}
extern "C" void dvc_ColorCollideOpt( char *ID, double *disteven, double *distodd, double *phi, double *ColorGrad,
double *Velocity, int Nx, int Ny, int Nz, int S,double rlx_setA, double rlx_setB,
double alpha, double beta, double Fx, double Fy, double Fz)
{
int i,j,k,n,nn,N;
// distributions
double f0,f1,f2,f3,f4,f5,f6,f7,f8,f9;
double f10,f11,f12,f13,f14,f15,f16,f17,f18;
// non-conserved moments
double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
// additional variables needed for computations
double rho,jx,jy,jz,C,nx,ny,nz;
N = Nx*Ny*Nz;
char id;
for (n=0; n<N; n++){
id = ID[n];
if (id > 0){
//.......Back out the 3-D indices for node n..............
k = n/(Nx*Ny);
j = (n-Nx*Ny*k)/Nx;
i = n-Nx*Ny*k-Nx*j;
//........................................................................
//........Get 1-D index for this thread....................
// n = S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x;
//........................................................................
// COMPUTE THE COLOR GRADIENT
//........................................................................
//.................Read Phase Indicator Values............................
//........................................................................
nn = n-1; // neighbor index (get convention)
if (i-1<0) nn += Nx; // periodic BC along the x-boundary
f1 = phi[nn]; // get neighbor for phi - 1
//........................................................................
nn = n+1; // neighbor index (get convention)
if (!(i+1<Nx)) nn -= Nx; // periodic BC along the x-boundary
f2 = phi[nn]; // get neighbor for phi - 2
//........................................................................
nn = n-Nx; // neighbor index (get convention)
if (j-1<0) nn += Nx*Ny; // Perioidic BC along the y-boundary
f3 = phi[nn]; // get neighbor for phi - 3
//........................................................................
nn = n+Nx; // neighbor index (get convention)
if (!(j+1<Ny)) nn -= Nx*Ny; // Perioidic BC along the y-boundary
f4 = phi[nn]; // get neighbor for phi - 4
//........................................................................
nn = n-Nx*Ny; // neighbor index (get convention)
if (k-1<0) nn += Nx*Ny*Nz; // Perioidic BC along the z-boundary
f5 = phi[nn]; // get neighbor for phi - 5
//........................................................................
nn = n+Nx*Ny; // neighbor index (get convention)
if (!(k+1<Nz)) nn -= Nx*Ny*Nz; // Perioidic BC along the z-boundary
f6 = phi[nn]; // get neighbor for phi - 6
//........................................................................
nn = n-Nx-1; // neighbor index (get convention)
if (i-1<0) nn += Nx; // periodic BC along the x-boundary
if (j-1<0) nn += Nx*Ny; // Perioidic BC along the y-boundary
f7 = phi[nn]; // get neighbor for phi - 7
//........................................................................
nn = n+Nx+1; // neighbor index (get convention)
if (!(i+1<Nx)) nn -= Nx; // periodic BC along the x-boundary
if (!(j+1<Ny)) nn -= Nx*Ny; // Perioidic BC along the y-boundary
f8 = phi[nn]; // get neighbor for phi - 8
//........................................................................
nn = n+Nx-1; // neighbor index (get convention)
if (i-1<0) nn += Nx; // periodic BC along the x-boundary
if (!(j+1<Ny)) nn -= Nx*Ny; // Perioidic BC along the y-boundary
f9 = phi[nn]; // get neighbor for phi - 9
//........................................................................
nn = n-Nx+1; // neighbor index (get convention)
if (!(i+1<Nx)) nn -= Nx; // periodic BC along the x-boundary
if (j-1<0) nn += Nx*Ny; // Perioidic BC along the y-boundary
f10 = phi[nn]; // get neighbor for phi - 10
//........................................................................
nn = n-Nx*Ny-1; // neighbor index (get convention)
if (i-1<0) nn += Nx; // periodic BC along the x-boundary
if (k-1<0) nn += Nx*Ny*Nz; // Perioidic BC along the z-boundary
f11 = phi[nn]; // get neighbor for phi - 11
//........................................................................
nn = n+Nx*Ny+1; // neighbor index (get convention)
if (!(i+1<Nx)) nn -= Nx; // periodic BC along the x-boundary
if (!(k+1<Nz)) nn -= Nx*Ny*Nz; // Perioidic BC along the z-boundary
f12 = phi[nn]; // get neighbor for phi - 12
//........................................................................
nn = n+Nx*Ny-1; // neighbor index (get convention)
if (i-1<0) nn += Nx; // periodic BC along the x-boundary
if (!(k+1<Nz)) nn -= Nx*Ny*Nz; // Perioidic BC along the z-boundary
f13 = phi[nn]; // get neighbor for phi - 13
//........................................................................
nn = n-Nx*Ny+1; // neighbor index (get convention)
if (!(i+1<Nx)) nn -= Nx; // periodic BC along the x-boundary
if (k-1<0) nn += Nx*Ny*Nz; // Perioidic BC along the z-boundary
f14 = phi[nn]; // get neighbor for phi - 14
//........................................................................
nn = n-Nx*Ny-Nx; // neighbor index (get convention)
if (j-1<0) nn += Nx*Ny; // Perioidic BC along the y-boundary
if (k-1<0) nn += Nx*Ny*Nz; // Perioidic BC along the z-boundary
f15 = phi[nn]; // get neighbor for phi - 15
//........................................................................
nn = n+Nx*Ny+Nx; // neighbor index (get convention)
if (!(j+1<Ny)) nn -= Nx*Ny; // Perioidic BC along the y-boundary
if (!(k+1<Nz)) nn -= Nx*Ny*Nz; // Perioidic BC along the z-boundary
f16 = phi[nn]; // get neighbor for phi - 16
//........................................................................
nn = n+Nx*Ny-Nx; // neighbor index (get convention)
if (j-1<0) nn += Nx*Ny; // Perioidic BC along the y-boundary
if (!(k+1<Nz)) nn -= Nx*Ny*Nz; // Perioidic BC along the z-boundary
f17 = phi[nn]; // get neighbor for phi - 17
//........................................................................
nn = n-Nx*Ny+Nx; // neighbor index (get convention)
if (!(j+1<Ny)) nn -= Nx*Ny; // Perioidic BC along the y-boundary
if (k-1<0) nn += Nx*Ny*Nz; // Perioidic BC along the z-boundary
f18 = phi[nn]; // get neighbor for phi - 18
//............Compute the Color Gradient...................................
nx = -(f1-f2+0.5*(f7-f8+f9-f10+f11-f12+f13-f14));
ny = -(f3-f4+0.5*(f7-f8-f9+f10+f15-f16+f17-f18));
nz = -(f5-f6+0.5*(f11-f12-f13+f14+f15-f16-f17+f18));
//...Store the Color Gradient....................
ColorGrad[n] = nx;
ColorGrad[N+n] = ny;
ColorGrad[2*N+n] = nz;
//...............................................
//...........Normalize the Color Gradient.................................
C = sqrt(nx*nx+ny*ny+nz*nz);
nx = nx/C;
ny = ny/C;
nz = nz/C;
//......No color gradient at z-boundary if pressure BC are set.............
// if (pBC && k==0) nx = ny = nz = 0.f;
// if (pBC && k==Nz-1) nx = ny = nz = 0.f;
//........................................................................
// READ THE DISTRIBUTIONS
// (read from opposite array due to previous swap operation)
//........................................................................
f2 = distodd[n];
f4 = distodd[N+n];
f6 = distodd[2*N+n];
f0 = disteven[n];
f1 = disteven[N+n];
f3 = disteven[2*N+n];
f5 = disteven[3*N+n];
//........................................................................
//....................compute the moments...............................................
rho = f0+f2+f1+f4+f3+f6+f5;
m1 = -30*f0-11*(f2+f1+f4+f3+f6+f5);
m2 = 12*f0-4*(f2+f1 +f4+f3+f6 +f5);
jx = f1-f2;
m4 = 4*(-f1+f2);
jy = f3-f4;
m6 = -4*(f3-f4);
jz = f5-f6;
m8 = -4*(f5-f6);
m9 = 2*(f1+f2)-f3-f4-f5-f6;
m10 = -4*(f1+f2)+2*(f4+f3+f6+f5);
m11 = f4+f3-f6-f5;
m12 = -2*(f4+f3-f6-f5);
//........................................................................
f8 = distodd[3*N+n];
f10 = distodd[4*N+n];
f7 = disteven[4*N+n];
f9 = disteven[5*N+n];
//........................................................................
rho += f8+f7+f10+f9;
m1 += 8*(f8+f7+f10+f9);
m2 += f8+f7+f10+f9;
jx += f7-f8+f9-f10;
m4 += f7-f8+f9-f10;
jy += f7-f8-f9+f10;
m6 += f7-f8-f9+f10;
m9 += f7+f8+f9+f10;
m10 += f8+f7+f10+f9;
m11 += f8+f7+f10+f9;
m12 += f8+f7+f10+f9;
m13 = f8+f7-f10-f9;
m16 = f7-f8+f9-f10;
m17 = -f7+f8+f9-f10;
//........................................................................
f11 = disteven[6*N+n];
f13 = disteven[7*N+n];
f12 = distodd[5*N+n];
f14 = distodd[6*N+n];
//........................................................................
//........................................................................
f15 = disteven[8*N+n];
f17 = disteven[9*N+n];
f16 = distodd[7*N+n];
f18 = distodd[8*N+n];
//........................................................................
//....................compute the moments...............................................
rho += f12+f11+f14+f13+f16+f15+f18+f17;
m1 += 8*(f12+f11+f14+f13+f16+f15+f18+f17);
m2 += f12+f11+f14+f13+f16+f15+f18+f17;
jx += f11-f12+f13-f14;
m4 += f11-f12+f13-f14;
jy += f15-f16+f17-f18;
m6 += f15-f16+f17-f18;
jz += f11-f12-f13+f14+f15-f16-f17+f18;
m8 += f11-f12-f13+f14+f15-f16-f17+f18;
m9 += f11+f12+f13+f14-2*(f15+f16+f17+f18);
m10 += f12+f11+f14+f13-2*(f16+f15+f18+f17);
m11 += -f12-f11-f14-f13;
m12 += -f12-f11-f14-f13;
m14 = f16+f15-f18-f17;
m15 = f12+f11-f14-f13;
m16 += -f11+f12-f13+f14;
m17 += f15-f16+f17-f18;
m18 = f11-f12-f13+f14-f15+f16+f17-f18;
//........................................................................
/* f2 = distodd[n];
f4 = distodd[N+n];
f6 = distodd[2*N+n];
f8 = distodd[3*N+n];
//........................................................................
f0 = disteven[n];
f1 = disteven[N+n];
f3 = disteven[2*N+n];
f5 = disteven[3*N+n];
f7 = disteven[4*N+n];
//........................................................................
//........................................................................
//....................compute the moments...............................................
rho = f0+f2+f1+f4+f3+f6+f5+f8+f7;
m1 = -30*f0-11*(f2+f1+f4+f3+f6+f5)+8*(f8+f7);
m2 = 12*f0-4*(f2+f1 +f4+f3+f6 +f5)+f8+f7;
jx = f1-f2+f7-f8;
m4 = 4*(-f1+f2)+f7-f8;
jy = f3-f4+f7-f8;
m6 = -4*(f3-f4)+f7-f8;
jz = f5-f6;
m8 = -4*(f5-f6);
m9 = 2*(f1+f2)-f3-f4-f5-f6+f7+f8;
m10 = -4*(f1+f2)+2*(f4+f3+f6+f5)+f8+f7;
m11 = f4+f3-f6-f5+f8+f7;
m12 = -2*(f4+f3-f6-f5)+f8+f7;
m13 = f8+f7;
m16 = f7-f8;
m17 = -f7+f8;
//........................................................................
f9 = disteven[5*N+n];
f11 = disteven[6*N+n];
f13 = disteven[7*N+n];
f15 = disteven[8*N+n];
f17 = disteven[9*N+n];
f10 = distodd[4*N+n];
f12 = distodd[5*N+n];
f14 = distodd[6*N+n];
f16 = distodd[7*N+n];
f18 = distodd[8*N+n];
//........................................................................
rho += f10+f9+f12+f11+f14+f13+f16+f15+f18+f17;
m1 += 8*(f10+f9+f12+f11+f14+f13+f16+f15+f18 +f17);
m2 += f10+f9+f12+f11+f14+f13+f16+f15+f18+f17;
jx += f9-f10+f11-f12+f13-f14;
m4 += f9-f10+f11-f12+f13-f14;
jy += -f9+f10+f15-f16+f17-f18;
m6 += -f9+f10+f15-f16+f17-f18;
jz += f11-f12-f13+f14+f15-f16-f17+f18;
m8 += f11-f12-f13+f14+f15-f16-f17+f18;
m9 += f9+f10+f11+f12+f13+f14-2*(f15+f16+f17+f18);
m10 += f10+f9+f12+f11+f14+f13-2*(f16+f15+f18+f17);
m11 += f10+f9-f12-f11-f14-f13;
m12 += f10+f9-f12-f11-f14-f13;
m13 += -f10-f9;
m14 = f16+f15-f18-f17;
m15 = f12+f11-f14-f13;
m16 += f9-f10-f11+f12-f13+f14;
m17 += f9-f10+f15-f16+f17-f18;
m18 = f11-f12-f13+f14-f15+f16+f17-f18;
*/ //........................................................................
// PERFORM RELAXATION PROCESS
//........................................................................
//..........Toelke, Fruediger et. al. 2006...............
if (C == 0.0) nx = ny = nz = 1.0;
m1 = m1 + rlx_setA*((19*(jx*jx+jy*jy+jz*jz)/rho - 11*rho) -alpha*C - m1);
m2 = m2 + rlx_setA*((3*rho - 5.5*(jx*jx+jy*jy+jz*jz)/rho)- m2);
m4 = m4 + rlx_setB*((-0.6666666666666666*jx)- m4);
m6 = m6 + rlx_setB*((-0.6666666666666666*jy)- m6);
m8 = m8 + rlx_setB*((-0.6666666666666666*jz)- m8);
m9 = m9 + rlx_setA*(((2*jx*jx-jy*jy-jz*jz)/rho) + 0.5*alpha*C*(2*nx*nx-ny*ny-nz*nz) - m9);
m10 = m10 + rlx_setA*(-0.5*((2*jx*jx-jy*jy-jz*jz)/rho) - m10);
m11 = m11 + rlx_setA*(((jy*jy-jz*jz)/rho) + 0.5*alpha*C*(ny*ny-nz*nz)- m11);
m12 = m12 + rlx_setA*( -0.5*((jy*jy-jz*jz)/rho) - m12);
m13 = m13 + rlx_setA*( (jx*jy/rho) + 0.5*alpha*C*nx*ny - m13);
m14 = m14 + rlx_setA*( (jy*jz/rho) + 0.5*alpha*C*ny*nz - m14);
m15 = m15 + rlx_setA*( (jx*jz/rho) + 0.5*alpha*C*nx*nz - m15);
m16 = m16 + rlx_setB*( - m16);
m17 = m17 + rlx_setB*( - m17);
m18 = m18 + rlx_setB*( - m18);
//.................inverse transformation......................................................
f0 = 0.05263157894736842*rho-0.012531328320802*m1+0.04761904761904762*m2;
f1 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2
+0.1*(jx-m4)+0.0555555555555555555555555*(m9-m10);
f2 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2
+0.1*(m4-jx)+0.0555555555555555555555555*(m9-m10);
f3 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2
+0.1*(jy-m6)+0.02777777777777778*(m10-m9)+0.08333333333333333*(m11-m12);
f4 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2
+0.1*(m6-jy)+0.02777777777777778*(m10-m9)+0.08333333333333333*(m11-m12);
f5 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2
+0.1*(jz-m8)+0.02777777777777778*(m10-m9)+0.08333333333333333*(m12-m11);
f6 = 0.05263157894736842*rho-0.004594820384294068*m1-0.01587301587301587*m2
+0.1*(m8-jz)+0.02777777777777778*(m10-m9)+0.08333333333333333*(m12-m11);
f7 = 0.05263157894736842*rho+0.003341687552213868*m1+0.003968253968253968*m2+0.1*(jx+jy)+0.025*(m4+m6)
+0.02777777777777778*m9+0.01388888888888889*m10+0.08333333333333333*m11
+0.04166666666666666*m12+0.25*m13+0.125*(m16-m17);
f8 = 0.05263157894736842*rho+0.003341687552213868*m1+0.003968253968253968*m2-0.1*(jx+jy)-0.025*(m4+m6)
+0.02777777777777778*m9+0.01388888888888889*m10+0.08333333333333333*m11
+0.04166666666666666*m12+0.25*m13+0.125*(m17-m16);
f9 = 0.05263157894736842*rho+0.003341687552213868*m1+0.003968253968253968*m2+0.1*(jx-jy)+0.025*(m4-m6)
+0.02777777777777778*m9+0.01388888888888889*m10+0.08333333333333333*m11
+0.04166666666666666*m12-0.25*m13+0.125*(m16+m17);
f10 = 0.05263157894736842*rho+0.003341687552213868*m1+0.003968253968253968*m2+0.1*(jy-jx)+0.025*(m6-m4)
+0.02777777777777778*m9+0.01388888888888889*m10+0.08333333333333333*m11
+0.04166666666666666*m12-0.25*m13-0.125*(m16+m17);
f11 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2+0.1*(jx+jz)+0.025*(m4+m8)
+0.02777777777777778*m9+0.01388888888888889*m10-0.08333333333333333*m11
-0.04166666666666666*m12+0.25*m15+0.125*(m18-m16);
f12 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2-0.1*(jx+jz)-0.025*(m4+m8)
+0.02777777777777778*m9+0.01388888888888889*m10-0.08333333333333333*m11
-0.04166666666666666*m12+0.25*m15+0.125*(m16-m18);
f13 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2+0.1*(jx-jz)+0.025*(m4-m8)
+0.02777777777777778*m9+0.01388888888888889*m10-0.08333333333333333*m11
-0.04166666666666666*m12-0.25*m15-0.125*(m16+m18);
f14 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2+0.1*(jz-jx)+0.025*(m8-m4)
+0.02777777777777778*m9+0.01388888888888889*m10-0.08333333333333333*m11
-0.04166666666666666*m12-0.25*m15+0.125*(m16+m18);
f15 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2+0.1*(jy+jz)+0.025*(m6+m8)
-0.0555555555555555555555555*m9-0.02777777777777778*m10+0.25*m14+0.125*(m17-m18);
f16 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2-0.1*(jy+jz)-0.025*(m6+m8)
-0.0555555555555555555555555*m9-0.02777777777777778*m10+0.25*m14+0.125*(m18-m17);
f17 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2+0.1*(jy-jz)+0.025*(m6-m8)
-0.0555555555555555555555555*m9-0.02777777777777778*m10-0.25*m14+0.125*(m17+m18);
f18 = 0.05263157894736842*rho+0.003341687552213868*m1
+0.003968253968253968*m2+0.1*(jz-jy)+0.025*(m8-m6)
-0.0555555555555555555555555*m9-0.02777777777777778*m10-0.25*m14-0.125*(m17+m18);
//....................................................................................................... //.......................................................................................................
// incorporate external force // incorporate external force
f1 += 0.16666666*Fx; f1 += 0.16666666*Fx;
@@ -572,18 +1039,14 @@ extern void ColorCollide( char *ID, double *disteven, double *distodd, double *C
Velocity[3*n] = jx; Velocity[3*n] = jx;
Velocity[3*n+1] = jy; Velocity[3*n+1] = jy;
Velocity[3*n+2] = jz; Velocity[3*n+2] = jz;
/* //...Store the Color Gradient....................
ColorGrad[3*n] = C*nx;
ColorGrad[3*n+1] = C*ny;
ColorGrad[3*n+2] = C*nz;
*/ //...............................................
//*************************************************************** //***************************************************************
} // check if n is in the solid } // check if n is in the solid
} // check if n is in the domain } // loop over n
} }
//************************************************************************* //*************************************************************************
extern void DensityStreamD3Q7(char *ID, double *Den, double *Copy, double *Phi, double *ColorGrad, double *Velocity, extern "C" void dvc_DensityStreamD3Q7(char *ID, double *Den, double *Copy, double *Phi, double *ColorGrad, double *Velocity,
double beta, int Nx, int Ny, int Nz, bool pBC) double beta, int Nx, int Ny, int Nz, bool pBC, int S)
{ {
char id; char id;
@@ -602,7 +1065,7 @@ extern void DensityStreamD3Q7(char *ID, double *Den, double *Copy, double *Phi,
int D3Q7[3][3]={{1,0,0},{0,1,0},{0,0,1}}; int D3Q7[3][3]={{1,0,0},{0,1,0},{0,0,1}};
N = Nx*Ny*Nz; N = Nx*Ny*Nz;
for ( n=0; n<N; n++){ for (n=0; n<N; n++){
id = ID[n]; id = ID[n];
// Local Density Values // Local Density Values
na = Copy[2*n]; na = Copy[2*n];
@@ -613,9 +1076,9 @@ extern void DensityStreamD3Q7(char *ID, double *Den, double *Copy, double *Phi,
int j = (n-Nx*Ny*k)/Nx; int j = (n-Nx*Ny*k)/Nx;
int i = n-Nx*Ny*k-Nx*j; int i = n-Nx*Ny*k-Nx*j;
//.....Load the Color gradient......... //.....Load the Color gradient.........
nx = ColorGrad[3*n]; nx = ColorGrad[n];
ny = ColorGrad[3*n+1]; ny = ColorGrad[N+n];
nz = ColorGrad[3*n+2]; nz = ColorGrad[2*N+n];
C = sqrt(nx*nx+ny*ny+nz*nz); C = sqrt(nx*nx+ny*ny+nz*nz);
nx = nx/C; nx = nx/C;
ny = ny/C; ny = ny/C;
@@ -627,6 +1090,8 @@ extern void DensityStreamD3Q7(char *ID, double *Den, double *Copy, double *Phi,
//....Instantiate the density distributions //....Instantiate the density distributions
// Generate Equilibrium Distributions and stream // Generate Equilibrium Distributions and stream
// Stationary value - distribution 0 // Stationary value - distribution 0
// Den[2*n] += 0.3333333333333333*na;
// Den[2*n+1] += 0.3333333333333333*nb;
Den[2*n] += 0.3333333333333333*na; Den[2*n] += 0.3333333333333333*na;
Den[2*n+1] += 0.3333333333333333*nb; Den[2*n+1] += 0.3333333333333333*nb;
// Non-Stationary equilibrium distributions // Non-Stationary equilibrium distributions
@@ -669,19 +1134,19 @@ extern void DensityStreamD3Q7(char *ID, double *Den, double *Copy, double *Phi,
kn = k+Cqz; kn = k+Cqz;
// Adjust for periodic BC, if necessary // Adjust for periodic BC, if necessary
if (in<0) in+= Nx; // if (in<0) in+= Nx;
if (jn<0) jn+= Ny; // if (jn<0) jn+= Ny;
if (kn<0) kn+= Nz; // if (kn<0) kn+= Nz;
if (!(in<Nx)) in-= Nx; // if (!(in<Nx)) in-= Nx;
if (!(jn<Ny)) jn-= Ny; // if (!(jn<Ny)) jn-= Ny;
if (!(kn<Nz)) kn-= Nz; // if (!(kn<Nz)) kn-= Nz;
// Perform streaming or bounce-back as needed // Perform streaming or bounce-back as needed
id = ID[kn*Nx*Ny+jn*Nx+in]; id = ID[kn*Nx*Ny+jn*Nx+in];
if (id == 0){ //.....Bounce-back Rule........... if (id == 0){ //.....Bounce-back Rule...........
// Den[2*n] += a1;
// Den[2*n+1] += b1;
Den[2*n] += a1; Den[2*n] += a1;
Den[2*n+1] += b1; Den[2*n+1] += b1;
// atomicAdd(&Den[2*n], a1);
// atomicAdd(&Den[2*n+1], b1);
} }
else{ else{
//......Push the "distribution" to neighboring node........... //......Push the "distribution" to neighboring node...........
@@ -689,10 +1154,10 @@ extern void DensityStreamD3Q7(char *ID, double *Den, double *Copy, double *Phi,
//nn = (kn-zmin[rank]+1)*Nxp*Nyp + (jn-ymin[rank]+1)*Nxp + (in-xmin[rank]+1); //nn = (kn-zmin[rank]+1)*Nxp*Nyp + (jn-ymin[rank]+1)*Nxp + (in-xmin[rank]+1);
nn = kn*Nx*Ny+jn*Nx+in; nn = kn*Nx*Ny+jn*Nx+in;
// Push to neighboring node // Push to neighboring node
// Den[2*nn] += a1;
// Den[2*nn+1] += b1;
Den[2*nn] += a1; Den[2*nn] += a1;
Den[2*nn+1] += b1; Den[2*nn+1] += b1;
// atomicAdd(&Den[2*nn], a1);
// atomicAdd(&Den[2*nn+1], b1);
} }
// .......Get the neighbor node.............. // .......Get the neighbor node..............
@@ -701,20 +1166,20 @@ extern void DensityStreamD3Q7(char *ID, double *Den, double *Copy, double *Phi,
jn = j-Cqy; jn = j-Cqy;
kn = k-Cqz; kn = k-Cqz;
// Adjust for periodic BC, if necessary // Adjust for periodic BC, if necessary
if (in<0) in+= Nx; // if (in<0) in+= Nx;
if (jn<0) jn+= Ny; // if (jn<0) jn+= Ny;
if (kn<0) kn+= Nz; // if (kn<0) kn+= Nz;
if (!(in<Nx)) in-= Nx; // if (!(in<Nx)) in-= Nx;
if (!(jn<Ny)) jn-= Ny; // if (!(jn<Ny)) jn-= Ny;
if (!(kn<Nz)) kn-= Nz; // if (!(kn<Nz)) kn-= Nz;
// Perform streaming or bounce-back as needed // Perform streaming or bounce-back as needed
id = ID[kn*Nx*Ny+jn*Nx+in]; id = ID[kn*Nx*Ny+jn*Nx+in];
if (id == 0){ if (id == 0){
//.....Bounce-back Rule........... //.....Bounce-back Rule...........
// Den[2*n] += a2;
// Den[2*n+1] += b2;
Den[2*n] += a2; Den[2*n] += a2;
Den[2*n+1] += b2; Den[2*n+1] += b2;
// atomicAdd(&Den[2*n], a2);
// atomicAdd(&Den[2*n+1], b2);
} }
else{ else{
//......Push the "distribution" to neighboring node........... //......Push the "distribution" to neighboring node...........
@@ -722,24 +1187,25 @@ extern void DensityStreamD3Q7(char *ID, double *Den, double *Copy, double *Phi,
//nn = (kn-zmin[rank]+1)*Nxp*Nyp + (jn-ymin[rank]+1)*Nxp + (in-xmin[rank]+1); //nn = (kn-zmin[rank]+1)*Nxp*Nyp + (jn-ymin[rank]+1)*Nxp + (in-xmin[rank]+1);
nn = kn*Nx*Ny+jn*Nx+in; nn = kn*Nx*Ny+jn*Nx+in;
// Push to neighboring node // Push to neighboring node
// Den[2*nn] += a2;
// Den[2*nn+1] += b2;
Den[2*nn] += a2; Den[2*nn] += a2;
Den[2*nn+1] += b2; Den[2*nn+1] += b2;
// atomicAdd(&Den[2*nn], a2);
// atomicAdd(&Den[2*nn+1], b2);
} }
} }
} }
} }
} }
extern void ComputePhi(char *ID, double *Phi, double *Copy, double *Den, int N) extern "C" void dvc_ComputePhi(char *ID, double *Phi, double *Copy, double *Den, int N, int S)
{ {
int n; int n;
double Na,Nb; double Na,Nb;
//................................................................... //...................................................................
// Update Phi // Update Phi
for ( n=0; n<N; n++){ for (n=0; n<N; n++){
if (ID[n] > 0){
if (ID[n] > 0 && n<N){
// Get the density value (Streaming already performed) // Get the density value (Streaming already performed)
Na = Den[2*n]; Na = Den[2*n];
Nb = Den[2*n+1]; Nb = Den[2*n+1];
@@ -754,3 +1220,62 @@ extern void ComputePhi(char *ID, double *Phi, double *Copy, double *Den, int N)
} }
//................................................................... //...................................................................
} }
/*
//*************************************************************************
extern "C" void dvc_InitDenColor( int nblocks, int nthreads, int S,
char *ID, double *Den, double *Phi, double das, double dbs, int Nx, int Ny, int Nz)
{
InitDenColor <<<nblocks, nthreads>>> (ID, Den, Phi, das, dbs, Nx, Ny, Nz, S);
}
//*************************************************************************
extern "C" void dvc_ComputeColorGradient(int nBlocks, int nthreads, int S,
char *ID, double *Phi, double *ColorGrad, int Nx, int Ny, int Nz)
{
ComputeColorGradient<<<nBlocks,nthreads>>>(ID, Phi, ColorGrad, Nx, Ny, Nz, S);
}
//*************************************************************************
extern "C" void dvc_ColorCollide(int nBlocks, int nthreads, int S,
char *ID, double *f_even, double *f_odd, double *ColorGrad, double *Velocity,
double rlxA, double rlxB,double alpha, double beta, double Fx, double Fy, double Fz,
int Nx, int Ny, int Nz, bool pBC)
{
ColorCollide<<<nBlocks, nthreads>>>(ID, f_even, f_odd, ColorGrad, Velocity, Nx, Ny, Nz, S,
rlxA, rlxB, alpha, beta, Fx, Fy, Fz, pBC);
}
//*************************************************************************
extern "C" void dvc_ColorCollideOpt(int nBlocks, int nthreads, int S,
char *ID, double *f_even, double *f_odd, double *Phi, double *ColorGrad,
double *Velocity, int Nx, int Ny, int Nz,double rlxA, double rlxB,
double alpha, double beta, double Fx, double Fy, double Fz)
{
ColorCollideOpt<<<nBlocks, nthreads>>>(ID, f_even, f_odd, Phi, ColorGrad, Velocity, Nx, Ny, Nz, S,
rlxA, rlxB, alpha, beta, Fx, Fy, Fz);
// bool pBC = false;
// ColorCollide<<<nBlocks, nthreads>>>(ID, f_even, f_odd, ColorGrad, Velocity, Nx, Ny, Nz, S,
// rlxA, rlxB, alpha, beta, Fx, Fy, Fz, pBC);
}
//*************************************************************************
extern "C" void dvc_DensityStreamD3Q7(int nBlocks, int nthreads, int S,
char *ID, double *Den, double *Copy, double *Phi, double *ColorGrad, double *Velocity,
double beta, int Nx, int Ny, int Nz, bool pBC)
{
DensityStreamD3Q7<<<nBlocks, nthreads>>>(ID,Den,Copy,Phi,ColorGrad,Velocity,beta,Nx,Ny,Nz,pBC,S);
}
//*************************************************************************
extern "C" void dvc_ComputePhi(int nBlocks, int nthreads, int S,
char *ID, double *Phi, double *Copy, double *Den, int N)
{
ComputePhi<<<nBlocks, nthreads>>>(ID,Phi,Copy,Den,N,S);
}
//*************************************************************************
extern "C" void dvc_ComputePressure(int nBlocks, int nthreads, int S,
char *ID, double *disteven, double *distodd,
double *Pressure, int Nx, int Ny, int Nz)
{
ComputePressureD3Q19<<<nBlocks, nthreads>>>(ID,disteven,distodd,Pressure,Nx,Ny,Nz,S);
}
*/

41
cpu/Color.h
View File

@@ -1,21 +1,20 @@
extern void InitDenColor(char *ID, double *Den, double *Phi, double das, double dbs, int N); extern "C" void dvc_InitDenColor(char *ID, double *Den, double *Phi, double das, double dbs, int Nx, int Ny, int Nz, int S);
extern void InitD3Q19(char *ID, double *f_even, double *f_odd, int Nx, int Ny, int Nz); extern "C" void dvc_InitDenColorDistance(char *ID, double *Den, double *Phi, double *Distance,
double das, double dbs, double beta, double xp, int Nx, int Ny, int Nz, int S);
extern void Compute_VELOCITY(char *ID, double *disteven, double *distodd, double *vel, int Nx, int Ny, int Nz); extern "C" void dvc_Compute_VELOCITY(char *ID, double *disteven, double *distodd, double *vel, int Nx, int Ny, int Nz, int S);
extern "C" void dvc_ComputePressureD3Q19(char *ID, double *disteven, double *distodd, double *Pressure,
//************************************************************************* int Nx, int Ny, int Nz, int S);
//************************************************************************* extern "C" void dvc_PressureBC_inlet(double *disteven, double *distodd, double din,
extern void PressureBC_inlet(double *disteven, double *distodd, double din, int Nx, int Ny, int Nz, int S);
int Nx, int Ny, int Nz); extern "C" void dvc_PressureBC_outlet(double *disteven, double *distodd, double dout,
extern void PressureBC_outlet(double *disteven, double *distodd, double dout, int Nx, int Ny, int Nz, int S, int outlet);
int Nx, int Ny, int Nz, int S, int outlet); extern "C" void dvc_ComputeColorGradient(char *ID, double *phi, double *ColorGrad, int Nx, int Ny, int Nz, int S);
//************************************************************************* extern "C" void dvc_ColorCollide( char *ID, double *disteven, double *distodd, double *ColorGrad,
extern void ComputeColorGradient(char *ID, double *phi, double *ColorGrad, int Nx, int Ny, int Nz); double *Velocity, int Nx, int Ny, int Nz, int S,double rlx_setA, double rlx_setB,
//************************************************************************* double alpha, double beta, double Fx, double Fy, double Fz, bool pBC);
extern void ColorCollide( char *ID, double *disteven, double *distodd, double *ColorGrad, extern "C" void dvc_ColorCollideOpt( char *ID, double *disteven, double *distodd, double *phi, double *ColorGrad,
double *Velocity, int Nx, int Ny, int Nz, double rlx_setA, double rlx_setB, double *Velocity, int Nx, int Ny, int Nz, int S,double rlx_setA, double rlx_setB,
double alpha, double beta, double Fx, double Fy, double Fz, bool pBC); double alpha, double beta, double Fx, double Fy, double Fz);
//************************************************************************* extern "C" void dvc_DensityStreamD3Q7(char *ID, double *Den, double *Copy, double *Phi, double *ColorGrad, double *Velocity,
extern void DensityStreamD3Q7(char *ID, double *Den, double *Copy, double *Phi, double *ColorGrad, double *Velocity, double beta, int Nx, int Ny, int Nz, bool pBC, int S);
double beta, int Nx, int Ny, int Nz, bool pBC); extern "C" void dvc_ComputePhi(char *ID, double *Phi, double *Copy, double *Den, int N, int S);
extern void ComputePhi(char *ID, double *Phi, double *Copy, double *Den, int N);

46
cpu/D3Q19.cpp
View File

@@ -1,4 +1,4 @@
extern void PackDist(int q, int *list, int start, int count, double *sendbuf, double *dist, int N){ extern "C" void dvc_PackDist(int q, int *list, int start, int count, double *sendbuf, double *dist, int N){
//.................................................................................... //....................................................................................
// Pack distribution q into the send buffer for the listed lattice sites // Pack distribution q into the send buffer for the listed lattice sites
// dist may be even or odd distributions stored by stream layout // dist may be even or odd distributions stored by stream layout
@@ -10,9 +10,7 @@ extern void PackDist(int q, int *list, int start, int count, double *sendbuf, do
} }
} }
extern "C" void dvc_UnpackDist(int q, int Cqx, int Cqy, int Cqz, int *list, int start, int count,
extern void MapRecvDist(int q, int Cqx, int Cqy, int Cqz, int *list, int start, int count,
double *recvbuf, double *dist, int Nx, int Ny, int Nz){ double *recvbuf, double *dist, int Nx, int Ny, int Nz){
//.................................................................................... //....................................................................................
// Unack distribution from the recv buffer // Unack distribution from the recv buffer
@@ -54,8 +52,46 @@ extern void MapRecvDist(int q, int Cqx, int Cqy, int Cqz, int *list, int start,
} }
} }
extern "C" void dvc_InitD3Q19(char *ID, double *f_even, double *f_odd, int Nx, int Ny, int Nz, int S)
{
int n,N;
N = Nx*Ny*Nz;
for (n=0; n<N; n++){
if (ID[n] > 0){
f_even[n] = 0.3333333333333333;
f_odd[n] = 0.055555555555555555; //double(100*n)+1.f;
f_even[N+n] = 0.055555555555555555; //double(100*n)+2.f;
f_odd[N+n] = 0.055555555555555555; //double(100*n)+3.f;
f_even[2*N+n] = 0.055555555555555555; //double(100*n)+4.f;
f_odd[2*N+n] = 0.055555555555555555; //double(100*n)+5.f;
f_even[3*N+n] = 0.055555555555555555; //double(100*n)+6.f;
f_odd[3*N+n] = 0.0277777777777778; //double(100*n)+7.f;
f_even[4*N+n] = 0.0277777777777778; //double(100*n)+8.f;
f_odd[4*N+n] = 0.0277777777777778; //double(100*n)+9.f;
f_even[5*N+n] = 0.0277777777777778; //double(100*n)+10.f;
f_odd[5*N+n] = 0.0277777777777778; //double(100*n)+11.f;
f_even[6*N+n] = 0.0277777777777778; //double(100*n)+12.f;
f_odd[6*N+n] = 0.0277777777777778; //double(100*n)+13.f;
f_even[7*N+n] = 0.0277777777777778; //double(100*n)+14.f;
f_odd[7*N+n] = 0.0277777777777778; //double(100*n)+15.f;
f_even[8*N+n] = 0.0277777777777778; //double(100*n)+16.f;
f_odd[8*N+n] = 0.0277777777777778; //double(100*n)+17.f;
f_even[9*N+n] = 0.0277777777777778; //double(100*n)+18.f;
}
else{
for(int q=0; q<9; q++){
f_even[q*N+n] = -1.0;
f_odd[q*N+n] = -1.0;
}
f_even[9*N+n] = -1.0;
}
}
}
//************************************************************************* //*************************************************************************
extern void SwapD3Q19(char *ID, double *disteven, double *distodd, int Nx, int Ny, int Nz) extern "C" void dvc_SwapD3Q19(char *ID, double *disteven, double *distodd, int Nx, int Ny, int Nz, int S)
{ {
int n,nn,N; int n,nn,N;
// distributions // distributions

8
cpu/D3Q19.h
View File

@@ -1,6 +1,6 @@
extern "C" void dvc_PackDist(int q, int *list, int start, int count, double *sendbuf, double *dist, int N);
extern void PackDist(int q, int *list, int start, int count, double *sendbuf, double *dist, int N); extern "C" void dvc_UnpackDist(int q, int Cqx, int Cqy, int Cqz, int *list, int start, int count,
extern void MapRecvDist(int q, int Cqx, int Cqy, int Cqz, int *list, int start, int count,
double *recvbuf, double *dist, int Nx, int Ny, int Nz); double *recvbuf, double *dist, int Nx, int Ny, int Nz);
//************************************************************************* //*************************************************************************
extern void SwapD3Q19(char *ID, double *disteven, double *distodd, int Nx, int Ny, int Nz); extern "C" void dvc_InitD3Q19(char *ID, double *f_even, double *f_odd, int Nx, int Ny, int Nz, int S);
extern "C" void dvc_SwapD3Q19(char *ID, double *disteven, double *distodd, int Nx, int Ny, int Nz, int S);

10
cpu/D3Q7.cpp
View File

@@ -1,6 +1,6 @@
// GPU Functions for D3Q7 Lattice Boltzmann Methods // CPU Functions for D3Q7 Lattice Boltzmann Methods
extern void PackValues(int *list, int count, double *sendbuf, double *Data, int N){ extern "C" void dvc_PackValues(int *list, int count, double *sendbuf, double *Data, int N){
//.................................................................................... //....................................................................................
// Pack distribution q into the send buffer for the listed lattice sites // Pack distribution q into the send buffer for the listed lattice sites
// dist may be even or odd distributions stored by stream layout // dist may be even or odd distributions stored by stream layout
@@ -11,7 +11,7 @@ extern void PackValues(int *list, int count, double *sendbuf, double *Data, int
sendbuf[idx] = Data[n]; sendbuf[idx] = Data[n];
} }
} }
extern void UnpackValues(int *list, int count, double *recvbuf, double *Data, int N){ extern "C" void dvc_UnpackValues(int *list, int count, double *recvbuf, double *Data, int N){
//.................................................................................... //....................................................................................
// Pack distribution q into the send buffer for the listed lattice sites // Pack distribution q into the send buffer for the listed lattice sites
// dist may be even or odd distributions stored by stream layout // dist may be even or odd distributions stored by stream layout
@@ -23,7 +23,7 @@ extern void UnpackValues(int *list, int count, double *recvbuf, double *Data, in
} }
} }
extern void PackDenD3Q7(int *list, int count, double *sendbuf, int number, double *Data, int N){ extern "C" void dvc_PackDenD3Q7(int *list, int count, double *sendbuf, int number, double *Data, int N){
//.................................................................................... //....................................................................................
// Pack distribution into the send buffer for the listed lattice sites // Pack distribution into the send buffer for the listed lattice sites
//.................................................................................... //....................................................................................
@@ -38,7 +38,7 @@ extern void PackDenD3Q7(int *list, int count, double *sendbuf, int number, doubl
} }
extern void UnpackDenD3Q7(int *list, int count, double *recvbuf, int number, double *Data, int N){ extern "C" void dvc_UnpackDenD3Q7(int *list, int count, double *recvbuf, int number, double *Data, int N){
//.................................................................................... //....................................................................................
// Unack distribution from the recv buffer // Unack distribution from the recv buffer
// Sum to the existing density value // Sum to the existing density value

8
cpu/D3Q7.h
View File

@@ -1,9 +1,9 @@
// CPU Functions for D3Q7 Lattice Boltzmann Methods // CPU Functions for D3Q7 Lattice Boltzmann Methods
extern void PackValues(int *list, int count, double *sendbuf, double *Data, int N); extern "C" void dvc_PackValues(int *list, int count, double *sendbuf, double *Data, int N);
extern void UnpackValues(int *list, int count, double *recvbuf, double *Data, int N); extern "C" void dvc_UnpackValues(int *list, int count, double *recvbuf, double *Data, int N);
extern void PackDenD3Q7(int *list, int count, double *sendbuf, int number, double *Data, int N); extern "C" void dvc_PackDenD3Q7(int *list, int count, double *sendbuf, int number, double *Data, int N);
extern void UnpackDenD3Q7(int *list, int count, double *recvbuf, int number, double *Data, int N); extern "C" void dvc_UnpackDenD3Q7(int *list, int count, double *recvbuf, int number, double *Data, int N);

28
cpu/Extras.cpp Normal file
View File

@@ -0,0 +1,28 @@
// Basic cuda functions callable from C/C++ code
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
extern "C" void dvc_AllocateDeviceMemory(void** address, size_t size){
//cudaMalloc(address,size);
(*address) = malloc(size);
if (*address==NULL){
printf("Memory allocation failed! \n");
}
}
extern "C" void dvc_CopyToDevice(void* dest, void* source, size_t size){
// cudaMemcpy(dest,source,size,cudaMemcpyHostToDevice);
memcpy(dest, source, size);
}
extern "C" void dvc_CopyToHost(void* dest, void* source, size_t size){
// cudaMemcpy(dest,source,size,cudaMemcpyDeviceToHost);
memcpy(dest, source, size);
}
extern "C" void dvc_Barrier(){
// cudaDeviceSynchronize();
}

7
cpu/Extras.h Normal file
View File

@@ -0,0 +1,7 @@
extern "C" void dvc_AllocateDeviceMemory(void** address, size_t size);
extern "C" void dvc_CopyToDevice(void* dest, void* source, size_t size);
extern "C" void dvc_CopyToHost(void* dest, void* source, size_t size);
extern "C" void dvc_Barrier();

2447
cpu/lb2_Color_wia_mpi.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

2492
cpu/lb2_Color_wia_mpi_bubble.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

12
include/Array.h
View File

@@ -312,14 +312,14 @@ double DoubleArray::e(int i, int j, int k)
extern DoubleArray IncreaseSize(DoubleArray &A, int addLength) extern DoubleArray IncreaseSize(DoubleArray &A, int addLength)
{ {
if (addLength<0) { if (addLength<0) {
printf("IncreaseSize(Array,Length)","Length needs to be >0."); printf("IncreaseSize(Array,Length) Length needs to be >0.");
return DoubleArray(); return DoubleArray();
} }
int newM,newN,newO; int newM,newN,newO;
if (A.o>1) { if (A.o>1) {
if (addLength%(A.m*A.n)!=0) { if (addLength%(A.m*A.n)!=0) {
printf("IncreaseSize(Array,Length)","Length needs to be a multiple of m*n"); printf("IncreaseSize(Array,Length) Length needs to be a multiple of m*n");
return DoubleArray(); return DoubleArray();
} }
newM = A.m; newM = A.m;
@@ -328,7 +328,7 @@ extern DoubleArray IncreaseSize(DoubleArray &A, int addLength)
} }
else if (A.n>1) { else if (A.n>1) {
if (addLength%(A.m)!=0) { if (addLength%(A.m)!=0) {
printf("IncreaseSize(Array,Length)","Length needs to be a multiple of m"); printf("IncreaseSize(Array,Length) Length needs to be a multiple of m");
return DoubleArray(); return DoubleArray();
} }
newM = A.m; newM = A.m;
@@ -348,14 +348,14 @@ extern DoubleArray IncreaseSize(DoubleArray &A, int addLength)
extern IntArray IncreaseSize(IntArray &A, int addLength) extern IntArray IncreaseSize(IntArray &A, int addLength)
{ {
if (addLength<0) { if (addLength<0) {
printf("IncreaseSize(Array,Length)","Length needs to be >0."); printf("IncreaseSize(Array,Length) Length needs to be >0.");
return IntArray(); return IntArray();
} }
int newM,newN,newO; int newM,newN,newO;
if (A.o>1) { if (A.o>1) {
if (addLength%(A.m*A.n)!=0) { if (addLength%(A.m*A.n)!=0) {
printf("IncreaseSize(Array,Length)","Length needs to be a multiple of m*n"); printf("IncreaseSize(Array,Length) Length needs to be a multiple of m*n");
return IntArray(); return IntArray();
} }
newM = A.m; newM = A.m;
@@ -364,7 +364,7 @@ extern IntArray IncreaseSize(IntArray &A, int addLength)
} }
else if (A.n>1) { else if (A.n>1) {
if (addLength%(A.m)!=0) { if (addLength%(A.m)!=0) {
printf("IncreaseSize(Array,Length)","Length needs to be a multiple of m"); printf("IncreaseSize(Array,Length) Length needs to be a multiple of m");
return IntArray(); return IntArray();
} }
newM = A.m; newM = A.m;

15
include/Domain.h
View File

@@ -399,3 +399,18 @@ inline void ReadCheckpoint(char *FILENAME, double *cDen, double *cDistEven, doub
} }
File.close(); File.close();
} }
inline void ReadBinaryFile(char *FILENAME, double *Data, int N)
{
int n;
double value;
ifstream File(FILENAME,ios::binary);
for (n=0; n<N; n++){
// Write the two density values
File.read((char*) &value, sizeof(value));
Data[n] = value;
}
File.close();
}

75
include/pmmc.h
View File

@@ -3402,15 +3402,24 @@ inline void pmmc_MeshCurvature(DoubleArray &f, DoubleArray &MeanCurvature, Doubl
fyz = 0.25*(f(i,j+1,k+1) - f(i,j+1,k-1) - f(i,j-1,k+1) + f(i,j-1,k-1)); fyz = 0.25*(f(i,j+1,k+1) - f(i,j+1,k-1) - f(i,j-1,k+1) + f(i,j-1,k-1));
// Evaluate the Mean Curvature // Evaluate the Mean Curvature
denominator = pow(sqrt(fx*fx + fy*fy + fz*fz),3); denominator = pow(sqrt(fx*fx + fy*fy + fz*fz),3);
if (denominator == 0.0) denominator = 1.0; if (denominator == 0.0){
MeanCurvature(i,j,k)=(1.0/denominator)*((fyy+fzz)*fx*fx + (fxx+fzz)*fy*fy + (fxx+fyy)*fz*fz MeanCurvature(i,j,k) = 0.0;
-2.0*fx*fy*fxy - 2.0*fx*fz*fxz - 2.0*fy*fz*fyz); }
else{
MeanCurvature(i,j,k)=(1.0/denominator)*((fyy+fzz)*fx*fx + (fxx+fzz)*fy*fy + (fxx+fyy)*fz*fz
-2.0*fx*fy*fxy - 2.0*fx*fz*fxz - 2.0*fy*fz*fyz);
}
// Evaluate the Gaussian Curvature // Evaluate the Gaussian Curvature
denominator = pow(fx*fx + fy*fy + fz*fz,2); denominator = pow(fx*fx + fy*fy + fz*fz,2);
if (denominator == 0.0) denominator = 1.0; if (denominator == 0.0){
GaussCurvature(i,j,k) = (1.0/denominator)*(fx*fx*(fyy*fzz-fyz*fyz) + fy*fy*(fxx*fzz-fxz*fxz) + fz*fz*(fxx*fyy-fxy*fxy) GaussCurvature(i,j,k) = 0.0;
+2.0*(fx*fy*(fxz*fyz-fxy*fzz) + fy*fz*(fxy*fxz-fyz*fxx) }
+ fx*fz*(fxy*fyz-fxz*fyy))); else{
GaussCurvature(i,j,k) = (1.0/denominator)*(fx*fx*(fyy*fzz-fyz*fyz) + fy*fy*(fxx*fzz-fxz*fxz) + fz*fz*(fxx*fyy-fxy*fxy)
+2.0*(fx*fy*(fxz*fyz-fxy*fzz) + fy*fz*(fxy*fxz-fyz*fxx)
+ fx*fz*(fxy*fyz-fxz*fyy)));
}
} }
} }
} }
@@ -3831,13 +3840,14 @@ inline void pmmc_InterfaceSpeed(DoubleArray &dPdt, DoubleArray &P_x, DoubleArray
Point A,B,C; Point A,B,C;
int p; int p;
double vA,vB,vC; double vA,vB,vC;
double vAx,vBx,vCx,vAy,vBy,vCy,vAz,vBz,vCz;
double x,y,z; double x,y,z;
double s,s1,s2,s3,temp; double s,s1,s2,s3,temp;
double a,b,c,d,e,f,g,h; double a,b,c,d,e,f,g,h;
double norm, zeta; double norm, zeta;
// ................x component ............................. // ................x component .............................
// Copy the curvature values for the cube // Copy the x derivative values for the cube
CubeValues(0,0,0) = P_x(i,j,k); CubeValues(0,0,0) = P_x(i,j,k);
CubeValues(1,0,0) = P_x(i+1,j,k); CubeValues(1,0,0) = P_x(i+1,j,k);
CubeValues(0,1,0) = P_x(i,j+1,k); CubeValues(0,1,0) = P_x(i,j+1,k);
@@ -3866,7 +3876,7 @@ inline void pmmc_InterfaceSpeed(DoubleArray &dPdt, DoubleArray &P_x, DoubleArray
} }
// ................y component ............................. // ................y component .............................
// Copy the curvature values for the cube // Copy the y derivative values for the cube
CubeValues(0,0,0) = P_y(i,j,k); CubeValues(0,0,0) = P_y(i,j,k);
CubeValues(1,0,0) = P_y(i+1,j,k); CubeValues(1,0,0) = P_y(i+1,j,k);
CubeValues(0,1,0) = P_y(i,j+1,k); CubeValues(0,1,0) = P_y(i,j+1,k);
@@ -3895,7 +3905,7 @@ inline void pmmc_InterfaceSpeed(DoubleArray &dPdt, DoubleArray &P_x, DoubleArray
} }
// ................z component ............................. // ................z component .............................
// Copy the curvature values for the cube // Copy the z derivative values for the cube
CubeValues(0,0,0) = P_z(i,j,k); CubeValues(0,0,0) = P_z(i,j,k);
CubeValues(1,0,0) = P_z(i+1,j,k); CubeValues(1,0,0) = P_z(i+1,j,k);
CubeValues(0,1,0) = P_z(i,j+1,k); CubeValues(0,1,0) = P_z(i,j+1,k);
@@ -3983,22 +3993,43 @@ inline void pmmc_InterfaceSpeed(DoubleArray &dPdt, DoubleArray &P_x, DoubleArray
s = 0.5*(s1+s2+s3); s = 0.5*(s1+s2+s3);
temp = s*(s-s1)*(s-s2)*(s-s3); temp = s*(s-s1)*(s-s2)*(s-s3);
if (temp > 0.0){ if (temp > 0.0){
// Surface value (speed)
vA = SurfaceValues(Triangles(0,r));
vB = SurfaceValues(Triangles(1,r));
vC = SurfaceValues(Triangles(2,r));
// Increment the averaged values // Increment the averaged values
// x component // x component
vA = SurfaceVector(Triangles(0,r))*SurfaceValues(Triangles(0,r)); vAx = SurfaceVector(Triangles(0,r))*vA;
vB = SurfaceVector(Triangles(1,r))*SurfaceValues(Triangles(1,r)); vBx = SurfaceVector(Triangles(1,r))*vB;
vC = SurfaceVector(Triangles(2,r))*SurfaceValues(Triangles(2,r)); vCx = SurfaceVector(Triangles(2,r))*vC;
AvgVel(0) += sqrt(temp)*0.33333333333333333*(vA+vB+vC);
// y component // y component
vA = SurfaceVector(npts+Triangles(0,r))*SurfaceValues(Triangles(0,r)); vAy = SurfaceVector(npts+Triangles(0,r))*vA;
vB = SurfaceVector(npts+Triangles(1,r))*SurfaceValues(Triangles(1,r)); vBy = SurfaceVector(npts+Triangles(1,r))*vB;
vC = SurfaceVector(npts+Triangles(2,r))*SurfaceValues(Triangles(2,r)); vCy = SurfaceVector(npts+Triangles(2,r))*vC;
AvgVel(1) += sqrt(temp)*0.33333333333333333*(vA+vB+vC);
// z component // z component
vA = SurfaceVector(2*npts+Triangles(0,r))*SurfaceValues(Triangles(0,r)); vAz = SurfaceVector(2*npts+Triangles(0,r))*vA;
vB = SurfaceVector(2*npts+Triangles(1,r))*SurfaceValues(Triangles(1,r)); vBz = SurfaceVector(2*npts+Triangles(1,r))*vB;
vC = SurfaceVector(2*npts+Triangles(2,r))*SurfaceValues(Triangles(2,r)); vCz = SurfaceVector(2*npts+Triangles(2,r))*vC;
AvgVel(2) += sqrt(temp)*0.33333333333333333*(vA+vB+vC);
AvgVel(0) += sqrt(temp)*0.33333333333333333*(vAx+vBx+vCx);
AvgVel(1) += sqrt(temp)*0.33333333333333333*(vAy+vBy+vCy);
AvgVel(2) += sqrt(temp)*0.33333333333333333*(vAz+vBz+vCz);
// Update the Averages. Differentiate between advancing (0,1,2) and receding (3,4,5) interfaces
// All points on a triangle have the same orientation in the color gradient
/* if (vA > 0.0){
// Advancing interface
AvgVel(0) += sqrt(temp)*0.33333333333333333*(vAx+vBx+vCx);
AvgVel(1) += sqrt(temp)*0.33333333333333333*(vAy+vBy+vCy);
AvgVel(2) += sqrt(temp)*0.33333333333333333*(vAz+vBz+vCz);
}
else{
// Receding interface
AvgVel(3) += sqrt(temp)*0.33333333333333333*(vAx+vBx+vCx);
AvgVel(4) += sqrt(temp)*0.33333333333333333*(vAy+vBy+vCy);
AvgVel(5) += sqrt(temp)*0.33333333333333333*(vAz+vBz+vCz);
}
*/
} }
} }
//............................................................................. //.............................................................................

125
pmmc/Analysis.cpp
View File

@@ -15,12 +15,17 @@ int main(int argc, char **argv)
{ {
//....................................................................... //.......................................................................
// printf("Radius = %s \n,"RADIUS); // printf("Radius = %s \n,"RADIUS);
int Nx,Ny,Nz; int Nx,Ny,Nz,N;
int i,j,k,p,q,r,n; int i,j,k,p,q,r,n;
int nspheres; int nspheres;
double Lx,Ly,Lz; double Lx,Ly,Lz;
//....................................................................... //.......................................................................
Nx = Ny = Nz = 60; Nx = Ny = Nz = 60;
cout << "Enter Domain size " << endl;
cout << "Nx = " << endl;
cin >> Nx;
Ny = Nz = Nx;
N = Nx*Ny*Nz;
//....................................................................... //.......................................................................
// Reading the domain information file // Reading the domain information file
/* //....................................................................... /* //.......................................................................
@@ -129,6 +134,8 @@ int main(int argc, char **argv)
DoubleArray Gns(6); DoubleArray Gns(6);
DoubleArray Gws(6); DoubleArray Gws(6);
double iVol = 1.0/Nx/Ny/Nz;
int c; int c;
//........................................................................... //...........................................................................
int ncubes = (Nx-2)*(Ny-2)*(Nz-2); // Exclude the "upper" halo int ncubes = (Nx-2)*(Ny-2)*(Nz-2); // Exclude the "upper" halo
@@ -159,8 +166,8 @@ int main(int argc, char **argv)
dist1 = sqrt((i-Cx)*(i-Cx)+(j-Cy)*(j-Cy)) - RADIUS; dist1 = sqrt((i-Cx)*(i-Cx)+(j-Cy)*(j-Cy)) - RADIUS;
dist2 = sqrt((i-Cx)*(i-Cx)+(j-Cy)*(j-Cy)+(k-Cz)*(k-Cz)) - CAPRAD; dist2 = sqrt((i-Cx)*(i-Cx)+(j-Cy)*(j-Cy)+(k-Cz)*(k-Cz)) - CAPRAD;
SignDist(i,j,k) = -dist1; //SignDist(i,j,k) = -dist1;
Phase(i,j,k) = dist2; //Phase(i,j,k) = dist2;
} }
} }
} }
@@ -175,7 +182,41 @@ int main(int argc, char **argv)
} }
} }
//........................................................................... awn = aws = ans = lwns = 0.0;
nwp_volume = 0.0;
As = 0.0;
Jwn = 0.0;
efawns = 0.0;
// Compute phase averages
pan = paw = 0.0;
vaw(0) = vaw(1) = vaw(2) = 0.0;
van(0) = van(1) = van(2) = 0.0;
vawn(0) = vawn(1) = vawn(2) = 0.0;
Gwn(0) = Gwn(1) = Gwn(2) = 0.0;
Gwn(3) = Gwn(4) = Gwn(5) = 0.0;
Gws(0) = Gws(1) = Gws(2) = 0.0;
Gws(3) = Gws(4) = Gws(5) = 0.0;
Gns(0) = Gns(1) = Gns(2) = 0.0;
Gns(3) = Gns(4) = Gns(5) = 0.0;
vol_w = vol_n =0.0;
// Read the input files for the phase, distance and pressure field
char PHASEFILE[16];
sprintf(PHASEFILE,"Phase.in");
ReadBinaryFile(PHASEFILE,Phase.data,Nx*Ny*Nz);
char DISTFILE[16];
sprintf(DISTFILE,"SignDist.in");
ReadBinaryFile(DISTFILE,SignDist.data,Nx*Ny*Nz);
/* FILE *PRESS
PRESS = fopen("Pressure.in","wb");
fread(Phase.data,8,N,PRESS);
fclose(PRESS);
FILE *VEL;
VEL = fopen("Pressure.in","wb");
fread(Phase.data,8,3*N,VEL);
fclose(VEL);
*/ //...........................................................................
// Calculate the time derivative of the phase indicator field // Calculate the time derivative of the phase indicator field
for (int n=0; n<Nx*Ny*Nz; n++) dPdt(n) = 0.5*(Phase_tplus(n) - Phase_tminus(n)); for (int n=0; n<Nx*Ny*Nz; n++) dPdt(n) = 0.5*(Phase_tplus(n) - Phase_tminus(n));
@@ -237,6 +278,18 @@ int main(int argc, char **argv)
vol_w = vol_n =0.0; vol_w = vol_n =0.0;
FILE *WN_TRIS;
WN_TRIS = fopen("wn-tris.out","w");
FILE *NS_TRIS;
NS_TRIS = fopen("ns-tris.out","w");
FILE *WS_TRIS;
WS_TRIS = fopen("ws-tris.out","w");
FILE *WNS_PTS;
WNS_PTS = fopen("wns-pts.out","w");
for (c=0;c<ncubes;c++){ for (c=0;c<ncubes;c++){
// Get cube from the list // Get cube from the list
i = cubeList(0,c); i = cubeList(0,c);
@@ -262,6 +315,10 @@ int main(int argc, char **argv)
pmmc_InterfaceSpeed(dPdt, Phase_x, Phase_y, Phase_z, CubeValues, nw_pts, nw_tris, pmmc_InterfaceSpeed(dPdt, Phase_x, Phase_y, Phase_z, CubeValues, nw_pts, nw_tris,
NormalVector, InterfaceSpeed, vawn, i, j, k, n_nw_pts, n_nw_tris); NormalVector, InterfaceSpeed, vawn, i, j, k, n_nw_pts, n_nw_tris);
// pmmc_InterfaceSpeed(dPdt, Phase_x, Phase_y, Phase_z, CubeValues, nw_pts, nw_tris,
// NormalVector, InterfaceSpeed, vawn, i, j, k, n_nw_pts, n_nw_tris);
// Compute the average contact angle // Compute the average contact angle
efawns += pmmc_CubeContactAngle(CubeValues,ContactAngle,Phase_x,Phase_y,Phase_z,Sx,Sy,Sz, efawns += pmmc_CubeContactAngle(CubeValues,ContactAngle,Phase_x,Phase_y,Phase_z,Sx,Sy,Sz,
local_nws_pts,i,j,k,n_local_nws_pts); local_nws_pts,i,j,k,n_local_nws_pts);
@@ -282,7 +339,43 @@ int main(int argc, char **argv)
// aws += pmmc_CubeSurfaceArea(ws_pts,ws_tris,n_ws_tris); // aws += pmmc_CubeSurfaceArea(ws_pts,ws_tris,n_ws_tris);
As += pmmc_CubeSurfaceArea(local_sol_pts,local_sol_tris,n_local_sol_tris); As += pmmc_CubeSurfaceArea(local_sol_pts,local_sol_tris,n_local_sol_tris);
lwns += pmmc_CubeCurveLength(local_nws_pts,n_local_nws_pts); lwns += pmmc_CubeCurveLength(local_nws_pts,n_local_nws_pts);
//.......................................................................................
// Write the triangle lists to text file
for (r=0;r<n_nw_tris;r++){
A = nw_pts(nw_tris(0,r));
B = nw_pts(nw_tris(1,r));
C = nw_pts(nw_tris(2,r));
fprintf(WN_TRIS,"%f %f %f %f %f %f %f %f %f \n",A.x,A.y,A.z,B.x,B.y,B.z,C.x,C.y,C.z);
}
for (r=0;r<n_ws_tris;r++){
A = ws_pts(ws_tris(0,r));
B = ws_pts(ws_tris(1,r));
C = ws_pts(ws_tris(2,r));
fprintf(WS_TRIS,"%f %f %f %f %f %f %f %f %f \n",A.x,A.y,A.z,B.x,B.y,B.z,C.x,C.y,C.z);
}
for (r=0;r<n_ns_tris;r++){
A = ns_pts(ns_tris(0,r));
B = ns_pts(ns_tris(1,r));
C = ns_pts(ns_tris(2,r));
fprintf(NS_TRIS,"%f %f %f %f %f %f %f %f %f \n",A.x,A.y,A.z,B.x,B.y,B.z,C.x,C.y,C.z);
}
for (p=0; p < n_nws_pts; p++){
P = nws_pts(p);
fprintf(WNS_PTS,"%f %f %f \n",P.x, P.y, P.z);
}
} }
fclose(WN_TRIS);
fclose(NS_TRIS);
fclose(WS_TRIS);
fclose(WNS_PTS);
printf("Jwn = %f \n",Jwn);
printf("awn = %f \n",awn);
printf("efawns = %f \n",efawns);
printf("lwns = %f \n",lwns);
printf("efawns = %f \n",efawns/lwns);
Jwn /= awn; Jwn /= awn;
efawns /= lwns; efawns /= lwns;
@@ -291,6 +384,11 @@ int main(int argc, char **argv)
for (i=0; i<6; i++) Gns(i) /= ans; for (i=0; i<6; i++) Gns(i) /= ans;
for (i=0; i<6; i++) Gws(i) /= aws; for (i=0; i<6; i++) Gws(i) /= aws;
awn = awn*iVol;
aws = aws*iVol;
ans = ans*iVol;
lwns = lwns*iVol;
printf("--------------------------------------------------------------------------------------\n"); printf("--------------------------------------------------------------------------------------\n");
printf("sw pw pn vw[x, y, z] vn[x, y, z] "); // Volume averages printf("sw pw pn vw[x, y, z] vn[x, y, z] "); // Volume averages
printf("awn ans aws Jwn vwn[x, y, z] lwns efawns "); // Interface and common curve averages printf("awn ans aws Jwn vwn[x, y, z] lwns efawns "); // Interface and common curve averages
@@ -303,12 +401,13 @@ int main(int argc, char **argv)
printf("%.5g %.5g %.5g ",van(0),van(1),van(2)); // average velocity of n phase printf("%.5g %.5g %.5g ",van(0),van(1),van(2)); // average velocity of n phase
printf("%.5g %.5g %.5g ",awn,ans,aws); // interfacial areas printf("%.5g %.5g %.5g ",awn,ans,aws); // interfacial areas
printf("%.5g ",Jwn); // curvature of wn interface printf("%.5g ",Jwn); // curvature of wn interface
printf("%.5g %.5g %.5g ",vawn(0),vawn(1),vawn(2)); // velocity of wn interface printf("%.5g ", lwns); // common curve length
printf("%.5g ",efawns); // average contact angle
printf("%.5g %.5g %.5g %.5g %.5g %.5g ", printf("%.5g %.5g %.5g %.5g %.5g %.5g ",
Gwn(0),Gwn(1),Gwn(2),Gwn(3),Gwn(4),Gwn(5)); // orientation of wn interface Gwn(0),Gwn(1),Gwn(2),Gwn(3),Gwn(4),Gwn(5)); // orientation of wn interface
printf("%.5g %.5g %.5g %.5g %.5g %.5g ", printf("%.5g %.5g %.5g %.5g %.5g %.5g ",
Gns(0),Gns(1),Gns(2),Gns(3),Gns(4),Gns(5)); // orientation of ns interface Gns(0),Gns(1),Gns(2),Gns(3),Gns(4),Gns(5)); // orientation of ns interface
printf("%.5g %.5g %.5g %.5g %.5g %.5g ", printf("%.5g %.5g %.5g %.5g %.5g %.5g \n",
Gws(0),Gws(1),Gws(2),Gws(3),Gws(4),Gws(5)); // orientation of ws interface Gws(0),Gws(1),Gws(2),Gws(3),Gws(4),Gws(5)); // orientation of ws interface
@@ -319,19 +418,19 @@ int main(int argc, char **argv)
printf("Area ws = %f, Analytical = %f \n", aws, 4*PI*RADIUS*HEIGHT); printf("Area ws = %f, Analytical = %f \n", aws, 4*PI*RADIUS*HEIGHT);
printf("Area s = %f, Analytical = %f \n", As, 2*PI*RADIUS*(N-2)); printf("Area s = %f, Analytical = %f \n", As, 2*PI*RADIUS*(N-2));
printf("Length wns = %f, Analytical = %f \n", lwns, 4*PI*RADIUS); printf("Length wns = %f, Analytical = %f \n", lwns, 4*PI*RADIUS);
// printf("Cos(theta_wns) = %f, Analytical = %f \n",efawns/lwns,1.0*RADIUS/CAPRAD); // printf("Cos(theta_wns) = %f, Analytical = %f \n",efawns/lwns,1.0*RADIUS/CAPRAD);
printf("Interface Velocity = %f,%f,%f \n",vawn(0)/awn,vawn(1)/awn,vawn(2)/awn); printf("Interface Velocity = %f,%f,%f \n",vawn(0)/awn,vawn(1)/awn,vawn(2)/awn);
printf("-------------------------------- \n"); printf("-------------------------------- \n");
//......................................................................... //.........................................................................
*/
FILE *PHASE; FILE *PHASE;
PHASE = fopen("Phase.in","wb"); PHASE = fopen("Phase.out","wb");
fwrite(Phase,8,SIZE,PHASE); fwrite(Phase.data,8,N,PHASE);
fclose(PHASE); fclose(PHASE);
FILE *SOLID; FILE *SOLID;
SOLID = fopen("Distance.in","wb"); SOLID = fopen("Distance.out","wb");
fwrite(Solid,8,SIZE,SOLID); fwrite(SignDist.data,8,N,SOLID);
fclose(SOLID); fclose(SOLID);
*/
} }

2
tests/TestContactAngle.cpp
View File

@@ -153,10 +153,8 @@ int main (int argc, char *argv[])
aws += pmmc_CubeSurfaceArea(ws_pts,ws_tris,n_ws_tris); aws += pmmc_CubeSurfaceArea(ws_pts,ws_tris,n_ws_tris);
As += pmmc_CubeSurfaceArea(local_sol_pts,local_sol_tris,n_local_sol_tris); As += pmmc_CubeSurfaceArea(local_sol_pts,local_sol_tris,n_local_sol_tris);
lwns += pmmc_CubeCurveLength(local_nws_pts,n_local_nws_pts); lwns += pmmc_CubeCurveLength(local_nws_pts,n_local_nws_pts);
} }
printf("-------------------------------- \n"); printf("-------------------------------- \n");
printf("NWP volume = %f \n", nwp_volume); printf("NWP volume = %f \n", nwp_volume);
printf("Area wn = %f, Analytical = %f \n", awn,2*PI*RADIUS*RADIUS); printf("Area wn = %f, Analytical = %f \n", awn,2*PI*RADIUS*RADIUS);

14
tests/TestInterfaceSpeed.cpp
View File

@@ -8,7 +8,7 @@
#define CAPRAD 20 #define CAPRAD 20
#define HEIGHT 15.5 #define HEIGHT 15.5
#define N 60 #define N 60
#define SPEED 1 #define SPEED -1
#define PI 3.14159 #define PI 3.14159
int main (int argc, char *argv[]) int main (int argc, char *argv[])
@@ -45,7 +45,7 @@ int main (int argc, char *argv[])
// Averaging variables // Averaging variables
//........................................................................... //...........................................................................
double awn,ans,aws,lwns,nwp_volume; double awn,ans,aws,lwns,nwp_volume;
double efawns; double efawns,Jwn;
double As; double As;
double dEs,dAwn,dAns; // Global surface energy (calculated by rank=0) double dEs,dAwn,dAns; // Global surface energy (calculated by rank=0)
double awn_global,ans_global,aws_global,lwns_global,nwp_volume_global; double awn_global,ans_global,aws_global,lwns_global,nwp_volume_global;
@@ -87,9 +87,10 @@ int main (int argc, char *argv[])
DoubleArray CubeValues(2,2,2); DoubleArray CubeValues(2,2,2);
DoubleArray ContactAngle(20); DoubleArray ContactAngle(20);
DoubleArray wn_curvature(20);
DoubleArray InterfaceSpeed(20); DoubleArray InterfaceSpeed(20);
DoubleArray NormalVector(60); DoubleArray NormalVector(60);
DoubleArray vawn(3); DoubleArray vawn(6);
int c; int c;
//........................................................................... //...........................................................................
@@ -212,9 +213,7 @@ int main (int argc, char *argv[])
Jwn /= awn; Jwn /= awn;
efawns /= lwns; efawns /= lwns;
vawn(0) /= awn; for (i=0;i<6;i++) vawn(i) /= awn;
vawn(1) /= awn;
vawn(2) /= awn;
printf("-------------------------------- \n"); printf("-------------------------------- \n");
printf("NWP volume = %f \n", nwp_volume); printf("NWP volume = %f \n", nwp_volume);
@@ -224,7 +223,8 @@ int main (int argc, char *argv[])
printf("Area s = %f, Analytical = %f \n", As, 2*PI*RADIUS*(N-2)); printf("Area s = %f, Analytical = %f \n", As, 2*PI*RADIUS*(N-2));
printf("Length wns = %f, Analytical = %f \n", lwns, 4*PI*RADIUS); printf("Length wns = %f, Analytical = %f \n", lwns, 4*PI*RADIUS);
// printf("Cos(theta_wns) = %f, Analytical = %f \n",efawns/lwns,1.0*RADIUS/CAPRAD); // printf("Cos(theta_wns) = %f, Analytical = %f \n",efawns/lwns,1.0*RADIUS/CAPRAD);
printf("Interface Velocity = %f,%f,%f \n",vawn(0)/awn,vawn(1)/awn,vawn(2)/awn); printf("Advancing Interface Velocity = %f,%f,%f \n",vawn(0),vawn(1),vawn(2));
printf("Receding Interface Velocity = %f,%f,%f \n",vawn(3),vawn(4),vawn(5));
printf("-------------------------------- \n"); printf("-------------------------------- \n");
//......................................................................... //.........................................................................