void iterate(void){
// A 'DKD'-like integrator will do the first 'D' part.
PROFILING_START()
integrator_part1();
PROFILING_STOP(PROFILING_CAT_INTEGRATOR)
// Check for root crossings.
PROFILING_START()
boundaries_check();
PROFILING_STOP(PROFILING_CAT_BOUNDARY)
// Update and simplify tree.
// Prepare particles for distribution to other nodes.
// This function also creates the tree if called for the first time.
PROFILING_START()
#ifdef TREE
tree_update();
#endif //TREE
#ifdef MPI
// Distribute particles and add newly received particles to tree.
communication_mpi_distribute_particles();
#endif // MPI
#ifdef GRAVITY_TREE
// Update center of mass and quadrupole moments in tree in preparation of force calculation.
tree_update_gravity_data();
#ifdef MPI
// Prepare essential tree (and particles close to the boundary needed for collisions) for distribution to other nodes.
tree_prepare_essential_tree_for_gravity();
// Transfer essential tree and particles needed for collisions.
communication_mpi_distribute_essential_tree_for_gravity();
#endif // MPI
#endif // GRAVITY_TREE
// Calculate accelerations.
gravity_calculate_acceleration();
if (N_megno){
gravity_calculate_variational_acceleration();
}
// Calculate non-gravity accelerations.
if (problem_additional_forces) problem_additional_forces();
if (problem_additional_forces_with_parameters) problem_additional_forces_with_parameters(particles, t, dt, G, N, N_megno);
PROFILING_STOP(PROFILING_CAT_GRAVITY)
// A 'DKD'-like integrator will do the 'KD' part.
PROFILING_START()
integrator_part2();
if (problem_post_timestep_modifications){
integrator_synchronize();
problem_post_timestep_modifications();
if (integrator == WHFAST || integrator == HYBRID){
integrator_whfast_recalculate_jacobi_this_timestep = 1;
}
}
if (problem_post_timestep_modifications_with_parameters){
integrator_synchronize();
problem_post_timestep_modifications_with_parameters(particles, t, dt, G, N, N_megno);
if (integrator == WHFAST || integrator == HYBRID){
integrator_whfast_recalculate_jacobi_this_timestep = 1;
}
}
PROFILING_STOP(PROFILING_CAT_INTEGRATOR)
// Do collisions here. We need both the positions and velocities at the same time.
#ifndef COLLISIONS_NONE
// Check for root crossings.
PROFILING_START()
boundaries_check();
PROFILING_STOP(PROFILING_CAT_BOUNDARY)
// Search for collisions using local and essential tree.
PROFILING_START()
collisions_search();
// Resolve collisions (only local particles are affected).
collisions_resolve();
PROFILING_STOP(PROFILING_CAT_COLLISION)
#endif // COLLISIONS_NONE
#ifdef OPENGL
PROFILING_START()
display();
PROFILING_STOP(PROFILING_CAT_VISUALIZATION)
#endif // OPENGL
problem_output();
// Check if the simulation finished.
#ifdef MPI
int _exit_simulation = 0;
MPI_Allreduce(&exit_simulation, &_exit_simulation,1,MPI_INT,MPI_MAX,MPI_COMM_WORLD);
exit_simulation = _exit_simulation;
#endif // MPI
// @TODO: Adjust timestep so that t==tmax exaclty at the end.
if((t+dt>tmax && tmax!=0.0) || exit_simulation==1){
#ifdef GRAVITY_GRAPE
gravity_finish();
#endif // GRAVITY_GRAPE
problem_finish();
struct timeval tim;
gettimeofday(&tim, NULL);
double timing_final = tim.tv_sec+(tim.tv_usec/1000000.0);
printf("\nComputation finished. Total runtime: %f s\n",timing_final-timing_initial);
#ifdef MPI
MPI_Finalize();
#endif // MPI
exit(0);
}
}
void display(){
if (display_pause) return;
#ifdef TREE
if (display_tree){
tree_update();
#ifdef GRAVITY_TREE
tree_update_gravity_data();
#endif
}
#endif
if (display_clear){
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
}
if (!display_wire) {
if (display_spheres){
glDisable(GL_BLEND);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
GLfloat lightpos[] = {0, boxsize_max, boxsize_max, 0.f};
glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
}else{
glEnable(GL_BLEND);
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_LIGHT0);
}
}
glEnable(GL_POINT_SMOOTH);
glVertexPointer(3, GL_DOUBLE, sizeof(struct particle), particles);
int _N_active = (N_active==-1)?N:N_active;
if (display_reference>=0){
glTranslatef(-particles[display_reference].x,-particles[display_reference].y,-particles[display_reference].z);
}
glRotatef(display_rotate_x,1,0,0);
glRotatef(display_rotate_z,0,0,1);
for (int i=-display_ghostboxes*nghostx;i<=display_ghostboxes*nghostx;i++){
for (int j=-display_ghostboxes*nghosty;j<=display_ghostboxes*nghosty;j++){
for (int k=-display_ghostboxes*nghostz;k<=display_ghostboxes*nghostz;k++){
struct ghostbox gb = boundaries_get_ghostbox(i,j,k);
glTranslatef(gb.shiftx,gb.shifty,gb.shiftz);
if (!(!display_clear&&display_wire)){
if (display_spheres){
// Drawing Spheres
glColor4f(1.0,1.0,1.0,1.0);
#ifndef COLLISIONS_NONE
for (int i=0;i<N;i++){
struct particle p = particles[i];
glTranslatef(p.x,p.y,p.z);
glScalef(p.r,p.r,p.r);
#ifdef _APPLE
glCallList(display_dlist_sphere);
#else //_APPLE
glutSolidSphere(1,40,10);
#endif //_APPLE
glScalef(1./p.r,1./p.r,1./p.r);
glTranslatef(-p.x,-p.y,-p.z);
}
#endif // COLLISIONS_NONE
}else{
// Drawing Points
glEnableClientState(GL_VERTEX_ARRAY);
glPointSize(3.);
glColor4f(1.0,1.0,1.0,0.5);
glDrawArrays(GL_POINTS, _N_active, N-_N_active);
glColor4f(1.0,1.0,0.0,0.9);
glPointSize(5.);
glDrawArrays(GL_POINTS, 0, _N_active);
glDisableClientState(GL_VERTEX_ARRAY);
}
}
// Drawing wires
if (display_wire){
#ifndef INTEGRATOR_SEI
double radius = 0;
struct particle com = particles[0];
for (int i=1;i<N;i++){
struct particle p = particles[i];
if (N_active>0){
// Different colors for active/test particles
if (i>=N_active){
glColor4f(0.9,1.0,0.9,0.9);
}else{
glColor4f(1.0,0.9,0.0,0.9);
}
}else{
// Alternating colors
if (i%2 == 1){
glColor4f(0.0,1.0,0.0,0.9);
}else{
glColor4f(0.0,0.0,1.0,0.9);
}
}
struct orbit o = tools_p2orbit(p,com);
glPushMatrix();
glTranslatef(com.x,com.y,com.z);
glRotatef(o.Omega/DEG2RAD,0,0,1);
glRotatef(o.inc/DEG2RAD,1,0,0);
glRotatef(o.omega/DEG2RAD,0,0,1);
glBegin(GL_LINE_LOOP);
for (double trueAnom=0; trueAnom < 2.*M_PI; trueAnom+=M_PI/100.) {
//convert degrees into radians
radius = o.a * (1. - o.e*o.e) / (1. + o.e*cos(trueAnom));
glVertex3f(radius*cos(trueAnom),radius*sin(trueAnom),0);
}
glEnd();
glPopMatrix();
com = tools_get_center_of_mass(p,com);
}
#else // INTEGRATOR_SEI
for (int i=1;i<N;i++){
struct particle p = particles[i];
glBegin(GL_LINE_LOOP);
for (double _t=-100.*dt;_t<=100.*dt;_t+=20.*dt){
double frac = 1.-fabs(_t/(120.*dt));
glColor4f(1.0,(_t+100.*dt)/(200.*dt),0.0,frac);
glVertex3f(p.x+p.vx*_t, p.y+p.vy*_t, p.z+p.vz*_t);
}
glEnd();
}
#endif // INTEGRATOR_SEI
}
// Drawing Tree
glColor4f(1.0,0.0,0.0,0.4);
#ifdef TREE
if (display_tree){
glColor4f(1.0,0.0,0.0,0.4);
display_entire_tree();
}
#endif // TREE
glTranslatef(-gb.shiftx,-gb.shifty,-gb.shiftz);
}
}
}
glColor4f(1.0,0.0,0.0,0.4);
glScalef(boxsize_x,boxsize_y,boxsize_z);
glutWireCube(1);
glScalef(1./boxsize_x,1./boxsize_y,1./boxsize_z);
glRotatef(-display_rotate_z,0,0,1);
glRotatef(-display_rotate_x,1,0,0);
if (display_reference>=0){
glTranslatef(particles[display_reference].x,particles[display_reference].y,particles[display_reference].z);
}
glutSwapBuffers();
}
