Physics 115/242 The leapfrog method and other symplectic algorithms for integrating Newton s laws of motion

Transcription

1 Physics 115/242 The leapfrog method and other symplectic algorithms for integrating Newton s laws of motion Peter Young (Dated: April 14, 2009) I. INTRODUCTION One frequently obtains detailed dynamical information about interacting classical systems from molecular dynamics (MD) simulations, which require integrating Newton s equations of motion over a long period of time starting from some initial conditions. One might be interested, for example, in following the motion of atoms in a fluid. As another example, astronomers might want to integrate the motion of the solar system for a long period of time, or consider the evolution of a galaxy by following the motions of its constituent stars. (In an astronomical setting, molecular dynamics simulations are called N-body simulations.) In this handout I will discuss an algorithm, called leapfrog, which is particularly suited for these simulations because (i) it is simple, and (ii) it has a sort of global stability (in technical jargon, the algorithm is symplectic ). I will explain what this term means, and also discuss briefly some higher order symplectic algorithms. II. THE LEAPFROG ALGORITHM We have already seen in our discussion of numerical differentiation and of numerical integration (midpoint method) that the slope of a chord between two points on a function, (x 0, f 0 ) and (x 1, f 1 ), is a much better approximation of the derivative at the midpoint, f 1/2, than at either end. We can use the same idea in a simple, elegant method for integrating Newton s laws of motion, which takes advantage of the property that the equation for dx/dt does not involve x itself and the equation for dv/dt (v is the velocity) does not involve v (assuming velocity independent forces). More precisely, for a single degree of freedom, the equations of motion are dx dt dv dt = v (1) = F (x) ( = du(x) ) dx (2)

2 2 where F (x) is the force on the particle when it is at x, U(x) is the potential energy, and for simplicity we set the mass equal to unity. (To put back the mass replace F by F/m throughout.) The Euler method would approximate Eq. (1) by x 1 = x 0 + hv 0, (3) where as usual h is the interval between time steps. A better approximation would be to replace v by its value at the midpoint of the interval, i.e. x 1 = x 0 + hv 1/2. (4) Of course, you would protest that we don t yet know v 1/2 so how can we use this. Let s finesse this for now and assume that we can get v 1/2 in some way. Then we can immediately apply a similar midpoint rule to Eq. (2) to step v forward in time, i.e. v 3/2 = v 1/2 + hf (x 1 ), (5) since we do know x 1. Then we can step forward x with x 2 = x 1 + hv 3/2 and so on. Thus, once we have started off with x 0 and v 1/2 we can continue with x and v leapfrogging over each other as shown in Fig. 1. x t/h v FIG. 1: Sketch showing the structure of the leapfrog method. The basic integration formula for the leapfrog algorithm is therefore x n+1 = x n + hv n+1/2, (6a) v n+3/2 = v n+1/2 + hf (x n+1 ) (leapfrog). (6b) How accurate is this approach? Well x 1 x 0 is of order h, and we showed earlier in the class that the expected leading error h 2 vanishes for the midpoint approximation, and so the error for one interval is h 3. To integrate over a finite time T the number of intervals is T/h and so the overall error is of proportional to h 3 (1/h) = h 2. Leapfrog is therefore a second order method,

3 3 like RK2, and better than Euler, which is only first order. We shall see shortly that, in addition to leapfrog being of higher order than Euler even though it is hardly more complicated, it has other desirable features connected with its global properties. The leapfrog method has a long history. I don t know who first introduced it but there is a nice discussion in the Feynman Lectures on Physics, Vol. I, Sec The leapfrog method, which is second order, is closely related to a modification of the Euler method called Euler-Cromer. Both Euler and Euler-Cromer are first order approximations, but Euler-Cromer is more stable. Whereas the Euler method is x n+1 = x n + hv n, (7a) v n+1 = v n + hf (x n ) (Euler), (7b) the Euler-Cromer method uses the (already computed) new value of x when computing the force in Eq. (7b), i.e. x n+1 = x n + hv n, (8a) v n+1 = v n + hf (x n+1 ) (Euler-Cromer). (8b) The Euler-Cromer method, Eqs. (8), is seen to be the same as the leapfrog method, Eqs. (6), except that the velocity is computed at the same times as the position rather than intermediate times. Thus, Euler-Cromer becomes leapfrog simply by updating the velocity by an extra half-step at the beginning, and using the resulting value of v as the starting value in Eq. (8a). By this simple change, a first order method (Euler-Cromer) becomes a second order method (leapfrog). I therefore recommend always using leapfrog rather than Euler-Cromer. More discussion on how to start the leapfrog algorithm is given in the next section. III. THE VELOCITY VERLET ALGORITHM To make leapfrog useful, however, two questions have to be addressed. The first, which we have already mentioned, is how to we start since we need v 1/2, but we only have the initial velocity v 0 (as well as the initial position x 0 ). The simplest approximation is just to do a single half step v 1/2 = v 0 + 1hF (x 2 0). (9) Although this is not a midpoint method, and so has an error of h 2 we only do this once so it does not lower the order of the method, which remains second order.

