Simulación gravitatoria de la Tierra y el Super Júpiter

Introducción

En este proyecto, desarrollaremos una simulación gravitacional utilizando Python, que muestra la interacción entre la Tierra y un hipotético "Super Júpiter", un planeta con 500 veces la masa de Júpiter. Esta simulación tiene como objetivo demostrar el impacto de un cuerpo tan masivo sobre el movimiento de la Tierra, considerando las inmensas fuerzas gravitacionales en juego. Este proyecto es adecuado para estudiantes y aficionados apasionados por la física, la astronomía y las simulaciones computacionales. Para lograr esto, emplearemos bibliotecas de Python como NumPy para cálculos numéricos y Matplotlib para visualizar los movimientos dinámicos de los planetas.

👀 Vista previa

🎯 Tareas

En este proyecto, aprenderá:

• Cómo entender y aplicar la Ley de Gravitación Universal de Newton para modelar la interacción entre cuerpos celestes.
• Cómo utilizar la programación de Python para crear un modelo computacional de un sistema gravitacional.
• Cómo emplear la biblioteca NumPy para cálculos numéricos eficientes en Python.
• Cómo simular la mecánica orbital de la Tierra en presencia de un "Super Júpiter" con 500 veces la masa de Júpiter.
• Cómo analizar e interpretar los resultados de la simulación para comprender el impacto de los cuerpos celestes masivos en la dinámica orbital.
• Cómo implementar Matplotlib para crear representaciones visuales de la simulación, mostrando las trayectorias orbitales y las posiciones relativas de los planetas.
• Cómo explorar los conceptos de fuerza, masa y aceleración en un contexto cósmico.
• Cómo ajustar los parámetros de simulación como masa, distancia y pasos de tiempo para diferentes escenarios.
• Cómo desarrollar habilidades en la depuración y optimización del código de Python para cálculos científicos.

🏆 Logros

Después de completar este proyecto, podrá:

• Aplicar los principios fundamentales de la física, específicamente la Ley de Gravitación Universal de Newton, en un contexto práctico y computacional.
• Crear y ejecutar una simulación basada en física utilizando Python.
• Demostrar la competencia en el uso de NumPy para manejar cálculos numéricos a gran escala de manera eficiente.
• Visualizar datos y simulaciones complejas utilizando Matplotlib, mejorando la interpretabilidad de los resultados científicos.
• Comprender la dinámica del movimiento planetario y los efectos de las fuerzas gravitacionales de los cuerpos masivos.
• Analizar e interpretar los resultados de la simulación para extraer conclusiones significativas sobre la mecánica celeste.
• Ajustar y experimentar con los parámetros de simulación, lo que conduce a una comprensión más profunda de la mecánica orbital.
• Mostrar habilidades mejoradas en la resolución de problemas y la depuración en un entorno de programación, particularmente en el contexto del cálculo científico.
• Demostrar un conocimiento básico de cómo las fuerzas gravitacionales configuran el movimiento de los cuerpos celestes, pavimentando el camino para una exploración ulterior en astrofísica y modelado computacional.

Configuración del entorno

Primero, debemos configurar nuestros archivos de proyecto e importar las bibliotecas necesarias.

Crea un archivo de Python llamado simulation.py:

touch ~/project/simulation.py

Luego importa las siguientes bibliotecas:

## Importando las bibliotecas necesarias
from typing import Tuple
import numpy as np
import pylab as py
import matplotlib.pyplot as plt
from matplotlib import animation
from matplotlib.lines import Line2D
from tqdm import trange

En este primer paso del proyecto de simulación gravitacional, se importan varias bibliotecas importantes de Python para configurar el entorno de nuestra simulación:

1. typing: Específicamente, se importa Tuple del módulo typing. Esto se utiliza para la indicación de tipos en Python, lo que ayuda con la legibilidad y la depuración del código. Permite especificar qué tipos de valores pueden agruparse en una tupla, lo que garantiza la consistencia y la claridad en las definiciones de funciones.
2. numpy: La biblioteca numpy, importada como np, es un paquete fundamental para el cálculo científico en Python. Proporciona soporte para matrices y arreglos multidimensionales de gran tamaño, junto con una amplia colección de funciones matemáticas de alto nivel para operar sobre estos arreglos. Es fundamental para manejar los cálculos numéricos en la simulación.
3. pylab: Importado como py, pylab es un módulo en Matplotlib que se instala junto con Matplotlib. Proporciona una interfaz similar a MATLAB, particularmente útil para cálculos y trazados interactivos. Sin embargo, generalmente se desaconseja su uso a favor de la importación explícita de matplotlib.pyplot y numpy.
4. matplotlib.pyplot: Este módulo, importado como plt, se utiliza para crear visualizaciones estáticas, animadas e interactivas en Python. Es un aspecto central de este proyecto para trazar las trayectorias de los cuerpos celestes.
5. matplotlib.animation: Este submódulo de Matplotlib proporciona la funcionalidad para crear animaciones. Es esencial para visualizar el movimiento dinámico de los planetas en la simulación gravitacional.
6. matplotlib.lines.Line2D: Esta clase de la biblioteca Matplotlib se utiliza para crear objetos de línea que se pueden dibujar en los trazados. Es útil para trazados más detallados o personalizados en la simulación.
7. tqdm.trange: trange del módulo tqdm es una variante de la función range de Python con un medidor de progreso integrado. Es útil para mostrar el progreso de los bucles en la simulación, especialmente cuando se tratan con cálculos extensos.

Al importar estas bibliotecas y módulos, establecemos las bases para los cálculos numéricos complejos y las visualizaciones requeridas en el proyecto de simulación gravitacional. Esta configuración es fundamental para los pasos subsiguientes donde se implementará la física y la lógica de animación reales.

Definiendo constantes

Define las constantes que se utilizarán en nuestra simulación. Esto incluye la constante gravitacional, las unidades astronómicas y las masas normalizadas de la Tierra, Júpiter y el Sol.

## Constantes
G = 6.673e-11                 ## Constante gravitacional
AU = 1.496e11                 ## Unidad astronómica en km
YEAR = 365*24*60*60.0         ## Segundos en un año
MM = 6e24                     ## Normalizando masa
ME = 6e24/MM                  ## Masa normalizada de la Tierra
MS = 2e30/MM                  ## Masa normalizada del Sol
MJ = 500*1.9e27/MM            ## Masa normalizada de Júpiter
GG = (MM*G*YEAR**2)/(AU**3)   ## Constante gravitacional para la simulación

En este paso, definimos varias constantes esenciales para la simulación gravitacional. Estas constantes son fundamentales para modelar con precisión la mecánica celeste y las interacciones gravitacionales en la simulación:

1. Constante gravitacional (G): Establecida en 6.673e-11 (en unidades SI), esta constante es crucial en la ley de gravitación universal de Newton. Representa la fuerza de gravedad y se utiliza para calcular la fuerza gravitacional entre dos masas.
2. Unidad astronómica (AU): Definida como 1.496e11 kilómetros, representa la distancia promedio de la Tierra al Sol. Esta unidad se utiliza para expresar las distancias dentro del sistema solar de manera más manejable.
3. Año (YEAR): Calculado como 365*24*60*60.0, representa el número de segundos en un año. Esto se utiliza para convertir cálculos relacionados con el tiempo a años, una unidad de tiempo más intuitiva para simulaciones astronómicas.
4. Normalizando masa (MM): Establecida en 6e24, este valor se utiliza como masa de referencia para normalizar otras masas en la simulación. Es aproximadamente equivalente a la masa de la Tierra.
5. Masa normalizada de la Tierra (ME): Calculada como 6e24/MM, representa la masa de la Tierra en unidades normalizadas. Es esencialmente establecida en 1, ya que la masa de normalización (MM) se basa en la masa de la Tierra.
6. Masa normalizada del Sol (MS): Establecida en 2e30/MM, representa la masa del Sol en unidades normalizadas. La masa del Sol es un factor crítico en la simulación de la atracción gravitatoria sobre los planetas.
7. Masa normalizada de Júpiter (MJ): Unicamene, en esta simulación, la masa de Júpiter se amplifica a 500*1.9e27/MM para representar un escenario de "Super Júpiter". Esta masa significativamente más grande demostrará el impacto de un planeta mucho más masivo en la órbita de la Tierra.
8. Constante gravitacional para la simulación (GG): Esta es la constante gravitacional ajustada para la escala y las unidades de la simulación, calculada como (MM*G*YEAR**2)/(AU**3). Ajusta la constante gravitacional del mundo real a las unidades normalizadas utilizadas en la simulación.

