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);
}
void reb_tools_init_plummer(struct reb_simulation* r, int _N, double M, double R) {
// Algorithm from:
// http://adsabs.harvard.edu/abs/1974A%26A....37..183A
double E = 3./64.*M_PI*M*M/R;
for (int i=0;i<_N;i++){
struct reb_particle star = {0};
double _r = pow(pow(reb_random_uniform(0,1),-2./3.)-1.,-1./2.);
double x2 = reb_random_uniform(0,1);
double x3 = reb_random_uniform(0,2.*M_PI);
star.z = (1.-2.*x2)*_r;
star.x = sqrt(_r*_r-star.z*star.z)*cos(x3);
star.y = sqrt(_r*_r-star.z*star.z)*sin(x3);
double x5,g,q;
do{
x5 = reb_random_uniform(0.,1.);
q = reb_random_uniform(0.,1.);
g = q*q*pow(1.-q*q,7./2.);
}while(0.1*x5>g);
double ve = pow(2.,1./2.)*pow(1.+_r*_r,-1./4.);
double v = q*ve;
double x6 = reb_random_uniform(0.,1.);
double x7 = reb_random_uniform(0.,2.*M_PI);
star.vz = (1.-2.*x6)*v;
star.vx = sqrt(v*v-star.vz*star.vz)*cos(x7);
star.vy = sqrt(v*v-star.vz*star.vz)*sin(x7);
star.x *= 3.*M_PI/64.*M*M/E;
star.y *= 3.*M_PI/64.*M*M/E;
star.z *= 3.*M_PI/64.*M*M/E;
star.vx *= sqrt(E*64./3./M_PI/M);
star.vy *= sqrt(E*64./3./M_PI/M);
star.vz *= sqrt(E*64./3./M_PI/M);
star.m = M/(double)_N;
reb_add(r, star);
}
}
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);
}
int main(int argc, char* argv[]) {
int np = 20;
omp_set_num_threads(np);
FILE *fp2;
char hash_name[] = "hash.csv";
fp2 = fopen(hash_name, "w+");
fprintf(fp2, "Hash, Mass, Radius\n");
char filename[512] = "veras_no_frag.bin";
// Trying to restart from the Simulation Archive.
struct reb_simulation* r = reb_create_simulation_from_simulationarchive(filename);
printf("Loaded Simulation Successfully\n");
printf("Time is: %.16f\n", r->t);
printf("N_active is: %i\n", r->N);
printf("Timestep is: %.3f\n", r->dt);
r->heartbeat = heartbeat;
r->dt = 10.0;
r->gravity = REB_GRAVITY_TREE;
r->integrator = REB_INTEGRATOR_WHFAST;
r->collision = REB_COLLISION_TREE;
r->boundary = REB_BOUNDARY_OPEN;
const double boxsize = 2.5e10; // about 0.15 AU, with fragments at 0.0054 AU
reb_configure_box(r,boxsize,1,1,1);
struct rebx_extras* rebx = rebx_init(r);
/*
struct rebx_effect* rad_params = rebx_add(rebx, "radiation_forces");
double* c = rebx_add_param(rad_params, "c", REBX_TYPE_DOUBLE);
*c = 3.e8; // speed of light in SI units */
struct reb_particle* wd = reb_get_particle_by_hash(r, reb_hash("wd"));
int wd_index = reb_get_particle_index(wd);
/*
int* rad_source = rebx_add_param(&r->particles[wd_index], "radiation_source", REBX_TYPE_INT);
*rad_source = 1; */
struct rebx_effect* gr_params = rebx_add(rebx, "gr");
double* c_2 = rebx_add_param(gr_params, "c", REBX_TYPE_DOUBLE);
*c_2 = 3.e8;
int* source = rebx_add_param(&r->particles[wd_index], "gr_source", REBX_TYPE_INT);
*source = 1;
double wd_rad = wd->r;
double disk_rad_in = 10.0*wd_rad;
double disk_rad_out = 90.0*wd_rad;
printf("Inner disk radius is: %f AU\n", disk_rad_in/1.496e11);
printf("Outer disk radius is: %f AU\n", disk_rad_out/1.496e11);
int N_disk = 2000;
double disk_inc_low = 0.0;
double disk_inc_high = 0.0;
double e_low = 0.0;
double e_high = 0.0;
r->N_active = r->N;
double* add_beta;
while(r->N<N_disk + r->N_active){
struct reb_particle pt = {0};
double a = reb_random_uniform(disk_rad_in, disk_rad_out);
double e = reb_random_uniform(e_low, e_high);
double inc = reb_random_uniform(disk_inc_low, disk_inc_high);
double Omega = reb_random_uniform(0, 2.*M_PI);
double apsis = reb_random_uniform(0, 2.*M_PI);
double phi = reb_random_uniform(0.0, 2.*M_PI);
pt = reb_tools_orbit_to_particle(r->G, r->particles[wd_index], 0.0, a, e, inc, Omega, apsis, phi);
int N_count = r->N - r->N_active;
pt.hash = N_count + 8000;
reb_add(r, pt);
add_beta = rebx_add_param(&r->particles[N_count], "beta", REBX_TYPE_DOUBLE);
*add_beta = 0.01;
}
r->simulationarchive_interval = 6.32e6;
char sim_name[1000];
filename[strlen(filename) - 4] = 0;
sprintf(sim_name, "%s_months.bin", filename);
r->simulationarchive_filename = sim_name;
for (int i=0; i < r->N; i=i+1){
fprintf(fp2, "%u, %f, %f\n", r->particles[i].hash, r->particles[i].m, r->particles[i].r);
}
fclose(fp2);
reb_integrate(r, 1.6e8); // ~5 years
rebx_free(rebx);
}
double reb_random_rayleigh(double sigma){
double y = reb_random_uniform(0.,1.);
return sigma*sqrt(-2*log(y));
}
double reb_random_powerlaw(double min, double max, double slope){
double y = reb_random_uniform(0., 1.);
return pow( (pow(max,slope+1.)-pow(min,slope+1.))*y+pow(min,slope+1.), 1./(slope+1.));
}
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);
}