simulación de la interacción de los tres cuerpos

Simulacion de la interaccion de los tres cuerposC.F. Ariza ∗ D.Y. Jaimes ∗ and J.S. Mendez ∗

∗Universidad Nacional de Colombia, Facultad de ciencias, Departamento de Fısica

Programacion en introduccion a los metodos numericos

Un problema antıguo de la mecanica clasica es obtener las ecua-ciones de movimiento de tres cuerpos arbitrarios, sometidos a suinteraccion gravitacional, para esto se han hecho bastantes aproxi-maciones analiticas, sin algun resultado definitivo para describir elproblema. Este trabajo busca dar una solucion aproximada mediantemetodos numericos, especıficamente el de Runge-Kutta. Se utilizapython para obtener dichos resultados, ademas se simulan tres casosespecıficos; la interaccion arbitraria de tres cuerpos, la interaccionde los mismo cuerpos bajo distintas condiciones iniciales y por ultimouna aproximacion de como serıa el sistema solar

Python | VPython | Tres cuerpos | Simulacion | Metodo numerico

IntroduccionEn principio, las herramientas matematicas y fısicas para

describir el problema, son las leyes de Newton y las ecuacio-nes diferenciales, dado que se tienen ecuaciones diferencialesacopladas, no es sencillo desarrollar estas ecuaciones analıti-camente, por tal razon se busca una aproximacion numerica.A continuacion se da una breve revision de la fısica y la ma-tematica del problema.

Marco teoricoLas ecuaciones de Newton.Para analizar la interaccion seconsidera a n cuerpos en ℜ3 con posiciones en coordenadasgeneralizadas q1, q2, ..., qn ∈ ℜ3 masas m1,m2, ...,mi > 0. Co-mo se considera que la unica interaccion que se tiene entre loscuerpos es la gravitacional, se utiliza la segunda ley de new-ton para poder describir las interacciones entre cada uno delos cuerpos

miqi =∑

Fij i = 1, ..., n.

Entonces las interacciones entre la i-esima partıcula y la j-esi-ma estan dadas por

Fij = Gmimjqi − qjr2ij

donde rij = |qi − qj | [1]

esta es la parte fundamental a utilizar para construir lasinteracciones entre los n-cuerpos. Ecuaciones diferenciales or-dinarias de segundo orden. Para poder analizar el problemade manera adecuada, sin introducir divergencia alguna, se exi-ge que qi 6= qj , es decir, no se puede hacer la medicion de lainteraccion del cuerpo i-esimo es su sistema de referencia. Eneste trabajo se considera dos ejemplos. El primero con n = 3,i = 1, 2, 3 y m1 = m2 = m3, que es el tradicional problemade la interaccion de tres cuerpos. A partir de este, se extiendela interaccion a n = 11, i = 1, ..., 11 emulando el comporta-miento del sistema solar, tomando las masas de los respectivosplanetas adjuntos en la tabla 1.

Metodo de runge-Kutta.Uno de los metodos mas exactos pa-ra poder resolver numericamente un problemas de ecuacio-nes diferenciales y valores iniciales. Hay distintos ordenes delmetodo que surgen a partir del desarrollo en serie de taylor

de y(xn + h), tal y como lo muestra la ecuacion siguiente

y(xn+1) = y(xn + h) = y(xn) + hy′(xn)

+h2

2!y′′(xn) + ...+

hk+1

(k + 1)!yk+1(c),

donde c es un numero entre xnyxn + h. Ahora se presentael metodo de cuarto orden. Consiste en hallar las constantesadecuadas para que la formula

yn+1 = yn + ak1 + bk2 + ck3 + dk4,

en la cual

k1 = hf(xn, yn)

k2 = hf(xn + α1h, yn + β1k1)

k3 = hf(xn + α2h, yn + β2k1 + β3k2)

k4 = hf(xn + α3h, yn + β4k1 + β5k2 + β6k3)

coincide con un polinomio de Taylor de cuarto grado. Con loanterior se obtienen once ecuaciones con trece incognitas. Elconjunto de ecuaciones mas corriente es:

yn+1 = yn +1

6(k1 + 2k2 + 2k3 + k4),

k1 = hf (xn, yn)

k2 = hf

(

xn +1

2h.yn +

1

2k1

)

k3 = hf

(

xn +1

2h.yn +

1

2k2

)

k4 = hf

(

xn +1

2h.yn + k3

)

La pendiente es un promedio ponderado de pendientes, dondek1 es la pendiente al principio del intervalo, k2 es la pendienteen el punto medio del intervalo, usando k1 para determinar elvalor de y en el punto xn+h

2usando el mtodo de Euler. k3 es

