Brad Gibson Centre for Astrophysics & Supercomputing Swinburne University

Transcription

1 N-body Simulations: Tree and Mesh Approaches Brad Gibson Centre for Astrophysics & Supercomputing Swinburne University

2 Demystifying the Jargon Trees Collisionless Boltzmann Equation Symplectic Time Integration Eulerian Reference Frame Hermite Time Integration Leap-Frog Timestepping Poisson s Equation Comoving Coordinates Meshe s Lagrangian Reference Frame Green s Functions Gravitational Softening Vlasov Equation Grids AMR

3 N-body Simulations: Overview Basic equations (by definition, anathema to a good talk!) Basic techniques PP, PM, P3M, Tree, FMM, TreePM Basic tools hardware, software Are all codes created equal? (strengths & weaknesses) Resources

4 N-body Simulations: Basic Structure Chris Power! All N-body codes consist of two basic modules: 1. Force field computation 2. Particle trajectory computation Both modules are called at each time step to ensure that the force field and particle trajectories evolve in a self-consistent manner. Chris Power

5 N-body Simulations: Basic Equations Dark matter and stars are modeled as self-gravitating collisionless fluids - i.e., they obey the Vlasov/Diffusion/Collisionless Boltzmann equation: where the self-consistent potential Φ is the solution of Poisson s eqn: F = -sφ and f(r,v,t) is the mass density in single-particle phase space. The N-body problem is the task of following Newton s equations of motion for a large number of particles under their own selfgravity.

6 N-body Simulations: Basic Equations Let s start simple and examine the N=2 scenario, and work in terms of the relative position: Newton s gravitational equation of motion then becomes: where and

7 N-body Simulations: Basic Equations Keep it further simple by setting G=1 and M 1 +M 2 =1: We now have the equations of motion for the relative position of one particle with respect to the other. We now need an algorithm to integrate these equations. Order of algorithm? Low? High? Structure of algorithm? Euler, Leapfrog, Hermite, Symplectic

8 N-body Simulations: Forward-Euler Algorithm What is the order of an algorithm? Signifies the rate of convergence Since no algorithm with a finite time step size is perfect, they all make numerical errors. In a 4th-order algorithm, this error scales as the 4th power of the time step. High-order integrators are complex to code and their region of convergence is limited There is an optimal order for each type of problem (well-behaved allows higher-orders)

9 N-body Simulations: Forward-Euler Algorithm What should the structure of the algorithm be? Simplest is 1st-order forward Eulerian integrator At each time step, you simply take a step tangential to the orbit you are on. At the next time step, the new value of the acceleration forces you to slightly change direction, and again you move for a step dt in a straight line in that direction. Orbit is thus constructed out of a number of straight line segments, where each one has the proper direction at the beginning of the segment but the wrong one at the end. Backwards Eulerian entails getting the right direction at the end of the time step (which is done via iteration guess a direction and then you correct for the mistake so that your second iteration is more accurate) Can also split the difference, which then becomes 2nd-order accurate (e.g. 2nd-order Runge-Kutta and Leapfrog)

10 N-body Simulations: Forward-Euler Algorithm What should the structure of the algorithm be? Simplest is 1st-order forward Eulerian integrator Above is notation for position and velocity of an individual particle, after time step dt. Acceleration is a. We now have enough in the way of equations to write an N-body code!

11 An N-body Code in <10 Lines (N=2) Initial Conditions (relative position & velocity)

12 N-body Simulations: Forward-Euler Algorithm Time step too large; artificial slingshot where orbital curvature is highest (just after pericenter)

13 N-body Simulations: Forward-Euler Algorithm Time step too large; artificial slingshot where orbital curvature is highest (just after pericenter)

14 N-body Simulations: Forward-Euler Algorithm Time step too large; artificial slingshot where orbital curvature is highest (just after pericenter)

15 N-body Simulations: Forward-Euler Algorithm Time step too large; artificial slingshot where orbital curvature is highest (just after pericenter)

16 N-body Simulations: Forward-Euler Algorithm Time step too large; artificial slingshot where orbital curvature is highest (just after pericenter)

17 N-body Simulations: Forward-Euler Algorithm In reality, many-body simulations do not have analytical solutions which would allow us to gauge convergence. Are there conserved quantities which could be used to better gauge convergence? Yes! Energy conservation is the simplest to employ, and must be rigorously conserved, so any deviations must be numerical. Our 1st-order forward Eulerian test does converge, but slowly!

18 N-body Simulations: Leapfrog Algorithm The leapfrog algorithm is one of the most popular higher-order integrators in use today. The name derives from the fact that positions and velocities leap over each other. Positions are defined at times t i,t i+1,, spaced at constant dt, while velocities are defined at times halfway between, or t i-1/2,t i+1/2, The leapfrog algorithm then reads: Accelerations defined only on integer times, just like positions while velocities are defined only on half-integer times.

19 N-body Simulations: Leapfrog Algorithm At the beginning of the integration we set up the velocity at its first half-integer time step. Starting with initial conditions r 0 and v 0, we take 1st term in Taylor series expansion to compute 1st leap value for v : We then use to compute the new position r 1 using the 1st leap value for v 1/2. Next we compute the acceleration a 1, which enables us to compute the 2nd leap value v 3/2 using and so on.

