From 4c8ec687d23f01f1fbb429619a4aa6bb2fc093f5 Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Wed, 24 Feb 2021 20:28:36 -0500
Subject: [PATCH 01/19] unfinished work: try to add capillary penalty term in
 GreyscaleColor

---
 cuda/GreyscaleColor.cu | 1451 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1451 insertions(+)

diff --git a/cuda/GreyscaleColor.cu b/cuda/GreyscaleColor.cu
index 58dfa311..0cc49bcd 100644
--- a/cuda/GreyscaleColor.cu
+++ b/cuda/GreyscaleColor.cu
@@ -1447,6 +1447,1457 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor(int *Map, double *dist,
 	}
 }
 
+//CP: capillary penalty
+// also turn off recoloring for grey nodes
+__global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den,
+		 double *Phi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure,
+         double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff,double alpha, double beta,
+		double Gx, double Gy, double Gz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np){
+
+	int n,nn,ijk,nread;
+	int nr1,nr2,nr3,nr4,nr5,nr6;
+	int nr7,nr8,nr9,nr10;
+	int nr11,nr12,nr13,nr14;
+	//int nr15,nr16,nr17,nr18;
+	double fq;
+	// conserved momemnts
+	double rho,jx,jy,jz;
+	//double vx,vy,vz,v_mag;
+    //double ux,uy,uz,u_mag;
+    double ux,uy,uz;
+	// non-conserved moments
+	double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
+	double m3,m5,m7;
+	double nA,nB; // number density
+	double a1,b1,a2,b2,nAB,delta;
+	double C,nx,ny,nz; //color gradient magnitude and direction
+	double phi,tau,rho0,rlx_setA,rlx_setB;
+    double Fcpx,Fcpy,Fcpz;
+
+    //double GeoFun=0.0;//geometric function from Guo's PRE 66, 036304 (2002)
+    double porosity;
+    double perm;//voxel permeability
+    double c0, c1; //Guo's model parameters
+    double tau_eff;
+    double mu_eff;//kinematic viscosity
+    double nx_gs,ny_gs,nz_gs;//grey-solid color gradient
+    double nx_phase,ny_phase,nz_phase,C_phase;
+    double Fx,Fy,Fz;
+
+	const double mrt_V1=0.05263157894736842;
+	const double mrt_V2=0.012531328320802;
+	const double mrt_V3=0.04761904761904762;
+	const double mrt_V4=0.004594820384294068;
+	const double mrt_V5=0.01587301587301587;
+	const double mrt_V6=0.0555555555555555555555555;
+	const double mrt_V7=0.02777777777777778;
+	const double mrt_V8=0.08333333333333333;
+	const double mrt_V9=0.003341687552213868;
+	const double mrt_V10=0.003968253968253968;
+	const double mrt_V11=0.01388888888888889;
+	const double mrt_V12=0.04166666666666666;
+
+	int S = Np/NBLOCKS/NTHREADS + 1;
+	for (int s=0; s<S; s++){
+		//........Get 1-D index for this thread....................
+		n =  S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x + start;
+		if (n<finish) {
+			// read the component number densities
+			nA = Den[n];
+			nB = Den[Np + n];
+
+            porosity = Poros[n];
+            perm = Perm[n];
+            nx_gs = GreySolidGrad[n+0*Np];
+            ny_gs = GreySolidGrad[n+1*Np];
+            nz_gs = GreySolidGrad[n+2*Np];
+
+			// compute phase indicator field
+			phi=(nA-nB)/(nA+nB);
+
+			// local density
+			rho0=rhoA + 0.5*(1.0-phi)*(rhoB-rhoA);
+			// local relaxation time
+			tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
+			tau_eff=tauA_eff + 0.5*(1.0-phi)*(tauB_eff-tauA_eff);
+			rlx_setA = 1.f/tau;
+			rlx_setB = 8.f*(2.f-rlx_setA)/(8.f-rlx_setA);
+            mu_eff = (tau_eff-0.5)/3.0;//kinematic viscosity
+			
+			// Get the 1D index based on regular data layout
+			ijk = Map[n];
+			//					COMPUTE THE COLOR GRADIENT
+			//........................................................................
+			//.................Read Phase Indicator Values............................
+			//........................................................................
+			nn = ijk-1;							// neighbor index (get convention)
+			m1 = Phi[nn];						// get neighbor for phi - 1
+			//........................................................................
+			nn = ijk+1;							// neighbor index (get convention)
+			m2 = Phi[nn];						// get neighbor for phi - 2
+			//........................................................................
+			nn = ijk-strideY;							// neighbor index (get convention)
+			m3 = Phi[nn];					// get neighbor for phi - 3
+			//........................................................................
+			nn = ijk+strideY;							// neighbor index (get convention)
+			m4 = Phi[nn];					// get neighbor for phi - 4
+			//........................................................................
+			nn = ijk-strideZ;						// neighbor index (get convention)
+			m5 = Phi[nn];					// get neighbor for phi - 5
+			//........................................................................
+			nn = ijk+strideZ;						// neighbor index (get convention)
+			m6 = Phi[nn];					// get neighbor for phi - 6
+			//........................................................................
+			nn = ijk-strideY-1;						// neighbor index (get convention)
+			m7 = Phi[nn];					// get neighbor for phi - 7
+			//........................................................................
+			nn = ijk+strideY+1;						// neighbor index (get convention)
+			m8 = Phi[nn];					// get neighbor for phi - 8
+			//........................................................................
+			nn = ijk+strideY-1;						// neighbor index (get convention)
+			m9 = Phi[nn];					// get neighbor for phi - 9
+			//........................................................................
+			nn = ijk-strideY+1;						// neighbor index (get convention)
+			m10 = Phi[nn];					// get neighbor for phi - 10
+			//........................................................................
+			nn = ijk-strideZ-1;						// neighbor index (get convention)
+			m11 = Phi[nn];					// get neighbor for phi - 11
+			//........................................................................
+			nn = ijk+strideZ+1;						// neighbor index (get convention)
+			m12 = Phi[nn];					// get neighbor for phi - 12
+			//........................................................................
+			nn = ijk+strideZ-1;						// neighbor index (get convention)
+			m13 = Phi[nn];					// get neighbor for phi - 13
+			//........................................................................
+			nn = ijk-strideZ+1;						// neighbor index (get convention)
+			m14 = Phi[nn];					// get neighbor for phi - 14
+			//........................................................................
+			nn = ijk-strideZ-strideY;					// neighbor index (get convention)
+			m15 = Phi[nn];					// get neighbor for phi - 15
+			//........................................................................
+			nn = ijk+strideZ+strideY;					// neighbor index (get convention)
+			m16 = Phi[nn];					// get neighbor for phi - 16
+			//........................................................................
+			nn = ijk+strideZ-strideY;					// neighbor index (get convention)
+			m17 = Phi[nn];					// get neighbor for phi - 17
+			//........................................................................
+			nn = ijk-strideZ+strideY;					// neighbor index (get convention)
+			m18 = Phi[nn];					// get neighbor for phi - 18
+			//............Compute the Color Gradient...................................
+			nx_phase = -(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+			ny_phase = -(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+			nz_phase = -(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+			C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
+
+            //correct the normal color gradient by considering the effect of grey solid
+            nx = nx_phase + (1.0-porosity)*nx_gs; 
+            ny = ny_phase + (1.0-porosity)*ny_gs; 
+            nz = nz_phase + (1.0-porosity)*nz_gs; 
+            if (C_phase==0.0){
+                nx = nx_phase; 
+                ny = ny_phase;
+                nz = nz_phase;
+            }
+
+			//...........Normalize the Color Gradient.................................
+			C = sqrt(nx*nx+ny*ny+nz*nz);
+			double ColorMag = C;
+			if (C==0.0) ColorMag=1.0;
+			nx = nx/ColorMag;
+			ny = ny/ColorMag;
+			nz = nz/ColorMag;		
+            //----------- Introduce capillary penalty force -------------------------
+            //NOTE: apply only to grey nodes
+            Fcpx = 0.5*alpha*C*W/sqrt(perm)*nx;
+            Fcpy = 0.5*alpha*C*W/sqrt(perm)*ny;
+            Fcpz = 0.5*alpha*C*W/sqrt(perm)*nz;
+            if (porosity==1.0){
+                Fcpx = 0.0;
+                Fcpy = 0.0;
+                Fcpz = 0.0;
+            }
+
+			// q=0
+			fq = dist[n];
+			rho = fq;
+			m1  = -30.0*fq;
+			m2  = 12.0*fq;
+
+			// q=1
+			//nread = neighborList[n]; // neighbor 2 
+			//fq = dist[nread]; // reading the f1 data into register fq		
+			nr1 = neighborList[n]; 
+			fq = dist[nr1]; // reading the f1 data into register fq
+			rho += fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jx = fq;
+			m4 = -4.0*fq;
+			m9 = 2.0*fq;
+			m10 = -4.0*fq;
+
+			// f2 = dist[10*Np+n];
+			//nread = neighborList[n+Np]; // neighbor 1 ( < 10Np => even part of dist)
+			//fq = dist[nread];  // reading the f2 data into register fq
+			nr2 = neighborList[n+Np]; // neighbor 1 ( < 10Np => even part of dist)
+			fq = dist[nr2];  // reading the f2 data into register fq
+			rho += fq;
+			m1 -= 11.0*(fq);
+			m2 -= 4.0*(fq);
+			jx -= fq;
+			m4 += 4.0*(fq);
+			m9 += 2.0*(fq);
+			m10 -= 4.0*(fq);
+
+			// q=3
+			//nread = neighborList[n+2*Np]; // neighbor 4
+			//fq = dist[nread];
+			nr3 = neighborList[n+2*Np]; // neighbor 4
+			fq = dist[nr3];
+			rho += fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jy = fq;
+			m6 = -4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 = fq;
+			m12 = -2.0*fq;
+
+			// q = 4
+			//nread = neighborList[n+3*Np]; // neighbor 3
+			//fq = dist[nread];
+			nr4 = neighborList[n+3*Np]; // neighbor 3
+			fq = dist[nr4];
+			rho+= fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jy -= fq;
+			m6 += 4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 += fq;
+			m12 -= 2.0*fq;
+
+			// q=5
+			//nread = neighborList[n+4*Np];
+			//fq = dist[nread];
+			nr5 = neighborList[n+4*Np];
+			fq = dist[nr5];
+			rho += fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jz = fq;
+			m8 = -4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 -= fq;
+			m12 += 2.0*fq;
+
+
+			// q = 6
+			//nread = neighborList[n+5*Np];
+			//fq = dist[nread];
+			nr6 = neighborList[n+5*Np];
+			fq = dist[nr6];
+			rho+= fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jz -= fq;
+			m8 += 4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 -= fq;
+			m12 += 2.0*fq;
+
+			// q=7
+			//nread = neighborList[n+6*Np];
+			//fq = dist[nread];
+			nr7 = neighborList[n+6*Np];
+			fq = dist[nr7];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jy += fq;
+			m6 += fq;
+			m9  += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 = fq;
+			m16 = fq;
+			m17 = -fq;
+
+			// q = 8
+			//nread = neighborList[n+7*Np];
+			//fq = dist[nread];
+			nr8 = neighborList[n+7*Np];
+			fq = dist[nr8];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jy -= fq;
+			m6 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 += fq;
+			m16 -= fq;
+			m17 += fq;
+
+			// q=9
+			//nread = neighborList[n+8*Np];
+			//fq = dist[nread];
+			nr9 = neighborList[n+8*Np];
+			fq = dist[nr9];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jy -= fq;
+			m6 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 -= fq;
+			m16 += fq;
+			m17 += fq;
+
+			// q = 10
+			//nread = neighborList[n+9*Np];
+			//fq = dist[nread];
+			nr10 = neighborList[n+9*Np];
+			fq = dist[nr10];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jy += fq;
+			m6 += fq;
+			m9 += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 -= fq;
+			m16 -= fq;
+			m17 -= fq;
+
+			// q=11
+			//nread = neighborList[n+10*Np];
+			//fq = dist[nread];
+			nr11 = neighborList[n+10*Np];
+			fq = dist[nr11];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jz += fq;
+			m8 += fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 = fq;
+			m16 -= fq;
+			m18 = fq;
+
+			// q=12
+			//nread = neighborList[n+11*Np];
+			//fq = dist[nread];
+			nr12 = neighborList[n+11*Np];
+			fq = dist[nr12];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 += fq;
+			m16 += fq;
+			m18 -= fq;
+
+			// q=13
+			//nread = neighborList[n+12*Np];
+			//fq = dist[nread];
+			nr13 = neighborList[n+12*Np];
+			fq = dist[nr13];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 -= fq;
+			m16 -= fq;
+			m18 -= fq;
+
+			// q=14
+			//nread = neighborList[n+13*Np];
+			//fq = dist[nread];
+			nr14 = neighborList[n+13*Np];
+			fq = dist[nr14];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jz += fq;
+			m8 += fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 -= fq;
+			m16 += fq;
+			m18 += fq;
+
+			// q=15
+			nread = neighborList[n+14*Np];
+			fq = dist[nread];
+			//fq = dist[17*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy += fq;
+			m6 += fq;
+			jz += fq;
+			m8 += fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 = fq;
+			m17 += fq;
+			m18 -= fq;
+
+			// q=16
+			nread = neighborList[n+15*Np];
+			fq = dist[nread];
+			//fq = dist[8*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy -= fq;
+			m6 -= fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 += fq;
+			m17 -= fq;
+			m18 += fq;
+
+			// q=17
+			//fq = dist[18*Np+n];
+			nread = neighborList[n+16*Np];
+			fq = dist[nread];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy += fq;
+			m6 += fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 -= fq;
+			m17 += fq;
+			m18 += fq;
+
+			// q=18
+			nread = neighborList[n+17*Np];
+			fq = dist[nread];
+			//fq = dist[9*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy -= fq;
+			m6 -= fq;
+			jz += fq;
+			m8 += fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 -= fq;
+			m17 -= fq;
+			m18 -= fq;
+			
+            //// Compute greyscale related parameters
+            ux = (jx/rho0+0.5*porosity*Gx+0.5*Fcpx/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            uy = (jy/rho0+0.5*porosity*Gy+0.5*Fcpy/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            uz = (jz/rho0+0.5*porosity*Gz+0.5*Fcpz/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+
+            //Update the total force to include linear (Darcy) and nonlinear (Forchheimer) drags due to the porous medium
+            Fx = rho0*(-porosity*mu_eff/perm*ux + porosity*Gx)+Fcpx;
+            Fy = rho0*(-porosity*mu_eff/perm*uy + porosity*Gy)+Fcpy;
+            Fz = rho0*(-porosity*mu_eff/perm*uz + porosity*Gz)+Fcpz;
+            if (porosity==1.0){
+                Fx=rho0*(porosity*Gx);
+                Fy=rho0*(porosity*Gy);
+                Fz=rho0*(porosity*Gz);
+            }
+
+			// write the velocity 
+			Velocity[n] = ux;
+			Velocity[Np+n] = uy;
+			Velocity[2*Np+n] = uz;
+            //Pressure[n] = rho/3.f/porosity;
+            Pressure[n] = rho/3.f;
+
+			//........................................................................
+			//..............carry out relaxation process..............................
+			//..........Toelke, Fruediger et. al. 2006................................
+            //---------------- NO higher-order force -------------------------------//
+			if (C == 0.0)	nx = ny = nz = 0.0;
+			m1 = m1 + rlx_setA*((19*(ux*ux+uy*uy+uz*uz)*rho0/porosity - 11*rho) -19*alpha*C - m1);
+			m2 = m2 + rlx_setA*((3*rho - 5.5*(ux*ux+uy*uy+uz*uz)*rho0/porosity)- m2);
+            jx = jx + Fx;
+			m4 = m4 + rlx_setB*((-0.6666666666666666*ux*rho0)- m4)
+                    + (1-0.5*rlx_setB)*(-0.6666666666666666*Fx);
+            jy = jy + Fy;
+			m6 = m6 + rlx_setB*((-0.6666666666666666*uy*rho0)- m6)
+                    + (1-0.5*rlx_setB)*(-0.6666666666666666*Fy);
+            jz = jz + Fz;
+			m8 = m8 + rlx_setB*((-0.6666666666666666*uz*rho0)- m8)
+                    + (1-0.5*rlx_setB)*(-0.6666666666666666*Fz);
+			m9 = m9 + rlx_setA*(((2*ux*ux-uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(2*nx*nx-ny*ny-nz*nz) - m9);
+			m10 = m10 + rlx_setA*( - m10);
+            //m10 = m10 + rlx_setA*(-0.5*rho0*((2*ux*ux-uy*uy-uz*uz)/porosity)- m10);
+			m11 = m11 + rlx_setA*(((uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(ny*ny-nz*nz)- m11);
+			m12 = m12 + rlx_setA*( - m12);
+            //m12 = m12 + rlx_setA*(-0.5*(rho0*(uy*uy-uz*uz)/porosity)- m12);
+			m13 = m13 + rlx_setA*( (ux*uy*rho0/porosity) + 0.5*alpha*C*nx*ny - m13);
+			m14 = m14 + rlx_setA*( (uy*uz*rho0/porosity) + 0.5*alpha*C*ny*nz - m14);
+			m15 = m15 + rlx_setA*( (ux*uz*rho0/porosity) + 0.5*alpha*C*nx*nz - m15);
+			m16 = m16 + rlx_setB*( - m16);
+			m17 = m17 + rlx_setB*( - m17);
+			m18 = m18 + rlx_setB*( - m18);
+            //----------------------------------------------------------------------//
+
+            //----------------With higher-order force ------------------------------//
+			//if (C == 0.0)	nx = ny = nz = 0.0;
+			//m1 = m1 + rlx_setA*((19*(ux*ux+uy*uy+uz*uz)*rho0/porosity - 11*rho) -19*alpha*C - m1)
+            //        + (1-0.5*rlx_setA)*38*(Fx*ux+Fy*uy+Fz*uz)/porosity;
+			//m2 = m2 + rlx_setA*((3*rho - 5.5*(ux*ux+uy*uy+uz*uz)*rho0/porosity)- m2)
+            //        + (1-0.5*rlx_setA)*11*(-Fx*ux-Fy*uy-Fz*uz)/porosity;
+            //jx = jx + Fx;
+			//m4 = m4 + rlx_setB*((-0.6666666666666666*ux*rho0)- m4)
+            //        + (1-0.5*rlx_setB)*(-0.6666666666666666*Fx);
+            //jy = jy + Fy;
+			//m6 = m6 + rlx_setB*((-0.6666666666666666*uy*rho0)- m6)
+            //        + (1-0.5*rlx_setB)*(-0.6666666666666666*Fy);
+            //jz = jz + Fz;
+			//m8 = m8 + rlx_setB*((-0.6666666666666666*uz*rho0)- m8)
+            //        + (1-0.5*rlx_setB)*(-0.6666666666666666*Fz);
+			//m9 = m9 + rlx_setA*(((2*ux*ux-uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(2*nx*nx-ny*ny-nz*nz) - m9)
+            //        + (1-0.5*rlx_setA)*(4*Fx*ux-2*Fy*uy-2*Fz*uz)/porosity;
+			////m10 = m10 + rlx_setA*( - m10);
+            //m10 = m10 + rlx_setA*(-0.5*rho0*((2*ux*ux-uy*uy-uz*uz)/porosity)- m10)
+            //          + (1-0.5*rlx_setA)*(-2*Fx*ux+Fy*uy+Fz*uz)/porosity;
+			//m11 = m11 + rlx_setA*(((uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(ny*ny-nz*nz)- m11)
+            //          + (1-0.5*rlx_setA)*(2*Fy*uy-2*Fz*uz)/porosity;
+			////m12 = m12 + rlx_setA*( - m12);
+            //m12 = m12 + rlx_setA*(-0.5*(rho0*(uy*uy-uz*uz)/porosity)- m12)
+            //          + (1-0.5*rlx_setA)*(-Fy*uy+Fz*uz)/porosity;
+			//m13 = m13 + rlx_setA*( (ux*uy*rho0/porosity) + 0.5*alpha*C*nx*ny - m13);
+            //          + (1-0.5*rlx_setA)*(Fy*ux+Fx*uy)/porosity;
+			//m14 = m14 + rlx_setA*( (uy*uz*rho0/porosity) + 0.5*alpha*C*ny*nz - m14);
+            //          + (1-0.5*rlx_setA)*(Fz*uy+Fy*uz)/porosity;
+			//m15 = m15 + rlx_setA*( (ux*uz*rho0/porosity) + 0.5*alpha*C*nx*nz - m15);
+            //          + (1-0.5*rlx_setA)*(Fz*ux+Fx*uz)/porosity;
+			//m16 = m16 + rlx_setB*( - m16);
+			//m17 = m17 + rlx_setB*( - m17);
+			//m18 = m18 + rlx_setB*( - m18);
+            //----------------------------------------------------------------------//
+
+			//.................inverse transformation......................................................
+			// q=0
+			fq = mrt_V1*rho-mrt_V2*m1+mrt_V3*m2;
+			dist[n] = fq;
+
+			// q = 1
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jx-m4)+mrt_V6*(m9-m10);
+			//nread = neighborList[n+Np];
+			dist[nr2] = fq;
+
+			// q=2
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m4-jx)+mrt_V6*(m9-m10);
+			//nread = neighborList[n];
+			dist[nr1] = fq;
+
+			// q = 3
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jy-m6)+mrt_V7*(m10-m9)+mrt_V8*(m11-m12);
+			//nread = neighborList[n+3*Np];
+			dist[nr4] = fq;
+
+			// q = 4
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m6-jy)+mrt_V7*(m10-m9)+mrt_V8*(m11-m12);
+			//nread = neighborList[n+2*Np];
+			dist[nr3] = fq;
+
+			// q = 5
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jz-m8)+mrt_V7*(m10-m9)+mrt_V8*(m12-m11);
+			//nread = neighborList[n+5*Np];
+			dist[nr6] = fq;
+
+			// q = 6
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m8-jz)+mrt_V7*(m10-m9)+mrt_V8*(m12-m11);
+			//nread = neighborList[n+4*Np];
+			dist[nr5] = fq;
+
+			// q = 7
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jx+jy)+0.025*(m4+m6)+
+					mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12+0.25*m13+0.125*(m16-m17);
+			//nread = neighborList[n+7*Np];
+			dist[nr8] = fq;
+
+			// q = 8
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2-0.1*(jx+jy)-0.025*(m4+m6) +mrt_V7*m9+mrt_V11*m10+mrt_V8*m11
+					+mrt_V12*m12+0.25*m13+0.125*(m17-m16);
+			//nread = neighborList[n+6*Np];
+			dist[nr7] = fq;
+
+			// q = 9
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jx-jy)+0.025*(m4-m6)+
+					mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12-0.25*m13+0.125*(m16+m17);
+			//nread = neighborList[n+9*Np];
+			dist[nr10] = fq;
+
+			// q = 10
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jy-jx)+0.025*(m6-m4)+
+					mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12-0.25*m13-0.125*(m16+m17);
+			//nread = neighborList[n+8*Np];
+			dist[nr9] = fq;
+
+			// q = 11
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jx+jz)+0.025*(m4+m8)
+					+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+					-mrt_V12*m12+0.25*m15+0.125*(m18-m16);
+			//nread = neighborList[n+11*Np];
+			dist[nr12] = fq;
+
+			// q = 12
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2-0.1*(jx+jz)-0.025*(m4+m8)+
+					mrt_V7*m9+mrt_V11*m10-mrt_V8*m11-mrt_V12*m12+0.25*m15+0.125*(m16-m18);
+			//nread = neighborList[n+10*Np];
+			dist[nr11]= fq;
+
+			// q = 13
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jx-jz)+0.025*(m4-m8)
+					+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+					-mrt_V12*m12-0.25*m15-0.125*(m16+m18);
+			//nread = neighborList[n+13*Np];
+			dist[nr14] = fq;
+
+			// q= 14
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jz-jx)+0.025*(m8-m4)
+					+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+					-mrt_V12*m12-0.25*m15+0.125*(m16+m18);
+			//nread = neighborList[n+12*Np];
+			dist[nr13] = fq;
+
+
+			// q = 15
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jy+jz)+0.025*(m6+m8)
+					-mrt_V6*m9-mrt_V7*m10+0.25*m14+0.125*(m17-m18);
+			nread = neighborList[n+15*Np];
+			dist[nread] = fq;
+
+			// q = 16
+			fq =  mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2-0.1*(jy+jz)-0.025*(m6+m8)
+					-mrt_V6*m9-mrt_V7*m10+0.25*m14+0.125*(m18-m17);
+			nread = neighborList[n+14*Np];
+			dist[nread] = fq;
+
+
+			// q = 17
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jy-jz)+0.025*(m6-m8)
+					-mrt_V6*m9-mrt_V7*m10-0.25*m14+0.125*(m17+m18);
+			nread = neighborList[n+17*Np];
+			dist[nread] = fq;
+
+			// q = 18
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jz-jy)+0.025*(m8-m6)
+					-mrt_V6*m9-mrt_V7*m10-0.25*m14-0.125*(m17+m18);
+			nread = neighborList[n+16*Np];
+			dist[nread] = fq;
+			//........................................................................
+
+			// Instantiate mass transport distributions
+			// Stationary value - distribution 0
+			nAB = 1.0/(nA+nB);
+			Aq[n] = 0.3333333333333333*nA;
+			Bq[n] = 0.3333333333333333*nB;
+
+			//...............................................
+			// q = 0,2,4
+			// Cq = {1,0,0}, {0,1,0}, {0,0,1}
+			delta = beta*nA*nB*nAB*0.1111111111111111*nx;
+			if (!(nA*nB*nAB>0)) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
+			a1 = nA*(0.1111111111111111*(1+4.5*ux))+delta;
+			b1 = nB*(0.1111111111111111*(1+4.5*ux))-delta;
+			a2 = nA*(0.1111111111111111*(1-4.5*ux))-delta;
+			b2 = nB*(0.1111111111111111*(1-4.5*ux))+delta;
+
+			// q = 1
+			//nread = neighborList[n+Np];
+			Aq[nr2] = a1;
+			Bq[nr2] = b1;
+			// q=2
+			//nread = neighborList[n];
+			Aq[nr1] = a2;
+			Bq[nr1] = b2;
+
+			//...............................................
+			// Cq = {0,1,0}
+			delta = beta*nA*nB*nAB*0.1111111111111111*ny;
+			if (!(nA*nB*nAB>0)) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
+			a1 = nA*(0.1111111111111111*(1+4.5*uy))+delta;
+			b1 = nB*(0.1111111111111111*(1+4.5*uy))-delta;
+			a2 = nA*(0.1111111111111111*(1-4.5*uy))-delta;
+			b2 = nB*(0.1111111111111111*(1-4.5*uy))+delta;
+
+			// q = 3
+			//nread = neighborList[n+3*Np];
+			Aq[nr4] = a1;
+			Bq[nr4] = b1;
+			// q = 4
+			//nread = neighborList[n+2*Np];
+			Aq[nr3] = a2;
+			Bq[nr3] = b2;
+
+			//...............................................
+			// q = 4
+			// Cq = {0,0,1}
+			delta = beta*nA*nB*nAB*0.1111111111111111*nz;
+			if (!(nA*nB*nAB>0)) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
+			a1 = nA*(0.1111111111111111*(1+4.5*uz))+delta;
+			b1 = nB*(0.1111111111111111*(1+4.5*uz))-delta;
+			a2 = nA*(0.1111111111111111*(1-4.5*uz))-delta;
+			b2 = nB*(0.1111111111111111*(1-4.5*uz))+delta;
+
+			// q = 5
+			//nread = neighborList[n+5*Np];
+			Aq[nr6] = a1;
+			Bq[nr6] = b1;
+			// q = 6
+			//nread = neighborList[n+4*Np];
+			Aq[nr5] = a2;
+			Bq[nr5] = b2;
+			//...............................................
+		}
+	}
+}
+
+//CP: capillary penalty
+// also turn off recoloring for grey nodes
+__global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
+        double *Phi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure, 
+        double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
+		double Gx, double Gy, double Gz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np){
+	int ijk,nn,n;
+	double fq;
+	// conserved momemnts
+	double rho,jx,jy,jz;
+	//double vx,vy,vz,v_mag;
+    //double ux,uy,uz,u_mag;
+    double ux,uy,uz;
+	// non-conserved moments
+	double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
+	double m3,m5,m7;
+	double nA,nB; // number density
+	double a1,b1,a2,b2,nAB,delta;
+	double C,nx,ny,nz; //color gradient magnitude and direction
+	double phi,tau,rho0,rlx_setA,rlx_setB;
+    double Fcpx,Fcpy,Fcpz;
+
+    //double GeoFun=0.0;//geometric function from Guo's PRE 66, 036304 (2002)
+    double porosity;
+    double perm;//voxel permeability
+    double c0, c1; //Guo's model parameters
+    double tau_eff;
+    double mu_eff;//kinematic viscosity
+    double nx_gs,ny_gs,nz_gs;//grey-solid color gradient
+    double nx_phase,ny_phase,nz_phase,C_phase;
+    double Fx,Fy,Fz;
+
+	const double mrt_V1=0.05263157894736842;
+	const double mrt_V2=0.012531328320802;
+	const double mrt_V3=0.04761904761904762;
+	const double mrt_V4=0.004594820384294068;
+	const double mrt_V5=0.01587301587301587;
+	const double mrt_V6=0.0555555555555555555555555;
+	const double mrt_V7=0.02777777777777778;
+	const double mrt_V8=0.08333333333333333;
+	const double mrt_V9=0.003341687552213868;
+	const double mrt_V10=0.003968253968253968;
+	const double mrt_V11=0.01388888888888889;
+	const double mrt_V12=0.04166666666666666;
+
+	int S = Np/NBLOCKS/NTHREADS + 1;
+	for (int s=0; s<S; s++){
+		//........Get 1-D index for this thread....................
+		n =  S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x + start;
+		if (n<finish) {
+
+			// read the component number densities
+			nA = Den[n];
+			nB = Den[Np + n];
+            porosity = Poros[n];
+            perm = Perm[n];
+            nx_gs = GreySolidGrad[n+0*Np];
+            ny_gs = GreySolidGrad[n+1*Np];
+            nz_gs = GreySolidGrad[n+2*Np];
+
+			// compute phase indicator field
+			phi=(nA-nB)/(nA+nB);
+
+			// local density
+			rho0=rhoA + 0.5*(1.0-phi)*(rhoB-rhoA);
+			// local relaxation time
+			tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
+			tau_eff=tauA_eff + 0.5*(1.0-phi)*(tauB_eff-tauA_eff);
+			rlx_setA = 1.f/tau;
+			rlx_setB = 8.f*(2.f-rlx_setA)/(8.f-rlx_setA);
+            mu_eff = (tau_eff-0.5)/3.0;//kinematic viscosity
+
+			// Get the 1D index based on regular data layout
+			ijk = Map[n];
+			//					COMPUTE THE COLOR GRADIENT
+			//........................................................................
+			//.................Read Phase Indicator Values............................
+			//........................................................................
+			nn = ijk-1;							// neighbor index (get convention)
+			m1 = Phi[nn];						// get neighbor for phi - 1
+			//........................................................................
+			nn = ijk+1;							// neighbor index (get convention)
+			m2 = Phi[nn];						// get neighbor for phi - 2
+			//........................................................................
+			nn = ijk-strideY;							// neighbor index (get convention)
+			m3 = Phi[nn];					// get neighbor for phi - 3
+			//........................................................................
+			nn = ijk+strideY;							// neighbor index (get convention)
+			m4 = Phi[nn];					// get neighbor for phi - 4
+			//........................................................................
+			nn = ijk-strideZ;						// neighbor index (get convention)
+			m5 = Phi[nn];					// get neighbor for phi - 5
+			//........................................................................
+			nn = ijk+strideZ;						// neighbor index (get convention)
+			m6 = Phi[nn];					// get neighbor for phi - 6
+			//........................................................................
+			nn = ijk-strideY-1;						// neighbor index (get convention)
+			m7 = Phi[nn];					// get neighbor for phi - 7
+			//........................................................................
+			nn = ijk+strideY+1;						// neighbor index (get convention)
+			m8 = Phi[nn];					// get neighbor for phi - 8
+			//........................................................................
+			nn = ijk+strideY-1;						// neighbor index (get convention)
+			m9 = Phi[nn];					// get neighbor for phi - 9
+			//........................................................................
+			nn = ijk-strideY+1;						// neighbor index (get convention)
+			m10 = Phi[nn];					// get neighbor for phi - 10
+			//........................................................................
+			nn = ijk-strideZ-1;						// neighbor index (get convention)
+			m11 = Phi[nn];					// get neighbor for phi - 11
+			//........................................................................
+			nn = ijk+strideZ+1;						// neighbor index (get convention)
+			m12 = Phi[nn];					// get neighbor for phi - 12
+			//........................................................................
+			nn = ijk+strideZ-1;						// neighbor index (get convention)
+			m13 = Phi[nn];					// get neighbor for phi - 13
+			//........................................................................
+			nn = ijk-strideZ+1;						// neighbor index (get convention)
+			m14 = Phi[nn];					// get neighbor for phi - 14
+			//........................................................................
+			nn = ijk-strideZ-strideY;					// neighbor index (get convention)
+			m15 = Phi[nn];					// get neighbor for phi - 15
+			//........................................................................
+			nn = ijk+strideZ+strideY;					// neighbor index (get convention)
+			m16 = Phi[nn];					// get neighbor for phi - 16
+			//........................................................................
+			nn = ijk+strideZ-strideY;					// neighbor index (get convention)
+			m17 = Phi[nn];					// get neighbor for phi - 17
+			//........................................................................
+			nn = ijk-strideZ+strideY;					// neighbor index (get convention)
+			m18 = Phi[nn];					// get neighbor for phi - 18
+			//............Compute the Color Gradient...................................
+			nx_phase = -(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+			ny_phase = -(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+			nz_phase = -(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+			C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
+
+            //correct the normal color gradient by considering the effect of grey solid
+            nx = nx_phase + (1.0-porosity)*nx_gs; 
+            ny = ny_phase + (1.0-porosity)*ny_gs; 
+            nz = nz_phase + (1.0-porosity)*nz_gs; 
+            if (C_phase==0.0){
+                nx = nx_phase; 
+                ny = ny_phase;
+                nz = nz_phase;
+            }
+
+			//...........Normalize the Color Gradient.................................
+			C = sqrt(nx*nx+ny*ny+nz*nz);
+			double ColorMag = C;
+			if (C==0.0) ColorMag=1.0;
+			nx = nx/ColorMag;
+			ny = ny/ColorMag;
+			nz = nz/ColorMag;		
+
+			// q=0
+			fq = dist[n];
+			rho = fq;
+			m1  = -30.0*fq;
+			m2  = 12.0*fq;
+
+			// q=1
+			fq = dist[2*Np+n];
+			rho += fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jx = fq;
+			m4 = -4.0*fq;
+			m9 = 2.0*fq;
+			m10 = -4.0*fq;
+
+			// f2 = dist[10*Np+n];
+			fq = dist[1*Np+n];
+			rho += fq;
+			m1 -= 11.0*(fq);
+			m2 -= 4.0*(fq);
+			jx -= fq;
+			m4 += 4.0*(fq);
+			m9 += 2.0*(fq);
+			m10 -= 4.0*(fq);
+
+			// q=3
+			fq = dist[4*Np+n];
+			rho += fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jy = fq;
+			m6 = -4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 = fq;
+			m12 = -2.0*fq;
+
+			// q = 4
+			fq = dist[3*Np+n];
+			rho+= fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jy -= fq;
+			m6 += 4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 += fq;
+			m12 -= 2.0*fq;
+
+			// q=5
+			fq = dist[6*Np+n];
+			rho += fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jz = fq;
+			m8 = -4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 -= fq;
+			m12 += 2.0*fq;
+
+			// q = 6
+			fq = dist[5*Np+n];
+			rho+= fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jz -= fq;
+			m8 += 4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 -= fq;
+			m12 += 2.0*fq;
+
+			// q=7
+			fq = dist[8*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jy += fq;
+			m6 += fq;
+			m9  += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 = fq;
+			m16 = fq;
+			m17 = -fq;
+
+			// q = 8
+			fq = dist[7*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jy -= fq;
+			m6 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 += fq;
+			m16 -= fq;
+			m17 += fq;
+
+			// q=9
+			fq = dist[10*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jy -= fq;
+			m6 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 -= fq;
+			m16 += fq;
+			m17 += fq;
+
+			// q = 10
+			fq = dist[9*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jy += fq;
+			m6 += fq;
+			m9 += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 -= fq;
+			m16 -= fq;
+			m17 -= fq;
+
+			// q=11
+			fq = dist[12*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jz += fq;
+			m8 += fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 = fq;
+			m16 -= fq;
+			m18 = fq;
+
+			// q=12
+			fq = dist[11*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 += fq;
+			m16 += fq;
+			m18 -= fq;
+
+			// q=13
+			fq = dist[14*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 -= fq;
+			m16 -= fq;
+			m18 -= fq;
+
+			// q=14
+			fq = dist[13*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jz += fq;
+			m8 += fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 -= fq;
+			m16 += fq;
+			m18 += fq;
+
+			// q=15
+			fq = dist[16*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy += fq;
+			m6 += fq;
+			jz += fq;
+			m8 += fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 = fq;
+			m17 += fq;
+			m18 -= fq;
+
+			// q=16
+			fq = dist[15*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy -= fq;
+			m6 -= fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 += fq;
+			m17 -= fq;
+			m18 += fq;
+
+			// q=17
+			fq = dist[18*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy += fq;
+			m6 += fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 -= fq;
+			m17 += fq;
+			m18 += fq;
+
+			// q=18
+			fq = dist[17*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy -= fq;
+			m6 -= fq;
+			jz += fq;
+			m8 += fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 -= fq;
+			m17 -= fq;
+			m18 -= fq;
+
+            // Compute greyscale related parameters
+            c0 = 0.5*(1.0+porosity*0.5*mu_eff/perm);
+            if (porosity==1.0) c0 = 0.5;//i.e. apparent pore nodes
+            //GeoFun = 1.75/sqrt(150.0*porosity*porosity*porosity);
+            c1 = porosity*0.5*GeoFun/sqrt(perm);
+            if (porosity==1.0) c1 = 0.0;//i.e. apparent pore nodes
+
+            vx = jx/rho0+0.5*(porosity*Gx);
+            vy = jy/rho0+0.5*(porosity*Gy);
+            vz = jz/rho0+0.5*(porosity*Gz);
+            v_mag=sqrt(vx*vx+vy*vy+vz*vz);
+            ux = vx/(c0+sqrt(c0*c0+c1*v_mag));
+            uy = vy/(c0+sqrt(c0*c0+c1*v_mag));
+            uz = vz/(c0+sqrt(c0*c0+c1*v_mag));
+            u_mag=sqrt(ux*ux+uy*uy+uz*uz);
+
+            //Update the total force to include linear (Darcy) and nonlinear (Forchheimer) drags due to the porous medium
+            Fx = rho0*(-porosity*mu_eff/perm*ux - porosity*GeoFun/sqrt(perm)*u_mag*ux + porosity*Gx);
+            Fy = rho0*(-porosity*mu_eff/perm*uy - porosity*GeoFun/sqrt(perm)*u_mag*uy + porosity*Gy);
+            Fz = rho0*(-porosity*mu_eff/perm*uz - porosity*GeoFun/sqrt(perm)*u_mag*uz + porosity*Gz);
+            if (porosity==1.0){
+                Fx=rho0*(Gx);
+                Fy=rho0*(Gy);
+                Fz=rho0*(Gz);
+            }
+
+			// write the velocity 
+			Velocity[n] = ux;
+			Velocity[Np+n] = uy;
+			Velocity[2*Np+n] = uz;
+            //Pressure[n] = rho/3.f/porosity;
+            Pressure[n] = rho/3.f;
+
+			//........................................................................
+			//..............carry out relaxation process..............................
+			//..........Toelke, Fruediger et. al. 2006................................
+            //---------------- NO higher-order force -------------------------------//
+			if (C == 0.0)	nx = ny = nz = 0.0;
+			m1 = m1 + rlx_setA*((19*(ux*ux+uy*uy+uz*uz)*rho0/porosity - 11*rho) -19*alpha*C - m1);
+			m2 = m2 + rlx_setA*((3*rho - 5.5*(ux*ux+uy*uy+uz*uz)*rho0/porosity)- m2);
+            jx = jx + Fx;
+			m4 = m4 + rlx_setB*((-0.6666666666666666*ux*rho0)- m4)
+                    + (1-0.5*rlx_setB)*(-0.6666666666666666*Fx);
+            jy = jy + Fy;
+			m6 = m6 + rlx_setB*((-0.6666666666666666*uy*rho0)- m6)
+                    + (1-0.5*rlx_setB)*(-0.6666666666666666*Fy);
+            jz = jz + Fz;
+			m8 = m8 + rlx_setB*((-0.6666666666666666*uz*rho0)- m8)
+                    + (1-0.5*rlx_setB)*(-0.6666666666666666*Fz);
+			m9 = m9 + rlx_setA*(((2*ux*ux-uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(2*nx*nx-ny*ny-nz*nz) - m9);
+			m10 = m10 + rlx_setA*( - m10);
+            //m10 = m10 + rlx_setA*(-0.5*rho0*((2*ux*ux-uy*uy-uz*uz)/porosity)- m10);
+			m11 = m11 + rlx_setA*(((uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(ny*ny-nz*nz)- m11);
+			m12 = m12 + rlx_setA*( - m12);
+            //m12 = m12 + rlx_setA*(-0.5*(rho0*(uy*uy-uz*uz)/porosity)- m12);
+			m13 = m13 + rlx_setA*( (ux*uy*rho0/porosity) + 0.5*alpha*C*nx*ny - m13);
+			m14 = m14 + rlx_setA*( (uy*uz*rho0/porosity) + 0.5*alpha*C*ny*nz - m14);
+			m15 = m15 + rlx_setA*( (ux*uz*rho0/porosity) + 0.5*alpha*C*nx*nz - m15);
+			m16 = m16 + rlx_setB*( - m16);
+			m17 = m17 + rlx_setB*( - m17);
+			m18 = m18 + rlx_setB*( - m18);
+            //----------------------------------------------------------------------//
+
+            //----------------With higher-order force ------------------------------//
+			//if (C == 0.0)	nx = ny = nz = 0.0;
+			//m1 = m1 + rlx_setA*((19*(ux*ux+uy*uy+uz*uz)*rho0/porosity - 11*rho) -19*alpha*C - m1)
+            //        + (1-0.5*rlx_setA)*38*(Fx*ux+Fy*uy+Fz*uz)/porosity;
+			//m2 = m2 + rlx_setA*((3*rho - 5.5*(ux*ux+uy*uy+uz*uz)*rho0/porosity)- m2)
+            //        + (1-0.5*rlx_setA)*11*(-Fx*ux-Fy*uy-Fz*uz)/porosity;
+            //jx = jx + Fx;
+			//m4 = m4 + rlx_setB*((-0.6666666666666666*ux*rho0)- m4)
+            //        + (1-0.5*rlx_setB)*(-0.6666666666666666*Fx);
+            //jy = jy + Fy;
+			//m6 = m6 + rlx_setB*((-0.6666666666666666*uy*rho0)- m6)
+            //        + (1-0.5*rlx_setB)*(-0.6666666666666666*Fy);
+            //jz = jz + Fz;
+			//m8 = m8 + rlx_setB*((-0.6666666666666666*uz*rho0)- m8)
+            //        + (1-0.5*rlx_setB)*(-0.6666666666666666*Fz);
+			//m9 = m9 + rlx_setA*(((2*ux*ux-uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(2*nx*nx-ny*ny-nz*nz) - m9)
+            //        + (1-0.5*rlx_setA)*(4*Fx*ux-2*Fy*uy-2*Fz*uz)/porosity;
+			////m10 = m10 + rlx_setA*( - m10);
+            //m10 = m10 + rlx_setA*(-0.5*rho0*((2*ux*ux-uy*uy-uz*uz)/porosity)- m10)
+            //          + (1-0.5*rlx_setA)*(-2*Fx*ux+Fy*uy+Fz*uz)/porosity;
+			//m11 = m11 + rlx_setA*(((uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(ny*ny-nz*nz)- m11)
+            //          + (1-0.5*rlx_setA)*(2*Fy*uy-2*Fz*uz)/porosity;
+			////m12 = m12 + rlx_setA*( - m12);
+            //m12 = m12 + rlx_setA*(-0.5*(rho0*(uy*uy-uz*uz)/porosity)- m12)
+            //          + (1-0.5*rlx_setA)*(-Fy*uy+Fz*uz)/porosity;
+			//m13 = m13 + rlx_setA*( (ux*uy*rho0/porosity) + 0.5*alpha*C*nx*ny - m13);
+            //          + (1-0.5*rlx_setA)*(Fy*ux+Fx*uy)/porosity;
+			//m14 = m14 + rlx_setA*( (uy*uz*rho0/porosity) + 0.5*alpha*C*ny*nz - m14);
+            //          + (1-0.5*rlx_setA)*(Fz*uy+Fy*uz)/porosity;
+			//m15 = m15 + rlx_setA*( (ux*uz*rho0/porosity) + 0.5*alpha*C*nx*nz - m15);
+            //          + (1-0.5*rlx_setA)*(Fz*ux+Fx*uz)/porosity;
+			//m16 = m16 + rlx_setB*( - m16);
+			//m17 = m17 + rlx_setB*( - m17);
+			//m18 = m18 + rlx_setB*( - m18);
+            //----------------------------------------------------------------------//
+
+			//.................inverse transformation......................................................
+			// q=0
+			fq = mrt_V1*rho-mrt_V2*m1+mrt_V3*m2;
+			dist[n] = fq;
+
+			// q = 1
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jx-m4)+mrt_V6*(m9-m10);
+			dist[1*Np+n] = fq;
+
+			// q=2
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m4-jx)+mrt_V6*(m9-m10);
+			dist[2*Np+n] = fq;
+
+			// q = 3
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jy-m6)+mrt_V7*(m10-m9)+mrt_V8*(m11-m12);
+			dist[3*Np+n] = fq;
+
+			// q = 4
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m6-jy)+mrt_V7*(m10-m9)+mrt_V8*(m11-m12);
+			dist[4*Np+n] = fq;
+
+			// q = 5
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jz-m8)+mrt_V7*(m10-m9)+mrt_V8*(m12-m11);
+			dist[5*Np+n] = fq;
+
+			// q = 6
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m8-jz)+mrt_V7*(m10-m9)+mrt_V8*(m12-m11);
+			dist[6*Np+n] = fq;
+
+			// q = 7
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jx+jy)+0.025*(m4+m6)+
+					mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12+0.25*m13+0.125*(m16-m17);
+			dist[7*Np+n] = fq;
+
+
+			// q = 8
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2-0.1*(jx+jy)-0.025*(m4+m6) +mrt_V7*m9+mrt_V11*m10+mrt_V8*m11
+					+mrt_V12*m12+0.25*m13+0.125*(m17-m16);
+			dist[8*Np+n] = fq;
+
+			// q = 9
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jx-jy)+0.025*(m4-m6)+
+					mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12-0.25*m13+0.125*(m16+m17);
+			dist[9*Np+n] = fq;
+
+			// q = 10
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jy-jx)+0.025*(m6-m4)+
+					mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12-0.25*m13-0.125*(m16+m17);
+			dist[10*Np+n] = fq;
+
+
+			// q = 11
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jx+jz)+0.025*(m4+m8)
+					+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+					-mrt_V12*m12+0.25*m15+0.125*(m18-m16);
+			dist[11*Np+n] = fq;
+
+			// q = 12
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2-0.1*(jx+jz)-0.025*(m4+m8)+
+					mrt_V7*m9+mrt_V11*m10-mrt_V8*m11-mrt_V12*m12+0.25*m15+0.125*(m16-m18);
+			dist[12*Np+n] = fq;
+
+			// q = 13
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jx-jz)+0.025*(m4-m8)
+					+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+					-mrt_V12*m12-0.25*m15-0.125*(m16+m18);
+			dist[13*Np+n] = fq;
+
+			// q= 14
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jz-jx)+0.025*(m8-m4)
+					+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+					-mrt_V12*m12-0.25*m15+0.125*(m16+m18);
+
+			dist[14*Np+n] = fq;
+
+			// q = 15
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jy+jz)+0.025*(m6+m8)
+					-mrt_V6*m9-mrt_V7*m10+0.25*m14+0.125*(m17-m18);
+			dist[15*Np+n] = fq;
+
+			// q = 16
+			fq =  mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2-0.1*(jy+jz)-0.025*(m6+m8)
+					-mrt_V6*m9-mrt_V7*m10+0.25*m14+0.125*(m18-m17);
+			dist[16*Np+n] = fq;
+
+
+			// q = 17
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jy-jz)+0.025*(m6-m8)
+					-mrt_V6*m9-mrt_V7*m10-0.25*m14+0.125*(m17+m18);
+			dist[17*Np+n] = fq;
+
+			// q = 18
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jz-jy)+0.025*(m8-m6)
+					-mrt_V6*m9-mrt_V7*m10-0.25*m14-0.125*(m17+m18);
+			dist[18*Np+n] = fq;
+			//........................................................................
+
+			// Instantiate mass transport distributions
+			// Stationary value - distribution 0
+			nAB = 1.0/(nA+nB);
+			Aq[n] = 0.3333333333333333*nA;
+			Bq[n] = 0.3333333333333333*nB;
+
+			//...............................................
+			// q = 0,2,4
+			// Cq = {1,0,0}, {0,1,0}, {0,0,1}
+			delta = beta*nA*nB*nAB*0.1111111111111111*nx;
+			if (!(nA*nB*nAB>0)) delta=0;
+			a1 = nA*(0.1111111111111111*(1+4.5*ux))+delta;
+			b1 = nB*(0.1111111111111111*(1+4.5*ux))-delta;
+			a2 = nA*(0.1111111111111111*(1-4.5*ux))-delta;
+			b2 = nB*(0.1111111111111111*(1-4.5*ux))+delta;
+
+			Aq[1*Np+n] = a1;
+			Bq[1*Np+n] = b1;
+			Aq[2*Np+n] = a2;
+			Bq[2*Np+n] = b2;
+
+			//...............................................
+			// q = 2
+			// Cq = {0,1,0}
+			delta = beta*nA*nB*nAB*0.1111111111111111*ny;
+			if (!(nA*nB*nAB>0)) delta=0;
+			a1 = nA*(0.1111111111111111*(1+4.5*uy))+delta;
+			b1 = nB*(0.1111111111111111*(1+4.5*uy))-delta;
+			a2 = nA*(0.1111111111111111*(1-4.5*uy))-delta;
+			b2 = nB*(0.1111111111111111*(1-4.5*uy))+delta;
+
+			Aq[3*Np+n] = a1;
+			Bq[3*Np+n] = b1;
+			Aq[4*Np+n] = a2;
+			Bq[4*Np+n] = b2;
+			//...............................................
+			// q = 4
+			// Cq = {0,0,1}
+			delta = beta*nA*nB*nAB*0.1111111111111111*nz;
+			if (!(nA*nB*nAB>0)) delta=0;
+			a1 = nA*(0.1111111111111111*(1+4.5*uz))+delta;
+			b1 = nB*(0.1111111111111111*(1+4.5*uz))-delta;
+			a2 = nA*(0.1111111111111111*(1-4.5*uz))-delta;
+			b2 = nB*(0.1111111111111111*(1-4.5*uz))+delta;
+
+			Aq[5*Np+n] = a1;
+			Bq[5*Np+n] = b1;
+			Aq[6*Np+n] = a2;
+			Bq[6*Np+n] = b2;
+			//...............................................
+
+		}
+	}
+}
+
 __global__ void dvc_ScaLBL_PhaseField_InitFromRestart(double *Den, double *Aq, double *Bq, int start, int finish, int Np){
 	int idx;
 	double nA,nB;

From dfac3e134954a3e32a095e828d79c5dd53a89716 Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Sun, 28 Feb 2021 18:27:16 -0500
Subject: [PATCH 02/19] continue to add capillary penalty to pressure; to be
 compiled and tested

---
 common/ScaLBL.h                |  10 +++
 cuda/GreyscaleColor.cu         | 115 +++++++++++++++++++++------------
 models/GreyscaleColorModel.cpp |  50 ++++++++++----
 models/GreyscaleColorModel.h   |   2 +
 4 files changed, 121 insertions(+), 56 deletions(-)

diff --git a/common/ScaLBL.h b/common/ScaLBL.h
index 42c51525..007bb35f 100644
--- a/common/ScaLBL.h
+++ b/common/ScaLBL.h
@@ -87,6 +87,16 @@ extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor(int *d_neighborList, int *Map,
         double rhoA, double rhoB, double tauA, double tauB, double tauA_eff,double tauB_eff, double alpha, double beta,
 		double Fx, double Fy, double Fz, int strideY, int strideZ, int start, int finish, int Np);
 
+extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
+        double *Phi,double *GreySolidGrad, double *Poros,double *Perm,double *Vel, double *Pressure,
+        double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
+		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np);
+
+extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *d_neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den, 
+		double *Phi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel,double *Pressure, 
+        double rhoA, double rhoB, double tauA, double tauB, double tauA_eff,double tauB_eff, double alpha, double beta,
+		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np);
+
 // ION TRANSPORT MODEL
 
 extern "C" void ScaLBL_D3Q7_AAodd_IonConcentration(int *neighborList, double *dist, double *Den, int start, int finish, int Np);
diff --git a/cuda/GreyscaleColor.cu b/cuda/GreyscaleColor.cu
index 0cc49bcd..906782c9 100644
--- a/cuda/GreyscaleColor.cu
+++ b/cuda/GreyscaleColor.cu
@@ -1452,7 +1452,7 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor(int *Map, double *dist,
 __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den,
 		 double *Phi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure,
          double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff,double alpha, double beta,
-		double Gx, double Gy, double Gz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np){
+		double Gx, double Gy, double Gz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
 
 	int n,nn,ijk,nread;
 	int nr1,nr2,nr3,nr4,nr5,nr6;
@@ -1472,12 +1472,12 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 	double a1,b1,a2,b2,nAB,delta;
 	double C,nx,ny,nz; //color gradient magnitude and direction
 	double phi,tau,rho0,rlx_setA,rlx_setB;
-    double Fcpx,Fcpy,Fcpz;
+    double cp;//capillary pressure penalty - pressure term
 
     //double GeoFun=0.0;//geometric function from Guo's PRE 66, 036304 (2002)
     double porosity;
     double perm;//voxel permeability
-    double c0, c1; //Guo's model parameters
+    //double c0, c1; //Guo's model parameters
     double tau_eff;
     double mu_eff;//kinematic viscosity
     double nx_gs,ny_gs,nz_gs;//grey-solid color gradient
@@ -1606,16 +1606,6 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			nx = nx/ColorMag;
 			ny = ny/ColorMag;
 			nz = nz/ColorMag;		
-            //----------- Introduce capillary penalty force -------------------------
-            //NOTE: apply only to grey nodes
-            Fcpx = 0.5*alpha*C*W/sqrt(perm)*nx;
-            Fcpy = 0.5*alpha*C*W/sqrt(perm)*ny;
-            Fcpz = 0.5*alpha*C*W/sqrt(perm)*nz;
-            if (porosity==1.0){
-                Fcpx = 0.0;
-                Fcpy = 0.0;
-                Fcpz = 0.0;
-            }
 
 			// q=0
 			fq = dist[n];
@@ -1939,14 +1929,14 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			m18 -= fq;
 			
             //// Compute greyscale related parameters
-            ux = (jx/rho0+0.5*porosity*Gx+0.5*Fcpx/rho0)/(1.0+0.5*porosity*mu_eff/perm);
-            uy = (jy/rho0+0.5*porosity*Gy+0.5*Fcpy/rho0)/(1.0+0.5*porosity*mu_eff/perm);
-            uz = (jz/rho0+0.5*porosity*Gz+0.5*Fcpz/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            ux = (jx/rho0+0.5*porosity*Gx)/(1.0+0.5*porosity*mu_eff/perm);
+            uy = (jy/rho0+0.5*porosity*Gy)/(1.0+0.5*porosity*mu_eff/perm);
+            uz = (jz/rho0+0.5*porosity*Gz)/(1.0+0.5*porosity*mu_eff/perm);
 
             //Update the total force to include linear (Darcy) and nonlinear (Forchheimer) drags due to the porous medium
-            Fx = rho0*(-porosity*mu_eff/perm*ux + porosity*Gx)+Fcpx;
-            Fy = rho0*(-porosity*mu_eff/perm*uy + porosity*Gy)+Fcpy;
-            Fz = rho0*(-porosity*mu_eff/perm*uz + porosity*Gz)+Fcpz;
+            Fx = rho0*(-porosity*mu_eff/perm*ux + porosity*Gx);
+            Fy = rho0*(-porosity*mu_eff/perm*uy + porosity*Gy);
+            Fz = rho0*(-porosity*mu_eff/perm*uz + porosity*Gz);
             if (porosity==1.0){
                 Fx=rho0*(porosity*Gx);
                 Fy=rho0*(porosity*Gy);
@@ -1960,6 +1950,14 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
             //Pressure[n] = rho/3.f/porosity;
             Pressure[n] = rho/3.f;
 
+            //----------- Introduce capillary penalty force -------------------------
+            //NOTE: apply only to grey nodes
+            cp = 0.1*tanh(W*alpha*phi/sqrt(perm));//the extra factor of 0.1 is to make sure cp is bounded within [-0.1,0.1]
+            if (porosity==1.0){
+                cp = 0.0;
+            }
+            rho += cp;//pressure perturbation
+
 			//........................................................................
 			//..............carry out relaxation process..............................
 			//..........Toelke, Fruediger et. al. 2006................................
@@ -2220,7 +2218,7 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
         double *Phi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure, 
         double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
-		double Gx, double Gy, double Gz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np){
+		double Gx, double Gy, double Gz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
 	int ijk,nn,n;
 	double fq;
 	// conserved momemnts
@@ -2235,12 +2233,12 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 	double a1,b1,a2,b2,nAB,delta;
 	double C,nx,ny,nz; //color gradient magnitude and direction
 	double phi,tau,rho0,rlx_setA,rlx_setB;
-    double Fcpx,Fcpy,Fcpz;
+    double cp;//capillary pressure penalty - pressure term
 
     //double GeoFun=0.0;//geometric function from Guo's PRE 66, 036304 (2002)
     double porosity;
     double perm;//voxel permeability
-    double c0, c1; //Guo's model parameters
+    //double c0, c1; //Guo's model parameters
     double tau_eff;
     double mu_eff;//kinematic viscosity
     double nx_gs,ny_gs,nz_gs;//grey-solid color gradient
@@ -2640,30 +2638,19 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			m17 -= fq;
 			m18 -= fq;
 
-            // Compute greyscale related parameters
-            c0 = 0.5*(1.0+porosity*0.5*mu_eff/perm);
-            if (porosity==1.0) c0 = 0.5;//i.e. apparent pore nodes
-            //GeoFun = 1.75/sqrt(150.0*porosity*porosity*porosity);
-            c1 = porosity*0.5*GeoFun/sqrt(perm);
-            if (porosity==1.0) c1 = 0.0;//i.e. apparent pore nodes
-
-            vx = jx/rho0+0.5*(porosity*Gx);
-            vy = jy/rho0+0.5*(porosity*Gy);
-            vz = jz/rho0+0.5*(porosity*Gz);
-            v_mag=sqrt(vx*vx+vy*vy+vz*vz);
-            ux = vx/(c0+sqrt(c0*c0+c1*v_mag));
-            uy = vy/(c0+sqrt(c0*c0+c1*v_mag));
-            uz = vz/(c0+sqrt(c0*c0+c1*v_mag));
-            u_mag=sqrt(ux*ux+uy*uy+uz*uz);
+            //// Compute greyscale related parameters
+            ux = (jx/rho0+0.5*porosity*Gx)/(1.0+0.5*porosity*mu_eff/perm);
+            uy = (jy/rho0+0.5*porosity*Gy)/(1.0+0.5*porosity*mu_eff/perm);
+            uz = (jz/rho0+0.5*porosity*Gz)/(1.0+0.5*porosity*mu_eff/perm);
 
             //Update the total force to include linear (Darcy) and nonlinear (Forchheimer) drags due to the porous medium
-            Fx = rho0*(-porosity*mu_eff/perm*ux - porosity*GeoFun/sqrt(perm)*u_mag*ux + porosity*Gx);
-            Fy = rho0*(-porosity*mu_eff/perm*uy - porosity*GeoFun/sqrt(perm)*u_mag*uy + porosity*Gy);
-            Fz = rho0*(-porosity*mu_eff/perm*uz - porosity*GeoFun/sqrt(perm)*u_mag*uz + porosity*Gz);
+            Fx = rho0*(-porosity*mu_eff/perm*ux + porosity*Gx);
+            Fy = rho0*(-porosity*mu_eff/perm*uy + porosity*Gy);
+            Fz = rho0*(-porosity*mu_eff/perm*uz + porosity*Gz);
             if (porosity==1.0){
-                Fx=rho0*(Gx);
-                Fy=rho0*(Gy);
-                Fz=rho0*(Gz);
+                Fx=rho0*(porosity*Gx);
+                Fy=rho0*(porosity*Gy);
+                Fz=rho0*(porosity*Gz);
             }
 
 			// write the velocity 
@@ -2673,6 +2660,14 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
             //Pressure[n] = rho/3.f/porosity;
             Pressure[n] = rho/3.f;
 
+            //----------- Introduce capillary penalty force -------------------------
+            //NOTE: apply only to grey nodes
+            cp = 0.1*tanh(W*alpha*phi/sqrt(perm));//the extra factor of 0.1 is to make sure cp is bounded within [-0.1,0.1]
+            if (porosity==1.0){
+                cp = 0.0;
+            }
+            rho += cp;//pressure perturbation
+
 			//........................................................................
 			//..............carry out relaxation process..............................
 			//..........Toelke, Fruediger et. al. 2006................................
@@ -2854,6 +2849,7 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			// Cq = {1,0,0}, {0,1,0}, {0,0,1}
 			delta = beta*nA*nB*nAB*0.1111111111111111*nx;
 			if (!(nA*nB*nAB>0)) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*ux))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*ux))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*ux))-delta;
@@ -2869,6 +2865,7 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			// Cq = {0,1,0}
 			delta = beta*nA*nB*nAB*0.1111111111111111*ny;
 			if (!(nA*nB*nAB>0)) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*uy))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*uy))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*uy))-delta;
@@ -2883,6 +2880,7 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			// Cq = {0,0,1}
 			delta = beta*nA*nB*nAB*0.1111111111111111*nz;
 			if (!(nA*nB*nAB>0)) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*uz))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*uz))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*uz))-delta;
@@ -4448,6 +4446,37 @@ extern "C" void ScaLBL_PhaseField_InitFromRestart(double *Den, double *Aq, doubl
 		printf("CUDA error in ScaLBL_PhaseField_InitFromRestart: %s \n",cudaGetErrorString(err));
 	}
 }
+
+//Model-1 & 4 with capillary pressure penalty
+extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
+        double *Phi,double *GreySolidGrad, double *Poros,double *Perm,double *Vel, double *Pressure,
+        double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
+		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
+
+	dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP<<<NBLOCKS,NTHREADS >>>(Map, dist, Aq, Bq, Den, Phi, GreySolidGrad, Poros, Perm, Vel, Pressure,
+            rhoA, rhoB, tauA, tauB, tauA_eff, tauB_eff, alpha, beta, Fx, Fy, Fz, RecoloringOff, W, strideY, strideZ, start, finish, Np);
+	cudaError_t err = cudaGetLastError();
+	if (cudaSuccess != err){
+		printf("CUDA error in ScaLBL_D3Q19_AAeven_GreyscaleColor_CP: %s \n",cudaGetErrorString(err));
+	}
+
+}
+
+//Model-1 & 4 with capillary pressure penalty
+extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *d_neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den, 
+		double *Phi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel,double *Pressure, 
+        double rhoA, double rhoB, double tauA, double tauB, double tauA_eff,double tauB_eff, double alpha, double beta,
+		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
+
+	dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP<<<NBLOCKS,NTHREADS >>>(d_neighborList, Map, dist, Aq, Bq, Den, Phi,  GreySolidGrad, Poros, Perm,Vel,Pressure,
+			rhoA, rhoB, tauA, tauB, tauA_eff, tauB_eff,alpha, beta, Fx, Fy, Fz, RecoloringOff, W, strideY, strideZ, start, finish, Np);
+
+	cudaError_t err = cudaGetLastError();
+	if (cudaSuccess != err){
+		printf("CUDA error in ScaLBL_D3Q19_AAodd_GreyscaleColor_CP: %s \n",cudaGetErrorString(err));
+	}
+}
+
 ////Model-2&3
 //extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
 //        double *Phi,double *GreySolidGrad, double *Poros,double *Perm,double *Vel, 
diff --git a/models/GreyscaleColorModel.cpp b/models/GreyscaleColorModel.cpp
index 5d2b4d07..d5ecea2d 100644
--- a/models/GreyscaleColorModel.cpp
+++ b/models/GreyscaleColorModel.cpp
@@ -17,7 +17,7 @@ void DeleteArray( const TYPE *p )
 
 ScaLBL_GreyscaleColorModel::ScaLBL_GreyscaleColorModel(int RANK, int NP, const Utilities::MPI& COMM):
 rank(RANK), nprocs(NP), Restart(0),timestep(0),timestepMax(0),tauA(0),tauB(0),tauA_eff(0),tauB_eff(0),rhoA(0),rhoB(0),alpha(0),beta(0),
-Fx(0),Fy(0),Fz(0),flux(0),din(0),dout(0),inletA(0),inletB(0),outletA(0),outletB(0),GreyPorosity(0),
+Fx(0),Fy(0),Fz(0),flux(0),din(0),dout(0),inletA(0),inletB(0),outletA(0),outletB(0),GreyPorosity(0),RecoloringOff(0),W(0),
 Nx(0),Ny(0),Nz(0),N(0),Np(0),nprocx(0),nprocy(0),nprocz(0),BoundaryCondition(0),Lx(0),Ly(0),Lz(0),comm(COMM)
 {
 	REVERSE_FLOW_DIRECTION = false;
@@ -43,6 +43,8 @@ void ScaLBL_GreyscaleColorModel::ReadParams(string filename){
 	Restart=false;
 	din=dout=1.0;
 	flux=0.0;
+    RecoloringOff = false;
+    W=1.0;
 	
 	// Color Model parameters
 	if (greyscaleColor_db->keyExists( "timestepMax" )){
@@ -85,6 +87,12 @@ void ScaLBL_GreyscaleColorModel::ReadParams(string filename){
 	if (greyscaleColor_db->keyExists( "flux" )){
 		flux = greyscaleColor_db->getScalar<double>( "flux" );
 	}
+	if (greyscaleColor_db->keyExists( "RecoloringOff" )){
+		RecoloringOff = greyscaleColor_db->getScalar<bool>( "RecoloringOff" );
+	}
+	if (greyscaleColor_db->keyExists( "W" )){
+		W = greyscaleColor_db->getScalar<double>( "W" );
+	}
 	inletA=1.f;
 	inletB=0.f;
 	outletA=0.f;
@@ -943,10 +951,14 @@ void ScaLBL_GreyscaleColorModel::Run(){
 		}
 		// Halo exchange for phase field
 		ScaLBL_Comm_Regular->SendHalo(Phi);
-        //Model-1&4
-        ScaLBL_D3Q19_AAodd_GreyscaleColor(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
+        //Model-1&4 with capillary pressure penalty for grey nodes
+        ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
                 rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff, 
-                alpha, beta, Fx, Fy, Fz, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+                alpha, beta, Fx, Fy, Fz, RecoloringOff, W, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+        //Model-1&4
+        //ScaLBL_D3Q19_AAodd_GreyscaleColor(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
+        //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff, 
+        //        alpha, beta, Fx, Fy, Fz, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
         ////Model-2&3
         //ScaLBL_D3Q19_AAodd_GreyscaleColor(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidPhi,Porosity_dvc,Permeability_dvc,Velocity, 
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff, 
@@ -968,10 +980,14 @@ void ScaLBL_GreyscaleColorModel::Run(){
 			ScaLBL_Comm->D3Q19_Reflection_BC_Z(fq);
 		}
 
-        //Model-1&4
-        ScaLBL_D3Q19_AAodd_GreyscaleColor(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
+        //Model-1&4 with capillary pressure penalty for grey nodes
+        ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
                 rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
-                alpha, beta, Fx, Fy, Fz, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
+                alpha, beta, Fx, Fy, Fz, RecoloringOff, W, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
+        //Model-1&4
+        //ScaLBL_D3Q19_AAodd_GreyscaleColor(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
+        //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
+        //        alpha, beta, Fx, Fy, Fz, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
         ////Model-2&3
         //ScaLBL_D3Q19_AAodd_GreyscaleColor(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidPhi,Porosity_dvc,Permeability_dvc,Velocity,
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
@@ -995,10 +1011,14 @@ void ScaLBL_GreyscaleColorModel::Run(){
 			ScaLBL_Comm->Color_BC_Z(dvcMap, Phi, Den, outletA, outletB);
 		}
 		ScaLBL_Comm_Regular->SendHalo(Phi);
-        //Model-1&4
-        ScaLBL_D3Q19_AAeven_GreyscaleColor(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure, 
+        //Model-1&4 with capillary pressure penalty for grey nodes
+        ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure, 
                 rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
-                alpha, beta, Fx, Fy, Fz,  Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+                alpha, beta, Fx, Fy, Fz, RecoloringOff, W, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+        //Model-1&4
+        //ScaLBL_D3Q19_AAeven_GreyscaleColor(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure, 
+        //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
+        //        alpha, beta, Fx, Fy, Fz,  Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
         ////Model-2&3
         //ScaLBL_D3Q19_AAeven_GreyscaleColor(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidPhi,Porosity_dvc,Permeability_dvc,Velocity, 
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
@@ -1020,10 +1040,14 @@ void ScaLBL_GreyscaleColorModel::Run(){
 			ScaLBL_Comm->D3Q19_Reflection_BC_Z(fq);
 		}
 
-        //Model-1&4
-        ScaLBL_D3Q19_AAeven_GreyscaleColor(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
+        //Model-1&4 with capillary pressure penalty for grey nodes
+        ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
                 rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
-                alpha, beta, Fx, Fy, Fz, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
+                alpha, beta, Fx, Fy, Fz, RecoloringOff, W, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
+        //Model-1&4
+        //ScaLBL_D3Q19_AAeven_GreyscaleColor(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
+        //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
+        //        alpha, beta, Fx, Fy, Fz, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
         ////Model-2&3
         //ScaLBL_D3Q19_AAeven_GreyscaleColor(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidPhi,Porosity_dvc,Permeability_dvc,Velocity,
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
diff --git a/models/GreyscaleColorModel.h b/models/GreyscaleColorModel.h
index 667099e9..dd25e613 100644
--- a/models/GreyscaleColorModel.h
+++ b/models/GreyscaleColorModel.h
@@ -39,6 +39,8 @@ public:
 	double Fx,Fy,Fz,flux;
 	double din,dout,inletA,inletB,outletA,outletB;
     double GreyPorosity;
+    bool RecoloringOff;//recoloring can be turn off for grey nodes if this is true
+    double W;//wetting strength paramter for capillary pressure penalty for grey nodes
 	
 	int Nx,Ny,Nz,N,Np;
 	int rank,nprocx,nprocy,nprocz,nprocs;

From 6aeb038fce252b33ac47058dfd00fbd094b61845 Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Wed, 3 Mar 2021 20:25:26 -0500
Subject: [PATCH 03/19] update the cap penalty formulation; to be built and
 verified

---
 common/ScaLBL.h                |   3 +
 cuda/GreyscaleColor.cu         | 155 +++++++++++++++++++++++++--------
 models/GreyscaleColorModel.cpp |  94 ++++++++++++++++++--
 models/GreyscaleColorModel.h   |   1 +
 4 files changed, 209 insertions(+), 44 deletions(-)

diff --git a/common/ScaLBL.h b/common/ScaLBL.h
index 007bb35f..762efb20 100644
--- a/common/ScaLBL.h
+++ b/common/ScaLBL.h
@@ -97,6 +97,9 @@ extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *d_neighborList, int *M
         double rhoA, double rhoB, double tauA, double tauB, double tauA_eff,double tauB_eff, double alpha, double beta,
 		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np);
 
+extern "C" void ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
+		int start, int finish);
+
 // ION TRANSPORT MODEL
 
 extern "C" void ScaLBL_D3Q7_AAodd_IonConcentration(int *neighborList, double *dist, double *Den, int start, int finish, int Np);
diff --git a/cuda/GreyscaleColor.cu b/cuda/GreyscaleColor.cu
index 906782c9..ee989bba 100644
--- a/cuda/GreyscaleColor.cu
+++ b/cuda/GreyscaleColor.cu
@@ -1450,9 +1450,9 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor(int *Map, double *dist,
 //CP: capillary penalty
 // also turn off recoloring for grey nodes
 __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den,
-		 double *Phi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure,
+		 double *Phi, double *Psi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure,
          double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff,double alpha, double beta,
-		double Gx, double Gy, double Gz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
+		double Gx, double Gy, double Gz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np){
 
 	int n,nn,ijk,nread;
 	int nr1,nr2,nr3,nr4,nr5,nr6;
@@ -1472,7 +1472,7 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 	double a1,b1,a2,b2,nAB,delta;
 	double C,nx,ny,nz; //color gradient magnitude and direction
 	double phi,tau,rho0,rlx_setA,rlx_setB;
-    double cp;//capillary pressure penalty - pressure term
+    double psi;//greyscale potential
 
     //double GeoFun=0.0;//geometric function from Guo's PRE 66, 036304 (2002)
     double porosity;
@@ -1483,6 +1483,9 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
     double nx_gs,ny_gs,nz_gs;//grey-solid color gradient
     double nx_phase,ny_phase,nz_phase,C_phase;
     double Fx,Fy,Fz;
+	double gp1,gp2,gp4,gp6,gp8,gp9,gp10,gp11,gp12,gp13,gp14,gp15,gp16,gp17,gp18;
+	double gp3,gp5,gp7;
+    double Fcpx,Fcpy,Fcpz;//capillary penalty force
 
 	const double mrt_V1=0.05263157894736842;
 	const double mrt_V2=0.012531328320802;
@@ -1532,62 +1535,85 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			//........................................................................
 			nn = ijk-1;							// neighbor index (get convention)
 			m1 = Phi[nn];						// get neighbor for phi - 1
+            gp1 = Psi[nn];
 			//........................................................................
 			nn = ijk+1;							// neighbor index (get convention)
 			m2 = Phi[nn];						// get neighbor for phi - 2
+            gp2 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideY;							// neighbor index (get convention)
 			m3 = Phi[nn];					// get neighbor for phi - 3
+            gp3 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideY;							// neighbor index (get convention)
 			m4 = Phi[nn];					// get neighbor for phi - 4
+            gp4 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideZ;						// neighbor index (get convention)
 			m5 = Phi[nn];					// get neighbor for phi - 5
+            gp5 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideZ;						// neighbor index (get convention)
 			m6 = Phi[nn];					// get neighbor for phi - 6
+            gp6 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideY-1;						// neighbor index (get convention)
 			m7 = Phi[nn];					// get neighbor for phi - 7
+            gp7 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideY+1;						// neighbor index (get convention)
 			m8 = Phi[nn];					// get neighbor for phi - 8
+            gp8 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideY-1;						// neighbor index (get convention)
 			m9 = Phi[nn];					// get neighbor for phi - 9
+            gp9 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideY+1;						// neighbor index (get convention)
 			m10 = Phi[nn];					// get neighbor for phi - 10
+            gp10 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideZ-1;						// neighbor index (get convention)
 			m11 = Phi[nn];					// get neighbor for phi - 11
+            gp11 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideZ+1;						// neighbor index (get convention)
 			m12 = Phi[nn];					// get neighbor for phi - 12
+            gp12 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideZ-1;						// neighbor index (get convention)
 			m13 = Phi[nn];					// get neighbor for phi - 13
+            gp13 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideZ+1;						// neighbor index (get convention)
 			m14 = Phi[nn];					// get neighbor for phi - 14
+            gp14 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideZ-strideY;					// neighbor index (get convention)
 			m15 = Phi[nn];					// get neighbor for phi - 15
+            gp15 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideZ+strideY;					// neighbor index (get convention)
 			m16 = Phi[nn];					// get neighbor for phi - 16
+            gp16 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideZ-strideY;					// neighbor index (get convention)
 			m17 = Phi[nn];					// get neighbor for phi - 17
+            gp17 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideZ+strideY;					// neighbor index (get convention)
 			m18 = Phi[nn];					// get neighbor for phi - 18
+            gp18 = Psi[nn];
 			//............Compute the Color Gradient...................................
 			nx_phase = -(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
 			ny_phase = -(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
 			nz_phase = -(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
 			C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
+			//............Compute the Greyscale Potential Gradient.....................
+			Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
+			Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
+			Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+
 
             //correct the normal color gradient by considering the effect of grey solid
             nx = nx_phase + (1.0-porosity)*nx_gs; 
@@ -1928,15 +1954,20 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			m17 -= fq;
 			m18 -= fq;
 			
-            //// Compute greyscale related parameters
-            ux = (jx/rho0+0.5*porosity*Gx)/(1.0+0.5*porosity*mu_eff/perm);
-            uy = (jy/rho0+0.5*porosity*Gy)/(1.0+0.5*porosity*mu_eff/perm);
-            uz = (jz/rho0+0.5*porosity*Gz)/(1.0+0.5*porosity*mu_eff/perm);
+            // Compute greyscale related parameters
+            ux = (jx/rho0+0.5*porosity*Gx+0.5*Fcpx/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            uy = (jy/rho0+0.5*porosity*Gy+0.5*Fcpy/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            uz = (jz/rho0+0.5*porosity*Gz+0.5*Fcpz/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            if (porosity==1.0){//i.e. open nodes
+                ux = (jx/rho0+0.5*porosity*Gx);
+                uy = (jy/rho0+0.5*porosity*Gy);
+                uz = (jz/rho0+0.5*porosity*Gz);
+            }
 
             //Update the total force to include linear (Darcy) and nonlinear (Forchheimer) drags due to the porous medium
-            Fx = rho0*(-porosity*mu_eff/perm*ux + porosity*Gx);
-            Fy = rho0*(-porosity*mu_eff/perm*uy + porosity*Gy);
-            Fz = rho0*(-porosity*mu_eff/perm*uz + porosity*Gz);
+            Fx = rho0*(-porosity*mu_eff/perm*ux + porosity*Gx)+Fcpx;
+            Fy = rho0*(-porosity*mu_eff/perm*uy + porosity*Gy)+Fcpy;
+            Fz = rho0*(-porosity*mu_eff/perm*uz + porosity*Gz)+Fcpz;
             if (porosity==1.0){
                 Fx=rho0*(porosity*Gx);
                 Fy=rho0*(porosity*Gy);
@@ -1950,14 +1981,6 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
             //Pressure[n] = rho/3.f/porosity;
             Pressure[n] = rho/3.f;
 
-            //----------- Introduce capillary penalty force -------------------------
-            //NOTE: apply only to grey nodes
-            cp = 0.1*tanh(W*alpha*phi/sqrt(perm));//the extra factor of 0.1 is to make sure cp is bounded within [-0.1,0.1]
-            if (porosity==1.0){
-                cp = 0.0;
-            }
-            rho += cp;//pressure perturbation
-
 			//........................................................................
 			//..............carry out relaxation process..............................
 			//..........Toelke, Fruediger et. al. 2006................................
@@ -2216,9 +2239,9 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 //CP: capillary penalty
 // also turn off recoloring for grey nodes
 __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
-        double *Phi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure, 
+        double *Phi, double *Psi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure, 
         double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
-		double Gx, double Gy, double Gz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
+		double Gx, double Gy, double Gz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np){
 	int ijk,nn,n;
 	double fq;
 	// conserved momemnts
@@ -2233,7 +2256,7 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 	double a1,b1,a2,b2,nAB,delta;
 	double C,nx,ny,nz; //color gradient magnitude and direction
 	double phi,tau,rho0,rlx_setA,rlx_setB;
-    double cp;//capillary pressure penalty - pressure term
+    double psi;//greyscale potential
 
     //double GeoFun=0.0;//geometric function from Guo's PRE 66, 036304 (2002)
     double porosity;
@@ -2244,6 +2267,9 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
     double nx_gs,ny_gs,nz_gs;//grey-solid color gradient
     double nx_phase,ny_phase,nz_phase,C_phase;
     double Fx,Fy,Fz;
+	double gp1,gp2,gp4,gp6,gp8,gp9,gp10,gp11,gp12,gp13,gp14,gp15,gp16,gp17,gp18;
+	double gp3,gp5,gp7;
+    double Fcpx,Fcpy,Fcpz;//capillary penalty force
 
 	const double mrt_V1=0.05263157894736842;
 	const double mrt_V2=0.012531328320802;
@@ -2293,62 +2319,84 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			//........................................................................
 			nn = ijk-1;							// neighbor index (get convention)
 			m1 = Phi[nn];						// get neighbor for phi - 1
+            gp1 = Psi[nn];
 			//........................................................................
 			nn = ijk+1;							// neighbor index (get convention)
 			m2 = Phi[nn];						// get neighbor for phi - 2
+            gp2 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideY;							// neighbor index (get convention)
 			m3 = Phi[nn];					// get neighbor for phi - 3
+            gp3 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideY;							// neighbor index (get convention)
 			m4 = Phi[nn];					// get neighbor for phi - 4
+            gp4 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideZ;						// neighbor index (get convention)
 			m5 = Phi[nn];					// get neighbor for phi - 5
+            gp5 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideZ;						// neighbor index (get convention)
 			m6 = Phi[nn];					// get neighbor for phi - 6
+            gp6 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideY-1;						// neighbor index (get convention)
 			m7 = Phi[nn];					// get neighbor for phi - 7
+            gp7 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideY+1;						// neighbor index (get convention)
 			m8 = Phi[nn];					// get neighbor for phi - 8
+            gp8 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideY-1;						// neighbor index (get convention)
 			m9 = Phi[nn];					// get neighbor for phi - 9
+            gp9 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideY+1;						// neighbor index (get convention)
 			m10 = Phi[nn];					// get neighbor for phi - 10
+            gp10 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideZ-1;						// neighbor index (get convention)
 			m11 = Phi[nn];					// get neighbor for phi - 11
+            gp11 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideZ+1;						// neighbor index (get convention)
 			m12 = Phi[nn];					// get neighbor for phi - 12
+            gp12 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideZ-1;						// neighbor index (get convention)
 			m13 = Phi[nn];					// get neighbor for phi - 13
+            gp13 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideZ+1;						// neighbor index (get convention)
 			m14 = Phi[nn];					// get neighbor for phi - 14
+            gp14 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideZ-strideY;					// neighbor index (get convention)
 			m15 = Phi[nn];					// get neighbor for phi - 15
+            gp15 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideZ+strideY;					// neighbor index (get convention)
 			m16 = Phi[nn];					// get neighbor for phi - 16
+            gp16 = Psi[nn];
 			//........................................................................
 			nn = ijk+strideZ-strideY;					// neighbor index (get convention)
 			m17 = Phi[nn];					// get neighbor for phi - 17
+            gp17 = Psi[nn];
 			//........................................................................
 			nn = ijk-strideZ+strideY;					// neighbor index (get convention)
 			m18 = Phi[nn];					// get neighbor for phi - 18
+            gp18 = Psi[nn];
 			//............Compute the Color Gradient...................................
 			nx_phase = -(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
 			ny_phase = -(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
 			nz_phase = -(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
 			C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
+			//............Compute the Greyscale Potential Gradient.....................
+			Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
+			Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
+			Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
 
             //correct the normal color gradient by considering the effect of grey solid
             nx = nx_phase + (1.0-porosity)*nx_gs; 
@@ -2638,15 +2686,20 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			m17 -= fq;
 			m18 -= fq;
 
-            //// Compute greyscale related parameters
-            ux = (jx/rho0+0.5*porosity*Gx)/(1.0+0.5*porosity*mu_eff/perm);
-            uy = (jy/rho0+0.5*porosity*Gy)/(1.0+0.5*porosity*mu_eff/perm);
-            uz = (jz/rho0+0.5*porosity*Gz)/(1.0+0.5*porosity*mu_eff/perm);
+            // Compute greyscale related parameters
+            ux = (jx/rho0+0.5*porosity*Gx+0.5*Fcpx/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            uy = (jy/rho0+0.5*porosity*Gy+0.5*Fcpy/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            uz = (jz/rho0+0.5*porosity*Gz+0.5*Fcpz/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            if (porosity==1.0){//i.e. open nodes
+                ux = (jx/rho0+0.5*porosity*Gx);
+                uy = (jy/rho0+0.5*porosity*Gy);
+                uz = (jz/rho0+0.5*porosity*Gz);
+            }
 
             //Update the total force to include linear (Darcy) and nonlinear (Forchheimer) drags due to the porous medium
-            Fx = rho0*(-porosity*mu_eff/perm*ux + porosity*Gx);
-            Fy = rho0*(-porosity*mu_eff/perm*uy + porosity*Gy);
-            Fz = rho0*(-porosity*mu_eff/perm*uz + porosity*Gz);
+            Fx = rho0*(-porosity*mu_eff/perm*ux + porosity*Gx)+Fcpx;
+            Fy = rho0*(-porosity*mu_eff/perm*uy + porosity*Gy)+Fcpy;
+            Fz = rho0*(-porosity*mu_eff/perm*uz + porosity*Gz)+Fcpz;
             if (porosity==1.0){
                 Fx=rho0*(porosity*Gx);
                 Fy=rho0*(porosity*Gy);
@@ -2660,14 +2713,6 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
             //Pressure[n] = rho/3.f/porosity;
             Pressure[n] = rho/3.f;
 
-            //----------- Introduce capillary penalty force -------------------------
-            //NOTE: apply only to grey nodes
-            cp = 0.1*tanh(W*alpha*phi/sqrt(perm));//the extra factor of 0.1 is to make sure cp is bounded within [-0.1,0.1]
-            if (porosity==1.0){
-                cp = 0.0;
-            }
-            rho += cp;//pressure perturbation
-
 			//........................................................................
 			//..............carry out relaxation process..............................
 			//..........Toelke, Fruediger et. al. 2006................................
@@ -2927,6 +2972,33 @@ __global__ void dvc_ScaLBL_PhaseField_InitFromRestart(double *Den, double *Aq, d
 		}
 	}
 }
+
+__global__  void dvc_ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
+                                                      int start, int finish){
+	int idx,n;
+    double phi,psi;
+    double cap_penalty;
+    double porosity,perm;
+
+	int S = Np/NBLOCKS/NTHREADS + 1;
+	for (int s=0; s<S; s++){
+		//........Get 1-D index for this thread....................
+		n =  S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x + start;
+		if (n<finish) {
+			idx = Map[n];
+			phi = Phi[idx];
+            porosity = Poro[n];
+            perm = Perm[n];    
+            cap_penalty = 1.0;
+
+            if (porosity!=1.0) cap_penalty = alpha*W/sqrt(perm);
+            psi = cap_penalty*phi;
+            Psi[idx] = psi;
+		}
+	}
+}
+
+
 ////Model-2&3
 //__global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor(int *neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den,
 //		 double *Phi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, 
@@ -4477,6 +4549,17 @@ extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *d_neighborList, int *M
 	}
 }
 
+extern "C" void ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
+		int start, int finish){
+
+	dvc_ScaLBL_Update_GreyscalePotential<<<NBLOCKS,NTHREADS >>>(Map, Phi, Psi, Poro, Perm, alpha, W, start, finish);
+
+	cudaError_t err = cudaGetLastError();
+	if (cudaSuccess != err){
+		printf("CUDA error in ScaLBL_Update_GreyscalePotential: %s \n",cudaGetErrorString(err));
+	}
+}
+
 ////Model-2&3
 //extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
 //        double *Phi,double *GreySolidGrad, double *Poros,double *Perm,double *Vel, 
diff --git a/models/GreyscaleColorModel.cpp b/models/GreyscaleColorModel.cpp
index d5ecea2d..2e2b2f4b 100644
--- a/models/GreyscaleColorModel.cpp
+++ b/models/GreyscaleColorModel.cpp
@@ -220,6 +220,7 @@ void ScaLBL_GreyscaleColorModel::ReadInput(){
 	
 }
 
+
 void ScaLBL_GreyscaleColorModel::AssignComponentLabels()
 {
     // Initialize impermeability solid nodes and grey nodes
@@ -264,6 +265,7 @@ void ScaLBL_GreyscaleColorModel::AssignComponentLabels()
 				      //printf("idx=%i, value=%i, %i, \n",idx, VALUE,LabelList[idx]);
 					if (VALUE == LabelList[idx]){
 						AFFINITY=AffinityList[idx];
+
 						label_count[idx] += 1.0;
 						idx = NLABELS;
 						//Mask->id[n] = 0; // set mask to zero since this is an immobile component
@@ -583,6 +585,71 @@ void ScaLBL_GreyscaleColorModel::AssignGreyPoroPermLabels()
     delete [] Permeability;
 }
 
+void ScaLBL_GreyscaleColorModel::AssignGreyscalePotential()
+{
+    double *psi;//greyscale potential
+	psi = new double[N];
+
+	size_t NLABELS=0;
+	signed char VALUE=0;
+	double AFFINITY=0.f;
+
+	auto LabelList = greyscaleColor_db->getVector<int>( "ComponentLabels" );
+	auto AffinityList = greyscaleColor_db->getVector<double>( "ComponentAffinity" );
+	NLABELS=LabelList.size();
+
+    //first, copy over normal phase field
+	for (int k=0;k<Nz;k++){
+		for (int j=0;j<Ny;j++){
+			for (int i=0;i<Nx;i++){
+				int n = k*Nx*Ny+j*Nx+i;
+				VALUE=id[n];
+				// Assign the affinity from the paired list
+				for (unsigned int idx=0; idx < NLABELS; idx++){
+				      //printf("idx=%i, value=%i, %i, \n",idx, VALUE,LabelList[idx]);
+					if (VALUE == LabelList[idx]){
+						AFFINITY=AffinityList[idx];
+						idx = NLABELS;
+					}
+				}
+				// fluid labels are reserved
+				if (VALUE == 1) AFFINITY=1.0;
+				else if (VALUE == 2) AFFINITY=-1.0;
+				psi[n] = AFFINITY;
+			}
+		}
+	}
+
+    //second, scale the phase field for grey nodes
+	double Cap_Penalty=1.f;
+	auto GreyLabelList = greyscaleColor_db->getVector<int>( "GreySolidLabels" );
+	auto PermeabilityList = greyscaleColor_db->getVector<double>( "PermeabilityList" );
+	NLABELS=GreyLabelList.size();
+
+	for (int k=0;k<Nz;k++){
+		for (int j=0;j<Ny;j++){
+			for (int i=0;i<Nx;i++){
+				int n = k*Nx*Ny+j*Nx+i;
+				VALUE=id[n];
+                Cap_Penalty=1.f;
+				// Assign the affinity from the paired list
+				for (unsigned int idx=0; idx < NLABELS; idx++){
+					if (VALUE == GreyLabelList[idx]){
+						Cap_Penalty=alpha*W/sqrt(PermeabilityList[idx]/Dm->voxel_length/Dm->voxel_length);
+						idx = NLABELS;
+					}
+				}
+                //update greyscale potential
+                psi[n] = psi[n]*Cap_Penalty;
+			}
+		}
+	}
+
+	ScaLBL_CopyToDevice(Psi, psi, N*sizeof(double));
+	ScaLBL_Comm->Barrier();
+    delete [] psi;
+}
+
 void ScaLBL_GreyscaleColorModel::Create(){
 	/*
 	 *  This function creates the variables needed to run a LBM 
@@ -603,6 +670,7 @@ void ScaLBL_GreyscaleColorModel::Create(){
 	// ScaLBL_Communicator ScaLBL_Comm(Mask); // original
 	ScaLBL_Comm  = std::shared_ptr<ScaLBL_Communicator>(new ScaLBL_Communicator(Mask));
 	ScaLBL_Comm_Regular  = std::shared_ptr<ScaLBL_Communicator>(new ScaLBL_Communicator(Mask));
+	ScaLBL_Comm_Regular_2  = std::shared_ptr<ScaLBL_Communicator>(new ScaLBL_Communicator(Mask));
 
 	int Npad=(Np/16 + 2)*16;
 	if (rank==0)    printf ("Set up memory efficient layout, %i | %i | %i \n", Np, Npad, N);
@@ -627,6 +695,7 @@ void ScaLBL_GreyscaleColorModel::Create(){
 	ScaLBL_AllocateDeviceMemory((void **) &Bq, 7*dist_mem_size);
 	ScaLBL_AllocateDeviceMemory((void **) &Den, 2*dist_mem_size);
 	ScaLBL_AllocateDeviceMemory((void **) &Phi, sizeof(double)*Nx*Ny*Nz);		
+	ScaLBL_AllocateDeviceMemory((void **) &Psi, sizeof(double)*Nx*Ny*Nz);//greyscale potential		
 	ScaLBL_AllocateDeviceMemory((void **) &Pressure, sizeof(double)*Np);
 	ScaLBL_AllocateDeviceMemory((void **) &Velocity, 3*sizeof(double)*Np);
 	//ScaLBL_AllocateDeviceMemory((void **) &ColorGrad, 3*sizeof(double)*Np);
@@ -675,6 +744,7 @@ void ScaLBL_GreyscaleColorModel::Create(){
 	AssignComponentLabels();//do open/black/grey nodes initialization
     AssignGreySolidLabels();
     AssignGreyPoroPermLabels(); 
+    AssignGreyscalePotential(); 
 	Averages->SetParams(rhoA,rhoB,tauA,tauB,Fx,Fy,Fz,alpha,beta,GreyPorosity);
 	ScaLBL_Comm->RegularLayout(Map,Porosity_dvc,Averages->Porosity);//porosity doesn't change over time
 }        
@@ -939,9 +1009,11 @@ void ScaLBL_GreyscaleColorModel::Run(){
 		// Read for Aq, Bq happens in this routine (requires communication)
 		ScaLBL_Comm->BiSendD3Q7AA(Aq,Bq); //READ FROM NORMAL
 		ScaLBL_D3Q7_AAodd_PhaseField(NeighborList, dvcMap, Aq, Bq, Den, Phi, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior());
 		ScaLBL_Comm->BiRecvD3Q7AA(Aq,Bq); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
 		ScaLBL_D3Q7_AAodd_PhaseField(NeighborList, dvcMap, Aq, Bq, Den, Phi, 0, ScaLBL_Comm->LastExterior(), Np);
+        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,0,ScaLBL_Comm->LastExterior());
 
 		// Perform the collision operation
 		ScaLBL_Comm->SendD3Q19AA(fq); //READ FROM NORMAL
@@ -951,10 +1023,11 @@ void ScaLBL_GreyscaleColorModel::Run(){
 		}
 		// Halo exchange for phase field
 		ScaLBL_Comm_Regular->SendHalo(Phi);
+		ScaLBL_Comm_Regular_2->SendHalo(Psi);
         //Model-1&4 with capillary pressure penalty for grey nodes
-        ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
+        ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi, Psi, GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
                 rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff, 
-                alpha, beta, Fx, Fy, Fz, RecoloringOff, W, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+                alpha, beta, Fx, Fy, Fz, RecoloringOff, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
         //Model-1&4
         //ScaLBL_D3Q19_AAodd_GreyscaleColor(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff, 
@@ -963,6 +1036,7 @@ void ScaLBL_GreyscaleColorModel::Run(){
         //ScaLBL_D3Q19_AAodd_GreyscaleColor(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidPhi,Porosity_dvc,Permeability_dvc,Velocity, 
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff, 
         //        alpha, beta, Fx, Fy, Fz, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+		ScaLBL_Comm_Regular_2->RecvHalo(Psi);
 		ScaLBL_Comm_Regular->RecvHalo(Phi);
 		ScaLBL_Comm->RecvD3Q19AA(fq); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
@@ -981,9 +1055,9 @@ void ScaLBL_GreyscaleColorModel::Run(){
 		}
 
         //Model-1&4 with capillary pressure penalty for grey nodes
-        ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
+        ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi, Psi, GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
                 rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
-                alpha, beta, Fx, Fy, Fz, RecoloringOff, W, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
+                alpha, beta, Fx, Fy, Fz, RecoloringOff, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
         //Model-1&4
         //ScaLBL_D3Q19_AAodd_GreyscaleColor(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
@@ -999,9 +1073,11 @@ void ScaLBL_GreyscaleColorModel::Run(){
 		// Compute the Phase indicator field
 		ScaLBL_Comm->BiSendD3Q7AA(Aq,Bq); //READ FROM NORMAL
 		ScaLBL_D3Q7_AAeven_PhaseField(dvcMap, Aq, Bq, Den, Phi, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior());
 		ScaLBL_Comm->BiRecvD3Q7AA(Aq,Bq); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
 		ScaLBL_D3Q7_AAeven_PhaseField(dvcMap, Aq, Bq, Den, Phi, 0, ScaLBL_Comm->LastExterior(), Np);
+        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,0,ScaLBL_Comm->LastExterior());
 
 		// Perform the collision operation
 		ScaLBL_Comm->SendD3Q19AA(fq); //READ FORM NORMAL
@@ -1011,10 +1087,11 @@ void ScaLBL_GreyscaleColorModel::Run(){
 			ScaLBL_Comm->Color_BC_Z(dvcMap, Phi, Den, outletA, outletB);
 		}
 		ScaLBL_Comm_Regular->SendHalo(Phi);
+		ScaLBL_Comm_Regular_2->SendHalo(Psi);
         //Model-1&4 with capillary pressure penalty for grey nodes
-        ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure, 
+        ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(dvcMap, fq, Aq, Bq, Den, Phi, Psi, GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure, 
                 rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
-                alpha, beta, Fx, Fy, Fz, RecoloringOff, W, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+                alpha, beta, Fx, Fy, Fz, RecoloringOff, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
         //Model-1&4
         //ScaLBL_D3Q19_AAeven_GreyscaleColor(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure, 
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
@@ -1023,6 +1100,7 @@ void ScaLBL_GreyscaleColorModel::Run(){
         //ScaLBL_D3Q19_AAeven_GreyscaleColor(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidPhi,Porosity_dvc,Permeability_dvc,Velocity, 
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
         //        alpha, beta, Fx, Fy, Fz,  Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+		ScaLBL_Comm_Regular_2->RecvHalo(Psi);
 		ScaLBL_Comm_Regular->RecvHalo(Phi);
 		ScaLBL_Comm->RecvD3Q19AA(fq); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
@@ -1041,9 +1119,9 @@ void ScaLBL_GreyscaleColorModel::Run(){
 		}
 
         //Model-1&4 with capillary pressure penalty for grey nodes
-        ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
+        ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(dvcMap, fq, Aq, Bq, Den, Phi, Psi, GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
                 rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
-                alpha, beta, Fx, Fy, Fz, RecoloringOff, W, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
+                alpha, beta, Fx, Fy, Fz, RecoloringOff, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
         //Model-1&4
         //ScaLBL_D3Q19_AAeven_GreyscaleColor(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
diff --git a/models/GreyscaleColorModel.h b/models/GreyscaleColorModel.h
index dd25e613..8285ee56 100644
--- a/models/GreyscaleColorModel.h
+++ b/models/GreyscaleColorModel.h
@@ -88,6 +88,7 @@ private:
     void AssignComponentLabels();
     void AssignGreySolidLabels();
     void AssignGreyPoroPermLabels();
+    void AssignGreyscalePotential();
     void ImageInit(std::string filename);
     double MorphInit(const double beta, const double morph_delta);
     double SeedPhaseField(const double seed_water_in_oil);

From 1ff5951ce0dfb368a06f1bb88509f1d30326703e Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Wed, 3 Mar 2021 20:53:36 -0500
Subject: [PATCH 04/19] build pass; model to be validated

---
 common/ScaLBL.h                | 10 +++++-----
 cuda/GreyscaleColor.cu         | 24 +++++++++++-------------
 models/GreyscaleColorModel.cpp |  8 ++++----
 models/GreyscaleColorModel.h   |  4 +++-
 4 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/common/ScaLBL.h b/common/ScaLBL.h
index 762efb20..24a5e370 100644
--- a/common/ScaLBL.h
+++ b/common/ScaLBL.h
@@ -88,17 +88,17 @@ extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor(int *d_neighborList, int *Map,
 		double Fx, double Fy, double Fz, int strideY, int strideZ, int start, int finish, int Np);
 
 extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
-        double *Phi,double *GreySolidGrad, double *Poros,double *Perm,double *Vel, double *Pressure,
+        double *Phi,double *Psi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel, double *Pressure,
         double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
-		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np);
+		double Fx, double Fy, double Fz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np);
 
 extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *d_neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den, 
-		double *Phi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel,double *Pressure, 
+		double *Phi,double *Psi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel,double *Pressure, 
         double rhoA, double rhoB, double tauA, double tauB, double tauA_eff,double tauB_eff, double alpha, double beta,
-		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np);
+		double Fx, double Fy, double Fz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np);
 
 extern "C" void ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
-		int start, int finish);
+		int start, int finish, int Np);
 
 // ION TRANSPORT MODEL
 
diff --git a/cuda/GreyscaleColor.cu b/cuda/GreyscaleColor.cu
index ee989bba..d9541cc4 100644
--- a/cuda/GreyscaleColor.cu
+++ b/cuda/GreyscaleColor.cu
@@ -1472,7 +1472,6 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 	double a1,b1,a2,b2,nAB,delta;
 	double C,nx,ny,nz; //color gradient magnitude and direction
 	double phi,tau,rho0,rlx_setA,rlx_setB;
-    double psi;//greyscale potential
 
     //double GeoFun=0.0;//geometric function from Guo's PRE 66, 036304 (2002)
     double porosity;
@@ -2256,7 +2255,6 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 	double a1,b1,a2,b2,nAB,delta;
 	double C,nx,ny,nz; //color gradient magnitude and direction
 	double phi,tau,rho0,rlx_setA,rlx_setB;
-    double psi;//greyscale potential
 
     //double GeoFun=0.0;//geometric function from Guo's PRE 66, 036304 (2002)
     double porosity;
@@ -2974,7 +2972,7 @@ __global__ void dvc_ScaLBL_PhaseField_InitFromRestart(double *Den, double *Aq, d
 }
 
 __global__  void dvc_ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
-                                                      int start, int finish){
+                                                      int start, int finish, int Np){
 	int idx,n;
     double phi,psi;
     double cap_penalty;
@@ -4521,12 +4519,12 @@ extern "C" void ScaLBL_PhaseField_InitFromRestart(double *Den, double *Aq, doubl
 
 //Model-1 & 4 with capillary pressure penalty
 extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
-        double *Phi,double *GreySolidGrad, double *Poros,double *Perm,double *Vel, double *Pressure,
+        double *Phi,double *Psi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel, double *Pressure,
         double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
-		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
+		double Fx, double Fy, double Fz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np){
 
-	dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP<<<NBLOCKS,NTHREADS >>>(Map, dist, Aq, Bq, Den, Phi, GreySolidGrad, Poros, Perm, Vel, Pressure,
-            rhoA, rhoB, tauA, tauB, tauA_eff, tauB_eff, alpha, beta, Fx, Fy, Fz, RecoloringOff, W, strideY, strideZ, start, finish, Np);
+	dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP<<<NBLOCKS,NTHREADS >>>(Map, dist, Aq, Bq, Den, Phi, Psi, GreySolidGrad, Poros, Perm, Vel, Pressure,
+            rhoA, rhoB, tauA, tauB, tauA_eff, tauB_eff, alpha, beta, Fx, Fy, Fz, RecoloringOff, strideY, strideZ, start, finish, Np);
 	cudaError_t err = cudaGetLastError();
 	if (cudaSuccess != err){
 		printf("CUDA error in ScaLBL_D3Q19_AAeven_GreyscaleColor_CP: %s \n",cudaGetErrorString(err));
@@ -4536,12 +4534,12 @@ extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, do
 
 //Model-1 & 4 with capillary pressure penalty
 extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *d_neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den, 
-		double *Phi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel,double *Pressure, 
+		double *Phi, double *Psi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel,double *Pressure, 
         double rhoA, double rhoB, double tauA, double tauB, double tauA_eff,double tauB_eff, double alpha, double beta,
-		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
+		double Fx, double Fy, double Fz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np){
 
-	dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP<<<NBLOCKS,NTHREADS >>>(d_neighborList, Map, dist, Aq, Bq, Den, Phi,  GreySolidGrad, Poros, Perm,Vel,Pressure,
-			rhoA, rhoB, tauA, tauB, tauA_eff, tauB_eff,alpha, beta, Fx, Fy, Fz, RecoloringOff, W, strideY, strideZ, start, finish, Np);
+	dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP<<<NBLOCKS,NTHREADS >>>(d_neighborList, Map, dist, Aq, Bq, Den, Phi, Psi, GreySolidGrad, Poros, Perm,Vel,Pressure,
+			rhoA, rhoB, tauA, tauB, tauA_eff, tauB_eff,alpha, beta, Fx, Fy, Fz, RecoloringOff, strideY, strideZ, start, finish, Np);
 
 	cudaError_t err = cudaGetLastError();
 	if (cudaSuccess != err){
@@ -4550,9 +4548,9 @@ extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *d_neighborList, int *M
 }
 
 extern "C" void ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
-		int start, int finish){
+		int start, int finish, int Np){
 
-	dvc_ScaLBL_Update_GreyscalePotential<<<NBLOCKS,NTHREADS >>>(Map, Phi, Psi, Poro, Perm, alpha, W, start, finish);
+	dvc_ScaLBL_Update_GreyscalePotential<<<NBLOCKS,NTHREADS >>>(Map, Phi, Psi, Poro, Perm, alpha, W, start, finish, Np);
 
 	cudaError_t err = cudaGetLastError();
 	if (cudaSuccess != err){
diff --git a/models/GreyscaleColorModel.cpp b/models/GreyscaleColorModel.cpp
index 2e2b2f4b..f4cc6f95 100644
--- a/models/GreyscaleColorModel.cpp
+++ b/models/GreyscaleColorModel.cpp
@@ -1009,11 +1009,11 @@ void ScaLBL_GreyscaleColorModel::Run(){
 		// Read for Aq, Bq happens in this routine (requires communication)
 		ScaLBL_Comm->BiSendD3Q7AA(Aq,Bq); //READ FROM NORMAL
 		ScaLBL_D3Q7_AAodd_PhaseField(NeighborList, dvcMap, Aq, Bq, Den, Phi, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
-        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior());
+        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
 		ScaLBL_Comm->BiRecvD3Q7AA(Aq,Bq); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
 		ScaLBL_D3Q7_AAodd_PhaseField(NeighborList, dvcMap, Aq, Bq, Den, Phi, 0, ScaLBL_Comm->LastExterior(), Np);
-        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,0,ScaLBL_Comm->LastExterior());
+        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,0,ScaLBL_Comm->LastExterior(), Np);
 
 		// Perform the collision operation
 		ScaLBL_Comm->SendD3Q19AA(fq); //READ FROM NORMAL
@@ -1073,11 +1073,11 @@ void ScaLBL_GreyscaleColorModel::Run(){
 		// Compute the Phase indicator field
 		ScaLBL_Comm->BiSendD3Q7AA(Aq,Bq); //READ FROM NORMAL
 		ScaLBL_D3Q7_AAeven_PhaseField(dvcMap, Aq, Bq, Den, Phi, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
-        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior());
+        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
 		ScaLBL_Comm->BiRecvD3Q7AA(Aq,Bq); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
 		ScaLBL_D3Q7_AAeven_PhaseField(dvcMap, Aq, Bq, Den, Phi, 0, ScaLBL_Comm->LastExterior(), Np);
-        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,0,ScaLBL_Comm->LastExterior());
+        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,0,ScaLBL_Comm->LastExterior(), Np);
 
 		// Perform the collision operation
 		ScaLBL_Comm->SendD3Q19AA(fq); //READ FORM NORMAL
diff --git a/models/GreyscaleColorModel.h b/models/GreyscaleColorModel.h
index 8285ee56..be17c910 100644
--- a/models/GreyscaleColorModel.h
+++ b/models/GreyscaleColorModel.h
@@ -50,7 +50,8 @@ public:
 	std::shared_ptr<Domain> Mask; // this domain is for lbm
 	std::shared_ptr<ScaLBL_Communicator> ScaLBL_Comm;
 	std::shared_ptr<ScaLBL_Communicator> ScaLBL_Comm_Regular;
-        std::shared_ptr<GreyPhaseAnalysis> Averages;
+	std::shared_ptr<ScaLBL_Communicator> ScaLBL_Comm_Regular_2;
+    std::shared_ptr<GreyPhaseAnalysis> Averages;
     
     // input database
     std::shared_ptr<Database> db;
@@ -72,6 +73,7 @@ public:
 	double *Pressure;
     double *Porosity_dvc;
     double *Permeability_dvc;
+    double *Psi;
 		
 private:
 	Utilities::MPI comm;

From 5645f6125fe4c1e5c017956d3311db26de725564 Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Mon, 8 Mar 2021 20:39:37 -0500
Subject: [PATCH 05/19] add debug output for greyscale potential

---
 models/GreyscaleColorModel.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/models/GreyscaleColorModel.cpp b/models/GreyscaleColorModel.cpp
index f4cc6f95..de51270a 100644
--- a/models/GreyscaleColorModel.cpp
+++ b/models/GreyscaleColorModel.cpp
@@ -1677,6 +1677,13 @@ void ScaLBL_GreyscaleColorModel::WriteDebug(){
 	fwrite(PhaseField.data(),8,N,OUTFILE);
 	fclose(OUTFILE);
 
+	ScaLBL_CopyToHost(PhaseField.data(), Psi, sizeof(double)*N);
+	FILE *PSIFILE;
+	sprintf(LocalRankFilename,"Psi.%05i.raw",rank);
+	PSIFILE = fopen(LocalRankFilename,"wb");
+	fwrite(PhaseField.data(),8,N,PSIFILE);
+	fclose(PSIFILE);
+
     ScaLBL_Comm->RegularLayout(Map,&Den[0],PhaseField);
 	FILE *AFILE;
 	sprintf(LocalRankFilename,"A.%05i.raw",rank);

From 3ed949efb1e680b9b77529c95348732f34919e7b Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Mon, 8 Mar 2021 22:28:19 -0500
Subject: [PATCH 06/19] slightly change the implementation of capillary
 penalty, to be built and tested

---
 common/ScaLBL.h                |  4 +--
 cuda/GreyscaleColor.cu         | 46 +++++++++++++++++++++++++---------
 models/GreyscaleColorModel.cpp | 16 ++++++------
 3 files changed, 44 insertions(+), 22 deletions(-)

diff --git a/common/ScaLBL.h b/common/ScaLBL.h
index 24a5e370..5c4d4730 100644
--- a/common/ScaLBL.h
+++ b/common/ScaLBL.h
@@ -90,12 +90,12 @@ extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor(int *d_neighborList, int *Map,
 extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
         double *Phi,double *Psi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel, double *Pressure,
         double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
-		double Fx, double Fy, double Fz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np);
+		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np);
 
 extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *d_neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den, 
 		double *Phi,double *Psi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel,double *Pressure, 
         double rhoA, double rhoB, double tauA, double tauB, double tauA_eff,double tauB_eff, double alpha, double beta,
-		double Fx, double Fy, double Fz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np);
+		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np);
 
 extern "C" void ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
 		int start, int finish, int Np);
diff --git a/cuda/GreyscaleColor.cu b/cuda/GreyscaleColor.cu
index d9541cc4..e3a4c421 100644
--- a/cuda/GreyscaleColor.cu
+++ b/cuda/GreyscaleColor.cu
@@ -1452,7 +1452,7 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor(int *Map, double *dist,
 __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den,
 		 double *Phi, double *Psi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure,
          double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff,double alpha, double beta,
-		double Gx, double Gy, double Gz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np){
+		double Gx, double Gy, double Gz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
 
 	int n,nn,ijk,nread;
 	int nr1,nr2,nr3,nr4,nr5,nr6;
@@ -1609,9 +1609,20 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			nz_phase = -(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
 			C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
 			//............Compute the Greyscale Potential Gradient.....................
-			Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
-			Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
-			Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+			Fcpx = 0.0;
+			Fcpy = 0.0;
+			Fcpz = 0.0;
+            if (porosity!=1.0){
+                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
+                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
+                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+                Fcpx *= alpha*W/sqrt(perm); 
+                Fcpy *= alpha*W/sqrt(perm); 
+                Fcpz *= alpha*W/sqrt(perm); 
+            }
 
 
             //correct the normal color gradient by considering the effect of grey solid
@@ -2240,7 +2251,7 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
         double *Phi, double *Psi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure, 
         double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
-		double Gx, double Gy, double Gz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np){
+		double Gx, double Gy, double Gz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
 	int ijk,nn,n;
 	double fq;
 	// conserved momemnts
@@ -2392,9 +2403,20 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			nz_phase = -(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
 			C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
 			//............Compute the Greyscale Potential Gradient.....................
-			Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
-			Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
-			Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+			Fcpx = 0.0;
+			Fcpy = 0.0;
+			Fcpz = 0.0;
+            if (porosity!=1.0){
+                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
+                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
+                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+                Fcpx *= alpha*W/sqrt(perm); 
+                Fcpy *= alpha*W/sqrt(perm); 
+                Fcpz *= alpha*W/sqrt(perm); 
+            }
 
             //correct the normal color gradient by considering the effect of grey solid
             nx = nx_phase + (1.0-porosity)*nx_gs; 
@@ -4521,10 +4543,10 @@ extern "C" void ScaLBL_PhaseField_InitFromRestart(double *Den, double *Aq, doubl
 extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
         double *Phi,double *Psi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel, double *Pressure,
         double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
-		double Fx, double Fy, double Fz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np){
+		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
 
 	dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP<<<NBLOCKS,NTHREADS >>>(Map, dist, Aq, Bq, Den, Phi, Psi, GreySolidGrad, Poros, Perm, Vel, Pressure,
-            rhoA, rhoB, tauA, tauB, tauA_eff, tauB_eff, alpha, beta, Fx, Fy, Fz, RecoloringOff, strideY, strideZ, start, finish, Np);
+            rhoA, rhoB, tauA, tauB, tauA_eff, tauB_eff, alpha, beta, Fx, Fy, Fz, RecoloringOff, W, strideY, strideZ, start, finish, Np);
 	cudaError_t err = cudaGetLastError();
 	if (cudaSuccess != err){
 		printf("CUDA error in ScaLBL_D3Q19_AAeven_GreyscaleColor_CP: %s \n",cudaGetErrorString(err));
@@ -4536,10 +4558,10 @@ extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, do
 extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *d_neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den, 
 		double *Phi, double *Psi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel,double *Pressure, 
         double rhoA, double rhoB, double tauA, double tauB, double tauA_eff,double tauB_eff, double alpha, double beta,
-		double Fx, double Fy, double Fz, bool RecoloringOff, int strideY, int strideZ, int start, int finish, int Np){
+		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
 
 	dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP<<<NBLOCKS,NTHREADS >>>(d_neighborList, Map, dist, Aq, Bq, Den, Phi, Psi, GreySolidGrad, Poros, Perm,Vel,Pressure,
-			rhoA, rhoB, tauA, tauB, tauA_eff, tauB_eff,alpha, beta, Fx, Fy, Fz, RecoloringOff, strideY, strideZ, start, finish, Np);
+			rhoA, rhoB, tauA, tauB, tauA_eff, tauB_eff,alpha, beta, Fx, Fy, Fz, RecoloringOff, W, strideY, strideZ, start, finish, Np);
 
 	cudaError_t err = cudaGetLastError();
 	if (cudaSuccess != err){
diff --git a/models/GreyscaleColorModel.cpp b/models/GreyscaleColorModel.cpp
index de51270a..a4bb607e 100644
--- a/models/GreyscaleColorModel.cpp
+++ b/models/GreyscaleColorModel.cpp
@@ -1009,11 +1009,11 @@ void ScaLBL_GreyscaleColorModel::Run(){
 		// Read for Aq, Bq happens in this routine (requires communication)
 		ScaLBL_Comm->BiSendD3Q7AA(Aq,Bq); //READ FROM NORMAL
 		ScaLBL_D3Q7_AAodd_PhaseField(NeighborList, dvcMap, Aq, Bq, Den, Phi, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
-        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+        //ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
 		ScaLBL_Comm->BiRecvD3Q7AA(Aq,Bq); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
 		ScaLBL_D3Q7_AAodd_PhaseField(NeighborList, dvcMap, Aq, Bq, Den, Phi, 0, ScaLBL_Comm->LastExterior(), Np);
-        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,0,ScaLBL_Comm->LastExterior(), Np);
+        //ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,0,ScaLBL_Comm->LastExterior(), Np);
 
 		// Perform the collision operation
 		ScaLBL_Comm->SendD3Q19AA(fq); //READ FROM NORMAL
@@ -1027,7 +1027,7 @@ void ScaLBL_GreyscaleColorModel::Run(){
         //Model-1&4 with capillary pressure penalty for grey nodes
         ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi, Psi, GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
                 rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff, 
-                alpha, beta, Fx, Fy, Fz, RecoloringOff, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+                alpha, beta, Fx, Fy, Fz, RecoloringOff, W, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
         //Model-1&4
         //ScaLBL_D3Q19_AAodd_GreyscaleColor(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff, 
@@ -1057,7 +1057,7 @@ void ScaLBL_GreyscaleColorModel::Run(){
         //Model-1&4 with capillary pressure penalty for grey nodes
         ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi, Psi, GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
                 rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
-                alpha, beta, Fx, Fy, Fz, RecoloringOff, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
+                alpha, beta, Fx, Fy, Fz, RecoloringOff, W, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
         //Model-1&4
         //ScaLBL_D3Q19_AAodd_GreyscaleColor(NeighborList, dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
@@ -1073,11 +1073,11 @@ void ScaLBL_GreyscaleColorModel::Run(){
 		// Compute the Phase indicator field
 		ScaLBL_Comm->BiSendD3Q7AA(Aq,Bq); //READ FROM NORMAL
 		ScaLBL_D3Q7_AAeven_PhaseField(dvcMap, Aq, Bq, Den, Phi, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
-        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+        //ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
 		ScaLBL_Comm->BiRecvD3Q7AA(Aq,Bq); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
 		ScaLBL_D3Q7_AAeven_PhaseField(dvcMap, Aq, Bq, Den, Phi, 0, ScaLBL_Comm->LastExterior(), Np);
-        ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,0,ScaLBL_Comm->LastExterior(), Np);
+        //ScaLBL_Update_GreyscalePotential(dvcMap,Phi,Psi,Porosity_dvc,Permeability_dvc,alpha,W,0,ScaLBL_Comm->LastExterior(), Np);
 
 		// Perform the collision operation
 		ScaLBL_Comm->SendD3Q19AA(fq); //READ FORM NORMAL
@@ -1091,7 +1091,7 @@ void ScaLBL_GreyscaleColorModel::Run(){
         //Model-1&4 with capillary pressure penalty for grey nodes
         ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(dvcMap, fq, Aq, Bq, Den, Phi, Psi, GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure, 
                 rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
-                alpha, beta, Fx, Fy, Fz, RecoloringOff, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+                alpha, beta, Fx, Fy, Fz, RecoloringOff, W, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
         //Model-1&4
         //ScaLBL_D3Q19_AAeven_GreyscaleColor(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure, 
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
@@ -1121,7 +1121,7 @@ void ScaLBL_GreyscaleColorModel::Run(){
         //Model-1&4 with capillary pressure penalty for grey nodes
         ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(dvcMap, fq, Aq, Bq, Den, Phi, Psi, GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
                 rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,
-                alpha, beta, Fx, Fy, Fz, RecoloringOff, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
+                alpha, beta, Fx, Fy, Fz, RecoloringOff, W, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
         //Model-1&4
         //ScaLBL_D3Q19_AAeven_GreyscaleColor(dvcMap, fq, Aq, Bq, Den, Phi,GreySolidGrad,Porosity_dvc,Permeability_dvc,Velocity,Pressure,
         //        rhoA, rhoB, tauA, tauB,tauA_eff, tauB_eff,

From 2cec6b260e8554ef826d2994ff8e0f6551e5441e Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Wed, 10 Mar 2021 19:53:58 -0500
Subject: [PATCH 07/19] change color-gradient on greynodes to be the same as
 Fcp

---
 cuda/GreyscaleColor.cu | 88 ++++++++++++++++++++++++------------------
 1 file changed, 51 insertions(+), 37 deletions(-)

diff --git a/cuda/GreyscaleColor.cu b/cuda/GreyscaleColor.cu
index e3a4c421..01597f7f 100644
--- a/cuda/GreyscaleColor.cu
+++ b/cuda/GreyscaleColor.cu
@@ -1608,22 +1608,6 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			ny_phase = -(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
 			nz_phase = -(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
 			C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
-			//............Compute the Greyscale Potential Gradient.....................
-			Fcpx = 0.0;
-			Fcpy = 0.0;
-			Fcpz = 0.0;
-            if (porosity!=1.0){
-                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
-                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
-                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
-                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
-                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
-                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
-                Fcpx *= alpha*W/sqrt(perm); 
-                Fcpy *= alpha*W/sqrt(perm); 
-                Fcpz *= alpha*W/sqrt(perm); 
-            }
-
 
             //correct the normal color gradient by considering the effect of grey solid
             nx = nx_phase + (1.0-porosity)*nx_gs; 
@@ -1643,6 +1627,28 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			ny = ny/ColorMag;
 			nz = nz/ColorMag;		
 
+			//............Compute the Greyscale Potential Gradient.....................
+			Fcpx = 0.0;
+			Fcpy = 0.0;
+			Fcpz = 0.0;
+            if (porosity!=1.0){
+                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
+                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
+                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+                Fcpx *= alpha*W/sqrt(perm); 
+                Fcpy *= alpha*W/sqrt(perm); 
+                Fcpz *= alpha*W/sqrt(perm); 
+                double Fcp_mag_temp = sqrt(Fcpx*Fcpx+Fcpy*Fcpy+Fcpz*Fcpz);
+                double Fcp_mag = Fcp_mag_temp;
+                if (Fcp_mag_temp==0.0) Fcp_mag=1.0;
+                nx = Fcpx/Fcp_mag;
+                ny = Fcpy/Fcp_mag;
+                nz = Fcpz/Fcp_mag;
+            }
+
 			// q=0
 			fq = dist[n];
 			rho = fq;
@@ -2188,7 +2194,7 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			// Cq = {1,0,0}, {0,1,0}, {0,0,1}
 			delta = beta*nA*nB*nAB*0.1111111111111111*nx;
 			if (!(nA*nB*nAB>0)) delta=0;
-            if (RecoloringOff==true && porosity !=1.0) delta=0;
+            //if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*ux))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*ux))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*ux))-delta;
@@ -2207,7 +2213,7 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			// Cq = {0,1,0}
 			delta = beta*nA*nB*nAB*0.1111111111111111*ny;
 			if (!(nA*nB*nAB>0)) delta=0;
-            if (RecoloringOff==true && porosity !=1.0) delta=0;
+            //if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*uy))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*uy))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*uy))-delta;
@@ -2227,7 +2233,7 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			// Cq = {0,0,1}
 			delta = beta*nA*nB*nAB*0.1111111111111111*nz;
 			if (!(nA*nB*nAB>0)) delta=0;
-            if (RecoloringOff==true && porosity !=1.0) delta=0;
+            //if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*uz))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*uz))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*uz))-delta;
@@ -2402,21 +2408,6 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			ny_phase = -(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
 			nz_phase = -(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
 			C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
-			//............Compute the Greyscale Potential Gradient.....................
-			Fcpx = 0.0;
-			Fcpy = 0.0;
-			Fcpz = 0.0;
-            if (porosity!=1.0){
-                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
-                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
-                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
-                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
-                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
-                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
-                Fcpx *= alpha*W/sqrt(perm); 
-                Fcpy *= alpha*W/sqrt(perm); 
-                Fcpz *= alpha*W/sqrt(perm); 
-            }
 
             //correct the normal color gradient by considering the effect of grey solid
             nx = nx_phase + (1.0-porosity)*nx_gs; 
@@ -2436,6 +2427,29 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			ny = ny/ColorMag;
 			nz = nz/ColorMag;		
 
+			//............Compute the Greyscale Potential Gradient.....................
+			Fcpx = 0.0;
+			Fcpy = 0.0;
+			Fcpz = 0.0;
+            if (porosity!=1.0){
+                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
+                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
+                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+                Fcpx *= alpha*W/sqrt(perm); 
+                Fcpy *= alpha*W/sqrt(perm); 
+                Fcpz *= alpha*W/sqrt(perm); 
+                double Fcp_mag_temp = sqrt(Fcpx*Fcpx+Fcpy*Fcpy+Fcpz*Fcpz);
+                double Fcp_mag = Fcp_mag_temp;
+                if (Fcp_mag_temp==0.0) Fcp_mag=1.0;
+                nx = Fcpx/Fcp_mag;
+                ny = Fcpy/Fcp_mag;
+                nz = Fcpz/Fcp_mag;
+            }
+
+
 			// q=0
 			fq = dist[n];
 			rho = fq;
@@ -2914,7 +2928,7 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			// Cq = {1,0,0}, {0,1,0}, {0,0,1}
 			delta = beta*nA*nB*nAB*0.1111111111111111*nx;
 			if (!(nA*nB*nAB>0)) delta=0;
-            if (RecoloringOff==true && porosity !=1.0) delta=0;
+            //if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*ux))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*ux))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*ux))-delta;
@@ -2930,7 +2944,7 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			// Cq = {0,1,0}
 			delta = beta*nA*nB*nAB*0.1111111111111111*ny;
 			if (!(nA*nB*nAB>0)) delta=0;
-            if (RecoloringOff==true && porosity !=1.0) delta=0;
+            //if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*uy))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*uy))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*uy))-delta;
@@ -2945,7 +2959,7 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			// Cq = {0,0,1}
 			delta = beta*nA*nB*nAB*0.1111111111111111*nz;
 			if (!(nA*nB*nAB>0)) delta=0;
-            if (RecoloringOff==true && porosity !=1.0) delta=0;
+            //if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*uz))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*uz))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*uz))-delta;

From 57158b539ec401341af426dd84648d88a21febdc Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Thu, 11 Mar 2021 20:00:03 -0500
Subject: [PATCH 08/19] had accidentally comment out the recoloring check; put
 it back on

---
 cuda/GreyscaleColor.cu | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/cuda/GreyscaleColor.cu b/cuda/GreyscaleColor.cu
index 01597f7f..5cc5d87e 100644
--- a/cuda/GreyscaleColor.cu
+++ b/cuda/GreyscaleColor.cu
@@ -2194,7 +2194,7 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			// Cq = {1,0,0}, {0,1,0}, {0,0,1}
 			delta = beta*nA*nB*nAB*0.1111111111111111*nx;
 			if (!(nA*nB*nAB>0)) delta=0;
-            //if (RecoloringOff==true && porosity !=1.0) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*ux))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*ux))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*ux))-delta;
@@ -2213,7 +2213,7 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			// Cq = {0,1,0}
 			delta = beta*nA*nB*nAB*0.1111111111111111*ny;
 			if (!(nA*nB*nAB>0)) delta=0;
-            //if (RecoloringOff==true && porosity !=1.0) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*uy))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*uy))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*uy))-delta;
@@ -2233,7 +2233,7 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			// Cq = {0,0,1}
 			delta = beta*nA*nB*nAB*0.1111111111111111*nz;
 			if (!(nA*nB*nAB>0)) delta=0;
-            //if (RecoloringOff==true && porosity !=1.0) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*uz))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*uz))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*uz))-delta;
@@ -2928,7 +2928,7 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			// Cq = {1,0,0}, {0,1,0}, {0,0,1}
 			delta = beta*nA*nB*nAB*0.1111111111111111*nx;
 			if (!(nA*nB*nAB>0)) delta=0;
-            //if (RecoloringOff==true && porosity !=1.0) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*ux))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*ux))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*ux))-delta;
@@ -2944,7 +2944,7 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			// Cq = {0,1,0}
 			delta = beta*nA*nB*nAB*0.1111111111111111*ny;
 			if (!(nA*nB*nAB>0)) delta=0;
-            //if (RecoloringOff==true && porosity !=1.0) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*uy))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*uy))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*uy))-delta;
@@ -2959,7 +2959,7 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			// Cq = {0,0,1}
 			delta = beta*nA*nB*nAB*0.1111111111111111*nz;
 			if (!(nA*nB*nAB>0)) delta=0;
-            //if (RecoloringOff==true && porosity !=1.0) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
 			a1 = nA*(0.1111111111111111*(1+4.5*uz))+delta;
 			b1 = nB*(0.1111111111111111*(1+4.5*uz))-delta;
 			a2 = nA*(0.1111111111111111*(1-4.5*uz))-delta;

From fdf635bb57c11a7cb2b336393bf45a57a8a7d844 Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Thu, 11 Mar 2021 21:11:57 -0500
Subject: [PATCH 09/19] revise the capillary penalty formulation

---
 cuda/GreyscaleColor.cu | 106 +++++++++++++++++++++++------------------
 1 file changed, 60 insertions(+), 46 deletions(-)

diff --git a/cuda/GreyscaleColor.cu b/cuda/GreyscaleColor.cu
index 5cc5d87e..089d8fdc 100644
--- a/cuda/GreyscaleColor.cu
+++ b/cuda/GreyscaleColor.cu
@@ -1604,9 +1604,9 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			m18 = Phi[nn];					// get neighbor for phi - 18
             gp18 = Psi[nn];
 			//............Compute the Color Gradient...................................
-			nx_phase = -(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
-			ny_phase = -(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
-			nz_phase = -(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+			nx_phase = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+			ny_phase = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+			nz_phase = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
 			C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
 
             //correct the normal color gradient by considering the effect of grey solid
@@ -1628,26 +1628,33 @@ __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int
 			nz = nz/ColorMag;		
 
 			//............Compute the Greyscale Potential Gradient.....................
-			Fcpx = 0.0;
-			Fcpy = 0.0;
-			Fcpz = 0.0;
-            if (porosity!=1.0){
-                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
-                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
-                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
-                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
-                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
-                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
-                Fcpx *= alpha*W/sqrt(perm); 
-                Fcpy *= alpha*W/sqrt(perm); 
-                Fcpz *= alpha*W/sqrt(perm); 
-                double Fcp_mag_temp = sqrt(Fcpx*Fcpx+Fcpy*Fcpy+Fcpz*Fcpz);
-                double Fcp_mag = Fcp_mag_temp;
-                if (Fcp_mag_temp==0.0) Fcp_mag=1.0;
-                nx = Fcpx/Fcp_mag;
-                ny = Fcpy/Fcp_mag;
-                nz = Fcpz/Fcp_mag;
-            }
+//			Fcpx = 0.0;
+//			Fcpy = 0.0;
+//			Fcpz = 0.0;
+//            if (porosity!=1.0){
+//                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
+//                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
+//                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+//                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+//                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+//                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+//                Fcpx *= alpha*W/sqrt(perm); 
+//                Fcpy *= alpha*W/sqrt(perm); 
+//                Fcpz *= alpha*W/sqrt(perm); 
+//                //double Fcp_mag_temp = sqrt(Fcpx*Fcpx+Fcpy*Fcpy+Fcpz*Fcpz);
+//                //double Fcp_mag = Fcp_mag_temp;
+//                //if (Fcp_mag_temp==0.0) Fcp_mag=1.0;
+//                //nx = Fcpx/Fcp_mag;
+//                //ny = Fcpy/Fcp_mag;
+//                //nz = Fcpz/Fcp_mag;
+//            }
+            Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+            Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+            Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+            //NOTE for open node (porosity=1.0),Fcp=0.0
+            Fcpx *= alpha*W*(1.0-porosity)/sqrt(perm); 
+            Fcpy *= alpha*W*(1.0-porosity)/sqrt(perm); 
+            Fcpz *= alpha*W*(1.0-porosity)/sqrt(perm); 
 
 			// q=0
 			fq = dist[n];
@@ -2404,9 +2411,9 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			m18 = Phi[nn];					// get neighbor for phi - 18
             gp18 = Psi[nn];
 			//............Compute the Color Gradient...................................
-			nx_phase = -(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
-			ny_phase = -(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
-			nz_phase = -(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+			nx_phase = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+			ny_phase = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+			nz_phase = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
 			C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
 
             //correct the normal color gradient by considering the effect of grey solid
@@ -2428,26 +2435,33 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dis
 			nz = nz/ColorMag;		
 
 			//............Compute the Greyscale Potential Gradient.....................
-			Fcpx = 0.0;
-			Fcpy = 0.0;
-			Fcpz = 0.0;
-            if (porosity!=1.0){
-                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
-                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
-                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
-                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
-                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
-                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
-                Fcpx *= alpha*W/sqrt(perm); 
-                Fcpy *= alpha*W/sqrt(perm); 
-                Fcpz *= alpha*W/sqrt(perm); 
-                double Fcp_mag_temp = sqrt(Fcpx*Fcpx+Fcpy*Fcpy+Fcpz*Fcpz);
-                double Fcp_mag = Fcp_mag_temp;
-                if (Fcp_mag_temp==0.0) Fcp_mag=1.0;
-                nx = Fcpx/Fcp_mag;
-                ny = Fcpy/Fcp_mag;
-                nz = Fcpz/Fcp_mag;
-            }
+//			Fcpx = 0.0;
+//			Fcpy = 0.0;
+//			Fcpz = 0.0;
+//            if (porosity!=1.0){
+//                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
+//                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
+//                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+//                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+//                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+//                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+//                Fcpx *= alpha*W/sqrt(perm); 
+//                Fcpy *= alpha*W/sqrt(perm); 
+//                Fcpz *= alpha*W/sqrt(perm); 
+//                double Fcp_mag_temp = sqrt(Fcpx*Fcpx+Fcpy*Fcpy+Fcpz*Fcpz);
+//                double Fcp_mag = Fcp_mag_temp;
+//                if (Fcp_mag_temp==0.0) Fcp_mag=1.0;
+//                nx = Fcpx/Fcp_mag;
+//                ny = Fcpy/Fcp_mag;
+//                nz = Fcpz/Fcp_mag;
+//            }
+            Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+            Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+            Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+            //NOTE for open node (porosity=1.0),Fcp=0.0
+            Fcpx *= alpha*W*(1.0-porosity)/sqrt(perm); 
+            Fcpy *= alpha*W*(1.0-porosity)/sqrt(perm); 
+            Fcpz *= alpha*W*(1.0-porosity)/sqrt(perm); 
 
 
 			// q=0

From 02d2e514ed2bfb6828e7736ecd8364a8b9ac74df Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Thu, 18 Mar 2021 07:58:05 -0400
Subject: [PATCH 10/19] make CPU also ready for capillary penalty; to be built
 and verified

---
 common/ScaLBL.h        |    4 +-
 cpu/GreyscaleColor.cpp | 1456 ++++++++++++++++++++++++++++++++++++++++
 cuda/GreyscaleColor.cu |   71 +-
 3 files changed, 1495 insertions(+), 36 deletions(-)

diff --git a/common/ScaLBL.h b/common/ScaLBL.h
index 5c4d4730..22ef077c 100644
--- a/common/ScaLBL.h
+++ b/common/ScaLBL.h
@@ -97,8 +97,8 @@ extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *d_neighborList, int *M
         double rhoA, double rhoB, double tauA, double tauB, double tauA_eff,double tauB_eff, double alpha, double beta,
 		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np);
 
-extern "C" void ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
-		int start, int finish, int Np);
+//extern "C" void ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
+//		int start, int finish, int Np);
 
 // ION TRANSPORT MODEL
 
diff --git a/cpu/GreyscaleColor.cpp b/cpu/GreyscaleColor.cpp
index 057c8a7d..dfd755e3 100644
--- a/cpu/GreyscaleColor.cpp
+++ b/cpu/GreyscaleColor.cpp
@@ -1338,6 +1338,1462 @@ extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor(int *Map, double *dist, doubl
 	}
 }
 
+//CP: capillary penalty
+// also turn off recoloring for grey nodes
+extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den, 
+		double *Phi, double *Psi, double *GreySolidGrad, double *Poros,double *Perm,double *Velocity,double *Pressure,
+        double rhoA, double rhoB, double tauA, double tauB, double tauA_eff,double tauB_eff, double alpha, double beta,
+		double Gx, double Gy, double Gz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
+
+	int n,nn,ijk,nread;
+	int nr1,nr2,nr3,nr4,nr5,nr6;
+	int nr7,nr8,nr9,nr10;
+	int nr11,nr12,nr13,nr14;
+	//int nr15,nr16,nr17,nr18;
+	double fq;
+	// conserved momemnts
+	double rho,jx,jy,jz;
+	//double vx,vy,vz,v_mag;
+    //double ux,uy,uz,u_mag;
+    double ux,uy,uz;
+	// non-conserved moments
+	double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
+	double m3,m5,m7;
+	double nA,nB; // number density
+	double a1,b1,a2,b2,nAB,delta;
+	double C,nx,ny,nz; //color gradient magnitude and direction
+	double phi,tau,rho0,rlx_setA,rlx_setB;
+
+    //double GeoFun=0.0;//geometric function from Guo's PRE 66, 036304 (2002)
+    double porosity;
+    double perm;//voxel permeability
+    //double c0, c1; //Guo's model parameters
+    double tau_eff;
+    double mu_eff;//kinematic viscosity
+    double nx_gs,ny_gs,nz_gs;//grey-solid color gradient
+    double nx_phase,ny_phase,nz_phase,C_phase;
+    double Fx,Fy,Fz;
+	double gp1,gp2,gp4,gp6,gp8,gp9,gp10,gp11,gp12,gp13,gp14,gp15,gp16,gp17,gp18;
+	double gp3,gp5,gp7;
+    double Fcpx,Fcpy,Fcpz;//capillary penalty force
+
+	const double mrt_V1=0.05263157894736842;
+	const double mrt_V2=0.012531328320802;
+	const double mrt_V3=0.04761904761904762;
+	const double mrt_V4=0.004594820384294068;
+	const double mrt_V5=0.01587301587301587;
+	const double mrt_V6=0.0555555555555555555555555;
+	const double mrt_V7=0.02777777777777778;
+	const double mrt_V8=0.08333333333333333;
+	const double mrt_V9=0.003341687552213868;
+	const double mrt_V10=0.003968253968253968;
+	const double mrt_V11=0.01388888888888889;
+	const double mrt_V12=0.04166666666666666;
+
+	for (n=start; n<finish; n++){
+		// read the component number densities
+		nA = Den[n];
+		nB = Den[Np + n];
+        porosity = Poros[n];
+        perm = Perm[n];
+        nx_gs = GreySolidGrad[n+0*Np];
+        ny_gs = GreySolidGrad[n+1*Np];
+        nz_gs = GreySolidGrad[n+2*Np];
+
+		// compute phase indicator field
+		phi=(nA-nB)/(nA+nB);
+
+		// local density
+		rho0=rhoA + 0.5*(1.0-phi)*(rhoB-rhoA);
+		// local relaxation time
+		tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
+		tau_eff=tauA_eff + 0.5*(1.0-phi)*(tauB_eff-tauA_eff);
+		rlx_setA = 1.f/tau;
+		rlx_setB = 8.f*(2.f-rlx_setA)/(8.f-rlx_setA);
+        mu_eff = (tau_eff-0.5)/3.0;//kinematic viscosity
+		
+		// Get the 1D index based on regular data layout
+		ijk = Map[n];
+		//					COMPUTE THE COLOR GRADIENT
+		//........................................................................
+		//.................Read Phase Indicator Values............................
+		//........................................................................
+		nn = ijk-1;							// neighbor index (get convention)
+		m1 = Phi[nn];						// get neighbor for phi - 1
+        gp1 = Psi[nn];
+		//........................................................................
+		nn = ijk+1;							// neighbor index (get convention)
+		m2 = Phi[nn];						// get neighbor for phi - 2
+        gp2 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideY;							// neighbor index (get convention)
+		m3 = Phi[nn];					// get neighbor for phi - 3
+        gp3 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideY;							// neighbor index (get convention)
+		m4 = Phi[nn];					// get neighbor for phi - 4
+        gp4 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideZ;						// neighbor index (get convention)
+		m5 = Phi[nn];					// get neighbor for phi - 5
+        gp5 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideZ;						// neighbor index (get convention)
+		m6 = Phi[nn];					// get neighbor for phi - 6
+        gp6 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideY-1;						// neighbor index (get convention)
+		m7 = Phi[nn];					// get neighbor for phi - 7
+        gp7 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideY+1;						// neighbor index (get convention)
+		m8 = Phi[nn];					// get neighbor for phi - 8
+        gp8 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideY-1;						// neighbor index (get convention)
+		m9 = Phi[nn];					// get neighbor for phi - 9
+        gp9 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideY+1;						// neighbor index (get convention)
+		m10 = Phi[nn];					// get neighbor for phi - 10
+        gp10 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideZ-1;						// neighbor index (get convention)
+		m11 = Phi[nn];					// get neighbor for phi - 11
+        gp11 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideZ+1;						// neighbor index (get convention)
+		m12 = Phi[nn];					// get neighbor for phi - 12
+        gp12 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideZ-1;						// neighbor index (get convention)
+		m13 = Phi[nn];					// get neighbor for phi - 13
+        gp13 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideZ+1;						// neighbor index (get convention)
+		m14 = Phi[nn];					// get neighbor for phi - 14
+        gp14 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideZ-strideY;					// neighbor index (get convention)
+		m15 = Phi[nn];					// get neighbor for phi - 15
+        gp15 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideZ+strideY;					// neighbor index (get convention)
+		m16 = Phi[nn];					// get neighbor for phi - 16
+        gp16 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideZ-strideY;					// neighbor index (get convention)
+		m17 = Phi[nn];					// get neighbor for phi - 17
+        gp17 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideZ+strideY;					// neighbor index (get convention)
+		m18 = Phi[nn];					// get neighbor for phi - 18
+        gp18 = Psi[nn];
+		//............Compute the Color Gradient...................................
+		nx_phase = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+		ny_phase = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+		nz_phase = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+		C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
+
+        //correct the normal color gradient by considering the effect of grey solid
+        nx = nx_phase + (1.0-porosity)*nx_gs; 
+        ny = ny_phase + (1.0-porosity)*ny_gs; 
+        nz = nz_phase + (1.0-porosity)*nz_gs; 
+        if (C_phase==0.0){
+            nx = nx_phase; 
+            ny = ny_phase;
+            nz = nz_phase;
+        }
+
+		//...........Normalize the Color Gradient.................................
+		C = sqrt(nx*nx+ny*ny+nz*nz);
+		double ColorMag = C;
+		if (C==0.0) ColorMag=1.0;
+		nx = nx/ColorMag;
+		ny = ny/ColorMag;
+		nz = nz/ColorMag;		
+
+			//............Compute the Greyscale Potential Gradient.....................
+//			Fcpx = 0.0;
+//			Fcpy = 0.0;
+//			Fcpz = 0.0;
+//            if (porosity!=1.0){
+//                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
+//                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
+//                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+//                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+//                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+//                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+//                Fcpx *= alpha*W/sqrt(perm); 
+//                Fcpy *= alpha*W/sqrt(perm); 
+//                Fcpz *= alpha*W/sqrt(perm); 
+//                //double Fcp_mag_temp = sqrt(Fcpx*Fcpx+Fcpy*Fcpy+Fcpz*Fcpz);
+//                //double Fcp_mag = Fcp_mag_temp;
+//                //if (Fcp_mag_temp==0.0) Fcp_mag=1.0;
+//                //nx = Fcpx/Fcp_mag;
+//                //ny = Fcpy/Fcp_mag;
+//                //nz = Fcpz/Fcp_mag;
+//            }
+        Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+        Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+        Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+        //NOTE for open node (porosity=1.0),Fcp=0.0
+        Fcpx *= alpha*W*(1.0-porosity)/sqrt(perm); 
+        Fcpy *= alpha*W*(1.0-porosity)/sqrt(perm); 
+        Fcpz *= alpha*W*(1.0-porosity)/sqrt(perm); 
+
+		// q=0
+		fq = dist[n];
+		rho = fq;
+		m1  = -30.0*fq;
+		m2  = 12.0*fq;
+
+		// q=1
+		//nread = neighborList[n]; // neighbor 2 
+		//fq = dist[nread]; // reading the f1 data into register fq		
+		nr1 = neighborList[n]; 
+		fq = dist[nr1]; // reading the f1 data into register fq
+		rho += fq;
+		m1 -= 11.0*fq;
+		m2 -= 4.0*fq;
+		jx = fq;
+		m4 = -4.0*fq;
+		m9 = 2.0*fq;
+		m10 = -4.0*fq;
+
+		// f2 = dist[10*Np+n];
+		//nread = neighborList[n+Np]; // neighbor 1 ( < 10Np => even part of dist)
+		//fq = dist[nread];  // reading the f2 data into register fq
+		nr2 = neighborList[n+Np]; // neighbor 1 ( < 10Np => even part of dist)
+		fq = dist[nr2];  // reading the f2 data into register fq
+		rho += fq;
+		m1 -= 11.0*(fq);
+		m2 -= 4.0*(fq);
+		jx -= fq;
+		m4 += 4.0*(fq);
+		m9 += 2.0*(fq);
+		m10 -= 4.0*(fq);
+
+		// q=3
+		//nread = neighborList[n+2*Np]; // neighbor 4
+		//fq = dist[nread];
+		nr3 = neighborList[n+2*Np]; // neighbor 4
+		fq = dist[nr3];
+		rho += fq;
+		m1 -= 11.0*fq;
+		m2 -= 4.0*fq;
+		jy = fq;
+		m6 = -4.0*fq;
+		m9 -= fq;
+		m10 += 2.0*fq;
+		m11 = fq;
+		m12 = -2.0*fq;
+
+		// q = 4
+		//nread = neighborList[n+3*Np]; // neighbor 3
+		//fq = dist[nread];
+		nr4 = neighborList[n+3*Np]; // neighbor 3
+		fq = dist[nr4];
+		rho+= fq;
+		m1 -= 11.0*fq;
+		m2 -= 4.0*fq;
+		jy -= fq;
+		m6 += 4.0*fq;
+		m9 -= fq;
+		m10 += 2.0*fq;
+		m11 += fq;
+		m12 -= 2.0*fq;
+
+		// q=5
+		//nread = neighborList[n+4*Np];
+		//fq = dist[nread];
+		nr5 = neighborList[n+4*Np];
+		fq = dist[nr5];
+		rho += fq;
+		m1 -= 11.0*fq;
+		m2 -= 4.0*fq;
+		jz = fq;
+		m8 = -4.0*fq;
+		m9 -= fq;
+		m10 += 2.0*fq;
+		m11 -= fq;
+		m12 += 2.0*fq;
+
+
+		// q = 6
+		//nread = neighborList[n+5*Np];
+		//fq = dist[nread];
+		nr6 = neighborList[n+5*Np];
+		fq = dist[nr6];
+		rho+= fq;
+		m1 -= 11.0*fq;
+		m2 -= 4.0*fq;
+		jz -= fq;
+		m8 += 4.0*fq;
+		m9 -= fq;
+		m10 += 2.0*fq;
+		m11 -= fq;
+		m12 += 2.0*fq;
+
+		// q=7
+		//nread = neighborList[n+6*Np];
+		//fq = dist[nread];
+		nr7 = neighborList[n+6*Np];
+		fq = dist[nr7];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx += fq;
+		m4 += fq;
+		jy += fq;
+		m6 += fq;
+		m9  += fq;
+		m10 += fq;
+		m11 += fq;
+		m12 += fq;
+		m13 = fq;
+		m16 = fq;
+		m17 = -fq;
+
+		// q = 8
+		//nread = neighborList[n+7*Np];
+		//fq = dist[nread];
+		nr8 = neighborList[n+7*Np];
+		fq = dist[nr8];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx -= fq;
+		m4 -= fq;
+		jy -= fq;
+		m6 -= fq;
+		m9 += fq;
+		m10 += fq;
+		m11 += fq;
+		m12 += fq;
+		m13 += fq;
+		m16 -= fq;
+		m17 += fq;
+
+		// q=9
+		//nread = neighborList[n+8*Np];
+		//fq = dist[nread];
+		nr9 = neighborList[n+8*Np];
+		fq = dist[nr9];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx += fq;
+		m4 += fq;
+		jy -= fq;
+		m6 -= fq;
+		m9 += fq;
+		m10 += fq;
+		m11 += fq;
+		m12 += fq;
+		m13 -= fq;
+		m16 += fq;
+		m17 += fq;
+
+		// q = 10
+		//nread = neighborList[n+9*Np];
+		//fq = dist[nread];
+		nr10 = neighborList[n+9*Np];
+		fq = dist[nr10];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx -= fq;
+		m4 -= fq;
+		jy += fq;
+		m6 += fq;
+		m9 += fq;
+		m10 += fq;
+		m11 += fq;
+		m12 += fq;
+		m13 -= fq;
+		m16 -= fq;
+		m17 -= fq;
+
+		// q=11
+		//nread = neighborList[n+10*Np];
+		//fq = dist[nread];
+		nr11 = neighborList[n+10*Np];
+		fq = dist[nr11];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx += fq;
+		m4 += fq;
+		jz += fq;
+		m8 += fq;
+		m9 += fq;
+		m10 += fq;
+		m11 -= fq;
+		m12 -= fq;
+		m15 = fq;
+		m16 -= fq;
+		m18 = fq;
+
+		// q=12
+		//nread = neighborList[n+11*Np];
+		//fq = dist[nread];
+		nr12 = neighborList[n+11*Np];
+		fq = dist[nr12];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx -= fq;
+		m4 -= fq;
+		jz -= fq;
+		m8 -= fq;
+		m9 += fq;
+		m10 += fq;
+		m11 -= fq;
+		m12 -= fq;
+		m15 += fq;
+		m16 += fq;
+		m18 -= fq;
+
+		// q=13
+		//nread = neighborList[n+12*Np];
+		//fq = dist[nread];
+		nr13 = neighborList[n+12*Np];
+		fq = dist[nr13];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx += fq;
+		m4 += fq;
+		jz -= fq;
+		m8 -= fq;
+		m9 += fq;
+		m10 += fq;
+		m11 -= fq;
+		m12 -= fq;
+		m15 -= fq;
+		m16 -= fq;
+		m18 -= fq;
+
+		// q=14
+		//nread = neighborList[n+13*Np];
+		//fq = dist[nread];
+		nr14 = neighborList[n+13*Np];
+		fq = dist[nr14];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx -= fq;
+		m4 -= fq;
+		jz += fq;
+		m8 += fq;
+		m9 += fq;
+		m10 += fq;
+		m11 -= fq;
+		m12 -= fq;
+		m15 -= fq;
+		m16 += fq;
+		m18 += fq;
+
+		// q=15
+		nread = neighborList[n+14*Np];
+		fq = dist[nread];
+		//fq = dist[17*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jy += fq;
+		m6 += fq;
+		jz += fq;
+		m8 += fq;
+		m9 -= 2.0*fq;
+		m10 -= 2.0*fq;
+		m14 = fq;
+		m17 += fq;
+		m18 -= fq;
+
+		// q=16
+		nread = neighborList[n+15*Np];
+		fq = dist[nread];
+		//fq = dist[8*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jy -= fq;
+		m6 -= fq;
+		jz -= fq;
+		m8 -= fq;
+		m9 -= 2.0*fq;
+		m10 -= 2.0*fq;
+		m14 += fq;
+		m17 -= fq;
+		m18 += fq;
+
+		// q=17
+		//fq = dist[18*Np+n];
+		nread = neighborList[n+16*Np];
+		fq = dist[nread];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jy += fq;
+		m6 += fq;
+		jz -= fq;
+		m8 -= fq;
+		m9 -= 2.0*fq;
+		m10 -= 2.0*fq;
+		m14 -= fq;
+		m17 += fq;
+		m18 += fq;
+
+		// q=18
+		nread = neighborList[n+17*Np];
+		fq = dist[nread];
+		//fq = dist[9*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jy -= fq;
+		m6 -= fq;
+		jz += fq;
+		m8 += fq;
+		m9 -= 2.0*fq;
+		m10 -= 2.0*fq;
+		m14 -= fq;
+		m17 -= fq;
+		m18 -= fq;
+		
+        // Compute greyscale related parameters
+        ux = (jx/rho0+0.5*porosity*Gx+0.5*Fcpx/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+        uy = (jy/rho0+0.5*porosity*Gy+0.5*Fcpy/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+        uz = (jz/rho0+0.5*porosity*Gz+0.5*Fcpz/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+        if (porosity==1.0){//i.e. open nodes
+            ux = (jx/rho0+0.5*porosity*Gx);
+            uy = (jy/rho0+0.5*porosity*Gy);
+            uz = (jz/rho0+0.5*porosity*Gz);
+        }
+
+        //Update the total force to include linear (Darcy) and nonlinear (Forchheimer) drags due to the porous medium
+        Fx = rho0*(-porosity*mu_eff/perm*ux + porosity*Gx)+Fcpx;
+        Fy = rho0*(-porosity*mu_eff/perm*uy + porosity*Gy)+Fcpy;
+        Fz = rho0*(-porosity*mu_eff/perm*uz + porosity*Gz)+Fcpz;
+        if (porosity==1.0){
+            Fx=rho0*(porosity*Gx);
+            Fy=rho0*(porosity*Gy);
+            Fz=rho0*(porosity*Gz);
+        }
+
+		// write the velocity 
+		Velocity[n] = ux;
+		Velocity[Np+n] = uy;
+		Velocity[2*Np+n] = uz;
+        //Pressure[n] = rho/3.f/porosity;
+        Pressure[n] = rho/3.f;
+
+		//........................................................................
+		//..............carry out relaxation process..............................
+		//..........Toelke, Fruediger et. al. 2006................................
+		if (C == 0.0)	nx = ny = nz = 0.0;
+		m1 = m1 + rlx_setA*((19*(ux*ux+uy*uy+uz*uz)*rho0/porosity - 11*rho) -19*alpha*C - m1);
+		m2 = m2 + rlx_setA*((3*rho - 5.5*(ux*ux+uy*uy+uz*uz)*rho0/porosity)- m2);
+        jx = jx + Fx;
+		m4 = m4 + rlx_setB*((-0.6666666666666666*ux*rho0)- m4)
+                + (1-0.5*rlx_setB)*(-0.6666666666666666*Fx);
+        jy = jy + Fy;
+		m6 = m6 + rlx_setB*((-0.6666666666666666*uy*rho0)- m6)
+                + (1-0.5*rlx_setB)*(-0.6666666666666666*Fy);
+        jz = jz + Fz;
+		m8 = m8 + rlx_setB*((-0.6666666666666666*uz*rho0)- m8)
+                + (1-0.5*rlx_setB)*(-0.6666666666666666*Fz);
+		m9 = m9 + rlx_setA*(((2*ux*ux-uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(2*nx*nx-ny*ny-nz*nz) - m9);
+		m10 = m10 + rlx_setA*( - m10);
+        //m10 = m10 + rlx_setA*(-0.5*rho0*((2*ux*ux-uy*uy-uz*uz)/porosity)- m10);
+		m11 = m11 + rlx_setA*(((uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(ny*ny-nz*nz)- m11);
+		m12 = m12 + rlx_setA*( - m12);
+        //m12 = m12 + rlx_setA*(-0.5*(rho0*(uy*uy-uz*uz)/porosity)- m12);
+		m13 = m13 + rlx_setA*( (ux*uy*rho0/porosity) + 0.5*alpha*C*nx*ny - m13);
+		m14 = m14 + rlx_setA*( (uy*uz*rho0/porosity) + 0.5*alpha*C*ny*nz - m14);
+		m15 = m15 + rlx_setA*( (ux*uz*rho0/porosity) + 0.5*alpha*C*nx*nz - m15);
+		m16 = m16 + rlx_setB*( - m16);
+		m17 = m17 + rlx_setB*( - m17);
+		m18 = m18 + rlx_setB*( - m18);
+
+		//.................inverse transformation......................................................
+		// q=0
+		fq = mrt_V1*rho-mrt_V2*m1+mrt_V3*m2;
+		dist[n] = fq;
+
+		// q = 1
+		fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jx-m4)+mrt_V6*(m9-m10);
+		//nread = neighborList[n+Np];
+		dist[nr2] = fq;
+
+		// q=2
+		fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m4-jx)+mrt_V6*(m9-m10);
+		//nread = neighborList[n];
+		dist[nr1] = fq;
+
+		// q = 3
+		fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jy-m6)+mrt_V7*(m10-m9)+mrt_V8*(m11-m12);
+		//nread = neighborList[n+3*Np];
+		dist[nr4] = fq;
+
+		// q = 4
+		fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m6-jy)+mrt_V7*(m10-m9)+mrt_V8*(m11-m12);
+		//nread = neighborList[n+2*Np];
+		dist[nr3] = fq;
+
+		// q = 5
+		fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jz-m8)+mrt_V7*(m10-m9)+mrt_V8*(m12-m11);
+		//nread = neighborList[n+5*Np];
+		dist[nr6] = fq;
+
+		// q = 6
+		fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m8-jz)+mrt_V7*(m10-m9)+mrt_V8*(m12-m11);
+		//nread = neighborList[n+4*Np];
+		dist[nr5] = fq;
+
+		// q = 7
+		fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jx+jy)+0.025*(m4+m6)+
+				mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12+0.25*m13+0.125*(m16-m17);
+		//nread = neighborList[n+7*Np];
+		dist[nr8] = fq;
+
+		// q = 8
+		fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2-0.1*(jx+jy)-0.025*(m4+m6) +mrt_V7*m9+mrt_V11*m10+mrt_V8*m11
+				+mrt_V12*m12+0.25*m13+0.125*(m17-m16);
+		//nread = neighborList[n+6*Np];
+		dist[nr7] = fq;
+
+		// q = 9
+		fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jx-jy)+0.025*(m4-m6)+
+				mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12-0.25*m13+0.125*(m16+m17);
+		//nread = neighborList[n+9*Np];
+		dist[nr10] = fq;
+
+		// q = 10
+		fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jy-jx)+0.025*(m6-m4)+
+				mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12-0.25*m13-0.125*(m16+m17);
+		//nread = neighborList[n+8*Np];
+		dist[nr9] = fq;
+
+		// q = 11
+		fq = mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2+0.1*(jx+jz)+0.025*(m4+m8)
+				+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+				-mrt_V12*m12+0.25*m15+0.125*(m18-m16);
+		//nread = neighborList[n+11*Np];
+		dist[nr12] = fq;
+
+		// q = 12
+		fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2-0.1*(jx+jz)-0.025*(m4+m8)+
+				mrt_V7*m9+mrt_V11*m10-mrt_V8*m11-mrt_V12*m12+0.25*m15+0.125*(m16-m18);
+		//nread = neighborList[n+10*Np];
+		dist[nr11]= fq;
+
+		// q = 13
+		fq = mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2+0.1*(jx-jz)+0.025*(m4-m8)
+				+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+				-mrt_V12*m12-0.25*m15-0.125*(m16+m18);
+		//nread = neighborList[n+13*Np];
+		dist[nr14] = fq;
+
+		// q= 14
+		fq = mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2+0.1*(jz-jx)+0.025*(m8-m4)
+				+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+				-mrt_V12*m12-0.25*m15+0.125*(m16+m18);
+		//nread = neighborList[n+12*Np];
+		dist[nr13] = fq;
+
+
+		// q = 15
+		fq = mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2+0.1*(jy+jz)+0.025*(m6+m8)
+				-mrt_V6*m9-mrt_V7*m10+0.25*m14+0.125*(m17-m18);
+		nread = neighborList[n+15*Np];
+		dist[nread] = fq;
+
+		// q = 16
+		fq =  mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2-0.1*(jy+jz)-0.025*(m6+m8)
+				-mrt_V6*m9-mrt_V7*m10+0.25*m14+0.125*(m18-m17);
+		nread = neighborList[n+14*Np];
+		dist[nread] = fq;
+
+
+		// q = 17
+		fq = mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2+0.1*(jy-jz)+0.025*(m6-m8)
+				-mrt_V6*m9-mrt_V7*m10-0.25*m14+0.125*(m17+m18);
+		nread = neighborList[n+17*Np];
+		dist[nread] = fq;
+
+		// q = 18
+		fq = mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2+0.1*(jz-jy)+0.025*(m8-m6)
+				-mrt_V6*m9-mrt_V7*m10-0.25*m14-0.125*(m17+m18);
+		nread = neighborList[n+16*Np];
+		dist[nread] = fq;
+		//........................................................................
+
+		// Instantiate mass transport distributions
+		// Stationary value - distribution 0
+		nAB = 1.0/(nA+nB);
+		Aq[n] = 0.3333333333333333*nA;
+		Bq[n] = 0.3333333333333333*nB;
+
+		//...............................................
+		// q = 0,2,4
+		// Cq = {1,0,0}, {0,1,0}, {0,0,1}
+		delta = beta*nA*nB*nAB*0.1111111111111111*nx;
+		if (!(nA*nB*nAB>0)) delta=0;
+        if (RecoloringOff==true && porosity !=1.0) delta=0;
+		a1 = nA*(0.1111111111111111*(1+4.5*ux))+delta;
+		b1 = nB*(0.1111111111111111*(1+4.5*ux))-delta;
+		a2 = nA*(0.1111111111111111*(1-4.5*ux))-delta;
+		b2 = nB*(0.1111111111111111*(1-4.5*ux))+delta;
+
+		// q = 1
+		//nread = neighborList[n+Np];
+		Aq[nr2] = a1;
+		Bq[nr2] = b1;
+		// q=2
+		//nread = neighborList[n];
+		Aq[nr1] = a2;
+		Bq[nr1] = b2;
+
+		//...............................................
+		// Cq = {0,1,0}
+		delta = beta*nA*nB*nAB*0.1111111111111111*ny;
+		if (!(nA*nB*nAB>0)) delta=0;
+        if (RecoloringOff==true && porosity !=1.0) delta=0;
+		a1 = nA*(0.1111111111111111*(1+4.5*uy))+delta;
+		b1 = nB*(0.1111111111111111*(1+4.5*uy))-delta;
+		a2 = nA*(0.1111111111111111*(1-4.5*uy))-delta;
+		b2 = nB*(0.1111111111111111*(1-4.5*uy))+delta;
+
+		// q = 3
+		//nread = neighborList[n+3*Np];
+		Aq[nr4] = a1;
+		Bq[nr4] = b1;
+		// q = 4
+		//nread = neighborList[n+2*Np];
+		Aq[nr3] = a2;
+		Bq[nr3] = b2;
+
+		//...............................................
+		// q = 4
+		// Cq = {0,0,1}
+		delta = beta*nA*nB*nAB*0.1111111111111111*nz;
+		if (!(nA*nB*nAB>0)) delta=0;
+        if (RecoloringOff==true && porosity !=1.0) delta=0;
+		a1 = nA*(0.1111111111111111*(1+4.5*uz))+delta;
+		b1 = nB*(0.1111111111111111*(1+4.5*uz))-delta;
+		a2 = nA*(0.1111111111111111*(1-4.5*uz))-delta;
+		b2 = nB*(0.1111111111111111*(1-4.5*uz))+delta;
+
+		// q = 5
+		//nread = neighborList[n+5*Np];
+		Aq[nr6] = a1;
+		Bq[nr6] = b1;
+		// q = 6
+		//nread = neighborList[n+4*Np];
+		Aq[nr5] = a2;
+		Bq[nr5] = b2;
+		//...............................................
+	}
+}
+
+//CP: capillary penalty
+// also turn off recoloring for grey nodes
+extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
+        double *Phi,double *Psi, double *GreySolidGrad, double *Poros,double *Perm,double *Velocity,double *Pressure,
+        double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
+		double Gx, double Gy, double Gz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
+
+	int ijk,nn,n;
+	double fq;
+	// conserved momemnts
+	double rho,jx,jy,jz;
+	//double vx,vy,vz,v_mag;
+    //double ux,uy,uz,u_mag;
+    double ux,uy,uz;
+	// non-conserved moments
+	double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
+	double m3,m5,m7;
+	double nA,nB; // number density
+	double a1,b1,a2,b2,nAB,delta;
+	double C,nx,ny,nz; //color gradient magnitude and direction
+	double phi,tau,rho0,rlx_setA,rlx_setB;
+
+    //double GeoFun=0.0;//geometric function from Guo's PRE 66, 036304 (2002)
+    double porosity;
+    double perm;//voxel permeability
+    //double c0, c1; //Guo's model parameters
+    double tau_eff;
+    double mu_eff;//kinematic viscosity
+    double nx_gs,ny_gs,nz_gs;//grey-solid color gradient
+    double nx_phase,ny_phase,nz_phase,C_phase;
+    double Fx,Fy,Fz;
+	double gp1,gp2,gp4,gp6,gp8,gp9,gp10,gp11,gp12,gp13,gp14,gp15,gp16,gp17,gp18;
+	double gp3,gp5,gp7;
+    double Fcpx,Fcpy,Fcpz;//capillary penalty force
+
+	const double mrt_V1=0.05263157894736842;
+	const double mrt_V2=0.012531328320802;
+	const double mrt_V3=0.04761904761904762;
+	const double mrt_V4=0.004594820384294068;
+	const double mrt_V5=0.01587301587301587;
+	const double mrt_V6=0.0555555555555555555555555;
+	const double mrt_V7=0.02777777777777778;
+	const double mrt_V8=0.08333333333333333;
+	const double mrt_V9=0.003341687552213868;
+	const double mrt_V10=0.003968253968253968;
+	const double mrt_V11=0.01388888888888889;
+	const double mrt_V12=0.04166666666666666;
+
+	for (n=start; n<finish; n++){
+
+		// read the component number densities
+		nA = Den[n];
+		nB = Den[Np + n];
+        porosity = Poros[n];
+        perm = Perm[n];
+        nx_gs = GreySolidGrad[n+0*Np];
+        ny_gs = GreySolidGrad[n+1*Np];
+        nz_gs = GreySolidGrad[n+2*Np];
+
+		// compute phase indicator field
+		phi=(nA-nB)/(nA+nB);
+
+		// local density
+		rho0=rhoA + 0.5*(1.0-phi)*(rhoB-rhoA);
+		// local relaxation time
+		tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
+		tau_eff=tauA_eff + 0.5*(1.0-phi)*(tauB_eff-tauA_eff);
+		rlx_setA = 1.f/tau;
+		rlx_setB = 8.f*(2.f-rlx_setA)/(8.f-rlx_setA);
+        mu_eff = (tau_eff-0.5)/3.0;//kinematic viscosity
+
+		// Get the 1D index based on regular data layout
+		ijk = Map[n];
+		//					COMPUTE THE COLOR GRADIENT
+		//........................................................................
+		//.................Read Phase Indicator Values............................
+		//........................................................................
+		nn = ijk-1;							// neighbor index (get convention)
+		m1 = Phi[nn];						// get neighbor for phi - 1
+        gp1 = Psi[nn];
+		//........................................................................
+		nn = ijk+1;							// neighbor index (get convention)
+		m2 = Phi[nn];						// get neighbor for phi - 2
+        gp2 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideY;							// neighbor index (get convention)
+		m3 = Phi[nn];					// get neighbor for phi - 3
+        gp3 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideY;							// neighbor index (get convention)
+		m4 = Phi[nn];					// get neighbor for phi - 4
+        gp4 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideZ;						// neighbor index (get convention)
+		m5 = Phi[nn];					// get neighbor for phi - 5
+        gp5 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideZ;						// neighbor index (get convention)
+		m6 = Phi[nn];					// get neighbor for phi - 6
+        gp6 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideY-1;						// neighbor index (get convention)
+		m7 = Phi[nn];					// get neighbor for phi - 7
+        gp7 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideY+1;						// neighbor index (get convention)
+		m8 = Phi[nn];					// get neighbor for phi - 8
+        gp8 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideY-1;						// neighbor index (get convention)
+		m9 = Phi[nn];					// get neighbor for phi - 9
+        gp9 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideY+1;						// neighbor index (get convention)
+		m10 = Phi[nn];					// get neighbor for phi - 10
+        gp10 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideZ-1;						// neighbor index (get convention)
+		m11 = Phi[nn];					// get neighbor for phi - 11
+        gp11 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideZ+1;						// neighbor index (get convention)
+		m12 = Phi[nn];					// get neighbor for phi - 12
+        gp12 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideZ-1;						// neighbor index (get convention)
+		m13 = Phi[nn];					// get neighbor for phi - 13
+        gp13 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideZ+1;						// neighbor index (get convention)
+		m14 = Phi[nn];					// get neighbor for phi - 14
+        gp14 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideZ-strideY;					// neighbor index (get convention)
+		m15 = Phi[nn];					// get neighbor for phi - 15
+        gp15 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideZ+strideY;					// neighbor index (get convention)
+		m16 = Phi[nn];					// get neighbor for phi - 16
+        gp16 = Psi[nn];
+		//........................................................................
+		nn = ijk+strideZ-strideY;					// neighbor index (get convention)
+		m17 = Phi[nn];					// get neighbor for phi - 17
+        gp17 = Psi[nn];
+		//........................................................................
+		nn = ijk-strideZ+strideY;					// neighbor index (get convention)
+		m18 = Phi[nn];					// get neighbor for phi - 18
+        gp18 = Psi[nn];
+		//............Compute the Color Gradient...................................
+		nx_phase = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+		ny_phase = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+		nz_phase = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+		C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
+
+        //correct the normal color gradient by considering the effect of grey solid
+        nx = nx_phase + (1.0-porosity)*nx_gs; 
+        ny = ny_phase + (1.0-porosity)*ny_gs; 
+        nz = nz_phase + (1.0-porosity)*nz_gs; 
+        if (C_phase==0.0){
+            nx = nx_phase; 
+            ny = ny_phase;
+            nz = nz_phase;
+        }
+
+		//...........Normalize the Color Gradient.................................
+		C = sqrt(nx*nx+ny*ny+nz*nz);
+		double ColorMag = C;
+		if (C==0.0) ColorMag=1.0;
+		nx = nx/ColorMag;
+		ny = ny/ColorMag;
+		nz = nz/ColorMag;		
+
+			//............Compute the Greyscale Potential Gradient.....................
+//			Fcpx = 0.0;
+//			Fcpy = 0.0;
+//			Fcpz = 0.0;
+//            if (porosity!=1.0){
+//                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
+//                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
+//                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+//                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+//                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+//                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+//                Fcpx *= alpha*W/sqrt(perm); 
+//                Fcpy *= alpha*W/sqrt(perm); 
+//                Fcpz *= alpha*W/sqrt(perm); 
+//                double Fcp_mag_temp = sqrt(Fcpx*Fcpx+Fcpy*Fcpy+Fcpz*Fcpz);
+//                double Fcp_mag = Fcp_mag_temp;
+//                if (Fcp_mag_temp==0.0) Fcp_mag=1.0;
+//                nx = Fcpx/Fcp_mag;
+//                ny = Fcpy/Fcp_mag;
+//                nz = Fcpz/Fcp_mag;
+//            }
+        Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+        Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+        Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+        //NOTE for open node (porosity=1.0),Fcp=0.0
+        Fcpx *= alpha*W*(1.0-porosity)/sqrt(perm); 
+        Fcpy *= alpha*W*(1.0-porosity)/sqrt(perm); 
+        Fcpz *= alpha*W*(1.0-porosity)/sqrt(perm); 
+
+
+		// q=0
+		fq = dist[n];
+		rho = fq;
+		m1  = -30.0*fq;
+		m2  = 12.0*fq;
+
+		// q=1
+		fq = dist[2*Np+n];
+		rho += fq;
+		m1 -= 11.0*fq;
+		m2 -= 4.0*fq;
+		jx = fq;
+		m4 = -4.0*fq;
+		m9 = 2.0*fq;
+		m10 = -4.0*fq;
+
+		// f2 = dist[10*Np+n];
+		fq = dist[1*Np+n];
+		rho += fq;
+		m1 -= 11.0*(fq);
+		m2 -= 4.0*(fq);
+		jx -= fq;
+		m4 += 4.0*(fq);
+		m9 += 2.0*(fq);
+		m10 -= 4.0*(fq);
+
+		// q=3
+		fq = dist[4*Np+n];
+		rho += fq;
+		m1 -= 11.0*fq;
+		m2 -= 4.0*fq;
+		jy = fq;
+		m6 = -4.0*fq;
+		m9 -= fq;
+		m10 += 2.0*fq;
+		m11 = fq;
+		m12 = -2.0*fq;
+
+		// q = 4
+		fq = dist[3*Np+n];
+		rho+= fq;
+		m1 -= 11.0*fq;
+		m2 -= 4.0*fq;
+		jy -= fq;
+		m6 += 4.0*fq;
+		m9 -= fq;
+		m10 += 2.0*fq;
+		m11 += fq;
+		m12 -= 2.0*fq;
+
+		// q=5
+		fq = dist[6*Np+n];
+		rho += fq;
+		m1 -= 11.0*fq;
+		m2 -= 4.0*fq;
+		jz = fq;
+		m8 = -4.0*fq;
+		m9 -= fq;
+		m10 += 2.0*fq;
+		m11 -= fq;
+		m12 += 2.0*fq;
+
+		// q = 6
+		fq = dist[5*Np+n];
+		rho+= fq;
+		m1 -= 11.0*fq;
+		m2 -= 4.0*fq;
+		jz -= fq;
+		m8 += 4.0*fq;
+		m9 -= fq;
+		m10 += 2.0*fq;
+		m11 -= fq;
+		m12 += 2.0*fq;
+
+		// q=7
+		fq = dist[8*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx += fq;
+		m4 += fq;
+		jy += fq;
+		m6 += fq;
+		m9  += fq;
+		m10 += fq;
+		m11 += fq;
+		m12 += fq;
+		m13 = fq;
+		m16 = fq;
+		m17 = -fq;
+
+		// q = 8
+		fq = dist[7*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx -= fq;
+		m4 -= fq;
+		jy -= fq;
+		m6 -= fq;
+		m9 += fq;
+		m10 += fq;
+		m11 += fq;
+		m12 += fq;
+		m13 += fq;
+		m16 -= fq;
+		m17 += fq;
+
+		// q=9
+		fq = dist[10*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx += fq;
+		m4 += fq;
+		jy -= fq;
+		m6 -= fq;
+		m9 += fq;
+		m10 += fq;
+		m11 += fq;
+		m12 += fq;
+		m13 -= fq;
+		m16 += fq;
+		m17 += fq;
+
+		// q = 10
+		fq = dist[9*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx -= fq;
+		m4 -= fq;
+		jy += fq;
+		m6 += fq;
+		m9 += fq;
+		m10 += fq;
+		m11 += fq;
+		m12 += fq;
+		m13 -= fq;
+		m16 -= fq;
+		m17 -= fq;
+
+		// q=11
+		fq = dist[12*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx += fq;
+		m4 += fq;
+		jz += fq;
+		m8 += fq;
+		m9 += fq;
+		m10 += fq;
+		m11 -= fq;
+		m12 -= fq;
+		m15 = fq;
+		m16 -= fq;
+		m18 = fq;
+
+		// q=12
+		fq = dist[11*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx -= fq;
+		m4 -= fq;
+		jz -= fq;
+		m8 -= fq;
+		m9 += fq;
+		m10 += fq;
+		m11 -= fq;
+		m12 -= fq;
+		m15 += fq;
+		m16 += fq;
+		m18 -= fq;
+
+		// q=13
+		fq = dist[14*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx += fq;
+		m4 += fq;
+		jz -= fq;
+		m8 -= fq;
+		m9 += fq;
+		m10 += fq;
+		m11 -= fq;
+		m12 -= fq;
+		m15 -= fq;
+		m16 -= fq;
+		m18 -= fq;
+
+		// q=14
+		fq = dist[13*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jx -= fq;
+		m4 -= fq;
+		jz += fq;
+		m8 += fq;
+		m9 += fq;
+		m10 += fq;
+		m11 -= fq;
+		m12 -= fq;
+		m15 -= fq;
+		m16 += fq;
+		m18 += fq;
+
+		// q=15
+		fq = dist[16*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jy += fq;
+		m6 += fq;
+		jz += fq;
+		m8 += fq;
+		m9 -= 2.0*fq;
+		m10 -= 2.0*fq;
+		m14 = fq;
+		m17 += fq;
+		m18 -= fq;
+
+		// q=16
+		fq = dist[15*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jy -= fq;
+		m6 -= fq;
+		jz -= fq;
+		m8 -= fq;
+		m9 -= 2.0*fq;
+		m10 -= 2.0*fq;
+		m14 += fq;
+		m17 -= fq;
+		m18 += fq;
+
+		// q=17
+		fq = dist[18*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jy += fq;
+		m6 += fq;
+		jz -= fq;
+		m8 -= fq;
+		m9 -= 2.0*fq;
+		m10 -= 2.0*fq;
+		m14 -= fq;
+		m17 += fq;
+		m18 += fq;
+
+		// q=18
+		fq = dist[17*Np+n];
+		rho += fq;
+		m1 += 8.0*fq;
+		m2 += fq;
+		jy -= fq;
+		m6 -= fq;
+		jz += fq;
+		m8 += fq;
+		m9 -= 2.0*fq;
+		m10 -= 2.0*fq;
+		m14 -= fq;
+		m17 -= fq;
+		m18 -= fq;
+
+        // Compute greyscale related parameters
+        ux = (jx/rho0+0.5*porosity*Gx+0.5*Fcpx/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+        uy = (jy/rho0+0.5*porosity*Gy+0.5*Fcpy/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+        uz = (jz/rho0+0.5*porosity*Gz+0.5*Fcpz/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+        if (porosity==1.0){//i.e. open nodes
+            ux = (jx/rho0+0.5*porosity*Gx);
+            uy = (jy/rho0+0.5*porosity*Gy);
+            uz = (jz/rho0+0.5*porosity*Gz);
+        }
+
+        //Update the total force to include linear (Darcy) and nonlinear (Forchheimer) drags due to the porous medium
+        Fx = rho0*(-porosity*mu_eff/perm*ux + porosity*Gx)+Fcpx;
+        Fy = rho0*(-porosity*mu_eff/perm*uy + porosity*Gy)+Fcpy;
+        Fz = rho0*(-porosity*mu_eff/perm*uz + porosity*Gz)+Fcpz;
+        if (porosity==1.0){
+            Fx=rho0*(porosity*Gx);
+            Fy=rho0*(porosity*Gy);
+            Fz=rho0*(porosity*Gz);
+        }
+
+		// write the velocity 
+		Velocity[n] = ux;
+		Velocity[Np+n] = uy;
+		Velocity[2*Np+n] = uz;
+        //Pressure[n] = rho/3.f/porosity;
+        Pressure[n] = rho/3.f;
+
+		//........................................................................
+		//..............carry out relaxation process..............................
+		//..........Toelke, Fruediger et. al. 2006................................
+		if (C == 0.0)	nx = ny = nz = 0.0;
+		m1 = m1 + rlx_setA*((19*(ux*ux+uy*uy+uz*uz)*rho0/porosity - 11*rho) -19*alpha*C - m1);
+		m2 = m2 + rlx_setA*((3*rho - 5.5*(ux*ux+uy*uy+uz*uz)*rho0/porosity)- m2);
+        jx = jx + Fx;
+		m4 = m4 + rlx_setB*((-0.6666666666666666*ux*rho0)- m4)
+                + (1-0.5*rlx_setB)*(-0.6666666666666666*Fx);
+        jy = jy + Fy;
+		m6 = m6 + rlx_setB*((-0.6666666666666666*uy*rho0)- m6)
+                + (1-0.5*rlx_setB)*(-0.6666666666666666*Fy);
+        jz = jz + Fz;
+		m8 = m8 + rlx_setB*((-0.6666666666666666*uz*rho0)- m8)
+                + (1-0.5*rlx_setB)*(-0.6666666666666666*Fz);
+		m9 = m9 + rlx_setA*(((2*ux*ux-uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(2*nx*nx-ny*ny-nz*nz) - m9);
+		m10 = m10 + rlx_setA*( - m10);
+        //m10 = m10 + rlx_setA*(-0.5*rho0*((2*ux*ux-uy*uy-uz*uz)/porosity)- m10);
+		m11 = m11 + rlx_setA*(((uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(ny*ny-nz*nz)- m11);
+		m12 = m12 + rlx_setA*( - m12);
+        //m12 = m12 + rlx_setA*(-0.5*(rho0*(uy*uy-uz*uz)/porosity)- m12);
+		m13 = m13 + rlx_setA*( (ux*uy*rho0/porosity) + 0.5*alpha*C*nx*ny - m13);
+		m14 = m14 + rlx_setA*( (uy*uz*rho0/porosity) + 0.5*alpha*C*ny*nz - m14);
+		m15 = m15 + rlx_setA*( (ux*uz*rho0/porosity) + 0.5*alpha*C*nx*nz - m15);
+		m16 = m16 + rlx_setB*( - m16);
+		m17 = m17 + rlx_setB*( - m17);
+		m18 = m18 + rlx_setB*( - m18);
+
+		//.................inverse transformation......................................................
+		// q=0
+		fq = mrt_V1*rho-mrt_V2*m1+mrt_V3*m2;
+		dist[n] = fq;
+
+		// q = 1
+		fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jx-m4)+mrt_V6*(m9-m10);
+		dist[1*Np+n] = fq;
+
+		// q=2
+		fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m4-jx)+mrt_V6*(m9-m10);
+		dist[2*Np+n] = fq;
+
+		// q = 3
+		fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jy-m6)+mrt_V7*(m10-m9)+mrt_V8*(m11-m12);
+		dist[3*Np+n] = fq;
+
+		// q = 4
+		fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m6-jy)+mrt_V7*(m10-m9)+mrt_V8*(m11-m12);
+		dist[4*Np+n] = fq;
+
+		// q = 5
+		fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jz-m8)+mrt_V7*(m10-m9)+mrt_V8*(m12-m11);
+		dist[5*Np+n] = fq;
+
+		// q = 6
+		fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m8-jz)+mrt_V7*(m10-m9)+mrt_V8*(m12-m11);
+		dist[6*Np+n] = fq;
+
+		// q = 7
+		fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jx+jy)+0.025*(m4+m6)+
+				mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12+0.25*m13+0.125*(m16-m17);
+		dist[7*Np+n] = fq;
+
+
+		// q = 8
+		fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2-0.1*(jx+jy)-0.025*(m4+m6) +mrt_V7*m9+mrt_V11*m10+mrt_V8*m11
+				+mrt_V12*m12+0.25*m13+0.125*(m17-m16);
+		dist[8*Np+n] = fq;
+
+		// q = 9
+		fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jx-jy)+0.025*(m4-m6)+
+				mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12-0.25*m13+0.125*(m16+m17);
+		dist[9*Np+n] = fq;
+
+		// q = 10
+		fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jy-jx)+0.025*(m6-m4)+
+				mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12-0.25*m13-0.125*(m16+m17);
+		dist[10*Np+n] = fq;
+
+
+		// q = 11
+		fq = mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2+0.1*(jx+jz)+0.025*(m4+m8)
+				+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+				-mrt_V12*m12+0.25*m15+0.125*(m18-m16);
+		dist[11*Np+n] = fq;
+
+		// q = 12
+		fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2-0.1*(jx+jz)-0.025*(m4+m8)+
+				mrt_V7*m9+mrt_V11*m10-mrt_V8*m11-mrt_V12*m12+0.25*m15+0.125*(m16-m18);
+		dist[12*Np+n] = fq;
+
+		// q = 13
+		fq = mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2+0.1*(jx-jz)+0.025*(m4-m8)
+				+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+				-mrt_V12*m12-0.25*m15-0.125*(m16+m18);
+		dist[13*Np+n] = fq;
+
+		// q= 14
+		fq = mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2+0.1*(jz-jx)+0.025*(m8-m4)
+				+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+				-mrt_V12*m12-0.25*m15+0.125*(m16+m18);
+
+		dist[14*Np+n] = fq;
+
+		// q = 15
+		fq = mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2+0.1*(jy+jz)+0.025*(m6+m8)
+				-mrt_V6*m9-mrt_V7*m10+0.25*m14+0.125*(m17-m18);
+		dist[15*Np+n] = fq;
+
+		// q = 16
+		fq =  mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2-0.1*(jy+jz)-0.025*(m6+m8)
+				-mrt_V6*m9-mrt_V7*m10+0.25*m14+0.125*(m18-m17);
+		dist[16*Np+n] = fq;
+
+
+		// q = 17
+		fq = mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2+0.1*(jy-jz)+0.025*(m6-m8)
+				-mrt_V6*m9-mrt_V7*m10-0.25*m14+0.125*(m17+m18);
+		dist[17*Np+n] = fq;
+
+		// q = 18
+		fq = mrt_V1*rho+mrt_V9*m1
+				+mrt_V10*m2+0.1*(jz-jy)+0.025*(m8-m6)
+				-mrt_V6*m9-mrt_V7*m10-0.25*m14-0.125*(m17+m18);
+		dist[18*Np+n] = fq;
+		//........................................................................
+
+		// Instantiate mass transport distributions
+		// Stationary value - distribution 0
+		nAB = 1.0/(nA+nB);
+		Aq[n] = 0.3333333333333333*nA;
+		Bq[n] = 0.3333333333333333*nB;
+
+		//...............................................
+		// q = 0,2,4
+		// Cq = {1,0,0}, {0,1,0}, {0,0,1}
+		delta = beta*nA*nB*nAB*0.1111111111111111*nx;
+		if (!(nA*nB*nAB>0)) delta=0;
+        if (RecoloringOff==true && porosity !=1.0) delta=0;
+		a1 = nA*(0.1111111111111111*(1+4.5*ux))+delta;
+		b1 = nB*(0.1111111111111111*(1+4.5*ux))-delta;
+		a2 = nA*(0.1111111111111111*(1-4.5*ux))-delta;
+		b2 = nB*(0.1111111111111111*(1-4.5*ux))+delta;
+
+		Aq[1*Np+n] = a1;
+		Bq[1*Np+n] = b1;
+		Aq[2*Np+n] = a2;
+		Bq[2*Np+n] = b2;
+
+		//...............................................
+		// q = 2
+		// Cq = {0,1,0}
+		delta = beta*nA*nB*nAB*0.1111111111111111*ny;
+		if (!(nA*nB*nAB>0)) delta=0;
+        if (RecoloringOff==true && porosity !=1.0) delta=0;
+		a1 = nA*(0.1111111111111111*(1+4.5*uy))+delta;
+		b1 = nB*(0.1111111111111111*(1+4.5*uy))-delta;
+		a2 = nA*(0.1111111111111111*(1-4.5*uy))-delta;
+		b2 = nB*(0.1111111111111111*(1-4.5*uy))+delta;
+
+		Aq[3*Np+n] = a1;
+		Bq[3*Np+n] = b1;
+		Aq[4*Np+n] = a2;
+		Bq[4*Np+n] = b2;
+		//...............................................
+		// q = 4
+		// Cq = {0,0,1}
+		delta = beta*nA*nB*nAB*0.1111111111111111*nz;
+		if (!(nA*nB*nAB>0)) delta=0;
+        if (RecoloringOff==true && porosity !=1.0) delta=0;
+		a1 = nA*(0.1111111111111111*(1+4.5*uz))+delta;
+		b1 = nB*(0.1111111111111111*(1+4.5*uz))-delta;
+		a2 = nA*(0.1111111111111111*(1-4.5*uz))-delta;
+		b2 = nB*(0.1111111111111111*(1-4.5*uz))+delta;
+
+		Aq[5*Np+n] = a1;
+		Bq[5*Np+n] = b1;
+		Aq[6*Np+n] = a2;
+		Bq[6*Np+n] = b2;
+		//...............................................
+	}
+}
+
+
 extern "C" void ScaLBL_PhaseField_InitFromRestart(double *Den, double *Aq, double *Bq, int start, int finish, int Np){
 	int idx;
 	double nA,nB;
diff --git a/cuda/GreyscaleColor.cu b/cuda/GreyscaleColor.cu
index 089d8fdc..de4b9e0d 100644
--- a/cuda/GreyscaleColor.cu
+++ b/cuda/GreyscaleColor.cu
@@ -3021,30 +3021,33 @@ __global__ void dvc_ScaLBL_PhaseField_InitFromRestart(double *Den, double *Aq, d
 	}
 }
 
-__global__  void dvc_ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
-                                                      int start, int finish, int Np){
-	int idx,n;
-    double phi,psi;
-    double cap_penalty;
-    double porosity,perm;
-
-	int S = Np/NBLOCKS/NTHREADS + 1;
-	for (int s=0; s<S; s++){
-		//........Get 1-D index for this thread....................
-		n =  S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x + start;
-		if (n<finish) {
-			idx = Map[n];
-			phi = Phi[idx];
-            porosity = Poro[n];
-            perm = Perm[n];    
-            cap_penalty = 1.0;
-
-            if (porosity!=1.0) cap_penalty = alpha*W/sqrt(perm);
-            psi = cap_penalty*phi;
-            Psi[idx] = psi;
-		}
-	}
-}
+//NOTE: so far it seems that we don't need this greyscale potental update;
+//      if we compute a grey-potential first, and take its gradient to work out the capillary penalty force, it is highly unstable;
+//      this is because the grey-potential is simply a scaling of the normal phase field, but such scaling create some artificial gradient at the open-grey interface
+//__global__  void dvc_ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
+//                                                      int start, int finish, int Np){
+//	int idx,n;
+//    double phi,psi;
+//    double cap_penalty;
+//    double porosity,perm;
+//
+//	int S = Np/NBLOCKS/NTHREADS + 1;
+//	for (int s=0; s<S; s++){
+//		//........Get 1-D index for this thread....................
+//		n =  S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x + start;
+//		if (n<finish) {
+//			idx = Map[n];
+//			phi = Phi[idx];
+//            porosity = Poro[n];
+//            perm = Perm[n];    
+//            cap_penalty = 1.0;
+//
+//            if (porosity!=1.0) cap_penalty = alpha*W/sqrt(perm);
+//            psi = cap_penalty*phi;
+//            Psi[idx] = psi;
+//		}
+//	}
+//}
 
 
 ////Model-2&3
@@ -4597,16 +4600,16 @@ extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *d_neighborList, int *M
 	}
 }
 
-extern "C" void ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
-		int start, int finish, int Np){
-
-	dvc_ScaLBL_Update_GreyscalePotential<<<NBLOCKS,NTHREADS >>>(Map, Phi, Psi, Poro, Perm, alpha, W, start, finish, Np);
-
-	cudaError_t err = cudaGetLastError();
-	if (cudaSuccess != err){
-		printf("CUDA error in ScaLBL_Update_GreyscalePotential: %s \n",cudaGetErrorString(err));
-	}
-}
+//extern "C" void ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
+//		int start, int finish, int Np){
+//
+//	dvc_ScaLBL_Update_GreyscalePotential<<<NBLOCKS,NTHREADS >>>(Map, Phi, Psi, Poro, Perm, alpha, W, start, finish, Np);
+//
+//	cudaError_t err = cudaGetLastError();
+//	if (cudaSuccess != err){
+//		printf("CUDA error in ScaLBL_Update_GreyscalePotential: %s \n",cudaGetErrorString(err));
+//	}
+//}
 
 ////Model-2&3
 //extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor(int *Map, double *dist, double *Aq, double *Bq, double *Den, 

From 0f94439a6bc535302af91f1a9ab37cbd5732b491 Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Wed, 24 Mar 2021 21:02:34 -0400
Subject: [PATCH 11/19] 1.revised relations of surface tension and
 W;2.reintroduce theta for better modele tuning;3.put chemical potential in
 debug output

---
 cpu/FreeLee.cpp                  | 43 ++++++++++++++++++++++----------
 models/FreeLeeModel.cpp          | 19 +++++++++++---
 tests/lbpm_freelee_simulator.cpp |  2 +-
 3 files changed, 46 insertions(+), 18 deletions(-)

diff --git a/cpu/FreeLee.cpp b/cpu/FreeLee.cpp
index 16a9b3bd..7d4dbb1d 100644
--- a/cpu/FreeLee.cpp
+++ b/cpu/FreeLee.cpp
@@ -83,6 +83,7 @@ extern "C" void ScaLBL_FreeLeeModel_PhaseField_Init(int *Map, double *Phi, doubl
     double theta;//anti-diffusion term
     double cs2_inv = 4.5;//inverse of speed of sound for D3Q7
     double M = 1.0/cs2_inv*(tauM-0.5);//diffusivity (or mobility)
+    double factor = 1.0;
 
 	for (idx=start; idx<finish; idx++){
 
@@ -103,7 +104,7 @@ extern "C" void ScaLBL_FreeLeeModel_PhaseField_Init(int *Map, double *Phi, doubl
 		ny = ny/ColorMag_temp;
 		nz = nz/ColorMag_temp;		
 
-        theta = M*cs2_inv*(1-4.0*phi*phi)/W;
+        theta = M*cs2_inv*(1-factor*phi*phi)/W;
         theta = 0; // try more diffusive initial condition
         
 		hq[0*Np+idx]=0.3333333333333333*(phi);
@@ -224,12 +225,14 @@ extern "C" void ScaLBL_D3Q7_AAodd_FreeLee_PhaseField(int *neighborList, int *Map
 	double phi;
     double M = 2.0/9.0*(tauM-0.5);//diffusivity (or mobility) for the phase field D3Q7
     double factor = 1.0;
+    double theta;
 
 	for (int n=start; n<finish; n++){
 
 		/* load phase indicator field */
 		idx = Map[n];
 		phi = Phi[idx];
+        theta = 4.5*M*2.0*(1-phi*phi)/W;
 
 		/* velocity */
 		ux = Vel[0*Np+n];
@@ -274,12 +277,18 @@ extern "C" void ScaLBL_D3Q7_AAodd_FreeLee_PhaseField(int *neighborList, int *Map
 
         //-------------------------------- BGK collison for phase field ---------------------------------//
 		h0 -= (h0 - 0.3333333333333333*phi)/tauM;
-		h1 -= (h1 - phi*(0.1111111111111111 + 0.5*ux) - (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
-		h2 -= (h2 - phi*(0.1111111111111111 - 0.5*ux) + (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
-		h3 -= (h3 - phi*(0.1111111111111111 + 0.5*uy) - (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
-		h4 -= (h4 - phi*(0.1111111111111111 - 0.5*uy) + (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
-		h5 -= (h5 - phi*(0.1111111111111111 + 0.5*uz) - (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
-		h6 -= (h6 - phi*(0.1111111111111111 - 0.5*uz) + (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+//		h1 -= (h1 - phi*(0.1111111111111111 + 0.5*ux) - (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
+//		h2 -= (h2 - phi*(0.1111111111111111 - 0.5*ux) + (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
+//		h3 -= (h3 - phi*(0.1111111111111111 + 0.5*uy) - (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
+//		h4 -= (h4 - phi*(0.1111111111111111 - 0.5*uy) + (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
+//		h5 -= (h5 - phi*(0.1111111111111111 + 0.5*uz) - (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+//		h6 -= (h6 - phi*(0.1111111111111111 - 0.5*uz) + (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+		h1 -= (h1 - 0.1111111111111111*nx*theta - phi*(0.1111111111111111 + 0.5*ux))/tauM;
+		h2 -= (h2 + 0.1111111111111111*nx*theta - phi*(0.1111111111111111 - 0.5*ux))/tauM;
+		h3 -= (h3 - 0.1111111111111111*ny*theta - phi*(0.1111111111111111 + 0.5*uy))/tauM;
+		h4 -= (h4 + 0.1111111111111111*ny*theta - phi*(0.1111111111111111 - 0.5*uy))/tauM;
+		h5 -= (h5 - 0.1111111111111111*nz*theta - phi*(0.1111111111111111 + 0.5*uz))/tauM;
+		h6 -= (h6 + 0.1111111111111111*nz*theta - phi*(0.1111111111111111 - 0.5*uz))/tauM; 
 		//........................................................................
 		
 		/*Update the distributions */
@@ -308,12 +317,14 @@ extern "C" void ScaLBL_D3Q7_AAeven_FreeLee_PhaseField( int *Map, double *hq, dou
 	double phi;
     double M = 2.0/9.0*(tauM-0.5);//diffusivity (or mobility) for the phase field D3Q7
     double factor = 1.0;
+    double theta;
 
 	for (int n=start; n<finish; n++){
 
 		/* load phase indicator field */
 		idx = Map[n];
 		phi = Phi[idx];
+        theta = 4.5*M*2.0*(1-phi*phi)/W;
 
 		/* velocity */
 		ux = Vel[0*Np+n];
@@ -342,12 +353,18 @@ extern "C" void ScaLBL_D3Q7_AAeven_FreeLee_PhaseField( int *Map, double *hq, dou
 
 		//-------------------------------- BGK collison for phase field ---------------------------------//
 		h0 -= (h0 - 0.3333333333333333*phi)/tauM;
-		h1 -= (h1 - phi*(0.1111111111111111 + 0.5*ux) - (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
-		h2 -= (h2 - phi*(0.1111111111111111 - 0.5*ux) + (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
-		h3 -= (h3 - phi*(0.1111111111111111 + 0.5*uy) - (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
-		h4 -= (h4 - phi*(0.1111111111111111 - 0.5*uy) + (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
-		h5 -= (h5 - phi*(0.1111111111111111 + 0.5*uz) - (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
-		h6 -= (h6 - phi*(0.1111111111111111 - 0.5*uz) + (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+//		h1 -= (h1 - phi*(0.1111111111111111 + 0.5*ux) - (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
+//		h2 -= (h2 - phi*(0.1111111111111111 - 0.5*ux) + (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
+//		h3 -= (h3 - phi*(0.1111111111111111 + 0.5*uy) - (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
+//		h4 -= (h4 - phi*(0.1111111111111111 - 0.5*uy) + (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
+//		h5 -= (h5 - phi*(0.1111111111111111 + 0.5*uz) - (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+//		h6 -= (h6 - phi*(0.1111111111111111 - 0.5*uz) + (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+		h1 -= (h1 - 0.1111111111111111*nx*theta - phi*(0.1111111111111111 + 0.5*ux))/tauM;
+		h2 -= (h2 + 0.1111111111111111*nx*theta - phi*(0.1111111111111111 - 0.5*ux))/tauM;
+		h3 -= (h3 - 0.1111111111111111*ny*theta - phi*(0.1111111111111111 + 0.5*uy))/tauM;
+		h4 -= (h4 + 0.1111111111111111*ny*theta - phi*(0.1111111111111111 - 0.5*uy))/tauM;
+		h5 -= (h5 - 0.1111111111111111*nz*theta - phi*(0.1111111111111111 + 0.5*uz))/tauM;
+		h6 -= (h6 + 0.1111111111111111*nz*theta - phi*(0.1111111111111111 - 0.5*uz))/tauM; 
 		//........................................................................
 
 		/*Update the distributions */
diff --git a/models/FreeLeeModel.cpp b/models/FreeLeeModel.cpp
index 428db40f..ce4e2b92 100644
--- a/models/FreeLeeModel.cpp
+++ b/models/FreeLeeModel.cpp
@@ -77,8 +77,10 @@ void ScaLBL_FreeLeeModel::ReadParams(string filename){
 	Fx = Fy = Fz = 0.0;
 	gamma=1e-3;//surface tension
 	W=5.0;//interfacial thickness
-    beta = 12.0*gamma/W;
-    kappa = 3.0*gamma*W/2.0;//beta and kappa are related to surface tension \gamma
+    //beta = 12.0*gamma/W;
+    //kappa = 3.0*gamma*W/2.0;//beta and kappa are related to surface tension \gamma
+    beta = 0.75*gamma/W;
+    kappa = 0.375*gamma*W;//beta and kappa are related to surface tension \gamma
 	Restart=false;
 	din=dout=1.0;
 	flux=0.0;
@@ -136,8 +138,10 @@ void ScaLBL_FreeLeeModel::ReadParams(string filename){
 	outletA=0.f;
 	outletB=1.f;
     //update secondary parameters
-    beta = 12.0*gamma/W;
-    kappa = 3.0*gamma*W/2.0;//beta and kappa are related to surface tension \gamma
+    //beta = 12.0*gamma/W;
+    //kappa = 3.0*gamma*W/2.0;//beta and kappa are related to surface tension \gamma
+    beta = 0.75*gamma/W;
+    kappa = 0.375*gamma*W;//beta and kappa are related to surface tension \gamma
 	//if (BoundaryCondition==4) flux *= rhoA; // mass flux must adjust for density (see formulation for details)
 
 	BoundaryCondition = 0;
@@ -1055,6 +1059,13 @@ void ScaLBL_FreeLeeModel::WriteDebug_TwoFluid(){
 	fwrite(PhaseField.data(),8,N,PFILE);
 	fclose(PFILE);
 
+	ScaLBL_Comm->RegularLayout(Map,mu_phi,PhaseField);
+	FILE *CHEMFILE;
+	sprintf(LocalRankFilename,"ChemPotential.%05i.raw",rank);
+	CHEMFILE = fopen(LocalRankFilename,"wb");
+	fwrite(PhaseField.data(),8,N,CHEMFILE);
+	fclose(CHEMFILE);
+
 	ScaLBL_Comm->RegularLayout(Map,&Velocity[0],PhaseField);
 	FILE *VELX_FILE;
 	sprintf(LocalRankFilename,"Velocity_X.%05i.raw",rank);
diff --git a/tests/lbpm_freelee_simulator.cpp b/tests/lbpm_freelee_simulator.cpp
index 0508c43a..69fd58ad 100644
--- a/tests/lbpm_freelee_simulator.cpp
+++ b/tests/lbpm_freelee_simulator.cpp
@@ -72,7 +72,7 @@ int main( int argc, char **argv )
         	Analysis.WriteVis(LeeModel,LeeModel.db, timestep);
         	timestep += visualization_time;
         }
-        //LeeModel.WriteDebug_TwoFluid();
+        LeeModel.WriteDebug_TwoFluid();
     	if (rank==0) printf("********************************************************\n");
     	if (rank==0) printf("Lattice update rate (per core)= %f MLUPS \n", MLUPS);
     	MLUPS *= nprocs;

From d1e4a84b257593052d223d94e30a8cd06ae58f3c Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Thu, 25 Mar 2021 01:52:45 -0400
Subject: [PATCH 12/19] try the old approach for phase field collision; to be
 built and verified

---
 common/ScaLBL.h         |   17 +-
 cpu/FreeLee.cpp         | 1221 ++++++++++++++++++++++++++++++++++++++-
 models/FreeLeeModel.cpp |   65 ++-
 3 files changed, 1271 insertions(+), 32 deletions(-)

diff --git a/common/ScaLBL.h b/common/ScaLBL.h
index 3bc752dc..f6738ac2 100644
--- a/common/ScaLBL.h
+++ b/common/ScaLBL.h
@@ -193,11 +193,12 @@ extern "C" void ScaLBL_D3Q19_FreeLeeModel_SingleFluid_Init(double *gqbar, double
 extern "C" void ScaLBL_FreeLeeModel_PhaseField_Init(int *Map, double *Phi, double *Den, double *hq, double *ColorGrad, 
                                                     double rhonA, double rhoB, double tauM, double W, int start, int finish, int Np);
 
-//extern "C" void ScaLBL_D3Q7_AAodd_FreeLeeModel_PhaseField(int *neighborList, int *Map, double *hq, double *Den, double *Phi, 
- //                                                         double rhoA, double rhoB, int start, int finish, int Np);
+extern "C" void ScaLBL_D3Q7_AAodd_FreeLeeModel_PhaseField(int *neighborList, int *Map, double *hq, double *Den, double *Phi, 
+                                                         double rhoA, double rhoB, int start, int finish, int Np);
+
+extern "C" void ScaLBL_D3Q7_AAeven_FreeLeeModel_PhaseField(int *Map, double *hq, double *Den, double *Phi, 
+			                                               double rhoA, double rhoB, int start, int finish, int Np);
 
-//extern "C" void ScaLBL_D3Q7_AAeven_FreeLeeModel_PhaseField(int *Map, double *hq, double *Den, double *Phi, 
-//			                                               double rhoA, double rhoB, int start, int finish, int Np);
 extern "C" void ScaLBL_D3Q7_AAodd_FreeLee_PhaseField(int *neighborList, int *Map, double *hq, double *Den, double *Phi, double *ColorGrad, double *Vel,
                                                           double rhoA, double rhoB, double tauM, double W, int start, int finish, int Np);
 
@@ -214,6 +215,14 @@ extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel(int *Map, double *dist, double
                                                 double rhoA, double rhoB, double tauA, double tauB, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
                                                 int strideY, int strideZ, int start, int finish, int Np);
 
+extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(int *neighborList, int *Map, double *dist, double *hq, double *Den,	double *Phi, double *mu_phi, double *Vel, double *Pressure, double *ColorGrad,
+                                                double rhoA, double rhoB, double tauA, double tauB, double tauM, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
+                                                int strideY, int strideZ, int start, int finish, int Np);
+
+extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(int *Map, double *dist, double *hq, double *Den,	double *Phi, double *mu_phi, double *Vel, double *Pressure, double *ColorGrad,
+                                                double rhoA, double rhoB, double tauA, double tauB, double tauM, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
+                                                int strideY, int strideZ, int start, int finish, int Np);
+
 extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_SingleFluid_BGK(int *neighborList, double *dist, double *Vel, double *Pressure,  
                                                                 double tau, double rho0, double Fx, double Fy, double Fz, int start, int finish, int Np);
 
diff --git a/cpu/FreeLee.cpp b/cpu/FreeLee.cpp
index 7d4dbb1d..0358af4a 100644
--- a/cpu/FreeLee.cpp
+++ b/cpu/FreeLee.cpp
@@ -104,8 +104,9 @@ extern "C" void ScaLBL_FreeLeeModel_PhaseField_Init(int *Map, double *Phi, doubl
 		ny = ny/ColorMag_temp;
 		nz = nz/ColorMag_temp;		
 
-        theta = M*cs2_inv*(1-factor*phi*phi)/W;
-        theta = 0; // try more diffusive initial condition
+        //theta = M*cs2_inv*(1-factor*phi*phi)/W;
+        theta = 4.5*M*2.0*(1-phi*phi)/W;
+        //theta = 0; // try more diffusive initial condition
         
 		hq[0*Np+idx]=0.3333333333333333*(phi);
 		hq[1*Np+idx]=0.1111111111111111*(phi+theta*nx);
@@ -1497,6 +1498,1222 @@ extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel(int *Map, double *dist, double
 	}
 }
 
+extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(int *neighborList, int *Map, double *dist, double *hq, double *Den,	double *Phi, double *mu_phi, double *Vel, double *Pressure, double *ColorGrad, 
+                                                double rhoA, double rhoB, double tauA, double tauB, double tauM, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
+                                                int strideY, int strideZ, int start, int finish, int Np){
+	
+	int n,nn,nn2x,ijk;
+	int nr1,nr2,nr3,nr4,nr5,nr6,nr7,nr8,nr9,nr10,nr11,nr12,nr13,nr14,nr15,nr16,nr17,nr18;
+    double ux,uy,uz;//fluid velocity 
+    double p;//pressure
+    double chem;//chemical potential
+    double phi; //phase field
+    double rho0;//fluid density
+	// distribution functions
+	double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
+	double m0,m3,m5,m7;
+	double mm1,mm2,mm4,mm6,mm8,mm9,mm10,mm11,mm12,mm13,mm14,mm15,mm16,mm17,mm18;
+	double mm3,mm5,mm7;
+    double feq0,feq1,feq2,feq3,feq4,feq5,feq6,feq7,feq8,feq9,feq10,feq11,feq12,feq13,feq14,feq15,feq16,feq17,feq18;
+    double nx,ny,nz;//normal color gradient
+    double mgx,mgy,mgz;//mixed gradient reaching secondary neighbor
+
+	//double f0,f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18;
+    double h0,h1,h2,h3,h4,h5,h6;//distributions for LB phase field
+	double tau;//position dependent LB relaxation time for fluid
+    double C,theta;
+    double M = 2.0/9.0*(tauM-0.5);//diffusivity (or mobility) for the phase field D3Q7
+
+	for (int n=start; n<finish; n++){
+
+		rho0 = Den[n];//load density
+
+		// Get the 1D index based on regular data layout
+		ijk = Map[n];
+        phi = Phi[ijk];// load phase field
+
+		// local relaxation time
+		tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
+
+		//					COMPUTE THE COLOR GRADIENT
+		//........................................................................
+		//.................Read Phase Indicator Values............................
+		//........................................................................
+		nn = ijk-1;							// neighbor index (get convention)
+		m1 = Phi[nn];						// get neighbor for phi - 1
+		//........................................................................
+		nn = ijk+1;							// neighbor index (get convention)
+		m2 = Phi[nn];						// get neighbor for phi - 2
+		//........................................................................
+		nn = ijk-strideY;							// neighbor index (get convention)
+		m3 = Phi[nn];					// get neighbor for phi - 3
+		//........................................................................
+		nn = ijk+strideY;							// neighbor index (get convention)
+		m4 = Phi[nn];					// get neighbor for phi - 4
+		//........................................................................
+		nn = ijk-strideZ;						// neighbor index (get convention)
+		m5 = Phi[nn];					// get neighbor for phi - 5
+		//........................................................................
+		nn = ijk+strideZ;						// neighbor index (get convention)
+		m6 = Phi[nn];					// get neighbor for phi - 6
+		//........................................................................
+		nn = ijk-strideY-1;						// neighbor index (get convention)
+		m7 = Phi[nn];					// get neighbor for phi - 7
+		//........................................................................
+		nn = ijk+strideY+1;						// neighbor index (get convention)
+		m8 = Phi[nn];					// get neighbor for phi - 8
+		//........................................................................
+		nn = ijk+strideY-1;						// neighbor index (get convention)
+		m9 = Phi[nn];					// get neighbor for phi - 9
+		//........................................................................
+		nn = ijk-strideY+1;						// neighbor index (get convention)
+		m10 = Phi[nn];					// get neighbor for phi - 10
+		//........................................................................
+		nn = ijk-strideZ-1;						// neighbor index (get convention)
+		m11 = Phi[nn];					// get neighbor for phi - 11
+		//........................................................................
+		nn = ijk+strideZ+1;						// neighbor index (get convention)
+		m12 = Phi[nn];					// get neighbor for phi - 12
+		//........................................................................
+		nn = ijk+strideZ-1;						// neighbor index (get convention)
+		m13 = Phi[nn];					// get neighbor for phi - 13
+		//........................................................................
+		nn = ijk-strideZ+1;						// neighbor index (get convention)
+		m14 = Phi[nn];					// get neighbor for phi - 14
+		//........................................................................
+		nn = ijk-strideZ-strideY;					// neighbor index (get convention)
+		m15 = Phi[nn];					// get neighbor for phi - 15
+		//........................................................................
+		nn = ijk+strideZ+strideY;					// neighbor index (get convention)
+		m16 = Phi[nn];					// get neighbor for phi - 16
+		//........................................................................
+		nn = ijk+strideZ-strideY;					// neighbor index (get convention)
+		m17 = Phi[nn];					// get neighbor for phi - 17
+		//........................................................................
+		nn = ijk-strideZ+strideY;					// neighbor index (get convention)
+		m18 = Phi[nn];					// get neighbor for phi - 18
+
+        // compute mixed difference (Eq.30, A.Fukhari et al. JCP 315(2016) 434-457)
+		//........................................................................
+		nn2x = ijk-2;							// neighbor index (get convention)
+		mm1 = Phi[nn2x];						// get neighbor for phi - 1
+        mm1 = 0.25*(-mm1+5.0*m1-3.0*phi-m2);
+		//........................................................................
+		nn2x = ijk+2;							// neighbor index (get convention)
+		mm2 = Phi[nn2x];						// get neighbor for phi - 2
+        mm2 = 0.25*(-mm2+5.0*m2-3.0*phi-m1);
+		//........................................................................
+		nn2x = ijk-strideY*2;							// neighbor index (get convention)
+		mm3 = Phi[nn2x];					// get neighbor for phi - 3
+        mm3 = 0.25*(-mm3+5.0*m3-3.0*phi-m4);
+		//........................................................................
+		nn2x = ijk+strideY*2;							// neighbor index (get convention)
+		mm4 = Phi[nn2x];					// get neighbor for phi - 4
+        mm4 = 0.25*(-mm4+5.0*m4-3.0*phi-m3);
+		//........................................................................
+		nn2x = ijk-strideZ*2;						// neighbor index (get convention)
+		mm5 = Phi[nn2x];					// get neighbor for phi - 5
+        mm5 = 0.25*(-mm5+5.0*m5-3.0*phi-m6);
+		//........................................................................
+		nn2x = ijk+strideZ*2;						// neighbor index (get convention)
+		mm6 = Phi[nn2x];					// get neighbor for phi - 6
+        mm6 = 0.25*(-mm6+5.0*m6-3.0*phi-m5);
+		//........................................................................
+		nn2x = ijk-strideY*2-2;						// neighbor index (get convention)
+		mm7 = Phi[nn2x];					// get neighbor for phi - 7
+        mm7 = 0.25*(-mm7+5.0*m7-3.0*phi-m8);
+		//........................................................................
+		nn2x = ijk+strideY*2+2;						// neighbor index (get convention)
+		mm8 = Phi[nn2x];					// get neighbor for phi - 8
+        mm8 = 0.25*(-mm8+5.0*m8-3.0*phi-m7);
+		//........................................................................
+		nn2x = ijk+strideY*2-2;						// neighbor index (get convention)
+		mm9 = Phi[nn2x];					// get neighbor for phi - 9
+        mm9 = 0.25*(-mm9+5.0*m9-3.0*phi-m10);
+		//........................................................................
+		nn2x = ijk-strideY*2+2;						// neighbor index (get convention)
+		mm10 = Phi[nn2x];					// get neighbor for phi - 10
+        mm10 = 0.25*(-mm10+5.0*m10-3.0*phi-m9);
+		//........................................................................
+		nn2x = ijk-strideZ*2-2;						// neighbor index (get convention)
+		mm11 = Phi[nn2x];					// get neighbor for phi - 11
+        mm11 = 0.25*(-mm11+5.0*m11-3.0*phi-m12);
+		//........................................................................
+		nn2x = ijk+strideZ*2+2;						// neighbor index (get convention)
+		mm12 = Phi[nn2x];					// get neighbor for phi - 12
+        mm12 = 0.25*(-mm12+5.0*m12-3.0*phi-m11);
+		//........................................................................
+		nn2x = ijk+strideZ*2-2;						// neighbor index (get convention)
+		mm13 = Phi[nn2x];					// get neighbor for phi - 13
+        mm13 = 0.25*(-mm13+5.0*m13-3.0*phi-m14);
+		//........................................................................
+		nn2x = ijk-strideZ*2+2;						// neighbor index (get convention)
+		mm14 = Phi[nn2x];					// get neighbor for phi - 14
+        mm14 = 0.25*(-mm14+5.0*m14-3.0*phi-m13);
+		//........................................................................
+		nn2x = ijk-strideZ*2-strideY*2;					// neighbor index (get convention)
+		mm15 = Phi[nn2x];					// get neighbor for phi - 15
+        mm15 = 0.25*(-mm15+5.0*m15-3.0*phi-m16);
+		//........................................................................
+		nn2x = ijk+strideZ*2+strideY*2;					// neighbor index (get convention)
+		mm16 = Phi[nn2x];					// get neighbor for phi - 16
+        mm16 = 0.25*(-mm16+5.0*m16-3.0*phi-m15);
+		//........................................................................
+		nn2x = ijk+strideZ*2-strideY*2;					// neighbor index (get convention)
+		mm17 = Phi[nn2x];					// get neighbor for phi - 17
+        mm17 = 0.25*(-mm17+5.0*m17-3.0*phi-m18);
+		//........................................................................
+		nn2x = ijk-strideZ*2+strideY*2;					// neighbor index (get convention)
+		mm18 = Phi[nn2x];					// get neighbor for phi - 18
+        mm18 = 0.25*(-mm18+5.0*m18-3.0*phi-m17);
+
+
+		//............Compute the Color Gradient...................................
+		nx = -3.0*1.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+		ny = -3.0*1.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+		nz = -3.0*1.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+		//............Compute the Chemical Potential...............................
+        chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi));//intermediate var, i.e. the laplacian
+        chem = 4.0*beta*phi*(phi+1.0)*(phi-1.0)-kappa*chem;
+		//............Compute the Mixed Gradient...................................
+		mgx = -3.0*1.0/18.0*(mm1-mm2+0.5*(mm7-mm8+mm9-mm10+mm11-mm12+mm13-mm14));
+		mgy = -3.0*1.0/18.0*(mm3-mm4+0.5*(mm7-mm8-mm9+mm10+mm15-mm16+mm17-mm18));
+		mgz = -3.0*1.0/18.0*(mm5-mm6+0.5*(mm11-mm12-mm13+mm14+mm15-mm16-mm17+mm18));
+		
+        //de-noise color gradient and mixed gradient
+		C = sqrt(nx*nx+ny*ny+nz*nz);
+		if (C<1.0e-12) nx=ny=nz=0.0;
+		double mg_mag = sqrt(mgx*mgx+mgy*mgy+mgz*mgz);
+		if (mg_mag<1.0e-12) mgx=mgy=mgz=0.0;
+        //TODO - maybe you can also de-noise chemical potential ? within the bulk phase chem should be ZERO
+        //if (fabs(chem)<1.0e-12) chem=0.0;
+
+		// q=0
+		m0 = dist[n];
+		// q=1
+		nr1 = neighborList[n]; // neighbor 2 ( > 10Np => odd part of dist)
+		m1 = dist[nr1]; // reading the f1 data into register fq
+
+		nr2 = neighborList[n+Np]; // neighbor 1 ( < 10Np => even part of dist)
+		m2 = dist[nr2];  // reading the f2 data into register fq
+
+		// q=3
+		nr3 = neighborList[n+2*Np]; // neighbor 4
+		m3 = dist[nr3];
+
+		// q = 4
+		nr4 = neighborList[n+3*Np]; // neighbor 3
+		m4 = dist[nr4];
+
+		// q=5
+		nr5 = neighborList[n+4*Np];
+		m5 = dist[nr5];
+
+		// q = 6
+		nr6 = neighborList[n+5*Np];
+		m6 = dist[nr6];
+		
+		// q=7
+		nr7 = neighborList[n+6*Np];
+		m7 = dist[nr7];
+
+		// q = 8
+		nr8 = neighborList[n+7*Np];
+		m8 = dist[nr8];
+
+		// q=9
+		nr9 = neighborList[n+8*Np];
+		m9 = dist[nr9];
+
+		// q = 10
+		nr10 = neighborList[n+9*Np];
+		m10 = dist[nr10];
+
+		// q=11
+		nr11 = neighborList[n+10*Np];
+		m11 = dist[nr11];
+
+		// q=12
+		nr12 = neighborList[n+11*Np];
+		m12 = dist[nr12];
+
+		// q=13
+		nr13 = neighborList[n+12*Np];
+		m13 = dist[nr13];
+
+		// q=14
+		nr14 = neighborList[n+13*Np];
+		m14 = dist[nr14];
+
+		// q=15
+		nr15 = neighborList[n+14*Np];
+		m15 = dist[nr15];
+
+		// q=16
+		nr16 = neighborList[n+15*Np];
+		m16 = dist[nr16];
+
+		// q=17
+		nr17 = neighborList[n+16*Np];
+		m17 = dist[nr17];
+
+		// q=18
+		nr18 = neighborList[n+17*Np];
+		m18 = dist[nr18];
+
+        //compute fluid velocity
+        ux = 3.0/rho0*(m1-m2+m7-m8+m9-m10+m11-m12+m13-m14+0.5*(chem*nx+Fx)/3.0);
+        uy = 3.0/rho0*(m3-m4+m7-m8-m9+m10+m15-m16+m17-m18+0.5*(chem*ny+Fy)/3.0);
+        uz = 3.0/rho0*(m5-m6+m11-m12-m13+m14+m15-m16-m17+m18+0.5*(chem*nz+Fz)/3.0);
+        //compute pressure
+        p = (m0+m2+m1+m4+m3+m6+m5+m8+m7+m10+m9+m12+m11+m14+m13+m16+m15+m18+m17)
+                  +0.5*(rhoA-rhoB)/2.0/3.0*(ux*nx+uy*ny+uz*nz);
+
+        //compute equilibrium distributions
+            feq0 = 0.3333333333333333*p - 0.25*(Fx*ux + Fy*uy + Fz*uz)*(-0.6666666666666666 + ux*ux + uy*uy + uz*uz) - 
+     0.16666666666666666*rho0*(ux*ux + uy*uy + uz*uz) - 0.5*(-(nx*ux) - ny*uy - nz*uz)*
+      (-0.08333333333333333*(rhoA - rhoB)*(ux*ux + uy*uy + uz*uz) + chem*(0.3333333333333333 - 0.5*(ux*ux + uy*uy + uz*uz)));
+            feq1 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-ux*ux + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*uz)) - 
+     0.125*(Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 
+       0.3333333333333333*(-2.*ux + ux*ux + uy*uy + uz*uz)) - 0.0625*(nx - nx*ux - ny*uy - nz*uz)*
+      (2*chem*ux*ux - 0.3333333333333333*((-rhoA + rhoB)*ux*ux + 2*chem*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*uz)));
+            feq2 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-ux*ux + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*uz)) - 
+     0.125*(Fx + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 
+       0.3333333333333333*(2.*ux + ux*ux + uy*uy + uz*uz)) - 0.0625*(nx + nx*ux + ny*uy + nz*uz)*
+      (-2.*chem*ux*ux + 0.1111111111111111*(-4.*chem + rhoB*(-2.*ux - 1.*ux*ux - 1.*uy*uy - 1.*uz*uz) + 
+         rhoA*(2.*ux + ux*ux + uy*uy + uz*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*ux*ux + 
+         chem*(4.*ux + 2.*ux*ux + 2.*uy*uy + 2.*uz*uz)));
+            feq3 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uy*uy + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*uz)) - 
+     0.125*(Fx*ux + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 
+       0.3333333333333333*(ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.0625*(ny - nx*ux - ny*uy - nz*uz)*
+      (2*chem*uy*uy - 0.3333333333333333*((-rhoA + rhoB)*uy*uy + 2*chem*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*uz)));
+            feq4 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uy*uy + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*uz)) - 
+     0.125*(Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 
+       0.3333333333333333*(ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.0625*(ny + nx*ux + ny*uy + nz*uz)*
+      (-2.*chem*uy*uy + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 2.*uy - 1.*uy*uy - 1.*uz*uz) + 
+         rhoA*(ux*ux + 2.*uy + uy*uy + uz*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*uy*uy + 
+         chem*(2.*ux*ux + 4.*uy + 2.*uy*uy + 2.*uz*uz))); 
+            feq5 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uz*uz + 0.3333333333333333*(ux*ux + uy*uy + (-2 + uz)*uz)) - 
+     0.125*(Fx*ux + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + uy*uy + (-2. + uz)*uz)) - 0.0625*(nx*ux + ny*uy + nz*(-1. + uz))*
+      (-2.*chem*uz*uz + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 1.*uy*uy + (2. - 1.*uz)*uz) + 
+         rhoA*(ux*ux + uy*uy + (-2. + uz)*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*uz*uz + 
+         chem*(2.*ux*ux + 2.*uy*uy + uz*(-4. + 2.*uz)))); 
+            feq6 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uz*uz + 0.3333333333333333*(ux*ux + uy*uy + uz*(2 + uz))) - 
+     0.125*(Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + uy*uy + uz*(2. + uz))) - 0.0625*(nz + nx*ux + ny*uy + nz*uz)*
+      (-2.*chem*uz*uz + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 1.*uy*uy + (-2. - 1.*uz)*uz) + 
+         rhoA*(ux*ux + uy*uy + uz*(2. + uz))) + 0.3333333333333333*((-1.*rhoA + rhoB)*uz*uz + 
+         chem*(2.*ux*ux + 2.*uy*uy + uz*(4. + 2.*uz)))); 
+            feq7 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uy)*(ux + uy) + 0.3333333333333333*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fx*(-1. + ux) + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(-2.*ux + ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.03125*(nx + ny - nx*ux - ny*uy - nz*uz)*
+      (2*chem*(ux + uy)*(ux + uy) + 0.3333333333333333*((rhoA - rhoB)*(ux + uy)*(ux + uy) - 2*chem*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz))); 
+            feq8 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uy)*(ux + uy) + 0.3333333333333333*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fx + Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(2.*ux + ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.03125*(-(nx*(1 + ux)) - ny*(1 + uy) - nz*uz)*
+      (2*chem*(ux + uy)*(ux + uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux + uy)*(ux + uy)) + 
+         2*chem*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz))); 
+            feq9 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uy)*(ux - uy) + 0.3333333333333333*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fy + Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(-2.*ux + ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.03125*(nx - nx*ux - ny*(1 + uy) - nz*uz)*
+      (2*chem*(ux - uy)*(ux - uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uy)*(ux - uy)) + 
+         2*chem*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz))); 
+            feq10 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uy)*(ux - uy) + 0.3333333333333333*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fx*(1 + ux) + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(2.*ux + ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.03125*(ny - nx*(1 + ux) - ny*uy - nz*uz)*
+      (2*chem*(ux - uy)*(ux - uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uy)*(ux - uy)) + 
+         2*chem*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz))); 
+            feq11 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uz)*(ux + uz) + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*(-1. + ux) + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(-2.*ux + ux*ux + uy*uy + (-2. + uz)*uz)) - 0.03125*(nx + nz - nx*ux - ny*uy - nz*uz)*
+      (2*chem*(ux + uz)*(ux + uz) + 0.3333333333333333*((rhoA - rhoB)*(ux + uz)*(ux + uz) - 2*chem*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz))); 
+            feq12 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uz)*(ux + uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fx + Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(2.*ux + ux*ux + uy*uy + uz*(2. + uz))) - 0.03125*(-(nx*(1 + ux)) - ny*uy - nz*(1 + uz))*
+      (2*chem*(ux + uz)*(ux + uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux + uz)*(ux + uz)) + 
+         2*chem*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))); 
+            feq13 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uz)*(ux - uz) + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fz + Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(-2.*ux + ux*ux + uy*uy + uz*(2. + uz))) - 0.03125*(nx - nx*ux - ny*uy - nz*(1 + uz))*
+      (2*chem*(ux - uz)*(ux - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uz)*(ux - uz)) + 
+         2*chem*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*(2 + uz)))); 
+            feq14 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uz)*(ux - uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*(1 + ux) + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(2.*ux + ux*ux + uy*uy + (-2. + uz)*uz)) - 0.03125*(nz - nx*(1 + ux) - ny*uy - nz*uz)*
+      (2*chem*(ux - uz)*(ux - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uz)*(ux - uz)) + 
+         2*chem*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz))); 
+            feq15 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*ux + Fy*(-1. + uy) + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uy*uy - 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux - 2.*uy + uy*uy + (-2. + uz)*uz)) - 0.03125*(ny + nz - nx*ux - ny*uy - nz*uz)*
+      (2*chem*(uy + uz)*(uy + uz) + 0.3333333333333333*((rhoA - rhoB)*(uy + uz)*(uy + uz) - 2*chem*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))); 
+            feq16 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fy + Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy - 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + 2.*uy + uy*uy + uz*(2. + uz))) - 0.03125*(-(nx*ux) - ny*(1 + uy) - nz*(1 + uz))*
+      (2*chem*(uy + uz)*(uy + uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy + uz)*(uy + uz)) + 
+         2*chem*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))); 
+            feq17 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fz + Fx*ux + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux - 2.*uy + uy*uy + uz*(2. + uz))) - 0.03125*(ny - nx*ux - ny*uy - nz*(1 + uz))*
+      (2*chem*(uy - uz)*(uy - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy - uz)*(uy - uz)) + 
+         2*chem*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))); 
+            feq18 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*ux + Fy*(1 + uy) + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uy*uy + 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + 2.*uy + uy*uy + (-2. + uz)*uz)) - 0.03125*(nz - nx*ux - ny*(1 + uy) - nz*uz)*
+      (2*chem*(uy - uz)*(uy - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy - uz)*(uy - uz)) + 
+         2*chem*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz))); 
+
+        //------------------------------------------------- BCK collison ------------------------------------------------------------//
+		// q=0
+		dist[n] = m0 - (m0-feq0)/tau + 0.25*(2*(Fx*ux + Fy*uy + Fz*uz)*(-0.6666666666666666 + ux*ux + uy*uy + uz*uz) + 
+     (mgx*ux + mgy*uy + mgz*uz)*(2*chem*(ux*ux + uy*uy + uz*uz) + 
+        0.3333333333333333*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + uz*uz)))); 
+
+		// q = 1
+		dist[nr2] = m1 - (m1-feq1)/tau + 0.125*(2*(Fx*(-1 + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - ux*ux + 
+        0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+     (mgx*(-1 + ux) + mgy*uy + mgz*uz)*(-2*chem*(ux*ux) + 
+        0.3333333333333333*((-rhoA + rhoB)*(ux*ux) + 2*chem*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*uz))));
+
+		// q=2
+		dist[nr1] = m2 - (m2-feq2)/tau + 0.125*(2*(Fx + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - ux*ux + 
+        0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*uz)) + 
+     (mgx + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(ux*ux) + 
+        0.3333333333333333*((-rhoA + rhoB)*(ux*ux) + 2*chem*(2*ux + ux*ux + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*uz))));
+
+		// q = 3
+		dist[nr4] = m3 - (m3-feq3)/tau + 0.125*(2*(Fx*ux + Fy*(-1 + uy) + Fz*uz)*(-0.2222222222222222 - uy*uy + 
+        0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+     (mgx*ux + mgy*(-1 + uy) + mgz*uz)*(-2*chem*(uy*uy) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uy*uy) + 2*chem*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*uz))));
+
+		// q = 4
+		dist[nr3] = m4 - (m4-feq4)/tau + 0.125*(2*(Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - uy*uy + 
+        0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*uz)) + 
+     (mgy + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(uy*uy) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uy*uy) + 2*chem*(ux*ux + 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*uz))));
+
+		// q = 5
+		dist[nr6] = m5 - (m5-feq5)/tau + 0.125*(2*(Fx*ux + Fy*uy + Fz*(-1 + uz))*(-0.2222222222222222 - uz*uz + 
+        0.3333333333333333*(ux*ux + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*ux + mgy*uy + mgz*(-1 + uz))*(-2*chem*(uz*uz) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uz*uz) + 2*chem*(ux*ux + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + (-2 + uz)*uz))));
+
+		// q = 6
+		dist[nr5] = m6 - (m6-feq6)/tau + 0.125*(2*(Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - uz*uz + 
+        0.3333333333333333*(ux*ux + uy*uy + uz*(2 + uz))) + 
+     (mgz + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(uz*uz) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uz*uz) + 2*chem*(ux*ux + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + uz*(2 + uz)))));
+
+		// q = 7
+		dist[nr8] = m7 - (m7-feq7)/tau + 0.0625*(-2*(Fx*(-1 + ux) + Fy*(-1 + uy) + Fz*uz)*
+      (0.2222222222222222 + (ux + uy)*(ux + uy) - 
+        0.3333333333333333*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+     (mgx*(-1 + ux) + mgy*(-1 + uy) + mgz*uz)*
+      (-2*chem*((ux + uy)*(ux + uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uy)*(ux + uy))) + 2*chem*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz))));
+
+		// q = 8
+		dist[nr7] = m8 - (m8-feq8)/tau + 0.0625*(2*(Fx + Fy + Fx*ux + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux + uy)*(ux + uy) + 
+        0.3333333333333333*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+     (mgx + mgy + mgx*ux + mgy*uy + mgz*uz)*
+      (-2*chem*((ux + uy)*(ux + uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uy)*(ux + uy))) + 2*chem*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz))));
+
+		// q = 9
+		dist[nr10] = m9 - (m9-feq9)/tau + 0.0625*(2*(Fy + Fx*(-1 + ux) + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux - uy)*(ux - uy) + 
+        0.3333333333333333*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+     (mgy + mgx*(-1 + ux) + mgy*uy + mgz*uz)*
+      (-2*chem*((ux - uy)*(ux - uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uy)*(ux - uy))) + 2*chem*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz))));
+
+		// q = 10
+		dist[nr9] = m10 - (m10-feq10)/tau + 0.0625*(2*(Fx*(1 + ux) + Fy*(-1 + uy) + Fz*uz)*
+      (-0.2222222222222222 - (ux - uy)*(ux - uy) + 
+        0.3333333333333333*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+     (mgx*(1 + ux) + mgy*(-1 + uy) + mgz*uz)*
+      (-2*chem*((ux - uy)*(ux - uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uy)*(ux - uy))) + 2*chem*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz))));
+
+		// q = 11
+		dist[nr12] = m11 - (m11-feq11)/tau + 0.0625*(-2*(Fx*(-1 + ux) + Fy*uy + Fz*(-1 + uz))*
+      (0.2222222222222222 + (ux + uz)*(ux + uz) - 
+        0.3333333333333333*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*(-1 + ux) + mgy*uy + mgz*(-1 + uz))*
+      (-2*chem*((ux + uz)*(ux + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uz)*(ux + uz))) + 2*chem*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz))));
+
+		// q = 12
+		dist[nr11] = m12 - (m12-feq12)/tau + 0.0625*(2*(Fx + Fz + Fx*ux + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux + uz)*(ux + uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))
+       + (mgx + mgz + mgx*ux + mgy*uy + mgz*uz)*
+      (-2*chem*((ux + uz)*(ux + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uz)*(ux + uz))) + 2*chem*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))));
+
+		// q = 13
+		dist[nr14] = m13 - (m13-feq13)/tau + 0.0625*(2*(Fz + Fx*(-1 + ux) + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux - uz)*(ux - uz) + 
+        0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+     (mgz + mgx*(-1 + ux) + mgy*uy + mgz*uz)*
+      (-2*chem*((ux - uz)*(ux - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uz)*(ux - uz))) + 2*chem*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*(2 + uz)))));
+
+		// q= 14
+		dist[nr13] = m14 - (m14-feq14)/tau + 0.0625*(2*(Fx*(1 + ux) + Fy*uy + Fz*(-1 + uz))*
+      (-0.2222222222222222 - (ux - uz)*(ux - uz) + 
+        0.3333333333333333*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*(1 + ux) + mgy*uy + mgz*(-1 + uz))*
+      (-2*chem*((ux - uz)*(ux - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uz)*(ux - uz))) + 2*chem*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz))));
+
+		// q = 15
+		dist[nr16] = m15 - (m15-feq15)/tau + 0.0625*(-2*(Fx*ux + Fy*(-1 + uy) + Fz*(-1 + uz))*
+      (0.2222222222222222 + (uy + uz)*(uy + uz) - 0.3333333333333333*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))
+       + (mgx*ux + mgy*(-1 + uy) + mgz*(-1 + uz))*
+      (-2*chem*((uy + uz)*(uy + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy + uz)*(uy + uz))) + 2*chem*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))));
+
+		// q = 16
+		dist[nr15] = m16 - (m16-feq16)/tau + 0.0625*(2*(Fy + Fz + Fx*ux + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))
+       + (mgy + mgz + mgx*ux + mgy*uy + mgz*uz)*
+      (-2*chem*((uy + uz)*(uy + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy + uz)*(uy + uz))) + 2*chem*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))));
+
+		// q = 17
+		dist[nr18] = m17 - (m17-feq17)/tau + 0.0625*(2*(Fz + Fx*ux + Fy*(-1 + uy) + Fz*uz)*
+      (-0.2222222222222222 - (uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))
+       + (mgz + mgx*ux + mgy*(-1 + uy) + mgz*uz)*
+      (-2*chem*((uy - uz)*(uy - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy - uz)*(uy - uz))) + 2*chem*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))));
+
+		// q = 18
+		dist[nr17] = m18 - (m18-feq18)/tau + 0.0625*(2*(Fx*ux + Fy*(1 + uy) + Fz*(-1 + uz))*
+      (-0.2222222222222222 - (uy - uz)*(uy - uz) + 
+        0.3333333333333333*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*ux + mgy*(1 + uy) + mgz*(-1 + uz))*
+      (-2*chem*((uy - uz)*(uy - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy - uz)*(uy - uz))) + 2*chem*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz))));
+        //----------------------------------------------------------------------------------------------------------------------------------------//
+
+
+        // ----------------------------- compute phase field evolution ----------------------------------------
+		//Normalize the Color Gradient
+		C = sqrt(nx*nx+ny*ny+nz*nz);
+		double ColorMag = C;
+		if (C==0.0) ColorMag=1.0;
+		nx = nx/ColorMag;
+		ny = ny/ColorMag;
+		nz = nz/ColorMag;		
+        //compute surface tension-related parameter
+        theta = 4.5*M*2.0*(1-phi*phi)/W;
+
+        //load distributions of phase field
+		//q=0
+		h0 = hq[n];
+		//q=1
+		h1 = hq[nr1]; 
+
+		//q=2
+		h2 = hq[nr2];  
+
+		//q=3
+		h3 = hq[nr3];
+
+		//q=4
+		h4 = hq[nr4];
+
+		//q=5
+		h5 = hq[nr5];
+
+		//q=6
+		h6 = hq[nr6];
+
+        //-------------------------------- BGK collison for phase field ---------------------------------//
+		// q = 0
+		hq[n] = h0 - (h0 - 0.3333333333333333*phi)/tauM;
+
+		// q = 1
+		hq[nr2] = h1 - (h1 - 0.1111111111111111*nx*theta - phi*(0.1111111111111111 + 0.5*ux))/tauM;
+
+		// q = 2
+		hq[nr1] = h2 - (h2 + 0.1111111111111111*nx*theta - phi*(0.1111111111111111 - 0.5*ux))/tauM;
+
+		// q = 3
+		hq[nr4] = h3 - (h3 - 0.1111111111111111*ny*theta - phi*(0.1111111111111111 + 0.5*uy))/tauM;
+
+		// q = 4
+		hq[nr3] = h4 - (h4 + 0.1111111111111111*ny*theta - phi*(0.1111111111111111 - 0.5*uy))/tauM;
+
+		// q = 5
+		hq[nr6] = h5 - (h5 - 0.1111111111111111*nz*theta - phi*(0.1111111111111111 + 0.5*uz))/tauM;
+
+		// q = 6
+		hq[nr5] = h6 - (h6 + 0.1111111111111111*nz*theta - phi*(0.1111111111111111 - 0.5*uz))/tauM;
+		//........................................................................
+
+        //Update velocity on device
+		Vel[0*Np+n] = ux;
+		Vel[1*Np+n] = uy;
+		Vel[2*Np+n] = uz;
+        //Update pressure on device
+        Pressure[n] = p;
+        //Update chemical potential on device
+        mu_phi[n] = chem;
+        //Update color gradient on device
+		ColorGrad[0*Np+n] = nx;
+		ColorGrad[1*Np+n] = ny;
+		ColorGrad[2*Np+n] = nz;
+
+	}
+}
+
+extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(int *Map, double *dist, double *hq, double *Den,	double *Phi, double *mu_phi, double *Vel, double *Pressure, double *ColorGrad,
+                                                double rhoA, double rhoB, double tauA, double tauB, double tauM, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
+                                                int strideY, int strideZ, int start, int finish, int Np){
+	
+	int n,nn,nn2x,ijk;
+	//int nr1,nr2,nr3,nr4,nr5,nr6,nr7,nr8,nr9,nr10,nr11,nr12,nr13,nr14,nr15,nr16,nr17,nr18;
+    double ux,uy,uz;//fluid velocity 
+    double p;//pressure
+    double chem;//chemical potential
+    double phi; //phase field
+    double rho0;//fluid density
+	// distribution functions
+	double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
+	double m0,m3,m5,m7;
+	double mm1,mm2,mm4,mm6,mm8,mm9,mm10,mm11,mm12,mm13,mm14,mm15,mm16,mm17,mm18;
+	double mm3,mm5,mm7;
+    double feq0,feq1,feq2,feq3,feq4,feq5,feq6,feq7,feq8,feq9,feq10,feq11,feq12,feq13,feq14,feq15,feq16,feq17,feq18;
+    double nx,ny,nz;//normal color gradient
+    double mgx,mgy,mgz;//mixed gradient reaching secondary neighbor
+
+	//double f0,f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18;
+    double h0,h1,h2,h3,h4,h5,h6;//distributions for LB phase field
+	double tau;//position dependent LB relaxation time for fluid
+    double C,theta;
+    double M = 2.0/9.0*(tauM-0.5);//diffusivity (or mobility) for the phase field D3Q7
+
+	for (int n=start; n<finish; n++){
+
+		rho0 = Den[n];//load density
+
+		// Get the 1D index based on regular data layout
+		ijk = Map[n];
+        phi = Phi[ijk];// load phase field
+
+		// local relaxation time
+		tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
+
+		//					COMPUTE THE COLOR GRADIENT
+		//........................................................................
+		//.................Read Phase Indicator Values............................
+		//........................................................................
+		nn = ijk-1;							// neighbor index (get convention)
+		m1 = Phi[nn];						// get neighbor for phi - 1
+		//........................................................................
+		nn = ijk+1;							// neighbor index (get convention)
+		m2 = Phi[nn];						// get neighbor for phi - 2
+		//........................................................................
+		nn = ijk-strideY;							// neighbor index (get convention)
+		m3 = Phi[nn];					// get neighbor for phi - 3
+		//........................................................................
+		nn = ijk+strideY;							// neighbor index (get convention)
+		m4 = Phi[nn];					// get neighbor for phi - 4
+		//........................................................................
+		nn = ijk-strideZ;						// neighbor index (get convention)
+		m5 = Phi[nn];					// get neighbor for phi - 5
+		//........................................................................
+		nn = ijk+strideZ;						// neighbor index (get convention)
+		m6 = Phi[nn];					// get neighbor for phi - 6
+		//........................................................................
+		nn = ijk-strideY-1;						// neighbor index (get convention)
+		m7 = Phi[nn];					// get neighbor for phi - 7
+		//........................................................................
+		nn = ijk+strideY+1;						// neighbor index (get convention)
+		m8 = Phi[nn];					// get neighbor for phi - 8
+		//........................................................................
+		nn = ijk+strideY-1;						// neighbor index (get convention)
+		m9 = Phi[nn];					// get neighbor for phi - 9
+		//........................................................................
+		nn = ijk-strideY+1;						// neighbor index (get convention)
+		m10 = Phi[nn];					// get neighbor for phi - 10
+		//........................................................................
+		nn = ijk-strideZ-1;						// neighbor index (get convention)
+		m11 = Phi[nn];					// get neighbor for phi - 11
+		//........................................................................
+		nn = ijk+strideZ+1;						// neighbor index (get convention)
+		m12 = Phi[nn];					// get neighbor for phi - 12
+		//........................................................................
+		nn = ijk+strideZ-1;						// neighbor index (get convention)
+		m13 = Phi[nn];					// get neighbor for phi - 13
+		//........................................................................
+		nn = ijk-strideZ+1;						// neighbor index (get convention)
+		m14 = Phi[nn];					// get neighbor for phi - 14
+		//........................................................................
+		nn = ijk-strideZ-strideY;					// neighbor index (get convention)
+		m15 = Phi[nn];					// get neighbor for phi - 15
+		//........................................................................
+		nn = ijk+strideZ+strideY;					// neighbor index (get convention)
+		m16 = Phi[nn];					// get neighbor for phi - 16
+		//........................................................................
+		nn = ijk+strideZ-strideY;					// neighbor index (get convention)
+		m17 = Phi[nn];					// get neighbor for phi - 17
+		//........................................................................
+		nn = ijk-strideZ+strideY;					// neighbor index (get convention)
+		m18 = Phi[nn];					// get neighbor for phi - 18
+
+        // compute mixed difference (Eq.30, A.Fukhari et al. JCP 315(2016) 434-457)
+		//........................................................................
+		nn2x = ijk-2;							// neighbor index (get convention)
+		mm1 = Phi[nn2x];						// get neighbor for phi - 1
+        mm1 = 0.25*(-mm1+5.0*m1-3.0*phi-m2);
+		//........................................................................
+		nn2x = ijk+2;							// neighbor index (get convention)
+		mm2 = Phi[nn2x];						// get neighbor for phi - 2
+        mm2 = 0.25*(-mm2+5.0*m2-3.0*phi-m1);
+		//........................................................................
+		nn2x = ijk-strideY*2;							// neighbor index (get convention)
+		mm3 = Phi[nn2x];					// get neighbor for phi - 3
+        mm3 = 0.25*(-mm3+5.0*m3-3.0*phi-m4);
+		//........................................................................
+		nn2x = ijk+strideY*2;							// neighbor index (get convention)
+		mm4 = Phi[nn2x];					// get neighbor for phi - 4
+        mm4 = 0.25*(-mm4+5.0*m4-3.0*phi-m3);
+		//........................................................................
+		nn2x = ijk-strideZ*2;						// neighbor index (get convention)
+		mm5 = Phi[nn2x];					// get neighbor for phi - 5
+        mm5 = 0.25*(-mm5+5.0*m5-3.0*phi-m6);
+		//........................................................................
+		nn2x = ijk+strideZ*2;						// neighbor index (get convention)
+		mm6 = Phi[nn2x];					// get neighbor for phi - 6
+        mm6 = 0.25*(-mm6+5.0*m6-3.0*phi-m5);
+		//........................................................................
+		nn2x = ijk-strideY*2-2;						// neighbor index (get convention)
+		mm7 = Phi[nn2x];					// get neighbor for phi - 7
+        mm7 = 0.25*(-mm7+5.0*m7-3.0*phi-m8);
+		//........................................................................
+		nn2x = ijk+strideY*2+2;						// neighbor index (get convention)
+		mm8 = Phi[nn2x];					// get neighbor for phi - 8
+        mm8 = 0.25*(-mm8+5.0*m8-3.0*phi-m7);
+		//........................................................................
+		nn2x = ijk+strideY*2-2;						// neighbor index (get convention)
+		mm9 = Phi[nn2x];					// get neighbor for phi - 9
+        mm9 = 0.25*(-mm9+5.0*m9-3.0*phi-m10);
+		//........................................................................
+		nn2x = ijk-strideY*2+2;						// neighbor index (get convention)
+		mm10 = Phi[nn2x];					// get neighbor for phi - 10
+        mm10 = 0.25*(-mm10+5.0*m10-3.0*phi-m9);
+		//........................................................................
+		nn2x = ijk-strideZ*2-2;						// neighbor index (get convention)
+		mm11 = Phi[nn2x];					// get neighbor for phi - 11
+        mm11 = 0.25*(-mm11+5.0*m11-3.0*phi-m12);
+		//........................................................................
+		nn2x = ijk+strideZ*2+2;						// neighbor index (get convention)
+		mm12 = Phi[nn2x];					// get neighbor for phi - 12
+        mm12 = 0.25*(-mm12+5.0*m12-3.0*phi-m11);
+		//........................................................................
+		nn2x = ijk+strideZ*2-2;						// neighbor index (get convention)
+		mm13 = Phi[nn2x];					// get neighbor for phi - 13
+        mm13 = 0.25*(-mm13+5.0*m13-3.0*phi-m14);
+		//........................................................................
+		nn2x = ijk-strideZ*2+2;						// neighbor index (get convention)
+		mm14 = Phi[nn2x];					// get neighbor for phi - 14
+        mm14 = 0.25*(-mm14+5.0*m14-3.0*phi-m13);
+		//........................................................................
+		nn2x = ijk-strideZ*2-strideY*2;					// neighbor index (get convention)
+		mm15 = Phi[nn2x];					// get neighbor for phi - 15
+        mm15 = 0.25*(-mm15+5.0*m15-3.0*phi-m16);
+		//........................................................................
+		nn2x = ijk+strideZ*2+strideY*2;					// neighbor index (get convention)
+		mm16 = Phi[nn2x];					// get neighbor for phi - 16
+        mm16 = 0.25*(-mm16+5.0*m16-3.0*phi-m15);
+		//........................................................................
+		nn2x = ijk+strideZ*2-strideY*2;					// neighbor index (get convention)
+		mm17 = Phi[nn2x];					// get neighbor for phi - 17
+        mm17 = 0.25*(-mm17+5.0*m17-3.0*phi-m18);
+		//........................................................................
+		nn2x = ijk-strideZ*2+strideY*2;					// neighbor index (get convention)
+		mm18 = Phi[nn2x];					// get neighbor for phi - 18
+        mm18 = 0.25*(-mm18+5.0*m18-3.0*phi-m17);
+
+
+		//............Compute the Color Gradient...................................
+		nx = -3.0*1.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+		ny = -3.0*1.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+		nz = -3.0*1.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+		//............Compute the Chemical Potential...............................
+        chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi));//intermediate var, i.e. the laplacian
+        chem = 4.0*beta*phi*(phi+1.0)*(phi-1.0)-kappa*chem;
+		//............Compute the Mixed Gradient...................................
+		mgx = -3.0*1.0/18.0*(mm1-mm2+0.5*(mm7-mm8+mm9-mm10+mm11-mm12+mm13-mm14));
+		mgy = -3.0*1.0/18.0*(mm3-mm4+0.5*(mm7-mm8-mm9+mm10+mm15-mm16+mm17-mm18));
+		mgz = -3.0*1.0/18.0*(mm5-mm6+0.5*(mm11-mm12-mm13+mm14+mm15-mm16-mm17+mm18));
+		
+        //de-noise color gradient and mixed gradient
+		C = sqrt(nx*nx+ny*ny+nz*nz);
+		if (C<1.0e-12) nx=ny=nz=0.0;
+		double mg_mag = sqrt(mgx*mgx+mgy*mgy+mgz*mgz);
+		if (mg_mag<1.0e-12) mgx=mgy=mgz=0.0;
+        //TODO - maybe you can also de-noise chemical potential ? within the bulk phase chem should be ZERO
+        //if (fabs(chem)<1.0e-12) chem=0.0;
+
+		// q=0
+		m0 = dist[n];
+		// q=1
+		m1 = dist[2*Np+n]; 
+
+        // q=2
+		m2 = dist[1*Np+n];  
+
+		// q=3
+		m3 = dist[4*Np+n];
+
+		// q = 4
+		m4 = dist[3*Np+n];
+
+		// q=5
+		m5 = dist[6*Np+n];
+
+		// q = 6
+		m6 = dist[5*Np+n];
+		
+		// q=7
+		m7 = dist[8*Np+n];
+
+		// q = 8
+		m8 = dist[7*Np+n];
+
+		// q=9
+		m9 = dist[10*Np+n];
+
+		// q = 10
+		m10 = dist[9*Np+n];
+
+		// q=11
+		m11 = dist[12*Np+n];
+
+		// q=12
+		m12 = dist[11*Np+n];
+
+		// q=13
+		m13 = dist[14*Np+n];
+
+		// q=14
+		m14 = dist[13*Np+n];
+
+		// q=15
+		m15 = dist[16*Np+n];
+
+		// q=16
+		m16 = dist[15*Np+n];
+
+		// q=17
+		m17 = dist[18*Np+n];
+
+		// q=18
+		m18 = dist[17*Np+n];
+
+        //compute fluid velocity
+        ux = 3.0/rho0*(m1-m2+m7-m8+m9-m10+m11-m12+m13-m14+0.5*(chem*nx+Fx)/3.0);
+        uy = 3.0/rho0*(m3-m4+m7-m8-m9+m10+m15-m16+m17-m18+0.5*(chem*ny+Fy)/3.0);
+        uz = 3.0/rho0*(m5-m6+m11-m12-m13+m14+m15-m16-m17+m18+0.5*(chem*nz+Fz)/3.0);
+        //compute pressure
+        p = (m0+m2+m1+m4+m3+m6+m5+m8+m7+m10+m9+m12+m11+m14+m13+m16+m15+m18+m17)
+                  +0.5*(rhoA-rhoB)/2.0/3.0*(ux*nx+uy*ny+uz*nz);
+
+        //compute equilibrium distributions
+            feq0 = 0.3333333333333333*p - 0.25*(Fx*ux + Fy*uy + Fz*uz)*(-0.6666666666666666 + ux*ux + uy*uy + uz*uz) - 
+     0.16666666666666666*rho0*(ux*ux + uy*uy + uz*uz) - 0.5*(-(nx*ux) - ny*uy - nz*uz)*
+      (-0.08333333333333333*(rhoA - rhoB)*(ux*ux + uy*uy + uz*uz) + chem*(0.3333333333333333 - 0.5*(ux*ux + uy*uy + uz*uz)));
+            feq1 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-ux*ux + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*uz)) - 
+     0.125*(Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 
+       0.3333333333333333*(-2.*ux + ux*ux + uy*uy + uz*uz)) - 0.0625*(nx - nx*ux - ny*uy - nz*uz)*
+      (2*chem*ux*ux - 0.3333333333333333*((-rhoA + rhoB)*ux*ux + 2*chem*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*uz)));
+            feq2 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-ux*ux + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*uz)) - 
+     0.125*(Fx + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 
+       0.3333333333333333*(2.*ux + ux*ux + uy*uy + uz*uz)) - 0.0625*(nx + nx*ux + ny*uy + nz*uz)*
+      (-2.*chem*ux*ux + 0.1111111111111111*(-4.*chem + rhoB*(-2.*ux - 1.*ux*ux - 1.*uy*uy - 1.*uz*uz) + 
+         rhoA*(2.*ux + ux*ux + uy*uy + uz*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*ux*ux + 
+         chem*(4.*ux + 2.*ux*ux + 2.*uy*uy + 2.*uz*uz)));
+            feq3 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uy*uy + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*uz)) - 
+     0.125*(Fx*ux + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 
+       0.3333333333333333*(ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.0625*(ny - nx*ux - ny*uy - nz*uz)*
+      (2*chem*uy*uy - 0.3333333333333333*((-rhoA + rhoB)*uy*uy + 2*chem*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*uz)));
+            feq4 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uy*uy + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*uz)) - 
+     0.125*(Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 
+       0.3333333333333333*(ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.0625*(ny + nx*ux + ny*uy + nz*uz)*
+      (-2.*chem*uy*uy + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 2.*uy - 1.*uy*uy - 1.*uz*uz) + 
+         rhoA*(ux*ux + 2.*uy + uy*uy + uz*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*uy*uy + 
+         chem*(2.*ux*ux + 4.*uy + 2.*uy*uy + 2.*uz*uz))); 
+            feq5 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uz*uz + 0.3333333333333333*(ux*ux + uy*uy + (-2 + uz)*uz)) - 
+     0.125*(Fx*ux + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + uy*uy + (-2. + uz)*uz)) - 0.0625*(nx*ux + ny*uy + nz*(-1. + uz))*
+      (-2.*chem*uz*uz + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 1.*uy*uy + (2. - 1.*uz)*uz) + 
+         rhoA*(ux*ux + uy*uy + (-2. + uz)*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*uz*uz + 
+         chem*(2.*ux*ux + 2.*uy*uy + uz*(-4. + 2.*uz)))); 
+            feq6 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uz*uz + 0.3333333333333333*(ux*ux + uy*uy + uz*(2 + uz))) - 
+     0.125*(Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + uy*uy + uz*(2. + uz))) - 0.0625*(nz + nx*ux + ny*uy + nz*uz)*
+      (-2.*chem*uz*uz + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 1.*uy*uy + (-2. - 1.*uz)*uz) + 
+         rhoA*(ux*ux + uy*uy + uz*(2. + uz))) + 0.3333333333333333*((-1.*rhoA + rhoB)*uz*uz + 
+         chem*(2.*ux*ux + 2.*uy*uy + uz*(4. + 2.*uz)))); 
+            feq7 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uy)*(ux + uy) + 0.3333333333333333*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fx*(-1. + ux) + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(-2.*ux + ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.03125*(nx + ny - nx*ux - ny*uy - nz*uz)*
+      (2*chem*(ux + uy)*(ux + uy) + 0.3333333333333333*((rhoA - rhoB)*(ux + uy)*(ux + uy) - 2*chem*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz))); 
+            feq8 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uy)*(ux + uy) + 0.3333333333333333*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fx + Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(2.*ux + ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.03125*(-(nx*(1 + ux)) - ny*(1 + uy) - nz*uz)*
+      (2*chem*(ux + uy)*(ux + uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux + uy)*(ux + uy)) + 
+         2*chem*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz))); 
+            feq9 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uy)*(ux - uy) + 0.3333333333333333*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fy + Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(-2.*ux + ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.03125*(nx - nx*ux - ny*(1 + uy) - nz*uz)*
+      (2*chem*(ux - uy)*(ux - uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uy)*(ux - uy)) + 
+         2*chem*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz))); 
+            feq10 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uy)*(ux - uy) + 0.3333333333333333*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fx*(1 + ux) + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(2.*ux + ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.03125*(ny - nx*(1 + ux) - ny*uy - nz*uz)*
+      (2*chem*(ux - uy)*(ux - uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uy)*(ux - uy)) + 
+         2*chem*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz))); 
+            feq11 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uz)*(ux + uz) + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*(-1. + ux) + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(-2.*ux + ux*ux + uy*uy + (-2. + uz)*uz)) - 0.03125*(nx + nz - nx*ux - ny*uy - nz*uz)*
+      (2*chem*(ux + uz)*(ux + uz) + 0.3333333333333333*((rhoA - rhoB)*(ux + uz)*(ux + uz) - 2*chem*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz))); 
+            feq12 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uz)*(ux + uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fx + Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(2.*ux + ux*ux + uy*uy + uz*(2. + uz))) - 0.03125*(-(nx*(1 + ux)) - ny*uy - nz*(1 + uz))*
+      (2*chem*(ux + uz)*(ux + uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux + uz)*(ux + uz)) + 
+         2*chem*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))); 
+            feq13 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uz)*(ux - uz) + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fz + Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(-2.*ux + ux*ux + uy*uy + uz*(2. + uz))) - 0.03125*(nx - nx*ux - ny*uy - nz*(1 + uz))*
+      (2*chem*(ux - uz)*(ux - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uz)*(ux - uz)) + 
+         2*chem*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*(2 + uz)))); 
+            feq14 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uz)*(ux - uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*(1 + ux) + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(2.*ux + ux*ux + uy*uy + (-2. + uz)*uz)) - 0.03125*(nz - nx*(1 + ux) - ny*uy - nz*uz)*
+      (2*chem*(ux - uz)*(ux - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uz)*(ux - uz)) + 
+         2*chem*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz))); 
+            feq15 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*ux + Fy*(-1. + uy) + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uy*uy - 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux - 2.*uy + uy*uy + (-2. + uz)*uz)) - 0.03125*(ny + nz - nx*ux - ny*uy - nz*uz)*
+      (2*chem*(uy + uz)*(uy + uz) + 0.3333333333333333*((rhoA - rhoB)*(uy + uz)*(uy + uz) - 2*chem*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))); 
+            feq16 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fy + Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy - 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + 2.*uy + uy*uy + uz*(2. + uz))) - 0.03125*(-(nx*ux) - ny*(1 + uy) - nz*(1 + uz))*
+      (2*chem*(uy + uz)*(uy + uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy + uz)*(uy + uz)) + 
+         2*chem*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))); 
+            feq17 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fz + Fx*ux + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux - 2.*uy + uy*uy + uz*(2. + uz))) - 0.03125*(ny - nx*ux - ny*uy - nz*(1 + uz))*
+      (2*chem*(uy - uz)*(uy - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy - uz)*(uy - uz)) + 
+         2*chem*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))); 
+            feq18 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*ux + Fy*(1 + uy) + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uy*uy + 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + 2.*uy + uy*uy + (-2. + uz)*uz)) - 0.03125*(nz - nx*ux - ny*(1 + uy) - nz*uz)*
+      (2*chem*(uy - uz)*(uy - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy - uz)*(uy - uz)) + 
+         2*chem*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz))); 
+
+        //------------------------------------------------- BCK collison ------------------------------------------------------------//
+		// q=0
+		dist[n] = m0 - (m0-feq0)/tau + 0.25*(2*(Fx*ux + Fy*uy + Fz*uz)*(-0.6666666666666666 + ux*ux + uy*uy + uz*uz) + 
+     (mgx*ux + mgy*uy + mgz*uz)*(2*chem*(ux*ux + uy*uy + uz*uz) + 
+        0.3333333333333333*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + uz*uz))));
+
+		// q = 1
+		dist[1*Np+n] = m1 - (m1-feq1)/tau + 0.125*(2*(Fx*(-1 + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - ux*ux + 
+        0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+     (mgx*(-1 + ux) + mgy*uy + mgz*uz)*(-2*chem*(ux*ux) + 
+        0.3333333333333333*((-rhoA + rhoB)*(ux*ux) + 2*chem*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*uz))));
+
+		// q=2
+		dist[2*Np+n] = m2 - (m2-feq2)/tau + 0.125*(2*(Fx + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - ux*ux + 
+        0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*uz)) + 
+     (mgx + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(ux*ux) + 
+        0.3333333333333333*((-rhoA + rhoB)*(ux*ux) + 2*chem*(2*ux + ux*ux + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*uz))));
+
+		// q = 3
+		dist[3*Np+n] = m3 - (m3-feq3)/tau + 0.125*(2*(Fx*ux + Fy*(-1 + uy) + Fz*uz)*(-0.2222222222222222 - uy*uy + 
+        0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+     (mgx*ux + mgy*(-1 + uy) + mgz*uz)*(-2*chem*(uy*uy) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uy*uy) + 2*chem*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*uz))));
+
+		// q = 4
+		dist[4*Np+n] = m4 - (m4-feq4)/tau + 0.125*(2*(Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - uy*uy + 
+        0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*uz)) + 
+     (mgy + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(uy*uy) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uy*uy) + 2*chem*(ux*ux + 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*uz))));
+
+		// q = 5
+		dist[5*Np+n] = m5 - (m5-feq5)/tau + 0.125*(2*(Fx*ux + Fy*uy + Fz*(-1 + uz))*(-0.2222222222222222 - uz*uz + 
+        0.3333333333333333*(ux*ux + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*ux + mgy*uy + mgz*(-1 + uz))*(-2*chem*(uz*uz) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uz*uz) + 2*chem*(ux*ux + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + (-2 + uz)*uz))));
+
+		// q = 6
+		dist[6*Np+n] = m6 - (m6-feq6)/tau + 0.125*(2*(Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - uz*uz + 
+        0.3333333333333333*(ux*ux + uy*uy + uz*(2 + uz))) + 
+     (mgz + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(uz*uz) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uz*uz) + 2*chem*(ux*ux + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + uz*(2 + uz)))));
+
+		// q = 7
+		dist[7*Np+n] = m7 - (m7-feq7)/tau + 0.0625*(-2*(Fx*(-1 + ux) + Fy*(-1 + uy) + Fz*uz)*
+      (0.2222222222222222 + (ux + uy)*(ux + uy) - 
+        0.3333333333333333*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+     (mgx*(-1 + ux) + mgy*(-1 + uy) + mgz*uz)*
+      (-2*chem*((ux + uy)*(ux + uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uy)*(ux + uy))) + 2*chem*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz))));
+
+		// q = 8
+		dist[8*Np+n] = m8 - (m8-feq8)/tau + 0.0625*(2*(Fx + Fy + Fx*ux + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux + uy)*(ux + uy) + 
+        0.3333333333333333*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+     (mgx + mgy + mgx*ux + mgy*uy + mgz*uz)*
+      (-2*chem*((ux + uy)*(ux + uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uy)*(ux + uy))) + 2*chem*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz))));
+
+		// q = 9
+		dist[9*Np+n] = m9 - (m9-feq9)/tau + 0.0625*(2*(Fy + Fx*(-1 + ux) + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux - uy)*(ux - uy) + 
+        0.3333333333333333*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+     (mgy + mgx*(-1 + ux) + mgy*uy + mgz*uz)*
+      (-2*chem*((ux - uy)*(ux - uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uy)*(ux - uy))) + 2*chem*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz))));
+
+		// q = 10
+		dist[10*Np+n] = m10 - (m10-feq10)/tau + 0.0625*(2*(Fx*(1 + ux) + Fy*(-1 + uy) + Fz*uz)*
+      (-0.2222222222222222 - (ux - uy)*(ux - uy) + 
+        0.3333333333333333*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+     (mgx*(1 + ux) + mgy*(-1 + uy) + mgz*uz)*
+      (-2*chem*((ux - uy)*(ux - uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uy)*(ux - uy))) + 2*chem*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz))));
+
+		// q = 11
+		dist[11*Np+n] = m11 - (m11-feq11)/tau + 0.0625*(-2*(Fx*(-1 + ux) + Fy*uy + Fz*(-1 + uz))*
+      (0.2222222222222222 + (ux + uz)*(ux + uz) - 
+        0.3333333333333333*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*(-1 + ux) + mgy*uy + mgz*(-1 + uz))*
+      (-2*chem*((ux + uz)*(ux + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uz)*(ux + uz))) + 2*chem*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz))));
+
+		// q = 12
+		dist[12*Np+n] = m12 - (m12-feq12)/tau + 0.0625*(2*(Fx + Fz + Fx*ux + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux + uz)*(ux + uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))
+       + (mgx + mgz + mgx*ux + mgy*uy + mgz*uz)*
+      (-2*chem*((ux + uz)*(ux + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uz)*(ux + uz))) + 2*chem*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))));
+
+		// q = 13
+		dist[13*Np+n] = m13 - (m13-feq13)/tau + 0.0625*(2*(Fz + Fx*(-1 + ux) + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux - uz)*(ux - uz) + 
+        0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+     (mgz + mgx*(-1 + ux) + mgy*uy + mgz*uz)*
+      (-2*chem*((ux - uz)*(ux - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uz)*(ux - uz))) + 2*chem*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*(2 + uz)))));
+
+		// q= 14
+		dist[14*Np+n] = m14 - (m14-feq14)/tau + 0.0625*(2*(Fx*(1 + ux) + Fy*uy + Fz*(-1 + uz))*
+      (-0.2222222222222222 - (ux - uz)*(ux - uz) + 
+        0.3333333333333333*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*(1 + ux) + mgy*uy + mgz*(-1 + uz))*
+      (-2*chem*((ux - uz)*(ux - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uz)*(ux - uz))) + 2*chem*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz))));
+
+		// q = 15
+		dist[15*Np+n] = m15 - (m15-feq15)/tau + 0.0625*(-2*(Fx*ux + Fy*(-1 + uy) + Fz*(-1 + uz))*
+      (0.2222222222222222 + (uy + uz)*(uy + uz) - 0.3333333333333333*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))
+       + (mgx*ux + mgy*(-1 + uy) + mgz*(-1 + uz))*
+      (-2*chem*((uy + uz)*(uy + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy + uz)*(uy + uz))) + 2*chem*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))));
+
+		// q = 16
+		dist[16*Np+n] = m16 - (m16-feq16)/tau + 0.0625*(2*(Fy + Fz + Fx*ux + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))
+       + (mgy + mgz + mgx*ux + mgy*uy + mgz*uz)*
+      (-2*chem*((uy + uz)*(uy + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy + uz)*(uy + uz))) + 2*chem*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))));
+
+		// q = 17
+		dist[17*Np+n] = m17 - (m17-feq17)/tau + 0.0625*(2*(Fz + Fx*ux + Fy*(-1 + uy) + Fz*uz)*
+      (-0.2222222222222222 - (uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))
+       + (mgz + mgx*ux + mgy*(-1 + uy) + mgz*uz)*
+      (-2*chem*((uy - uz)*(uy - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy - uz)*(uy - uz))) + 2*chem*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))));
+
+		// q = 18
+		dist[18*Np+n] = m18 - (m18-feq18)/tau + 0.0625*(2*(Fx*ux + Fy*(1 + uy) + Fz*(-1 + uz))*
+      (-0.2222222222222222 - (uy - uz)*(uy - uz) + 
+        0.3333333333333333*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*ux + mgy*(1 + uy) + mgz*(-1 + uz))*
+      (-2*chem*((uy - uz)*(uy - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy - uz)*(uy - uz))) + 2*chem*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz))));
+        //----------------------------------------------------------------------------------------------------------------------------------------//
+
+
+        // ----------------------------- compute phase field evolution ----------------------------------------
+		//Normalize the Color Gradient
+		C = sqrt(nx*nx+ny*ny+nz*nz);
+		double ColorMag = C;
+		if (C==0.0) ColorMag=1.0;
+		nx = nx/ColorMag;
+		ny = ny/ColorMag;
+		nz = nz/ColorMag;		
+        //compute surface tension-related parameter
+        theta = 4.5*M*2.0*(1-phi*phi)/W;
+
+        //load distributions of phase field
+		//q=0
+		h0 = hq[n];
+		//q=1
+		h1 = hq[2*Np+n]; 
+
+		//q=2
+		h2 = hq[1*Np+n];  
+
+		//q=3
+		h3 = hq[4*Np+n];
+
+		//q=4
+		h4 = hq[3*Np+n];
+
+		//q=5
+		h5 = hq[6*Np+n];
+
+		//q=6
+		h6 = hq[5*Np+n];
+
+        //-------------------------------- BGK collison for phase field ---------------------------------//
+		// q = 0
+		hq[n] = h0 - (h0 - 0.3333333333333333*phi)/tauM;
+
+		// q = 1
+		hq[1*Np+n] = h1 - (h1 - 0.1111111111111111*nx*theta - phi*(0.1111111111111111 + 0.5*ux))/tauM;
+
+		// q = 2
+		hq[2*Np+n] = h2 - (h2 + 0.1111111111111111*nx*theta - phi*(0.1111111111111111 - 0.5*ux))/tauM;
+
+		// q = 3
+		hq[3*Np+n] = h3 - (h3 - 0.1111111111111111*ny*theta - phi*(0.1111111111111111 + 0.5*uy))/tauM;
+
+		// q = 4
+		hq[4*Np+n] = h4 - (h4 + 0.1111111111111111*ny*theta - phi*(0.1111111111111111 - 0.5*uy))/tauM;
+
+		// q = 5
+		hq[5*Np+n] = h5 - (h5 - 0.1111111111111111*nz*theta - phi*(0.1111111111111111 + 0.5*uz))/tauM;
+
+		// q = 6
+		hq[6*Np+n] = h6 - (h6 + 0.1111111111111111*nz*theta - phi*(0.1111111111111111 - 0.5*uz))/tauM;
+		//........................................................................
+
+        //Update velocity on device
+		Vel[0*Np+n] = ux;
+		Vel[1*Np+n] = uy;
+		Vel[2*Np+n] = uz;
+        //Update pressure on device
+        Pressure[n] = p;
+        //Update chemical potential on device
+        mu_phi[n] = chem;
+        //Update color gradient on device
+		ColorGrad[0*Np+n] = nx;
+		ColorGrad[1*Np+n] = ny;
+		ColorGrad[2*Np+n] = nz;
+
+	}
+}
+
+
 extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_SingleFluid_BGK(int *neighborList, double *dist, double *Vel, double *Pressure,  
                                                                 double tau, double rho0, double Fx, double Fy, double Fz, int start, int finish, int Np){
 	
diff --git a/models/FreeLeeModel.cpp b/models/FreeLeeModel.cpp
index ce4e2b92..b08dc75b 100644
--- a/models/FreeLeeModel.cpp
+++ b/models/FreeLeeModel.cpp
@@ -1,4 +1,4 @@
-/*
+u*
 color lattice boltzmann model
  */
 #include "models/FreeLeeModel.h"
@@ -799,27 +799,31 @@ double ScaLBL_FreeLeeModel::Run_TwoFluid(int returntime){
 		// Compute the Phase indicator field
 		// Read for hq happens in this routine (requires communication)
 		ScaLBL_Comm->SendD3Q7AA(hq,0); //READ FROM NORMAL
-		ScaLBL_D3Q7_AAodd_FreeLee_PhaseField(NeighborList, dvcMap, hq, Den, Phi, ColorGrad, Velocity, rhoA, rhoB, tauM, W, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+		ScaLBL_D3Q7_AAodd_FreeLeeModel_PhaseField(NeighborList, dvcMap, hq, Den, Phi, rhoA, rhoB, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+		//ScaLBL_D3Q7_AAodd_FreeLee_PhaseField(NeighborList, dvcMap, hq, Den, Phi, ColorGrad, Velocity, rhoA, rhoB, tauM, W, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
 		ScaLBL_Comm->RecvD3Q7AA(hq,0); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
-		ScaLBL_D3Q7_AAodd_FreeLee_PhaseField(NeighborList, dvcMap, hq, Den, Phi, ColorGrad, Velocity, rhoA, rhoB, tauM, W, 0, ScaLBL_Comm->LastExterior(), Np);
+		ScaLBL_D3Q7_AAodd_FreeLeeModel_PhaseField(NeighborList, dvcMap, hq, Den, Phi, rhoA, rhoB,  0, ScaLBL_Comm->LastExterior(), Np);
+		//ScaLBL_D3Q7_AAodd_FreeLee_PhaseField(NeighborList, dvcMap, hq, Den, Phi, ColorGrad, Velocity, rhoA, rhoB, tauM, W, 0, ScaLBL_Comm->LastExterior(), Np);
 
 		// Perform the collision operation
-		// Halo exchange for phase field
-		ScaLBL_D3Q7_ComputePhaseField(dvcMap, hq, Den, Phi, rhoA, rhoB, 0, ScaLBL_Comm->LastInterior(), Np);
-		ScaLBL_Comm_WideHalo->Send(Phi);
-		ScaLBL_Comm_WideHalo->Recv(Phi);
+		//ScaLBL_D3Q7_ComputePhaseField(dvcMap, hq, Den, Phi, rhoA, rhoB, 0, ScaLBL_Comm->LastInterior(), Np);
+		//ScaLBL_Comm_WideHalo->Send(Phi);
+		//ScaLBL_Comm_WideHalo->Recv(Phi);
+		ScaLBL_Comm->SendD3Q19AA(gqbar); //READ FROM NORMAL
 		if (BoundaryCondition > 0 && BoundaryCondition < 5){
             //TODO to be revised
 			// Need to add BC for hq!!!
 			ScaLBL_Comm->Color_BC_z(dvcMap, Phi, Den, inletA, inletB);
 			ScaLBL_Comm->Color_BC_Z(dvcMap, Phi, Den, outletA, outletB);
 		}
-		
-		ScaLBL_Comm->SendD3Q19AA(gqbar); //READ FROM NORMAL		
-		ScaLBL_D3Q19_AAodd_FreeLeeModel(NeighborList, dvcMap, gqbar, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB,
-				                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
-
+		// Halo exchange for phase field
+		ScaLBL_Comm_WideHalo->Send(Phi);
+		//ScaLBL_D3Q19_AAodd_FreeLeeModel(NeighborList, dvcMap, gqbar, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB,
+		//		                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+		ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(NeighborList, dvcMap, gqbar, hq, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, tauM,
+				                        kappa, beta, W, Fx, Fy, Fz, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+		ScaLBL_Comm_WideHalo->Recv(Phi);
 		ScaLBL_Comm->RecvD3Q19AA(gqbar); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
 		// Set BCs
@@ -836,8 +840,10 @@ double ScaLBL_FreeLeeModel::Run_TwoFluid(int returntime){
 			ScaLBL_Comm->D3Q19_Reflection_BC_Z(gqbar);
 		}
 
-		ScaLBL_D3Q19_AAodd_FreeLeeModel(NeighborList, dvcMap, gqbar, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, 
-				                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, 0, ScaLBL_Comm->LastExterior(), Np);
+		//ScaLBL_D3Q19_AAodd_FreeLeeModel(NeighborList, dvcMap, gqbar, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, 
+		//		                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, 0, ScaLBL_Comm->LastExterior(), Np);
+		ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(NeighborList, dvcMap, gqbar, hq, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, tauM,
+				                        kappa, beta, W, Fx, Fy, Fz, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
 		ScaLBL_Comm->Barrier(); 
 		
 				
@@ -845,24 +851,29 @@ double ScaLBL_FreeLeeModel::Run_TwoFluid(int returntime){
 		timestep++;
 		// Compute the Phase indicator field
 		ScaLBL_Comm->SendD3Q7AA(hq,0); //READ FROM NORMA
-		ScaLBL_D3Q7_AAeven_FreeLee_PhaseField(dvcMap, hq, Den, Phi, ColorGrad, Velocity, rhoA, rhoB, tauM, W, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+		ScaLBL_D3Q7_AAeven_FreeLeeModel_PhaseField(dvcMap, hq, Den, Phi, rhoA, rhoB,  ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+		//ScaLBL_D3Q7_AAeven_FreeLee_PhaseField(dvcMap, hq, Den, Phi, ColorGrad, Velocity, rhoA, rhoB, tauM, W, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
 		ScaLBL_Comm->RecvD3Q7AA(hq,0); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
-		ScaLBL_D3Q7_AAeven_FreeLee_PhaseField(dvcMap, hq, Den, Phi, ColorGrad, Velocity, rhoA, rhoB, tauM, W, 0, ScaLBL_Comm->LastExterior(), Np);
+		ScaLBL_D3Q7_AAeven_FreeLeeModel_PhaseField(dvcMap, hq, Den, Phi, rhoA, rhoB,  0, ScaLBL_Comm->LastExterior(), Np);
+		//ScaLBL_D3Q7_AAeven_FreeLee_PhaseField(dvcMap, hq, Den, Phi, ColorGrad, Velocity, rhoA, rhoB, tauM, W, 0, ScaLBL_Comm->LastExterior(), Np);
 
 		// Perform the collision operation
-		// Halo exchange for phase field
-		ScaLBL_D3Q7_ComputePhaseField(dvcMap, hq, Den, Phi, rhoA, rhoB, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
-		ScaLBL_Comm_WideHalo->Send(Phi);
-		ScaLBL_Comm_WideHalo->Recv(Phi);
+		//ScaLBL_D3Q7_ComputePhaseField(dvcMap, hq, Den, Phi, rhoA, rhoB, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+		//ScaLBL_Comm_WideHalo->Send(Phi);
+		//ScaLBL_Comm_WideHalo->Recv(Phi);
+		ScaLBL_Comm->SendD3Q19AA(gqbar); //READ FORM NORMAL
 		if (BoundaryCondition > 0 && BoundaryCondition < 5){
 			ScaLBL_Comm->Color_BC_z(dvcMap, Phi, Den, inletA, inletB);
 			ScaLBL_Comm->Color_BC_Z(dvcMap, Phi, Den, outletA, outletB);
 		}
-		ScaLBL_Comm->SendD3Q19AA(gqbar); //READ FORM NORMAL
-
-		ScaLBL_D3Q19_AAeven_FreeLeeModel(dvcMap, gqbar, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, 
-				                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+		// Halo exchange for phase field
+		ScaLBL_Comm_WideHalo->Send(Phi);
+		//ScaLBL_D3Q19_AAeven_FreeLeeModel(dvcMap, gqbar, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, 
+		//		                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+		ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(dvcMap, gqbar, hq, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, tauM,
+				                        kappa, beta, W, Fx, Fy, Fz, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+		ScaLBL_Comm_WideHalo->Recv(Phi);
 		ScaLBL_Comm->RecvD3Q19AA(gqbar); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
 		// Set boundary conditions
@@ -878,8 +889,10 @@ double ScaLBL_FreeLeeModel::Run_TwoFluid(int returntime){
 			ScaLBL_Comm->D3Q19_Reflection_BC_z(gqbar);
 			ScaLBL_Comm->D3Q19_Reflection_BC_Z(gqbar);
 		}
-		ScaLBL_D3Q19_AAeven_FreeLeeModel(dvcMap, gqbar, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB,
-				                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, 0, ScaLBL_Comm->LastExterior(), Np);
+		//ScaLBL_D3Q19_AAeven_FreeLeeModel(dvcMap, gqbar, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB,
+		//		                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, 0, ScaLBL_Comm->LastExterior(), Np);
+		ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(dvcMap, gqbar, hq, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, tauM,
+				                        kappa, beta, W, Fx, Fy, Fz, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
 		ScaLBL_Comm->Barrier();
 		//************************************************************************
 		PROFILE_STOP("Update");

From e4490231a1f3e6b7e7be2bdbfb93c3a5abc47283 Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Thu, 25 Mar 2021 02:09:31 -0400
Subject: [PATCH 13/19] fix a nuclear-level dumb typo

---
 models/FreeLeeModel.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/models/FreeLeeModel.cpp b/models/FreeLeeModel.cpp
index b08dc75b..ed8a6c0f 100644
--- a/models/FreeLeeModel.cpp
+++ b/models/FreeLeeModel.cpp
@@ -1,4 +1,4 @@
-u*
+/*
 color lattice boltzmann model
  */
 #include "models/FreeLeeModel.h"

From e73a466b5f0ccc461b2eae8950c4286b44b6ee8b Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Thu, 25 Mar 2021 08:18:22 -0400
Subject: [PATCH 14/19] fix a few dumb typo

---
 cpu/FreeLee.cpp         | 4 ++--
 models/FreeLeeModel.cpp | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/cpu/FreeLee.cpp b/cpu/FreeLee.cpp
index 0358af4a..5daac030 100644
--- a/cpu/FreeLee.cpp
+++ b/cpu/FreeLee.cpp
@@ -1686,7 +1686,7 @@ extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(int *neighborList, int
 		double mg_mag = sqrt(mgx*mgx+mgy*mgy+mgz*mgz);
 		if (mg_mag<1.0e-12) mgx=mgy=mgz=0.0;
         //TODO - maybe you can also de-noise chemical potential ? within the bulk phase chem should be ZERO
-        //if (fabs(chem)<1.0e-12) chem=0.0;
+        if (fabs(chem)<1.0e-12) chem=0.0;
 
 		// q=0
 		m0 = dist[n];
@@ -2302,7 +2302,7 @@ extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(int *Map, double *dist
 		double mg_mag = sqrt(mgx*mgx+mgy*mgy+mgz*mgz);
 		if (mg_mag<1.0e-12) mgx=mgy=mgz=0.0;
         //TODO - maybe you can also de-noise chemical potential ? within the bulk phase chem should be ZERO
-        //if (fabs(chem)<1.0e-12) chem=0.0;
+        if (fabs(chem)<1.0e-12) chem=0.0;
 
 		// q=0
 		m0 = dist[n];
diff --git a/models/FreeLeeModel.cpp b/models/FreeLeeModel.cpp
index ed8a6c0f..231e0c61 100644
--- a/models/FreeLeeModel.cpp
+++ b/models/FreeLeeModel.cpp
@@ -822,7 +822,7 @@ double ScaLBL_FreeLeeModel::Run_TwoFluid(int returntime){
 		//ScaLBL_D3Q19_AAodd_FreeLeeModel(NeighborList, dvcMap, gqbar, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB,
 		//		                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
 		ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(NeighborList, dvcMap, gqbar, hq, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, tauM,
-				                        kappa, beta, W, Fx, Fy, Fz, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+				                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
 		ScaLBL_Comm_WideHalo->Recv(Phi);
 		ScaLBL_Comm->RecvD3Q19AA(gqbar); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
@@ -843,7 +843,7 @@ double ScaLBL_FreeLeeModel::Run_TwoFluid(int returntime){
 		//ScaLBL_D3Q19_AAodd_FreeLeeModel(NeighborList, dvcMap, gqbar, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, 
 		//		                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, 0, ScaLBL_Comm->LastExterior(), Np);
 		ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(NeighborList, dvcMap, gqbar, hq, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, tauM,
-				                        kappa, beta, W, Fx, Fy, Fz, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
+				                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, 0, ScaLBL_Comm->LastExterior(), Np);
 		ScaLBL_Comm->Barrier(); 
 		
 				
@@ -872,7 +872,7 @@ double ScaLBL_FreeLeeModel::Run_TwoFluid(int returntime){
 		//ScaLBL_D3Q19_AAeven_FreeLeeModel(dvcMap, gqbar, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, 
 		//		                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
 		ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(dvcMap, gqbar, hq, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, tauM,
-				                        kappa, beta, W, Fx, Fy, Fz, Nx, Nx*Ny, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
+				                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, ScaLBL_Comm->FirstInterior(), ScaLBL_Comm->LastInterior(), Np);
 		ScaLBL_Comm_WideHalo->Recv(Phi);
 		ScaLBL_Comm->RecvD3Q19AA(gqbar); //WRITE INTO OPPOSITE
 		ScaLBL_Comm->Barrier();
@@ -892,7 +892,7 @@ double ScaLBL_FreeLeeModel::Run_TwoFluid(int returntime){
 		//ScaLBL_D3Q19_AAeven_FreeLeeModel(dvcMap, gqbar, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB,
 		//		                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, 0, ScaLBL_Comm->LastExterior(), Np);
 		ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(dvcMap, gqbar, hq, Den, Phi, mu_phi, Velocity, Pressure, ColorGrad, rhoA, rhoB, tauA, tauB, tauM,
-				                        kappa, beta, W, Fx, Fy, Fz, Nx, Nx*Ny, 0, ScaLBL_Comm->LastExterior(), Np);
+				                        kappa, beta, W, Fx, Fy, Fz, Nxh, Nxh*Nyh, 0, ScaLBL_Comm->LastExterior(), Np);
 		ScaLBL_Comm->Barrier();
 		//************************************************************************
 		PROFILE_STOP("Update");

From ea64630cc77ade246dbcc83e397137f12941104b Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Thu, 25 Mar 2021 23:07:01 -0400
Subject: [PATCH 15/19] further regulate the phase field

---
 cpu/FreeLee.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/cpu/FreeLee.cpp b/cpu/FreeLee.cpp
index 5daac030..1e2fc04d 100644
--- a/cpu/FreeLee.cpp
+++ b/cpu/FreeLee.cpp
@@ -161,6 +161,9 @@ extern "C" void ScaLBL_D3Q7_AAodd_FreeLeeModel_PhaseField(int *neighborList, int
 		fq = hq[nread];
 		phi += fq;
 		
+		if (phi > 1.f)   phi = 1.0;
+		if (phi < -1.f)  phi = -1.0;
+
 		// save the number densities
 		Den[n] = rhoA + 0.5*(1.0-phi)*(rhoB-rhoA);
 		
@@ -207,6 +210,9 @@ extern "C" void ScaLBL_D3Q7_AAeven_FreeLeeModel_PhaseField(int *Map, double *hq,
 		fq = hq[5*Np+n];
 		phi += fq;
 
+		if (phi > 1.f)   phi = 1.0;
+		if (phi < -1.f)  phi = -1.0;
+
 		// save the number densities
 		Den[n] = rhoA + 0.5*(1.0-phi)*(rhoB-rhoA);
 		

From f02cf7abc491c7a4bb6faecb33d4d58b5dbd1d78 Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Sun, 28 Mar 2021 21:26:01 -0400
Subject: [PATCH 16/19] remove the phase field denoise since it ruins mass
 conservation

---
 cpu/FreeLee.cpp | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/cpu/FreeLee.cpp b/cpu/FreeLee.cpp
index 1e2fc04d..5daac030 100644
--- a/cpu/FreeLee.cpp
+++ b/cpu/FreeLee.cpp
@@ -161,9 +161,6 @@ extern "C" void ScaLBL_D3Q7_AAodd_FreeLeeModel_PhaseField(int *neighborList, int
 		fq = hq[nread];
 		phi += fq;
 		
-		if (phi > 1.f)   phi = 1.0;
-		if (phi < -1.f)  phi = -1.0;
-
 		// save the number densities
 		Den[n] = rhoA + 0.5*(1.0-phi)*(rhoB-rhoA);
 		
@@ -210,9 +207,6 @@ extern "C" void ScaLBL_D3Q7_AAeven_FreeLeeModel_PhaseField(int *Map, double *hq,
 		fq = hq[5*Np+n];
 		phi += fq;
 
-		if (phi > 1.f)   phi = 1.0;
-		if (phi < -1.f)  phi = -1.0;
-
 		// save the number densities
 		Den[n] = rhoA + 0.5*(1.0-phi)*(rhoB-rhoA);
 		

From e87db53a019bb93566020e035950e0fbb8e2fb56 Mon Sep 17 00:00:00 2001
From: Rex Zhe Li <zhe.rex.li@gmail.com>
Date: Mon, 29 Mar 2021 23:28:26 -0400
Subject: [PATCH 17/19] apply the phase denoise without affecting the mass
 conservation

---
 cpu/FreeLee.cpp | 30 ++++++++++++++++++++++--------
 1 file changed, 22 insertions(+), 8 deletions(-)

diff --git a/cpu/FreeLee.cpp b/cpu/FreeLee.cpp
index 5daac030..98613f5c 100644
--- a/cpu/FreeLee.cpp
+++ b/cpu/FreeLee.cpp
@@ -1523,6 +1523,7 @@ extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(int *neighborList, int
 	double tau;//position dependent LB relaxation time for fluid
     double C,theta;
     double M = 2.0/9.0*(tauM-0.5);//diffusivity (or mobility) for the phase field D3Q7
+    double phi_temp;
 
 	for (int n=start; n<finish; n++){
 
@@ -1531,6 +1532,9 @@ extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(int *neighborList, int
 		// Get the 1D index based on regular data layout
 		ijk = Map[n];
         phi = Phi[ijk];// load phase field
+        phi_temp = phi;
+        if (phi>1.f) phi_temp=1.0;
+        if (phi<-1.f) phi_temp=-1.0;
 
 		// local relaxation time
 		tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
@@ -1673,8 +1677,10 @@ extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(int *neighborList, int
 		ny = -3.0*1.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
 		nz = -3.0*1.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
 		//............Compute the Chemical Potential...............................
-        chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi));//intermediate var, i.e. the laplacian
-        chem = 4.0*beta*phi*(phi+1.0)*(phi-1.0)-kappa*chem;
+        //chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi));//intermediate var, i.e. the laplacian
+        //chem = 4.0*beta*phi*(phi+1.0)*(phi-1.0)-kappa*chem;
+        chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi_temp+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi_temp));//intermediate var, i.e. the laplacian
+        chem = 4.0*beta*phi_temp*(phi_temp+1.0)*(phi_temp-1.0)-kappa*chem;
 		//............Compute the Mixed Gradient...................................
 		mgx = -3.0*1.0/18.0*(mm1-mm2+0.5*(mm7-mm8+mm9-mm10+mm11-mm12+mm13-mm14));
 		mgy = -3.0*1.0/18.0*(mm3-mm4+0.5*(mm7-mm8-mm9+mm10+mm15-mm16+mm17-mm18));
@@ -1685,7 +1691,7 @@ extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(int *neighborList, int
 		if (C<1.0e-12) nx=ny=nz=0.0;
 		double mg_mag = sqrt(mgx*mgx+mgy*mgy+mgz*mgz);
 		if (mg_mag<1.0e-12) mgx=mgy=mgz=0.0;
-        //TODO - maybe you can also de-noise chemical potential ? within the bulk phase chem should be ZERO
+        //maybe you can also de-noise chemical potential ? within the bulk phase chem should be ZERO
         if (fabs(chem)<1.0e-12) chem=0.0;
 
 		// q=0
@@ -2052,7 +2058,8 @@ extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(int *neighborList, int
 		ny = ny/ColorMag;
 		nz = nz/ColorMag;		
         //compute surface tension-related parameter
-        theta = 4.5*M*2.0*(1-phi*phi)/W;
+        //theta = 4.5*M*2.0*(1-phi*phi)/W;
+        theta = 4.5*M*2.0*(1-phi_temp*phi_temp)/W;
 
         //load distributions of phase field
 		//q=0
@@ -2139,6 +2146,7 @@ extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(int *Map, double *dist
 	double tau;//position dependent LB relaxation time for fluid
     double C,theta;
     double M = 2.0/9.0*(tauM-0.5);//diffusivity (or mobility) for the phase field D3Q7
+    double phi_temp;
 
 	for (int n=start; n<finish; n++){
 
@@ -2147,6 +2155,9 @@ extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(int *Map, double *dist
 		// Get the 1D index based on regular data layout
 		ijk = Map[n];
         phi = Phi[ijk];// load phase field
+        phi_temp = phi;
+        if (phi>1.f) phi_temp=1.0;
+        if (phi<-1.f) phi_temp=-1.0;
 
 		// local relaxation time
 		tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
@@ -2289,8 +2300,10 @@ extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(int *Map, double *dist
 		ny = -3.0*1.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
 		nz = -3.0*1.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
 		//............Compute the Chemical Potential...............................
-        chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi));//intermediate var, i.e. the laplacian
-        chem = 4.0*beta*phi*(phi+1.0)*(phi-1.0)-kappa*chem;
+        //chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi));//intermediate var, i.e. the laplacian
+        //chem = 4.0*beta*phi*(phi+1.0)*(phi-1.0)-kappa*chem;
+        chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi_temp+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi_temp));//intermediate var, i.e. the laplacian
+        chem = 4.0*beta*phi_temp*(phi_temp+1.0)*(phi_temp-1.0)-kappa*chem;
 		//............Compute the Mixed Gradient...................................
 		mgx = -3.0*1.0/18.0*(mm1-mm2+0.5*(mm7-mm8+mm9-mm10+mm11-mm12+mm13-mm14));
 		mgy = -3.0*1.0/18.0*(mm3-mm4+0.5*(mm7-mm8-mm9+mm10+mm15-mm16+mm17-mm18));
@@ -2301,7 +2314,7 @@ extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(int *Map, double *dist
 		if (C<1.0e-12) nx=ny=nz=0.0;
 		double mg_mag = sqrt(mgx*mgx+mgy*mgy+mgz*mgz);
 		if (mg_mag<1.0e-12) mgx=mgy=mgz=0.0;
-        //TODO - maybe you can also de-noise chemical potential ? within the bulk phase chem should be ZERO
+        //maybe you can also de-noise chemical potential ? within the bulk phase chem should be ZERO
         if (fabs(chem)<1.0e-12) chem=0.0;
 
 		// q=0
@@ -2651,7 +2664,8 @@ extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(int *Map, double *dist
 		ny = ny/ColorMag;
 		nz = nz/ColorMag;		
         //compute surface tension-related parameter
-        theta = 4.5*M*2.0*(1-phi*phi)/W;
+        //theta = 4.5*M*2.0*(1-phi*phi)/W;
+        theta = 4.5*M*2.0*(1-phi_temp*phi_temp)/W;
 
         //load distributions of phase field
 		//q=0

From a1b82b2aa4c8a9f4e221d95555348ad5c86ee3ef Mon Sep 17 00:00:00 2001
From: James McClure <jemcclur@gmail.com>
Date: Wed, 31 Mar 2021 11:19:13 -0400
Subject: [PATCH 18/19] updated cuda version for Lee model

---
 cuda/FreeLee.cu | 1306 ++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 1290 insertions(+), 16 deletions(-)

diff --git a/cuda/FreeLee.cu b/cuda/FreeLee.cu
index 45bbf65b..bed05515 100644
--- a/cuda/FreeLee.cu
+++ b/cuda/FreeLee.cu
@@ -118,8 +118,10 @@ __global__ void dvc_ScaLBL_FreeLeeModel_PhaseField_Init(int *Map, double *Phi, d
 		ny = ny/ColorMag_temp;
 		nz = nz/ColorMag_temp;		
 
-        theta = M*cs2_inv*(1-4.0*phi*phi)/W;
-
+        //theta = M*cs2_inv*(1-factor*phi*phi)/W;
+        theta = 4.5*M*2.0*(1-phi*phi)/W;
+        //theta = 0; // try more diffusive initial condition
+        
 		hq[0*Np+idx]=0.3333333333333333*(phi);
 		hq[1*Np+idx]=0.1111111111111111*(phi+theta*nx);
 		hq[2*Np+idx]=0.1111111111111111*(phi-theta*nx);
@@ -127,7 +129,6 @@ __global__ void dvc_ScaLBL_FreeLeeModel_PhaseField_Init(int *Map, double *Phi, d
 		hq[4*Np+idx]=0.1111111111111111*(phi-theta*ny);
 		hq[5*Np+idx]=0.1111111111111111*(phi+theta*nz);
 		hq[6*Np+idx]=0.1111111111111111*(phi-theta*nz);
-		
 	}
 }
 
@@ -204,10 +205,10 @@ __global__ void dvc_ScaLBL_D3Q7_AAodd_FreeLee_PhaseField(int *neighborList, int
 		n = S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x + start;
 
 		if ( n<finish ){		
-
 			/* load phase indicator field */
 			idx = Map[n];
 			phi = Phi[idx];
+	        theta = 4.5*M*2.0*(1-phi*phi)/W;
 
 			/* velocity */
 			ux = Vel[0*Np+n];
@@ -252,12 +253,18 @@ __global__ void dvc_ScaLBL_D3Q7_AAodd_FreeLee_PhaseField(int *neighborList, int
 
 	        //-------------------------------- BGK collison for phase field ---------------------------------//
 			h0 -= (h0 - 0.3333333333333333*phi)/tauM;
-			h1 -= (h1 - phi*(0.1111111111111111 + 0.5*ux) - (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
-			h2 -= (h2 - phi*(0.1111111111111111 - 0.5*ux) + (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
-			h3 -= (h3 - phi*(0.1111111111111111 + 0.5*uy) - (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
-			h4 -= (h4 - phi*(0.1111111111111111 - 0.5*uy) + (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
-			h5 -= (h5 - phi*(0.1111111111111111 + 0.5*uz) - (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
-			h6 -= (h6 - phi*(0.1111111111111111 - 0.5*uz) + (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+	//		h1 -= (h1 - phi*(0.1111111111111111 + 0.5*ux) - (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
+	//		h2 -= (h2 - phi*(0.1111111111111111 - 0.5*ux) + (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
+	//		h3 -= (h3 - phi*(0.1111111111111111 + 0.5*uy) - (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
+	//		h4 -= (h4 - phi*(0.1111111111111111 - 0.5*uy) + (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
+	//		h5 -= (h5 - phi*(0.1111111111111111 + 0.5*uz) - (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+	//		h6 -= (h6 - phi*(0.1111111111111111 - 0.5*uz) + (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+			h1 -= (h1 - 0.1111111111111111*nx*theta - phi*(0.1111111111111111 + 0.5*ux))/tauM;
+			h2 -= (h2 + 0.1111111111111111*nx*theta - phi*(0.1111111111111111 - 0.5*ux))/tauM;
+			h3 -= (h3 - 0.1111111111111111*ny*theta - phi*(0.1111111111111111 + 0.5*uy))/tauM;
+			h4 -= (h4 + 0.1111111111111111*ny*theta - phi*(0.1111111111111111 - 0.5*uy))/tauM;
+			h5 -= (h5 - 0.1111111111111111*nz*theta - phi*(0.1111111111111111 + 0.5*uz))/tauM;
+			h6 -= (h6 + 0.1111111111111111*nz*theta - phi*(0.1111111111111111 - 0.5*uz))/tauM; 
 			//........................................................................
 			
 			/*Update the distributions */
@@ -295,6 +302,7 @@ __global__ void dvc_ScaLBL_D3Q7_AAeven_FreeLee_PhaseField( int *Map, double *hq,
 			/* load phase indicator field */
 			idx = Map[n];
 			phi = Phi[idx];
+	        theta = 4.5*M*2.0*(1-phi*phi)/W;
 
 			/* velocity */
 			ux = Vel[0*Np+n];
@@ -323,12 +331,18 @@ __global__ void dvc_ScaLBL_D3Q7_AAeven_FreeLee_PhaseField( int *Map, double *hq,
 
 			//-------------------------------- BGK collison for phase field ---------------------------------//
 			h0 -= (h0 - 0.3333333333333333*phi)/tauM;
-			h1 -= (h1 - phi*(0.1111111111111111 + 0.5*ux) - (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
-			h2 -= (h2 - phi*(0.1111111111111111 - 0.5*ux) + (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
-			h3 -= (h3 - phi*(0.1111111111111111 + 0.5*uy) - (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
-			h4 -= (h4 - phi*(0.1111111111111111 - 0.5*uy) + (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
-			h5 -= (h5 - phi*(0.1111111111111111 + 0.5*uz) - (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
-			h6 -= (h6 - phi*(0.1111111111111111 - 0.5*uz) + (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+	//		h1 -= (h1 - phi*(0.1111111111111111 + 0.5*ux) - (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
+	//		h2 -= (h2 - phi*(0.1111111111111111 - 0.5*ux) + (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
+	//		h3 -= (h3 - phi*(0.1111111111111111 + 0.5*uy) - (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
+	//		h4 -= (h4 - phi*(0.1111111111111111 - 0.5*uy) + (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
+	//		h5 -= (h5 - phi*(0.1111111111111111 + 0.5*uz) - (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+	//		h6 -= (h6 - phi*(0.1111111111111111 - 0.5*uz) + (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+			h1 -= (h1 - 0.1111111111111111*nx*theta - phi*(0.1111111111111111 + 0.5*ux))/tauM;
+			h2 -= (h2 + 0.1111111111111111*nx*theta - phi*(0.1111111111111111 - 0.5*ux))/tauM;
+			h3 -= (h3 - 0.1111111111111111*ny*theta - phi*(0.1111111111111111 + 0.5*uy))/tauM;
+			h4 -= (h4 + 0.1111111111111111*ny*theta - phi*(0.1111111111111111 - 0.5*uy))/tauM;
+			h5 -= (h5 - 0.1111111111111111*nz*theta - phi*(0.1111111111111111 + 0.5*uz))/tauM;
+			h6 -= (h6 + 0.1111111111111111*nz*theta - phi*(0.1111111111111111 - 0.5*uz))/tauM; 
 			//........................................................................
 
 			/*Update the distributions */
@@ -1474,6 +1488,1242 @@ __global__ void dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel(int *Map, double *dist, dou
 	}
 }
 
+
+
+__global__ void dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(int *neighborList, int *Map, double *dist, double *hq, double *Den,	double *Phi, double *mu_phi, double *Vel, double *Pressure, double *ColorGrad, 
+        double rhoA, double rhoB, double tauA, double tauB, double tauM, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
+        int strideY, int strideZ, int start, int finish, int Np){
+
+	int nr1,nr2,nr3,nr4,nr5,nr6,nr7,nr8,nr9,nr10,nr11,nr12,nr13,nr14,nr15,nr16,nr17,nr18;
+    double ux,uy,uz;//fluid velocity 
+    double p;//pressure
+    double chem;//chemical potential
+    double phi; //phase field
+    double rho0;//fluid density
+	// distribution functions
+	double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
+	double m0,m3,m5,m7;
+	double mm1,mm2,mm4,mm6,mm8,mm9,mm10,mm11,mm12,mm13,mm14,mm15,mm16,mm17,mm18;
+	double mm3,mm5,mm7;
+    double feq0,feq1,feq2,feq3,feq4,feq5,feq6,feq7,feq8,feq9,feq10,feq11,feq12,feq13,feq14,feq15,feq16,feq17,feq18;
+    double nx,ny,nz;//normal color gradient
+    double mgx,mgy,mgz;//mixed gradient reaching secondary neighbor
+
+	//double f0,f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18;
+    double h0,h1,h2,h3,h4,h5,h6;//distributions for LB phase field
+	double tau;//position dependent LB relaxation time for fluid
+    double C,theta;
+    double M = 2.0/9.0*(tauM-0.5);//diffusivity (or mobility) for the phase field D3Q7
+    double phi_temp;
+    
+    int S = Np/NBLOCKS/NTHREADS + 1;
+    for (int s=0; s<S; s++){
+
+		rho0 = Den[n];//load density
+
+		// Get the 1D index based on regular data layout
+		ijk = Map[n];
+        phi = Phi[ijk];// load phase field
+        phi_temp = phi;
+        if (phi>1.f) phi_temp=1.0;
+        if (phi<-1.f) phi_temp=-1.0;
+
+		// local relaxation time
+		tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
+
+		//					COMPUTE THE COLOR GRADIENT
+		//........................................................................
+		//.................Read Phase Indicator Values............................
+		//........................................................................
+		nn = ijk-1;							// neighbor index (get convention)
+		m1 = Phi[nn];						// get neighbor for phi - 1
+		//........................................................................
+		nn = ijk+1;							// neighbor index (get convention)
+		m2 = Phi[nn];						// get neighbor for phi - 2
+		//........................................................................
+		nn = ijk-strideY;							// neighbor index (get convention)
+		m3 = Phi[nn];					// get neighbor for phi - 3
+		//........................................................................
+		nn = ijk+strideY;							// neighbor index (get convention)
+		m4 = Phi[nn];					// get neighbor for phi - 4
+		//........................................................................
+		nn = ijk-strideZ;						// neighbor index (get convention)
+		m5 = Phi[nn];					// get neighbor for phi - 5
+		//........................................................................
+		nn = ijk+strideZ;						// neighbor index (get convention)
+		m6 = Phi[nn];					// get neighbor for phi - 6
+		//........................................................................
+		nn = ijk-strideY-1;						// neighbor index (get convention)
+		m7 = Phi[nn];					// get neighbor for phi - 7
+		//........................................................................
+		nn = ijk+strideY+1;						// neighbor index (get convention)
+		m8 = Phi[nn];					// get neighbor for phi - 8
+		//........................................................................
+		nn = ijk+strideY-1;						// neighbor index (get convention)
+		m9 = Phi[nn];					// get neighbor for phi - 9
+		//........................................................................
+		nn = ijk-strideY+1;						// neighbor index (get convention)
+		m10 = Phi[nn];					// get neighbor for phi - 10
+		//........................................................................
+		nn = ijk-strideZ-1;						// neighbor index (get convention)
+		m11 = Phi[nn];					// get neighbor for phi - 11
+		//........................................................................
+		nn = ijk+strideZ+1;						// neighbor index (get convention)
+		m12 = Phi[nn];					// get neighbor for phi - 12
+		//........................................................................
+		nn = ijk+strideZ-1;						// neighbor index (get convention)
+		m13 = Phi[nn];					// get neighbor for phi - 13
+		//........................................................................
+		nn = ijk-strideZ+1;						// neighbor index (get convention)
+		m14 = Phi[nn];					// get neighbor for phi - 14
+		//........................................................................
+		nn = ijk-strideZ-strideY;					// neighbor index (get convention)
+		m15 = Phi[nn];					// get neighbor for phi - 15
+		//........................................................................
+		nn = ijk+strideZ+strideY;					// neighbor index (get convention)
+		m16 = Phi[nn];					// get neighbor for phi - 16
+		//........................................................................
+		nn = ijk+strideZ-strideY;					// neighbor index (get convention)
+		m17 = Phi[nn];					// get neighbor for phi - 17
+		//........................................................................
+		nn = ijk-strideZ+strideY;					// neighbor index (get convention)
+		m18 = Phi[nn];					// get neighbor for phi - 18
+
+        // compute mixed difference (Eq.30, A.Fukhari et al. JCP 315(2016) 434-457)
+		//........................................................................
+		nn2x = ijk-2;							// neighbor index (get convention)
+		mm1 = Phi[nn2x];						// get neighbor for phi - 1
+        mm1 = 0.25*(-mm1+5.0*m1-3.0*phi-m2);
+		//........................................................................
+		nn2x = ijk+2;							// neighbor index (get convention)
+		mm2 = Phi[nn2x];						// get neighbor for phi - 2
+        mm2 = 0.25*(-mm2+5.0*m2-3.0*phi-m1);
+		//........................................................................
+		nn2x = ijk-strideY*2;							// neighbor index (get convention)
+		mm3 = Phi[nn2x];					// get neighbor for phi - 3
+        mm3 = 0.25*(-mm3+5.0*m3-3.0*phi-m4);
+		//........................................................................
+		nn2x = ijk+strideY*2;							// neighbor index (get convention)
+		mm4 = Phi[nn2x];					// get neighbor for phi - 4
+        mm4 = 0.25*(-mm4+5.0*m4-3.0*phi-m3);
+		//........................................................................
+		nn2x = ijk-strideZ*2;						// neighbor index (get convention)
+		mm5 = Phi[nn2x];					// get neighbor for phi - 5
+        mm5 = 0.25*(-mm5+5.0*m5-3.0*phi-m6);
+		//........................................................................
+		nn2x = ijk+strideZ*2;						// neighbor index (get convention)
+		mm6 = Phi[nn2x];					// get neighbor for phi - 6
+        mm6 = 0.25*(-mm6+5.0*m6-3.0*phi-m5);
+		//........................................................................
+		nn2x = ijk-strideY*2-2;						// neighbor index (get convention)
+		mm7 = Phi[nn2x];					// get neighbor for phi - 7
+        mm7 = 0.25*(-mm7+5.0*m7-3.0*phi-m8);
+		//........................................................................
+		nn2x = ijk+strideY*2+2;						// neighbor index (get convention)
+		mm8 = Phi[nn2x];					// get neighbor for phi - 8
+        mm8 = 0.25*(-mm8+5.0*m8-3.0*phi-m7);
+		//........................................................................
+		nn2x = ijk+strideY*2-2;						// neighbor index (get convention)
+		mm9 = Phi[nn2x];					// get neighbor for phi - 9
+        mm9 = 0.25*(-mm9+5.0*m9-3.0*phi-m10);
+		//........................................................................
+		nn2x = ijk-strideY*2+2;						// neighbor index (get convention)
+		mm10 = Phi[nn2x];					// get neighbor for phi - 10
+        mm10 = 0.25*(-mm10+5.0*m10-3.0*phi-m9);
+		//........................................................................
+		nn2x = ijk-strideZ*2-2;						// neighbor index (get convention)
+		mm11 = Phi[nn2x];					// get neighbor for phi - 11
+        mm11 = 0.25*(-mm11+5.0*m11-3.0*phi-m12);
+		//........................................................................
+		nn2x = ijk+strideZ*2+2;						// neighbor index (get convention)
+		mm12 = Phi[nn2x];					// get neighbor for phi - 12
+        mm12 = 0.25*(-mm12+5.0*m12-3.0*phi-m11);
+		//........................................................................
+		nn2x = ijk+strideZ*2-2;						// neighbor index (get convention)
+		mm13 = Phi[nn2x];					// get neighbor for phi - 13
+        mm13 = 0.25*(-mm13+5.0*m13-3.0*phi-m14);
+		//........................................................................
+		nn2x = ijk-strideZ*2+2;						// neighbor index (get convention)
+		mm14 = Phi[nn2x];					// get neighbor for phi - 14
+        mm14 = 0.25*(-mm14+5.0*m14-3.0*phi-m13);
+		//........................................................................
+		nn2x = ijk-strideZ*2-strideY*2;					// neighbor index (get convention)
+		mm15 = Phi[nn2x];					// get neighbor for phi - 15
+        mm15 = 0.25*(-mm15+5.0*m15-3.0*phi-m16);
+		//........................................................................
+		nn2x = ijk+strideZ*2+strideY*2;					// neighbor index (get convention)
+		mm16 = Phi[nn2x];					// get neighbor for phi - 16
+        mm16 = 0.25*(-mm16+5.0*m16-3.0*phi-m15);
+		//........................................................................
+		nn2x = ijk+strideZ*2-strideY*2;					// neighbor index (get convention)
+		mm17 = Phi[nn2x];					// get neighbor for phi - 17
+        mm17 = 0.25*(-mm17+5.0*m17-3.0*phi-m18);
+		//........................................................................
+		nn2x = ijk-strideZ*2+strideY*2;					// neighbor index (get convention)
+		mm18 = Phi[nn2x];					// get neighbor for phi - 18
+        mm18 = 0.25*(-mm18+5.0*m18-3.0*phi-m17);
+
+
+		//............Compute the Color Gradient...................................
+		nx = -3.0*1.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+		ny = -3.0*1.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+		nz = -3.0*1.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+		//............Compute the Chemical Potential...............................
+        //chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi));//intermediate var, i.e. the laplacian
+        //chem = 4.0*beta*phi*(phi+1.0)*(phi-1.0)-kappa*chem;
+        chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi_temp+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi_temp));//intermediate var, i.e. the laplacian
+        chem = 4.0*beta*phi_temp*(phi_temp+1.0)*(phi_temp-1.0)-kappa*chem;
+		//............Compute the Mixed Gradient...................................
+		mgx = -3.0*1.0/18.0*(mm1-mm2+0.5*(mm7-mm8+mm9-mm10+mm11-mm12+mm13-mm14));
+		mgy = -3.0*1.0/18.0*(mm3-mm4+0.5*(mm7-mm8-mm9+mm10+mm15-mm16+mm17-mm18));
+		mgz = -3.0*1.0/18.0*(mm5-mm6+0.5*(mm11-mm12-mm13+mm14+mm15-mm16-mm17+mm18));
+		
+        //de-noise color gradient and mixed gradient
+		C = sqrt(nx*nx+ny*ny+nz*nz);
+		if (C<1.0e-12) nx=ny=nz=0.0;
+		double mg_mag = sqrt(mgx*mgx+mgy*mgy+mgz*mgz);
+		if (mg_mag<1.0e-12) mgx=mgy=mgz=0.0;
+        //maybe you can also de-noise chemical potential ? within the bulk phase chem should be ZERO
+        if (fabs(chem)<1.0e-12) chem=0.0;
+
+		// q=0
+		m0 = dist[n];
+		// q=1
+		nr1 = neighborList[n]; // neighbor 2 ( > 10Np => odd part of dist)
+		m1 = dist[nr1]; // reading the f1 data into register fq
+
+		nr2 = neighborList[n+Np]; // neighbor 1 ( < 10Np => even part of dist)
+		m2 = dist[nr2];  // reading the f2 data into register fq
+
+		// q=3
+		nr3 = neighborList[n+2*Np]; // neighbor 4
+		m3 = dist[nr3];
+
+		// q = 4
+		nr4 = neighborList[n+3*Np]; // neighbor 3
+		m4 = dist[nr4];
+
+		// q=5
+		nr5 = neighborList[n+4*Np];
+		m5 = dist[nr5];
+
+		// q = 6
+		nr6 = neighborList[n+5*Np];
+		m6 = dist[nr6];
+		
+		// q=7
+		nr7 = neighborList[n+6*Np];
+		m7 = dist[nr7];
+
+		// q = 8
+		nr8 = neighborList[n+7*Np];
+		m8 = dist[nr8];
+
+		// q=9
+		nr9 = neighborList[n+8*Np];
+		m9 = dist[nr9];
+
+		// q = 10
+		nr10 = neighborList[n+9*Np];
+		m10 = dist[nr10];
+
+		// q=11
+		nr11 = neighborList[n+10*Np];
+		m11 = dist[nr11];
+
+		// q=12
+		nr12 = neighborList[n+11*Np];
+		m12 = dist[nr12];
+
+		// q=13
+		nr13 = neighborList[n+12*Np];
+		m13 = dist[nr13];
+
+		// q=14
+		nr14 = neighborList[n+13*Np];
+		m14 = dist[nr14];
+
+		// q=15
+		nr15 = neighborList[n+14*Np];
+		m15 = dist[nr15];
+
+		// q=16
+		nr16 = neighborList[n+15*Np];
+		m16 = dist[nr16];
+
+		// q=17
+		nr17 = neighborList[n+16*Np];
+		m17 = dist[nr17];
+
+		// q=18
+		nr18 = neighborList[n+17*Np];
+		m18 = dist[nr18];
+
+        //compute fluid velocity
+        ux = 3.0/rho0*(m1-m2+m7-m8+m9-m10+m11-m12+m13-m14+0.5*(chem*nx+Fx)/3.0);
+        uy = 3.0/rho0*(m3-m4+m7-m8-m9+m10+m15-m16+m17-m18+0.5*(chem*ny+Fy)/3.0);
+        uz = 3.0/rho0*(m5-m6+m11-m12-m13+m14+m15-m16-m17+m18+0.5*(chem*nz+Fz)/3.0);
+        //compute pressure
+        p = (m0+m2+m1+m4+m3+m6+m5+m8+m7+m10+m9+m12+m11+m14+m13+m16+m15+m18+m17)
+                  +0.5*(rhoA-rhoB)/2.0/3.0*(ux*nx+uy*ny+uz*nz);
+
+        //compute equilibrium distributions
+            feq0 = 0.3333333333333333*p - 0.25*(Fx*ux + Fy*uy + Fz*uz)*(-0.6666666666666666 + ux*ux + uy*uy + uz*uz) - 
+     0.16666666666666666*rho0*(ux*ux + uy*uy + uz*uz) - 0.5*(-(nx*ux) - ny*uy - nz*uz)*
+      (-0.08333333333333333*(rhoA - rhoB)*(ux*ux + uy*uy + uz*uz) + chem*(0.3333333333333333 - 0.5*(ux*ux + uy*uy + uz*uz)));
+            feq1 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-ux*ux + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*uz)) - 
+     0.125*(Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 
+       0.3333333333333333*(-2.*ux + ux*ux + uy*uy + uz*uz)) - 0.0625*(nx - nx*ux - ny*uy - nz*uz)*
+      (2*chem*ux*ux - 0.3333333333333333*((-rhoA + rhoB)*ux*ux + 2*chem*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*uz)));
+            feq2 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-ux*ux + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*uz)) - 
+     0.125*(Fx + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 
+       0.3333333333333333*(2.*ux + ux*ux + uy*uy + uz*uz)) - 0.0625*(nx + nx*ux + ny*uy + nz*uz)*
+      (-2.*chem*ux*ux + 0.1111111111111111*(-4.*chem + rhoB*(-2.*ux - 1.*ux*ux - 1.*uy*uy - 1.*uz*uz) + 
+         rhoA*(2.*ux + ux*ux + uy*uy + uz*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*ux*ux + 
+         chem*(4.*ux + 2.*ux*ux + 2.*uy*uy + 2.*uz*uz)));
+            feq3 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uy*uy + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*uz)) - 
+     0.125*(Fx*ux + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 
+       0.3333333333333333*(ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.0625*(ny - nx*ux - ny*uy - nz*uz)*
+      (2*chem*uy*uy - 0.3333333333333333*((-rhoA + rhoB)*uy*uy + 2*chem*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*uz)));
+            feq4 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uy*uy + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*uz)) - 
+     0.125*(Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 
+       0.3333333333333333*(ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.0625*(ny + nx*ux + ny*uy + nz*uz)*
+      (-2.*chem*uy*uy + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 2.*uy - 1.*uy*uy - 1.*uz*uz) + 
+         rhoA*(ux*ux + 2.*uy + uy*uy + uz*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*uy*uy + 
+         chem*(2.*ux*ux + 4.*uy + 2.*uy*uy + 2.*uz*uz))); 
+            feq5 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uz*uz + 0.3333333333333333*(ux*ux + uy*uy + (-2 + uz)*uz)) - 
+     0.125*(Fx*ux + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + uy*uy + (-2. + uz)*uz)) - 0.0625*(nx*ux + ny*uy + nz*(-1. + uz))*
+      (-2.*chem*uz*uz + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 1.*uy*uy + (2. - 1.*uz)*uz) + 
+         rhoA*(ux*ux + uy*uy + (-2. + uz)*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*uz*uz + 
+         chem*(2.*ux*ux + 2.*uy*uy + uz*(-4. + 2.*uz)))); 
+            feq6 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uz*uz + 0.3333333333333333*(ux*ux + uy*uy + uz*(2 + uz))) - 
+     0.125*(Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + uy*uy + uz*(2. + uz))) - 0.0625*(nz + nx*ux + ny*uy + nz*uz)*
+      (-2.*chem*uz*uz + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 1.*uy*uy + (-2. - 1.*uz)*uz) + 
+         rhoA*(ux*ux + uy*uy + uz*(2. + uz))) + 0.3333333333333333*((-1.*rhoA + rhoB)*uz*uz + 
+         chem*(2.*ux*ux + 2.*uy*uy + uz*(4. + 2.*uz)))); 
+            feq7 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uy)*(ux + uy) + 0.3333333333333333*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fx*(-1. + ux) + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(-2.*ux + ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.03125*(nx + ny - nx*ux - ny*uy - nz*uz)*
+      (2*chem*(ux + uy)*(ux + uy) + 0.3333333333333333*((rhoA - rhoB)*(ux + uy)*(ux + uy) - 2*chem*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz))); 
+            feq8 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uy)*(ux + uy) + 0.3333333333333333*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fx + Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(2.*ux + ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.03125*(-(nx*(1 + ux)) - ny*(1 + uy) - nz*uz)*
+      (2*chem*(ux + uy)*(ux + uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux + uy)*(ux + uy)) + 
+         2*chem*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz))); 
+            feq9 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uy)*(ux - uy) + 0.3333333333333333*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fy + Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(-2.*ux + ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.03125*(nx - nx*ux - ny*(1 + uy) - nz*uz)*
+      (2*chem*(ux - uy)*(ux - uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uy)*(ux - uy)) + 
+         2*chem*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz))); 
+            feq10 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uy)*(ux - uy) + 0.3333333333333333*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fx*(1 + ux) + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(2.*ux + ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.03125*(ny - nx*(1 + ux) - ny*uy - nz*uz)*
+      (2*chem*(ux - uy)*(ux - uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uy)*(ux - uy)) + 
+         2*chem*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz))); 
+            feq11 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uz)*(ux + uz) + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*(-1. + ux) + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(-2.*ux + ux*ux + uy*uy + (-2. + uz)*uz)) - 0.03125*(nx + nz - nx*ux - ny*uy - nz*uz)*
+      (2*chem*(ux + uz)*(ux + uz) + 0.3333333333333333*((rhoA - rhoB)*(ux + uz)*(ux + uz) - 2*chem*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz))); 
+            feq12 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uz)*(ux + uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fx + Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(2.*ux + ux*ux + uy*uy + uz*(2. + uz))) - 0.03125*(-(nx*(1 + ux)) - ny*uy - nz*(1 + uz))*
+      (2*chem*(ux + uz)*(ux + uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux + uz)*(ux + uz)) + 
+         2*chem*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))); 
+            feq13 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uz)*(ux - uz) + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fz + Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(-2.*ux + ux*ux + uy*uy + uz*(2. + uz))) - 0.03125*(nx - nx*ux - ny*uy - nz*(1 + uz))*
+      (2*chem*(ux - uz)*(ux - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uz)*(ux - uz)) + 
+         2*chem*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*(2 + uz)))); 
+            feq14 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uz)*(ux - uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*(1 + ux) + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(2.*ux + ux*ux + uy*uy + (-2. + uz)*uz)) - 0.03125*(nz - nx*(1 + ux) - ny*uy - nz*uz)*
+      (2*chem*(ux - uz)*(ux - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uz)*(ux - uz)) + 
+         2*chem*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz))); 
+            feq15 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*ux + Fy*(-1. + uy) + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uy*uy - 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux - 2.*uy + uy*uy + (-2. + uz)*uz)) - 0.03125*(ny + nz - nx*ux - ny*uy - nz*uz)*
+      (2*chem*(uy + uz)*(uy + uz) + 0.3333333333333333*((rhoA - rhoB)*(uy + uz)*(uy + uz) - 2*chem*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))); 
+            feq16 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fy + Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy - 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + 2.*uy + uy*uy + uz*(2. + uz))) - 0.03125*(-(nx*ux) - ny*(1 + uy) - nz*(1 + uz))*
+      (2*chem*(uy + uz)*(uy + uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy + uz)*(uy + uz)) + 
+         2*chem*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))); 
+            feq17 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fz + Fx*ux + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux - 2.*uy + uy*uy + uz*(2. + uz))) - 0.03125*(ny - nx*ux - ny*uy - nz*(1 + uz))*
+      (2*chem*(uy - uz)*(uy - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy - uz)*(uy - uz)) + 
+         2*chem*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))); 
+            feq18 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*ux + Fy*(1 + uy) + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uy*uy + 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + 2.*uy + uy*uy + (-2. + uz)*uz)) - 0.03125*(nz - nx*ux - ny*(1 + uy) - nz*uz)*
+      (2*chem*(uy - uz)*(uy - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy - uz)*(uy - uz)) + 
+         2*chem*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz))); 
+
+        //------------------------------------------------- BCK collison ------------------------------------------------------------//
+		// q=0
+		dist[n] = m0 - (m0-feq0)/tau + 0.25*(2*(Fx*ux + Fy*uy + Fz*uz)*(-0.6666666666666666 + ux*ux + uy*uy + uz*uz) + 
+     (mgx*ux + mgy*uy + mgz*uz)*(2*chem*(ux*ux + uy*uy + uz*uz) + 
+        0.3333333333333333*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + uz*uz)))); 
+
+		// q = 1
+		dist[nr2] = m1 - (m1-feq1)/tau + 0.125*(2*(Fx*(-1 + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - ux*ux + 
+        0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+     (mgx*(-1 + ux) + mgy*uy + mgz*uz)*(-2*chem*(ux*ux) + 
+        0.3333333333333333*((-rhoA + rhoB)*(ux*ux) + 2*chem*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*uz))));
+
+		// q=2
+		dist[nr1] = m2 - (m2-feq2)/tau + 0.125*(2*(Fx + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - ux*ux + 
+        0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*uz)) + 
+     (mgx + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(ux*ux) + 
+        0.3333333333333333*((-rhoA + rhoB)*(ux*ux) + 2*chem*(2*ux + ux*ux + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*uz))));
+
+		// q = 3
+		dist[nr4] = m3 - (m3-feq3)/tau + 0.125*(2*(Fx*ux + Fy*(-1 + uy) + Fz*uz)*(-0.2222222222222222 - uy*uy + 
+        0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+     (mgx*ux + mgy*(-1 + uy) + mgz*uz)*(-2*chem*(uy*uy) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uy*uy) + 2*chem*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*uz))));
+
+		// q = 4
+		dist[nr3] = m4 - (m4-feq4)/tau + 0.125*(2*(Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - uy*uy + 
+        0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*uz)) + 
+     (mgy + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(uy*uy) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uy*uy) + 2*chem*(ux*ux + 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*uz))));
+
+		// q = 5
+		dist[nr6] = m5 - (m5-feq5)/tau + 0.125*(2*(Fx*ux + Fy*uy + Fz*(-1 + uz))*(-0.2222222222222222 - uz*uz + 
+        0.3333333333333333*(ux*ux + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*ux + mgy*uy + mgz*(-1 + uz))*(-2*chem*(uz*uz) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uz*uz) + 2*chem*(ux*ux + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + (-2 + uz)*uz))));
+
+		// q = 6
+		dist[nr5] = m6 - (m6-feq6)/tau + 0.125*(2*(Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - uz*uz + 
+        0.3333333333333333*(ux*ux + uy*uy + uz*(2 + uz))) + 
+     (mgz + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(uz*uz) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uz*uz) + 2*chem*(ux*ux + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + uz*(2 + uz)))));
+
+		// q = 7
+		dist[nr8] = m7 - (m7-feq7)/tau + 0.0625*(-2*(Fx*(-1 + ux) + Fy*(-1 + uy) + Fz*uz)*
+      (0.2222222222222222 + (ux + uy)*(ux + uy) - 
+        0.3333333333333333*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+     (mgx*(-1 + ux) + mgy*(-1 + uy) + mgz*uz)*
+      (-2*chem*((ux + uy)*(ux + uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uy)*(ux + uy))) + 2*chem*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz))));
+
+		// q = 8
+		dist[nr7] = m8 - (m8-feq8)/tau + 0.0625*(2*(Fx + Fy + Fx*ux + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux + uy)*(ux + uy) + 
+        0.3333333333333333*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+     (mgx + mgy + mgx*ux + mgy*uy + mgz*uz)*
+      (-2*chem*((ux + uy)*(ux + uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uy)*(ux + uy))) + 2*chem*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz))));
+
+		// q = 9
+		dist[nr10] = m9 - (m9-feq9)/tau + 0.0625*(2*(Fy + Fx*(-1 + ux) + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux - uy)*(ux - uy) + 
+        0.3333333333333333*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+     (mgy + mgx*(-1 + ux) + mgy*uy + mgz*uz)*
+      (-2*chem*((ux - uy)*(ux - uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uy)*(ux - uy))) + 2*chem*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz))));
+
+		// q = 10
+		dist[nr9] = m10 - (m10-feq10)/tau + 0.0625*(2*(Fx*(1 + ux) + Fy*(-1 + uy) + Fz*uz)*
+      (-0.2222222222222222 - (ux - uy)*(ux - uy) + 
+        0.3333333333333333*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+     (mgx*(1 + ux) + mgy*(-1 + uy) + mgz*uz)*
+      (-2*chem*((ux - uy)*(ux - uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uy)*(ux - uy))) + 2*chem*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz))));
+
+		// q = 11
+		dist[nr12] = m11 - (m11-feq11)/tau + 0.0625*(-2*(Fx*(-1 + ux) + Fy*uy + Fz*(-1 + uz))*
+      (0.2222222222222222 + (ux + uz)*(ux + uz) - 
+        0.3333333333333333*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*(-1 + ux) + mgy*uy + mgz*(-1 + uz))*
+      (-2*chem*((ux + uz)*(ux + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uz)*(ux + uz))) + 2*chem*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz))));
+
+		// q = 12
+		dist[nr11] = m12 - (m12-feq12)/tau + 0.0625*(2*(Fx + Fz + Fx*ux + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux + uz)*(ux + uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))
+       + (mgx + mgz + mgx*ux + mgy*uy + mgz*uz)*
+      (-2*chem*((ux + uz)*(ux + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uz)*(ux + uz))) + 2*chem*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))));
+
+		// q = 13
+		dist[nr14] = m13 - (m13-feq13)/tau + 0.0625*(2*(Fz + Fx*(-1 + ux) + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux - uz)*(ux - uz) + 
+        0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+     (mgz + mgx*(-1 + ux) + mgy*uy + mgz*uz)*
+      (-2*chem*((ux - uz)*(ux - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uz)*(ux - uz))) + 2*chem*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*(2 + uz)))));
+
+		// q= 14
+		dist[nr13] = m14 - (m14-feq14)/tau + 0.0625*(2*(Fx*(1 + ux) + Fy*uy + Fz*(-1 + uz))*
+      (-0.2222222222222222 - (ux - uz)*(ux - uz) + 
+        0.3333333333333333*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*(1 + ux) + mgy*uy + mgz*(-1 + uz))*
+      (-2*chem*((ux - uz)*(ux - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uz)*(ux - uz))) + 2*chem*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz))));
+
+		// q = 15
+		dist[nr16] = m15 - (m15-feq15)/tau + 0.0625*(-2*(Fx*ux + Fy*(-1 + uy) + Fz*(-1 + uz))*
+      (0.2222222222222222 + (uy + uz)*(uy + uz) - 0.3333333333333333*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))
+       + (mgx*ux + mgy*(-1 + uy) + mgz*(-1 + uz))*
+      (-2*chem*((uy + uz)*(uy + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy + uz)*(uy + uz))) + 2*chem*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))));
+
+		// q = 16
+		dist[nr15] = m16 - (m16-feq16)/tau + 0.0625*(2*(Fy + Fz + Fx*ux + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))
+       + (mgy + mgz + mgx*ux + mgy*uy + mgz*uz)*
+      (-2*chem*((uy + uz)*(uy + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy + uz)*(uy + uz))) + 2*chem*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))));
+
+		// q = 17
+		dist[nr18] = m17 - (m17-feq17)/tau + 0.0625*(2*(Fz + Fx*ux + Fy*(-1 + uy) + Fz*uz)*
+      (-0.2222222222222222 - (uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))
+       + (mgz + mgx*ux + mgy*(-1 + uy) + mgz*uz)*
+      (-2*chem*((uy - uz)*(uy - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy - uz)*(uy - uz))) + 2*chem*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))));
+
+		// q = 18
+		dist[nr17] = m18 - (m18-feq18)/tau + 0.0625*(2*(Fx*ux + Fy*(1 + uy) + Fz*(-1 + uz))*
+      (-0.2222222222222222 - (uy - uz)*(uy - uz) + 
+        0.3333333333333333*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*ux + mgy*(1 + uy) + mgz*(-1 + uz))*
+      (-2*chem*((uy - uz)*(uy - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy - uz)*(uy - uz))) + 2*chem*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz))));
+        //----------------------------------------------------------------------------------------------------------------------------------------//
+
+
+        // ----------------------------- compute phase field evolution ----------------------------------------
+		//Normalize the Color Gradient
+		C = sqrt(nx*nx+ny*ny+nz*nz);
+		double ColorMag = C;
+		if (C==0.0) ColorMag=1.0;
+		nx = nx/ColorMag;
+		ny = ny/ColorMag;
+		nz = nz/ColorMag;		
+        //compute surface tension-related parameter
+        //theta = 4.5*M*2.0*(1-phi*phi)/W;
+        theta = 4.5*M*2.0*(1-phi_temp*phi_temp)/W;
+
+        //load distributions of phase field
+		//q=0
+		h0 = hq[n];
+		//q=1
+		h1 = hq[nr1]; 
+
+		//q=2
+		h2 = hq[nr2];  
+
+		//q=3
+		h3 = hq[nr3];
+
+		//q=4
+		h4 = hq[nr4];
+
+		//q=5
+		h5 = hq[nr5];
+
+		//q=6
+		h6 = hq[nr6];
+
+        //-------------------------------- BGK collison for phase field ---------------------------------//
+		// q = 0
+		hq[n] = h0 - (h0 - 0.3333333333333333*phi)/tauM;
+
+		// q = 1
+		hq[nr2] = h1 - (h1 - 0.1111111111111111*nx*theta - phi*(0.1111111111111111 + 0.5*ux))/tauM;
+
+		// q = 2
+		hq[nr1] = h2 - (h2 + 0.1111111111111111*nx*theta - phi*(0.1111111111111111 - 0.5*ux))/tauM;
+
+		// q = 3
+		hq[nr4] = h3 - (h3 - 0.1111111111111111*ny*theta - phi*(0.1111111111111111 + 0.5*uy))/tauM;
+
+		// q = 4
+		hq[nr3] = h4 - (h4 + 0.1111111111111111*ny*theta - phi*(0.1111111111111111 - 0.5*uy))/tauM;
+
+		// q = 5
+		hq[nr6] = h5 - (h5 - 0.1111111111111111*nz*theta - phi*(0.1111111111111111 + 0.5*uz))/tauM;
+
+		// q = 6
+		hq[nr5] = h6 - (h6 + 0.1111111111111111*nz*theta - phi*(0.1111111111111111 - 0.5*uz))/tauM;
+		//........................................................................
+
+        //Update velocity on device
+		Vel[0*Np+n] = ux;
+		Vel[1*Np+n] = uy;
+		Vel[2*Np+n] = uz;
+        //Update pressure on device
+        Pressure[n] = p;
+        //Update chemical potential on device
+        mu_phi[n] = chem;
+        //Update color gradient on device
+		ColorGrad[0*Np+n] = nx;
+		ColorGrad[1*Np+n] = ny;
+		ColorGrad[2*Np+n] = nz;
+    }
+}
+
+__global__ void dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(int *Map, double *dist, double *hq, double *Den,	double *Phi, double *mu_phi, double *Vel, double *Pressure, double *ColorGrad,
+        double rhoA, double rhoB, double tauA, double tauB, double tauM, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
+        int strideY, int strideZ, int start, int finish, int Np){
+
+	int n,nn,nn2x,ijk;
+	//int nr1,nr2,nr3,nr4,nr5,nr6,nr7,nr8,nr9,nr10,nr11,nr12,nr13,nr14,nr15,nr16,nr17,nr18;
+    double ux,uy,uz;//fluid velocity 
+    double p;//pressure
+    double chem;//chemical potential
+    double phi; //phase field
+    double rho0;//fluid density
+	// distribution functions
+	double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
+	double m0,m3,m5,m7;
+	double mm1,mm2,mm4,mm6,mm8,mm9,mm10,mm11,mm12,mm13,mm14,mm15,mm16,mm17,mm18;
+	double mm3,mm5,mm7;
+    double feq0,feq1,feq2,feq3,feq4,feq5,feq6,feq7,feq8,feq9,feq10,feq11,feq12,feq13,feq14,feq15,feq16,feq17,feq18;
+    double nx,ny,nz;//normal color gradient
+    double mgx,mgy,mgz;//mixed gradient reaching secondary neighbor
+
+	//double f0,f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18;
+    double h0,h1,h2,h3,h4,h5,h6;//distributions for LB phase field
+	double tau;//position dependent LB relaxation time for fluid
+    double C,theta;
+    double M = 2.0/9.0*(tauM-0.5);//diffusivity (or mobility) for the phase field D3Q7
+    double phi_temp;
+    
+    //	for (int n=start; n<finish; n++){
+    int S = Np/NBLOCKS/NTHREADS + 1;
+    for (int s=0; s<S; s++){
+    	//........Get 1-D index for this thread....................
+    	n = S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x + start;
+
+    	if ( n<finish ){
+    		rho0 = Den[n];//load density
+
+    		// Get the 1D index based on regular data layout
+    		ijk = Map[n];
+            phi = Phi[ijk];// load phase field
+            phi_temp = phi;
+            if (phi>1.f) phi_temp=1.0;
+            if (phi<-1.f) phi_temp=-1.0;
+
+    		// local relaxation time
+    		tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
+
+    		//					COMPUTE THE COLOR GRADIENT
+    		//........................................................................
+    		//.................Read Phase Indicator Values............................
+    		//........................................................................
+    		nn = ijk-1;							// neighbor index (get convention)
+    		m1 = Phi[nn];						// get neighbor for phi - 1
+    		//........................................................................
+    		nn = ijk+1;							// neighbor index (get convention)
+    		m2 = Phi[nn];						// get neighbor for phi - 2
+    		//........................................................................
+    		nn = ijk-strideY;							// neighbor index (get convention)
+    		m3 = Phi[nn];					// get neighbor for phi - 3
+    		//........................................................................
+    		nn = ijk+strideY;							// neighbor index (get convention)
+    		m4 = Phi[nn];					// get neighbor for phi - 4
+    		//........................................................................
+    		nn = ijk-strideZ;						// neighbor index (get convention)
+    		m5 = Phi[nn];					// get neighbor for phi - 5
+    		//........................................................................
+    		nn = ijk+strideZ;						// neighbor index (get convention)
+    		m6 = Phi[nn];					// get neighbor for phi - 6
+    		//........................................................................
+    		nn = ijk-strideY-1;						// neighbor index (get convention)
+    		m7 = Phi[nn];					// get neighbor for phi - 7
+    		//........................................................................
+    		nn = ijk+strideY+1;						// neighbor index (get convention)
+    		m8 = Phi[nn];					// get neighbor for phi - 8
+    		//........................................................................
+    		nn = ijk+strideY-1;						// neighbor index (get convention)
+    		m9 = Phi[nn];					// get neighbor for phi - 9
+    		//........................................................................
+    		nn = ijk-strideY+1;						// neighbor index (get convention)
+    		m10 = Phi[nn];					// get neighbor for phi - 10
+    		//........................................................................
+    		nn = ijk-strideZ-1;						// neighbor index (get convention)
+    		m11 = Phi[nn];					// get neighbor for phi - 11
+    		//........................................................................
+    		nn = ijk+strideZ+1;						// neighbor index (get convention)
+    		m12 = Phi[nn];					// get neighbor for phi - 12
+    		//........................................................................
+    		nn = ijk+strideZ-1;						// neighbor index (get convention)
+    		m13 = Phi[nn];					// get neighbor for phi - 13
+    		//........................................................................
+    		nn = ijk-strideZ+1;						// neighbor index (get convention)
+    		m14 = Phi[nn];					// get neighbor for phi - 14
+    		//........................................................................
+    		nn = ijk-strideZ-strideY;					// neighbor index (get convention)
+    		m15 = Phi[nn];					// get neighbor for phi - 15
+    		//........................................................................
+    		nn = ijk+strideZ+strideY;					// neighbor index (get convention)
+    		m16 = Phi[nn];					// get neighbor for phi - 16
+    		//........................................................................
+    		nn = ijk+strideZ-strideY;					// neighbor index (get convention)
+    		m17 = Phi[nn];					// get neighbor for phi - 17
+    		//........................................................................
+    		nn = ijk-strideZ+strideY;					// neighbor index (get convention)
+    		m18 = Phi[nn];					// get neighbor for phi - 18
+
+            // compute mixed difference (Eq.30, A.Fukhari et al. JCP 315(2016) 434-457)
+    		//........................................................................
+    		nn2x = ijk-2;							// neighbor index (get convention)
+    		mm1 = Phi[nn2x];						// get neighbor for phi - 1
+            mm1 = 0.25*(-mm1+5.0*m1-3.0*phi-m2);
+    		//........................................................................
+    		nn2x = ijk+2;							// neighbor index (get convention)
+    		mm2 = Phi[nn2x];						// get neighbor for phi - 2
+            mm2 = 0.25*(-mm2+5.0*m2-3.0*phi-m1);
+    		//........................................................................
+    		nn2x = ijk-strideY*2;							// neighbor index (get convention)
+    		mm3 = Phi[nn2x];					// get neighbor for phi - 3
+            mm3 = 0.25*(-mm3+5.0*m3-3.0*phi-m4);
+    		//........................................................................
+    		nn2x = ijk+strideY*2;							// neighbor index (get convention)
+    		mm4 = Phi[nn2x];					// get neighbor for phi - 4
+            mm4 = 0.25*(-mm4+5.0*m4-3.0*phi-m3);
+    		//........................................................................
+    		nn2x = ijk-strideZ*2;						// neighbor index (get convention)
+    		mm5 = Phi[nn2x];					// get neighbor for phi - 5
+            mm5 = 0.25*(-mm5+5.0*m5-3.0*phi-m6);
+    		//........................................................................
+    		nn2x = ijk+strideZ*2;						// neighbor index (get convention)
+    		mm6 = Phi[nn2x];					// get neighbor for phi - 6
+            mm6 = 0.25*(-mm6+5.0*m6-3.0*phi-m5);
+    		//........................................................................
+    		nn2x = ijk-strideY*2-2;						// neighbor index (get convention)
+    		mm7 = Phi[nn2x];					// get neighbor for phi - 7
+            mm7 = 0.25*(-mm7+5.0*m7-3.0*phi-m8);
+    		//........................................................................
+    		nn2x = ijk+strideY*2+2;						// neighbor index (get convention)
+    		mm8 = Phi[nn2x];					// get neighbor for phi - 8
+            mm8 = 0.25*(-mm8+5.0*m8-3.0*phi-m7);
+    		//........................................................................
+    		nn2x = ijk+strideY*2-2;						// neighbor index (get convention)
+    		mm9 = Phi[nn2x];					// get neighbor for phi - 9
+            mm9 = 0.25*(-mm9+5.0*m9-3.0*phi-m10);
+    		//........................................................................
+    		nn2x = ijk-strideY*2+2;						// neighbor index (get convention)
+    		mm10 = Phi[nn2x];					// get neighbor for phi - 10
+            mm10 = 0.25*(-mm10+5.0*m10-3.0*phi-m9);
+    		//........................................................................
+    		nn2x = ijk-strideZ*2-2;						// neighbor index (get convention)
+    		mm11 = Phi[nn2x];					// get neighbor for phi - 11
+            mm11 = 0.25*(-mm11+5.0*m11-3.0*phi-m12);
+    		//........................................................................
+    		nn2x = ijk+strideZ*2+2;						// neighbor index (get convention)
+    		mm12 = Phi[nn2x];					// get neighbor for phi - 12
+            mm12 = 0.25*(-mm12+5.0*m12-3.0*phi-m11);
+    		//........................................................................
+    		nn2x = ijk+strideZ*2-2;						// neighbor index (get convention)
+    		mm13 = Phi[nn2x];					// get neighbor for phi - 13
+            mm13 = 0.25*(-mm13+5.0*m13-3.0*phi-m14);
+    		//........................................................................
+    		nn2x = ijk-strideZ*2+2;						// neighbor index (get convention)
+    		mm14 = Phi[nn2x];					// get neighbor for phi - 14
+            mm14 = 0.25*(-mm14+5.0*m14-3.0*phi-m13);
+    		//........................................................................
+    		nn2x = ijk-strideZ*2-strideY*2;					// neighbor index (get convention)
+    		mm15 = Phi[nn2x];					// get neighbor for phi - 15
+            mm15 = 0.25*(-mm15+5.0*m15-3.0*phi-m16);
+    		//........................................................................
+    		nn2x = ijk+strideZ*2+strideY*2;					// neighbor index (get convention)
+    		mm16 = Phi[nn2x];					// get neighbor for phi - 16
+            mm16 = 0.25*(-mm16+5.0*m16-3.0*phi-m15);
+    		//........................................................................
+    		nn2x = ijk+strideZ*2-strideY*2;					// neighbor index (get convention)
+    		mm17 = Phi[nn2x];					// get neighbor for phi - 17
+            mm17 = 0.25*(-mm17+5.0*m17-3.0*phi-m18);
+    		//........................................................................
+    		nn2x = ijk-strideZ*2+strideY*2;					// neighbor index (get convention)
+    		mm18 = Phi[nn2x];					// get neighbor for phi - 18
+            mm18 = 0.25*(-mm18+5.0*m18-3.0*phi-m17);
+
+
+    		//............Compute the Color Gradient...................................
+    		nx = -3.0*1.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+    		ny = -3.0*1.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+    		nz = -3.0*1.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+    		//............Compute the Chemical Potential...............................
+            //chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi));//intermediate var, i.e. the laplacian
+            //chem = 4.0*beta*phi*(phi+1.0)*(phi-1.0)-kappa*chem;
+            chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi_temp+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi_temp));//intermediate var, i.e. the laplacian
+            chem = 4.0*beta*phi_temp*(phi_temp+1.0)*(phi_temp-1.0)-kappa*chem;
+    		//............Compute the Mixed Gradient...................................
+    		mgx = -3.0*1.0/18.0*(mm1-mm2+0.5*(mm7-mm8+mm9-mm10+mm11-mm12+mm13-mm14));
+    		mgy = -3.0*1.0/18.0*(mm3-mm4+0.5*(mm7-mm8-mm9+mm10+mm15-mm16+mm17-mm18));
+    		mgz = -3.0*1.0/18.0*(mm5-mm6+0.5*(mm11-mm12-mm13+mm14+mm15-mm16-mm17+mm18));
+    		
+            //de-noise color gradient and mixed gradient
+    		C = sqrt(nx*nx+ny*ny+nz*nz);
+    		if (C<1.0e-12) nx=ny=nz=0.0;
+    		double mg_mag = sqrt(mgx*mgx+mgy*mgy+mgz*mgz);
+    		if (mg_mag<1.0e-12) mgx=mgy=mgz=0.0;
+            //maybe you can also de-noise chemical potential ? within the bulk phase chem should be ZERO
+            if (fabs(chem)<1.0e-12) chem=0.0;
+
+    		// q=0
+    		m0 = dist[n];
+    		// q=1
+    		m1 = dist[2*Np+n]; 
+
+            // q=2
+    		m2 = dist[1*Np+n];  
+
+    		// q=3
+    		m3 = dist[4*Np+n];
+
+    		// q = 4
+    		m4 = dist[3*Np+n];
+
+    		// q=5
+    		m5 = dist[6*Np+n];
+
+    		// q = 6
+    		m6 = dist[5*Np+n];
+    		
+    		// q=7
+    		m7 = dist[8*Np+n];
+
+    		// q = 8
+    		m8 = dist[7*Np+n];
+
+    		// q=9
+    		m9 = dist[10*Np+n];
+
+    		// q = 10
+    		m10 = dist[9*Np+n];
+
+    		// q=11
+    		m11 = dist[12*Np+n];
+
+    		// q=12
+    		m12 = dist[11*Np+n];
+
+    		// q=13
+    		m13 = dist[14*Np+n];
+
+    		// q=14
+    		m14 = dist[13*Np+n];
+
+    		// q=15
+    		m15 = dist[16*Np+n];
+
+    		// q=16
+    		m16 = dist[15*Np+n];
+
+    		// q=17
+    		m17 = dist[18*Np+n];
+
+    		// q=18
+    		m18 = dist[17*Np+n];
+
+            //compute fluid velocity
+            ux = 3.0/rho0*(m1-m2+m7-m8+m9-m10+m11-m12+m13-m14+0.5*(chem*nx+Fx)/3.0);
+            uy = 3.0/rho0*(m3-m4+m7-m8-m9+m10+m15-m16+m17-m18+0.5*(chem*ny+Fy)/3.0);
+            uz = 3.0/rho0*(m5-m6+m11-m12-m13+m14+m15-m16-m17+m18+0.5*(chem*nz+Fz)/3.0);
+            //compute pressure
+            p = (m0+m2+m1+m4+m3+m6+m5+m8+m7+m10+m9+m12+m11+m14+m13+m16+m15+m18+m17)
+                      +0.5*(rhoA-rhoB)/2.0/3.0*(ux*nx+uy*ny+uz*nz);
+
+            //compute equilibrium distributions
+                feq0 = 0.3333333333333333*p - 0.25*(Fx*ux + Fy*uy + Fz*uz)*(-0.6666666666666666 + ux*ux + uy*uy + uz*uz) - 
+         0.16666666666666666*rho0*(ux*ux + uy*uy + uz*uz) - 0.5*(-(nx*ux) - ny*uy - nz*uz)*
+          (-0.08333333333333333*(rhoA - rhoB)*(ux*ux + uy*uy + uz*uz) + chem*(0.3333333333333333 - 0.5*(ux*ux + uy*uy + uz*uz)));
+                feq1 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-ux*ux + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*uz)) - 
+         0.125*(Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 
+           0.3333333333333333*(-2.*ux + ux*ux + uy*uy + uz*uz)) - 0.0625*(nx - nx*ux - ny*uy - nz*uz)*
+          (2*chem*ux*ux - 0.3333333333333333*((-rhoA + rhoB)*ux*ux + 2*chem*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+           0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*uz)));
+                feq2 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-ux*ux + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*uz)) - 
+         0.125*(Fx + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 
+           0.3333333333333333*(2.*ux + ux*ux + uy*uy + uz*uz)) - 0.0625*(nx + nx*ux + ny*uy + nz*uz)*
+          (-2.*chem*ux*ux + 0.1111111111111111*(-4.*chem + rhoB*(-2.*ux - 1.*ux*ux - 1.*uy*uy - 1.*uz*uz) + 
+             rhoA*(2.*ux + ux*ux + uy*uy + uz*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*ux*ux + 
+             chem*(4.*ux + 2.*ux*ux + 2.*uy*uy + 2.*uz*uz)));
+                feq3 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uy*uy + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*uz)) - 
+         0.125*(Fx*ux + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 
+           0.3333333333333333*(ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.0625*(ny - nx*ux - ny*uy - nz*uz)*
+          (2*chem*uy*uy - 0.3333333333333333*((-rhoA + rhoB)*uy*uy + 2*chem*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+           0.1111111111111111*(4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*uz)));
+                feq4 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uy*uy + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*uz)) - 
+         0.125*(Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 
+           0.3333333333333333*(ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.0625*(ny + nx*ux + ny*uy + nz*uz)*
+          (-2.*chem*uy*uy + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 2.*uy - 1.*uy*uy - 1.*uz*uz) + 
+             rhoA*(ux*ux + 2.*uy + uy*uy + uz*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*uy*uy + 
+             chem*(2.*ux*ux + 4.*uy + 2.*uy*uy + 2.*uz*uz))); 
+                feq5 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uz*uz + 0.3333333333333333*(ux*ux + uy*uy + (-2 + uz)*uz)) - 
+         0.125*(Fx*ux + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uz*uz + 
+           0.3333333333333333*(ux*ux + uy*uy + (-2. + uz)*uz)) - 0.0625*(nx*ux + ny*uy + nz*(-1. + uz))*
+          (-2.*chem*uz*uz + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 1.*uy*uy + (2. - 1.*uz)*uz) + 
+             rhoA*(ux*ux + uy*uy + (-2. + uz)*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*uz*uz + 
+             chem*(2.*ux*ux + 2.*uy*uy + uz*(-4. + 2.*uz)))); 
+                feq6 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uz*uz + 0.3333333333333333*(ux*ux + uy*uy + uz*(2 + uz))) - 
+         0.125*(Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uz*uz + 
+           0.3333333333333333*(ux*ux + uy*uy + uz*(2. + uz))) - 0.0625*(nz + nx*ux + ny*uy + nz*uz)*
+          (-2.*chem*uz*uz + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 1.*uy*uy + (-2. - 1.*uz)*uz) + 
+             rhoA*(ux*ux + uy*uy + uz*(2. + uz))) + 0.3333333333333333*((-1.*rhoA + rhoB)*uz*uz + 
+             chem*(2.*ux*ux + 2.*uy*uy + uz*(4. + 2.*uz)))); 
+                feq7 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux + uy)*(ux + uy) + 0.3333333333333333*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) - 
+         0.0625*(Fx*(-1. + ux) + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uy - 1.*uy*uy + 
+           0.3333333333333333*(-2.*ux + ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.03125*(nx + ny - nx*ux - ny*uy - nz*uz)*
+          (2*chem*(ux + uy)*(ux + uy) + 0.3333333333333333*((rhoA - rhoB)*(ux + uy)*(ux + uy) - 2*chem*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+           0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz))); 
+                feq8 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux + uy)*(ux + uy) + 0.3333333333333333*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) - 
+         0.0625*(Fx + Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uy - 1.*uy*uy + 
+           0.3333333333333333*(2.*ux + ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.03125*(-(nx*(1 + ux)) - ny*(1 + uy) - nz*uz)*
+          (2*chem*(ux + uy)*(ux + uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux + uy)*(ux + uy)) + 
+             2*chem*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz))); 
+                feq9 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux - uy)*(ux - uy) + 0.3333333333333333*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) - 
+         0.0625*(Fy + Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uy - 1.*uy*uy + 
+           0.3333333333333333*(-2.*ux + ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.03125*(nx - nx*ux - ny*(1 + uy) - nz*uz)*
+          (2*chem*(ux - uy)*(ux - uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uy)*(ux - uy)) + 
+             2*chem*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz))); 
+                feq10 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux - uy)*(ux - uy) + 0.3333333333333333*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) - 
+         0.0625*(Fx*(1 + ux) + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uy - 1.*uy*uy + 
+           0.3333333333333333*(2.*ux + ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.03125*(ny - nx*(1 + ux) - ny*uy - nz*uz)*
+          (2*chem*(ux - uy)*(ux - uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uy)*(ux - uy)) + 
+             2*chem*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz))); 
+                feq11 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux + uz)*(ux + uz) + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) - 
+         0.0625*(Fx*(-1. + ux) + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uz - 1.*uz*uz + 
+           0.3333333333333333*(-2.*ux + ux*ux + uy*uy + (-2. + uz)*uz)) - 0.03125*(nx + nz - nx*ux - ny*uy - nz*uz)*
+          (2*chem*(ux + uz)*(ux + uz) + 0.3333333333333333*((rhoA - rhoB)*(ux + uz)*(ux + uz) - 2*chem*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+           0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz))); 
+                feq12 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux + uz)*(ux + uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) - 
+         0.0625*(Fx + Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uz - 1.*uz*uz + 
+           0.3333333333333333*(2.*ux + ux*ux + uy*uy + uz*(2. + uz))) - 0.03125*(-(nx*(1 + ux)) - ny*uy - nz*(1 + uz))*
+          (2*chem*(ux + uz)*(ux + uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux + uz)*(ux + uz)) + 
+             2*chem*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))); 
+                feq13 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux - uz)*(ux - uz) + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) - 
+         0.0625*(Fz + Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uz - 1.*uz*uz + 
+           0.3333333333333333*(-2.*ux + ux*ux + uy*uy + uz*(2. + uz))) - 0.03125*(nx - nx*ux - ny*uy - nz*(1 + uz))*
+          (2*chem*(ux - uz)*(ux - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uz)*(ux - uz)) + 
+             2*chem*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*(2 + uz)))); 
+                feq14 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux - uz)*(ux - uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) - 
+         0.0625*(Fx*(1 + ux) + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uz - 1.*uz*uz + 
+           0.3333333333333333*(2.*ux + ux*ux + uy*uy + (-2. + uz)*uz)) - 0.03125*(nz - nx*(1 + ux) - ny*uy - nz*uz)*
+          (2*chem*(ux - uz)*(ux - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uz)*(ux - uz)) + 
+             2*chem*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz))); 
+                feq15 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) - 
+         0.0625*(Fx*ux + Fy*(-1. + uy) + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uy*uy - 2.*uy*uz - 1.*uz*uz + 
+           0.3333333333333333*(ux*ux - 2.*uy + uy*uy + (-2. + uz)*uz)) - 0.03125*(ny + nz - nx*ux - ny*uy - nz*uz)*
+          (2*chem*(uy + uz)*(uy + uz) + 0.3333333333333333*((rhoA - rhoB)*(uy + uz)*(uy + uz) - 2*chem*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) + 
+           0.1111111111111111*(4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))); 
+                feq16 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) - 
+         0.0625*(Fy + Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy - 2.*uy*uz - 1.*uz*uz + 
+           0.3333333333333333*(ux*ux + 2.*uy + uy*uy + uz*(2. + uz))) - 0.03125*(-(nx*ux) - ny*(1 + uy) - nz*(1 + uz))*
+          (2*chem*(uy + uz)*(uy + uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy + uz)*(uy + uz)) + 
+             2*chem*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))); 
+                feq17 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) - 
+         0.0625*(Fz + Fx*ux + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 2.*uy*uz - 1.*uz*uz + 
+           0.3333333333333333*(ux*ux - 2.*uy + uy*uy + uz*(2. + uz))) - 0.03125*(ny - nx*ux - ny*uy - nz*(1 + uz))*
+          (2*chem*(uy - uz)*(uy - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy - uz)*(uy - uz)) + 
+             2*chem*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))); 
+                feq18 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) - 
+         0.0625*(Fx*ux + Fy*(1 + uy) + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uy*uy + 2.*uy*uz - 1.*uz*uz + 
+           0.3333333333333333*(ux*ux + 2.*uy + uy*uy + (-2. + uz)*uz)) - 0.03125*(nz - nx*ux - ny*(1 + uy) - nz*uz)*
+          (2*chem*(uy - uz)*(uy - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy - uz)*(uy - uz)) + 
+             2*chem*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz))); 
+
+            //------------------------------------------------- BCK collison ------------------------------------------------------------//
+    		// q=0
+    		dist[n] = m0 - (m0-feq0)/tau + 0.25*(2*(Fx*ux + Fy*uy + Fz*uz)*(-0.6666666666666666 + ux*ux + uy*uy + uz*uz) + 
+         (mgx*ux + mgy*uy + mgz*uz)*(2*chem*(ux*ux + uy*uy + uz*uz) + 
+            0.3333333333333333*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + uz*uz))));
+
+    		// q = 1
+    		dist[1*Np+n] = m1 - (m1-feq1)/tau + 0.125*(2*(Fx*(-1 + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - ux*ux + 
+            0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+         (mgx*(-1 + ux) + mgy*uy + mgz*uz)*(-2*chem*(ux*ux) + 
+            0.3333333333333333*((-rhoA + rhoB)*(ux*ux) + 2*chem*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*uz))));
+
+    		// q=2
+    		dist[2*Np+n] = m2 - (m2-feq2)/tau + 0.125*(2*(Fx + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - ux*ux + 
+            0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*uz)) + 
+         (mgx + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(ux*ux) + 
+            0.3333333333333333*((-rhoA + rhoB)*(ux*ux) + 2*chem*(2*ux + ux*ux + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*uz))));
+
+    		// q = 3
+    		dist[3*Np+n] = m3 - (m3-feq3)/tau + 0.125*(2*(Fx*ux + Fy*(-1 + uy) + Fz*uz)*(-0.2222222222222222 - uy*uy + 
+            0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+         (mgx*ux + mgy*(-1 + uy) + mgz*uz)*(-2*chem*(uy*uy) + 
+            0.3333333333333333*((-rhoA + rhoB)*(uy*uy) + 2*chem*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*uz))));
+
+    		// q = 4
+    		dist[4*Np+n] = m4 - (m4-feq4)/tau + 0.125*(2*(Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - uy*uy + 
+            0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*uz)) + 
+         (mgy + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(uy*uy) + 
+            0.3333333333333333*((-rhoA + rhoB)*(uy*uy) + 2*chem*(ux*ux + 2*uy + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*uz))));
+
+    		// q = 5
+    		dist[5*Np+n] = m5 - (m5-feq5)/tau + 0.125*(2*(Fx*ux + Fy*uy + Fz*(-1 + uz))*(-0.2222222222222222 - uz*uz + 
+            0.3333333333333333*(ux*ux + uy*uy + (-2 + uz)*uz)) + 
+         (mgx*ux + mgy*uy + mgz*(-1 + uz))*(-2*chem*(uz*uz) + 
+            0.3333333333333333*((-rhoA + rhoB)*(uz*uz) + 2*chem*(ux*ux + uy*uy + (-2 + uz)*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + (-2 + uz)*uz))));
+
+    		// q = 6
+    		dist[6*Np+n] = m6 - (m6-feq6)/tau + 0.125*(2*(Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - uz*uz + 
+            0.3333333333333333*(ux*ux + uy*uy + uz*(2 + uz))) + 
+         (mgz + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(uz*uz) + 
+            0.3333333333333333*((-rhoA + rhoB)*(uz*uz) + 2*chem*(ux*ux + uy*uy + uz*(2 + uz))) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + uz*(2 + uz)))));
+
+    		// q = 7
+    		dist[7*Np+n] = m7 - (m7-feq7)/tau + 0.0625*(-2*(Fx*(-1 + ux) + Fy*(-1 + uy) + Fz*uz)*
+          (0.2222222222222222 + (ux + uy)*(ux + uy) - 
+            0.3333333333333333*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+         (mgx*(-1 + ux) + mgy*(-1 + uy) + mgz*uz)*
+          (-2*chem*((ux + uy)*(ux + uy)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux + uy)*(ux + uy))) + 2*chem*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz))));
+
+    		// q = 8
+    		dist[8*Np+n] = m8 - (m8-feq8)/tau + 0.0625*(2*(Fx + Fy + Fx*ux + Fy*uy + Fz*uz)*
+          (-0.2222222222222222 - (ux + uy)*(ux + uy) + 
+            0.3333333333333333*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+         (mgx + mgy + mgx*ux + mgy*uy + mgz*uz)*
+          (-2*chem*((ux + uy)*(ux + uy)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux + uy)*(ux + uy))) + 2*chem*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz))));
+
+    		// q = 9
+    		dist[9*Np+n] = m9 - (m9-feq9)/tau + 0.0625*(2*(Fy + Fx*(-1 + ux) + Fy*uy + Fz*uz)*
+          (-0.2222222222222222 - (ux - uy)*(ux - uy) + 
+            0.3333333333333333*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+         (mgy + mgx*(-1 + ux) + mgy*uy + mgz*uz)*
+          (-2*chem*((ux - uy)*(ux - uy)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux - uy)*(ux - uy))) + 2*chem*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz))));
+
+    		// q = 10
+    		dist[10*Np+n] = m10 - (m10-feq10)/tau + 0.0625*(2*(Fx*(1 + ux) + Fy*(-1 + uy) + Fz*uz)*
+          (-0.2222222222222222 - (ux - uy)*(ux - uy) + 
+            0.3333333333333333*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+         (mgx*(1 + ux) + mgy*(-1 + uy) + mgz*uz)*
+          (-2*chem*((ux - uy)*(ux - uy)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux - uy)*(ux - uy))) + 2*chem*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz))));
+
+    		// q = 11
+    		dist[11*Np+n] = m11 - (m11-feq11)/tau + 0.0625*(-2*(Fx*(-1 + ux) + Fy*uy + Fz*(-1 + uz))*
+          (0.2222222222222222 + (ux + uz)*(ux + uz) - 
+            0.3333333333333333*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+         (mgx*(-1 + ux) + mgy*uy + mgz*(-1 + uz))*
+          (-2*chem*((ux + uz)*(ux + uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux + uz)*(ux + uz))) + 2*chem*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz))));
+
+    		// q = 12
+    		dist[12*Np+n] = m12 - (m12-feq12)/tau + 0.0625*(2*(Fx + Fz + Fx*ux + Fy*uy + Fz*uz)*
+          (-0.2222222222222222 - (ux + uz)*(ux + uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))
+           + (mgx + mgz + mgx*ux + mgy*uy + mgz*uz)*
+          (-2*chem*((ux + uz)*(ux + uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux + uz)*(ux + uz))) + 2*chem*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))));
+
+    		// q = 13
+    		dist[13*Np+n] = m13 - (m13-feq13)/tau + 0.0625*(2*(Fz + Fx*(-1 + ux) + Fy*uy + Fz*uz)*
+          (-0.2222222222222222 - (ux - uz)*(ux - uz) + 
+            0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+         (mgz + mgx*(-1 + ux) + mgy*uy + mgz*uz)*
+          (-2*chem*((ux - uz)*(ux - uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux - uz)*(ux - uz))) + 2*chem*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*(2 + uz)))));
+
+    		// q= 14
+    		dist[14*Np+n] = m14 - (m14-feq14)/tau + 0.0625*(2*(Fx*(1 + ux) + Fy*uy + Fz*(-1 + uz))*
+          (-0.2222222222222222 - (ux - uz)*(ux - uz) + 
+            0.3333333333333333*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+         (mgx*(1 + ux) + mgy*uy + mgz*(-1 + uz))*
+          (-2*chem*((ux - uz)*(ux - uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux - uz)*(ux - uz))) + 2*chem*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz))));
+
+    		// q = 15
+    		dist[15*Np+n] = m15 - (m15-feq15)/tau + 0.0625*(-2*(Fx*ux + Fy*(-1 + uy) + Fz*(-1 + uz))*
+          (0.2222222222222222 + (uy + uz)*(uy + uz) - 0.3333333333333333*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))
+           + (mgx*ux + mgy*(-1 + uy) + mgz*(-1 + uz))*
+          (-2*chem*((uy + uz)*(uy + uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((uy + uz)*(uy + uz))) + 2*chem*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))));
+
+    		// q = 16
+    		dist[16*Np+n] = m16 - (m16-feq16)/tau + 0.0625*(2*(Fy + Fz + Fx*ux + Fy*uy + Fz*uz)*
+          (-0.2222222222222222 - (uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))
+           + (mgy + mgz + mgx*ux + mgy*uy + mgz*uz)*
+          (-2*chem*((uy + uz)*(uy + uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((uy + uz)*(uy + uz))) + 2*chem*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))));
+
+    		// q = 17
+    		dist[17*Np+n] = m17 - (m17-feq17)/tau + 0.0625*(2*(Fz + Fx*ux + Fy*(-1 + uy) + Fz*uz)*
+          (-0.2222222222222222 - (uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))
+           + (mgz + mgx*ux + mgy*(-1 + uy) + mgz*uz)*
+          (-2*chem*((uy - uz)*(uy - uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((uy - uz)*(uy - uz))) + 2*chem*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))));
+
+    		// q = 18
+    		dist[18*Np+n] = m18 - (m18-feq18)/tau + 0.0625*(2*(Fx*ux + Fy*(1 + uy) + Fz*(-1 + uz))*
+          (-0.2222222222222222 - (uy - uz)*(uy - uz) + 
+            0.3333333333333333*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 
+         (mgx*ux + mgy*(1 + uy) + mgz*(-1 + uz))*
+          (-2*chem*((uy - uz)*(uy - uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((uy - uz)*(uy - uz))) + 2*chem*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz))));
+            //----------------------------------------------------------------------------------------------------------------------------------------//
+
+
+            // ----------------------------- compute phase field evolution ----------------------------------------
+    		//Normalize the Color Gradient
+    		C = sqrt(nx*nx+ny*ny+nz*nz);
+    		double ColorMag = C;
+    		if (C==0.0) ColorMag=1.0;
+    		nx = nx/ColorMag;
+    		ny = ny/ColorMag;
+    		nz = nz/ColorMag;		
+            //compute surface tension-related parameter
+            //theta = 4.5*M*2.0*(1-phi*phi)/W;
+            theta = 4.5*M*2.0*(1-phi_temp*phi_temp)/W;
+
+            //load distributions of phase field
+    		//q=0
+    		h0 = hq[n];
+    		//q=1
+    		h1 = hq[2*Np+n]; 
+
+    		//q=2
+    		h2 = hq[1*Np+n];  
+
+    		//q=3
+    		h3 = hq[4*Np+n];
+
+    		//q=4
+    		h4 = hq[3*Np+n];
+
+    		//q=5
+    		h5 = hq[6*Np+n];
+
+    		//q=6
+    		h6 = hq[5*Np+n];
+
+            //-------------------------------- BGK collison for phase field ---------------------------------//
+    		// q = 0
+    		hq[n] = h0 - (h0 - 0.3333333333333333*phi)/tauM;
+
+    		// q = 1
+    		hq[1*Np+n] = h1 - (h1 - 0.1111111111111111*nx*theta - phi*(0.1111111111111111 + 0.5*ux))/tauM;
+
+    		// q = 2
+    		hq[2*Np+n] = h2 - (h2 + 0.1111111111111111*nx*theta - phi*(0.1111111111111111 - 0.5*ux))/tauM;
+
+    		// q = 3
+    		hq[3*Np+n] = h3 - (h3 - 0.1111111111111111*ny*theta - phi*(0.1111111111111111 + 0.5*uy))/tauM;
+
+    		// q = 4
+    		hq[4*Np+n] = h4 - (h4 + 0.1111111111111111*ny*theta - phi*(0.1111111111111111 - 0.5*uy))/tauM;
+
+    		// q = 5
+    		hq[5*Np+n] = h5 - (h5 - 0.1111111111111111*nz*theta - phi*(0.1111111111111111 + 0.5*uz))/tauM;
+
+    		// q = 6
+    		hq[6*Np+n] = h6 - (h6 + 0.1111111111111111*nz*theta - phi*(0.1111111111111111 - 0.5*uz))/tauM;
+    		//........................................................................
+
+            //Update velocity on device
+    		Vel[0*Np+n] = ux;
+    		Vel[1*Np+n] = uy;
+    		Vel[2*Np+n] = uz;
+            //Update pressure on device
+            Pressure[n] = p;
+            //Update chemical potential on device
+            mu_phi[n] = chem;
+            //Update color gradient on device
+    		ColorGrad[0*Np+n] = nx;
+    		ColorGrad[1*Np+n] = ny;
+    		ColorGrad[2*Np+n] = nz;
+
+    	}
+    }
+}
+    	}
 __global__ void dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel_SingleFluid_BGK(int *neighborList, double *dist, double *Vel, double *Pressure,  
 		double tau, double rho0, double Fx, double Fy, double Fz, int start, int finish, int Np){
 
@@ -2093,6 +3343,30 @@ extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel(int *Map, double *dist, double
 	
 }
 
+extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(int *Map, double *dist, double *hq, double *Den, double *Phi, double *mu_phi, double *Vel, double *Pressure, double *ColorGrad,
+                                                double rhoA, double rhoB, double tauA, double tauB, double tauM, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
+                                                int strideY, int strideZ, int start, int finish, int Np){
+	cudaFuncSetCacheConfig(dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined, cudaFuncCachePreferL1);
+	dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined<<<NBLOCKS,NTHREADS >>>(Map, dist, Den, hq, Phi, mu_phi, Vel, Pressure,  ColorGrad, 
+            rhoA, rhoB, tauA, tauB, tauM, kappa, beta, W, Fx, Fy, Fz, strideY, strideZ, start, finish, Np);
+	cudaError_t err = cudaGetLastError();
+	if (cudaSuccess != err){
+		printf("CUDA error in ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined: %s \n",cudaGetErrorString(err));
+}
+
+extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(int *neighborList, int *Map, double *dist, double *hq, double *Den, double *Phi, double *mu_phi, double *Vel, double *Pressure, double *ColorGrad, 
+                                                double rhoA, double rhoB, double tauA, double tauB, double tauM, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
+                                                int strideY, int strideZ, int start, int finish, int Np){
+	
+	cudaFuncSetCacheConfig(dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined, cudaFuncCachePreferL1);
+	dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined<<<NBLOCKS,NTHREADS >>>(neighborList, Map, dist, hq, Den, Phi, mu_phi, Vel, Pressure,  ColorGrad, 
+            rhoA, rhoB, tauA, tauB, tauM, kappa, beta, W, Fx, Fy, Fz, strideY, strideZ, start, finish, Np);
+	cudaError_t err = cudaGetLastError();
+	if (cudaSuccess != err){
+		printf("CUDA error in ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined: %s \n",cudaGetErrorString(err));
+		
+}
+
 extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_SingleFluid_BGK(int *neighborList, double *dist, double *Vel, double *Pressure,  
                                                                 double tau, double rho0, double Fx, double Fy, double Fz, int start, int finish, int Np){
 

From ba8a11a1e71d4820e1a235824c52713d0129b71d Mon Sep 17 00:00:00 2001
From: James McClure <jemcclur@gmail.com>
Date: Wed, 31 Mar 2021 11:20:49 -0400
Subject: [PATCH 19/19] hip versions for lee / greyscale

---
 hip/FreeLee.cu        | 1342 +++++++++++++++++++++++++++++++++-
 hip/GreyscaleColor.cu | 1616 ++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 2922 insertions(+), 36 deletions(-)

diff --git a/hip/FreeLee.cu b/hip/FreeLee.cu
index 09bc8689..890934c0 100644
--- a/hip/FreeLee.cu
+++ b/hip/FreeLee.cu
@@ -1,6 +1,6 @@
 #include <math.h>
 #include <stdio.h>
-#include "hip/hip_runtime.h"
+#include <cuda_profiler_api.h>
 
 #define STOKES
 
@@ -118,8 +118,10 @@ __global__ void dvc_ScaLBL_FreeLeeModel_PhaseField_Init(int *Map, double *Phi, d
 		ny = ny/ColorMag_temp;
 		nz = nz/ColorMag_temp;		
 
-        theta = M*cs2_inv*(1-4.0*phi*phi)/W;
-
+        //theta = M*cs2_inv*(1-factor*phi*phi)/W;
+        theta = 4.5*M*2.0*(1-phi*phi)/W;
+        //theta = 0; // try more diffusive initial condition
+        
 		hq[0*Np+idx]=0.3333333333333333*(phi);
 		hq[1*Np+idx]=0.1111111111111111*(phi+theta*nx);
 		hq[2*Np+idx]=0.1111111111111111*(phi-theta*nx);
@@ -127,7 +129,6 @@ __global__ void dvc_ScaLBL_FreeLeeModel_PhaseField_Init(int *Map, double *Phi, d
 		hq[4*Np+idx]=0.1111111111111111*(phi-theta*ny);
 		hq[5*Np+idx]=0.1111111111111111*(phi+theta*nz);
 		hq[6*Np+idx]=0.1111111111111111*(phi-theta*nz);
-		
 	}
 }
 
@@ -204,10 +205,10 @@ __global__ void dvc_ScaLBL_D3Q7_AAodd_FreeLee_PhaseField(int *neighborList, int
 		n = S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x + start;
 
 		if ( n<finish ){		
-
 			/* load phase indicator field */
 			idx = Map[n];
 			phi = Phi[idx];
+	        theta = 4.5*M*2.0*(1-phi*phi)/W;
 
 			/* velocity */
 			ux = Vel[0*Np+n];
@@ -252,12 +253,18 @@ __global__ void dvc_ScaLBL_D3Q7_AAodd_FreeLee_PhaseField(int *neighborList, int
 
 	        //-------------------------------- BGK collison for phase field ---------------------------------//
 			h0 -= (h0 - 0.3333333333333333*phi)/tauM;
-			h1 -= (h1 - phi*(0.1111111111111111 + 0.5*ux) - (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
-			h2 -= (h2 - phi*(0.1111111111111111 - 0.5*ux) + (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
-			h3 -= (h3 - phi*(0.1111111111111111 + 0.5*uy) - (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
-			h4 -= (h4 - phi*(0.1111111111111111 - 0.5*uy) + (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
-			h5 -= (h5 - phi*(0.1111111111111111 + 0.5*uz) - (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
-			h6 -= (h6 - phi*(0.1111111111111111 - 0.5*uz) + (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+	//		h1 -= (h1 - phi*(0.1111111111111111 + 0.5*ux) - (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
+	//		h2 -= (h2 - phi*(0.1111111111111111 - 0.5*ux) + (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
+	//		h3 -= (h3 - phi*(0.1111111111111111 + 0.5*uy) - (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
+	//		h4 -= (h4 - phi*(0.1111111111111111 - 0.5*uy) + (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
+	//		h5 -= (h5 - phi*(0.1111111111111111 + 0.5*uz) - (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+	//		h6 -= (h6 - phi*(0.1111111111111111 - 0.5*uz) + (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+			h1 -= (h1 - 0.1111111111111111*nx*theta - phi*(0.1111111111111111 + 0.5*ux))/tauM;
+			h2 -= (h2 + 0.1111111111111111*nx*theta - phi*(0.1111111111111111 - 0.5*ux))/tauM;
+			h3 -= (h3 - 0.1111111111111111*ny*theta - phi*(0.1111111111111111 + 0.5*uy))/tauM;
+			h4 -= (h4 + 0.1111111111111111*ny*theta - phi*(0.1111111111111111 - 0.5*uy))/tauM;
+			h5 -= (h5 - 0.1111111111111111*nz*theta - phi*(0.1111111111111111 + 0.5*uz))/tauM;
+			h6 -= (h6 + 0.1111111111111111*nz*theta - phi*(0.1111111111111111 - 0.5*uz))/tauM; 
 			//........................................................................
 			
 			/*Update the distributions */
@@ -295,6 +302,7 @@ __global__ void dvc_ScaLBL_D3Q7_AAeven_FreeLee_PhaseField( int *Map, double *hq,
 			/* load phase indicator field */
 			idx = Map[n];
 			phi = Phi[idx];
+	        theta = 4.5*M*2.0*(1-phi*phi)/W;
 
 			/* velocity */
 			ux = Vel[0*Np+n];
@@ -323,12 +331,18 @@ __global__ void dvc_ScaLBL_D3Q7_AAeven_FreeLee_PhaseField( int *Map, double *hq,
 
 			//-------------------------------- BGK collison for phase field ---------------------------------//
 			h0 -= (h0 - 0.3333333333333333*phi)/tauM;
-			h1 -= (h1 - phi*(0.1111111111111111 + 0.5*ux) - (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
-			h2 -= (h2 - phi*(0.1111111111111111 - 0.5*ux) + (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
-			h3 -= (h3 - phi*(0.1111111111111111 + 0.5*uy) - (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
-			h4 -= (h4 - phi*(0.1111111111111111 - 0.5*uy) + (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
-			h5 -= (h5 - phi*(0.1111111111111111 + 0.5*uz) - (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
-			h6 -= (h6 - phi*(0.1111111111111111 - 0.5*uz) + (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+	//		h1 -= (h1 - phi*(0.1111111111111111 + 0.5*ux) - (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
+	//		h2 -= (h2 - phi*(0.1111111111111111 - 0.5*ux) + (0.5*M*nx*(1 - factor*phi*phi))/W)/tauM;
+	//		h3 -= (h3 - phi*(0.1111111111111111 + 0.5*uy) - (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
+	//		h4 -= (h4 - phi*(0.1111111111111111 - 0.5*uy) + (0.5*M*ny*(1 - factor*phi*phi))/W)/tauM;
+	//		h5 -= (h5 - phi*(0.1111111111111111 + 0.5*uz) - (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+	//		h6 -= (h6 - phi*(0.1111111111111111 - 0.5*uz) + (0.5*M*nz*(1 - factor*phi*phi))/W)/tauM;
+			h1 -= (h1 - 0.1111111111111111*nx*theta - phi*(0.1111111111111111 + 0.5*ux))/tauM;
+			h2 -= (h2 + 0.1111111111111111*nx*theta - phi*(0.1111111111111111 - 0.5*ux))/tauM;
+			h3 -= (h3 - 0.1111111111111111*ny*theta - phi*(0.1111111111111111 + 0.5*uy))/tauM;
+			h4 -= (h4 + 0.1111111111111111*ny*theta - phi*(0.1111111111111111 - 0.5*uy))/tauM;
+			h5 -= (h5 - 0.1111111111111111*nz*theta - phi*(0.1111111111111111 + 0.5*uz))/tauM;
+			h6 -= (h6 + 0.1111111111111111*nz*theta - phi*(0.1111111111111111 - 0.5*uz))/tauM; 
 			//........................................................................
 
 			/*Update the distributions */
@@ -1474,6 +1488,1242 @@ __global__ void dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel(int *Map, double *dist, dou
 	}
 }
 
+
+
+__global__ void dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(int *neighborList, int *Map, double *dist, double *hq, double *Den,	double *Phi, double *mu_phi, double *Vel, double *Pressure, double *ColorGrad, 
+        double rhoA, double rhoB, double tauA, double tauB, double tauM, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
+        int strideY, int strideZ, int start, int finish, int Np){
+
+	int nr1,nr2,nr3,nr4,nr5,nr6,nr7,nr8,nr9,nr10,nr11,nr12,nr13,nr14,nr15,nr16,nr17,nr18;
+    double ux,uy,uz;//fluid velocity 
+    double p;//pressure
+    double chem;//chemical potential
+    double phi; //phase field
+    double rho0;//fluid density
+	// distribution functions
+	double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
+	double m0,m3,m5,m7;
+	double mm1,mm2,mm4,mm6,mm8,mm9,mm10,mm11,mm12,mm13,mm14,mm15,mm16,mm17,mm18;
+	double mm3,mm5,mm7;
+    double feq0,feq1,feq2,feq3,feq4,feq5,feq6,feq7,feq8,feq9,feq10,feq11,feq12,feq13,feq14,feq15,feq16,feq17,feq18;
+    double nx,ny,nz;//normal color gradient
+    double mgx,mgy,mgz;//mixed gradient reaching secondary neighbor
+
+	//double f0,f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18;
+    double h0,h1,h2,h3,h4,h5,h6;//distributions for LB phase field
+	double tau;//position dependent LB relaxation time for fluid
+    double C,theta;
+    double M = 2.0/9.0*(tauM-0.5);//diffusivity (or mobility) for the phase field D3Q7
+    double phi_temp;
+    
+    int S = Np/NBLOCKS/NTHREADS + 1;
+    for (int s=0; s<S; s++){
+
+		rho0 = Den[n];//load density
+
+		// Get the 1D index based on regular data layout
+		ijk = Map[n];
+        phi = Phi[ijk];// load phase field
+        phi_temp = phi;
+        if (phi>1.f) phi_temp=1.0;
+        if (phi<-1.f) phi_temp=-1.0;
+
+		// local relaxation time
+		tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
+
+		//					COMPUTE THE COLOR GRADIENT
+		//........................................................................
+		//.................Read Phase Indicator Values............................
+		//........................................................................
+		nn = ijk-1;							// neighbor index (get convention)
+		m1 = Phi[nn];						// get neighbor for phi - 1
+		//........................................................................
+		nn = ijk+1;							// neighbor index (get convention)
+		m2 = Phi[nn];						// get neighbor for phi - 2
+		//........................................................................
+		nn = ijk-strideY;							// neighbor index (get convention)
+		m3 = Phi[nn];					// get neighbor for phi - 3
+		//........................................................................
+		nn = ijk+strideY;							// neighbor index (get convention)
+		m4 = Phi[nn];					// get neighbor for phi - 4
+		//........................................................................
+		nn = ijk-strideZ;						// neighbor index (get convention)
+		m5 = Phi[nn];					// get neighbor for phi - 5
+		//........................................................................
+		nn = ijk+strideZ;						// neighbor index (get convention)
+		m6 = Phi[nn];					// get neighbor for phi - 6
+		//........................................................................
+		nn = ijk-strideY-1;						// neighbor index (get convention)
+		m7 = Phi[nn];					// get neighbor for phi - 7
+		//........................................................................
+		nn = ijk+strideY+1;						// neighbor index (get convention)
+		m8 = Phi[nn];					// get neighbor for phi - 8
+		//........................................................................
+		nn = ijk+strideY-1;						// neighbor index (get convention)
+		m9 = Phi[nn];					// get neighbor for phi - 9
+		//........................................................................
+		nn = ijk-strideY+1;						// neighbor index (get convention)
+		m10 = Phi[nn];					// get neighbor for phi - 10
+		//........................................................................
+		nn = ijk-strideZ-1;						// neighbor index (get convention)
+		m11 = Phi[nn];					// get neighbor for phi - 11
+		//........................................................................
+		nn = ijk+strideZ+1;						// neighbor index (get convention)
+		m12 = Phi[nn];					// get neighbor for phi - 12
+		//........................................................................
+		nn = ijk+strideZ-1;						// neighbor index (get convention)
+		m13 = Phi[nn];					// get neighbor for phi - 13
+		//........................................................................
+		nn = ijk-strideZ+1;						// neighbor index (get convention)
+		m14 = Phi[nn];					// get neighbor for phi - 14
+		//........................................................................
+		nn = ijk-strideZ-strideY;					// neighbor index (get convention)
+		m15 = Phi[nn];					// get neighbor for phi - 15
+		//........................................................................
+		nn = ijk+strideZ+strideY;					// neighbor index (get convention)
+		m16 = Phi[nn];					// get neighbor for phi - 16
+		//........................................................................
+		nn = ijk+strideZ-strideY;					// neighbor index (get convention)
+		m17 = Phi[nn];					// get neighbor for phi - 17
+		//........................................................................
+		nn = ijk-strideZ+strideY;					// neighbor index (get convention)
+		m18 = Phi[nn];					// get neighbor for phi - 18
+
+        // compute mixed difference (Eq.30, A.Fukhari et al. JCP 315(2016) 434-457)
+		//........................................................................
+		nn2x = ijk-2;							// neighbor index (get convention)
+		mm1 = Phi[nn2x];						// get neighbor for phi - 1
+        mm1 = 0.25*(-mm1+5.0*m1-3.0*phi-m2);
+		//........................................................................
+		nn2x = ijk+2;							// neighbor index (get convention)
+		mm2 = Phi[nn2x];						// get neighbor for phi - 2
+        mm2 = 0.25*(-mm2+5.0*m2-3.0*phi-m1);
+		//........................................................................
+		nn2x = ijk-strideY*2;							// neighbor index (get convention)
+		mm3 = Phi[nn2x];					// get neighbor for phi - 3
+        mm3 = 0.25*(-mm3+5.0*m3-3.0*phi-m4);
+		//........................................................................
+		nn2x = ijk+strideY*2;							// neighbor index (get convention)
+		mm4 = Phi[nn2x];					// get neighbor for phi - 4
+        mm4 = 0.25*(-mm4+5.0*m4-3.0*phi-m3);
+		//........................................................................
+		nn2x = ijk-strideZ*2;						// neighbor index (get convention)
+		mm5 = Phi[nn2x];					// get neighbor for phi - 5
+        mm5 = 0.25*(-mm5+5.0*m5-3.0*phi-m6);
+		//........................................................................
+		nn2x = ijk+strideZ*2;						// neighbor index (get convention)
+		mm6 = Phi[nn2x];					// get neighbor for phi - 6
+        mm6 = 0.25*(-mm6+5.0*m6-3.0*phi-m5);
+		//........................................................................
+		nn2x = ijk-strideY*2-2;						// neighbor index (get convention)
+		mm7 = Phi[nn2x];					// get neighbor for phi - 7
+        mm7 = 0.25*(-mm7+5.0*m7-3.0*phi-m8);
+		//........................................................................
+		nn2x = ijk+strideY*2+2;						// neighbor index (get convention)
+		mm8 = Phi[nn2x];					// get neighbor for phi - 8
+        mm8 = 0.25*(-mm8+5.0*m8-3.0*phi-m7);
+		//........................................................................
+		nn2x = ijk+strideY*2-2;						// neighbor index (get convention)
+		mm9 = Phi[nn2x];					// get neighbor for phi - 9
+        mm9 = 0.25*(-mm9+5.0*m9-3.0*phi-m10);
+		//........................................................................
+		nn2x = ijk-strideY*2+2;						// neighbor index (get convention)
+		mm10 = Phi[nn2x];					// get neighbor for phi - 10
+        mm10 = 0.25*(-mm10+5.0*m10-3.0*phi-m9);
+		//........................................................................
+		nn2x = ijk-strideZ*2-2;						// neighbor index (get convention)
+		mm11 = Phi[nn2x];					// get neighbor for phi - 11
+        mm11 = 0.25*(-mm11+5.0*m11-3.0*phi-m12);
+		//........................................................................
+		nn2x = ijk+strideZ*2+2;						// neighbor index (get convention)
+		mm12 = Phi[nn2x];					// get neighbor for phi - 12
+        mm12 = 0.25*(-mm12+5.0*m12-3.0*phi-m11);
+		//........................................................................
+		nn2x = ijk+strideZ*2-2;						// neighbor index (get convention)
+		mm13 = Phi[nn2x];					// get neighbor for phi - 13
+        mm13 = 0.25*(-mm13+5.0*m13-3.0*phi-m14);
+		//........................................................................
+		nn2x = ijk-strideZ*2+2;						// neighbor index (get convention)
+		mm14 = Phi[nn2x];					// get neighbor for phi - 14
+        mm14 = 0.25*(-mm14+5.0*m14-3.0*phi-m13);
+		//........................................................................
+		nn2x = ijk-strideZ*2-strideY*2;					// neighbor index (get convention)
+		mm15 = Phi[nn2x];					// get neighbor for phi - 15
+        mm15 = 0.25*(-mm15+5.0*m15-3.0*phi-m16);
+		//........................................................................
+		nn2x = ijk+strideZ*2+strideY*2;					// neighbor index (get convention)
+		mm16 = Phi[nn2x];					// get neighbor for phi - 16
+        mm16 = 0.25*(-mm16+5.0*m16-3.0*phi-m15);
+		//........................................................................
+		nn2x = ijk+strideZ*2-strideY*2;					// neighbor index (get convention)
+		mm17 = Phi[nn2x];					// get neighbor for phi - 17
+        mm17 = 0.25*(-mm17+5.0*m17-3.0*phi-m18);
+		//........................................................................
+		nn2x = ijk-strideZ*2+strideY*2;					// neighbor index (get convention)
+		mm18 = Phi[nn2x];					// get neighbor for phi - 18
+        mm18 = 0.25*(-mm18+5.0*m18-3.0*phi-m17);
+
+
+		//............Compute the Color Gradient...................................
+		nx = -3.0*1.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+		ny = -3.0*1.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+		nz = -3.0*1.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+		//............Compute the Chemical Potential...............................
+        //chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi));//intermediate var, i.e. the laplacian
+        //chem = 4.0*beta*phi*(phi+1.0)*(phi-1.0)-kappa*chem;
+        chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi_temp+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi_temp));//intermediate var, i.e. the laplacian
+        chem = 4.0*beta*phi_temp*(phi_temp+1.0)*(phi_temp-1.0)-kappa*chem;
+		//............Compute the Mixed Gradient...................................
+		mgx = -3.0*1.0/18.0*(mm1-mm2+0.5*(mm7-mm8+mm9-mm10+mm11-mm12+mm13-mm14));
+		mgy = -3.0*1.0/18.0*(mm3-mm4+0.5*(mm7-mm8-mm9+mm10+mm15-mm16+mm17-mm18));
+		mgz = -3.0*1.0/18.0*(mm5-mm6+0.5*(mm11-mm12-mm13+mm14+mm15-mm16-mm17+mm18));
+		
+        //de-noise color gradient and mixed gradient
+		C = sqrt(nx*nx+ny*ny+nz*nz);
+		if (C<1.0e-12) nx=ny=nz=0.0;
+		double mg_mag = sqrt(mgx*mgx+mgy*mgy+mgz*mgz);
+		if (mg_mag<1.0e-12) mgx=mgy=mgz=0.0;
+        //maybe you can also de-noise chemical potential ? within the bulk phase chem should be ZERO
+        if (fabs(chem)<1.0e-12) chem=0.0;
+
+		// q=0
+		m0 = dist[n];
+		// q=1
+		nr1 = neighborList[n]; // neighbor 2 ( > 10Np => odd part of dist)
+		m1 = dist[nr1]; // reading the f1 data into register fq
+
+		nr2 = neighborList[n+Np]; // neighbor 1 ( < 10Np => even part of dist)
+		m2 = dist[nr2];  // reading the f2 data into register fq
+
+		// q=3
+		nr3 = neighborList[n+2*Np]; // neighbor 4
+		m3 = dist[nr3];
+
+		// q = 4
+		nr4 = neighborList[n+3*Np]; // neighbor 3
+		m4 = dist[nr4];
+
+		// q=5
+		nr5 = neighborList[n+4*Np];
+		m5 = dist[nr5];
+
+		// q = 6
+		nr6 = neighborList[n+5*Np];
+		m6 = dist[nr6];
+		
+		// q=7
+		nr7 = neighborList[n+6*Np];
+		m7 = dist[nr7];
+
+		// q = 8
+		nr8 = neighborList[n+7*Np];
+		m8 = dist[nr8];
+
+		// q=9
+		nr9 = neighborList[n+8*Np];
+		m9 = dist[nr9];
+
+		// q = 10
+		nr10 = neighborList[n+9*Np];
+		m10 = dist[nr10];
+
+		// q=11
+		nr11 = neighborList[n+10*Np];
+		m11 = dist[nr11];
+
+		// q=12
+		nr12 = neighborList[n+11*Np];
+		m12 = dist[nr12];
+
+		// q=13
+		nr13 = neighborList[n+12*Np];
+		m13 = dist[nr13];
+
+		// q=14
+		nr14 = neighborList[n+13*Np];
+		m14 = dist[nr14];
+
+		// q=15
+		nr15 = neighborList[n+14*Np];
+		m15 = dist[nr15];
+
+		// q=16
+		nr16 = neighborList[n+15*Np];
+		m16 = dist[nr16];
+
+		// q=17
+		nr17 = neighborList[n+16*Np];
+		m17 = dist[nr17];
+
+		// q=18
+		nr18 = neighborList[n+17*Np];
+		m18 = dist[nr18];
+
+        //compute fluid velocity
+        ux = 3.0/rho0*(m1-m2+m7-m8+m9-m10+m11-m12+m13-m14+0.5*(chem*nx+Fx)/3.0);
+        uy = 3.0/rho0*(m3-m4+m7-m8-m9+m10+m15-m16+m17-m18+0.5*(chem*ny+Fy)/3.0);
+        uz = 3.0/rho0*(m5-m6+m11-m12-m13+m14+m15-m16-m17+m18+0.5*(chem*nz+Fz)/3.0);
+        //compute pressure
+        p = (m0+m2+m1+m4+m3+m6+m5+m8+m7+m10+m9+m12+m11+m14+m13+m16+m15+m18+m17)
+                  +0.5*(rhoA-rhoB)/2.0/3.0*(ux*nx+uy*ny+uz*nz);
+
+        //compute equilibrium distributions
+            feq0 = 0.3333333333333333*p - 0.25*(Fx*ux + Fy*uy + Fz*uz)*(-0.6666666666666666 + ux*ux + uy*uy + uz*uz) - 
+     0.16666666666666666*rho0*(ux*ux + uy*uy + uz*uz) - 0.5*(-(nx*ux) - ny*uy - nz*uz)*
+      (-0.08333333333333333*(rhoA - rhoB)*(ux*ux + uy*uy + uz*uz) + chem*(0.3333333333333333 - 0.5*(ux*ux + uy*uy + uz*uz)));
+            feq1 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-ux*ux + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*uz)) - 
+     0.125*(Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 
+       0.3333333333333333*(-2.*ux + ux*ux + uy*uy + uz*uz)) - 0.0625*(nx - nx*ux - ny*uy - nz*uz)*
+      (2*chem*ux*ux - 0.3333333333333333*((-rhoA + rhoB)*ux*ux + 2*chem*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*uz)));
+            feq2 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-ux*ux + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*uz)) - 
+     0.125*(Fx + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 
+       0.3333333333333333*(2.*ux + ux*ux + uy*uy + uz*uz)) - 0.0625*(nx + nx*ux + ny*uy + nz*uz)*
+      (-2.*chem*ux*ux + 0.1111111111111111*(-4.*chem + rhoB*(-2.*ux - 1.*ux*ux - 1.*uy*uy - 1.*uz*uz) + 
+         rhoA*(2.*ux + ux*ux + uy*uy + uz*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*ux*ux + 
+         chem*(4.*ux + 2.*ux*ux + 2.*uy*uy + 2.*uz*uz)));
+            feq3 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uy*uy + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*uz)) - 
+     0.125*(Fx*ux + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 
+       0.3333333333333333*(ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.0625*(ny - nx*ux - ny*uy - nz*uz)*
+      (2*chem*uy*uy - 0.3333333333333333*((-rhoA + rhoB)*uy*uy + 2*chem*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*uz)));
+            feq4 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uy*uy + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*uz)) - 
+     0.125*(Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 
+       0.3333333333333333*(ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.0625*(ny + nx*ux + ny*uy + nz*uz)*
+      (-2.*chem*uy*uy + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 2.*uy - 1.*uy*uy - 1.*uz*uz) + 
+         rhoA*(ux*ux + 2.*uy + uy*uy + uz*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*uy*uy + 
+         chem*(2.*ux*ux + 4.*uy + 2.*uy*uy + 2.*uz*uz))); 
+            feq5 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uz*uz + 0.3333333333333333*(ux*ux + uy*uy + (-2 + uz)*uz)) - 
+     0.125*(Fx*ux + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + uy*uy + (-2. + uz)*uz)) - 0.0625*(nx*ux + ny*uy + nz*(-1. + uz))*
+      (-2.*chem*uz*uz + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 1.*uy*uy + (2. - 1.*uz)*uz) + 
+         rhoA*(ux*ux + uy*uy + (-2. + uz)*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*uz*uz + 
+         chem*(2.*ux*ux + 2.*uy*uy + uz*(-4. + 2.*uz)))); 
+            feq6 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uz*uz + 0.3333333333333333*(ux*ux + uy*uy + uz*(2 + uz))) - 
+     0.125*(Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + uy*uy + uz*(2. + uz))) - 0.0625*(nz + nx*ux + ny*uy + nz*uz)*
+      (-2.*chem*uz*uz + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 1.*uy*uy + (-2. - 1.*uz)*uz) + 
+         rhoA*(ux*ux + uy*uy + uz*(2. + uz))) + 0.3333333333333333*((-1.*rhoA + rhoB)*uz*uz + 
+         chem*(2.*ux*ux + 2.*uy*uy + uz*(4. + 2.*uz)))); 
+            feq7 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uy)*(ux + uy) + 0.3333333333333333*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fx*(-1. + ux) + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(-2.*ux + ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.03125*(nx + ny - nx*ux - ny*uy - nz*uz)*
+      (2*chem*(ux + uy)*(ux + uy) + 0.3333333333333333*((rhoA - rhoB)*(ux + uy)*(ux + uy) - 2*chem*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz))); 
+            feq8 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uy)*(ux + uy) + 0.3333333333333333*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fx + Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(2.*ux + ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.03125*(-(nx*(1 + ux)) - ny*(1 + uy) - nz*uz)*
+      (2*chem*(ux + uy)*(ux + uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux + uy)*(ux + uy)) + 
+         2*chem*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz))); 
+            feq9 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uy)*(ux - uy) + 0.3333333333333333*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fy + Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(-2.*ux + ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.03125*(nx - nx*ux - ny*(1 + uy) - nz*uz)*
+      (2*chem*(ux - uy)*(ux - uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uy)*(ux - uy)) + 
+         2*chem*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz))); 
+            feq10 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uy)*(ux - uy) + 0.3333333333333333*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) - 
+     0.0625*(Fx*(1 + ux) + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uy - 1.*uy*uy + 
+       0.3333333333333333*(2.*ux + ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.03125*(ny - nx*(1 + ux) - ny*uy - nz*uz)*
+      (2*chem*(ux - uy)*(ux - uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uy)*(ux - uy)) + 
+         2*chem*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz))); 
+            feq11 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uz)*(ux + uz) + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*(-1. + ux) + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(-2.*ux + ux*ux + uy*uy + (-2. + uz)*uz)) - 0.03125*(nx + nz - nx*ux - ny*uy - nz*uz)*
+      (2*chem*(ux + uz)*(ux + uz) + 0.3333333333333333*((rhoA - rhoB)*(ux + uz)*(ux + uz) - 2*chem*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz))); 
+            feq12 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux + uz)*(ux + uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fx + Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(2.*ux + ux*ux + uy*uy + uz*(2. + uz))) - 0.03125*(-(nx*(1 + ux)) - ny*uy - nz*(1 + uz))*
+      (2*chem*(ux + uz)*(ux + uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux + uz)*(ux + uz)) + 
+         2*chem*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))); 
+            feq13 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uz)*(ux - uz) + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fz + Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(-2.*ux + ux*ux + uy*uy + uz*(2. + uz))) - 0.03125*(nx - nx*ux - ny*uy - nz*(1 + uz))*
+      (2*chem*(ux - uz)*(ux - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uz)*(ux - uz)) + 
+         2*chem*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*(2 + uz)))); 
+            feq14 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(ux - uz)*(ux - uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*(1 + ux) + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uz - 1.*uz*uz + 
+       0.3333333333333333*(2.*ux + ux*ux + uy*uy + (-2. + uz)*uz)) - 0.03125*(nz - nx*(1 + ux) - ny*uy - nz*uz)*
+      (2*chem*(ux - uz)*(ux - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uz)*(ux - uz)) + 
+         2*chem*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz))); 
+            feq15 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*ux + Fy*(-1. + uy) + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uy*uy - 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux - 2.*uy + uy*uy + (-2. + uz)*uz)) - 0.03125*(ny + nz - nx*ux - ny*uy - nz*uz)*
+      (2*chem*(uy + uz)*(uy + uz) + 0.3333333333333333*((rhoA - rhoB)*(uy + uz)*(uy + uz) - 2*chem*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) + 
+       0.1111111111111111*(4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))); 
+            feq16 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fy + Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy - 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + 2.*uy + uy*uy + uz*(2. + uz))) - 0.03125*(-(nx*ux) - ny*(1 + uy) - nz*(1 + uz))*
+      (2*chem*(uy + uz)*(uy + uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy + uz)*(uy + uz)) + 
+         2*chem*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))); 
+            feq17 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) - 
+     0.0625*(Fz + Fx*ux + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux - 2.*uy + uy*uy + uz*(2. + uz))) - 0.03125*(ny - nx*ux - ny*uy - nz*(1 + uz))*
+      (2*chem*(uy - uz)*(uy - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy - uz)*(uy - uz)) + 
+         2*chem*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))); 
+            feq18 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+      (-(uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) - 
+     0.0625*(Fx*ux + Fy*(1 + uy) + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uy*uy + 2.*uy*uz - 1.*uz*uz + 
+       0.3333333333333333*(ux*ux + 2.*uy + uy*uy + (-2. + uz)*uz)) - 0.03125*(nz - nx*ux - ny*(1 + uy) - nz*uz)*
+      (2*chem*(uy - uz)*(uy - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy - uz)*(uy - uz)) + 
+         2*chem*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 0.1111111111111111*
+        (4*chem - (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz))); 
+
+        //------------------------------------------------- BCK collison ------------------------------------------------------------//
+		// q=0
+		dist[n] = m0 - (m0-feq0)/tau + 0.25*(2*(Fx*ux + Fy*uy + Fz*uz)*(-0.6666666666666666 + ux*ux + uy*uy + uz*uz) + 
+     (mgx*ux + mgy*uy + mgz*uz)*(2*chem*(ux*ux + uy*uy + uz*uz) + 
+        0.3333333333333333*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + uz*uz)))); 
+
+		// q = 1
+		dist[nr2] = m1 - (m1-feq1)/tau + 0.125*(2*(Fx*(-1 + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - ux*ux + 
+        0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+     (mgx*(-1 + ux) + mgy*uy + mgz*uz)*(-2*chem*(ux*ux) + 
+        0.3333333333333333*((-rhoA + rhoB)*(ux*ux) + 2*chem*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*uz))));
+
+		// q=2
+		dist[nr1] = m2 - (m2-feq2)/tau + 0.125*(2*(Fx + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - ux*ux + 
+        0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*uz)) + 
+     (mgx + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(ux*ux) + 
+        0.3333333333333333*((-rhoA + rhoB)*(ux*ux) + 2*chem*(2*ux + ux*ux + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*uz))));
+
+		// q = 3
+		dist[nr4] = m3 - (m3-feq3)/tau + 0.125*(2*(Fx*ux + Fy*(-1 + uy) + Fz*uz)*(-0.2222222222222222 - uy*uy + 
+        0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+     (mgx*ux + mgy*(-1 + uy) + mgz*uz)*(-2*chem*(uy*uy) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uy*uy) + 2*chem*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*uz))));
+
+		// q = 4
+		dist[nr3] = m4 - (m4-feq4)/tau + 0.125*(2*(Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - uy*uy + 
+        0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*uz)) + 
+     (mgy + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(uy*uy) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uy*uy) + 2*chem*(ux*ux + 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*uz))));
+
+		// q = 5
+		dist[nr6] = m5 - (m5-feq5)/tau + 0.125*(2*(Fx*ux + Fy*uy + Fz*(-1 + uz))*(-0.2222222222222222 - uz*uz + 
+        0.3333333333333333*(ux*ux + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*ux + mgy*uy + mgz*(-1 + uz))*(-2*chem*(uz*uz) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uz*uz) + 2*chem*(ux*ux + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + (-2 + uz)*uz))));
+
+		// q = 6
+		dist[nr5] = m6 - (m6-feq6)/tau + 0.125*(2*(Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - uz*uz + 
+        0.3333333333333333*(ux*ux + uy*uy + uz*(2 + uz))) + 
+     (mgz + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(uz*uz) + 
+        0.3333333333333333*((-rhoA + rhoB)*(uz*uz) + 2*chem*(ux*ux + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + uz*(2 + uz)))));
+
+		// q = 7
+		dist[nr8] = m7 - (m7-feq7)/tau + 0.0625*(-2*(Fx*(-1 + ux) + Fy*(-1 + uy) + Fz*uz)*
+      (0.2222222222222222 + (ux + uy)*(ux + uy) - 
+        0.3333333333333333*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+     (mgx*(-1 + ux) + mgy*(-1 + uy) + mgz*uz)*
+      (-2*chem*((ux + uy)*(ux + uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uy)*(ux + uy))) + 2*chem*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz))));
+
+		// q = 8
+		dist[nr7] = m8 - (m8-feq8)/tau + 0.0625*(2*(Fx + Fy + Fx*ux + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux + uy)*(ux + uy) + 
+        0.3333333333333333*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+     (mgx + mgy + mgx*ux + mgy*uy + mgz*uz)*
+      (-2*chem*((ux + uy)*(ux + uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uy)*(ux + uy))) + 2*chem*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz))));
+
+		// q = 9
+		dist[nr10] = m9 - (m9-feq9)/tau + 0.0625*(2*(Fy + Fx*(-1 + ux) + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux - uy)*(ux - uy) + 
+        0.3333333333333333*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+     (mgy + mgx*(-1 + ux) + mgy*uy + mgz*uz)*
+      (-2*chem*((ux - uy)*(ux - uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uy)*(ux - uy))) + 2*chem*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz))));
+
+		// q = 10
+		dist[nr9] = m10 - (m10-feq10)/tau + 0.0625*(2*(Fx*(1 + ux) + Fy*(-1 + uy) + Fz*uz)*
+      (-0.2222222222222222 - (ux - uy)*(ux - uy) + 
+        0.3333333333333333*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+     (mgx*(1 + ux) + mgy*(-1 + uy) + mgz*uz)*
+      (-2*chem*((ux - uy)*(ux - uy)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uy)*(ux - uy))) + 2*chem*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz))));
+
+		// q = 11
+		dist[nr12] = m11 - (m11-feq11)/tau + 0.0625*(-2*(Fx*(-1 + ux) + Fy*uy + Fz*(-1 + uz))*
+      (0.2222222222222222 + (ux + uz)*(ux + uz) - 
+        0.3333333333333333*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*(-1 + ux) + mgy*uy + mgz*(-1 + uz))*
+      (-2*chem*((ux + uz)*(ux + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uz)*(ux + uz))) + 2*chem*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz))));
+
+		// q = 12
+		dist[nr11] = m12 - (m12-feq12)/tau + 0.0625*(2*(Fx + Fz + Fx*ux + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux + uz)*(ux + uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))
+       + (mgx + mgz + mgx*ux + mgy*uy + mgz*uz)*
+      (-2*chem*((ux + uz)*(ux + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux + uz)*(ux + uz))) + 2*chem*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))));
+
+		// q = 13
+		dist[nr14] = m13 - (m13-feq13)/tau + 0.0625*(2*(Fz + Fx*(-1 + ux) + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (ux - uz)*(ux - uz) + 
+        0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+     (mgz + mgx*(-1 + ux) + mgy*uy + mgz*uz)*
+      (-2*chem*((ux - uz)*(ux - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uz)*(ux - uz))) + 2*chem*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*(2 + uz)))));
+
+		// q= 14
+		dist[nr13] = m14 - (m14-feq14)/tau + 0.0625*(2*(Fx*(1 + ux) + Fy*uy + Fz*(-1 + uz))*
+      (-0.2222222222222222 - (ux - uz)*(ux - uz) + 
+        0.3333333333333333*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*(1 + ux) + mgy*uy + mgz*(-1 + uz))*
+      (-2*chem*((ux - uz)*(ux - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((ux - uz)*(ux - uz))) + 2*chem*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz))));
+
+		// q = 15
+		dist[nr16] = m15 - (m15-feq15)/tau + 0.0625*(-2*(Fx*ux + Fy*(-1 + uy) + Fz*(-1 + uz))*
+      (0.2222222222222222 + (uy + uz)*(uy + uz) - 0.3333333333333333*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))
+       + (mgx*ux + mgy*(-1 + uy) + mgz*(-1 + uz))*
+      (-2*chem*((uy + uz)*(uy + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy + uz)*(uy + uz))) + 2*chem*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))));
+
+		// q = 16
+		dist[nr15] = m16 - (m16-feq16)/tau + 0.0625*(2*(Fy + Fz + Fx*ux + Fy*uy + Fz*uz)*
+      (-0.2222222222222222 - (uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))
+       + (mgy + mgz + mgx*ux + mgy*uy + mgz*uz)*
+      (-2*chem*((uy + uz)*(uy + uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy + uz)*(uy + uz))) + 2*chem*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))));
+
+		// q = 17
+		dist[nr18] = m17 - (m17-feq17)/tau + 0.0625*(2*(Fz + Fx*ux + Fy*(-1 + uy) + Fz*uz)*
+      (-0.2222222222222222 - (uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))
+       + (mgz + mgx*ux + mgy*(-1 + uy) + mgz*uz)*
+      (-2*chem*((uy - uz)*(uy - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy - uz)*(uy - uz))) + 2*chem*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))));
+
+		// q = 18
+		dist[nr17] = m18 - (m18-feq18)/tau + 0.0625*(2*(Fx*ux + Fy*(1 + uy) + Fz*(-1 + uz))*
+      (-0.2222222222222222 - (uy - uz)*(uy - uz) + 
+        0.3333333333333333*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 
+     (mgx*ux + mgy*(1 + uy) + mgz*(-1 + uz))*
+      (-2*chem*((uy - uz)*(uy - uz)) + 0.3333333333333333*
+         (-((rhoA - rhoB)*((uy - uz)*(uy - uz))) + 2*chem*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 
+        0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz))));
+        //----------------------------------------------------------------------------------------------------------------------------------------//
+
+
+        // ----------------------------- compute phase field evolution ----------------------------------------
+		//Normalize the Color Gradient
+		C = sqrt(nx*nx+ny*ny+nz*nz);
+		double ColorMag = C;
+		if (C==0.0) ColorMag=1.0;
+		nx = nx/ColorMag;
+		ny = ny/ColorMag;
+		nz = nz/ColorMag;		
+        //compute surface tension-related parameter
+        //theta = 4.5*M*2.0*(1-phi*phi)/W;
+        theta = 4.5*M*2.0*(1-phi_temp*phi_temp)/W;
+
+        //load distributions of phase field
+		//q=0
+		h0 = hq[n];
+		//q=1
+		h1 = hq[nr1]; 
+
+		//q=2
+		h2 = hq[nr2];  
+
+		//q=3
+		h3 = hq[nr3];
+
+		//q=4
+		h4 = hq[nr4];
+
+		//q=5
+		h5 = hq[nr5];
+
+		//q=6
+		h6 = hq[nr6];
+
+        //-------------------------------- BGK collison for phase field ---------------------------------//
+		// q = 0
+		hq[n] = h0 - (h0 - 0.3333333333333333*phi)/tauM;
+
+		// q = 1
+		hq[nr2] = h1 - (h1 - 0.1111111111111111*nx*theta - phi*(0.1111111111111111 + 0.5*ux))/tauM;
+
+		// q = 2
+		hq[nr1] = h2 - (h2 + 0.1111111111111111*nx*theta - phi*(0.1111111111111111 - 0.5*ux))/tauM;
+
+		// q = 3
+		hq[nr4] = h3 - (h3 - 0.1111111111111111*ny*theta - phi*(0.1111111111111111 + 0.5*uy))/tauM;
+
+		// q = 4
+		hq[nr3] = h4 - (h4 + 0.1111111111111111*ny*theta - phi*(0.1111111111111111 - 0.5*uy))/tauM;
+
+		// q = 5
+		hq[nr6] = h5 - (h5 - 0.1111111111111111*nz*theta - phi*(0.1111111111111111 + 0.5*uz))/tauM;
+
+		// q = 6
+		hq[nr5] = h6 - (h6 + 0.1111111111111111*nz*theta - phi*(0.1111111111111111 - 0.5*uz))/tauM;
+		//........................................................................
+
+        //Update velocity on device
+		Vel[0*Np+n] = ux;
+		Vel[1*Np+n] = uy;
+		Vel[2*Np+n] = uz;
+        //Update pressure on device
+        Pressure[n] = p;
+        //Update chemical potential on device
+        mu_phi[n] = chem;
+        //Update color gradient on device
+		ColorGrad[0*Np+n] = nx;
+		ColorGrad[1*Np+n] = ny;
+		ColorGrad[2*Np+n] = nz;
+    }
+}
+
+__global__ void dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(int *Map, double *dist, double *hq, double *Den,	double *Phi, double *mu_phi, double *Vel, double *Pressure, double *ColorGrad,
+        double rhoA, double rhoB, double tauA, double tauB, double tauM, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
+        int strideY, int strideZ, int start, int finish, int Np){
+
+	int n,nn,nn2x,ijk;
+	//int nr1,nr2,nr3,nr4,nr5,nr6,nr7,nr8,nr9,nr10,nr11,nr12,nr13,nr14,nr15,nr16,nr17,nr18;
+    double ux,uy,uz;//fluid velocity 
+    double p;//pressure
+    double chem;//chemical potential
+    double phi; //phase field
+    double rho0;//fluid density
+	// distribution functions
+	double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
+	double m0,m3,m5,m7;
+	double mm1,mm2,mm4,mm6,mm8,mm9,mm10,mm11,mm12,mm13,mm14,mm15,mm16,mm17,mm18;
+	double mm3,mm5,mm7;
+    double feq0,feq1,feq2,feq3,feq4,feq5,feq6,feq7,feq8,feq9,feq10,feq11,feq12,feq13,feq14,feq15,feq16,feq17,feq18;
+    double nx,ny,nz;//normal color gradient
+    double mgx,mgy,mgz;//mixed gradient reaching secondary neighbor
+
+	//double f0,f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18;
+    double h0,h1,h2,h3,h4,h5,h6;//distributions for LB phase field
+	double tau;//position dependent LB relaxation time for fluid
+    double C,theta;
+    double M = 2.0/9.0*(tauM-0.5);//diffusivity (or mobility) for the phase field D3Q7
+    double phi_temp;
+    
+    //	for (int n=start; n<finish; n++){
+    int S = Np/NBLOCKS/NTHREADS + 1;
+    for (int s=0; s<S; s++){
+    	//........Get 1-D index for this thread....................
+    	n = S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x + start;
+
+    	if ( n<finish ){
+    		rho0 = Den[n];//load density
+
+    		// Get the 1D index based on regular data layout
+    		ijk = Map[n];
+            phi = Phi[ijk];// load phase field
+            phi_temp = phi;
+            if (phi>1.f) phi_temp=1.0;
+            if (phi<-1.f) phi_temp=-1.0;
+
+    		// local relaxation time
+    		tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
+
+    		//					COMPUTE THE COLOR GRADIENT
+    		//........................................................................
+    		//.................Read Phase Indicator Values............................
+    		//........................................................................
+    		nn = ijk-1;							// neighbor index (get convention)
+    		m1 = Phi[nn];						// get neighbor for phi - 1
+    		//........................................................................
+    		nn = ijk+1;							// neighbor index (get convention)
+    		m2 = Phi[nn];						// get neighbor for phi - 2
+    		//........................................................................
+    		nn = ijk-strideY;							// neighbor index (get convention)
+    		m3 = Phi[nn];					// get neighbor for phi - 3
+    		//........................................................................
+    		nn = ijk+strideY;							// neighbor index (get convention)
+    		m4 = Phi[nn];					// get neighbor for phi - 4
+    		//........................................................................
+    		nn = ijk-strideZ;						// neighbor index (get convention)
+    		m5 = Phi[nn];					// get neighbor for phi - 5
+    		//........................................................................
+    		nn = ijk+strideZ;						// neighbor index (get convention)
+    		m6 = Phi[nn];					// get neighbor for phi - 6
+    		//........................................................................
+    		nn = ijk-strideY-1;						// neighbor index (get convention)
+    		m7 = Phi[nn];					// get neighbor for phi - 7
+    		//........................................................................
+    		nn = ijk+strideY+1;						// neighbor index (get convention)
+    		m8 = Phi[nn];					// get neighbor for phi - 8
+    		//........................................................................
+    		nn = ijk+strideY-1;						// neighbor index (get convention)
+    		m9 = Phi[nn];					// get neighbor for phi - 9
+    		//........................................................................
+    		nn = ijk-strideY+1;						// neighbor index (get convention)
+    		m10 = Phi[nn];					// get neighbor for phi - 10
+    		//........................................................................
+    		nn = ijk-strideZ-1;						// neighbor index (get convention)
+    		m11 = Phi[nn];					// get neighbor for phi - 11
+    		//........................................................................
+    		nn = ijk+strideZ+1;						// neighbor index (get convention)
+    		m12 = Phi[nn];					// get neighbor for phi - 12
+    		//........................................................................
+    		nn = ijk+strideZ-1;						// neighbor index (get convention)
+    		m13 = Phi[nn];					// get neighbor for phi - 13
+    		//........................................................................
+    		nn = ijk-strideZ+1;						// neighbor index (get convention)
+    		m14 = Phi[nn];					// get neighbor for phi - 14
+    		//........................................................................
+    		nn = ijk-strideZ-strideY;					// neighbor index (get convention)
+    		m15 = Phi[nn];					// get neighbor for phi - 15
+    		//........................................................................
+    		nn = ijk+strideZ+strideY;					// neighbor index (get convention)
+    		m16 = Phi[nn];					// get neighbor for phi - 16
+    		//........................................................................
+    		nn = ijk+strideZ-strideY;					// neighbor index (get convention)
+    		m17 = Phi[nn];					// get neighbor for phi - 17
+    		//........................................................................
+    		nn = ijk-strideZ+strideY;					// neighbor index (get convention)
+    		m18 = Phi[nn];					// get neighbor for phi - 18
+
+            // compute mixed difference (Eq.30, A.Fukhari et al. JCP 315(2016) 434-457)
+    		//........................................................................
+    		nn2x = ijk-2;							// neighbor index (get convention)
+    		mm1 = Phi[nn2x];						// get neighbor for phi - 1
+            mm1 = 0.25*(-mm1+5.0*m1-3.0*phi-m2);
+    		//........................................................................
+    		nn2x = ijk+2;							// neighbor index (get convention)
+    		mm2 = Phi[nn2x];						// get neighbor for phi - 2
+            mm2 = 0.25*(-mm2+5.0*m2-3.0*phi-m1);
+    		//........................................................................
+    		nn2x = ijk-strideY*2;							// neighbor index (get convention)
+    		mm3 = Phi[nn2x];					// get neighbor for phi - 3
+            mm3 = 0.25*(-mm3+5.0*m3-3.0*phi-m4);
+    		//........................................................................
+    		nn2x = ijk+strideY*2;							// neighbor index (get convention)
+    		mm4 = Phi[nn2x];					// get neighbor for phi - 4
+            mm4 = 0.25*(-mm4+5.0*m4-3.0*phi-m3);
+    		//........................................................................
+    		nn2x = ijk-strideZ*2;						// neighbor index (get convention)
+    		mm5 = Phi[nn2x];					// get neighbor for phi - 5
+            mm5 = 0.25*(-mm5+5.0*m5-3.0*phi-m6);
+    		//........................................................................
+    		nn2x = ijk+strideZ*2;						// neighbor index (get convention)
+    		mm6 = Phi[nn2x];					// get neighbor for phi - 6
+            mm6 = 0.25*(-mm6+5.0*m6-3.0*phi-m5);
+    		//........................................................................
+    		nn2x = ijk-strideY*2-2;						// neighbor index (get convention)
+    		mm7 = Phi[nn2x];					// get neighbor for phi - 7
+            mm7 = 0.25*(-mm7+5.0*m7-3.0*phi-m8);
+    		//........................................................................
+    		nn2x = ijk+strideY*2+2;						// neighbor index (get convention)
+    		mm8 = Phi[nn2x];					// get neighbor for phi - 8
+            mm8 = 0.25*(-mm8+5.0*m8-3.0*phi-m7);
+    		//........................................................................
+    		nn2x = ijk+strideY*2-2;						// neighbor index (get convention)
+    		mm9 = Phi[nn2x];					// get neighbor for phi - 9
+            mm9 = 0.25*(-mm9+5.0*m9-3.0*phi-m10);
+    		//........................................................................
+    		nn2x = ijk-strideY*2+2;						// neighbor index (get convention)
+    		mm10 = Phi[nn2x];					// get neighbor for phi - 10
+            mm10 = 0.25*(-mm10+5.0*m10-3.0*phi-m9);
+    		//........................................................................
+    		nn2x = ijk-strideZ*2-2;						// neighbor index (get convention)
+    		mm11 = Phi[nn2x];					// get neighbor for phi - 11
+            mm11 = 0.25*(-mm11+5.0*m11-3.0*phi-m12);
+    		//........................................................................
+    		nn2x = ijk+strideZ*2+2;						// neighbor index (get convention)
+    		mm12 = Phi[nn2x];					// get neighbor for phi - 12
+            mm12 = 0.25*(-mm12+5.0*m12-3.0*phi-m11);
+    		//........................................................................
+    		nn2x = ijk+strideZ*2-2;						// neighbor index (get convention)
+    		mm13 = Phi[nn2x];					// get neighbor for phi - 13
+            mm13 = 0.25*(-mm13+5.0*m13-3.0*phi-m14);
+    		//........................................................................
+    		nn2x = ijk-strideZ*2+2;						// neighbor index (get convention)
+    		mm14 = Phi[nn2x];					// get neighbor for phi - 14
+            mm14 = 0.25*(-mm14+5.0*m14-3.0*phi-m13);
+    		//........................................................................
+    		nn2x = ijk-strideZ*2-strideY*2;					// neighbor index (get convention)
+    		mm15 = Phi[nn2x];					// get neighbor for phi - 15
+            mm15 = 0.25*(-mm15+5.0*m15-3.0*phi-m16);
+    		//........................................................................
+    		nn2x = ijk+strideZ*2+strideY*2;					// neighbor index (get convention)
+    		mm16 = Phi[nn2x];					// get neighbor for phi - 16
+            mm16 = 0.25*(-mm16+5.0*m16-3.0*phi-m15);
+    		//........................................................................
+    		nn2x = ijk+strideZ*2-strideY*2;					// neighbor index (get convention)
+    		mm17 = Phi[nn2x];					// get neighbor for phi - 17
+            mm17 = 0.25*(-mm17+5.0*m17-3.0*phi-m18);
+    		//........................................................................
+    		nn2x = ijk-strideZ*2+strideY*2;					// neighbor index (get convention)
+    		mm18 = Phi[nn2x];					// get neighbor for phi - 18
+            mm18 = 0.25*(-mm18+5.0*m18-3.0*phi-m17);
+
+
+    		//............Compute the Color Gradient...................................
+    		nx = -3.0*1.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+    		ny = -3.0*1.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+    		nz = -3.0*1.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+    		//............Compute the Chemical Potential...............................
+            //chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi));//intermediate var, i.e. the laplacian
+            //chem = 4.0*beta*phi*(phi+1.0)*(phi-1.0)-kappa*chem;
+            chem = 2.0*3.0/18.0*(m1+m2+m3+m4+m5+m6-6*phi_temp+0.5*(m7+m8+m9+m10+m11+m12+m13+m14+m15+m16+m17+m18-12*phi_temp));//intermediate var, i.e. the laplacian
+            chem = 4.0*beta*phi_temp*(phi_temp+1.0)*(phi_temp-1.0)-kappa*chem;
+    		//............Compute the Mixed Gradient...................................
+    		mgx = -3.0*1.0/18.0*(mm1-mm2+0.5*(mm7-mm8+mm9-mm10+mm11-mm12+mm13-mm14));
+    		mgy = -3.0*1.0/18.0*(mm3-mm4+0.5*(mm7-mm8-mm9+mm10+mm15-mm16+mm17-mm18));
+    		mgz = -3.0*1.0/18.0*(mm5-mm6+0.5*(mm11-mm12-mm13+mm14+mm15-mm16-mm17+mm18));
+    		
+            //de-noise color gradient and mixed gradient
+    		C = sqrt(nx*nx+ny*ny+nz*nz);
+    		if (C<1.0e-12) nx=ny=nz=0.0;
+    		double mg_mag = sqrt(mgx*mgx+mgy*mgy+mgz*mgz);
+    		if (mg_mag<1.0e-12) mgx=mgy=mgz=0.0;
+            //maybe you can also de-noise chemical potential ? within the bulk phase chem should be ZERO
+            if (fabs(chem)<1.0e-12) chem=0.0;
+
+    		// q=0
+    		m0 = dist[n];
+    		// q=1
+    		m1 = dist[2*Np+n]; 
+
+            // q=2
+    		m2 = dist[1*Np+n];  
+
+    		// q=3
+    		m3 = dist[4*Np+n];
+
+    		// q = 4
+    		m4 = dist[3*Np+n];
+
+    		// q=5
+    		m5 = dist[6*Np+n];
+
+    		// q = 6
+    		m6 = dist[5*Np+n];
+    		
+    		// q=7
+    		m7 = dist[8*Np+n];
+
+    		// q = 8
+    		m8 = dist[7*Np+n];
+
+    		// q=9
+    		m9 = dist[10*Np+n];
+
+    		// q = 10
+    		m10 = dist[9*Np+n];
+
+    		// q=11
+    		m11 = dist[12*Np+n];
+
+    		// q=12
+    		m12 = dist[11*Np+n];
+
+    		// q=13
+    		m13 = dist[14*Np+n];
+
+    		// q=14
+    		m14 = dist[13*Np+n];
+
+    		// q=15
+    		m15 = dist[16*Np+n];
+
+    		// q=16
+    		m16 = dist[15*Np+n];
+
+    		// q=17
+    		m17 = dist[18*Np+n];
+
+    		// q=18
+    		m18 = dist[17*Np+n];
+
+            //compute fluid velocity
+            ux = 3.0/rho0*(m1-m2+m7-m8+m9-m10+m11-m12+m13-m14+0.5*(chem*nx+Fx)/3.0);
+            uy = 3.0/rho0*(m3-m4+m7-m8-m9+m10+m15-m16+m17-m18+0.5*(chem*ny+Fy)/3.0);
+            uz = 3.0/rho0*(m5-m6+m11-m12-m13+m14+m15-m16-m17+m18+0.5*(chem*nz+Fz)/3.0);
+            //compute pressure
+            p = (m0+m2+m1+m4+m3+m6+m5+m8+m7+m10+m9+m12+m11+m14+m13+m16+m15+m18+m17)
+                      +0.5*(rhoA-rhoB)/2.0/3.0*(ux*nx+uy*ny+uz*nz);
+
+            //compute equilibrium distributions
+                feq0 = 0.3333333333333333*p - 0.25*(Fx*ux + Fy*uy + Fz*uz)*(-0.6666666666666666 + ux*ux + uy*uy + uz*uz) - 
+         0.16666666666666666*rho0*(ux*ux + uy*uy + uz*uz) - 0.5*(-(nx*ux) - ny*uy - nz*uz)*
+          (-0.08333333333333333*(rhoA - rhoB)*(ux*ux + uy*uy + uz*uz) + chem*(0.3333333333333333 - 0.5*(ux*ux + uy*uy + uz*uz)));
+                feq1 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-ux*ux + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*uz)) - 
+         0.125*(Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 
+           0.3333333333333333*(-2.*ux + ux*ux + uy*uy + uz*uz)) - 0.0625*(nx - nx*ux - ny*uy - nz*uz)*
+          (2*chem*ux*ux - 0.3333333333333333*((-rhoA + rhoB)*ux*ux + 2*chem*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+           0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*uz)));
+                feq2 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-ux*ux + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*uz)) - 
+         0.125*(Fx + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 
+           0.3333333333333333*(2.*ux + ux*ux + uy*uy + uz*uz)) - 0.0625*(nx + nx*ux + ny*uy + nz*uz)*
+          (-2.*chem*ux*ux + 0.1111111111111111*(-4.*chem + rhoB*(-2.*ux - 1.*ux*ux - 1.*uy*uy - 1.*uz*uz) + 
+             rhoA*(2.*ux + ux*ux + uy*uy + uz*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*ux*ux + 
+             chem*(4.*ux + 2.*ux*ux + 2.*uy*uy + 2.*uz*uz)));
+                feq3 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uy*uy + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*uz)) - 
+         0.125*(Fx*ux + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 
+           0.3333333333333333*(ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.0625*(ny - nx*ux - ny*uy - nz*uz)*
+          (2*chem*uy*uy - 0.3333333333333333*((-rhoA + rhoB)*uy*uy + 2*chem*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+           0.1111111111111111*(4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*uz)));
+                feq4 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uy*uy + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*uz)) - 
+         0.125*(Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 
+           0.3333333333333333*(ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.0625*(ny + nx*ux + ny*uy + nz*uz)*
+          (-2.*chem*uy*uy + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 2.*uy - 1.*uy*uy - 1.*uz*uz) + 
+             rhoA*(ux*ux + 2.*uy + uy*uy + uz*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*uy*uy + 
+             chem*(2.*ux*ux + 4.*uy + 2.*uy*uy + 2.*uz*uz))); 
+                feq5 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uz*uz + 0.3333333333333333*(ux*ux + uy*uy + (-2 + uz)*uz)) - 
+         0.125*(Fx*ux + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uz*uz + 
+           0.3333333333333333*(ux*ux + uy*uy + (-2. + uz)*uz)) - 0.0625*(nx*ux + ny*uy + nz*(-1. + uz))*
+          (-2.*chem*uz*uz + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 1.*uy*uy + (2. - 1.*uz)*uz) + 
+             rhoA*(ux*ux + uy*uy + (-2. + uz)*uz)) + 0.3333333333333333*((-1.*rhoA + rhoB)*uz*uz + 
+             chem*(2.*ux*ux + 2.*uy*uy + uz*(-4. + 2.*uz)))); 
+                feq6 = 0.05555555555555555*p - 0.08333333333333333*rho0*(-uz*uz + 0.3333333333333333*(ux*ux + uy*uy + uz*(2 + uz))) - 
+         0.125*(Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uz*uz + 
+           0.3333333333333333*(ux*ux + uy*uy + uz*(2. + uz))) - 0.0625*(nz + nx*ux + ny*uy + nz*uz)*
+          (-2.*chem*uz*uz + 0.1111111111111111*(-4.*chem + rhoB*(-1.*ux*ux - 1.*uy*uy + (-2. - 1.*uz)*uz) + 
+             rhoA*(ux*ux + uy*uy + uz*(2. + uz))) + 0.3333333333333333*((-1.*rhoA + rhoB)*uz*uz + 
+             chem*(2.*ux*ux + 2.*uy*uy + uz*(4. + 2.*uz)))); 
+                feq7 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux + uy)*(ux + uy) + 0.3333333333333333*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) - 
+         0.0625*(Fx*(-1. + ux) + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uy - 1.*uy*uy + 
+           0.3333333333333333*(-2.*ux + ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.03125*(nx + ny - nx*ux - ny*uy - nz*uz)*
+          (2*chem*(ux + uy)*(ux + uy) + 0.3333333333333333*((rhoA - rhoB)*(ux + uy)*(ux + uy) - 2*chem*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+           0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz))); 
+                feq8 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux + uy)*(ux + uy) + 0.3333333333333333*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) - 
+         0.0625*(Fx + Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uy - 1.*uy*uy + 
+           0.3333333333333333*(2.*ux + ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.03125*(-(nx*(1 + ux)) - ny*(1 + uy) - nz*uz)*
+          (2*chem*(ux + uy)*(ux + uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux + uy)*(ux + uy)) + 
+             2*chem*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz))); 
+                feq9 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux - uy)*(ux - uy) + 0.3333333333333333*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) - 
+         0.0625*(Fy + Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uy - 1.*uy*uy + 
+           0.3333333333333333*(-2.*ux + ux*ux + 2.*uy + uy*uy + uz*uz)) - 0.03125*(nx - nx*ux - ny*(1 + uy) - nz*uz)*
+          (2*chem*(ux - uy)*(ux - uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uy)*(ux - uy)) + 
+             2*chem*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz))); 
+                feq10 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux - uy)*(ux - uy) + 0.3333333333333333*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) - 
+         0.0625*(Fx*(1 + ux) + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uy - 1.*uy*uy + 
+           0.3333333333333333*(2.*ux + ux*ux - 2.*uy + uy*uy + uz*uz)) - 0.03125*(ny - nx*(1 + ux) - ny*uy - nz*uz)*
+          (2*chem*(ux - uy)*(ux - uy) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uy)*(ux - uy)) + 
+             2*chem*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz))); 
+                feq11 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux + uz)*(ux + uz) + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) - 
+         0.0625*(Fx*(-1. + ux) + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uz - 1.*uz*uz + 
+           0.3333333333333333*(-2.*ux + ux*ux + uy*uy + (-2. + uz)*uz)) - 0.03125*(nx + nz - nx*ux - ny*uy - nz*uz)*
+          (2*chem*(ux + uz)*(ux + uz) + 0.3333333333333333*((rhoA - rhoB)*(ux + uz)*(ux + uz) - 2*chem*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+           0.1111111111111111*(4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz))); 
+                feq12 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux + uz)*(ux + uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) - 
+         0.0625*(Fx + Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux - 2.*ux*uz - 1.*uz*uz + 
+           0.3333333333333333*(2.*ux + ux*ux + uy*uy + uz*(2. + uz))) - 0.03125*(-(nx*(1 + ux)) - ny*uy - nz*(1 + uz))*
+          (2*chem*(ux + uz)*(ux + uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux + uz)*(ux + uz)) + 
+             2*chem*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))); 
+                feq13 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux - uz)*(ux - uz) + 0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) - 
+         0.0625*(Fz + Fx*(-1. + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uz - 1.*uz*uz + 
+           0.3333333333333333*(-2.*ux + ux*ux + uy*uy + uz*(2. + uz))) - 0.03125*(nx - nx*ux - ny*uy - nz*(1 + uz))*
+          (2*chem*(ux - uz)*(ux - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uz)*(ux - uz)) + 
+             2*chem*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*(2 + uz)))); 
+                feq14 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(ux - uz)*(ux - uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) - 
+         0.0625*(Fx*(1 + ux) + Fy*uy + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*ux*ux + 2.*ux*uz - 1.*uz*uz + 
+           0.3333333333333333*(2.*ux + ux*ux + uy*uy + (-2. + uz)*uz)) - 0.03125*(nz - nx*(1 + ux) - ny*uy - nz*uz)*
+          (2*chem*(ux - uz)*(ux - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(ux - uz)*(ux - uz)) + 
+             2*chem*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz))); 
+                feq15 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) - 
+         0.0625*(Fx*ux + Fy*(-1. + uy) + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uy*uy - 2.*uy*uz - 1.*uz*uz + 
+           0.3333333333333333*(ux*ux - 2.*uy + uy*uy + (-2. + uz)*uz)) - 0.03125*(ny + nz - nx*ux - ny*uy - nz*uz)*
+          (2*chem*(uy + uz)*(uy + uz) + 0.3333333333333333*((rhoA - rhoB)*(uy + uz)*(uy + uz) - 2*chem*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) + 
+           0.1111111111111111*(4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))); 
+                feq16 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) - 
+         0.0625*(Fy + Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy - 2.*uy*uz - 1.*uz*uz + 
+           0.3333333333333333*(ux*ux + 2.*uy + uy*uy + uz*(2. + uz))) - 0.03125*(-(nx*ux) - ny*(1 + uy) - nz*(1 + uz))*
+          (2*chem*(uy + uz)*(uy + uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy + uz)*(uy + uz)) + 
+             2*chem*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))); 
+                feq17 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) - 
+         0.0625*(Fz + Fx*ux + Fy*(-1. + uy) + Fz*uz)*(-0.2222222222222222 - 1.*uy*uy + 2.*uy*uz - 1.*uz*uz + 
+           0.3333333333333333*(ux*ux - 2.*uy + uy*uy + uz*(2. + uz))) - 0.03125*(ny - nx*ux - ny*uy - nz*(1 + uz))*
+          (2*chem*(uy - uz)*(uy - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy - uz)*(uy - uz)) + 
+             2*chem*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))); 
+                feq18 = 0.027777777777777776*p - 0.041666666666666664*rho0*
+          (-(uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) - 
+         0.0625*(Fx*ux + Fy*(1 + uy) + Fz*(-1. + uz))*(-0.2222222222222222 - 1.*uy*uy + 2.*uy*uz - 1.*uz*uz + 
+           0.3333333333333333*(ux*ux + 2.*uy + uy*uy + (-2. + uz)*uz)) - 0.03125*(nz - nx*ux - ny*(1 + uy) - nz*uz)*
+          (2*chem*(uy - uz)*(uy - uz) - 0.3333333333333333*(-((rhoA - rhoB)*(uy - uz)*(uy - uz)) + 
+             2*chem*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 0.1111111111111111*
+            (4*chem - (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz))); 
+
+            //------------------------------------------------- BCK collison ------------------------------------------------------------//
+    		// q=0
+    		dist[n] = m0 - (m0-feq0)/tau + 0.25*(2*(Fx*ux + Fy*uy + Fz*uz)*(-0.6666666666666666 + ux*ux + uy*uy + uz*uz) + 
+         (mgx*ux + mgy*uy + mgz*uz)*(2*chem*(ux*ux + uy*uy + uz*uz) + 
+            0.3333333333333333*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + uz*uz))));
+
+    		// q = 1
+    		dist[1*Np+n] = m1 - (m1-feq1)/tau + 0.125*(2*(Fx*(-1 + ux) + Fy*uy + Fz*uz)*(-0.2222222222222222 - ux*ux + 
+            0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+         (mgx*(-1 + ux) + mgy*uy + mgz*uz)*(-2*chem*(ux*ux) + 
+            0.3333333333333333*((-rhoA + rhoB)*(ux*ux) + 2*chem*(-2*ux + ux*ux + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*uz))));
+
+    		// q=2
+    		dist[2*Np+n] = m2 - (m2-feq2)/tau + 0.125*(2*(Fx + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - ux*ux + 
+            0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*uz)) + 
+         (mgx + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(ux*ux) + 
+            0.3333333333333333*((-rhoA + rhoB)*(ux*ux) + 2*chem*(2*ux + ux*ux + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*uz))));
+
+    		// q = 3
+    		dist[3*Np+n] = m3 - (m3-feq3)/tau + 0.125*(2*(Fx*ux + Fy*(-1 + uy) + Fz*uz)*(-0.2222222222222222 - uy*uy + 
+            0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+         (mgx*ux + mgy*(-1 + uy) + mgz*uz)*(-2*chem*(uy*uy) + 
+            0.3333333333333333*((-rhoA + rhoB)*(uy*uy) + 2*chem*(ux*ux - 2*uy + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*uz))));
+
+    		// q = 4
+    		dist[4*Np+n] = m4 - (m4-feq4)/tau + 0.125*(2*(Fy + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - uy*uy + 
+            0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*uz)) + 
+         (mgy + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(uy*uy) + 
+            0.3333333333333333*((-rhoA + rhoB)*(uy*uy) + 2*chem*(ux*ux + 2*uy + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*uz))));
+
+    		// q = 5
+    		dist[5*Np+n] = m5 - (m5-feq5)/tau + 0.125*(2*(Fx*ux + Fy*uy + Fz*(-1 + uz))*(-0.2222222222222222 - uz*uz + 
+            0.3333333333333333*(ux*ux + uy*uy + (-2 + uz)*uz)) + 
+         (mgx*ux + mgy*uy + mgz*(-1 + uz))*(-2*chem*(uz*uz) + 
+            0.3333333333333333*((-rhoA + rhoB)*(uz*uz) + 2*chem*(ux*ux + uy*uy + (-2 + uz)*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + (-2 + uz)*uz))));
+
+    		// q = 6
+    		dist[6*Np+n] = m6 - (m6-feq6)/tau + 0.125*(2*(Fz + Fx*ux + Fy*uy + Fz*uz)*(-0.2222222222222222 - uz*uz + 
+            0.3333333333333333*(ux*ux + uy*uy + uz*(2 + uz))) + 
+         (mgz + mgx*ux + mgy*uy + mgz*uz)*(-2*chem*(uz*uz) + 
+            0.3333333333333333*((-rhoA + rhoB)*(uz*uz) + 2*chem*(ux*ux + uy*uy + uz*(2 + uz))) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + uy*uy + uz*(2 + uz)))));
+
+    		// q = 7
+    		dist[7*Np+n] = m7 - (m7-feq7)/tau + 0.0625*(-2*(Fx*(-1 + ux) + Fy*(-1 + uy) + Fz*uz)*
+          (0.2222222222222222 + (ux + uy)*(ux + uy) - 
+            0.3333333333333333*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+         (mgx*(-1 + ux) + mgy*(-1 + uy) + mgz*uz)*
+          (-2*chem*((ux + uy)*(ux + uy)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux + uy)*(ux + uy))) + 2*chem*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux - 2*uy + uy*uy + uz*uz))));
+
+    		// q = 8
+    		dist[8*Np+n] = m8 - (m8-feq8)/tau + 0.0625*(2*(Fx + Fy + Fx*ux + Fy*uy + Fz*uz)*
+          (-0.2222222222222222 - (ux + uy)*(ux + uy) + 
+            0.3333333333333333*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+         (mgx + mgy + mgx*ux + mgy*uy + mgz*uz)*
+          (-2*chem*((ux + uy)*(ux + uy)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux + uy)*(ux + uy))) + 2*chem*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + 2*uy + uy*uy + uz*uz))));
+
+    		// q = 9
+    		dist[9*Np+n] = m9 - (m9-feq9)/tau + 0.0625*(2*(Fy + Fx*(-1 + ux) + Fy*uy + Fz*uz)*
+          (-0.2222222222222222 - (ux - uy)*(ux - uy) + 
+            0.3333333333333333*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+         (mgy + mgx*(-1 + ux) + mgy*uy + mgz*uz)*
+          (-2*chem*((ux - uy)*(ux - uy)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux - uy)*(ux - uy))) + 2*chem*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + 2*uy + uy*uy + uz*uz))));
+
+    		// q = 10
+    		dist[10*Np+n] = m10 - (m10-feq10)/tau + 0.0625*(2*(Fx*(1 + ux) + Fy*(-1 + uy) + Fz*uz)*
+          (-0.2222222222222222 - (ux - uy)*(ux - uy) + 
+            0.3333333333333333*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+         (mgx*(1 + ux) + mgy*(-1 + uy) + mgz*uz)*
+          (-2*chem*((ux - uy)*(ux - uy)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux - uy)*(ux - uy))) + 2*chem*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux - 2*uy + uy*uy + uz*uz))));
+
+    		// q = 11
+    		dist[11*Np+n] = m11 - (m11-feq11)/tau + 0.0625*(-2*(Fx*(-1 + ux) + Fy*uy + Fz*(-1 + uz))*
+          (0.2222222222222222 + (ux + uz)*(ux + uz) - 
+            0.3333333333333333*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+         (mgx*(-1 + ux) + mgy*uy + mgz*(-1 + uz))*
+          (-2*chem*((ux + uz)*(ux + uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux + uz)*(ux + uz))) + 2*chem*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + (-2 + uz)*uz))));
+
+    		// q = 12
+    		dist[12*Np+n] = m12 - (m12-feq12)/tau + 0.0625*(2*(Fx + Fz + Fx*ux + Fy*uy + Fz*uz)*
+          (-0.2222222222222222 - (ux + uz)*(ux + uz) + 0.3333333333333333*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))
+           + (mgx + mgz + mgx*ux + mgy*uy + mgz*uz)*
+          (-2*chem*((ux + uz)*(ux + uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux + uz)*(ux + uz))) + 2*chem*(2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + uz*(2 + uz)))));
+
+    		// q = 13
+    		dist[13*Np+n] = m13 - (m13-feq13)/tau + 0.0625*(2*(Fz + Fx*(-1 + ux) + Fy*uy + Fz*uz)*
+          (-0.2222222222222222 - (ux - uz)*(ux - uz) + 
+            0.3333333333333333*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+         (mgz + mgx*(-1 + ux) + mgy*uy + mgz*uz)*
+          (-2*chem*((ux - uz)*(ux - uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux - uz)*(ux - uz))) + 2*chem*(-2*ux + ux*ux + uy*uy + uz*(2 + uz))) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(-2*ux + ux*ux + uy*uy + uz*(2 + uz)))));
+
+    		// q= 14
+    		dist[14*Np+n] = m14 - (m14-feq14)/tau + 0.0625*(2*(Fx*(1 + ux) + Fy*uy + Fz*(-1 + uz))*
+          (-0.2222222222222222 - (ux - uz)*(ux - uz) + 
+            0.3333333333333333*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+         (mgx*(1 + ux) + mgy*uy + mgz*(-1 + uz))*
+          (-2*chem*((ux - uz)*(ux - uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((ux - uz)*(ux - uz))) + 2*chem*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(2*ux + ux*ux + uy*uy + (-2 + uz)*uz))));
+
+    		// q = 15
+    		dist[15*Np+n] = m15 - (m15-feq15)/tau + 0.0625*(-2*(Fx*ux + Fy*(-1 + uy) + Fz*(-1 + uz))*
+          (0.2222222222222222 + (uy + uz)*(uy + uz) - 0.3333333333333333*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))
+           + (mgx*ux + mgy*(-1 + uy) + mgz*(-1 + uz))*
+          (-2*chem*((uy + uz)*(uy + uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((uy + uz)*(uy + uz))) + 2*chem*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + (-2 + uz)*uz))));
+
+    		// q = 16
+    		dist[16*Np+n] = m16 - (m16-feq16)/tau + 0.0625*(2*(Fy + Fz + Fx*ux + Fy*uy + Fz*uz)*
+          (-0.2222222222222222 - (uy + uz)*(uy + uz) + 0.3333333333333333*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))
+           + (mgy + mgz + mgx*ux + mgy*uy + mgz*uz)*
+          (-2*chem*((uy + uz)*(uy + uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((uy + uz)*(uy + uz))) + 2*chem*(ux*ux + 2*uy + uy*uy + uz*(2 + uz))) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + uz*(2 + uz)))));
+
+    		// q = 17
+    		dist[17*Np+n] = m17 - (m17-feq17)/tau + 0.0625*(2*(Fz + Fx*ux + Fy*(-1 + uy) + Fz*uz)*
+          (-0.2222222222222222 - (uy - uz)*(uy - uz) + 0.3333333333333333*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))
+           + (mgz + mgx*ux + mgy*(-1 + uy) + mgz*uz)*
+          (-2*chem*((uy - uz)*(uy - uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((uy - uz)*(uy - uz))) + 2*chem*(ux*ux - 2*uy + uy*uy + uz*(2 + uz))) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux - 2*uy + uy*uy + uz*(2 + uz)))));
+
+    		// q = 18
+    		dist[18*Np+n] = m18 - (m18-feq18)/tau + 0.0625*(2*(Fx*ux + Fy*(1 + uy) + Fz*(-1 + uz))*
+          (-0.2222222222222222 - (uy - uz)*(uy - uz) + 
+            0.3333333333333333*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 
+         (mgx*ux + mgy*(1 + uy) + mgz*(-1 + uz))*
+          (-2*chem*((uy - uz)*(uy - uz)) + 0.3333333333333333*
+             (-((rhoA - rhoB)*((uy - uz)*(uy - uz))) + 2*chem*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz)) + 
+            0.1111111111111111*(-4*chem + (rhoA - rhoB)*(ux*ux + 2*uy + uy*uy + (-2 + uz)*uz))));
+            //----------------------------------------------------------------------------------------------------------------------------------------//
+
+
+            // ----------------------------- compute phase field evolution ----------------------------------------
+    		//Normalize the Color Gradient
+    		C = sqrt(nx*nx+ny*ny+nz*nz);
+    		double ColorMag = C;
+    		if (C==0.0) ColorMag=1.0;
+    		nx = nx/ColorMag;
+    		ny = ny/ColorMag;
+    		nz = nz/ColorMag;		
+            //compute surface tension-related parameter
+            //theta = 4.5*M*2.0*(1-phi*phi)/W;
+            theta = 4.5*M*2.0*(1-phi_temp*phi_temp)/W;
+
+            //load distributions of phase field
+    		//q=0
+    		h0 = hq[n];
+    		//q=1
+    		h1 = hq[2*Np+n]; 
+
+    		//q=2
+    		h2 = hq[1*Np+n];  
+
+    		//q=3
+    		h3 = hq[4*Np+n];
+
+    		//q=4
+    		h4 = hq[3*Np+n];
+
+    		//q=5
+    		h5 = hq[6*Np+n];
+
+    		//q=6
+    		h6 = hq[5*Np+n];
+
+            //-------------------------------- BGK collison for phase field ---------------------------------//
+    		// q = 0
+    		hq[n] = h0 - (h0 - 0.3333333333333333*phi)/tauM;
+
+    		// q = 1
+    		hq[1*Np+n] = h1 - (h1 - 0.1111111111111111*nx*theta - phi*(0.1111111111111111 + 0.5*ux))/tauM;
+
+    		// q = 2
+    		hq[2*Np+n] = h2 - (h2 + 0.1111111111111111*nx*theta - phi*(0.1111111111111111 - 0.5*ux))/tauM;
+
+    		// q = 3
+    		hq[3*Np+n] = h3 - (h3 - 0.1111111111111111*ny*theta - phi*(0.1111111111111111 + 0.5*uy))/tauM;
+
+    		// q = 4
+    		hq[4*Np+n] = h4 - (h4 + 0.1111111111111111*ny*theta - phi*(0.1111111111111111 - 0.5*uy))/tauM;
+
+    		// q = 5
+    		hq[5*Np+n] = h5 - (h5 - 0.1111111111111111*nz*theta - phi*(0.1111111111111111 + 0.5*uz))/tauM;
+
+    		// q = 6
+    		hq[6*Np+n] = h6 - (h6 + 0.1111111111111111*nz*theta - phi*(0.1111111111111111 - 0.5*uz))/tauM;
+    		//........................................................................
+
+            //Update velocity on device
+    		Vel[0*Np+n] = ux;
+    		Vel[1*Np+n] = uy;
+    		Vel[2*Np+n] = uz;
+            //Update pressure on device
+            Pressure[n] = p;
+            //Update chemical potential on device
+            mu_phi[n] = chem;
+            //Update color gradient on device
+    		ColorGrad[0*Np+n] = nx;
+    		ColorGrad[1*Np+n] = ny;
+    		ColorGrad[2*Np+n] = nz;
+
+    	}
+    }
+}
+    	}
 __global__ void dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel_SingleFluid_BGK(int *neighborList, double *dist, double *Vel, double *Pressure,  
 		double tau, double rho0, double Fx, double Fy, double Fz, int start, int finish, int Np){
 
@@ -2006,7 +3256,7 @@ extern "C" void ScaLBL_D3Q19_FreeLeeModel_TwoFluid_Init(double *gqbar, double *m
 	dvc_ScaLBL_D3Q19_FreeLeeModel_TwoFluid_Init<<<NBLOCKS,NTHREADS >>>( gqbar,  mu_phi, ColorGrad, Fx, Fy, Fz, Np);
 	hipError_t err = hipGetLastError();
 	if (hipSuccess != err){
-		printf("CUDA error in ScaLBL_D3Q19_FreeLeeModel_TwoFluid_Init: %s \n",hipGetErrorString(err));
+		printf("hip error in ScaLBL_D3Q19_FreeLeeModel_TwoFluid_Init: %s \n",hipGetErrorString(err));
 	}
 }
 
@@ -2016,7 +3266,7 @@ extern "C" void ScaLBL_D3Q19_FreeLeeModel_SingleFluid_Init(double *gqbar, double
 	dvc_ScaLBL_D3Q19_FreeLeeModel_SingleFluid_Init<<<NBLOCKS,NTHREADS >>>( gqbar, Fx, Fy, Fz, Np);
 	hipError_t err = hipGetLastError();
 	if (hipSuccess != err){
-		printf("CUDA error in ScaLBL_D3Q19_FreeLeeModel_SingleFluid_Init: %s \n",hipGetErrorString(err));
+		printf("hip error in ScaLBL_D3Q19_FreeLeeModel_SingleFluid_Init: %s \n",hipGetErrorString(err));
 	}
 }
 
@@ -2026,7 +3276,7 @@ extern "C" void ScaLBL_FreeLeeModel_PhaseField_Init(int *Map, double *Phi, doubl
 	dvc_ScaLBL_FreeLeeModel_PhaseField_Init<<<NBLOCKS,NTHREADS >>>(Map, Phi, Den, hq, ColorGrad, rhoA, rhoB, tauM, W, start, finish, Np);
 	hipError_t err = hipGetLastError();
 	if (hipSuccess != err){
-		printf("CUDA error in ScaLBL_FreeLeeModel_PhaseField_Init: %s \n",hipGetErrorString(err));
+		printf("hip error in ScaLBL_FreeLeeModel_PhaseField_Init: %s \n",hipGetErrorString(err));
 	}
 	
 	
@@ -2034,34 +3284,34 @@ extern "C" void ScaLBL_FreeLeeModel_PhaseField_Init(int *Map, double *Phi, doubl
 extern "C" void ScaLBL_D3Q7_AAodd_FreeLee_PhaseField(int *neighborList, int *Map, double *hq, double *Den, double *Phi, double *ColorGrad, double *Vel,
                                                           double rhoA, double rhoB, double tauM, double W, int start, int finish, int Np)
 {
-	hipFuncSetCacheConfig(dvc_ScaLBL_D3Q7_AAodd_FreeLee_PhaseField, hipFuncCachePreferL1);
+	cudaFuncSetCacheConfig(dvc_ScaLBL_D3Q7_AAodd_FreeLee_PhaseField, cudaFuncCachePreferL1);
 	dvc_ScaLBL_D3Q7_AAodd_FreeLee_PhaseField<<<NBLOCKS,NTHREADS >>>(neighborList, Map, hq, Den, Phi, ColorGrad, Vel,
              rhoA,  rhoB, tauM, W, start, finish,  Np);
 	hipError_t err = hipGetLastError();
 	if (hipSuccess != err){
-		printf("CUDA error in ScaLBL_D3Q7_AAodd_FreeLee_PhaseField: %s \n",hipGetErrorString(err));
+		printf("hip error in ScaLBL_D3Q7_AAodd_FreeLee_PhaseField: %s \n",hipGetErrorString(err));
 	}
 }
 
 extern "C" void ScaLBL_D3Q7_AAeven_FreeLee_PhaseField( int *Map, double *hq, double *Den, double *Phi, double *ColorGrad, double *Vel,
 		double rhoA, double rhoB, double tauM, double W, int start, int finish, int Np){
 
-	hipFuncSetCacheConfig(dvc_ScaLBL_D3Q7_AAeven_FreeLee_PhaseField, hipFuncCachePreferL1);
+	cudaFuncSetCacheConfig(dvc_ScaLBL_D3Q7_AAeven_FreeLee_PhaseField, cudaFuncCachePreferL1);
 	dvc_ScaLBL_D3Q7_AAeven_FreeLee_PhaseField<<<NBLOCKS,NTHREADS >>>( Map, hq, Den, Phi, ColorGrad, Vel, rhoA, rhoB, tauM, W, start, finish, Np);
 	hipError_t err = hipGetLastError();
 	if (hipSuccess != err){
-		printf("CUDA error in ScaLBL_D3Q7_AAeven_FreeLee_PhaseField: %s \n",hipGetErrorString(err));
+		printf("hip error in ScaLBL_D3Q7_AAeven_FreeLee_PhaseField: %s \n",hipGetErrorString(err));
 	}
 }
 
 
 extern "C" void ScaLBL_D3Q7_ComputePhaseField(int *Map,  double *hq, double *Den, double *Phi, double rhoA, double rhoB, int start, int finish, int Np){
 
-	hipFuncSetCacheConfig(dvc_ScaLBL_D3Q7_ComputePhaseField, hipFuncCachePreferL1);
+	cudaFuncSetCacheConfig(dvc_ScaLBL_D3Q7_ComputePhaseField, cudaFuncCachePreferL1);
 	dvc_ScaLBL_D3Q7_ComputePhaseField<<<NBLOCKS,NTHREADS >>>( Map, hq, Den, Phi, rhoA, rhoB, start, finish, Np);
 	hipError_t err = hipGetLastError();
 	if (hipSuccess != err){
-		printf("CUDA error in ScaLBL_D3Q7_ComputePhaseField: %s \n",hipGetErrorString(err));
+		printf("hip error in ScaLBL_D3Q7_ComputePhaseField: %s \n",hipGetErrorString(err));
 	}
 }
 
@@ -2070,12 +3320,12 @@ extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel(int *neighborList, int *Map, dou
                                                 double rhoA, double rhoB, double tauA, double tauB, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
                                                 int strideY, int strideZ, int start, int finish, int Np){
 	
-	hipFuncSetCacheConfig(dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel, hipFuncCachePreferL1);
+	cudaFuncSetCacheConfig(dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel, cudaFuncCachePreferL1);
 	dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel<<<NBLOCKS,NTHREADS >>>(neighborList, Map, dist, Den, Phi, mu_phi, Vel, Pressure,  ColorGrad, 
             rhoA, rhoB, tauA, tauB, kappa, beta, W, Fx, Fy, Fz, strideY, strideZ, start, finish, Np);
 	hipError_t err = hipGetLastError();
 	if (hipSuccess != err){
-		printf("CUDA error in ScaLBL_D3Q19_AAodd_FreeLeeModel: %s \n",hipGetErrorString(err));
+		printf("hip error in ScaLBL_D3Q19_AAodd_FreeLeeModel: %s \n",hipGetErrorString(err));
 	}
 }	
 
@@ -2083,37 +3333,61 @@ extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel(int *Map, double *dist, double
                                                 double rhoA, double rhoB, double tauA, double tauB, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
                                                 int strideY, int strideZ, int start, int finish, int Np){
 	
-	hipFuncSetCacheConfig(dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel, hipFuncCachePreferL1);
+	cudaFuncSetCacheConfig(dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel, cudaFuncCachePreferL1);
 	dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel<<<NBLOCKS,NTHREADS >>>(Map, dist, Den, Phi, mu_phi, Vel, Pressure,  ColorGrad, 
             rhoA, rhoB, tauA, tauB, kappa, beta, W, Fx, Fy, Fz, strideY, strideZ, start, finish, Np);
 	hipError_t err = hipGetLastError();
 	if (hipSuccess != err){
-		printf("CUDA error in ScaLBL_D3Q19_AAeven_FreeLeeModel: %s \n",hipGetErrorString(err));
+		printf("hip error in ScaLBL_D3Q19_AAeven_FreeLeeModel: %s \n",hipGetErrorString(err));
 	}
 	
 }
 
+extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined(int *Map, double *dist, double *hq, double *Den, double *Phi, double *mu_phi, double *Vel, double *Pressure, double *ColorGrad,
+                                                double rhoA, double rhoB, double tauA, double tauB, double tauM, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
+                                                int strideY, int strideZ, int start, int finish, int Np){
+	cudaFuncSetCacheConfig(dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined, cudaFuncCachePreferL1);
+	dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined<<<NBLOCKS,NTHREADS >>>(Map, dist, Den, hq, Phi, mu_phi, Vel, Pressure,  ColorGrad, 
+            rhoA, rhoB, tauA, tauB, tauM, kappa, beta, W, Fx, Fy, Fz, strideY, strideZ, start, finish, Np);
+	hipError_t err = hipGetLastError();
+	if (hipSuccess != err){
+		printf("hip error in ScaLBL_D3Q19_AAeven_FreeLeeModel_Combined: %s \n",hipGetErrorString(err));
+}
+
+extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined(int *neighborList, int *Map, double *dist, double *hq, double *Den, double *Phi, double *mu_phi, double *Vel, double *Pressure, double *ColorGrad, 
+                                                double rhoA, double rhoB, double tauA, double tauB, double tauM, double kappa, double beta, double W, double Fx, double Fy, double Fz, 
+                                                int strideY, int strideZ, int start, int finish, int Np){
+	
+	cudaFuncSetCacheConfig(dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined, cudaFuncCachePreferL1);
+	dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined<<<NBLOCKS,NTHREADS >>>(neighborList, Map, dist, hq, Den, Phi, mu_phi, Vel, Pressure,  ColorGrad, 
+            rhoA, rhoB, tauA, tauB, tauM, kappa, beta, W, Fx, Fy, Fz, strideY, strideZ, start, finish, Np);
+	hipError_t err = hipGetLastError();
+	if (hipSuccess != err){
+		printf("hip error in ScaLBL_D3Q19_AAodd_FreeLeeModel_Combined: %s \n",hipGetErrorString(err));
+		
+}
+
 extern "C" void ScaLBL_D3Q19_AAodd_FreeLeeModel_SingleFluid_BGK(int *neighborList, double *dist, double *Vel, double *Pressure,  
                                                                 double tau, double rho0, double Fx, double Fy, double Fz, int start, int finish, int Np){
 
-	hipFuncSetCacheConfig(dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel_SingleFluid_BGK, hipFuncCachePreferL1);
+	cudaFuncSetCacheConfig(dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel_SingleFluid_BGK, cudaFuncCachePreferL1);
 	dvc_ScaLBL_D3Q19_AAodd_FreeLeeModel_SingleFluid_BGK<<<NBLOCKS,NTHREADS >>>(neighborList, dist, Vel, Pressure, 
             tau, rho0, Fx, Fy, Fz, start, finish, Np);
 	hipError_t err = hipGetLastError();
 	if (hipSuccess != err){
-		printf("CUDA error in ScaLBL_D3Q19_AAodd_FreeLeeModel_SingleFluid_BGK: %s \n",hipGetErrorString(err));
+		printf("hip error in ScaLBL_D3Q19_AAodd_FreeLeeModel_SingleFluid_BGK: %s \n",hipGetErrorString(err));
 	}
 }
 
 extern "C" void ScaLBL_D3Q19_AAeven_FreeLeeModel_SingleFluid_BGK(double *dist, double *Vel, double *Pressure, 
                                                                  double tau, double rho0, double Fx, double Fy, double Fz, int start, int finish, int Np){
 
-	hipFuncSetCacheConfig(dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel_SingleFluid_BGK, hipFuncCachePreferL1);
+	cudaFuncSetCacheConfig(dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel_SingleFluid_BGK, cudaFuncCachePreferL1);
 	dvc_ScaLBL_D3Q19_AAeven_FreeLeeModel_SingleFluid_BGK<<<NBLOCKS,NTHREADS >>>(dist, Vel, Pressure, 
             tau, rho0,  Fx, Fy, Fz, start, finish, Np);
 	hipError_t err = hipGetLastError();
 	if (hipSuccess != err){
-		printf("CUDA error in ScaLBL_D3Q19_AAeven_FreeLeeModel_SingleFluid_BGK: %s \n",hipGetErrorString(err));
+		printf("hip error in ScaLBL_D3Q19_AAeven_FreeLeeModel_SingleFluid_BGK: %s \n",hipGetErrorString(err));
 	}
 }
 
diff --git a/hip/GreyscaleColor.cu b/hip/GreyscaleColor.cu
index 0ceb0522..c9dafb37 100644
--- a/hip/GreyscaleColor.cu
+++ b/hip/GreyscaleColor.cu
@@ -1,11 +1,9 @@
 #include <stdio.h>
 #include <math.h>
-#include "hip/hip_runtime.h"
 
 #define NBLOCKS 1024
 #define NTHREADS 256
 
-
 //Model-1 & 4
 __global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor(int *neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den,
 		 double *Phi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure,
@@ -1449,6 +1447,1548 @@ __global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor(int *Map, double *dist,
 	}
 }
 
+//CP: capillary penalty
+// also turn off recoloring for grey nodes
+__global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den,
+		 double *Phi, double *Psi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure,
+         double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff,double alpha, double beta,
+		double Gx, double Gy, double Gz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
+
+	int n,nn,ijk,nread;
+	int nr1,nr2,nr3,nr4,nr5,nr6;
+	int nr7,nr8,nr9,nr10;
+	int nr11,nr12,nr13,nr14;
+	//int nr15,nr16,nr17,nr18;
+	double fq;
+	// conserved momemnts
+	double rho,jx,jy,jz;
+	//double vx,vy,vz,v_mag;
+    //double ux,uy,uz,u_mag;
+    double ux,uy,uz;
+	// non-conserved moments
+	double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
+	double m3,m5,m7;
+	double nA,nB; // number density
+	double a1,b1,a2,b2,nAB,delta;
+	double C,nx,ny,nz; //color gradient magnitude and direction
+	double phi,tau,rho0,rlx_setA,rlx_setB;
+
+    //double GeoFun=0.0;//geometric function from Guo's PRE 66, 036304 (2002)
+    double porosity;
+    double perm;//voxel permeability
+    //double c0, c1; //Guo's model parameters
+    double tau_eff;
+    double mu_eff;//kinematic viscosity
+    double nx_gs,ny_gs,nz_gs;//grey-solid color gradient
+    double nx_phase,ny_phase,nz_phase,C_phase;
+    double Fx,Fy,Fz;
+	double gp1,gp2,gp4,gp6,gp8,gp9,gp10,gp11,gp12,gp13,gp14,gp15,gp16,gp17,gp18;
+	double gp3,gp5,gp7;
+    double Fcpx,Fcpy,Fcpz;//capillary penalty force
+
+	const double mrt_V1=0.05263157894736842;
+	const double mrt_V2=0.012531328320802;
+	const double mrt_V3=0.04761904761904762;
+	const double mrt_V4=0.004594820384294068;
+	const double mrt_V5=0.01587301587301587;
+	const double mrt_V6=0.0555555555555555555555555;
+	const double mrt_V7=0.02777777777777778;
+	const double mrt_V8=0.08333333333333333;
+	const double mrt_V9=0.003341687552213868;
+	const double mrt_V10=0.003968253968253968;
+	const double mrt_V11=0.01388888888888889;
+	const double mrt_V12=0.04166666666666666;
+
+	int S = Np/NBLOCKS/NTHREADS + 1;
+	for (int s=0; s<S; s++){
+		//........Get 1-D index for this thread....................
+		n =  S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x + start;
+		if (n<finish) {
+			// read the component number densities
+			nA = Den[n];
+			nB = Den[Np + n];
+
+            porosity = Poros[n];
+            perm = Perm[n];
+            nx_gs = GreySolidGrad[n+0*Np];
+            ny_gs = GreySolidGrad[n+1*Np];
+            nz_gs = GreySolidGrad[n+2*Np];
+
+			// compute phase indicator field
+			phi=(nA-nB)/(nA+nB);
+
+			// local density
+			rho0=rhoA + 0.5*(1.0-phi)*(rhoB-rhoA);
+			// local relaxation time
+			tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
+			tau_eff=tauA_eff + 0.5*(1.0-phi)*(tauB_eff-tauA_eff);
+			rlx_setA = 1.f/tau;
+			rlx_setB = 8.f*(2.f-rlx_setA)/(8.f-rlx_setA);
+            mu_eff = (tau_eff-0.5)/3.0;//kinematic viscosity
+			
+			// Get the 1D index based on regular data layout
+			ijk = Map[n];
+			//					COMPUTE THE COLOR GRADIENT
+			//........................................................................
+			//.................Read Phase Indicator Values............................
+			//........................................................................
+			nn = ijk-1;							// neighbor index (get convention)
+			m1 = Phi[nn];						// get neighbor for phi - 1
+            gp1 = Psi[nn];
+			//........................................................................
+			nn = ijk+1;							// neighbor index (get convention)
+			m2 = Phi[nn];						// get neighbor for phi - 2
+            gp2 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideY;							// neighbor index (get convention)
+			m3 = Phi[nn];					// get neighbor for phi - 3
+            gp3 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideY;							// neighbor index (get convention)
+			m4 = Phi[nn];					// get neighbor for phi - 4
+            gp4 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideZ;						// neighbor index (get convention)
+			m5 = Phi[nn];					// get neighbor for phi - 5
+            gp5 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideZ;						// neighbor index (get convention)
+			m6 = Phi[nn];					// get neighbor for phi - 6
+            gp6 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideY-1;						// neighbor index (get convention)
+			m7 = Phi[nn];					// get neighbor for phi - 7
+            gp7 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideY+1;						// neighbor index (get convention)
+			m8 = Phi[nn];					// get neighbor for phi - 8
+            gp8 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideY-1;						// neighbor index (get convention)
+			m9 = Phi[nn];					// get neighbor for phi - 9
+            gp9 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideY+1;						// neighbor index (get convention)
+			m10 = Phi[nn];					// get neighbor for phi - 10
+            gp10 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideZ-1;						// neighbor index (get convention)
+			m11 = Phi[nn];					// get neighbor for phi - 11
+            gp11 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideZ+1;						// neighbor index (get convention)
+			m12 = Phi[nn];					// get neighbor for phi - 12
+            gp12 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideZ-1;						// neighbor index (get convention)
+			m13 = Phi[nn];					// get neighbor for phi - 13
+            gp13 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideZ+1;						// neighbor index (get convention)
+			m14 = Phi[nn];					// get neighbor for phi - 14
+            gp14 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideZ-strideY;					// neighbor index (get convention)
+			m15 = Phi[nn];					// get neighbor for phi - 15
+            gp15 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideZ+strideY;					// neighbor index (get convention)
+			m16 = Phi[nn];					// get neighbor for phi - 16
+            gp16 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideZ-strideY;					// neighbor index (get convention)
+			m17 = Phi[nn];					// get neighbor for phi - 17
+            gp17 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideZ+strideY;					// neighbor index (get convention)
+			m18 = Phi[nn];					// get neighbor for phi - 18
+            gp18 = Psi[nn];
+			//............Compute the Color Gradient...................................
+			nx_phase = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+			ny_phase = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+			nz_phase = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+			C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
+
+            //correct the normal color gradient by considering the effect of grey solid
+            nx = nx_phase + (1.0-porosity)*nx_gs; 
+            ny = ny_phase + (1.0-porosity)*ny_gs; 
+            nz = nz_phase + (1.0-porosity)*nz_gs; 
+            if (C_phase==0.0){
+                nx = nx_phase; 
+                ny = ny_phase;
+                nz = nz_phase;
+            }
+
+			//...........Normalize the Color Gradient.................................
+			C = sqrt(nx*nx+ny*ny+nz*nz);
+			double ColorMag = C;
+			if (C==0.0) ColorMag=1.0;
+			nx = nx/ColorMag;
+			ny = ny/ColorMag;
+			nz = nz/ColorMag;		
+
+			//............Compute the Greyscale Potential Gradient.....................
+//			Fcpx = 0.0;
+//			Fcpy = 0.0;
+//			Fcpz = 0.0;
+//            if (porosity!=1.0){
+//                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
+//                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
+//                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+//                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+//                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+//                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+//                Fcpx *= alpha*W/sqrt(perm); 
+//                Fcpy *= alpha*W/sqrt(perm); 
+//                Fcpz *= alpha*W/sqrt(perm); 
+//                //double Fcp_mag_temp = sqrt(Fcpx*Fcpx+Fcpy*Fcpy+Fcpz*Fcpz);
+//                //double Fcp_mag = Fcp_mag_temp;
+//                //if (Fcp_mag_temp==0.0) Fcp_mag=1.0;
+//                //nx = Fcpx/Fcp_mag;
+//                //ny = Fcpy/Fcp_mag;
+//                //nz = Fcpz/Fcp_mag;
+//            }
+            Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+            Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+            Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+            //NOTE for open node (porosity=1.0),Fcp=0.0
+            Fcpx *= alpha*W*(1.0-porosity)/sqrt(perm); 
+            Fcpy *= alpha*W*(1.0-porosity)/sqrt(perm); 
+            Fcpz *= alpha*W*(1.0-porosity)/sqrt(perm); 
+
+			// q=0
+			fq = dist[n];
+			rho = fq;
+			m1  = -30.0*fq;
+			m2  = 12.0*fq;
+
+			// q=1
+			//nread = neighborList[n]; // neighbor 2 
+			//fq = dist[nread]; // reading the f1 data into register fq		
+			nr1 = neighborList[n]; 
+			fq = dist[nr1]; // reading the f1 data into register fq
+			rho += fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jx = fq;
+			m4 = -4.0*fq;
+			m9 = 2.0*fq;
+			m10 = -4.0*fq;
+
+			// f2 = dist[10*Np+n];
+			//nread = neighborList[n+Np]; // neighbor 1 ( < 10Np => even part of dist)
+			//fq = dist[nread];  // reading the f2 data into register fq
+			nr2 = neighborList[n+Np]; // neighbor 1 ( < 10Np => even part of dist)
+			fq = dist[nr2];  // reading the f2 data into register fq
+			rho += fq;
+			m1 -= 11.0*(fq);
+			m2 -= 4.0*(fq);
+			jx -= fq;
+			m4 += 4.0*(fq);
+			m9 += 2.0*(fq);
+			m10 -= 4.0*(fq);
+
+			// q=3
+			//nread = neighborList[n+2*Np]; // neighbor 4
+			//fq = dist[nread];
+			nr3 = neighborList[n+2*Np]; // neighbor 4
+			fq = dist[nr3];
+			rho += fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jy = fq;
+			m6 = -4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 = fq;
+			m12 = -2.0*fq;
+
+			// q = 4
+			//nread = neighborList[n+3*Np]; // neighbor 3
+			//fq = dist[nread];
+			nr4 = neighborList[n+3*Np]; // neighbor 3
+			fq = dist[nr4];
+			rho+= fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jy -= fq;
+			m6 += 4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 += fq;
+			m12 -= 2.0*fq;
+
+			// q=5
+			//nread = neighborList[n+4*Np];
+			//fq = dist[nread];
+			nr5 = neighborList[n+4*Np];
+			fq = dist[nr5];
+			rho += fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jz = fq;
+			m8 = -4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 -= fq;
+			m12 += 2.0*fq;
+
+
+			// q = 6
+			//nread = neighborList[n+5*Np];
+			//fq = dist[nread];
+			nr6 = neighborList[n+5*Np];
+			fq = dist[nr6];
+			rho+= fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jz -= fq;
+			m8 += 4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 -= fq;
+			m12 += 2.0*fq;
+
+			// q=7
+			//nread = neighborList[n+6*Np];
+			//fq = dist[nread];
+			nr7 = neighborList[n+6*Np];
+			fq = dist[nr7];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jy += fq;
+			m6 += fq;
+			m9  += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 = fq;
+			m16 = fq;
+			m17 = -fq;
+
+			// q = 8
+			//nread = neighborList[n+7*Np];
+			//fq = dist[nread];
+			nr8 = neighborList[n+7*Np];
+			fq = dist[nr8];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jy -= fq;
+			m6 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 += fq;
+			m16 -= fq;
+			m17 += fq;
+
+			// q=9
+			//nread = neighborList[n+8*Np];
+			//fq = dist[nread];
+			nr9 = neighborList[n+8*Np];
+			fq = dist[nr9];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jy -= fq;
+			m6 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 -= fq;
+			m16 += fq;
+			m17 += fq;
+
+			// q = 10
+			//nread = neighborList[n+9*Np];
+			//fq = dist[nread];
+			nr10 = neighborList[n+9*Np];
+			fq = dist[nr10];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jy += fq;
+			m6 += fq;
+			m9 += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 -= fq;
+			m16 -= fq;
+			m17 -= fq;
+
+			// q=11
+			//nread = neighborList[n+10*Np];
+			//fq = dist[nread];
+			nr11 = neighborList[n+10*Np];
+			fq = dist[nr11];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jz += fq;
+			m8 += fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 = fq;
+			m16 -= fq;
+			m18 = fq;
+
+			// q=12
+			//nread = neighborList[n+11*Np];
+			//fq = dist[nread];
+			nr12 = neighborList[n+11*Np];
+			fq = dist[nr12];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 += fq;
+			m16 += fq;
+			m18 -= fq;
+
+			// q=13
+			//nread = neighborList[n+12*Np];
+			//fq = dist[nread];
+			nr13 = neighborList[n+12*Np];
+			fq = dist[nr13];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 -= fq;
+			m16 -= fq;
+			m18 -= fq;
+
+			// q=14
+			//nread = neighborList[n+13*Np];
+			//fq = dist[nread];
+			nr14 = neighborList[n+13*Np];
+			fq = dist[nr14];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jz += fq;
+			m8 += fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 -= fq;
+			m16 += fq;
+			m18 += fq;
+
+			// q=15
+			nread = neighborList[n+14*Np];
+			fq = dist[nread];
+			//fq = dist[17*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy += fq;
+			m6 += fq;
+			jz += fq;
+			m8 += fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 = fq;
+			m17 += fq;
+			m18 -= fq;
+
+			// q=16
+			nread = neighborList[n+15*Np];
+			fq = dist[nread];
+			//fq = dist[8*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy -= fq;
+			m6 -= fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 += fq;
+			m17 -= fq;
+			m18 += fq;
+
+			// q=17
+			//fq = dist[18*Np+n];
+			nread = neighborList[n+16*Np];
+			fq = dist[nread];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy += fq;
+			m6 += fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 -= fq;
+			m17 += fq;
+			m18 += fq;
+
+			// q=18
+			nread = neighborList[n+17*Np];
+			fq = dist[nread];
+			//fq = dist[9*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy -= fq;
+			m6 -= fq;
+			jz += fq;
+			m8 += fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 -= fq;
+			m17 -= fq;
+			m18 -= fq;
+			
+            // Compute greyscale related parameters
+            ux = (jx/rho0+0.5*porosity*Gx+0.5*Fcpx/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            uy = (jy/rho0+0.5*porosity*Gy+0.5*Fcpy/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            uz = (jz/rho0+0.5*porosity*Gz+0.5*Fcpz/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            if (porosity==1.0){//i.e. open nodes
+                ux = (jx/rho0+0.5*porosity*Gx);
+                uy = (jy/rho0+0.5*porosity*Gy);
+                uz = (jz/rho0+0.5*porosity*Gz);
+            }
+
+            //Update the total force to include linear (Darcy) and nonlinear (Forchheimer) drags due to the porous medium
+            Fx = rho0*(-porosity*mu_eff/perm*ux + porosity*Gx)+Fcpx;
+            Fy = rho0*(-porosity*mu_eff/perm*uy + porosity*Gy)+Fcpy;
+            Fz = rho0*(-porosity*mu_eff/perm*uz + porosity*Gz)+Fcpz;
+            if (porosity==1.0){
+                Fx=rho0*(porosity*Gx);
+                Fy=rho0*(porosity*Gy);
+                Fz=rho0*(porosity*Gz);
+            }
+
+			// write the velocity 
+			Velocity[n] = ux;
+			Velocity[Np+n] = uy;
+			Velocity[2*Np+n] = uz;
+            //Pressure[n] = rho/3.f/porosity;
+            Pressure[n] = rho/3.f;
+
+			//........................................................................
+			//..............carry out relaxation process..............................
+			//..........Toelke, Fruediger et. al. 2006................................
+            //---------------- NO higher-order force -------------------------------//
+			if (C == 0.0)	nx = ny = nz = 0.0;
+			m1 = m1 + rlx_setA*((19*(ux*ux+uy*uy+uz*uz)*rho0/porosity - 11*rho) -19*alpha*C - m1);
+			m2 = m2 + rlx_setA*((3*rho - 5.5*(ux*ux+uy*uy+uz*uz)*rho0/porosity)- m2);
+            jx = jx + Fx;
+			m4 = m4 + rlx_setB*((-0.6666666666666666*ux*rho0)- m4)
+                    + (1-0.5*rlx_setB)*(-0.6666666666666666*Fx);
+            jy = jy + Fy;
+			m6 = m6 + rlx_setB*((-0.6666666666666666*uy*rho0)- m6)
+                    + (1-0.5*rlx_setB)*(-0.6666666666666666*Fy);
+            jz = jz + Fz;
+			m8 = m8 + rlx_setB*((-0.6666666666666666*uz*rho0)- m8)
+                    + (1-0.5*rlx_setB)*(-0.6666666666666666*Fz);
+			m9 = m9 + rlx_setA*(((2*ux*ux-uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(2*nx*nx-ny*ny-nz*nz) - m9);
+			m10 = m10 + rlx_setA*( - m10);
+            //m10 = m10 + rlx_setA*(-0.5*rho0*((2*ux*ux-uy*uy-uz*uz)/porosity)- m10);
+			m11 = m11 + rlx_setA*(((uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(ny*ny-nz*nz)- m11);
+			m12 = m12 + rlx_setA*( - m12);
+            //m12 = m12 + rlx_setA*(-0.5*(rho0*(uy*uy-uz*uz)/porosity)- m12);
+			m13 = m13 + rlx_setA*( (ux*uy*rho0/porosity) + 0.5*alpha*C*nx*ny - m13);
+			m14 = m14 + rlx_setA*( (uy*uz*rho0/porosity) + 0.5*alpha*C*ny*nz - m14);
+			m15 = m15 + rlx_setA*( (ux*uz*rho0/porosity) + 0.5*alpha*C*nx*nz - m15);
+			m16 = m16 + rlx_setB*( - m16);
+			m17 = m17 + rlx_setB*( - m17);
+			m18 = m18 + rlx_setB*( - m18);
+            //----------------------------------------------------------------------//
+
+            //----------------With higher-order force ------------------------------//
+			//if (C == 0.0)	nx = ny = nz = 0.0;
+			//m1 = m1 + rlx_setA*((19*(ux*ux+uy*uy+uz*uz)*rho0/porosity - 11*rho) -19*alpha*C - m1)
+            //        + (1-0.5*rlx_setA)*38*(Fx*ux+Fy*uy+Fz*uz)/porosity;
+			//m2 = m2 + rlx_setA*((3*rho - 5.5*(ux*ux+uy*uy+uz*uz)*rho0/porosity)- m2)
+            //        + (1-0.5*rlx_setA)*11*(-Fx*ux-Fy*uy-Fz*uz)/porosity;
+            //jx = jx + Fx;
+			//m4 = m4 + rlx_setB*((-0.6666666666666666*ux*rho0)- m4)
+            //        + (1-0.5*rlx_setB)*(-0.6666666666666666*Fx);
+            //jy = jy + Fy;
+			//m6 = m6 + rlx_setB*((-0.6666666666666666*uy*rho0)- m6)
+            //        + (1-0.5*rlx_setB)*(-0.6666666666666666*Fy);
+            //jz = jz + Fz;
+			//m8 = m8 + rlx_setB*((-0.6666666666666666*uz*rho0)- m8)
+            //        + (1-0.5*rlx_setB)*(-0.6666666666666666*Fz);
+			//m9 = m9 + rlx_setA*(((2*ux*ux-uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(2*nx*nx-ny*ny-nz*nz) - m9)
+            //        + (1-0.5*rlx_setA)*(4*Fx*ux-2*Fy*uy-2*Fz*uz)/porosity;
+			////m10 = m10 + rlx_setA*( - m10);
+            //m10 = m10 + rlx_setA*(-0.5*rho0*((2*ux*ux-uy*uy-uz*uz)/porosity)- m10)
+            //          + (1-0.5*rlx_setA)*(-2*Fx*ux+Fy*uy+Fz*uz)/porosity;
+			//m11 = m11 + rlx_setA*(((uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(ny*ny-nz*nz)- m11)
+            //          + (1-0.5*rlx_setA)*(2*Fy*uy-2*Fz*uz)/porosity;
+			////m12 = m12 + rlx_setA*( - m12);
+            //m12 = m12 + rlx_setA*(-0.5*(rho0*(uy*uy-uz*uz)/porosity)- m12)
+            //          + (1-0.5*rlx_setA)*(-Fy*uy+Fz*uz)/porosity;
+			//m13 = m13 + rlx_setA*( (ux*uy*rho0/porosity) + 0.5*alpha*C*nx*ny - m13);
+            //          + (1-0.5*rlx_setA)*(Fy*ux+Fx*uy)/porosity;
+			//m14 = m14 + rlx_setA*( (uy*uz*rho0/porosity) + 0.5*alpha*C*ny*nz - m14);
+            //          + (1-0.5*rlx_setA)*(Fz*uy+Fy*uz)/porosity;
+			//m15 = m15 + rlx_setA*( (ux*uz*rho0/porosity) + 0.5*alpha*C*nx*nz - m15);
+            //          + (1-0.5*rlx_setA)*(Fz*ux+Fx*uz)/porosity;
+			//m16 = m16 + rlx_setB*( - m16);
+			//m17 = m17 + rlx_setB*( - m17);
+			//m18 = m18 + rlx_setB*( - m18);
+            //----------------------------------------------------------------------//
+
+			//.................inverse transformation......................................................
+			// q=0
+			fq = mrt_V1*rho-mrt_V2*m1+mrt_V3*m2;
+			dist[n] = fq;
+
+			// q = 1
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jx-m4)+mrt_V6*(m9-m10);
+			//nread = neighborList[n+Np];
+			dist[nr2] = fq;
+
+			// q=2
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m4-jx)+mrt_V6*(m9-m10);
+			//nread = neighborList[n];
+			dist[nr1] = fq;
+
+			// q = 3
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jy-m6)+mrt_V7*(m10-m9)+mrt_V8*(m11-m12);
+			//nread = neighborList[n+3*Np];
+			dist[nr4] = fq;
+
+			// q = 4
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m6-jy)+mrt_V7*(m10-m9)+mrt_V8*(m11-m12);
+			//nread = neighborList[n+2*Np];
+			dist[nr3] = fq;
+
+			// q = 5
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jz-m8)+mrt_V7*(m10-m9)+mrt_V8*(m12-m11);
+			//nread = neighborList[n+5*Np];
+			dist[nr6] = fq;
+
+			// q = 6
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m8-jz)+mrt_V7*(m10-m9)+mrt_V8*(m12-m11);
+			//nread = neighborList[n+4*Np];
+			dist[nr5] = fq;
+
+			// q = 7
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jx+jy)+0.025*(m4+m6)+
+					mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12+0.25*m13+0.125*(m16-m17);
+			//nread = neighborList[n+7*Np];
+			dist[nr8] = fq;
+
+			// q = 8
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2-0.1*(jx+jy)-0.025*(m4+m6) +mrt_V7*m9+mrt_V11*m10+mrt_V8*m11
+					+mrt_V12*m12+0.25*m13+0.125*(m17-m16);
+			//nread = neighborList[n+6*Np];
+			dist[nr7] = fq;
+
+			// q = 9
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jx-jy)+0.025*(m4-m6)+
+					mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12-0.25*m13+0.125*(m16+m17);
+			//nread = neighborList[n+9*Np];
+			dist[nr10] = fq;
+
+			// q = 10
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jy-jx)+0.025*(m6-m4)+
+					mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12-0.25*m13-0.125*(m16+m17);
+			//nread = neighborList[n+8*Np];
+			dist[nr9] = fq;
+
+			// q = 11
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jx+jz)+0.025*(m4+m8)
+					+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+					-mrt_V12*m12+0.25*m15+0.125*(m18-m16);
+			//nread = neighborList[n+11*Np];
+			dist[nr12] = fq;
+
+			// q = 12
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2-0.1*(jx+jz)-0.025*(m4+m8)+
+					mrt_V7*m9+mrt_V11*m10-mrt_V8*m11-mrt_V12*m12+0.25*m15+0.125*(m16-m18);
+			//nread = neighborList[n+10*Np];
+			dist[nr11]= fq;
+
+			// q = 13
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jx-jz)+0.025*(m4-m8)
+					+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+					-mrt_V12*m12-0.25*m15-0.125*(m16+m18);
+			//nread = neighborList[n+13*Np];
+			dist[nr14] = fq;
+
+			// q= 14
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jz-jx)+0.025*(m8-m4)
+					+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+					-mrt_V12*m12-0.25*m15+0.125*(m16+m18);
+			//nread = neighborList[n+12*Np];
+			dist[nr13] = fq;
+
+
+			// q = 15
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jy+jz)+0.025*(m6+m8)
+					-mrt_V6*m9-mrt_V7*m10+0.25*m14+0.125*(m17-m18);
+			nread = neighborList[n+15*Np];
+			dist[nread] = fq;
+
+			// q = 16
+			fq =  mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2-0.1*(jy+jz)-0.025*(m6+m8)
+					-mrt_V6*m9-mrt_V7*m10+0.25*m14+0.125*(m18-m17);
+			nread = neighborList[n+14*Np];
+			dist[nread] = fq;
+
+
+			// q = 17
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jy-jz)+0.025*(m6-m8)
+					-mrt_V6*m9-mrt_V7*m10-0.25*m14+0.125*(m17+m18);
+			nread = neighborList[n+17*Np];
+			dist[nread] = fq;
+
+			// q = 18
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jz-jy)+0.025*(m8-m6)
+					-mrt_V6*m9-mrt_V7*m10-0.25*m14-0.125*(m17+m18);
+			nread = neighborList[n+16*Np];
+			dist[nread] = fq;
+			//........................................................................
+
+			// Instantiate mass transport distributions
+			// Stationary value - distribution 0
+			nAB = 1.0/(nA+nB);
+			Aq[n] = 0.3333333333333333*nA;
+			Bq[n] = 0.3333333333333333*nB;
+
+			//...............................................
+			// q = 0,2,4
+			// Cq = {1,0,0}, {0,1,0}, {0,0,1}
+			delta = beta*nA*nB*nAB*0.1111111111111111*nx;
+			if (!(nA*nB*nAB>0)) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
+			a1 = nA*(0.1111111111111111*(1+4.5*ux))+delta;
+			b1 = nB*(0.1111111111111111*(1+4.5*ux))-delta;
+			a2 = nA*(0.1111111111111111*(1-4.5*ux))-delta;
+			b2 = nB*(0.1111111111111111*(1-4.5*ux))+delta;
+
+			// q = 1
+			//nread = neighborList[n+Np];
+			Aq[nr2] = a1;
+			Bq[nr2] = b1;
+			// q=2
+			//nread = neighborList[n];
+			Aq[nr1] = a2;
+			Bq[nr1] = b2;
+
+			//...............................................
+			// Cq = {0,1,0}
+			delta = beta*nA*nB*nAB*0.1111111111111111*ny;
+			if (!(nA*nB*nAB>0)) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
+			a1 = nA*(0.1111111111111111*(1+4.5*uy))+delta;
+			b1 = nB*(0.1111111111111111*(1+4.5*uy))-delta;
+			a2 = nA*(0.1111111111111111*(1-4.5*uy))-delta;
+			b2 = nB*(0.1111111111111111*(1-4.5*uy))+delta;
+
+			// q = 3
+			//nread = neighborList[n+3*Np];
+			Aq[nr4] = a1;
+			Bq[nr4] = b1;
+			// q = 4
+			//nread = neighborList[n+2*Np];
+			Aq[nr3] = a2;
+			Bq[nr3] = b2;
+
+			//...............................................
+			// q = 4
+			// Cq = {0,0,1}
+			delta = beta*nA*nB*nAB*0.1111111111111111*nz;
+			if (!(nA*nB*nAB>0)) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
+			a1 = nA*(0.1111111111111111*(1+4.5*uz))+delta;
+			b1 = nB*(0.1111111111111111*(1+4.5*uz))-delta;
+			a2 = nA*(0.1111111111111111*(1-4.5*uz))-delta;
+			b2 = nB*(0.1111111111111111*(1-4.5*uz))+delta;
+
+			// q = 5
+			//nread = neighborList[n+5*Np];
+			Aq[nr6] = a1;
+			Bq[nr6] = b1;
+			// q = 6
+			//nread = neighborList[n+4*Np];
+			Aq[nr5] = a2;
+			Bq[nr5] = b2;
+			//...............................................
+		}
+	}
+}
+
+//CP: capillary penalty
+// also turn off recoloring for grey nodes
+__global__  void dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
+        double *Phi, double *Psi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, double *Pressure, 
+        double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
+		double Gx, double Gy, double Gz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
+	int ijk,nn,n;
+	double fq;
+	// conserved momemnts
+	double rho,jx,jy,jz;
+	//double vx,vy,vz,v_mag;
+    //double ux,uy,uz,u_mag;
+    double ux,uy,uz;
+	// non-conserved moments
+	double m1,m2,m4,m6,m8,m9,m10,m11,m12,m13,m14,m15,m16,m17,m18;
+	double m3,m5,m7;
+	double nA,nB; // number density
+	double a1,b1,a2,b2,nAB,delta;
+	double C,nx,ny,nz; //color gradient magnitude and direction
+	double phi,tau,rho0,rlx_setA,rlx_setB;
+
+    //double GeoFun=0.0;//geometric function from Guo's PRE 66, 036304 (2002)
+    double porosity;
+    double perm;//voxel permeability
+    //double c0, c1; //Guo's model parameters
+    double tau_eff;
+    double mu_eff;//kinematic viscosity
+    double nx_gs,ny_gs,nz_gs;//grey-solid color gradient
+    double nx_phase,ny_phase,nz_phase,C_phase;
+    double Fx,Fy,Fz;
+	double gp1,gp2,gp4,gp6,gp8,gp9,gp10,gp11,gp12,gp13,gp14,gp15,gp16,gp17,gp18;
+	double gp3,gp5,gp7;
+    double Fcpx,Fcpy,Fcpz;//capillary penalty force
+
+	const double mrt_V1=0.05263157894736842;
+	const double mrt_V2=0.012531328320802;
+	const double mrt_V3=0.04761904761904762;
+	const double mrt_V4=0.004594820384294068;
+	const double mrt_V5=0.01587301587301587;
+	const double mrt_V6=0.0555555555555555555555555;
+	const double mrt_V7=0.02777777777777778;
+	const double mrt_V8=0.08333333333333333;
+	const double mrt_V9=0.003341687552213868;
+	const double mrt_V10=0.003968253968253968;
+	const double mrt_V11=0.01388888888888889;
+	const double mrt_V12=0.04166666666666666;
+
+	int S = Np/NBLOCKS/NTHREADS + 1;
+	for (int s=0; s<S; s++){
+		//........Get 1-D index for this thread....................
+		n =  S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x + start;
+		if (n<finish) {
+
+			// read the component number densities
+			nA = Den[n];
+			nB = Den[Np + n];
+            porosity = Poros[n];
+            perm = Perm[n];
+            nx_gs = GreySolidGrad[n+0*Np];
+            ny_gs = GreySolidGrad[n+1*Np];
+            nz_gs = GreySolidGrad[n+2*Np];
+
+			// compute phase indicator field
+			phi=(nA-nB)/(nA+nB);
+
+			// local density
+			rho0=rhoA + 0.5*(1.0-phi)*(rhoB-rhoA);
+			// local relaxation time
+			tau=tauA + 0.5*(1.0-phi)*(tauB-tauA);
+			tau_eff=tauA_eff + 0.5*(1.0-phi)*(tauB_eff-tauA_eff);
+			rlx_setA = 1.f/tau;
+			rlx_setB = 8.f*(2.f-rlx_setA)/(8.f-rlx_setA);
+            mu_eff = (tau_eff-0.5)/3.0;//kinematic viscosity
+
+			// Get the 1D index based on regular data layout
+			ijk = Map[n];
+			//					COMPUTE THE COLOR GRADIENT
+			//........................................................................
+			//.................Read Phase Indicator Values............................
+			//........................................................................
+			nn = ijk-1;							// neighbor index (get convention)
+			m1 = Phi[nn];						// get neighbor for phi - 1
+            gp1 = Psi[nn];
+			//........................................................................
+			nn = ijk+1;							// neighbor index (get convention)
+			m2 = Phi[nn];						// get neighbor for phi - 2
+            gp2 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideY;							// neighbor index (get convention)
+			m3 = Phi[nn];					// get neighbor for phi - 3
+            gp3 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideY;							// neighbor index (get convention)
+			m4 = Phi[nn];					// get neighbor for phi - 4
+            gp4 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideZ;						// neighbor index (get convention)
+			m5 = Phi[nn];					// get neighbor for phi - 5
+            gp5 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideZ;						// neighbor index (get convention)
+			m6 = Phi[nn];					// get neighbor for phi - 6
+            gp6 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideY-1;						// neighbor index (get convention)
+			m7 = Phi[nn];					// get neighbor for phi - 7
+            gp7 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideY+1;						// neighbor index (get convention)
+			m8 = Phi[nn];					// get neighbor for phi - 8
+            gp8 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideY-1;						// neighbor index (get convention)
+			m9 = Phi[nn];					// get neighbor for phi - 9
+            gp9 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideY+1;						// neighbor index (get convention)
+			m10 = Phi[nn];					// get neighbor for phi - 10
+            gp10 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideZ-1;						// neighbor index (get convention)
+			m11 = Phi[nn];					// get neighbor for phi - 11
+            gp11 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideZ+1;						// neighbor index (get convention)
+			m12 = Phi[nn];					// get neighbor for phi - 12
+            gp12 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideZ-1;						// neighbor index (get convention)
+			m13 = Phi[nn];					// get neighbor for phi - 13
+            gp13 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideZ+1;						// neighbor index (get convention)
+			m14 = Phi[nn];					// get neighbor for phi - 14
+            gp14 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideZ-strideY;					// neighbor index (get convention)
+			m15 = Phi[nn];					// get neighbor for phi - 15
+            gp15 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideZ+strideY;					// neighbor index (get convention)
+			m16 = Phi[nn];					// get neighbor for phi - 16
+            gp16 = Psi[nn];
+			//........................................................................
+			nn = ijk+strideZ-strideY;					// neighbor index (get convention)
+			m17 = Phi[nn];					// get neighbor for phi - 17
+            gp17 = Psi[nn];
+			//........................................................................
+			nn = ijk-strideZ+strideY;					// neighbor index (get convention)
+			m18 = Phi[nn];					// get neighbor for phi - 18
+            gp18 = Psi[nn];
+			//............Compute the Color Gradient...................................
+			nx_phase = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+			ny_phase = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+			nz_phase = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+			C_phase = sqrt(nx_phase*nx_phase+ny_phase*ny_phase+nz_phase*nz_phase);
+
+            //correct the normal color gradient by considering the effect of grey solid
+            nx = nx_phase + (1.0-porosity)*nx_gs; 
+            ny = ny_phase + (1.0-porosity)*ny_gs; 
+            nz = nz_phase + (1.0-porosity)*nz_gs; 
+            if (C_phase==0.0){
+                nx = nx_phase; 
+                ny = ny_phase;
+                nz = nz_phase;
+            }
+
+			//...........Normalize the Color Gradient.................................
+			C = sqrt(nx*nx+ny*ny+nz*nz);
+			double ColorMag = C;
+			if (C==0.0) ColorMag=1.0;
+			nx = nx/ColorMag;
+			ny = ny/ColorMag;
+			nz = nz/ColorMag;		
+
+			//............Compute the Greyscale Potential Gradient.....................
+//			Fcpx = 0.0;
+//			Fcpy = 0.0;
+//			Fcpz = 0.0;
+//            if (porosity!=1.0){
+//                //Fcpx = -3.0/18.0*(gp1-gp2+0.5*(gp7-gp8+gp9-gp10+gp11-gp12+gp13-gp14));
+//                //Fcpy = -3.0/18.0*(gp3-gp4+0.5*(gp7-gp8-gp9+gp10+gp15-gp16+gp17-gp18));
+//                //Fcpz = -3.0/18.0*(gp5-gp6+0.5*(gp11-gp12-gp13+gp14+gp15-gp16-gp17+gp18));
+//                Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+//                Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+//                Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+//                Fcpx *= alpha*W/sqrt(perm); 
+//                Fcpy *= alpha*W/sqrt(perm); 
+//                Fcpz *= alpha*W/sqrt(perm); 
+//                double Fcp_mag_temp = sqrt(Fcpx*Fcpx+Fcpy*Fcpy+Fcpz*Fcpz);
+//                double Fcp_mag = Fcp_mag_temp;
+//                if (Fcp_mag_temp==0.0) Fcp_mag=1.0;
+//                nx = Fcpx/Fcp_mag;
+//                ny = Fcpy/Fcp_mag;
+//                nz = Fcpz/Fcp_mag;
+//            }
+            Fcpx = -3.0/18.0*(m1-m2+0.5*(m7-m8+m9-m10+m11-m12+m13-m14));
+            Fcpy = -3.0/18.0*(m3-m4+0.5*(m7-m8-m9+m10+m15-m16+m17-m18));
+            Fcpz = -3.0/18.0*(m5-m6+0.5*(m11-m12-m13+m14+m15-m16-m17+m18));
+            //NOTE for open node (porosity=1.0),Fcp=0.0
+            Fcpx *= alpha*W*(1.0-porosity)/sqrt(perm); 
+            Fcpy *= alpha*W*(1.0-porosity)/sqrt(perm); 
+            Fcpz *= alpha*W*(1.0-porosity)/sqrt(perm); 
+
+
+			// q=0
+			fq = dist[n];
+			rho = fq;
+			m1  = -30.0*fq;
+			m2  = 12.0*fq;
+
+			// q=1
+			fq = dist[2*Np+n];
+			rho += fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jx = fq;
+			m4 = -4.0*fq;
+			m9 = 2.0*fq;
+			m10 = -4.0*fq;
+
+			// f2 = dist[10*Np+n];
+			fq = dist[1*Np+n];
+			rho += fq;
+			m1 -= 11.0*(fq);
+			m2 -= 4.0*(fq);
+			jx -= fq;
+			m4 += 4.0*(fq);
+			m9 += 2.0*(fq);
+			m10 -= 4.0*(fq);
+
+			// q=3
+			fq = dist[4*Np+n];
+			rho += fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jy = fq;
+			m6 = -4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 = fq;
+			m12 = -2.0*fq;
+
+			// q = 4
+			fq = dist[3*Np+n];
+			rho+= fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jy -= fq;
+			m6 += 4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 += fq;
+			m12 -= 2.0*fq;
+
+			// q=5
+			fq = dist[6*Np+n];
+			rho += fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jz = fq;
+			m8 = -4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 -= fq;
+			m12 += 2.0*fq;
+
+			// q = 6
+			fq = dist[5*Np+n];
+			rho+= fq;
+			m1 -= 11.0*fq;
+			m2 -= 4.0*fq;
+			jz -= fq;
+			m8 += 4.0*fq;
+			m9 -= fq;
+			m10 += 2.0*fq;
+			m11 -= fq;
+			m12 += 2.0*fq;
+
+			// q=7
+			fq = dist[8*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jy += fq;
+			m6 += fq;
+			m9  += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 = fq;
+			m16 = fq;
+			m17 = -fq;
+
+			// q = 8
+			fq = dist[7*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jy -= fq;
+			m6 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 += fq;
+			m16 -= fq;
+			m17 += fq;
+
+			// q=9
+			fq = dist[10*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jy -= fq;
+			m6 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 -= fq;
+			m16 += fq;
+			m17 += fq;
+
+			// q = 10
+			fq = dist[9*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jy += fq;
+			m6 += fq;
+			m9 += fq;
+			m10 += fq;
+			m11 += fq;
+			m12 += fq;
+			m13 -= fq;
+			m16 -= fq;
+			m17 -= fq;
+
+			// q=11
+			fq = dist[12*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jz += fq;
+			m8 += fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 = fq;
+			m16 -= fq;
+			m18 = fq;
+
+			// q=12
+			fq = dist[11*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 += fq;
+			m16 += fq;
+			m18 -= fq;
+
+			// q=13
+			fq = dist[14*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx += fq;
+			m4 += fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 -= fq;
+			m16 -= fq;
+			m18 -= fq;
+
+			// q=14
+			fq = dist[13*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jx -= fq;
+			m4 -= fq;
+			jz += fq;
+			m8 += fq;
+			m9 += fq;
+			m10 += fq;
+			m11 -= fq;
+			m12 -= fq;
+			m15 -= fq;
+			m16 += fq;
+			m18 += fq;
+
+			// q=15
+			fq = dist[16*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy += fq;
+			m6 += fq;
+			jz += fq;
+			m8 += fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 = fq;
+			m17 += fq;
+			m18 -= fq;
+
+			// q=16
+			fq = dist[15*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy -= fq;
+			m6 -= fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 += fq;
+			m17 -= fq;
+			m18 += fq;
+
+			// q=17
+			fq = dist[18*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy += fq;
+			m6 += fq;
+			jz -= fq;
+			m8 -= fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 -= fq;
+			m17 += fq;
+			m18 += fq;
+
+			// q=18
+			fq = dist[17*Np+n];
+			rho += fq;
+			m1 += 8.0*fq;
+			m2 += fq;
+			jy -= fq;
+			m6 -= fq;
+			jz += fq;
+			m8 += fq;
+			m9 -= 2.0*fq;
+			m10 -= 2.0*fq;
+			m14 -= fq;
+			m17 -= fq;
+			m18 -= fq;
+
+            // Compute greyscale related parameters
+            ux = (jx/rho0+0.5*porosity*Gx+0.5*Fcpx/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            uy = (jy/rho0+0.5*porosity*Gy+0.5*Fcpy/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            uz = (jz/rho0+0.5*porosity*Gz+0.5*Fcpz/rho0)/(1.0+0.5*porosity*mu_eff/perm);
+            if (porosity==1.0){//i.e. open nodes
+                ux = (jx/rho0+0.5*porosity*Gx);
+                uy = (jy/rho0+0.5*porosity*Gy);
+                uz = (jz/rho0+0.5*porosity*Gz);
+            }
+
+            //Update the total force to include linear (Darcy) and nonlinear (Forchheimer) drags due to the porous medium
+            Fx = rho0*(-porosity*mu_eff/perm*ux + porosity*Gx)+Fcpx;
+            Fy = rho0*(-porosity*mu_eff/perm*uy + porosity*Gy)+Fcpy;
+            Fz = rho0*(-porosity*mu_eff/perm*uz + porosity*Gz)+Fcpz;
+            if (porosity==1.0){
+                Fx=rho0*(porosity*Gx);
+                Fy=rho0*(porosity*Gy);
+                Fz=rho0*(porosity*Gz);
+            }
+
+			// write the velocity 
+			Velocity[n] = ux;
+			Velocity[Np+n] = uy;
+			Velocity[2*Np+n] = uz;
+            //Pressure[n] = rho/3.f/porosity;
+            Pressure[n] = rho/3.f;
+
+			//........................................................................
+			//..............carry out relaxation process..............................
+			//..........Toelke, Fruediger et. al. 2006................................
+            //---------------- NO higher-order force -------------------------------//
+			if (C == 0.0)	nx = ny = nz = 0.0;
+			m1 = m1 + rlx_setA*((19*(ux*ux+uy*uy+uz*uz)*rho0/porosity - 11*rho) -19*alpha*C - m1);
+			m2 = m2 + rlx_setA*((3*rho - 5.5*(ux*ux+uy*uy+uz*uz)*rho0/porosity)- m2);
+            jx = jx + Fx;
+			m4 = m4 + rlx_setB*((-0.6666666666666666*ux*rho0)- m4)
+                    + (1-0.5*rlx_setB)*(-0.6666666666666666*Fx);
+            jy = jy + Fy;
+			m6 = m6 + rlx_setB*((-0.6666666666666666*uy*rho0)- m6)
+                    + (1-0.5*rlx_setB)*(-0.6666666666666666*Fy);
+            jz = jz + Fz;
+			m8 = m8 + rlx_setB*((-0.6666666666666666*uz*rho0)- m8)
+                    + (1-0.5*rlx_setB)*(-0.6666666666666666*Fz);
+			m9 = m9 + rlx_setA*(((2*ux*ux-uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(2*nx*nx-ny*ny-nz*nz) - m9);
+			m10 = m10 + rlx_setA*( - m10);
+            //m10 = m10 + rlx_setA*(-0.5*rho0*((2*ux*ux-uy*uy-uz*uz)/porosity)- m10);
+			m11 = m11 + rlx_setA*(((uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(ny*ny-nz*nz)- m11);
+			m12 = m12 + rlx_setA*( - m12);
+            //m12 = m12 + rlx_setA*(-0.5*(rho0*(uy*uy-uz*uz)/porosity)- m12);
+			m13 = m13 + rlx_setA*( (ux*uy*rho0/porosity) + 0.5*alpha*C*nx*ny - m13);
+			m14 = m14 + rlx_setA*( (uy*uz*rho0/porosity) + 0.5*alpha*C*ny*nz - m14);
+			m15 = m15 + rlx_setA*( (ux*uz*rho0/porosity) + 0.5*alpha*C*nx*nz - m15);
+			m16 = m16 + rlx_setB*( - m16);
+			m17 = m17 + rlx_setB*( - m17);
+			m18 = m18 + rlx_setB*( - m18);
+            //----------------------------------------------------------------------//
+
+            //----------------With higher-order force ------------------------------//
+			//if (C == 0.0)	nx = ny = nz = 0.0;
+			//m1 = m1 + rlx_setA*((19*(ux*ux+uy*uy+uz*uz)*rho0/porosity - 11*rho) -19*alpha*C - m1)
+            //        + (1-0.5*rlx_setA)*38*(Fx*ux+Fy*uy+Fz*uz)/porosity;
+			//m2 = m2 + rlx_setA*((3*rho - 5.5*(ux*ux+uy*uy+uz*uz)*rho0/porosity)- m2)
+            //        + (1-0.5*rlx_setA)*11*(-Fx*ux-Fy*uy-Fz*uz)/porosity;
+            //jx = jx + Fx;
+			//m4 = m4 + rlx_setB*((-0.6666666666666666*ux*rho0)- m4)
+            //        + (1-0.5*rlx_setB)*(-0.6666666666666666*Fx);
+            //jy = jy + Fy;
+			//m6 = m6 + rlx_setB*((-0.6666666666666666*uy*rho0)- m6)
+            //        + (1-0.5*rlx_setB)*(-0.6666666666666666*Fy);
+            //jz = jz + Fz;
+			//m8 = m8 + rlx_setB*((-0.6666666666666666*uz*rho0)- m8)
+            //        + (1-0.5*rlx_setB)*(-0.6666666666666666*Fz);
+			//m9 = m9 + rlx_setA*(((2*ux*ux-uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(2*nx*nx-ny*ny-nz*nz) - m9)
+            //        + (1-0.5*rlx_setA)*(4*Fx*ux-2*Fy*uy-2*Fz*uz)/porosity;
+			////m10 = m10 + rlx_setA*( - m10);
+            //m10 = m10 + rlx_setA*(-0.5*rho0*((2*ux*ux-uy*uy-uz*uz)/porosity)- m10)
+            //          + (1-0.5*rlx_setA)*(-2*Fx*ux+Fy*uy+Fz*uz)/porosity;
+			//m11 = m11 + rlx_setA*(((uy*uy-uz*uz)*rho0/porosity) + 0.5*alpha*C*(ny*ny-nz*nz)- m11)
+            //          + (1-0.5*rlx_setA)*(2*Fy*uy-2*Fz*uz)/porosity;
+			////m12 = m12 + rlx_setA*( - m12);
+            //m12 = m12 + rlx_setA*(-0.5*(rho0*(uy*uy-uz*uz)/porosity)- m12)
+            //          + (1-0.5*rlx_setA)*(-Fy*uy+Fz*uz)/porosity;
+			//m13 = m13 + rlx_setA*( (ux*uy*rho0/porosity) + 0.5*alpha*C*nx*ny - m13);
+            //          + (1-0.5*rlx_setA)*(Fy*ux+Fx*uy)/porosity;
+			//m14 = m14 + rlx_setA*( (uy*uz*rho0/porosity) + 0.5*alpha*C*ny*nz - m14);
+            //          + (1-0.5*rlx_setA)*(Fz*uy+Fy*uz)/porosity;
+			//m15 = m15 + rlx_setA*( (ux*uz*rho0/porosity) + 0.5*alpha*C*nx*nz - m15);
+            //          + (1-0.5*rlx_setA)*(Fz*ux+Fx*uz)/porosity;
+			//m16 = m16 + rlx_setB*( - m16);
+			//m17 = m17 + rlx_setB*( - m17);
+			//m18 = m18 + rlx_setB*( - m18);
+            //----------------------------------------------------------------------//
+
+			//.................inverse transformation......................................................
+			// q=0
+			fq = mrt_V1*rho-mrt_V2*m1+mrt_V3*m2;
+			dist[n] = fq;
+
+			// q = 1
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jx-m4)+mrt_V6*(m9-m10);
+			dist[1*Np+n] = fq;
+
+			// q=2
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m4-jx)+mrt_V6*(m9-m10);
+			dist[2*Np+n] = fq;
+
+			// q = 3
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jy-m6)+mrt_V7*(m10-m9)+mrt_V8*(m11-m12);
+			dist[3*Np+n] = fq;
+
+			// q = 4
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m6-jy)+mrt_V7*(m10-m9)+mrt_V8*(m11-m12);
+			dist[4*Np+n] = fq;
+
+			// q = 5
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(jz-m8)+mrt_V7*(m10-m9)+mrt_V8*(m12-m11);
+			dist[5*Np+n] = fq;
+
+			// q = 6
+			fq = mrt_V1*rho-mrt_V4*m1-mrt_V5*m2+0.1*(m8-jz)+mrt_V7*(m10-m9)+mrt_V8*(m12-m11);
+			dist[6*Np+n] = fq;
+
+			// q = 7
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jx+jy)+0.025*(m4+m6)+
+					mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12+0.25*m13+0.125*(m16-m17);
+			dist[7*Np+n] = fq;
+
+
+			// q = 8
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2-0.1*(jx+jy)-0.025*(m4+m6) +mrt_V7*m9+mrt_V11*m10+mrt_V8*m11
+					+mrt_V12*m12+0.25*m13+0.125*(m17-m16);
+			dist[8*Np+n] = fq;
+
+			// q = 9
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jx-jy)+0.025*(m4-m6)+
+					mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12-0.25*m13+0.125*(m16+m17);
+			dist[9*Np+n] = fq;
+
+			// q = 10
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2+0.1*(jy-jx)+0.025*(m6-m4)+
+					mrt_V7*m9+mrt_V11*m10+mrt_V8*m11+mrt_V12*m12-0.25*m13-0.125*(m16+m17);
+			dist[10*Np+n] = fq;
+
+
+			// q = 11
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jx+jz)+0.025*(m4+m8)
+					+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+					-mrt_V12*m12+0.25*m15+0.125*(m18-m16);
+			dist[11*Np+n] = fq;
+
+			// q = 12
+			fq = mrt_V1*rho+mrt_V9*m1+mrt_V10*m2-0.1*(jx+jz)-0.025*(m4+m8)+
+					mrt_V7*m9+mrt_V11*m10-mrt_V8*m11-mrt_V12*m12+0.25*m15+0.125*(m16-m18);
+			dist[12*Np+n] = fq;
+
+			// q = 13
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jx-jz)+0.025*(m4-m8)
+					+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+					-mrt_V12*m12-0.25*m15-0.125*(m16+m18);
+			dist[13*Np+n] = fq;
+
+			// q= 14
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jz-jx)+0.025*(m8-m4)
+					+mrt_V7*m9+mrt_V11*m10-mrt_V8*m11
+					-mrt_V12*m12-0.25*m15+0.125*(m16+m18);
+
+			dist[14*Np+n] = fq;
+
+			// q = 15
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jy+jz)+0.025*(m6+m8)
+					-mrt_V6*m9-mrt_V7*m10+0.25*m14+0.125*(m17-m18);
+			dist[15*Np+n] = fq;
+
+			// q = 16
+			fq =  mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2-0.1*(jy+jz)-0.025*(m6+m8)
+					-mrt_V6*m9-mrt_V7*m10+0.25*m14+0.125*(m18-m17);
+			dist[16*Np+n] = fq;
+
+
+			// q = 17
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jy-jz)+0.025*(m6-m8)
+					-mrt_V6*m9-mrt_V7*m10-0.25*m14+0.125*(m17+m18);
+			dist[17*Np+n] = fq;
+
+			// q = 18
+			fq = mrt_V1*rho+mrt_V9*m1
+					+mrt_V10*m2+0.1*(jz-jy)+0.025*(m8-m6)
+					-mrt_V6*m9-mrt_V7*m10-0.25*m14-0.125*(m17+m18);
+			dist[18*Np+n] = fq;
+			//........................................................................
+
+			// Instantiate mass transport distributions
+			// Stationary value - distribution 0
+			nAB = 1.0/(nA+nB);
+			Aq[n] = 0.3333333333333333*nA;
+			Bq[n] = 0.3333333333333333*nB;
+
+			//...............................................
+			// q = 0,2,4
+			// Cq = {1,0,0}, {0,1,0}, {0,0,1}
+			delta = beta*nA*nB*nAB*0.1111111111111111*nx;
+			if (!(nA*nB*nAB>0)) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
+			a1 = nA*(0.1111111111111111*(1+4.5*ux))+delta;
+			b1 = nB*(0.1111111111111111*(1+4.5*ux))-delta;
+			a2 = nA*(0.1111111111111111*(1-4.5*ux))-delta;
+			b2 = nB*(0.1111111111111111*(1-4.5*ux))+delta;
+
+			Aq[1*Np+n] = a1;
+			Bq[1*Np+n] = b1;
+			Aq[2*Np+n] = a2;
+			Bq[2*Np+n] = b2;
+
+			//...............................................
+			// q = 2
+			// Cq = {0,1,0}
+			delta = beta*nA*nB*nAB*0.1111111111111111*ny;
+			if (!(nA*nB*nAB>0)) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
+			a1 = nA*(0.1111111111111111*(1+4.5*uy))+delta;
+			b1 = nB*(0.1111111111111111*(1+4.5*uy))-delta;
+			a2 = nA*(0.1111111111111111*(1-4.5*uy))-delta;
+			b2 = nB*(0.1111111111111111*(1-4.5*uy))+delta;
+
+			Aq[3*Np+n] = a1;
+			Bq[3*Np+n] = b1;
+			Aq[4*Np+n] = a2;
+			Bq[4*Np+n] = b2;
+			//...............................................
+			// q = 4
+			// Cq = {0,0,1}
+			delta = beta*nA*nB*nAB*0.1111111111111111*nz;
+			if (!(nA*nB*nAB>0)) delta=0;
+            if (RecoloringOff==true && porosity !=1.0) delta=0;
+			a1 = nA*(0.1111111111111111*(1+4.5*uz))+delta;
+			b1 = nB*(0.1111111111111111*(1+4.5*uz))-delta;
+			a2 = nA*(0.1111111111111111*(1-4.5*uz))-delta;
+			b2 = nB*(0.1111111111111111*(1-4.5*uz))+delta;
+
+			Aq[5*Np+n] = a1;
+			Bq[5*Np+n] = b1;
+			Aq[6*Np+n] = a2;
+			Bq[6*Np+n] = b2;
+			//...............................................
+
+		}
+	}
+}
+
 __global__ void dvc_ScaLBL_PhaseField_InitFromRestart(double *Den, double *Aq, double *Bq, int start, int finish, int Np){
 	int idx;
 	double nA,nB;
@@ -1480,6 +3020,36 @@ __global__ void dvc_ScaLBL_PhaseField_InitFromRestart(double *Den, double *Aq, d
 		}
 	}
 }
+
+//NOTE: so far it seems that we don't need this greyscale potental update;
+//      if we compute a grey-potential first, and take its gradient to work out the capillary penalty force, it is highly unstable;
+//      this is because the grey-potential is simply a scaling of the normal phase field, but such scaling create some artificial gradient at the open-grey interface
+//__global__  void dvc_ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
+//                                                      int start, int finish, int Np){
+//	int idx,n;
+//    double phi,psi;
+//    double cap_penalty;
+//    double porosity,perm;
+//
+//	int S = Np/NBLOCKS/NTHREADS + 1;
+//	for (int s=0; s<S; s++){
+//		//........Get 1-D index for this thread....................
+//		n =  S*blockIdx.x*blockDim.x + s*blockDim.x + threadIdx.x + start;
+//		if (n<finish) {
+//			idx = Map[n];
+//			phi = Phi[idx];
+//            porosity = Poro[n];
+//            perm = Perm[n];    
+//            cap_penalty = 1.0;
+//
+//            if (porosity!=1.0) cap_penalty = alpha*W/sqrt(perm);
+//            psi = cap_penalty*phi;
+//            Psi[idx] = psi;
+//		}
+//	}
+//}
+
+
 ////Model-2&3
 //__global__ void dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor(int *neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den,
 //		 double *Phi, double *GreySolidGrad, double *Poros,double *Perm, double *Velocity, 
@@ -2999,6 +4569,48 @@ extern "C" void ScaLBL_PhaseField_InitFromRestart(double *Den, double *Aq, doubl
 		printf("hip error in ScaLBL_PhaseField_InitFromRestart: %s \n",hipGetErrorString(err));
 	}
 }
+
+//Model-1 & 4 with capillary pressure penalty
+extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor_CP(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
+        double *Phi,double *Psi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel, double *Pressure,
+        double rhoA, double rhoB, double tauA, double tauB,double tauA_eff,double tauB_eff, double alpha, double beta,
+		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
+
+	dvc_ScaLBL_D3Q19_AAeven_GreyscaleColor_CP<<<NBLOCKS,NTHREADS >>>(Map, dist, Aq, Bq, Den, Phi, Psi, GreySolidGrad, Poros, Perm, Vel, Pressure,
+            rhoA, rhoB, tauA, tauB, tauA_eff, tauB_eff, alpha, beta, Fx, Fy, Fz, RecoloringOff, W, strideY, strideZ, start, finish, Np);
+	hipError_t err = hipGetLastError();
+	if (hipSuccess != err){
+		printf("hip error in ScaLBL_D3Q19_AAeven_GreyscaleColor_CP: %s \n",hipGetErrorString(err));
+	}
+
+}
+
+//Model-1 & 4 with capillary pressure penalty
+extern "C" void ScaLBL_D3Q19_AAodd_GreyscaleColor_CP(int *d_neighborList, int *Map, double *dist, double *Aq, double *Bq, double *Den, 
+		double *Phi, double *Psi, double *GreySolidGrad, double *Poros,double *Perm,double *Vel,double *Pressure, 
+        double rhoA, double rhoB, double tauA, double tauB, double tauA_eff,double tauB_eff, double alpha, double beta,
+		double Fx, double Fy, double Fz, bool RecoloringOff, double W, int strideY, int strideZ, int start, int finish, int Np){
+
+	dvc_ScaLBL_D3Q19_AAodd_GreyscaleColor_CP<<<NBLOCKS,NTHREADS >>>(d_neighborList, Map, dist, Aq, Bq, Den, Phi, Psi, GreySolidGrad, Poros, Perm,Vel,Pressure,
+			rhoA, rhoB, tauA, tauB, tauA_eff, tauB_eff,alpha, beta, Fx, Fy, Fz, RecoloringOff, W, strideY, strideZ, start, finish, Np);
+
+	hipError_t err = hipGetLastError();
+	if (hipSuccess != err){
+		printf("hip error in ScaLBL_D3Q19_AAodd_GreyscaleColor_CP: %s \n",hipGetErrorString(err));
+	}
+}
+
+//extern "C" void ScaLBL_Update_GreyscalePotential(int *Map, double *Phi, double *Psi, double *Poro, double *Perm, double alpha, double W, 
+//		int start, int finish, int Np){
+//
+//	dvc_ScaLBL_Update_GreyscalePotential<<<NBLOCKS,NTHREADS >>>(Map, Phi, Psi, Poro, Perm, alpha, W, start, finish, Np);
+//
+//	hipError_t err = hipGetLastError();
+//	if (hipSuccess != err){
+//		printf("hip error in ScaLBL_Update_GreyscalePotential: %s \n",hipGetErrorString(err));
+//	}
+//}
+
 ////Model-2&3
 //extern "C" void ScaLBL_D3Q19_AAeven_GreyscaleColor(int *Map, double *dist, double *Aq, double *Bq, double *Den, 
 //        double *Phi,double *GreySolidGrad, double *Poros,double *Perm,double *Vel,