otra vez la pendiente del punto medio, pero ahora usando k2para determinar el valor de y; k4 es la pendiente al final delintervalo, con el valor de y determinado por k3. Promediandolas cuatro pendientes, se le asigna mayor peso a las pendientesen el punto medio:

pendiente =k1 + 2k2 + 2k3 + k4

6.

Reserved for Publication Footnotes

www.pnas.org — — PNAS Issue Date Volume Issue Number 1–12

Esta forma del metodo de Runge-Kutta, es un metodo decuarto orden lo cual significa que el error por paso es del or-den de O(h5), mientras que el error total acumulado tiene elorden O(h4). Por lo tanto, la convergencia del metodo es delorden de O(h4), razon por la cual es usado en los metodoscomputacionales.

Programa implementado en PythonSe utilizo el lenguaje de programacion Python para desa-

rrollar el problema de los tres cuerpos, y tambien para poderobservar su comportamiento en algunos casos particulares,utilizando especialmente el modulo VPython, para visualizarlas simulacion mediante una animacion.

Para la realizacion del programa, nos centramos en laecuacion de la ley de gravitacion universal de Newton, la cualaplicada al i-esimo cuerpo se puede expresar como:

mi∗d2~qidt2

=n∑

j=1

Gmimj

r3ij(~qi−~qj) con j 6= i, para i entre [1, n]

[2]

Al despejar la aceleracion de la anterior ecuacion y hacien-

do el cambio de variable d~vidt

= d2 ~qidt2

, se puede expresar comoun sistema de ecuaciones:

d~vidt

=n∑

j=1

Gmj

r3ij(~qi − ~qj) [3]

d~qidt

= ~vi [4]

De este modo se tienen n sistemas de ecuaciones que repre-sentan el movimiento de los diferentes n cuerpos, pero comose puede observar, la forma de los n sistemas de ecuaciones esla misma, por lo tanto para la implementacion basta con to-mar el sistema anterior generalizado y aplicarlo en el metodonumerico escogido para la resolucion de un sistema de ecuacio-nes diferenciales, en este caso el metodo trabajado es Runge-Kutta.

Para incluir a (3) y (4) en el programa se necesita ex-presar a cada ecuacion como una funcion, cuyos parametrosindispensables son las variables que en las mismas ecuacionesse muestran.Al desarrollar el programa se busco que la version final fueraadaptable a diferentes casos, es decir que pudiera trabajar sinproblemas para n cuerpos en donde n ≥ 2, sin tener que recu-rrir a cambiar su estructura general, sino que se pudiera rea-lizarse solo con el cambio de los valores iniciales. Para esto seplanteo una estructura en las funciones realizadas tal que estasfueran generales y no particulares. Para cumplir con este re-querimiento primero se tuvo que tener en cuenta las variablesde las cuales depende el problema, como se observa en (3) y(4), estas variables son m, q, v y n, (masa, posicion, velocidady cantidad de cuerpos), por lo tanto la funcion Ruge-Kuttadebe recibir estas variables.

Explicacion del programa: parte uno, implementacion meto-do numerico.Para explicar de una manera mas clara el pro-grama se escogio el orden en que se ejecuta el mismo, y no el

orden en el que se encuentra la sintaxis. Como se observa enel anexo , el programa se dividio en dos secciones: 1) Defini-cion de funciones y 2) Cuerpo del programa. En la primeraseccion se definen las funciones con las que opera el programa,y en la segunda seccion se dan las condiciones iniciales, y seactualizan los valores de las posiciones y las velocidades.

El programa se comienza a ejecutar en la seccion Seccion 2.

En la seccion 2.1 se nombran y se definen las principa-les variables a utilizar. Como se dijo anteriormente se realizoun programa que solo requiere cambiar las condiciones ini-ciales para trabajar sistemas de cuerpos diferentes, para ellose utilizo una estructura de datos de Python conocida como”listas”para definir los valores de masa, posicion y velocidad.

Lo primero que se hizo fue definir una variable entera parael numero de cuerpos (nc) y con esta variable automaticamen-te se definieron los tamanos de las listas: masa (mc), posicioninicial (xic) y final (xfc), y , velocidad inicial (vic) y final (vfc),las cuales corresponden a las variables iniciales del sistema.Estas listas son muy similares a los vectores en C++, guardanlos datos en diferentes componentes de la lista, pero estos da-tos no se puede operar tomando la lista completa, sino que sedebe tomar componente a componte para poder alterar cadadato, lo que presenta problemas cuando se requiere multipli-car toda la lista por una misma constante, ya que se debehacer dato a dato y no una simple multiplicacion de una va-riable por la lista. De hecho multiplicar un entero por la listahace que el numero de componentes de la lista se multiplique,este hecho se utilizo para definir el tamano de las listas mc,xic, xfc, vic, vfc, el cual depende del numero de cuerpos aanalizar. Con esto variar el numero de cuerpos a analizar solodepende de cambiar el valor de nc, y agregar o quitar valoresiniciales a las componentes de las listas mc, xic, xfc, vic, vfcsegun corresponda.