20 N-body Simulations: Leapfrog Algorithm dt=0.01 dt=0.001 Forward Eulerian

21 N-body Simulations: Calculating the Force An N-body code solves the equation of motion and the Poisson equation self-consistently. Moving particles and computing the force for a given particle distribution are a code s two most important components. Currently there are two commonly used approaches for deriving the potential from Poisson s equation: Tree Codes (particle-particle/group summation) PM (particle-mesh: integrate Poisson s equation on a grid)

22 N-body Simulations: Tree Codes Calculating the force at every single particle position via direct summation of Newton s laws between all pairs of particles means the PP method scales like N 2 just not feasible for large N. Can we get more clever? Yes, by organising particles in a treelike structure. Particles located far away from the particle in question are grouped together as a single (but more massive) particle. This has the effect of dramatically reducing the number of calculations.

23 N-body Simulations: Tree Codes Decompose computational domain hierarchically into a sequence of cubes, where each cube contains 8 siblings (oct-tree), each with half the side-length of the parent. Each node will contain either 1 particle or is progenitor to further nodes, in which case the node carries monopole and quadrupole moments of all the particles that lie inside its cube.

24 N-body Simulations: Tree Codes Force computation then proceeds by walking the tree and summing the appropriate force contributions from tree nodes. A user-specified opening criterion is employed to decide whether or not a particular node needs to be opened into finer branches if the latter is deemed necessary, the walk will continue with all of its siblings. Smaller opening angle=higher accuracy=more expensive

25 Multi-resolution CDM with GCD+ High-z snapshot High Resolution Region m DM =2x10 5 M, ε DM =0.14 kpc, m gas =3x10 4 M, ε gas =0.08 kpc J-band 5kpc = 0.83 M vir = 6x10 9 M V max = 65 km/s

26 N-body Simulations: Particle-Mesh (PM) Codes Another way to obtain forces is to numerically integrate Poisson s equation. This demands the introduction of a grid in order to define density. The grid is usually of a regular (cubic) shape. Forces are then calculated as such: assign all particles to the grid to get ρ solve Poisson s equation s 2 Φ = 4πGρ This is where most differentiate to get forces F=-sΦ of the time is spent interpolate F back to particle positions The most common way to solve Poisson s equation on a grid is to make use of FFTs.

27 N-body Simulations: Particle-Mesh (PM) Codes The analytical solution to Poisson s equation is given by the integral: where which is readily solved in Fourier space: is the Green s Function of Poisson s eqn. FTs of the respective variables.

28 N-body Simulations: Particle-Mesh (PM) Codes The PM approach is much faster than Tree codes. The most severe problem with PM codes is the lack of spatial resolution due to the underlying grid we cannot resolve structure on scales of the grid s cell spacing. Major problem! solution? Introduce finer grids in regions of high density

29 the simulations: n-bodies the n-body code grid hierarchy Multi Level Adaptive Particle Mesh only open source AMR code written in C extremely memory efficient extremely fast MPI parallelisation (planned ) hydrodynamics (planned ) on-the-fly analysis: MLAPM s grids naturally find substructure within halos!

30 the simulations: sample rd th refinement halo at level z=0 (out of 8) the satellite finder (Gill, Knebe, & Gibson 2003)

31 N-body Simulations: Tree vs PM Tree faster/more adaptive to highly clustered situations (Lagrangian = dynamic range) basically free of geometric restrictions two-body interactions more prominent PM faster for nearly homogeneous/non-clustered situations periodic boundary conditions more readily incorporated

32 Basic Tools: Supercomputers! 500 kcpu Swinburne, APAC, VPAC, NAOJ

33 Basic Tools: Software GCD+/GADGET Tree N-body + Smoothed Particle Hydrodynamics (parallel+vector) Star formation, energy feedback, chemical evolution, panchromatic MLAPM Adaptive Mesh Refinement (serial) Highly efficient, on-the-fly visualisation and analysis tools

34 Basic Tools: The Astonishing Approach Holmberg (1941) Truly astonishing and prescient N-body simulation Light Intensity=Gravity Used the fact that both fall off like 1/r 2 to simulate in-plane tidal interactions between disk galaxies! N=37*2 OK so N was only 74 it s still remarkable! Light Bulb Photocell + Galvanometer 80cm Initial Condition: Single Disk Galaxy; N=37

35 Basic Tools: The Astonishing Approach Simulations #hyperbolic & parabolic orbits #galactic diameter 2.5kpc #galactic mass10 11 M #interaction speed 450 km/ s #pericenter 2.5 kpc #realistic surface brightness #multi-mass via varying voltage #3mx4m graph paper #tangents via French Curves Results #prograde-prograde leads to trailing spiral arms #spiral/tidal arms appear prograde- retrograde-retrograde prograde

36 Resources N-body and Hydrodynamics Links (primarily cosmological and galactic) The Art of Computational Science (PP) GADGET (TreePM) Enzo (PM) MLAPM

37