An Improved Porosity Calculation Algorithm for Particle Flow Code

Abstract

The widely used discrete-element particle flow software PFC’s (PFC 7.0 and previous versions) algorithm for calculating porosity is not sufficiently accurate. Because of this, when the particles are densely packed, the solution to the equation produces an algorithm exception for odd calculations of porosity, which results in the inability to calculate the results. This paper, based on a Darcy seepage model of fluid flow through a granular bed, analyzed the shortcomings of the two porosity calculation methods of PFC and the function analysis method. Combining this analysis with the theory of computer graphics, a new and efficient porosity calculation algorithm was proposed. The result showed that the new proposed porosity calculation algorithm calculated a more accurate and reasonable porosity field and made the iterative solution of the CFD equation more stable. This method makes porosity-related models of PFC more accurate. The algorithm can be not only used to calculate porosity, but also applied to other fields.

1. Introduction

Particle flow refers to a stream of solid particles under the action of external and internal forces. The idea of discrete elements originated in molecular dynamics, which treats a medium as a series of discrete, independently moving particles. The first discrete element particle flow program was developed by Cundall [1,2] and Strack [3].

PFC (Particle Flow Code) is an advanced general computational analysis program developed and commercialized using the discrete-element particle flow method as the basic theoretical background. It is especially suitable for the description of micromechanics and the analysis of mechanical deformation of bulk or cementitious materials. It was developed by the company Itasca, Cundall being one of the founders. The software is widely used in the geotechnical engineering industry and has a great influence.

PFC has been successfully used by many academic institutions and private companies around the world for geoscience investigations, including slope stability analysis [4,5,6], rockfall hazard mitigation [7], cave mining [8,9,10], hydraulic fracturing [11,12,13], wave propagation in solids [14], brittle rock fracturing [15,16], etc. PFC has also been extensively used for material process engineering problems such as bulk material flow mixing [17] and bulk material conveying [18], etc.

The software has an example of simulating Darcy flow, which can be seen in Section 3.2. In this example, when the particles are densely packed, the program is not accurate enough to calculate the porosity, resulting in singularities in solving the equation and the inability to calculate the result.

However, the calculation results may still lead to a situation where the porosity is zero or even negative.

The following are some commonly used porosity calculation methods. 1. Analytical method: the analytical method is to establish a coordinate system and use the analytical expression of the function of the geometry to solve it. The disadvantage is that it is difficult to calculate when encountering complex geometry. 2. PCM (particle centroid method) [19]: this method causes errors that may reach 50% when the particle center is close to the edge of the CFD grid. 3. DPVM (divided particle volume) [20]: this method is used to solve the problem of large errors caused by PCM, but its numerical results are unstable. 4. SKM (statistical kernel method) [21]: the volume fraction of a certain point in its calculation domain is obtained by superposing the volume weights of different particles at that point. 5. Monte Carlo method [22]: its calculation cost is high and the results are unstable.

There are two ways to calculate porosity in the PFC software (PFC 7.0 and previous versions), which are centroid and polyhedron.

In centroid mode (this approach is based on PCM), if a particle’s centroid is contained in a mesh, the particle is considered to be entirely present within that fluid element. This approach results in a jump in porosity between adjacent meshes as particles move around the edge of the mesh, resulting in distortion.

In polyhedron mode (this approach is based on DPVM), the particles are wrapped using a cube, and the volume of the cube is used as the volume of the particles. The mesh porosity is then calculated. The particle volume calculation is significantly overweight, resulting in a low porosity.

These two methods produce significant error in calculating the porosity results, and it is easy to make some mesh porosity zero. When the balls are densely packed, a large part of the calculated mesh is calculated to have a porosity of zero. In addition, the zero-porosity fluid unit can lead to singularities in the governing equations of the fluid, resulting in the problem of overflow of computational data.

The volume of the balls in the mesh can be calculated directly using the $4/3\mathsf{\pi }{r}^3$ analytical formula, but the complication of the problem lies in the calculation of the balls at the edge of the grid. The mesh boundaries will cut the balls apart and belong to different meshes, as shown in Figure 1 and Figure 2.