Al definir estas constantes, contamos con los parámetros necesarios para simular con precisión las fuerzas gravitacionales y los movimientos de los cuerpos celestes como la Tierra y este hipotético "Super Júpiter". Este paso es vital para garantizar que los cálculos de la simulación reflejen la dinámica astronómica real. Al mismo tiempo, puedes modificar estas constantes según desees para observar diferentes resultados al final.

Creando la función de fuerza gravitatoria

Ahora, definiremos una función para calcular la fuerza gravitatoria entre dos cuerpos. Esta función será crucial para determinar el movimiento de los planetas.

## Función para calcular la fuerza gravitatoria
def gravitational_force(m1: float, m2: float, r: np.ndarray) -> np.ndarray:
    """
    Calcula la fuerza gravitatoria entre dos cuerpos.
    """
    F_mag = GG * m1 * m2 / (np.linalg.norm(r) + 1e-20)**2
    theta = np.arctan2(np.abs(r[1]), np.abs(r[0]) + 1e-20)
    F = F_mag * np.array([np.cos(theta), np.sin(theta)])
    F *= -np.sign(r)
    return F

En este paso, definimos una función gravitational_force para calcular la fuerza gravitatoria entre dos cuerpos celestes. Esta función es un componente crítico de la simulación, ya que aplica la ley de gravitación universal de Newton para determinar la fuerza ejercida entre cualesquiera dos masas en el espacio. Aquí está una descomposición de la función:

1. Definición de la función: La función gravitational_force toma tres argumentos:
   • m1 y m2: Las masas de los dos cuerpos (valores de tipo float).
   • r: Un arreglo de NumPy que representa el vector de desplazamiento entre los dos cuerpos.
2. Cálculo de la magnitud de la fuerza (F_mag):
   • La función primero calcula la magnitud de la fuerza gravitatoria utilizando la fórmula F_mag = GG * m1 * m2 / (np.linalg.norm(r) + 1e-20)**2.
   • GG es la constante gravitatoria para la simulación.
   • np.linalg.norm(r) calcula la distancia euclidiana entre los dos cuerpos. Se agrega un número pequeño (1e-20) para evitar la división por cero.
3. Determinación de la dirección (theta y F):
   • El ángulo theta se calcula utilizando np.arctan2 para encontrar el ángulo del vector de fuerza en coordenadas polares. Una vez más, se agrega un número pequeño (1e-20) al denominador para evitar la división por cero cuando el desplazamiento en la dirección x (r[0]) es cero.
   • El vector de fuerza F se calcula luego utilizando F_mag y el ángulo theta, con componentes a lo largo de los ejes x e y ([np.cos(theta), np.sin(theta)]).
4. Ajuste de la dirección de la fuerza:
   • El vector de fuerza F se multiplica por -np.sign(r) para asegurar que la fuerza siempre sea atractiva (apuntando hacia el otro cuerpo) de acuerdo con las leyes de la gravedad.
5. Devolución del vector de fuerza:
   • Finalmente, la función devuelve el vector de fuerza gravitatoria F.

Al implementar esta función, aprendemos cómo aplicar leyes físicas en un entorno computacional. La función es esencial para calcular las interacciones gravitatorias entre la Tierra y el "Super Júpiter" en la simulación, lo que influirá en sus respectivas trayectorias.

Implementando el resolutor RK4

Implementa el resolutor de cuarto orden de Runge-Kutta para resolver las ecuaciones diferenciales del movimiento. Este método se utiliza ampliamente para resolver ecuaciones diferenciales ordinarias numéricamente.