La seccion 2.2, comprende la inicializacion de las varia-bles utilizadas, es decir mc, xic, xfc, vic para cada uno de loscuerpos que se deseen analizar. Cabe senalar que los valoresiniciales de cada cuerpo se le asigna una componente de ca-da lista; como las componentes de las listas comienzan desdecero entonces las componentes iran desde 0 a n-1 para los ncuerpos. Ej. para las n masas, la lista de la masa quedarıamc[0],mc[1],...,mc[n-1]. Para los valores de posicion y veloci-dad se trabaja con vectores de tres dimensiones. La estructuravector(,,) es proporcionada por el modulo de Vpython, dondecada componente representa una coordenada cartesiana. Porlo tanto las listas xic, xfc, vic, vfc todas sus componentes sonvectores, mientras que para mc sus componentes son escalares.

Luego de tener todos los valores iniciales, el programa sedirige al bucle, Seccion 2.4, en donde se hallan los valores fi-nales xfc, vfc, y se actualizan los valores iniciales xic, vic deposicion y velocidad (seccion 2.4.1). Para hallar los valoresfinales se llama la funcion rk4, la cual es la implementaciondel metodo Runge-Kutta de cuarto orden, con la que se solu-ciona el sistema de ecuaciones (3) y (4). Este proceso se repiteindefinidamente con el animo de poder visualizar el compor-tamiento en una animacion. En cada paso del bucle se hallauna posicion futura de cada uno de los elementos del sistema.Cada iteracion sucede en un periodo que define el valor ”dt”.

En la Seccion 1 se encuentran definidas las funciones uti-lizadas.

Funcion fv1(), esta funcion se define para realizar laecuacion (3), es decir hallar la velocidad futura de cada cuerpo

2 www.pnas.org — — Footline Author

en cada una de las iteraciones. Para esto utiliza como entradalos valores de posicion inicial (x), velocidad inicial (v), masa(m) y numero de cuerpos(n). Primero se definen dos valoresimportantes G y d, estos valores representan dos constantesimportantes para la ejecucion de la funcion fv1(), G es laconstante de gravitacion universal, y d es una constante querepresenta un distancia mınima entre los cuerpos analizadosque utiliza como limitador para evitar que la velocidad encon-trada de valores muy grandes, ya que, dada la forma de (3)cuando la distancia es cero la ecuacion no se puede ejecutar.Ademas como (3) es una relacion inversa cubica para valoresmuy pequenos, los valores de velocidad finales hallados serianmuy grandes, por lo tanto se decidio poner una distancia darbitraria, en la cual si los cuerpos analizados estan a unadistancia menor a d, la velocidad final no se modificara, esdecir, es como si el cuerpo no se acelerara mas a partir deesa distancia mınima d, todo esto para evitar inestabilidadesnumericas en la ejecucion del programa cuando los cuerposestan muy cerca, dadas por divisiones cercanas a cero. En lafuncion se realizan dos ciclos for(), el interno realiza la suma-toria de la ecuacion (3), y el for() externo hace que el procesose realice para cada uno de los cuerpos involucrados, con estocada vez que se llama a la funcion fv1() se halla la velocidadfutura de cada uno de los cuerpos presentes en el programaen un tiempo tf.

Funcion fx(), esta funcion desarrolla la ecuacion (4), fa-vorablemente solo depende del valor de la velocidad actual,por ellos su parametro de entrada es vic.

Funcion rk4(), en esta funcion se implementa el metodoRunge-Kutta para hallar los valores futuros de posicion y ve-locidad, para ello utiliza los paramentos, fv1, fx, xic, vic, tf, ti,mc, nc, en donde fv1 y fx, son las funciones que representanlas ecuaciones del sistema mostrado por (3) y (4); tambien sele ingresan los valores actuales de posicion, velocidad y tiem-po ( xic, vic, ti), y el tiempo en el cual se quiere hallar laposicion y velocidad final (tf), ademas se ingresan los valoresde masa y numero de cuerpos, ya que estos valores son uti-lizados por algunas de las otras funciones que son llamadasdesde rk4(). Cabe senalar que en la funcion rk4() recibe todoslos valores de todos los cuerpos utilizados una vez se llama ,dado que el parametro de entrada son las listas que tienen to-dos estos valores. Como se observa en la literatura, el metodoRunge-Kutta, utiliza cuatro veces las funciones del sistema deecuaciones para hallar los valores k1, k2, k3 y k4, y si es unsistema de ecuaciones los valores a encontrar serian:Para la funcion (4), fx():

