DEPARTMENT OF PHYSICS

College of NATURAL AND COMPUTATIONAL SCIENCEs

Addis ababa university

Physics 606

COMPUTATIONAL PHYSICS

PROJECT REPORT

REACTION LIMITED AGGREGATION

Date of submission: July, 13,2023

Group No: 1

Group Members

Name ID No
1. Henock Tadele GSR/5543/15
2. Abera Gudesa GSR/9131/15

Name of Instructor: Dr. Tatek Y.

 Reaction Limited Aggregation
Abstract

In this project, we have investigated the reaction-limited aggregation (RLA) using the Metropolis Monte Carlo
Simulation method. We have simulated this diffusion phenomena for two distinct cases, for and
. The corresponding fractal structures were determined using GNUPlot software. Furthermore, we
have determined the respective fractal dimensions for both scenarios by plotting ( ) ( ) and taking
the slope of the linear section of the graph. The results were for and for
. These values were inconsistent with other experimental results; hence we investigated the
relationship between sticking probability constant and fractal dimension . From such experiment, we
found that had a decaying exponential relation. Therefore, it is expected that as
exponentially.

Introduction

Significant advances in our understanding of irreversible, kinetic colloid aggregation have been made in the
past several years. The structure of the colloidal aggregates has shown to be scale invariant, so that it can be
characterized as a fractal, allowing more detailed study of the process of aggregation and the relationship of
the cluster structure to the aggregation kinetics. Two limiting regimes of kinetics have been identified: rapid,
diffusion-limited (DLCA) and slow, reaction-limited (RLCA) colloid aggregation. Each regime exhibits
distinct behavior, characterized by the fractal dimension of the clusters, the shape of the cluster mass
distribution and the kinetics of aggregation. These two classes of aggregation are limiting regimes of the
kinetics, both rapid and slow and intermediate regimes of aggregation can often be described by a crossover
behavior between the two limits. This suggests that DLCA and RLCA may be sufficient to describe the full
range of kinetics of aggregation.[1]

The key to understanding colloidal aggregation is the behavior of the energy of interaction between two
approaching particles. Being more specific, the repulsive energy barrier between these particles plays
important role in the study of such interaction. If the height of this energy barrier is sufficiently larger than
, the particles will be unable to stick to one another when their diffusive motion causes them to collide.
Aggregation can only occur when the height of the barrier is reduced. If is reduced to much less than ,
every collision will result in the particles sticking together, leading to very rapid aggregation, limited only by
the rate of diffusion-induced collisions between clusters. This regime is called diffusion-limited colloid
aggregation. By contrast, if remains comparable to, or larger than , many collisions must occur before
two particles can stick to one another. In this case, the aggregation rate is limited by the probability of
overcoming the repulsive barrier ( ⁄ ), leading to much slower aggregation. This regime is
called reaction-limited colloid aggregation. In each case, however, as particles stick together to become
clusters, the clusters themselves continue to diffuse, collide and aggregate. Thus both types are examples of
cluster-cluster aggregation. Moreover, in either case, the strength of the resultant bonds are much larger than
, so the aggregation is irreversible and the clusters formed are rigid.[1]

The French mathematician Mandelbrot raised the concept of fractal in the 1970s. In his paper How long is the
coast of Britain? Statistical self-similarity and fractional dimension, he revealed the truth that most of the
natural objects are so complex and erratic that cannot be described well in terms of simple primitives. And
those complex objects present strong self-similarity. From his point of view, the coastline is the very
representative example of a fractal, which exhibits accurate or statistical self-similarity. Moreover, He pointed
out that the self-similarity is the core feature of fractals, which means fractal objects can be subdivided into

Reaction Limited Aggregation | 1

many parts, each of them may be a small scale copy of the whole, or they are similar in statistics at least. Thus
more and more scholars tend to take fractal dimension (or Hausdorff dimension) as the indicator to describe
the degree of self-similarity and complexity in geometry.[2] A fractal is a geometric shape containing detailed
structure at arbitrarily small scales. Such structures (for example, Lichtenberg Figures, lightening) are usually
described by the fractal dimension , which is an index for characterizing fractal patterns or sets by
quantifying their complexity as a ratio of the change in detail to change in scale. The fractal dimension for
DLCA is usually whereas, for RLCA ranges between (certain experiments may have
higher or lower values).

Simulation Method

