int main(int argc, char* argv[]) { struct reb_simulation* r = reb_create_simulation(); // Setup constants r->opening_angle2 = .5; // This determines the precission of the tree code gravity calculation. r->integrator = REB_INTEGRATOR_SEI; r->boundary = REB_BOUNDARY_SHEAR; r->gravity = REB_GRAVITY_TREE; r->collision = REB_COLLISION_TREE; double OMEGA = 0.00013143527; // 1/s r->ri_sei.OMEGA = OMEGA; r->G = 6.67428e-11; // N / (1e-5 kg)^2 m^2 r->softening = 0.1; // m r->dt = 1e-3*2.*M_PI/OMEGA; // s // This example uses two root boxes in the x and y direction. // Although not necessary in this case, it allows for the parallelization using MPI. // See Rein & Liu for a description of what a root box is in this context. double surfacedensity = 600; // kg/m^2 double particle_density = 400; // kg/m^3 double particle_radius_min = 1; // m double particle_radius_max = 4; // m double particle_radius_slope = -3; double boxsize = 100; // m if (argc>1){ // Try to read boxsize from command line boxsize = atof(argv[1]); } reb_configure_box(r, boxsize, 2, 2, 1); r->nghostx = 2; r->nghosty = 2; r->nghostz = 0; // Use Bridges et al coefficient of restitution. r->coefficient_of_restitution = coefficient_of_restitution_bridges; // When two particles collide and the relative velocity is zero, the might sink into each other in the next time step. // By adding a small repulsive velocity to each collision, we prevent this from happening. r->minimum_collision_velocity = particle_radius_min*OMEGA*0.001; // small fraction of the shear accross a particle // Add all ring paricles double total_mass = surfacedensity*r->boxsize.x*r->boxsize.y; double mass = 0; while(mass<total_mass){ struct reb_particle pt = {0.}; pt.x = reb_random_uniform(-r->boxsize.x/2.,r->boxsize.x/2.); pt.y = reb_random_uniform(-r->boxsize.y/2.,r->boxsize.y/2.); pt.z = reb_random_normal(1.); // m pt.vx = 0; pt.vy = -1.5*pt.x*OMEGA; pt.vz = 0; pt.ax = 0; pt.ay = 0; pt.az = 0; double radius = reb_random_powerlaw(particle_radius_min,particle_radius_max,particle_radius_slope); pt.r = radius; // m double particle_mass = particle_density*4./3.*M_PI*radius*radius*radius; pt.m = particle_mass; // kg reb_add(r, pt); mass += particle_mass; } reb_integrate(r, 2./OMEGA); }
int main(int argc, char* argv[]){ // Setup constants G = 1; integrator = LEAPFROG; softening = 0.01; dt = 3e-3; boxsize = 1.2; root_nx = 1; root_ny = 1; root_nz = 1; nghostx = 0; nghosty = 0; nghostz = 0; init_box(); // Setup particles double disc_mass = 2e-1; int _N = 10000; // Initial conditions struct reb_particle star; star.x = 0; star.y = 0; star.z = 0; star.vx = 0; star.vy = 0; star.vz = 0; star.ax = 0; star.ay = 0; star.az = 0; star.m = 1; reb_add(r, star); while(N<_N){ struct reb_particle pt; double a = reb_random_powerlaw(boxsize/10.,boxsize/2./1.2,-1.5); double phi = reb_random_uniform(0,2.*M_PI); pt.x = a*cos(phi); pt.y = a*sin(phi); pt.z = a*reb_random_normal(0.001); double mu = star.m + disc_mass * (pow(a,-3./2.)-pow(boxsize/10.,-3./2.))/(pow(boxsize/2./1.2,-3./2.)-pow(boxsize/10.,-3./2.)); double vkep = sqrt(G*mu/a); pt.vx = vkep * sin(phi); pt.vy = -vkep * cos(phi); pt.vz = 0; pt.ax = 0; pt.ay = 0; pt.az = 0; pt.m = disc_mass/(double)_N; reb_add(r, pt); } }
void run_sim(){ struct reb_simulation* const r = reb_create_simulation(); // Setup constants r->integrator = REB_INTEGRATOR_LEAPFROG; r->gravity = REB_GRAVITY_BASIC; r->boundary = REB_BOUNDARY_OPEN; r->opening_angle2 = 1.5; // This constant determines the accuracy of the tree code gravity estimate. r->G = 1; r->softening = 0.02; // Gravitational softening length r->dt = 3e-2; // Timestep const double boxsize = 10.2; reb_configure_box(r,boxsize,1,1,1); // Setup particles double disc_mass = 2e-1; // Total disc mass int N = 2000; // Number of particles // Initial conditions struct reb_particle star = {0}; star.m = 1; reb_add(r, star); for (int i=0;i<N;i++){ struct reb_particle pt = {0}; double a = reb_random_powerlaw(boxsize/10.,boxsize/2./1.2,-1.5); double phi = reb_random_uniform(0,2.*M_PI); pt.x = a*cos(phi); pt.y = a*sin(phi); pt.z = a*reb_random_normal(0.001); double mu = star.m + disc_mass * (pow(a,-3./2.)-pow(boxsize/10.,-3./2.))/(pow(boxsize/2./1.2,-3./2.)-pow(boxsize/10.,-3./2.)); double vkep = sqrt(r->G*mu/a); pt.vx = vkep * sin(phi); pt.vy = -vkep * cos(phi); pt.vz = 0; pt.m = disc_mass/(double)N; reb_add(r, pt); } reb_integrate(r, 1.0); reb_free_simulation(r); }
int main(int argc, char* argv[]){ struct reb_simulation* const r = reb_create_simulation(); // Setup constants r->integrator = REB_INTEGRATOR_LEAPFROG; r->gravity = REB_GRAVITY_TREE; r->boundary = REB_BOUNDARY_OPEN; r->opening_angle2 = 1.5; // This constant determines the accuracy of the tree code gravity estimate. r->G = 1; r->softening = 0.02; // Gravitational softening length r->dt = 3e-2; // Timestep const double boxsize = 10.2; // Setup root boxes for gravity tree. // Here, we use 2x2=4 root boxes (each with length 'boxsize') // This allows you to use up to 4 MPI nodes. reb_configure_box(r,boxsize,2,2,1); // Initialize MPI // This can only be done after reb_configure_box. reb_mpi_init(r); // Setup particles only on master node // In the first timestep, the master node will // distribute particles to other nodes. // Note that this is not the most efficient method // for very large particle numbers. double disc_mass = 2e-1/r->mpi_num; // Total disc mass int N = 10000/r->mpi_num; // Number of particles // Initial conditions struct reb_particle star = {0}; star.m = 1; if (r->mpi_id==0){ reb_add(r, star); } for (int i=0;i<N;i++){ struct reb_particle pt = {0}; double a = reb_random_powerlaw(boxsize/10.,boxsize/2./1.2,-1.5); double phi = reb_random_uniform(0,2.*M_PI); pt.x = a*cos(phi); pt.y = a*sin(phi); pt.z = a*reb_random_normal(0.001); double mu = star.m + disc_mass * (pow(a,-3./2.)-pow(boxsize/10.,-3./2.))/(pow(boxsize/2./1.2,-3./2.)-pow(boxsize/10.,-3./2.)); double vkep = sqrt(r->G*mu/a); pt.vx = vkep * sin(phi); pt.vy = -vkep * cos(phi); pt.vz = 0; pt.m = disc_mass/(double)N; reb_add(r, pt); } r->heartbeat = heartbeat; #ifdef OPENGL // Hack to artificially increase particle array. // This cannot be done once OpenGL is activated. r->allocatedN *=8; r->particles = realloc(r->particles,sizeof(struct reb_particle)*r->allocatedN); #endif // OPENGL // Start the integration reb_integrate(r, INFINITY); // Cleanup reb_mpi_finalize(r); reb_free_simulation(r); }
void reb_tools_megno_init(struct reb_simulation* const r, double delta){ int N_var = r->N; r->calculate_megno = 1; r->megno_Ys = 0.; r->megno_Yss = 0.; r->megno_cov_Yt = 0.; r->megno_var_t = 0.; r->megno_n = 0; r->megno_mean_Y = 0; r->megno_mean_t = 0; for (int i=0;i<N_var;i++){ struct reb_particle megno = { .m = r->particles[i].m, .x = reb_random_normal(1.), .y = reb_random_normal(1.), .z = reb_random_normal(1.), .vx = reb_random_normal(1.), .vy = reb_random_normal(1.), .vz = reb_random_normal(1.) }; double deltad = delta/sqrt(megno.x*megno.x + megno.y*megno.y + megno.z*megno.z + megno.vx*megno.vx + megno.vy*megno.vy + megno.vz*megno.vz); // rescale megno.x *= deltad; megno.y *= deltad; megno.z *= deltad; megno.vx *= deltad; megno.vy *= deltad; megno.vz *= deltad; reb_add(r, megno); } r->N_var = N_var; } double reb_tools_calculate_megno(struct reb_simulation* r){ // Returns the MEGNO <Y> if (r->t==0.) return 0.; return r->megno_Yss/r->t; } double reb_tools_calculate_lyapunov(struct reb_simulation* r){ // Returns the largest Lyapunov characteristic number (LCN), or maximal Lyapunov exponent if (r->t==0.) return 0.; return r->megno_cov_Yt/r->megno_var_t; } double reb_tools_megno_deltad_delta(struct reb_simulation* const r){ const struct reb_particle* restrict const particles = r->particles; const int N = r->N; const int N_var = r->N_var; double deltad = 0; double delta2 = 0; for (int i=N-N_var;i<N;i++){ deltad += particles[i].vx * particles[i].x; deltad += particles[i].vy * particles[i].y; deltad += particles[i].vz * particles[i].z; deltad += particles[i].ax * particles[i].vx; deltad += particles[i].ay * particles[i].vy; deltad += particles[i].az * particles[i].vz; delta2 += particles[i].x * particles[i].x; delta2 += particles[i].y * particles[i].y; delta2 += particles[i].z * particles[i].z; delta2 += particles[i].vx * particles[i].vx; delta2 += particles[i].vy * particles[i].vy; delta2 += particles[i].vz * particles[i].vz; } return deltad/delta2; } void reb_tools_megno_update(struct reb_simulation* r, double dY){ // Calculate running Y(t) r->megno_Ys += dY; double Y = r->megno_Ys/r->t; // Calculate averge <Y> r->megno_Yss += Y * r->dt; // Update covariance of (Y,t) and variance of t r->megno_n++; double _d_t = r->t - r->megno_mean_t; r->megno_mean_t += _d_t/(double)r->megno_n; double _d_Y = reb_tools_calculate_megno(r) - r->megno_mean_Y; r->megno_mean_Y += _d_Y/(double)r->megno_n; r->megno_cov_Yt += ((double)r->megno_n-1.)/(double)r->megno_n *(r->t-r->megno_mean_t) *(reb_tools_calculate_megno(r)-r->megno_mean_Y); r->megno_var_t += ((double)r->megno_n-1.)/(double)r->megno_n *(r->t-r->megno_mean_t) *(r->t-r->megno_mean_t); }
int main(int argc, char* argv[]){ struct reb_simulation* r = reb_create_simulation(); // Setup constants r->dt = 1e-1; r->gravity = REB_GRAVITY_NONE; r->integrator = REB_INTEGRATOR_LEAPFROG; r->collision = REB_COLLISION_TREE; r->boundary = REB_BOUNDARY_PERIODIC; // Override default collision handling to account for border particles r->collision_resolve = collision_resolve_hardsphere_withborder; r->heartbeat = heartbeat; reb_configure_box(r, 20., 1, 1, 4); r->nghostx = 1; r->nghosty = 1; r->nghostz = 0; double N_part = 0.00937*r->boxsize.x*r->boxsize.y*r->boxsize.z; // Add Border Particles double radius = 1; double mass = 1; double border_spacing_x = r->boxsize.x/(floor(r->boxsize.x/radius/2.)-1.); double border_spacing_y = r->boxsize.y/(floor(r->boxsize.y/radius/2.)-1.); struct reb_particle pt = {0}; pt.r = radius; pt.m = mass; pt.id = 1; for(double x = -r->boxsize.x/2.; x<r->boxsize.x/2.-border_spacing_x/2.;x+=border_spacing_x){ for(double y = -r->boxsize.y/2.; y<r->boxsize.y/2.-border_spacing_y/2.;y+=border_spacing_y){ pt.x = x; pt.y = y; // Add particle to bottom pt.z = -r->boxsize.z/2.+radius; pt.vy = 1; reb_add(r, pt); // Add particle to top pt.z = r->boxsize.z/2.-radius; pt.vy = -1; reb_add(r, pt); } } N_border = r->N; // Add real particles while(r->N-N_border<N_part){ struct reb_particle pt = {0}; pt.x = reb_random_uniform(-r->boxsize.x/2.,r->boxsize.x/2.); pt.y = reb_random_uniform(-r->boxsize.y/2.,r->boxsize.y/2.); pt.z = 0.758*reb_random_uniform(-r->boxsize.z/2.,r->boxsize.z/2.); pt.vx = reb_random_normal(0.001); pt.vy = reb_random_normal(0.001); pt.vz = reb_random_normal(0.001); pt.r = radius; // m pt.m = 1; pt.id = 2; reb_add(r, pt); } reb_integrate(r, INFINITY); }