k1v = h ∗ fx(t, x, v) [5]

k2x = h ∗ fx(t+ h/2, x+ k1x/2, v + k1v/2) [6]

k3x = h ∗ fx(t+ h/2, x+ k2x/2, v + k2v/2) [7]

k4x = h ∗ fx(t+ h, x+ k3x, v + k3v) [8]

Para la funcion (3), fv1():

k1v = h ∗ fx(t, x, v) [9]

k2v = h ∗ fx(t+ h/2, x+ k1x/2, v + k1v/2) [10]

k3v = h ∗ fx(t+ h/2, x+ k2x/2, v + k2v/2) [11]

k4v = h ∗ fx(t+ h, x+ k3x, v + k3v) [12]

Como se observa de las ecuaciones (5) a (13), las funcio-nes fv1(), y fx() deben multiplicarse por un valor h, y ademassus componentes varıan en funcion de kjx y kjv (para j entre

1 y 4), lo cual representa un problema para implementar enel codigo directamente ya que las funciones fv1(), fx(), y losobjetos xi, vi son listas, y estas no permiten operacion directaentre ellas,la unica forma de operar, es haciendolo mediantesus componentes. Para resolver este problema se implementa-ron la funciones operacion() y operacion2().

Funcion operacion(), esta funcion me permite encontrarlos valores de k1x, k2x, k3x, k4x, k1v, k2v,k3v y k4v, operandocomponente a componente cada una de las listas. Esta fun-cion devuelve cuatro valores xiv, viv, kjx, kjv (para j entre 1y 4); de los cuales los kjx y kjv son las constantes del metodoRunge-Kutta, y xiv, viv, son los nuevos valores que equivalen alas operaciones dentro de la funcion, por ejemplo en el caso de(11) la ecuacion se convertirıa k3v = h ∗ fx(t+ h/2, xiv, viv),ya que xiv = x + k2x/2 y viv = v + k2v/2 luego de emplearla funcion .operacion()”.

Funcion operacion2(),esta funcion se creo por el mis-mo problema anteriormente mencionado, pero esta funcionencuentra el valor futuro de posicion y velocidad xif, vif, quees el ultimo paso del metodo Runge-Kutta, es decir realiza lasiguiente operacion:

valorfinal = valorinicial +(k1 + 2,0 ∗ (k2 + k3) + k4)

6,0; [13]

Explicacion del programa: parte dos, Visualizacion Vpython.Se utilizo el modulo Vpython para visualizar los cuerpos quese quieran simular. Para esto, cada uno de los cuerpos se re-presento como una esfera. En la Seccion 2-3 se muestra comose define e inicializa los objetos se da la posicion la cual seigualo a las condiciones iniciales de la lista xic, tambien se elcolor de cada cuerpo y el tamano. Ademas tambien se definioque se trazara la trayectoria por donde se mueven los cuerpos.En la seccion 2.4.2 se actualiza la posicion en la que se visua-lizan los cuerpos, poniendo la posicion de cada esfera comoxfc[j] (donde j representa el j-esimo cuerpo).

ResultadosEn el apendice se muestra el codigo realizado para la si-

mulacion del problema, a continuacion, algunas imagenes quese tienen de la simulacion con Vpython

Interaccion gravitacional tres cuerpos: Para este sis-tema se tomaron tres cuerpos con masas (ma = 5,97 ×24)kg, (mv = 3,30× 24)kg, (mr = 4,86× 24)kg

Figura 1. Algunas tomas de la simulacion, interaccion de los tres cuerpos

Footline Author PNAS Issue Date Volume Issue Number 3

En principio para realizar la simulacion se utilizaron es-pecıficos valores iniciales, para poder dar un mejor enten-dimiento del proceso se presentan a continuacion los valoresutilizados. Para cada cuerpo se describen dos cantidades,la posicion inicial y la velocidad inicial. En primer lugar lascondiciones iniciales para la particula descrita mediante laesfera amarilla:

xa0= (51× 109, 0, 0)m va0

= (0,−29,0, 0)m

s

para el cuerpo descrito con el color verde las condicionesiniciales son:

xa0= (0, 57,9× 109, 0)m va0

= (−47,9, 0, 0)m

s

por ultimo el color rojo:

xa0= (0, 108,9× 109, 0)m va0

= (−35, 0, 0)m

s


Como se observa en la figuras [2,3], las trayectorias quesiguen las partıculas no siguen ninguna regularidad, cuan-do estan sometidas nada mas a las interacciones gravita-cionales sin ninguna consideracion, el sistema tiende a sercaotico, la figura [3] describe de manera contundente esterazonamiento