4 4 The second question to be addressed is how can we get the velocity at the same time as the position, which is needed, for example, to produce phase space plots (see below) and to to compute the energy and angular momentum. The simplest approach is to consider Eq. (6b) to be made up of two equal half steps, which successively relate v n+1 to v n+1/2 and v n+3/2 to v n+1. The leapfrog algorithm with a means of starting the algorithm and determining x and v at the same times in the way just mentioned, is called velocity Verlet. A single time step can be written as v n+1/2 = v n hf (x n), (10a) x n+1 = x n + hv n+1/2 (velocity Verlet), (10b) v n+1 = v n+1/ hf (x n+1), (10c) where n = 0, 1, 2,. Equation (10) is equivalent to Eq. (6) with the addition of a prescription for starting the algorithm off and for evaluating v and x at the same time. It looks as though we have to do two force calculations per time step in Eq. (10) but this is not so because the force in the third line is the same as the force in the first line of the next step, so it can be stored and reused. Since velocity Verlet is the same as leapfrog, it is a second order method. It is often useful to show the trajectory as a phase space plot i.e. the path in the p-x plane (where p = mv is the momentum). As an example consider the simple harmonic oscillator for which the energy is given by E = p 2 /2m + kx 2 /2, where k is the spring constant. Here we have set m = 1 and we will also set k = 1 so E = p2 2 + x2 2 (= const.) (11) Hence the phase space plot is a circle with radius equal to 2E. Figure 2 shows a phase space plot for one period of a simple harmonic oscillator using the velocity Verlet method with time step h = 0.02T, where T = 2π is the period. The starting values are x = 1, v = 0, so E = 1/2. The figure shows that the leapfrog/velocity Verlet method correctly follows the circular path in phase space (at least for one period T ). Note that instead of starting with a half step for v followed by full step for x and another half step for v, one could do the opposite: a half step for x followed by full step for v and another half step for x, i.e. x n+1/2 = x n hv n, (12a) v n+1 = v n + hf (x n+1/2 ) (position Verlet), (12b) x n+1 = x n+1/ hv n+1, (12c)

5 5 FIG. 2: Phase space plot for one orbit showing the expected circular trajectory. for n = 0, 1, 2,. This is called position Verlet. Once the algorithm has been started it is the same as velocity Verlet. It is trivial to generalize the equations of the leapfrog/verlet method to the case of more than one position and velocity. For example, for the position Verlet algorithm one has x i n+1/2 = xi n hvi n (i = 1,, N), (13a) vn+1 i = vn i + hf i ({x n+1/2 }) (i = 1,, N), (13b) x i n+1 = x i n+1/ hvi n+1 (i = 1,, N), (13c) where x i, v i (i = 1, 2,, N) are the positions and velocities, and F i ({x}) is the force which gives the acceleration of the coordinate x i, i.e. F i ({x}) = U({x})/ x i, where U is the potential energy. Each force depends, of course, on the set of all positions {x}. It is important that all the positions are updated in Eq. (13a), then all the forces are calculated using the new positions, then all the velocities are updated in Eq. (13b), and finally all the positions are updated again in Eq. (13c). IV. THE VERLET ALGORITHM If we are not interested in the velocities, but just the trajectory of the particle, we can eliminate the velocities from the algorithm since x n+2 = x n+1 + hv n+3/2 = x n+1 + h(v n+1/2 + hf (x n+1 )). (14)

