- 92 Views
- Uploaded on
- Presentation posted in: General

Efficient solution of the n-body problem

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Efficient solution of the n-body problem

Honor Thesis Presentation

Mike Bantegui, Hofstra University

Advisor: Dr. Xiang Fu, Hofstra University

- The N-Body Problem
- Computational challenges
- Results
- Existing work
- IGS Framework
- Extensions

- 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

- Must integrate 3N coupled nonlinear second order ordinary differential equations
- Not analytically possible except for N = 2
- Must resort to numerical methods

- Set
- While
- For each body, evaluate total force
- Integrate position, velocity of each body over small time
- Set

- For i = 0 … N – 1
- For j = I + 1 … N – 1
- Compute pairwise gravity between body and

- Total steps =
- Force evaluations =
- Integration =
- Overall complexity =

- Very slow due to quadratic behavior of force evaluation
- Requires evaluations for
- Constant time steps could miss near-collisions
- Force evaluation not obviously parallelizable

- (Triangular portion)
- (Block portion)

- 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

- 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

- Treat clustered system as point-like body
- Force between cluster and a body is given by total mass at center of mass

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

- 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

- 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

- 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)

- Call TreeWalk for each body:
- For i = 0 .. N – 1
- TreeWalk()

- 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

- For single body walking a node of size N:
- For N bodies:

- 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

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

- Component based Interactive Gravitational Simulator
- CoreIGS – Core simulation library
- CmdIGS – Command line driven interface
- VisIGS – Interactive visualizer

- 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!

- 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!)

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

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

- Any questions?