Phys 113 Final Project

Size: px

Start display at page:

Download "Phys 113 Final Project"

Kelly Foster
5 years ago
Views:

Phys 113 Final Project LBM model for capillary fluid modelling Andrey Sushko Introduction Lattice Boltzmann Method (LMB) models have recently emerged as a highly effective means of modelling complex

1 Phys 113 Final Project LBM model for capillary fluid modelling Andrey Sushko Introduction Lattice Boltzmann Method (LMB) models have recently emerged as a highly effective means of modelling complex fluid mechanics problems, owing to its ability to handle complex boundary conditions, arbitrary local and global forces, and systems with multiphase flows. In the paper, we discuss the basic implementation of an LBM model from a physical and computational standpoint, demonstrate various capabilities of the resulting software, and evaluate the effectiveness of the model under various conditions. Physical foundations Fundamentally, LBM modelling relies on a representation of the fluid as a collection of fractious particles traveling with set velocities along lattice links and colliding at lattice sites. A common implementation in 2 dimensions is the D2Q9 lattice shown here. There are 9 represented velocities (including stationary) with particles located at the centre streaming to the lattice points shown after one time step. If the particles are allowed to stream without collisions, the quantity of fluid with velocity at will obey: located In order to model the interactions of particle flows within the fluid, we introduce a collision operator and set Taking the limit for small increments of time, we see that and, hence, Although difficult to solve, is approximated numerically using a simplified operator introduced by Bhatnagar, Gross, Krook, and Welander (the BGKW approximation) as follows:

2 Where is the collision frequency and is the local equilibrium distribution function. While the equilibrium distribution can be modified to account for any number of forces, we will rely primarily on the normalized Maxwell distribution. Recognizing that we need only calculate ( for a finite number of flow velocities site ), we write the distribution as ) and (due to the finite number of lattice links from each lattice where is the macroscopic fluid velocity and is the local fluid density given by. Taylor expanding gives ( ) for appropriate constant weighting factors streaming velocities. which are specific to the configuration of possible Making this approximation we get an easily computable expression for the quantity of fluid streaming along each lattice link: [ ] In order to incorporate arbitrary body forces on the fluid, we can modify the macroscopic fluid velocity formula or, equivalently add an extra term to the formula for as follows [ ] Where is the sound speed given by and is the applied force. With the above formula we can very easily add gravity to the simulation by creating a constant downward pointing force vector or, more interestingly, simulate cohesion between particles of the fluid by setting Where is the interaction strength (positive or negative), are a set of lattice-specific weighting factors similar to, and the operator is usually of the form For constants and determined by the specifics of the system being analyzed.

Implementation The code required to implement an LBM model as described above can be broken down in to the following steps: For each time-step { Calculate and update in place at each point Stream to

3 Implementation The code required to implement an LBM model as described above can be broken down in to the following steps: For each time-step { Calculate and update in place at each point Stream to new locations Handle boundary conditions Update density, flow velocity, and force vectors to permit us to update The actual code used can be found in the appendix. Boundaries Boundary conditions for the simulation can be handled in a variety of ways. One of the simplest boundary conditions is the bounceback condition in which incoming flows have the normal component of flow velocity inverted i.e., any fluid with velocity directed towards the boundary will be updated to have velocity directed away. This straightforward method can also be modified to simulate a sliding boundary by, for instance, subtracting some fluid from one diagonally incident flow and adding it to the An illustration of the simple bounce-back boundary condition at one node. other diagonally incident flow thus adding some momentum to the system. Using this condition on one boundary is a very easy way to create a lid-driven-cavity system. Since the fluid is treated as collections of particles, any number of reasonable boundary conditions may be implemented. Copying the distribution one lattice cell away from the boundary to the cells along the boundary, for instance, generates adiabatic boundaries. It is also very simple to inject or remove fluid from the system by just adding to or subtracting from at any given point. This may be useful in cases where we want to simulate an open boundary by simply deleting fluid streaming across it. Similarly, one can create periodic systems simply by adding outgoing flows from one boundary to incoming flows from another.

4 Test cases A good test of the various components of the fluid dynamics code is the lid-driven cavity system. In this system, a stationary fluid of uniform density is placed in a box with bounce-back boundaries on three walls and a modified sliding-wall bounce-back boundary condition on the fourth (in this case, the right edge). The lid speed is set so as to give a Reynolds number of 100. Macroscopic flow velocities for the fluid are shown soon after initialising the system and after the flow approximately equilibrates at a much later time. After 5,000 time-steps:

5 After 100,000 time-steps:

6 Plotting the vertical velocity through a horizontal line bisecting the box allows us to compare the results of this model against existing data. The plot below shows the velocity profile after 1000, 10,000, and 100,000 time-steps. As time increases the solution appears to approach the reported values. It is difficult to determine whether exact agreement will be achieved after enough time owing to the rather high runtime of such a simulation 1k 10k 100k Discussion By design, it is clear that the simulation has a finite maximum lattice speed. In D2Q9 the fluid streams no more than one lattice cell per time-step in each dimension. Hence, it is impossible for any signals to travel faster than i.e., the speed of sound in the simulated fluid. The formula for can, in fact, produce negative solutions if the macroscopic fluid velocity becomes close to. Since the model will propagate any local results across the lattice, an error at just one lattice cell can destabilise and often completely invalidate the entire simulation. In general, therefore, it is safest to keep flow velocities and external force corrections below at all points to avoid erratic results.

7 Machine precision We can use conservation of mass to estimate the magnitude of error incurred by having a finite machine precision. When dealing with, in the lid-driven cavity scenario above, and using C++ double precision variables for all relevant quantities, the total mass change was found to be less than per time-step. While this is fairly reasonable, simulations that require, for instance, substantially lower fluid densities may be best computed in non-dimensional form. Parallelisation Since LBM is an explicit method, the computations can be easily parallelised to improve runtime. In fact, the collision and streaming steps can be parallelised with essentially no non-parallelisable overhead and the boundary conditions, in general, require be computed in parallel. calculations and, if need be, can also Conclusion LBM modelling is a very capable tool due to the variety of complex interactions that may be studied using the method. It is very well suited to solving complex time-dependent systems such as the behaviour of capillary fluids. At the same time, the computational costs make it somewhat prohibitive to implement on a large lattice unless parallel computing resources are available. Similarly, systems that reach equilibrium slowly but still contain moderately high equilibrium velocities, such as the lid driven cavity, can end up becoming very costly to compute. Various methods exist to improve computational time such as the use of non-uniform lattices which sacrifice precision in regions where it is not required, or variable time-stepping for systems that settle down to lower velocity over time. References Junfeng Zhang, Lattice Boltzmann method for microfluidics: models and applications: Mohamad, A. A., Lattice Boltzmann Method: 5.pdf?auth66= _d10a02de05c8febc7f0fd0dffc409a6b&ext=.pdf Sukop, Michael C. and Or, Dani Lattice Boltzmann method for modeling liquid-vapor interface configurations in porous media CFD Online Wiki: Validation and test cases Lallemand, Pierre and Luo, Li-Shi Theory of the Lattice Boltzmann Method: Dispersion, Dissipation, Isotropy, Galilean Invariance, and Stability

8 Appendix Full code used for the simulation. Note: for conciseness the code for graphical output has been omitted here. void LBMrun(int n, int m, int time, int interval){ //D2Q9 Code //====================================================== // LBM -Advection-Diffusion D2Q9 //int n=100, m=100; double f[9][n][m], u[n][m], v[n][m], XForce[n][m], YForce[n][m]; double feq[9]; double rho[n][m]; double x[n], y[m]; double w[9] = {4./9, 1./9, 1./9, 1./9, 1./9, 1./36, 1./36, 1./36, 1./36; double g[9] = {0, 2., 2., 2., 2., 1., 1., 1., 1.; double cx[9] = {0, 1, 0, -1, 0, 1, -1, -1, 1; double cy[9] = {0, 0, 1, 0, -1, 1, 1, -1, -1; double G = 0.0; double Vdamp = 0.0; //Expt with damping macroscopic vel for stability double grav = 0.0; int i,j,k; double dt = 1.0; double dx = 1.0; double dy = dx; x[0] = 0.0; y[0] = 0.0; for (i = 1; i < n; i++){ x[i] = x[i-1] + dx; for (i = 1; i < m; i++){ y[i] = y[i-1] + dy; double u0 = 0.0; double alpha = 0.01; double Re = u0 * m/alpha; cout << Re << endl; double ck = dx/dt; double csq = ck*ck; double omega = 1.0/(2.*alpha/(csq*dt)+0.5); cout << omega <<endl; double rho0 = 5; int mstep = time; u[i][j] = 0.0; v[i][j] = 0.0; XForce[i][j] = 0.0; YForce[i][j] = 0.0; rho[i][j] = rho0; for (k = 0; k < 9; k++){ f[k][i][j] = w[k]*rho0;

9 for (int i = 0; i < n; i++){ u[i][m-1] = u0; for (int kk = 1; kk < mstep; kk++){ //collision double t1 = u[i][j]*u[i][j] + v[i][j]*v[i][j]; for (k = 0; k < 9; k++){ double t2 = u[i][j]*cx[k] + v[i][j]*cy[k]; double Fk = XForce[i][j]*cx[k] + YForce[i][j]*cy[k]; feq[k] = w[k]*rho[i][j]*( *t2/csq + 4.5*t2*t2/csq/csq - 1.5*t1/csq); f[k][i][j] = omega*feq[k] + (1.- omega)*f[k][i][j] + w[k]*dt*fk/(csq); //streaming for (int j = 0; j < m; j++){ for (int i = n-1; i > 0; i--){ f[1][i][j] = f[1][i-1][j]; for (int i = 0; i < n-1; i++){ f[3][i][j] = f[3][i+1][j]; for (int j = m-1; j > 0; j--){ for (int i = 0; i < n; i++){ f[2][i][j] = f[2][i][j-1]; for (int i = n-1; i > 0; i--){ f[5][i][j] = f[5][i-1][j-1]; for (int i = 0; i < n-1; i++){ f[6][i][j] = f[6][i+1][j-1]; for (int j = 0; j < m-1; j++){ for (int i = 0; i < n; i++){ f[4][i][j] = f[4][i][j+1]; for (int i = 0; i < n-1; i++){ f[7][i][j] = f[7][i+1][j+1]; for (int i = n-1; i > 0; i--){ f[8][i][j] = f[8][i-1][j+1]; // Bounce back boundary conditions f[1][0][j] = f[3][0][j];

10 f[5][0][j] = f[7][0][j]; f[8][0][j] = f[6][0][j]; f[3][n-1][j] = f[1][n-1][j]; f[7][n-1][j] = f[5][n-1][j]; f[6][n-1][j] = f[8][n-1][j]; f[2][i][0] = f[4][i][0]; f[5][i][0] = f[7][i][0]; f[6][i][0] = f[8][i][0]; for (i = 1; i < n-1; i++){ double rhon = f[0][i][m-1] + f[1][i][m-1] + f[3][i][m-1] + 2*(f[2][i][m-1] + f[6][i][m-1] + f[5][i][m-1]); f[4][i][m-1] = f[2][i][m-1]; f[7][i][m-1] = f[5][i][m-1] - rhon*u0/6; f[8][i][m-1] = f[6][i][m-1] + rhon*u0/6; double netdens = 0; for (int i = 0; i < n; i++){ for (int j = 0; j < m; j++){ double sum = 0; for (int k = 0; k < 9; k++){ sum += f[k][i][j]; rho[i][j] = sum; netdens += sum; cout << netdens << endl; rho[i][m-1] = f[0][i][m-1] + f[1][i][m-1] + f[3][i][m-1] + 2*(f[2][i][m-1] + f[6][i][m-1] + f[5][i][m-1]); for (int i = 0; i < n; i++){ for (int j = 0; j < m; j++){ if(rho[i][j] > 0){ double usum = 0; double vsum = 0; for (int k = 0; k < 9; k++){ usum += f[k][i][j]*cx[k]; vsum += f[k][i][j]*cy[k]; u[i][j] = usum/rho[i][j]; v[i][j] = vsum/rho[i][j]; else { u[i][j] = v[i][j] = 0; if(rho[i][j] > 0){ double fxsum = 0; double fysum = 0;

11 for (k = 0; k < 9; k++){ int i2 = i+(int)cx[k]; int j2 = j+(int)cy[k]; if(i2 > 0 && i2 <n && j2 > 0 && j2 < m){ fxsum += G*Psi(rho[i][j])*g[k]*Psi(rho[i+(int)cx[k]][j+(int)cy[k]])*cx[k]; fysum += G*Psi(rho[i][j])*g[k]*Psi(rho[i+(int)cx[k]][j+(int)cy[k]])*cy[k]; XForce[i][j] = (fxsum + grav - Vdamp*u[i][j]) * rho[i][j]; YForce[i][j] = (fysum - Vdamp*v[i][j]) * rho[i][j]; //u[i][j] += XForce[i][j]/rho[i][j]/omega; //v[i][j] += YForce[i][j]/rho[i][j]/omega; //alternatice method of implementing force double netke = 0; double netpe = 0; netke += 0.5*rho[i][j]*(u[i][j]*u[i][j] + v[i][j]*v[i][j]); netpe += rho[i][j]*(n-i)*grav; if(kk%interval == 0){ cout << kk << endl; cout << netdens << endl; cout << netpe << ", " << netke << ", " << netpe+netke <<endl; double dens = (rho[i][j] > 0? rho[i][j] : 0); display.drawcellat(i, j, dens, u[i][j], v[i][j]); for (i = 3; i < n; i+=5){ for (j = 3; j < m; j+=5){ display.drawcellat(i, j, -1., u[i][j], v[i][j]); ofstream outfile; outfile.open("lbmout.csv"); for (int j = 0; j < m; j++){ outfile << u[50][j] << endl; /* Other BCs // Left boundary condition, the temperature is given, tw

12 //f[1][0][j] = w[1]*tw + w[3]*tw - f[3][0][j]; //f[5][0][j] = w[5]*tw + w[7]*tw - f[7][0][j]; //f[8][0][j] = w[8]*tw + w[6]*tw - f[6][0][j]; f[8][0][j] = -f[6][0][j]; f[1][0][j] = -f[3][0][j]; f[5][0][j] = -f[7][0][j]; f[4][0][j] = -f[2][0][j]; f[0][0][j] = 0.0; // Right hand boundary condition, T=0. f[6][n-1][j] = -f[8][n-1][j]; f[3][n-1][j] = -f[1][n-1][j]; f[7][n-1][j] = -f[5][n-1][j]; f[2][n-1][j] = -f[4][n-1][j]; f[0][n-1][j] = 0.0; // Top boundary conditions, T=0.0 f[8][i][m-1] = -f[6][i][m-1]; f[7][i][m-1] = -f[5][i][m-1]; f[4][i][m-1] = -f[2][i][m-1]; f[1][i][m-1] = -f[3][i][m-1]; f[0][i][m-1] = 0.0; // Bottom boundary conditions, Adiabatic // f(1,i,0)=f(1,i,1) // f(2,i,0)=f(2,i,1) // f(3,i,0)=f(3,i,1) // f(4,i,0)=f(4,i,1) // f(5,i,0)=f(5,i,1) // f(6,i,0)=f(6,i,1) // f(7,i,0)=f(7,i,1) // f(8,i,0)=f(8,i,1) // T=0.0 f[2][i][0] = -f[4][i][0]; f[6][i][0] = -f[8][i][0]; f[5][i][0] = -f[7][i][0]; f[1][i][0] = -f[3][i][0]; f[0][i][0] = 0.0; */ /*/ Periodic boundary conditions f[1][0][j] = f[1][n-1][j]; f[5][0][j] = f[5][n-1][j]; f[8][0][j] = f[8][n-1][j]; f[3][n-1][j] = f[3][0][j]; f[7][n-1][j] = f[7][0][j]; f[6][n-1][j] = f[6][0][j]; f[2][i][0] = f[2][i][m-1]; f[5][i][0] = f[5][i][m-1]; f[6][i][0] = f[6][i][m-1];

13 */ f[4][i][m-1] = f[4][i][0]; f[7][i][m-1] = f[7][i][0]; f[8][i][m-1] = f[8][i][0]; static double Psi(double rho){ return 4*exp(-rho/200);

Lattice Boltzmann with CUDA

Lattice Boltzmann with CUDA Lan Shi, Li Yi & Liyuan Zhang Hauptseminar: Multicore Architectures and Programming Page 1 Outline Overview of LBM An usage of LBM Algorithm Implementation in CUDA and Optimization