## Resolutor RK4
def RK4Solver(t: float, r: np.ndarray, v: np.ndarray, h: float, planet: str, r_other: np.ndarray, v_other: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
    """
    Resolutor de cuarto orden de Runge-Kutta para el movimiento planetario.
    """
    def dr_dt(v: np.ndarray) -> np.ndarray:
        return v

    def dv_dt(r: np.ndarray, planet: str) -> np.ndarray:
        if planet == 'earth':
            return (gravitational_force(ME, MS, r) + gravitational_force(ME, MJ, r - r_other)) / ME
        elif planet == 'jupiter':
            return (gravitational_force(MJ, MS, r) - gravitational_force(MJ, ME, r - r_other)) / MJ

    k11 = dr_dt(v)
    k21 = dv_dt(r, planet)

    k12 = dr_dt(v + 0.5 * h * k21)
    k22 = dv_dt(r + 0.5 * h * k11, planet)

    k13 = dr_dt(v + 0.5 * h * k22)
    k23 = dv_dt(r + 0.5 * h * k12, planet)

    k14 = dr_dt(v + h * k23)
    k24 = dv_dt(r + h * k13, planet)

    y0 = r + h * (k11 + 2 * k12 + 2 * k13 + k14) / 6
    y1 = v + h * (k21 + 2 * k22 + 2 * k23 + k24) / 6

    return y0, y1

En este paso, implementamos una función llamada RK4Solver, que utiliza el método de Runge-Kutta de cuarto orden (RK4) para resolver ecuaciones diferenciales. Este método es crucial para simular con precisión el movimiento de los planetas en nuestro modelo gravitacional. Aquí está una descripción general de lo que hace la función RK4Solver:

1. Definición de la función:
   • RK4Solver toma varios parámetros:
     • t: El tiempo actual.
     • r: El vector de posición actual del planeta.
     • v: El vector de velocidad actual del planeta.
     • h: El paso de tiempo para la simulación.
     • planet: Una cadena que indica qué planeta (Tierra o Júpiter) se está simulando.
     • r_other y v_other: Los vectores de posición y velocidad del otro planeta.
2. Funciones auxiliares dentro de RK4Solver:
   • dr_dt(v: np.ndarray) -> np.ndarray: Esta función devuelve la tasa de cambio de la posición, que es simplemente la velocidad v.
   • dv_dt(r: np.ndarray, planet: str) -> np.ndarray: Esta función calcula la aceleración del planeta debido a las fuerzas gravitacionales. Utiliza la función gravitational_force definida anteriormente para calcular las fuerzas ejercidas por el Sol y el otro planeta (Tierra o Júpiter) y devuelve la aceleración.
3. Cálculos de Runge-Kutta:
   • El método RK4 implica calcular cuatro "pendientes" (k11, k21, k12, k22, k13, k23, k14, k24) en diferentes puntos dentro del paso de tiempo y luego combinarlas para obtener una estimación precisa de la posición y la velocidad en el siguiente paso de tiempo.
   • Estas pendientes se calculan utilizando la posición y velocidad actuales, así como las derivadas de la posición (dr_dt) y la velocidad (dv_dt).
4. Actualización de la posición y la velocidad:
   • La función calcula la siguiente posición (y0) y velocidad (y1) del planeta utilizando el promedio ponderado de estas pendientes, de acuerdo con la fórmula de RK4.
5. Devolución de los resultados:
   • Finalmente, la función devuelve los vectores de posición y velocidad actualizados (y0, y1) para el planeta.

Al implementar la función RK4Solver, aprendemos un método eficiente y preciso para resolver ecuaciones diferenciales ordinarias numéricamente. Esto es particularmente importante en simulaciones que involucran sistemas complejos como el movimiento planetario, donde la precisión es fundamental para obtener resultados realistas. El método RK4 logra un buen equilibrio entre la eficiencia computacional y la precisión, lo que lo hace una opción popular en muchas aplicaciones científicas e ingenieriles.

Configurando la animación

Antes de ejecutar la simulación, necesitamos configurar la animación. Este paso implica crear un trazado e inicializar las líneas y los marcadores que representan a los planetas.

## Configuración de la animación
def setup_animation() -> Tuple[py.Figure, py.Axes, Line2D, Line2D, py.Text]:
    """
    Configura el trazado de la animación.
    """
    ## Creando una Figura y Ejes de Trazado
    fig, ax = py.subplots()

    ## Estableciendo los Límites y las Marcas de los Ejes
    ax.axis('square')
    ax.set_xlim((-7.2, 7.2))
    ax.set_ylim((-7.2, 7.2))
    ax.get_xaxis().set_ticks([])
    ax.get_yaxis().set_ticks([])

    ## Trazando el Sol
    ax.plot(0, 0, 'o', markersize=9, markerfacecolor="#FDB813",
            markeredgecolor="#FD7813")

    ## Inicializando Líneas para la Tierra y Júpiter
    line_earth, = ax.plot([], [], 'o-', color='#d2eeff',
                          markevery=10000, markerfacecolor='#0077BE', lw=2)
    line_jupiter, = ax.plot([], [], 'o-', color='#e3dccb', markersize=8,
                            markerfacecolor='#f66338', lw=2, markevery=10000)
    ## Agregando un Objeto de Texto
    ttl = ax.text(0.24, 1.05, '', transform=ax.transAxes, va='center')

    ## Devolviendo los Componentes
    return fig, ax, line_earth, line_jupiter, ttl

En este paso, definimos una función llamada setup_animation que prepara el trazado para animar la simulación gravitatoria. Esta función configura los componentes visuales de la simulación, como el área de trazado, los marcadores planetarios y la colocación inicial.

Esta función es esencial para visualizar las órbitas simuladas de la Tierra y Júpiter. Establece el escenario para la parte dinámica de la simulación donde las posiciones de estos planetas se actualizarán cuadro a cuadro para crear una animación.

Creando la función de animación

Crea una función que actualizará las posiciones de los planetas para cada fotograma de la animación.

## Función de animación
def animate(i: int) -> Tuple[Line2D, Line2D, py.Text]:
    """
    Función de animación para el movimiento planetario.
    """
    earth_trail, jupiter_trail = 40, 200
    tm_yr = 'Tiempo transcurrido ='+ str(round(t[i], 1)) +'años'
    ttl.set_text(tm_yr)
    line_earth.set_data(r[i:max(1, i - earth_trail):-1, 0],
                        r[i:max(1, i - earth_trail):-1, 1])
    line_jupiter.set_data(r_jupiter[i:max(
        1, i - jupiter_trail):-1, 0], r_jupiter[i:max(1, i - jupiter_trail):-1, 1])
    return line_earth, line_jupiter, ttl

En este paso, definimos la función animate, que es el núcleo de la creación de la animación para la simulación del movimiento planetario. Esta función se llama repetidamente para actualizar las posiciones de la Tierra y Júpiter en el trazado, creando el efecto de movimiento a lo largo del tiempo. Aquí es lo que sucede en la función animate:

1. Longitudes de la estela para la Tierra y Júpiter:
   • Las variables earth_trail y jupiter_trail se establecen, determinando cuántas posiciones anteriores (estela) de cada planeta se muestran. Esto crea un efecto de estela visual, mostrando el camino que ha recorrido cada planeta.
2. Actualización de la visualización del tiempo:
   • El tiempo transcurrido (tm_yr) se calcula y se establece como el texto del objeto de texto ttl. Esto muestra el tiempo de la simulación en años en la animación.
3. Actualización de la posición de la Tierra:
   • line_earth.set_data actualiza la posición de la Tierra en la animación. Utiliza un segmento del arreglo de posición r para crear un efecto de estela, mostrando dónde ha estado la Tierra recientemente en su órbita.
4. Actualización de la posición de Júpiter:
   • Del mismo modo, line_jupiter.set_data actualiza la posición de Júpiter utilizando un segmento del arreglo r_jupiter. La mayor longitud de la estela para Júpiter refleja su órbita más grande.
5. Devolución de los objetos actualizados:
   • La función devuelve los objetos Line2D actualizados (line_earth, line_jupiter) y el objeto de texto (ttl). Estos son los elementos que cambian en cada fotograma de la animación.

Esta función animate es crucial para visualizar la simulación, mostrando cómo la Tierra y Júpiter se mueven a lo largo del tiempo bajo sus influencias gravitatorias mutuas. Da vida a la simulación actualizando dinámicamente el trazado con cada fotograma.

Inicializando los parámetros de la simulación

Antes de comenzar la simulación, inicializa los parámetros de tiempo, la posición y la velocidad de la Tierra y Júpiter.

## Inicialización
ti, tf = 0, 120  ## Tiempo inicial y final en años
N = 100 * tf     ## 100 puntos por año
t = np.linspace(ti, tf, N)  ## Arreglo de tiempo
h = t[1] - t[0]  ## Paso de tiempo

## Inicialización de posición y velocidad
r = np.zeros([N, 2])         ## Posición de la Tierra
v = np.zeros([N, 2])         ## Velocidad de la Tierra
r_jupiter = np.zeros([N, 2])  ## Posición de Júpiter
v_jupiter = np.zeros([N, 2])  ## Velocidad de Júpiter

## Condiciones iniciales
r[0] = [1496e8 / AU, 0]
r_jupiter[0] = [5.2, 0]
v[0] = [0, np.sqrt(MS * GG / r[0, 0])]
v_jupiter[0] = [0, 13.06e3 * YEAR / AU]

En este paso, establecemos las condiciones iniciales y los parámetros para la simulación, lo cual es crucial para comenzar la animación del movimiento de la Tierra y Júpiter. Aquí está un resumen de lo que se está haciendo:

1. Inicialización de tiempo:
   • ti y tf se establecen como el tiempo inicial y final de la simulación, medido en años (0 a 120 años).
   • N se define como el número total de puntos en la simulación, calculado como 100 puntos por año.
   • t es un arreglo creado usando np.linspace para representar los pasos de tiempo desde el tiempo inicial hasta el tiempo final.
   • h es el paso de tiempo, calculado como la diferencia entre los primeros dos elementos del arreglo t.
2. Inicialización de posición y velocidad:
   • Los arreglos r y v se inicializan para almacenar la posición y la velocidad de la Tierra en cada paso de tiempo. Están inicializados a cero y tienen una forma para acomodar dos coordenadas (x e y) para cada paso de tiempo.
   • Del mismo modo, r_jupiter y v_jupiter se inicializan para almacenar la posición y la velocidad de Júpiter.
3. Establecimiento de las condiciones iniciales:
   • La posición inicial de la Tierra (r[0]) se establece a su distancia del Sol, normalizada por la Unidad Astronómica (AU).
   • La posición inicial de Júpiter (r_jupiter[0]) se establece a 5.2 AU del Sol, lo que refleja su posición real en el sistema solar.
   • La velocidad inicial de la Tierra (v[0]) se calcula basada en la fuerza gravitatoria ejercida por el Sol.
   • La velocidad inicial de Júpiter (v_jupiter[0]) se establece a un valor específico que refleja su velocidad orbital real.

Este paso es fundamental ya que establece el punto de partida para la simulación. Las posiciones y velocidades iniciales son cruciales para calcular el movimiento subsiguiente de ambos planetas bajo las fuerzas gravitatorias.

Ejecutando la simulación

Ejecuta la simulación en el marco de tiempo definido utilizando el resolutor RK4 y actualiza las posiciones de los planetas.

## Ejecutando la simulación
for i in trange(N - 1, desc="Generando Animación"):
    r[i + 1], v[i + 1] = RK4Solver(t[i], r[i],
                                   v[i], h, 'tierra', r_jupiter[i], v_jupiter[i])
    r_jupiter[i + 1], v_jupiter[i +
                                1] = RK4Solver(t[i], r_jupiter[i], v_jupiter[i], h, 'júpiter', r[i], v[i])

En este paso, ejecutamos el bucle principal para realizar la simulación gravitatoria. Aquí es donde se computa el movimiento de la Tierra y Júpiter durante el período de tiempo especificado utilizando la función RK4Solver. Aquí está una explicación simple de este proceso:

1. Ejecutando el bucle de simulación:
   • Se establece un bucle para ejecutarse N - 1 iteraciones, donde N es el número total de pasos de tiempo en la simulación. Este bucle es crucial para avanzar la simulación a través de cada paso de tiempo.
   • La función trange del módulo tqdm se utiliza para iterar sobre los pasos de tiempo. Esto proporciona una barra de progreso (descrita como "Generando Animación") para mostrar el progreso de la simulación.
2. Actualizando las posiciones y velocidades de la Tierra y Júpiter:
   • Dentro de cada iteración del bucle, la función RK4Solver se llama dos veces:
     • Una vez para actualizar la posición (r[i + 1]) y la velocidad (v[i + 1]) de la Tierra en el siguiente paso de tiempo.
     • Una vez para actualizar la posición (r_jupiter[i + 1]) y la velocidad (v_jupiter[i + 1]) de Júpiter en el siguiente paso de tiempo.
   • La función RK4Solver toma la posición y velocidad actual del planeta, junto con la posición y velocidad del otro planeta, para calcular el nuevo estado.
3. Simulando las interacciones:
   • Este bucle esencialmente simula la interacción gravitatoria entre la Tierra y Júpiter (considerando su influencia mutua y la influencia del Sol) en cada pequeño paso de tiempo, lo que conduce a una representación realista de sus órbitas a lo largo del tiempo.

Al final de este bucle, tenemos los arreglos r, v, r_jupiter y v_jupiter llenos con las posiciones y velocidades de la Tierra y Júpiter en cada paso de tiempo, listos para ser animados en la siguiente fase del proyecto. Este paso es donde se aplican las leyes físicas y los métodos numéricos principales para simular la dinámica celeste.

Mostrando la animación

Finalmente, ejecuta la animación y muestra los resultados.

## Configurando la animación
fig, ax, line_earth, line_jupiter, ttl = setup_animation()
## Agregando escala y etiquetas
ax.plot([-6,-5],[6.5,6.5],'r-')
ax.text(-4.5,6.3,r'1 UA = $1.496 \times 10^8$ km')

ax.plot(-6,-6.2,'o', color = '#d2eeff', markerfacecolor = '#0077BE')
ax.text(-5.5,-6.4,'Tierra')

ax.plot(-3.3,-6.2,'o', color = '#e3dccb',markersize = 8, markerfacecolor = '#f66338')
ax.text(-2.9,-6.4,'Super Júpiter (500x masa)')

ax.plot(5,-6.2,'o', markersize = 9, markerfacecolor = "#FDB813",markeredgecolor ="#FD7813")
ax.text(5.5,-6.4,'Sol')

## Creando la animación
anim = animation.FuncAnimation(
    fig, animate, frames=4000, interval=1, blit=False)

## Mostrando la animación
plt.show()

En el último paso del proyecto, mostramos la animación de la simulación gravitatoria que muestra el movimiento de la Tierra y el hipotético "Super Júpiter". Este paso implica visualizar las posiciones calculadas de los planetas durante el período de simulación.

Ahora que hemos completado todos los pasos, podemos ejecutar el código en el entorno de escritorio utilizando el siguiente comando:

cd ~/proyecto
python simulación.py

En este paso es donde podemos apreciar visualmente los resultados de su simulación, observando cómo el masivo "Super Júpiter" influye en la órbita de la Tierra.

Resumen

En este proyecto, hemos desarrollado efectivamente una simulación gravitatoria que incluye la Tierra y Júpiter utilizando Python. Utilizamos el método de Runge-Kutta de cuarto orden (RK4) para una integración numérica precisa y Matplotlib para una visualización clara y atractiva. Este proyecto no solo ofrece una aplicación práctica de los principios de física y codificación, sino que también anima a los estudiantes a experimentar modificando el código para simular cuerpos celestes de diferentes masas, explorando así una variedad de interacciones y dinámicas gravitatorias.