REBOUND

¿Qué es?
Es un código o integrador de N-cuerpos, multipropósito que está disponible
gratuitamente bajo una licencia de código abierto. Fue diseñado para la dinámica de
colisión, como los anillos planetarios, pero también puede resolver el clásico problema del
N-cuerpos, es decir, puede integrar el movimiento de partículas bajo la influencia de la gravedad.
Las partículas pueden representar estrellas, planetas, lunas, anillos o partículas de polvo. Es
altamente modular y muy flexible, se puede personalizar fácilmente para trabajar y
resolver con precisión y eficiencia una amplia variedad de problemas en astrofísica u otras
áreas.
Este código y sus precursores ya se han utilizado en una gran variedad de publicaciones.
actualmente no existe un código disponible públicamente para la dinámica de colisión
capaz de resolver problemas de N-cuerpos.

Estructura
Está escrito completamente en C, cumple con el estándar ISO C99. Se compila y se
ejecuta en cualquier plataforma informática moderna que admita el estándar POSIX, como
Linux, Unix y Mac OSX. En su forma más simple, no requiere bibliotecas externas para
compilar.
Para obtener visualizaciones 3D interactivas y en tiempo real es necesario instalar las
bibliotecas OpenGL y GLUT. Se requiere LIBPNG para guardar automáticamente las
capturas de pantalla. El código usa OpenMP para la paralelización en sistemas de memoria
compartida y en sistemas de memoria distribuida es necesario instalar la biblioteca MPI
para la paralelización. REBOUND también admite paralelización híbrida utilizando
simultáneamente OpenMP y MPI.

Descarga
El código fuente está alojado en la plataforma GitHub, permite mantenerse
actualizado con futuras actualizaciones. Una vez descargado y extraído, uno encuentra
cinco directorios principales.
El código fuente completo se puede encontrar en el directorio src/ en el cual nada en este
directorio necesita ser modificado.
Se proporcionan muchos ejemplos en el directorio examples/ Cada ejemplo viene con un
archivo de problema y un Makefile. Para compilar uno de estos, se debe ejecutar el
comando make en el directorio correspondiente.
La documentación del código fuente se puede generar en el directorio doc/ Para actualizar
la documentación con la selección de módulo actual, uno simplemente puede ejecutar
make doc en cualquier directorio con un archivo MAKE.
En el directorio tests/ se encuentran pruebas de precisión y escala, así como pruebas
unitarias simples.
El problem/ directorio es el lugar para crear nuevos problemas. Contiene una plantilla
para eso. Cualquiera de los ejemplos también se puede utilizar como punto de partida
para nuevos problemas.

Compilación
1) El archivo MAKE configura variables de entorno que controlan opciones como, la
elección del compilador, la optimización del código, la visualización en tiempo real y la
paralelización.
2) Establece enlaces simbólicos, especificando los módulos elegidos para este problema.
3) Llama al archivo MAKE en el directorio src / que compila y vincula todos los archivos
fuente.
4) El archivo binario se copia en el directorio del problema, desde donde se puede
ejecutar.

Módulos
Es extremadamente modular. El usuario tiene la opción de elegir entre diferentes
módulos de gravedad, colisión, frontera e integración. También es posible implementar
módulos completamente nuevos con un mínimo esfuerzo.
Esta configuración permite al usuario trabajar en múltiples proyectos al mismo tiempo
utilizando diferentes módulos. Al cambiar a otro problema, no se debe configurar nada y
el problema se puede compilar simplemente escribiendo make en el directorio
correspondiente.
Para implementar un nuevo módulo, se puede copiar un módulo existente en el directorio
del problema, modificarlo y cambiar el enlace en el archivo MAKE según corresponda.

Dominio computacional
El dominio computacional consiste en una colección de cajas cúbicas. Se puede
usar cualquier número entero de cajas en cada dirección. Esto permite que las cajas
alargadas se construyan a partir de cajas cúbicas. Cuando se usa un árbol para la detección
de gravedad o colisión, hay una estructura de árbol por cada caja raíz.

Condiciones de frontera
 REBOUND viene con tres condiciones de frontera diferentes. Los límites abiertos
