Efficient solution of the n-body problem

1. Efficient solution of the n-body problem Honor Thesis Presentation Mike Bantegui, Hofstra University Advisor: Dr. Xiang Fu, Hofstra University

2. Outline • The N-Body Problem • Computational challenges • Results • Existing work • IGS Framework • Extensions

3. The n-body problem • Given mass, position and velocities of N bodies at some time t • Know pairwise forces using • Determine evolution of the system of bodies • Used to study Stellar Dynamics

4. The n-body problem cont. • Must integrate 3N coupled nonlinear second order ordinary differential equations • Not analytically possible except for N = 2 • Must resort to numerical methods

5. Candidate Numerical solution • Set • While • For each body, evaluate total force • Integrate position, velocity of each body over small time • Set

6. Force Evaluation step • For i = 0 … N – 1 • For j = I + 1 … N – 1 • Compute pairwise gravity between body and

7. Example force evaluation

8. Time Complexity • Total steps = • Force evaluations = • Integration = • Overall complexity =

9. Issues with candidate solution • Very slow due to quadratic behavior of force evaluation • Requires evaluations for • Constant time steps could miss near-collisions • Force evaluation not obviously parallelizable

10. “Geometric trick” for parallelization

11. “Geometric trick” for parallelization

12. “Geometric trick” for parallelization

13. Time complexity of geometric trick • (Triangular portion) • (Block portion)

14. Issues with geometric trick • Parallelizes poorly beyond P > 2 using OpenMP • Use naïve force evaluation algorithm for P > 2: • For i = 0 … N – 1 • For j = 0 … N – 1 • if i != j • Add Force due to acting on onto • Twice as much work, for scalability

15. Naïve force evaluation speedup

16. Handling close encounters • Keep track of a minimum collision timescale for each body: • Use to vary when integrating • Number of steps taken is no longer predictable • Support higher order PEC-type integrators (Leapfrog, 4th and 6th order Hermite) • Allows dramatic increase in step size for similar error

17. A more efficient way of evaluating force • Treat clustered system as point-like body • Force between cluster and a body is given by total mass at center of mass

18. Example of clustering bodies

19. hierarchical force evaluation • Apply the clustering principle recursively • Consider sub-clusters within a cluster • Refine force evaluation via sub-clusters instead of main cluster

20. Clustering algorithm • Node Cluster(bodies, min_bound, max_bound) • If bodies.size == 0 • return null • if bodies.size == 1 • return node containing body • Collect bodies into spatial groups • For each group • Cluster(group.bodies, group.min_bound, group.max_bound) • Compute first order multipole expansion, passing up tree • return node containing groups

21. Methods of spatial subdivision • Octree Barnes-Hut Algorithm • K-D tree Stadel Algorithm • Other choices possible • Time to build tree is • Parallelization opportunity available on recursive calls to Cluster

22. Force evaluation algorithm • TreeWalk(body) • For each branch in the tree • If branch is leaf • If branch.body!= body • Compute force of branch.body on body • Else • Compute distance between branch and body • If body is well separated from cluster • Compute force of branch on body • Else • branch.TreeWalk(body)

23. Force evaluation algorithm, cont • Call TreeWalk for each body: • For i = 0 .. N – 1 • TreeWalk()

24. Separation criteria • Body is well separated when acceptance criteria met: • Accept the approximation when clusters compact, body is far away • allows tuning for performance vs. accuracy • Alternative criteria available

25. Time complexity of tree walk • For single body walking a node of size N: • For N bodies:

26. Overview of hierarchical algorithm • Build tree in steps • Walk tree in steps • For N = 65536, brute-force pairwise requires evaluations • Hierarchical algorithm can do same in evaluations • Very easily parallelization

27. Parallelizing tree methods

28. Scaling to large n, octree

29. Scaling to large n, kd-tree

30. Scaling to large n, brute force

31. Brute force vs tree methods

32. energy errors

33. energy errors cont.

34. Related work • nbody1 – nbody6, SverreAarseth • ACS toolkit, Jun Makino and Piet Hut • Grav-Sim, Mark Ridler • Gravit, Gerald Kaszuba et al.

35. The proposed framework • Component based Interactive Gravitational Simulator • CoreIGS – Core simulation library • CmdIGS – Command line driven interface • VisIGS – Interactive visualizer

36. Software Architecture

37. Project stats • Open Source – Available at IGS.codeplex.com • 3+ years development • 5670 lines of code • 65 .cpp, .h files • 107 subversion revisions • 8 development iterations • Many failures before success!

38. Extensions • Individual time steps • Distributed simulations using MPI • Higher order integrators • Command interface for the visualizer • Other spatial subdividers (Hilbert curves, etc.) • Multipole expansion for acceleration and higher derivatives • Pairwise interactions between tree nodes ( evaluations!)

39. Conclusions • Tree methods very efficient • Performance vs. Accuracy tradeoff possible • Extremely parallelizable • Accurate, real-time simulations possible on commodity hardware

40. acknowledgements • Dr. Xiang Fu for advisement and helpful discussions • Dr. GerdaKamberova for helpful comments on the paper • Lukasz Bator for many discussions on algorithmic efficiency

41. Thank you for coming! • Any questions?