6 6 In velocity Verlet we have hv n+1/2 = x n+1 x n and so we get an equation entirely for x variables: x n+2 = 2x n+1 x n + h 2 F (x n+1 ) (Verlet). (15) This Verlet algorithm is less often used than velocity or position Verlet because: (i) having the velocities is frequently useful, (ii) the Verlet algorithm is not self starting, and (iii) it is more susceptible to roundoff errors because it involves adding a very small term of order h 2 to terms of order unity. By contrast, the velocity or position Verlet schemes only add terms of order h (which is larger than h 2 since h is small) to terms of order unity. V. ADVANTAGES OF THE LEAPFROG/(VELOCITY OR POSITION) VERLET ALGORITHM In addition to combining great simplicity with second order accuracy, the leapfrog/(velocity or position) Verlet algorithm has several other desirable features: 1. Time reversal invariant. Newton s equations of motion are invariant under time reversal. What this means is as follows. Suppose we follow a trajectory from x i at some initial time t i (when the particle has velocity v i ) to x f at a later time t f (when the velocity is v f ). Now consider the time reversed trajectory which starts, at time t i, at position x f but with the opposite velocity v f. Then, at time t f, the particle will have reached the initial position x i and the velocity will be v i, see Fig. 3. original trajectory x, v, t f f f x i, v i, t i x v i t i,, f time reversed trajectory t x, v, f f i FIG. 3: Illustration of a trajectory and the time reversed trajectory. This time reversed trajectory is what you would see if you took a movie of the original trajectory and ran it backwards. Thus both the trajectory forward in time and the one backwards in time are possible trajectories. Since this is an exact symmetry of the equations, it is desirable that a numerical approximation respect it.

7 7 It is a matter of simple algebra to check that Eqs. (10) or (12) respect time reversal. Start with x 0 = X, v 0 = V, say, and determine x 1 and v 1. Then start the time reversed trajectory with x r 0 = x 1 and v0 r = v 1. The three steps of Eqs. (10) or (12) in the reversed trajectory correspond precisely to the three steps in the forward trajectory (with positions the same and velocities reversed) but in the reverse order, so one finds x r 1 = X (= x 0), v1 r = V (= v 0). The time-reversed trajectory thus retraces the forward trajectory. 2. Conserves Angular Momentum In a spherically symmetric potential, angular momentum is conserved and, remarkably, the leapfrog/(velocity or position) Verlet algorithm conserves it exactly. If the potential energy U only depends on the magnitude of r and not its direction then the force is along the direction of r, i.e. F (r) = ˆr du(r) dr where ˆr is a unit vector in the direction of r., (16) It is left as a homework exercise to show that the leapfrog algorithm conserves angular momentum for such a force. (Unfortunately, the other quantity conserved by Newton s equations, energy, is not exactly conserved in the algorithm.) It is obviously desirable that a numerical approximation respect symmetries exactly, and I m not aware of any other algorithms which conserve angular momentum exactly, though they may exist. This is obviously a plus for the leapfrog algorithm. 3. Symplectic (area preserving) The leapfrog/(velocity or position) Verlet algorithm is symplectic, i.e. area preserving. To understand what this means consider a small rectangular region of phase space of area da as shown in the left part of the Fig. 4. Let the four corners of the square, (x, p), (x + dx, p), (x, p + dp), (x + dx, p + dp) represent four possible coordinates of a particle at time t. These are labeled 1, 2, 3, 4. Then, at a later time t each of these four points will have changed, to form the corners of a parallelogram, as shown on the right of Fig. 4. Let the area of the parallelogram be da. An important theorem (Liouville s theorem) states that the areas are equal, i.e. da = da. (17)

