1 / 41

Efficient solution of the n-body problem

Efficient solution of the n-body problem. Honor Thesis Presentation Mike Bantegui, Hofstra University Advisor: Dr. Xiang Fu, Hofstra University. Outline. The N-Body Problem Computational challenges Results Existing work IGS Framework Extensions. The n-body problem.

evonne
Download Presentation

Efficient solution of the n-body problem

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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?

More Related