(limits_open.c) eliminan cada partícula de la simulación que abandona el dominio
computacional. Las condiciones de frontera periódicas (limits_periodic.c) se implementan
con cuadros fantasma. Se puede usar cualquier cantidad de cajas fantasma en cada
dirección. Las condiciones de frontera de corte periódico (limits_shear.c) se pueden usar
para simular una hoja de corte.

Integradores
Los integradores numéricos son algoritmos que pueden usarse para resolver
ecuaciones de movimiento, ecuaciones diferenciales. Se han implementado varios
integradores diferentes en REBOUND, todos estos integradores son precisos y
simplécticos de segundo orden, a excepción del IAS15. Además todos los integradores
siguen el esquema Drift-Kick-Drift (DKD) que es comúnmente utilizado.

Leap-frog
Leap-frog es un integrador preciso y simpléctico de segundo orden para cuadros
no giratorios. El hamiltoniano se divide en la parte cinética  y la parte
potencial H  2  = Φ ( x ). Los subpasos drift y kick son pasos de Euler. Primero se avanzan las
posiciones de todas las partículas durante medio paso de tiempo mientras se mantienen
las velocidades fijas. Luego, las velocidades avanzan durante un paso de tiempo mientras
se mantienen las posiciones fijas. En el último subpaso, las velocidades vuelven a avanzar
durante medio paso.

IAS15
IAS15 es un integrador de 15° orden específicamente ajustado para alta precisión
en dinámica gravitacional.
El integrador se basa en la conocida cuadratura de Gauss-Radau utilizada por primera vez
para las integraciones del Sistema Solar. El algoritmo puede manejar encuentros cercanos
y órbitas de alta excentricidad. Los errores sistemáticos se mantienen muy por debajo de
la precisión de la máquina.

WHFast 
Es una implementación rápida y precisa de un integrador simpléctico Wisdom-
Holman para integraciones de órbita a largo plazo de sistemas planetarios.
Asegura la estabilidad numérica de las transformaciones de coordenadas hacia y desde
las coordenadas de Jacobi. Permite calcular eficientemente indicadores de caos
ampliamente utilizados.
Recientemente se implementó WHFastHelio, utilizando coordenadas heliocéntricas que
son más adecuadas para sistemas en los que pueden ocurrir encuentros cercanos.

SEI
 La hoja de corte es un modelo de sistema dinámico que se utiliza para estudiar la
dinámica a pequeña escala de los discos astrofísicos.
El integrador es exacto cuando no hay fuerzas a pequeña escala, como las fuerzas
gravitatorias mutuas entre las partículas del disco. 

Gravedad
Está equipado con dos módulos de (auto) gravedad. Un módulo de gravedad
calcula exactamente o aproximadamente la aceleración en cada partícula. Para una
partícula con índice i esto está dado por:

donde G es la constante gravitacional, m  j la masa de la partícula j y r  ji la distancia

relativa entre las partículas j e i. El parámetro de ablandamiento gravitacional b
está predeterminado en cero. La variable Nactive especifica el número de partículas masivas
en la simulación. Partículas con un índice igual o mayor que N son tratados como
partículas de prueba. Por defecto, se supone que todas las partículas tienen masa y
contribuyen a la suma en la ecuación.

Suma directa
Se implementa en gravity_direct.c. El módulo de suma directa calcula la ecuación
anterior directamente. Si hay N partículas masivas y N partículas en total, el rendimiento
se escala.
La suma directa solo es eficiente con pocas partículas activas; típicamente N  activo ≲ 10 2.

Octree
Para Implementar dicho algoritmo se utiliza el módulo gravity_tree.c.
Es la estructura jerárquica que se realiza utilizando un árbol tridimensional en base al
algoritmo Barnes & Hut, algoritmo para aproximar la ecuación de la aceleración de cada
partícula, que puede reducir drásticamente el tiempo de cálculo. En base a una idea
sencilla, las partículas distantes contribuyen a la fuerza gravitacional menos que las
cercanas.
Cada nodo representa una celda cúbica que puede tener hasta ocho subceldas con la
mitad del tamaño. El nodo raíz del árbol contiene todas las partículas, mientras que los
nodos de las hojas contienen exactamente una partícula.
Ilustración de los árboles esenciales que necesita la caja raíz 4.

Colisiones
 Admite varios módulos diferentes para la detección de colisiones, todos estos