The simulation method used in this project is the so called Metropolis-Hastings Monte Carlo Algorithm. It is
a method for obtaining a sequence of random samples from a probability distribution from which direct
sampling is difficult. The algorithm is named in part for Nicholas Metropolis, the first coauthor of a 1953
paper, entitled Equation of State Calculations by Fast Computing Machines, with Arianna W. Rosenbluth,
Marshall Rosenbluth, Augusta H. Teller and Edward Teller. The Metropolis–Hastings algorithm can draw
samples from any probability distribution with probability density ( ) provided that we know a function
( ) proportional to the density and the values of ( ) can be calculated. The requirement that ( ) must
only be proportional to the density, rather than exactly equal to it, makes the Metropolis–Hastings algorithm
particularly useful, because calculating the necessary normalization factor is often extremely difficult in
practice. The Metropolis–Hastings algorithm generates a sequence of sample values in such a way that, as
more and more sample values are produced, the distribution of values more closely approximates the desired
distribution. These sample values are produced iteratively, with the distribution of the next sample being
dependent only on the current sample value, thus making the sequence of samples into a Markov chain.
Specifically, during each iteration, the algorithm picks a candidate for the next sample value based on the
current sample value. Then, with some probability, the candidate is either accepted, in which case the
candidate value is used in the next iteration or it is rejected in which case the candidate value is discarded, and
current value is reused in the next iteration. The probability of acceptance is determined by comparing the
values of the function ( ) of the current and candidate sample values with respect to the desired
distribution.[3]

In the appendix, the code for the simulation of the RLCA is present which outputs two files “fractal.txt” and
“plot.txt”. The former text file allows us to visualize the fractal structure for a particular sticking probability
constant . While the latter text file enables us to determine the fractal dimension by determining the
number of particles contained in a box of side length .

Figure 1 shows this by drawing concentric circles of varying radii from

the center particle, however, without affecting the value of to higher
degree we used squares of varying sides centered on the initial seed
particle placed at the center of the simulation box.

Figure 1 Mechanism for counting the number of particles

Reaction Limited Aggregation | 2

First we begun by constructing a square simulation box of side length . Next we drew two
concentric circles of as shown below. We then placed a particle at the center of our simulation
box. We then launched a new particle from distance away from the center, and this diffusing particle
exhibited a random walk motion. Depending on its energy and the probability where is the
number of newly created connections between the particle and the cluster, it has two instances: this particle
will collide with the seed particle at the center and stick to it or the particle will through Brownian motion
“escape” the bounding circle with radius , in which case it is discarded and another new particle is
launched. This process was repeated until a predefined cluster size was reached. Concerning the
tracking of the positions of the particles, a was used with jump vectors since we are
considering a lattice structure where each neighboring lattice sites are apart, assuming the center
seed particle (black) to be located at the origin. The cluster is grown with a iteration loop and
appropriate conditions are used in the code with self-explanatory comments in bold.

Figure 2 Simulation of Diffusion

Differences between DLCA and RLCA from the code is the condition ( () ). The ()
function generates random numbers between 0 and 1, if the number generated is less than the product of
“ ” and (number of neighboring particles, has values 0, 1, 2 or 3) then the particle is accepted,
representing an RLCA. However, such condition is not present in simulating DLCA and is assumed that when
is greater than 1 then the RLCA approaches DLCA type.

N.B: A Monte Carlo step ( ) is not used in such simulation since the process is irreversible where if a
particle collides and sticks to another then it can’t be unstuck.

Determination of

We first determined the number of particles as a function of the side length ( ), and used the following
equation to determine the fractal dimension .

( )

where we see that ( ( ))⁄ ( )

After obtaining the “plot.txt” file containing ( ), we imported these values into MS-Excel. However,
beyond some value of , the number of particles remained constant as it is apparent in
the log-log plots in the result section. Hence, we only took the values of the linear trend followed by

Reaction Limited Aggregation | 3

determining the natural logarithm of those values and fitted the points using a scatter plot and a linear trend
line. The slope of the linear trend line is an approximated value of by which Excel employs linear least
square fit method.

Results

Part i) Reaction-limited aggregation for

Figure 3 RLA Fractal structure for

(Plotted using GNUPlot)

log(N) vs. log(R) for a=0.2

9
8
7
6
log(N)

5
4
3
2
1
0
0 1 2 3 4 5 6
log(R)

Graph 1 log(N) vs. log(R) for

Reaction Limited Aggregation | 4

 log(N) vs. log(R) for a=0.2
9
8
7
6
log(N) = 1.5132log(R) + 1.8741
log(N)

5 R² = 0.9522
4
3
2
1
0
0 1 2 3 4 5
log(R)

Graph 2 Linear Plot of log-log curve for

Part ii) Reaction-limited aggregation for

Figure 4 RLA Fractal structure for

(Plotted using GNUPlot)

Reaction Limited Aggregation | 5

 log(N) vs. log(R) for a=0.9
9
8
7
6
log(N)

5
4
3
2
1
0
0 1 2 3 4 5 6
log(R)

Graph 3 log(N) vs. log(R) for

10
log(N) vs. log(R) for a=0.9
9
8
7
6
log(N)= 1.5146log(R) + 1.5259
log(N)

5 R² = 0.9793
4
3
2
1
0
0 1 2 3 4 5
log(R)

Graph 4 Linear Plot of log-log curve for

Reaction Limited Aggregation | 6

 Table 1 Investigation of relationship between and

a vs. df

2.4

2.2
Fractal Dimension,df

1.8

1.6

1.4

1.2

1
0 0.2 0.4 0.6 0.8 1
Sticking Probability, a