In both cases, the volume of the ball in the mesh can be easily calculated analytically. However, the complexity [23] of the model is that it assumes that the spheres can overlap to simulate a more realistic physical model. The “overlap” means several spheres partially overlap to form a new geometry.

The addition of the assumption of ball overlap makes it difficult to analytically calculate the volume of the balls in each mesh. For example, in the case of 2D, multiple balls overlapping with squares are shown in Figure 3.

In this case alone, it is difficult to calculate and divide the overlapping parts of the colors. Considering three dimensions, with more sphere overlap and mesh surface segmentation, the porosity calculation becomes more complex. Therefore, the method of function analysis is difficult to calculate for the time being.

In response to the above issues, applying the theory of computer graphics, this paper proposes a new and more efficient porosity calculation algorithm, which calculates a more accurate and reasonable porosity field, making the iterative solution of the equation more stable.

2. Methodology

The method proposed in this paper is to further divide the large mesh (which is CFD mesh) into smaller grids and calculate which small grids overlap with the small mesh. The next step is to see which large grid the small mesh belongs to, calculate how many volumes the small mesh occupies in the large grid, and then calculate the porosity of the large grid. The overlap between the balls can also be solved in this case. This paper proposes two methods to calculate the porosity, which are the traversal of the small-sphere algorithm and the traversal of the small-grid algorithm. We analyze the complexity of its time and space, and select the algorithm dynamically, to further improve the flexibility of the algorithm. It is worth mentioning that this method works well whether the CFD mesh is larger or smaller than the particle. The accuracy of the algorithm only requires that the artificially divided small grid (not the CFD mesh) used to calculate the porosity is sufficiently small.

2.1. Traversal Sphere Algorithm

Knowing the coordinates and radius of the sphere, it is necessary to calculate the coordinates of the boundary points of the sphere grid (the sphere is in Cartesian grid). First, the case of a two-dimensional circle is analyzed, and then we move on to a three-dimensional scenario.

In the two-dimensional case, the coordinates of the circle are located at the origin point, and to calculate the boundary coordinates of the circle, we use the analytic formula of the circle:

$$x^2+y^2=r^2$$

(1)

Along the x-axis, the boundary points of the circle are calculated from x − r to x + r.

$$y=y_c\pm \sqrt{r^2-(x_c-x{)}^2}$$

(2)

Although this method calculates the circle, the amount of calculation is very large at each step and, secondly, the boundary coordinates of the drawn circle are not continuous, as shown in Figure 4.

The midpoint circle algorithm [24] can be used to calculate the boundaries of the circle, which not only improves the computational efficiency (does not need to calculate the square term) but also makes the boundary of the circle continuous, which leads to greater accuracy.

First, define a function:

$$f_{}(x,y)=x^2+y^2-r^2$$

(3)

Apparently:

$$f(x,y)\left\{\begin{array}{c}<0,(x,y) \mathrm{i}\mathrm{n} \mathrm{t}\mathrm{h}\mathrm{e} \mathrm{c}\mathrm{i}\mathrm{r}\mathrm{c}\mathrm{l}\mathrm{e}\hfill \\ =0,(x,y) \mathrm{o}\mathrm{n} \mathrm{t}\mathrm{h}\mathrm{e} \mathrm{b}\mathrm{o}\mathrm{r}\mathrm{d}\mathrm{e}\mathrm{r} \mathrm{o}\mathrm{f} \mathrm{c}\mathrm{i}\mathrm{r}\mathrm{c}\mathrm{l}\mathrm{e}\hfill \\ >0, (x,y) \mathrm{o}\mathrm{u}\mathrm{t}\mathrm{s}\mathrm{i}\mathrm{d}\mathrm{e} \mathrm{t}\mathrm{h}\mathrm{e} \mathrm{c}\mathrm{i}\mathrm{r}\mathrm{c}\mathrm{l}\mathrm{e}’\mathrm{s} \mathrm{b}\mathrm{o}\mathrm{u}\mathrm{n}\mathrm{d}\mathrm{a}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{s}\hfill \end{array}\right.$$

(4)

Assuming a known boundary point of a circle at ($x_k,y_k$), the next step is to determine whether the next point is closer to the boundary of the circle at ($x_k+1,y_k$) or ($x_k+1,y_k-1$). Then it can be seen that the decision parameters are obtained in the middle of these two points of the circular function equation:

$$p_k=f\left(x_k+1,y_k-\frac{1}{2}\right)$$

$$p_k=(x_k+1{)}^2+{\left(y_k-\frac{1}{2}\right)}^2-r^2$$

(5)

The basic idea in this approach is to test the halfway position between two pixels to determine whether this midpoint is inside or outside the circle boundary. The midpoint is shown in Figure 5.

If $p_k$ < 0, then this midpoint is within the circle, and the boundaries of the circle are closer to ($x_k+1,y_k$); on the contrary, it is closer to ($x_k+1,y_k-1$).

$$p_{k+1}=f\left(x_{k+1}+1,y_{k+1}-\frac{1}{2}\right)$$

$$p_{k+1}=\left[\right(x_k+1)+1{]}^2+{\left(y_{k+1}-\frac{1}{2}\right)}^2-r^2$$

$$p_{k+1}=p_k+2(x_k+1)+\left(y_{k+1}^2-y_k^2\right)-(y_{k+1}-y_k)+1$$

(6)

$y_{k+1}=y_k$ or $y_{k+1}{=y}_k-1$, depending on the $p_k$.

When $y_{k+1}=y_k$:

$$p_{k+1}=p_k+2x_k+3$$

(7)

When $y_{k+1}{=y}_k-1$:

$$p_{k+1}=p_k+2\left(x_k-2y_k\right)+5$$

(8)

The starting point of the decision function is:

$$(x_0,y_0)=(0,r)$$

Then:

$$p_0=f(1,r-\frac{1}{2})$$

$$p_0=1+{\left(r-\frac{1}{2}\right)}^2-r^2$$

$$p_0=\frac{5}{4}-r$$

(9)

Based on the symmetry of the circle, one point is calculated, and seven other points can be determined. For example, if the circle (x, y) is determined, it can be determined that (−x, y), (−x, −y), (x, −y), (y, x), (−y, x), (−y, −x), (y, −x) are also the boundaries of the circle. As shown in Figure 6.

The midpoint circle algorithm is only an algorithm for calculating the boundaries of circles; this paper extends it to the calculation of solid circles. Each time a point (x, y) is calculated, it is immediately determined that all points between (−x, y) and (x, y) are within the circle. In this way, every time a point is taken at the boundary of the circle, it can be calculated that everything on a line is inside the circle. With all the points on the boundary taken, all calculated lines are combined into a circle, and the lines are guaranteed to be continuously adjacent to each other.

Furthermore, this paper extends the algorithm to the calculation of all the points inside the sphere in 3D.

It can be supposed there is a sphere in 3D space with the center of the circle at the origin. Then add the coordinates of the calculated grid x, y, and z respectively to calculate the actual value of coordinates, and it is easy to calculate the coordinate position of the overlapping small grid for all balls of the same radius.

The algorithm is divided into two loops, and the inner and outer loops each apply a midpoint circle algorithm.

In the outer loop, on the circle where the sphere intersects the x–z plane, the midpoint circle algorithm is applied to find a point ($x_k{,y}_k,z_k$), and obviously the other seven points of symmetry can be found at this point. In fact, only two points of x > 0 and y > 0 are used here, ($x_k,y_k,z_k$) and ($z_k,y_k{x}_k$).

In the inner loop, for each of the above two points, change the symbol to ($x_j,y_j,z_j$) in the point parallel to the x–y plane. Application of the point circle algorithm can calculate eight points, ($x_j$, $y_j$, $z_j$) and ($-x_j$, $y_j$, $z_j$), ($x_j$, −$y_j$, $z_j$) and (${-x}_j$, ${-y}_j$, $z_j$), ($y_j$, $x_j$, $z_j$) and (${-y}_j$, $x_j$, $z_j$), and ($y_j$, −$x_j$, $z_j$) and (${-y}_j$, −$x_j$, $z_j$), such that all points are calculated as points in the sphere. Then apply z = −z on the z-axis of the above eight points, and then connect them in pairs. This calculates a total of eight lines, which are located on two discs, as shown in Figure 7.

Two points were selected for the outer loop, so that the algorithm that calculates an inner and outer loop can calculate 16 lines, located on 4 planes, as shown in Figure 8.

The pseudocode of the algorithm proposed in this section can be written as shown in Algorithm 1.

Algorithm 1: Traversal sphere algorithm.
1:	#cells is the matrix of the mesh
2:	def line(x,y,z,cells,ball):
3:	for i in range(x):
4:	cells[i+ball.x][y+ball.y][z+ball.z]=True
5:	cells[−i+ball.x][y+ball.y][z+ball.z]=True
6:	def disk(ball,celss,r,z):
7:	# x is the x-coordinate of the axis in this loop
8:	x=0
9:	yr=r
10:	# Calculate the initial value of the decision parameter, P is decision parameter
11:	p = 5/4
12:	# Inner loop
13:	while(yr>=x):
14:	#Northern Hemisphere
15:	line(x,yr,z,cells,ball)
16:	line(yr,x,z,cells,ball)
17:	line(x,−yr,z,cells,ball)
18:	line(yr,−x,z,cells,ball)
19:	#Southern Hemisphere
20:	line(x,yr,−z,cells,ball)
21:	line(yr,x,−z,cells,ball)
22:	line(x,−yr,−z,cells,ball)
23:	line(yr,−x,−z,cells,ball)
24:	if(p<0):
25:	p = p+2*x+3
26:	else:
27:	p=p+2*(x−yr)+5
28:	yr−=1
29:	x+=1
30:	def circle(ball,cells):
31:	# Execute the midpoint circle algorithm first, get, x and z
32:	#r is radius of ball
33:	r=ball.r
34:	# z is the z-coordinate of the axis in this loop
35:	z=0
36:	yr=r
37:	# Calculate the initial value of the decision parameter, P is decision parameter
38:	P = 5/4
39:	# Outer loop
40:	while(yr>=x):
41:	# Execute the disc algorithm twice with x and z
42:	disk(ball,cells,z,yr)
43:	disk(ball,cells,yr,z)
44:	if(p<0):
45:	p = p +2*z+3
46:	else:
47:	p = p +2*(z−yr)+5
48:	yr-=1
49:	z+=1
50:	def main()::
51:	# i is the one of the ball
52:	for i in balls:
53:	circle(i,cells)

Algorithm Complexity Analysis:

K is the number of small grids, and the value needs to be set to True to indicate that they are occupied by the overlapping spheres. $N_r$ is the number of balls with radius r, and each type of ball generates a small grid of 4/3π$r^3$, and the set of sphere radius is A:

Time Complexity: O($\sum _{r\in A}^{ }4/3\pi r^3$)

Space Complexity: O(K)

2.2. Traversal of Small-Grid Algorithm

Traverse through each small grid ($x_i{,y}_i{,z}_i$) and then calculate whether there is a center of a sphere within the distance from each small grid to R (R is the largest radius of all spheres), and if so, the small grid is set to True, that is the small grid overlaps with the sphere. Finally, by counting how many small grids with True values exist in each large grid, the porosity of each large grid can be calculated.

The distance between the small grid and all the balls cannot be calculated, which creates inefficiency. Thus, in order to improve the efficiency of finding the balls, the distance between the small grid and the ball coordinates ($x_j$, $y_j$, $z_j$) satisfying $x_i$ − R < $x_j$ <$x_i$+ R, $y_i$ − R <$y_j$<$y_i$+ R, $z_i$ − R <${ z}_j$<$z_i$+ R should be calculated. In order to find the balls that meet such conditions more quickly, the number of balls, the number of small grids, and the search range R should be considered.

Suppose that the number of small grids is K and the maximum sphere radius is r.

When traversing a small mesh, the sphere is directly found within the cube with an edge of 2R, so its time complexity is O(8K$r^3$).

So the pseudocode can be written as shown in Algorithm 2.

Algorithm 2: Traversal of small-grid algorithm.
1:	# Calculate the distance between two points
2:	def distance(i,j,k,x,y,z,r):
3:	return (i−x)*(i−x)+(j−y)(j−y)+(k−z)(k−z)−r*r
4:	# i+r
5:	# Inner loop
6:	def small_cube(i,j,k,cells,cells_ball):
7:	for x,y,z,r in range(i−r, i+r, j−r, j+r, k−r, k+r):
8:	# The decision function is called only if the center of the circle is inside the small cube
9:	if(cells_ball[x][y][z]==True):
10:	#Call the distance function
11:	display=distance(i,j,k,x,y,z,r)
12:	# If the ball is with
13:	if(d<0):
14:	cells[i][j][k]=True
15:	return
16:	def main():
17:	# Traverse the grid in the R range
18:	# Mark with the coordinates of the center of the sphere
19:	for ball in balls:
20:	cells_ball[ball.x][ball.y][ball.z]=True
21:	#Outer loop, which traverses small grids
22:	for i,j,k in range(cells):
23:	small_cube(i,j,k,cells,cells_ball)

Algorithm Complexity Analysis:

Time Complexity: O(${8Kr}^3$).

Space Complexity: O(2K).

2.3. Algorithm Flowchart

The former is to traverse the small grids occupied by all the small meshes, and the latter is to traverse all the small meshes. Considering time complexity, which algorithm is more efficient depends on the degree of overlap between the balls and the number of balls. If the degree of overlap between ball and ball is high, the former algorithm calculates many duplicate points, resulting in a decrease in efficiency, and conversely, if the degree of overlap is low, its efficiency is higher. The discriminant is $\sum _{r\in A}^{ }4/3\pi r^3>{8Kr}^3$. The algorithm flowchart is shown in Figure 9.

3. Results and Discussion

3.1. Verification of the Sphere Algorithm

Feasibility verification of the sphere algorithm in Section 2.1: Assuming that the volume of the small mesh is 1, the number of grids is the volume of the sphere. Thus, the radius of the small ball depends on the degree of grid subdivision. The smaller the mesh is, the larger the ball radius is. The feasibility of calculating the volume of the sphere is verified by comparing the formula $4/3\mathsf{\pi }{r}^3$ of the sphere volume, as shown in

Table 1. Table of errors between the volume calculated using the method of this paper and the true volume.

Theoretical Value	Calculated in This Paper	Error	Radius
4.2	1	76.1%	1
33.5	35	−4.4%	2
113.1	93	17.8%	3
268.1	223	16.8%	4
523.6	529	−1.0%	5
904.8	819	9.5%	6
1436.8	1405	2.2%	7
2144.7	1987	7.4%	8
3053.6	2845	6.8%	9
4188.8	4175	0.3%	10
5575.3	5425	2.7%	11
7238.2	7111	1.8%	12
9202.8	8985	2.4%	13
11,494.0	11,267	2.0%	14
14,137.2	13,793	2.4%	15
17,157.3	16,595	3.3%	16
20,579.5	20,165	2.0%	17
24,429.0	24,115	1.3%	18
28,730.9	28,461	0.9%	19
33,510.3	32,943	1.7%	20
38,792.4	37,969	2.1%	21
44,602.2	43,823	1.7%	22
50,965.0	50,537	0.8%	23
57,905.8	57,115	1.4%	24
65,449.8	64,025	2.2%	25

.

It can be seen that with the increase of the radius, the error has a decreasing trend, indicating that the algorithm is feasible. The division of the small grid should be small enough so that the radius of the small ball is greater than 9.

3.2. Simulation Results

The physical model of Darcy’s flow is modeled as a 10 cm × 10 cm × 20 cm box in the porous medium in the PFC software (PFC 5.0). The grids (or the cells) are cube grids, assuming that the control volume is much larger than the volume of the ball and that the balls can partially overlap each other, with a density of 2600 ${\mathrm{k}\mathrm{g}/\mathrm{m}}^3$ and a water flow velocity of $1\times {10}^{-5}\mathrm{m}/\mathrm{s}$, as shown in Figure 10.

The box is divided into a 10 × 10 × 20 grid, as shown in the Figure 11.

According to Darcy’s law [25] for porous media with low Reynolds numbers:

$$\overrightarrow{\nu s}=-\frac{K}{\mu }\overrightarrow{\nabla }p$$

(10)

The superficial velocity and the fluid velocity have this relationship:

$$\overrightarrow{\nu s}=ϵ\overrightarrow{\nu }$$

(11)

Substitute Formula (10) into Formula (11):

$$\overrightarrow{\nu }=-\frac{K}{\mu ϵ}\overrightarrow{\nabla }p$$

(12)

where $\overrightarrow{\nu s}$ is the superficial velocity and $\overrightarrow{\nu }$ is the fluid velocity in m/s; K is the permeability, D; $\mu$ is the fluid viscosity, mPa·s; $ϵ$ is the porosity; and p is the fluid pressure, mPa. The fluid is assumed to be incompressible. Considering the effect of particle motion on the fluid, the permeability is calculated by the Kozeny–Carman relation:

$$K(ϵ)=\left\{\begin{array}{cc}\frac{1}{180}\frac{{ϵ}^3}{(1-ϵ{)}^2}(2r_e{)}^2& ϵ\le 0.7\\ K\left(0.7\right)& ϵ>0.7\end{array}\right.$$

(13)

where $r_e$is the radius of the particles, m.

The above is the calculation of the fluid, and the next calculation is the force motion of the solid particles.

$$\frac{\partial \overrightarrow{u}}{\partial t}=\frac{{\overrightarrow{f}}_{mech}+{\overrightarrow{f}}_{fluid}}{m}+\overrightarrow{g}$$

(14)

where $\overrightarrow{u}$ is the velocity of the solid particles, m is the mass of the particles, $\overrightarrow{g}$ is the acceleration due to gravity, ${\overrightarrow{f}}_{mech}$ is the force between the particles, and ${\overrightarrow{f}}_{fluid}$ is the force of the fluid on the particles.

The above formula is only a basic model, and the specific details of other formulas are not the focus of this paper. For more details, refer to the papers of Furtney [26,27] and documents of PFC.

When using the porosity calculation method of PFC, about 1/4 of the mesh porosity of the porosity calculation is close to 0, and from the perspective of Darcy’s formula, the denominator is easily able to approach 0, and the whole formula results tend to be close to infinity, resulting in variable overflow. The actual test results are the same, and the program runs for seven timesteps and then reports an error, indicating that the variable is overflowing, and then cannot be calculated.

This paper designed experiments with different radius spheres. The histogram of the porosity calculation of the original algorithm is shown in Figure 12, Figure 13, Figure 14, Figure 15, Figure 16 and Figure 17.

After using the algorithm in this paper, there are very few meshes with porosity close to zero, which is also in line with the actual situation, and there is no overflow of variables, and the program can run normally. The histogram of the calculation of the porosity of the algorithm in this paper is shown in Figure 18, Figure 19 and Figure 20.

4. Conclusions

Due to the inaccurate way in which the PFC software calculates porosity, the Darcy flow model cannot handle the low permeability and causes the program to crash. Based on the two-dimensional midpoint circle algorithm, this paper further extends to the three-dimensional case, and expands the algorithm to calculate the porosity more accurately and efficiently. Comparing the results calculated by the two calculation methods of the software, the algorithm of this paper makes it more difficult for the porosity to be zero, which is more in line with the actual situation, so that the Darcy seepage model can be run, and avoids the problem of the software algorithm leading to the overflow of the data, which would lead to the crash of the program.

This algorithm is not only used to calculate porosity, but can also be widely used in other computing fields. For example, there is a popular game called “Minecraft”. The scene of this game is made of cubic blocks. A programmer who wants to generate an approximate solid sphere in this game scene needs to find blocks that overlap with the sphere. The algorithm in this article can be used to find these blocks.

The algorithm is currently only a single thread but can be further extended to multi-core parallel computing and GPU parallel computing in the future. The development of its parallel algorithm has great computational efficiency. On the other hand, in the traversal branch of the small-grid algorithm, the search for the small sphere can also be accelerated by indexing. This is the work that needs to be done in the future.