Sistema Solar: Para este caso se tomaron datos deRef. [4, 5], de cada uno de los planetas, para poder simularaproximadamente el sistema. Las condiciones iniciales develocidad y posicion del sistema se encuentran en el Anexo,en la Seccion 2-2; para este caso se tomaron las posicionesdel perihelio (pp) y la velocidad en perihelio (vp), paraası poder ver la forma elıptica de las orbitas ya que si setrabajaba con la velocidad media y la distancia media latrayectoria descrita seria circular. Ademas para ubicar conmayor precision los planetas se utilizo el angulo del perihe-lio (a) y la inclinacion orbital (i). Algunas capturas

Figura 4. sistema solar, planetas internos

Figura 5. sistema solar, completo a


Figura 6. sistema solar, completo b

Como se observa en las figuras correspondientes al sistemasolar, las distancias entre los planetas se realizaron a es-cala, pero el tamano de la esfera que se creo en Vpythonpara representar los planetas, no esta a escala con el ta-mano de los planetas, esto por razones de visualizacion enla simulacion. Ademas como se observa la orbita que des-cribe la luna es mucho mas grande de lo que deberıa ser,esto se debe a que si se hacıa a escala, esta orbita seria im-perceptible, para evitar esto, cuando se fijo la posicion dela esfera que correspondıa a la luna, se escalo la distanciaun factor de 30, pero esto solo en la parte de la visualiza-cion, dado que los datos de velocidad y posicion utilizadosdentro del programa si son los correspondientes. Esto sepuede observar en la seccion 2.4.2 del programa, el objeto”ball6.actualiza su posicion basado en un factor de escala,predefinido llamado es”.

Figura 7. sistema solar, movimiento del solo

Es interesante notar el hecho del movimiento del sol, da-do que se realizo la simulacion con el sistema de referenciaubicado en el centro del sol, y exigiendo que el sol tuvie-ra una velocidad inicial de cero. Basicamente el centro demasas, que estara muy cerca del sol, se encuentra en repo-so, pero el sol que en este caso es el sistema de referencia,

tiene una velocidad luego de iniciar la evolucion temporaldel sistema, proporcionado por las condiciones iniciales.

Figura 8. sistema solar, movimiento del solo

Caso particular interaccion tres cuerpos: Para estecaso, se colocaron condiciones iniciales muy particulares,las cuales fueron tomadas de Ref. [1, 6], en donde se toma-ron 3 masas iguales, m1 = m2 = m3 = 1; ademas de estolas condiciones iniciales tienen otra particularidad, sus ubi-caciones iniciales deben ser colineales, en este caso m3 estaentre m2 y m1. Y la rapidez inicial de la masa que esta en-tre las otras dos m3 debe ser la mitad de la rapidez inicialde las otras dos. La simuacion de este caso se observa en lasfiguras 9, 10, 11, para las cuales m1 corresponde a la esferaverde, m2 corresponde a la esfera roja y m3 corresponde ala esfera azul.Para este caso se utilizaron los siguientes valores iniciales:Cuerpo descrito por la esfera verde:

x10 = (0,97000436,−0,243087530, 0)m

v10 = 0,5 ∗ (0,93240737, 0,86473146, 0)m

s

Cuerpo descrito por la esfera roja:

x20 = (−0,97000436, 0,243087530, 0)m

v20 = 0,5 ∗ (0,93240737, 0,86473146, 0)m

s

Cuerpo descrito por la esfera azul:

x30 = (0,0, 0,0, 0,0)

v30 = −(0,93240737, 0,86473146, 0)m

s


Figura 9. Posicion inicial

Figura 10. Posicion intermedia

Figura 11. Trayectoria completa

ConclusionesPara la descripcion de sistemas que no tienen solucion

analıtica, se encuentra que python es una herramienta muyeficiente, dado que no se necesitan bastantes lineas de codigopara poder resolver el problema, a diferencia de otros com-piladores como C++. Tambien se encontro que a partir delestudio de los tres cuerpos se pudo producir la simulacionaproximada del sistema solar.

El metodo numerico Runge-Kutta, permite hacer un mo-delo con poca complejidad que muestra resultados satisfacto-rios, por lo tanto aunque es un metodo basico de iteraciontiene grandes alcances.

El metodo numerico presenta bastante sensibilidad a lasdivergencias de las funciones, por lo tanto en casos cuando loscuerpos se encuentran muy cerca entre sı, dada la forma de laecuacion (3) como el denominador se acerca a cero, los resul-tados presentados no son confiables. Ademas debido al arregloque se tuvo que hacer en la funcion para evitar la division porcero, en el cual por debajo de una distancia mınima la ace-leracion se obliga a cero, y como esa distancia se establecioarbitrariamente, los resultados pueden estar muy lejos de loreal, por lo tanto para estos casos el programa implementadono es confiable.