Graph 5 Investigating the relation between

Discussion

In this project we have simulated RLCA for and . We have obtained the fractal structure as
shown in figure 3 and figure 4. Comparing these images, we can see that the fractal branches are more
“extending” and more closely packed, “hairy” or solid for . A good indicator for this would have been
to obtain a higher fractal dimension for than for . The determination of the fractal dimension
was done by first plotting ( ) ( ), where we only considered the linear section of the curve and
used Excel to determine the slope. We have obtained with fit correlation coefficient R² =
0.9522, and with R² = 0.9793. Since our experimental investigation didn’t agree with
previous findings we had to explore the relationship between by altering the value of in the code
and obtaining the fractal dimension values for each. Table 1 represents the values of we have
considered and again Excel was used to obtain the slope or We have observed a decaying exponential
curve and have expected the ( ) to be greater than ( ), however, using the log-log plots in
graphs 2 and 4 we saw that this was not the case. The plot in graph 5, shows that as , the value of

Reaction Limited Aggregation | 7

approaches some constant value, which explains why fractal dimension of and differ only by
the thousandth digit place.

Conclusion

In this project, we have explored cluster-cluster aggregation of diffusing particles more specifically the
reaction-limited colloid aggregation using the Metropolis Monte Carlo Simulation Method. We have
considered two distinct cases by varying the sticking probability constant and for a
predefined total number of particles . The two main objectives were to visualize the fractal structure
and determination of the fractal dimension . From the simulation for , we have obtained
and for . These results indicate that the as . However, this
contradicts previous experimental results (Souradeep Ghosh et al, Effect of free energy barrier on pattern
transition in 2D DLA morphology of electrodeposited copper, 2018). Following these results, we set out to
look into the connection between and . After plotting the graph, we found a decaying exponential
regression showing that as exponentially. Possible solutions to alleviate this
contradiction might be to consider larger value of N or use a computer with better clock speed.

References

1. M.Y. Lin; H.M. Lindsay et al, Universal Reaction Limited Colloid Aggregation, Physical Review,
Volume 41, Number 4, 1990
2. Jiaxin Wu; Xin Jin et al, An Effective Method to compute the Box-counting Dimension based on the
Mathematical Definitions and Intervals, Results in Engineering, 2000
3. Kalos, Malvin H; Whitlock, Paula A, Monte Carlo Methods Volume I: Basics, New York, Wiley
pp 78-88, 1986

Reaction Limited Aggregation | 8

 Appendix (Code Used)

!Reaction limited aggregation simulation on a 2D lattice

integer, parameter:: ncluster = 4000,lx=220, ly=220, rint = 200, rext = rint + 10
integer, dimension(ncluster):: x, y
double precision, parameter:: ck = 2d-1!a, this is the value to be altered
integer, dimension(-lx:lx, -ly:ly):: pos
integer,dimension(lx)::nc
integer, dimension(4):: jx, jy
integer :: i, j, k, xt, yt, stick, s
double precision:: theta, pi,d

!Add seed generator !Neighbor test

call generate_seed(i) s=0
i=ran(i) s = pos(xt+1,yt) + pos(xt,yt+1) + pos(xt-1,yt) +
pos(xt,yt-1)
!Jump Vectors
jx(1) = 1; jy(1) = 0 if(s.gt.0) then
jx(2) = -1; jy(2) = 0 if(ran().lt.ck*s) then
jx(3) = 0; jy(3) = 1 !Accept position
jx(4) = 0; jy(4) = -1 i=i+1
x(i) = xt
pos = 0 y(i) = yt
pi = acos(-1d0) pos(x(i),y(i)) = 1
stick = 1
!Place the seed particle at the center endif
x(1) = 0 endif
y(1) = 0
pos(x(1),y(1)) = 1 enddo !End diffusion loop

!Start growing cluster enddo !End cluster growth

i=1
do while(i.lt.ncluster) open(10, file='fractal.txt', status='unknown')
theta = ran()*2*pi do i = 1, ncluster
xt = rint*cos(theta) write(10,*)x(i), y(i)
yt = rint*sin(theta) enddo
!Plot
!Start diffusing particle nc=0
stick = 0 nc(1)=1!only center particle contianed in the first
do while(stick.eq.0) square
!Choose a direction at random i=1
k = ran()*4 + 1 do while(i<lx)
xt = xt + jx(k) i=i+1
yt = yt + jy(k) do j=-i,i
!Dump particle if beyond outer circle do k=-i,i
d = xt**2 + yt**2 nc(i)= nc(i) + pos(j,k)
if(d.gt.rext**2) exit end do
end do
Reaction Limited Aggregation | 9
 end do !***************************************
subroutine generate_seed(seed)
open(11,file='plot.txt',status='unknown') integer::seed
do i = 1, lx integer, dimension(3)::t
write(11,*) i, nc(i)
call itime(t)
enddo
end seed=487*t(1)+5645*t(2)+776896*t(3)
end

Reaction Limited Aggregation | 10