8 8 p p da dp 1 dx 4 1 da 3 4 time t time t x x FIG. 4: Illustration which shows that integrating forward Newton s equations by a finite time can be regarded as a map in phase space (i.e. x-p space). Each point in the left hand figure, which is for time t, maps into a corresponding point in the right hand figure, which is for a later time t. The area of a region on the left, like the rectangle formed by points 1 4, is equal to the area of the corresponding region on the right, so Newtonian dynamics gives rise to an area-preserving map. I have not been able to find a simple derivation of Liouville s theorem. For a more advanced text which gives a proof, see Landau and Lifshitz, Classical Mechanics. Now (x, p) transforms to (x, p ), where x and p are some (complicated non-linear) functions of x, and p, i.e. x = X(x, p) p = P (x, p). (18) A set of equations like (18), in which the values of one set of variables (x, p here), is transformed to new values (x, p here), is called a map. Thus, the result of integration of Newton s laws by a finite amount of time can be represented as an area preserving map. Since the area preserving property is an exact feature of the equations, it is desirable that a numerical approximation preserve it. Such approximations are called symplectic. What is the condition for a map to be symplectic? To see this we need to compute the area da in the above figure, and set it equal to da (= dx dp). The area da is given by da = d e 1 d e 2, (19) where d e 1 and d e 2 are the vectors describing the two sides of the parallelogram, 1 4 and 1 2. Now the components of d e 1 are just the changes in x and p when x is changed by

9 9 dx but p is fixed, i.e. and similarly ( x d e 1 = x ( x d e 2 = p ) p ˆx + x ˆp dx, (20) ) p ˆx + p ˆp dp. (21) It is well known that the vector product in Eq. (19) can be represented as a determinant, and so we get da = JdA, (22) where J = x x p x x p p p (Jacobian) (23) is the Jacobian of the transformation from (x, p ) to (x, p) which occurs when you change variables in an integral, i.e.... dx dp =... J dxdp. (24) Hence a symplectic algorithm has det J = 1. (25) To show that Eq. (25) is satisfied for leapfrog algorithm it is convenient to consider each of the three steps in Eq. (10) separately (remember we have m = 1 here so p and v can be used interchangeably): δx 1 = C δx 1, δv 1 δv 1/2 δx 1 = B δx 0, δv 1/2 δv 1/2 δx 0 = A δx 0, (26) δv 0 δv 1/2 where C = 1 0, B = 1 h, A = 1 0, (27) h 2 F (x 1 ) h 2 F (x 0 ) 1

10 10 so δx 1 = J δx 0, (28) δv 1 δv 0 where J is given by the matrix product J = CBA. (29) It is an important (but not sufficiently well known) theorem that the determinant of a product of matrices is the the product of the determinants, i.e. det J = det C det B det A. (30) By inspection, det A = det B = det C = 1, and so det J = 1 as required, see Eq. (25). Hence the leapfrog/velocity Verlet algorithm is symplectic. However, det J is not equal to unity for the other algorithms that we have considered, Euler, RK2 and RK4. (Since RK4 is very accurate the change in area will be small, of order h 4, but not zero.) The advantage of symplectic algorithms is that they possess a sort of global stability. Since the area bounded by adjacent trajectories is preserved, we can never have the situation that we saw for the Euler algorithm earlier in the class, where the coordinates (and hence the energy) increase without bound, because this would expand the area. Even in better nonsymplectic approximations, such as RK2 and RK4, the energy will deviate substantially from its initial value at very long times. In fact one can show that the results from an approximate symplectic integrator are equal to the exact dynamics of a close by Hamiltonian, H (h) where, for the case of a second order method like leapfrog, H (h) = H + (...) h 2 + (...) h 3 +, (31) in which H = p2 + V (x) (32) 2m is the actual Hamiltonian and (...) represent the extra pieces of H (h).

11 11 VI. NUMERICAL RESULTS We now show some numerical data which illustrates the symplectic behavior of the leapfrog algorithm. As usual, we take the simple harmonic oscillator, with time step h = 0.02T (where T is the period). FIG. 5: Variation of (twice) the energy E as a function of time for the simple harmonic oscillator using the velocity Verlet algorithm (solid line) and second order Runge-Kutta (RK2) (dashed line). This for m = k = 1, with initial conditions, x = 1, v = 0 and a timestep of h = 0.02T, where the period T is 2π. Since velocity Verlet is symplectic, 2E never deviates much from its exact value of 1, but the energy in RK2 deviates more and more at long times. Figure 5 shows that although the energy deviates from the exact value, it never wanders far from the exact result. By contrast, in the RK2 algorithm the energy deviates more and more from the exact value as t increases, as shown by the thick dashed line in the figure. The energy in the leapfrog method oscillates around the correct value because the method is symplectic. Note that for very small times (less than about a half period), the error with leapfrog is actually rather worse than with RK2 (though both are of order h 2 ). It is in the long time behavior that leapfrog is better since it has global stability.