1. G. Bor, R. Montgomery, Poincare y el problema de n-cuerpos, Miscelanea Matematica

58 (2014) 83–102

2. D. G. Zill, Differential Equations with Modeling Applicationes, International Thomson

Editores

3. D. C. Heggie, The Classical Gravitational N- Body Problem, arXiv:astreo-

ph/0503600v2 11Aug2005

4. http://www.mundos-fantasticos.com/es/ciencia/universo/sistema-solar/mercurio/

5. http://www.astronoo.com/es/articulos/posiciones-de-los-planetas.html

6. http://homepages.math.uic.edu/ jan/mcs320s07/ProjectT wo/solbody.html


Appendix: ANEXOS

-*- coding: cp1252 -*-# 20 de Noviembre 2015# Movimiento tres cuerpos:generalizacion a n cuerpos mediante la implementacion de vectores en python# En esta version se simulara el comportamiento en el sistema solar.

import mathfrom math import *from visual import *

##############################################################################################################################################################################################################

#SECCION 1:#Definicion de funciones:

#------------------------------------------------------------------------------------------------------

# 1ra funcion: Defino segunda derivada de la (dv/dt), ecuaciOn de movimiento

def fv1(t,x,v,m,n): #Funcion que encuentra la velocidad final de cada cuerpo en tf, x es un#vector que tiene en sus components todas las posiciones de los# diferentes objetos, v las velocidades iniciales respectivas a cada# objeto, m las masas y n la cantidad de objetos

vec=vector(0,0,0)dxi=[vec]*n;G=-6.673884e-11d=5e7 #radio minimo en el cual la velocidad no aumentara mas

for i in range(0,n):for j in range(0,n):

if j!=i: #evita restar el mismo vectorrij=sqrt(dot(x[i]-x[j],x[i]-x[j]))if rij>d: #Si la distancia entre los dos cuerpos es menor a d,

#el incremento de la velocidad sera cero.dxi[i]=dxi[i]+G*m[j]*(x[i]-x[j])/pow(rij,3)

else :dxi[i]=dxi[i]

return dxi#------------------------------------------------------------------------------------------------------

# 2da funcion: Defino primera derivada de la (dx/dt), ecuacion de movimiento

def fx(v): #Funcion que da la Posicion del sistemareturn v

#------------------------------------------------------------------------------------------------------

# 3ra funcion: Operacion necesaria para hallar k1,k2,k3 y k4 del metodo Runge-Kutta

def operacion(kix,kiv,xio,vio,n,var,h): #Funcion que me realiza las operaciones del metodo#runge-kutta, ya que las entradas son listas y no#puedo manipularlas diectamente

vec=vector(0,0,0)xip=[vec]*n;vip=[vec]*n;kipx=[vec]*n;kipv=[vec]*n;for i in range (0,n):

kipx[i]=h*kix[i]kipv[i]=h*kiv[i]if var==1: #Operacion realizada para hallar k2 y k3

xip[i]=xio[i]+kipx[i]/2vip[i]=vio[i]+kipv[i]/2

else: #Operacion utilizada para hallar k4xip[i]=xio[i]+kipx[i]vip[i]=vio[i]+kipv[i]


return xip,vip,kipx,kipv#------------------------------------------------------------------------------------------------------

# 4ta funcion: Operacion necesaria para hallar los nuevos valores de velocidad y posicion (vf y xf)# en el metodo Ruge-kutta

def operacion2(k1,k2,k3,k4,xio2,n):vec=vector(0,0,0)xip2=[vec]*n;

for i in range(0,n):xip2[i]=xio2[i]+(k1[i]+2*(k2[i]+k3[i])+k4[i])/6.

return xip2#------------------------------------------------------------------------------------------------------

######################################################################################################## METODO RUNGE-KUTTA

def rk4(fv,fx,xi,vi,tf,ti,m,n): #xi, vi vectores con todas las posiciones y velocidades#iniciales de los diferentes cuerpos

var=1; #Variable utilizada en la funcion operacion, para definir la#actualizacion para los casos de k2 y k3

h=tf-ti

k1x=fx(vi)k1v=fv(ti,xi,vi,m,n)

xiv,viv,k1x,k1v=operacion(k1x,k1v,xi,vi,n,var,h)k2x=fx(viv)k2v=fv(ti+h/2.,xiv,viv,m,n)