buscan colisiones solo aproximadamente, podrían perderse algunas de las colisiones o
detectar una colisión donde en realidad no la hay. Esto se debe a que las trayectorias de
partículas curvas se aproximan mediante líneas rectas o las partículas deben superponerse
para colisionar.
Se utiliza un modelo de colisión de esfera dura antideslizante. Las colisiones individuales
se resuelven utilizando el impulso y la conservación de energía. Para modelar colisiones
inelásticas se debe especificar un coeficiente de restitución normal dependiente de la
velocidad. La velocidad relativa después de una colisión viene dada por

donde v  n y v  t son las velocidades normales y tangenciales relativas antes de la colisión.
Diferentes algoritmos de detección de colisión. Izquierda: las trayectorias de partículas
curvas se aproximan mediante líneas rectas. Derecha: las trayectorias no son
aproximadas, las partículas solo chocan cuando se superponen.

Búsqueda directa de vecino más cercano

Es el módulo de colisión más simple en REBOUND. Se implementa en
collisions_direct.c, En este módulo, se detecta una colisión cada vez que dos partículas se
superponen al final del paso de tiempo DKD, es decir, en el medio del subpaso de deriva,
donde las posiciones y las velocidades se sincronizan en el tiempo.
Cada colisión individual se resuelve luego de verificar que las partículas se acercan entre
sí. Cada par de partículas se verifica una vez por cada paso de tiempo. Similar al método
de suma directa para la gravedad, esto solo es útil para un pequeño número de partículas.

Octree
El módulo collisions_tree.c implementa la búsqueda de vecino más cercano a partir
del Octree. Está paralelo con OpenMP y MPI. Se puede usar junto con cualquier módulo
de gravedad, pero cuando ambos módulos de árbol gravity_tree.c y collisions_tree.c se
usan simultáneamente, solo se necesita una estructura de árbol.

Algoritmo de barrido plano

Se tienen dos módulos de detección de colisión basados en un algoritmo de
barrido plano en collisions_sweep.c y collisions_sweepphi.c. El algoritmo de barrido de
plano utiliza un plano conceptual que se mueve a lo largo de una dimensión. El barrido se
realiza a lo largo de la dirección x o a lo largo del ángulo azimutal φ. El barrido en
la dirección x también se puede utilizar en la hoja de corte. El barrido en la dirección φ es
útil para anillos estrechos en simulaciones globales.
El plano está intersectando las trayectorias de las partículas 5 y 7.
Los experimentos han demostrado que el algoritmo de barrido plano es más eficiente que
una búsqueda de vecino más cercano en muchos órdenes de magnitud para sistemas de
baja dimensión.

Problemas de prueba
Energía y conservación del momento en colisiones.

En una caja de simulación no giratoria con límites periódicos y partículas de

colisión no gravitacionales, probaron tanto la conservación de la energía como la del
momentum. Usando un coeficiente de restitución unitario, colisiones perfectamente
elásticas.
Para todos los algoritmos de detección de colisiones el momentum total y la energía se
conservan hasta la precisión de la máquina.

Integración a largo plazo del sistema solar

Para probar el comportamiento a largo plazo de la implementación del integrador

Wisdom-Holman, se integró el Sistema Solar exterior durante 200 millones de años.
Utilizando las condiciones iniciales con 4 planetas masivos y Plutón como partícula de
prueba. El módulo de suma directa fue utilizado para calcular la gravedad propia. Con un
intervalo de tiempo de 40 días y un tiempo de integración de 200 Millones de años, el
tiempo de ejecución total en una CPU fue inferior a 2 h.

Grafica del perihelio de Plutón en función del tiempo. Se puede ver claramente dos
frecuencias de libración distintas con escalas de tiempo de 3.8 Myr y 34 Myr
respectivamente.

Prueba de Escalado

Se midió la escala de REBOUND y la eficiencia de la paralelización. Los parámetros

de simulación se han elegido para parecerse a los de una simulación típica del anillo A de
Saturno con una unidad de profundidad óptica de orden y una escala de tiempo de
colisión muy inferior a una órbita.

Pruebas de escala fuerte y débil utilizando una configuración de hoja de corte con los
módulos gravity_tree.c y collisions_tree.c.

Los resultados muestran que podemos utilizar completamente 64 núcleos de

procesadores con un millón de partículas. El tamaño del problema solo está limitado por
el número total de procesadores disponibles.