12 12 VII. HIGHER ORDER SYMPLECTIC ALGORITHMS (242 STUDENTS) Recently there has been interest in higher order algorithms which respect time reversal invariance and which are symplectic. The simplest higher order symplectic algorithm is that of E. Forest and R.D. Ruth[1], and extensions discussed in Omelyan et al.[2], which is fourth order. If initially x = x(t), v = v(t) then, in the Forest-Ruth algorithm, the following steps x = x + θ h 2 v v = v + θhf (x) x = x + (1 θ) h 2 v (33a) (33b) (33c) v = v + (1 2θ)hF (x) (FR algorithm) (33d) x = x + (1 θ) h 2 v v = v + θhf (x) x = x + θ h 2 v, (33e) (33f) (33g) with θ = , (34) yield x(t + h), v(t + h) and so generate one time step. Note that this method requires three evaluations of the force per time step, as opposed to just one for leapfrog. Note too that the steps are symmetric about the middle one (this ensures time reversal invariance). Since each step involves simply moving forward either the position or the velocity, the Jacobian of the transformation can be written, as for the leapfrog method discussed above, as a the product of determinants (7 here) each of which trivially has determinant unity. Hence the algorithm is symplectic. The hard work is to show that the algorithm gives an error of order h 5 for one interval (and hence of order h 4 when integrated over n = T/h time steps for a fixed time increment T ). This is where the strange value for θ comes from. It is curious that the middle step of the Forest-Ruth algorithm, Eq. (33d), is (i) larger in magnitude than h, since 1 2θ , and (ii), like some of the other steps, it goes backwards in time. This large step turns out out to be necessary to get a 4-th order symplectic algorithm requiring only three force evaluations per time step. If one is willing to accept more than 3 force evaluations one can avoid having a step greater in magnitude than h, as discussed in the next paragraph. However, to my knowledge, all higher order symplectic algorithms have some steps

13 13 which go backwards in time. To avoid a step which goes backward in time by more than h, one could use the Position Extended Forest-Ruth Like (PEFRL) algorithm of Omelyan et al.[2] Integrating forward one time step in this algorithm involves the following steps: x = x + ξhv v = v + (1 2λ) h 2 F (x) x = x + χhv v = v + λhf (x) (35a) (35b) (35c) (35d) x = x + (1 2(χ + ξ))hv (PEFRL algorithm) (35e) v = v + λhf (x) x = x + χhv v = v + (1 2λ) h 2 F (x) x = x + ξhv (35f) (35g) (35h) (35i) with ξ = E+00 λ = E+00 χ = E 01 (36a) (36b) (36c) This algorithm requires 4 force evaluations per time step rather than 3 for Forrest-Ruth, but it is more accurate, as we will see below, since it avoids the large time step. The following table shows results for the maximum error in 2E over one period (2E = 1 for the specified initial conditions x = 1, v = 0) for the leapfrog algorithm, Forest-Ruth (FR) algorithm, and the PEFRL algorithm of Omelyan et al. h/t leapfrog FR PEFRL By comparing the errors for the two different values of h/t one can see, as expected, that the error in the leapfrog algorithm varies as h 2 while that in the FR and PEFRL algorithms varies as h 4. Furthermore the PEFRL algorithm is about 26 times more accurate than the FR algorithm for the same value of h.

14 14 To make a fair comparison of the efficiency of the leapfrog and PEFRL algorithms, one should note that the PEFRL algorithm requires 4 times as many function evaluations per step. Hence we compare PEFRL with h/t = 0.02 and leapfrog with h/t = 0.005, which require the same number of steps; the result is that PEFRL is about still about 340 times more accurate. VIII. CONCLUSIONS Fourth-order symplectic algorithms have many advantages; they are are not very complicated but have good accuracy and global stability, so they are likely to play a major role in MD simulations in the future. However I agree with Omelyan et al. that symplectic integrators of order greater than 4 are probably not worth the extra complexity. For work in which high precision is not essential, the very simple second order velocity or position Verlet (leapfrog) method works very well, and I recommend it. [1] E. Forest and R.D. Ruth, Physica D, 43, 105 (1990) [2] I.M. Omelyan, I.M. Mryglod and R. Folk, Computer Physics Communications 146, 188 (2002),