xiv,viv,k2x,k2v=operacion(k2x,k2v,xi,vi,n,var,h)k3x=fx(viv)k3v=fv(ti+h/2.,xiv,viv,m,n)

var=0xiv,viv,k3x,k3v=operacion(k3x,k3v,xi,vi,n,var,h)k4x=fx(viv,)k4v=fv(ti+h,xiv,viv,m,n)

xiv,viv,k4x,k4v=operacion(k4x,k4v,xi,vi,n,var,h)

xiv=operacion2(k1x,k2x,k3x,k4x,xi,n)xf=xiv

viv=operacion2(k1v,k2v,k3v,k4v,vi,n)vf=viv

return xf,vf

##############################################################################################################################################################################################################

#SECCION 2:#CUERPO DEL PROGRAMA

#SECCION 2-1:#Nombramiento de variables

nc=11 #Numero de cuerpos

ni=1. #Numero de iteraciones en Ttot


Ttot=36000.dt=Ttot/ni #Cantidad de "tiempo" en que se actializara el sistemati=0.es=30. #Valor de escala para poder apreciar translacion de la lunaca=pi/180. #Conversion angulo a radianes

#Inicializacion de listas necesarias para el sistema, el numero de componentes de la lista la define nc

mc=[0]*nc #Lista de las masasxic=[0]*nc #Lista de la posicion inicialxfc=[0]*nc #Lista de la posicion finalvic=[0]*nc #Lista de la velocidad inicialvfc=[0]*nc #Lista de la velocidad final

#------------------------------------------------------------------------------------------------------#------------------------------------------------------------------------------------------------------

#SECCION 2-2:#Condiciones iniciales

#Inicializacion masas

mc[0]=1.989e30 #Masa Solmc[1]=3.302e23 #Masa Mercuriomc[2]=4.869e24 #Masa Venusmc[3]=5.9736e24 #Masa Tierramc[4]=6.4185e24 #Masa Martemc[5]=7.349e22 #Masa Lunamc[6]=1.899e27 #Masa Jupitermc[7]=5.688e26 #Masa Saturnomc[8]=8.686e25 #Masa Uranomc[9]=1.024e26 #Masa Neptunomc[10]=1.25e22 #Masa Pluton#------------------------------------------------------------------------------------------------------

#Inicializacion posiciones iniciales y finales

#A cada componente de la lista xic y vic se inicializa con el vector posicion inicial y velocidad#inicial respectivamente para evitar problemas la posicion final se iguala a la posicion inicial antes#de comenzar el programa

#Cuerpo 1 Solvic[0]=vector(0.,0.,0.)xic[0]=vector(0.,0.,0.)xfc[0]=xic[0]

#Cuerpo 2 Mercurio

vp=59.25e3 #velocidad periheliopp=46.00e9 #posicion perihelioa=29.12478*ca #angulo del perihelioi=7.00487*cavic[1]=vector(-vp*sin(a),vp*cos(a),0)xic[1]=vector(pp*cos(a)*cos(i),pp*sin(a)*cos(i),pp*sin(i))xfc[1]=xic[1]

#cuerpo 3 Venusvp=35.26e3 #velocidad periheliopp=107.48e9 #posicion perihelioa=54.8522*cai=3.39*cavic[2]=vector(-vp*sin(a),vp*cos(a),0)xic[2]=vector(pp*cos(a)*cos(i),pp*sin(a)*cos(i),pp*sin(i))xfc[2]=xic[2]

#cuerpo4 Tierra


vp=30.288e3 #velocidad periheliopp=147.10e9 #posicion perihelioa=282.94*cai=0.00*cavic[3]=vector(-vp*sin(a),vp*cos(a),0)xic[3]=vector(pp*cos(a)*cos(i),pp*sin(a)*cos(i),pp*sin(i))xfc[3]=xic[3]

#cuerpo5 Martevp=26.614e3 #velocidad periheliopp=206.67e9 #posicion perihelioa=286.46*cai=1.85*cavic[4]=vector(-vp*sin(a),vp*cos(a),0)xic[4]=vector(pp*cos(a)*cos(i),pp*sin(a)*cos(i),pp*sin(i))xfc[4]=xic[4]

#cuerpo6 Luna

vp=30.288e3-1000 #velocidad periheliopp=147.10e9+3.84e8 #posicion perihelioa=282.94*cai=0.00*cavic[5]=vector(-vp*sin(a),vp*cos(a),0)xic[5]=vector(pp*cos(a)*cos(i),pp*sin(a)*cos(i),pp*sin(i))xfc[5]=xic[5]

#cuerpo7 Jupitervp=13.73e3 #velocidad periheliopp=740.57e9 #posicion perihelioa=274.19*cai=1.3*cavic[6]=vector(-vp*sin(a),vp*cos(a),0)xic[6]=vector(pp*cos(a)*cos(i),pp*sin(a)*cos(i),pp*sin(i))xfc[6]=xic[4]

