Post on 18-Jan-2023
Algorithms and data structures in molecular dynamics
Alexander Aprelkin
2009
1 Introduction
1.1 Numerical simulation of particle models
An important area of numerical simulation deals with so-called particle models. These are si-mulation models in which the representation of the physical system consists of discrete particlesand its interactions.
Particles carry properties of physical objects, i.e. mass, velocity, position. Particles can representatoms or molecules as well as stars or parts of galaxies.
The Schrodinger equation is often replaced by Newton’s law.Incrementally, approximations to the values at later points in time are computed from the
values of approximations at previous points in time.
There are N2 interactions between particles in a system which consists of N particles. If self-interactions are excluded, this number is reduced by N. If we consider that all other interactionsare counted twice we obtain in total N2−N
2actions between particles.
This is a naive approach with O(N2) operations for N particles in each time step.
1
1.2 Basic Algorithm
real t = t start;
for i = 1,..,N do
set initial conditions xi (positions) and vi (velocities);
while (t < t end) compute for i = 1,..,N the new positions xi and
velocities vi at time t + delta t by an integration
procedure from the positions xi, velocities vi and
forces Fi on the particle at earlier times;
t = t + delta t;
2 The Linked Cell Method for Short-Range Potentials
2.1 Domain of simulation and boundary conditions
We now consider a system which consists of N particles with masses m1, ...,mN characterized bythe positions x1, ..., xN and the associated velocities v1, ..., vN . xi and vi are functions of time t.
In periodic systems, as i.e. in crystals it is natural to use periodicity conditions on the boun-daries. Particles that leave the simulation domain Ω at one side reenter the domain at the oppositeside. Also particles located close to opposite sides of the domain interact with each other.
Reflecting boundary conditions arise in the case of a closed simulation box.
Outflow conditions are used for boundaries where particles leave the simulation domain, whereasinflow conditions allow new particles to enter the simulation domain at certain times across theboundary.
Periodic Reflecting
2.2 Time integration method of Stormer-Verlet
If the interactions between the particles are described by a conservartive potential V = V (x1, .., xN )which doesn’t explicitly depends on time, one obtains Newton’s equations of motion:
xi = vi
mivi = Fi
mixi = Fi
2
i = 1, ..., N , where the Forces Fi are given by
Fi = −∇xiV (x1, ..., xN )
We decompose the time interval [0, tend] ⊂ R, on which the system of differential equations isto be solved into l subintervals of the same size
δt := tend/l.
Instead of the first derivative
dxdt
:= limδt→0
x(t+δt)−x(t)δt
one can use the discrete difference operator:
[dxdt
]rn := x(tn+1)−x(tn)δt
or the central difference operator
[dxdt
]cn := x(tn+1)−x(tn−1)2δt
The second derivative at the grid point tn can be approximated by the difference operator
[d2xdt2
]n := 1δt2
(x(tn + δt) − 2x(tn) + x(tn − δt))
Using the Taylor-expansion we obtain that the discretization error for the approximation of thesecond derivative is of the order O(δt2)
The velocity as the derivative of the position can be approximated using the central difference:
vni =
xn+1
i−xn−1
i
2δt
The so-called Velocity-Stormer-Verlet method solves this equation for xn−1i , substitutes
the result into xn+1i = 2xn
i − xn−1i + δt2 · F n
i /mi and then solves for xn+1i .
One obtains:
xn+1i = xn
i + δt · vni +
F ni ·δt2
2mi
Furthermore, we have:
vni =
xn+1
i−xn−1
i
2δt=
xni
δt−
xn−1
i
δt+
F ni
2miδt,
and
vn+1i + vn
i =xn+1
i−xn−1
i
δt+
(F n+1
i+F n
i )δt
2mi,
and finally:
vn+1i = vn
i +(F n
i +F n+1
i)δt
2mi
These two equations are called the Velocity-Stormer-Verlet integration method.
xn+1i = xn
i + δtvni +
F ni ·δ2
2mi
vn+1i = vn
i +(F n
i +F n+1
i)δt
2mi
3
xn+1i = xn
i + δt · vni +
F ni ·δt2
2mi
compute forces F
vn+1i = vn
i +(F n
i +F n+1
i)δt
2mi
Velocity-Stormer-Verlet Method
// start with initial data x, v, t
// auxilary vector F old
compute forces F;
while (t < t end) t = t + delta t;
loop over all i xi = xi+ delta t ∗(vi + .5/mi ∗ Fi∗ delta t); // update x
F oldi = Fi
compute forces Fi
loop over all i
vi = vi+delta t∗.5/mi ∗ (Fi + F oldi ); // update v
compute derived quantities as for example kinetic energy;
print values of t, x, v as well as derived quantities;
Velocity-Stormer-Verlet Method is the most commonly used method for the integration ofNewton’s equations of motions.
2.3 Implementation of the Basic Algorithm
Data structure Particle:
typedef struct real m; // mass
x[DIM]; // position
v[DIM]; // velocity
F[DIM]; // force
Particle;
4
Velocity-Stormer-Verlet Method
void timeIntegration (real t, real delta t, real t end, Particle *p, int N) compF basis(p,N)
while (t<t end) t += delta t;
compX basis(p, N, delta t);
compF basis(p, N);
compV basis(p, N, delta t);
compoutStatistic basis (p, N, t); // computation of the kinetic energy
outputResults basis(p, N, t);
Computation of the forces with O(N2) operations
The force on the particle i:
Fi = −∇xiV (x1, ..., xN ) =
N∑
j=1,j 6=i
−∇xiU(rij) =
N∑
j=1,j 6=i
Fij
void compF basis(Particle *p, int N) for (int i=0; i<N; i++)
for (int d=0; d<DIM; d++)
p[i].F[d] = 0; // initialize F with 0 for all particles
for (int i=0; i<N; i++)
for (int j=0; d<N; j++)
if (i!=j) force(&p[i], &p[j]); // add the forces Fij to Fi
2.4 Cutoff radius
It doesn’t make sense to sum over all particles to compute the forces. It is enough to sum overonly those particles, which contribute to the potential and to the force. A function decays rapidlywith distance if it decays faster in r, than 1/rd, where d is the dimension of the problem
We consider the Lennard-Jones-Potential that describes the interaction between a pair of neu-tral atoms or molecules. The potential between two particles with a distance rij is given by:
U(rij) = 4 · ǫ( σrij
)12 − ( σrij
)6 = 4 · ǫ · ( σrij
)6 · (( σrij
)6 − 1).
The corresponding force is given by
5
Fi = −∇Vxi(x1, ..., xN )
= 24 · ǫ
N∑
j=1,j 6=i
1
r2ij
· (σ
rij
)6
· (1 − 2 · (σ
rij
)6
)rij
The force Fi =N
∑
j=1,j 6=i
Fij The potential decays very fast with the distance rij between the
particles.
The idea is to neglect all contributions in the Fi =∑
Fij , that are smaller than a certain
threshold.The Lennard-Jones potential is then approximated by
U(rij) ≈
4 · ǫ(( σrij
)12 − ( σrij
)6) rij ≤ rcut
0 rij > rcut
,
i.e. it is cutoff at a distance r = rcut.
We now assume that the particles are more or less uniformly distributed throughout thesimulation domain. Then rcut can be chosen so that the number of remaining terms in the trun-cated sum
Fi = −∇xiV (x1, ..., xN ) = 24 · ǫ
N∑
j=1,j 6=i,0<rij≤rcut
1
r2ij
· (σ
rij
)6
· (1 − 2 · (σ
rij
)6
)rij
is bounded independent of the number of particles N.
The complexity of the evaluation of the potential and the forces is then proportional to N, itis of the order O(N) only.
This is a substantial reduction of the computational cost compared to the compexity of theorder O(N2) for the basic approach.The only one question left is how to manage the data, so that for a given particle the neighbouringparticles it interacts with, can be found efficiently.
2.5 The Linked Cell Method
The idea of the linked cell method is to split the physical simulation domain Ω into uniformsubdomains (cells).
If the length of the sides of the cells is chosen larger or equal to the cutoff radius rcut, theninteractions in the truncated potentials are limited to particles within a cell and from adjacentcells.
6
For the force on particle i in cell ic one obtains a sum of the form
Fi =∑
cell kc, kc∈N(ic)
∑
j∈particles in cell kc, j 6=i
Fij
where N (ic) is the cell ic itself and the direct neighbours of ic.The question is now how to efficiently access the neighbouring cells and particles inside these
cells in an algorithm.The cells at the boundary of the domain have correspondingly fewer nighbouring cells except
for the case of the periodic boundary conditions.In two dimensions each cell can be described by two indices (ic1,ic2). Each cell in the grid
posseses eight neighbouring cells.
Computation of the force in the linked cell method
loop over all cells ic
loop over all particles i in cell ic i->F[d] = 0 for all d;
loop over all cells kc in N(ic)
loop over all particles j in cell kc
if (i!=j)
if (rij <= rcut)
force(&i,&j) // add Fij to Fi
The complexity of the computation of the forces on the particles amounts to C ·N operationsif the particles are distributed almost uniformly and thus the number of particles per cell isbounded from above.
Compared to the naive summation of the force over all pairs of particles, the complexity is reducedfrom originally O(N2) to now O(N).
2.6 Implementation
Implementation of the linked cell methodData structure Linked List:
typedef struct ParticleList Particle p;
struct ParticleList *next;
ParticleList;
A linked list is represented by a poin-
7
ter to the first element.
A complete loop over all elements of the list is given by:
ParticleList *l = root list;
while (NULL!=l) process element l->p;
l = l->next;
Repeatedly inserting elements into an initially empty list, we can fill that list with the appro-priate particles.
The insertion of an element into the list is easiest at the beginning of the list. To implementit we only have to change the values of two pointers (the root-pointer and the next-pointer of thenew element).
Inserting elements into a linked list
void insertList(ParticleList **root list, ParticleList *i)
i->next = *root list; *root list = i;
Removing an element in a singly linked list
void deleteList(ParticleList **q) *q->next = ((*q)->next) ->next;
If some particles leave the simulation domain, then the data structure associated to this particlehas to be removed from its list and its dynamical allocated memory should possibly be released.If new particles can enter the simulation domain, data structure for these particles have to be
8
created and inserted into the appropriate list.In case of periodic boundary conditions, particles leaving the simulation domain on one side enterit at the opposite side of the domain, and they therefore just move from one cell into another cell.The grid cells are stored in a vector.A linked list is associated to each cell and its root pointer will be stored in that cell, i.e. a cell isrepresented by a root-pointer to this cell.The entire grid is then stored as a vector grid of cells of the Type Grid.
typedef ParticleList* Cell;
The grid consists of∏
d
nc[d] cells and the vector has that length. nc is a vector that consists
of the numbers of cells in each dimension. A mapping for two dimensions can be implementedfor instance as follows:
index (XY, nc) := XY[0] + nc[0] * XY[1],
where XY is a vector that consists of values for X and Y coordinates.With these data structures and declarations for the grid and its cells the evaluation of the forcesby the linked list method can be implemented as follows:
void compF LC(Cell *grid, int *nc, real r cut) int ic[DIM], kc[DIM]
for (ic[0]=0; ic[0]<nc[0]; ic[0]++)
for (ic[1]=0; ic[1]<nc[1]; ic[1]++)
for (ParticleList *i = grid[index(ic,nc)]; NULL!=i; i=i->next)
i->p.F[d] = 0; for (kc[0]=ic[0]-1; kc[0]<=ic[0]+1; kc[0]++)
for (kc[1]=ic[1]-1; kc[1]<=ic[1]+1; kc[1]++)
treat kc[d]<0 and kc[d]>=nc[d] according to boundary conditions;
if (distance of i->p to cell kc <= r cut)
for (ParticleList *j=grid[index(kc,nc)]; NULL!=j; j = j->next);
if (i!=j) real r = 0;
for (int d=0; d<DIM; d++)
r += j->p.x[d] - i->p.x[d];
if (r<=r cut)
force(&i->p, &j->p)
As seen already in the O(N2)-algorithm about half of the operations can be saved if oneexploits the symmetry of the forces.For all interactions within a cell also only half of them have to be computed.
9