#cuerpo 8 Saturnovp=10.195e3 #velocidad periheliopp=1353.6e9 #posicion perihelioa=339.39*cai=2.48*cavic[7]=vector(-vp*sin(a),vp*cos(a),0)xic[7]=vector(pp*cos(a)*cos(i),pp*sin(a)*cos(i),pp*sin(i))xfc[7]=xic[7]

#cuerpo 9 Uranovp=7.135e3 #velocidad periheliopp=2748.9e9 #posicion perihelioa=96.73*cai=0.769*cavic[8]=vector(-vp*sin(a),vp*cos(a),0)xic[8]=vector(pp*cos(a)*cos(i),pp*sin(a)*cos(i),pp*sin(i))xfc[8]=xic[8]

#cuerpo 10 Neptunovp=5.48e3 #velocidad periheliopp=4452.9e9 #posicion perihelioa=272.449*cai=1.769*cavic[9]=vector(-vp*sin(a),vp*cos(a),0)xic[9]=vector(pp*cos(a)*cos(i),pp*sin(a)*cos(i),pp*sin(i))xfc[9]=xic[9]

#cuerpo 11 Plutonvp=6.2618e3 #velocidad periheliopp=4438.6e9 #posicion perihelioa=113.76*ca


i=17.15*cavic[10]=vector(-vp*sin(a),vp*cos(a),0)xic[10]=vector(pp*cos(a)*cos(i),pp*sin(a)*cos(i),pp*sin(i))xfc[10]=xic[10]

#------------------------------------------------------------------------------------------------------#------------------------------------------------------------------------------------------------------

#SECCION 2-3#Definicion de los cuerpos que se visualizaron#A los cuales se les adjudica posicion inicial igual a los vectores de posicion iniciales definidos# anteriormente

ball1 = sphere(pos=xic[0],radius=5e9, color=color.yellow)ball1.trail = curve(color=ball1.color)

ball2 = sphere(pos=xic[1],radius=3e9, color=(0.5,0.5,0.5))ball2.trail = curve(color=ball2.color)

ball3 = sphere(pos=xic[2],radius=3e9, color=color.orange)ball3.trail = curve(color=ball3.color)

ball4 = sphere(pos=xic[3],radius=3e9, color=color.blue)ball4.trail = curve(color=ball4.color)

ball5 = sphere(pos=xic[4],radius=3e9, color=(0.5,0.2,0.))ball5.trail = curve(color=ball5.color)------------------------------------------------------------------------------------------#La posicion inicial de este cuerpo (LUNA) es escaladaa para poder visualizar

ball6 = sphere(pos=(xic[5]-xic[3])*es+xic[3],radius=1e9, color=(0.3,0.3,0.3))ball6.trail = curve(color=ball6.color)------------------------------------------------------------------------------------------



ball9 = sphere(pos=xic[7],radius=4e9, color=(1,1,1))ball9.trail = curve(color=ball9.color)

ball10 = sphere(pos=xic[9],radius=4e9, color=(0.,0.3,1.))ball10.trail = curve(color=ball10.color)


#------------------------------------------------------------------------------------------------------#------------------------------------------------------------------------------------------------------

#SECCION 2-4#BLUCLE

n=0

while True: #El bucle se ejecutara siempre

#SECCION 2-4-1#Calculo valores finales de posicion y velocidad de cada cuerpon=n+1 #Contador usado como opcion auxiliar para parar el programa,

# (se debe poner como condicion ej: While n<1000)rate(1e8)

tf=ti+dt


xfc,vfc=rk4(fv1,fx,xic,vic,tf,ti,mc,nc) #Llama la funcion Ruge-Kutta para hallar los valores#finales de posicion y velociadad

#Se actualizan los valores iniciales de velocidad, posicion y tiempovic=vfcxic=xfcti=tf

#------------------------------------------------------------------------------------------------------

#SECCION 2-4-2#Actualizacion final de los cuerpos para visualizar nueva posicion

ball1.pos = xfc[0]ball1.trail.append(pos=ball1.pos)

ball2.pos = xfc[1]ball2.trail.append(pos=ball2.pos,retain=1000)




pl=(xfc[5]-xfc[3])*es+xfc[3]ball6.pos = plball6.trail.append(pos=ball6.pos,retain=400) #,retain=10000






#Fin del bucle#------------------------------------------------------------------------------------------------------#------------------------------------------------------------------------------------------------------

#Fin del programa##############################################################################################################################################################################################################


simulación de la interacción de los tres cuerpos

Documents