Simulação Gravitacional da Terra e Super Júpiter

Introdução

Neste projeto, desenvolveremos uma simulação gravitacional usando Python, demonstrando a interação entre a Terra e um hipotético "Super Júpiter", um planeta com 500 vezes a massa de Júpiter. Esta simulação visa demonstrar o impacto de um corpo tão massivo no movimento da Terra, considerando as imensas forças gravitacionais em jogo. Este projeto é adequado para estudantes e entusiastas apaixonados por física, astronomia e simulações computacionais. Para isso, empregaremos bibliotecas Python como NumPy para cálculos numéricos e Matplotlib para visualizar os movimentos dinâmicos dos planetas.

👀 Pré-visualização

🎯 Tarefas

Neste projeto, você aprenderá:

• Como entender e aplicar a Lei da Gravitação Universal de Newton para modelar a interação entre corpos celestes.
• Como usar a programação Python para criar um modelo computacional de um sistema gravitacional.
• Como empregar a biblioteca NumPy para cálculos numéricos eficientes em Python.
• Como simular a mecânica orbital da Terra na presença de um "Super Júpiter" com 500 vezes a massa de Júpiter.
• Como analisar e interpretar os resultados da simulação para entender o impacto de corpos celestes massivos na dinâmica orbital.
• Como implementar Matplotlib para criar representações visuais da simulação, mostrando os caminhos orbitais e as posições relativas dos planetas.
• Como explorar os conceitos de força, massa e aceleração em um contexto cósmico.
• Como ajustar os parâmetros da simulação, como massa, distância e passos de tempo, para diferentes cenários.
• Como desenvolver habilidades em depuração e otimização de código Python para computações científicas.

🏆 Conquistas

Após concluir este projeto, você será capaz de:

• Aplicar princípios fundamentais da física, especificamente a Lei da Gravitação Universal de Newton, em um contexto prático e computacional.
• Criar e executar uma simulação baseada em física usando Python.
• Demonstrar proficiência no uso de NumPy para lidar com computações numéricas em larga escala de forma eficiente.
• Visualizar dados e simulações complexas usando Matplotlib, aprimorando a interpretabilidade dos resultados científicos.
• Compreender a dinâmica do movimento planetário e os efeitos das forças gravitacionais de corpos massivos.
• Analisar e interpretar os resultados da simulação para tirar conclusões significativas sobre a mecânica celeste.
• Ajustar e experimentar com os parâmetros da simulação, levando a uma compreensão mais profunda da mecânica orbital.
• Demonstrar habilidades aprimoradas de resolução de problemas e depuração em um ambiente de programação, particularmente no contexto da computação científica.
• Demonstrar um conhecimento fundamental de como as forças gravitacionais moldam o movimento dos corpos celestes, abrindo caminho para explorações futuras em astrofísica e modelagem computacional.

Configurando o Ambiente

Primeiramente, precisamos configurar os arquivos do nosso projeto e importar as bibliotecas necessárias.

Crie um arquivo Python chamado simulation.py:

touch ~/project/simulation.py

Em seguida, importe as seguintes bibliotecas:

## Importing required libraries
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

Nesta etapa inicial do projeto de simulação gravitacional, várias bibliotecas Python importantes são importadas para configurar o ambiente para nossa simulação:

1. typing: Especificamente, Tuple do módulo typing é importado. Isso é usado para type hinting em Python, o que ajuda na legibilidade e depuração do código. Ele permite especificar quais tipos de valores podem ser agrupados em uma tupla, garantindo consistência e clareza nas definições de função.
2. numpy: A biblioteca numpy, importada como np, é um pacote fundamental para computação científica em Python. Ele fornece suporte para grandes arrays e matrizes multidimensionais, juntamente com uma vasta coleção de funções matemáticas de alto nível para operar nesses arrays. É crucial para lidar com cálculos numéricos na simulação.
3. pylab: Importado como py, pylab é um módulo em Matplotlib que é instalado junto com Matplotlib. Ele fornece uma interface semelhante ao MATLAB, particularmente útil para cálculos interativos e plotagem. No entanto, seu uso é geralmente desencorajado em favor da importação explícita de matplotlib.pyplot e numpy.
4. matplotlib.pyplot: Este módulo, importado como plt, é usado para criar visualizações estáticas, animadas e interativas em Python. É um aspecto central deste projeto para plotar as trajetórias dos corpos celestes.
5. matplotlib.animation: Este submódulo de Matplotlib fornece a funcionalidade para criar animações. É essencial para visualizar o movimento dinâmico dos planetas na simulação gravitacional.
6. matplotlib.lines.Line2D: Esta classe da biblioteca Matplotlib é usada para criar objetos de linha que podem ser desenhados em gráficos. É útil para plotagem mais detalhada ou personalizada na simulação.
7. tqdm.trange: trange do módulo tqdm é uma variante da função range do Python com um medidor de progresso embutido. É útil para exibir o progresso dos loops na simulação, especialmente ao lidar com cálculos extensivos.

Ao importar essas bibliotecas e módulos, estabelecemos a base para as complexas computações numéricas e visualizações necessárias no projeto de simulação gravitacional. Essa configuração é crítica para as etapas subsequentes, onde a física real e a lógica de animação serão implementadas.

Definindo Constantes

Defina as constantes que serão usadas em nossa simulação. Isso inclui a constante gravitacional, unidades astronômicas e massas normalizadas da Terra, Júpiter e o Sol.

## Constants
G = 6.673e-11                 ## Gravitational Constant
AU = 1.496e11                 ## Astronomical Unit in km
YEAR = 365*24*60*60.0         ## Seconds in one year
MM = 6e24                     ## Normalizing mass
ME = 6e24/MM                  ## Normalized mass of Earth
MS = 2e30/MM                  ## Normalized mass of Sun
MJ = 500*1.9e27/MM            ## Normalized mass of Jupiter
GG = (MM*G*YEAR**2)/(AU**3)   ## Gravitational constant for simulation

Nesta etapa, definimos várias constantes essenciais para a simulação gravitacional. Essas constantes são fundamentais para modelar com precisão a mecânica celeste e as interações gravitacionais na simulação:

1. Constante Gravitacional (G): Definida como 6.673e-11 (em unidades SI), esta constante é crucial na lei da gravitação universal de Newton. Ela representa a força da gravidade e é usada para calcular a força gravitacional entre duas massas.
2. Unidade Astronômica (AU): Definida como 1.496e11 quilômetros, ela representa a distância média da Terra ao Sol. Esta unidade é usada para expressar distâncias dentro do sistema solar de uma forma mais gerenciável.
3. Ano (YEAR): Calculado como 365*24*60*60.0, ele representa o número de segundos em um ano. Isso é usado para converter cálculos relacionados ao tempo em anos, uma unidade de tempo mais intuitiva para simulações astronômicas.
4. Massa de Normalização (MM): Definida como 6e24, este valor é usado como uma massa de referência para normalizar outras massas na simulação. É aproximadamente equivalente à massa da Terra.
5. Massa Normalizada da Terra (ME): Calculada como 6e24/MM, ela representa a massa da Terra em unidades normalizadas. É essencialmente definida como 1, pois a massa de normalização (MM) é baseada na massa da Terra.
6. Massa Normalizada do Sol (MS): Definida como 2e30/MM, ela representa a massa do Sol em unidades normalizadas. A massa do Sol é um fator crítico na simulação da atração gravitacional sobre os planetas.
7. Massa Normalizada de Júpiter (MJ): Exclusivamente, nesta simulação, a massa de Júpiter é amplificada para 500*1.9e27/MM para representar um cenário de "Super Júpiter". Esta massa significativamente maior demonstrará o impacto de um planeta muito mais massivo na órbita da Terra.
8. Constante Gravitacional para Simulação (GG): Esta é a constante gravitacional ajustada para a escala e unidades da simulação, calculada como (MM*G*YEAR**2)/(AU**3). Ela adapta a constante gravitacional do mundo real às unidades normalizadas usadas na simulação.

Ao definir essas constantes, estamos equipados com os parâmetros necessários para simular com precisão as forças gravitacionais e os movimentos de corpos celestes como a Terra e este hipotético "Super Júpiter". Esta etapa é vital para garantir que os cálculos da simulação reflitam a dinâmica astronômica realista. Ao mesmo tempo, você pode modificar essas constantes o quanto quiser para observar resultados diferentes no final.

Criando a Função de Força Gravitacional

Agora, definiremos uma função para calcular a força gravitacional entre dois corpos. Esta função será crucial para determinar o movimento dos planetas.

## Function to calculate gravitational force
def gravitational_force(m1: float, m2: float, r: np.ndarray) -> np.ndarray:
    """
    Calculate gravitational force between two bodies.
    """
    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

Nesta etapa, definimos uma função gravitational_force para calcular a força gravitacional entre dois corpos celestes. Esta função é um componente crítico da simulação, pois aplica a lei da gravitação universal de Newton para determinar a força exercida entre quaisquer duas massas no espaço. Aqui está uma análise da função:

1. Definição da Função: A função gravitational_force recebe três argumentos:
   • m1 e m2: As massas dos dois corpos (valores float).
   • r: Um array NumPy representando o vetor de deslocamento entre os dois corpos.
2. Calculando a Magnitude da Força (F_mag):
   • A função primeiro calcula a magnitude da força gravitacional usando a fórmula F_mag = GG * m1 * m2 / (np.linalg.norm(r) + 1e-20)**2.
   • GG é a constante gravitacional para a simulação.
   • np.linalg.norm(r) calcula a distância euclidiana entre os dois corpos. Um pequeno número (1e-20) é adicionado para evitar a divisão por zero.
3. Determinando a Direção (theta e F):
   • O ângulo theta é calculado usando np.arctan2 para encontrar o ângulo do vetor de força em coordenadas polares. Novamente, um pequeno número (1e-20) é adicionado ao denominador para evitar a divisão por zero quando o deslocamento na direção x (r[0]) é zero.
   • O vetor de força F é então calculado usando F_mag e o ângulo theta, com componentes ao longo dos eixos x e y ([np.cos(theta), np.sin(theta)]).
4. Ajustando a Direção da Força:
   • O vetor de força F é multiplicado por -np.sign(r) para garantir que a força seja sempre atrativa (apontando para o outro corpo), de acordo com as leis da gravitação.
5. Retornando o Vetor de Força:
   • Finalmente, a função retorna o vetor de força gravitacional F.

Ao implementar esta função, aprendemos como aplicar as leis físicas em um ambiente computacional. A função é essencial para calcular as interações gravitacionais entre a Terra e o "Super Júpiter" na simulação, o que influenciará suas respectivas trajetórias.

Implementando o Solucionador RK4

Implemente o solucionador de Runge-Kutta de 4ª ordem para resolver as equações diferenciais de movimento. Este método é amplamente utilizado para resolver equações diferenciais ordinárias numericamente.

## RK4 Solver
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]:
    """
    Fourth order Runge-Kutta solver for planetary motion.
    """
    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

Nesta etapa, implementamos uma função chamada RK4Solver, que usa o método de Runge-Kutta de Quarta Ordem (RK4) para resolver equações diferenciais. Este método é crucial para simular com precisão o movimento dos planetas em nosso modelo gravitacional. Aqui está uma visão geral do que a função RK4Solver faz:

1. Definição da Função:
   • RK4Solver recebe vários parâmetros:
     • t: O tempo atual.
     • r: O vetor de posição atual do planeta.
     • v: O vetor de velocidade atual do planeta.
     • h: O passo de tempo para a simulação.
     • planet: Uma string indicando qual planeta (Terra ou Júpiter) está sendo simulado.
     • r_other e v_other: Os vetores de posição e velocidade do outro planeta.
2. Funções Auxiliares dentro de RK4Solver:
   • dr_dt(v: np.ndarray) -> np.ndarray: Esta função retorna a taxa de variação da posição, que é simplesmente a velocidade v.
   • dv_dt(r: np.ndarray, planet: str) -> np.ndarray: Esta função calcula a aceleração do planeta devido às forças gravitacionais. Ela usa a função gravitational_force definida anteriormente para calcular as forças exercidas pelo Sol e pelo outro planeta (Terra ou Júpiter) e retorna a aceleração.
3. Cálculos de Runge-Kutta:
   • O método RK4 envolve o cálculo de quatro "inclinações" (k11, k21, k12, k22, k13, k23, k14, k24) em diferentes pontos dentro do passo de tempo e, em seguida, combiná-los para obter uma estimativa precisa da posição e velocidade no próximo passo de tempo.
   • Essas inclinações são calculadas usando a posição e velocidade atuais, bem como as derivadas da posição (dr_dt) e da velocidade (dv_dt).
4. Atualizando a Posição e Velocidade:
   • A função calcula a próxima posição (y0) e velocidade (y1) do planeta usando a média ponderada dessas inclinações, de acordo com a fórmula RK4.
5. Retornando os Resultados:
   • Finalmente, a função retorna os vetores de posição e velocidade atualizados (y0, y1) para o planeta.

Ao implementar a função RK4Solver, aprendemos um método eficiente e preciso para resolver equações diferenciais ordinárias numericamente. Isso é particularmente importante em simulações envolvendo sistemas complexos como o movimento planetário, onde a precisão é fundamental para obter resultados realistas. O método RK4 encontra um bom equilíbrio entre eficiência computacional e precisão, tornando-o uma escolha popular em muitas aplicações científicas e de engenharia.

Configurando a Animação

Antes de executar a simulação, precisamos configurar a animação. Esta etapa envolve a criação de um gráfico e a inicialização das linhas e marcadores que representam os planetas.

## Setup animation
def setup_animation() -> Tuple[py.Figure, py.Axes, Line2D, Line2D, py.Text]:
    """
    Set up the animation plot.
    """
    ## Creating a Plot Figure and Axes
    fig, ax = py.subplots()

    ## Setting Axes Limits and Ticks
    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([])

    ## Plotting the Sun
    ax.plot(0, 0, 'o', markersize=9, markerfacecolor="#FDB813",
            markeredgecolor="#FD7813")

    ## Initializing Lines for Earth and Jupiter
    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)
    ## Adding a Text Object
    ttl = ax.text(0.24, 1.05, '', transform=ax.transAxes, va='center')

    ## Returning Components
    return fig, ax, line_earth, line_jupiter, ttl

Nesta etapa, definimos uma função chamada setup_animation que prepara o gráfico para animar a simulação gravitacional. Esta função configura os componentes visuais da simulação, como a área do gráfico, os marcadores planetários e o posicionamento inicial.

Esta função é essencial para visualizar as órbitas simuladas da Terra e de Júpiter. Ela prepara o cenário para a parte dinâmica da simulação, onde as posições desses planetas serão atualizadas quadro a quadro para criar uma animação.

Criando a Função de Animação

Crie uma função que atualizará as posições dos planetas para cada quadro da animação.

## Animation function
def animate(i: int) -> Tuple[Line2D, Line2D, py.Text]:
    """
    Animation function for the planetary motion.
    """
    earth_trail, jupiter_trail = 40, 200
    tm_yr = 'Elapsed time = ' + str(round(t[i], 1)) + ' years'
    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

Nesta etapa, definimos a função animate, que é o núcleo da criação da animação para a simulação do movimento planetário. Esta função é chamada repetidamente para atualizar as posições da Terra e de Júpiter no gráfico, criando o efeito de movimento ao longo do tempo. Veja o que acontece na função animate:

1. Comprimentos de Rastro para Terra e Júpiter:
   • As variáveis earth_trail e jupiter_trail são definidas, determinando quantas posições anteriores (rastro) de cada planeta são mostradas. Isso cria um efeito de rastro visual, mostrando o caminho que cada planeta percorreu.
2. Atualizando a Exibição do Tempo:
   • O tempo decorrido (tm_yr) é calculado e definido como o texto do objeto de texto ttl. Isso exibe o tempo da simulação em anos na animação.
3. Atualizando a Posição da Terra:
   • line_earth.set_data atualiza a posição da Terra na animação. Ele usa uma fatia da matriz de posição r para criar um efeito de rastro, mostrando onde a Terra esteve recentemente em sua órbita.
4. Atualizando a Posição de Júpiter:
   • Da mesma forma, line_jupiter.set_data atualiza a posição de Júpiter usando uma fatia da matriz r_jupiter. O comprimento de rastro maior para Júpiter reflete sua órbita maior.
5. Retornando Objetos Atualizados:
   • A função retorna os objetos Line2D atualizados (line_earth, line_jupiter) e o objeto de texto (ttl). Esses são os elementos que mudam em cada quadro da animação.

Esta função animate é crucial para visualizar a simulação, mostrando como a Terra e Júpiter se movem ao longo do tempo sob suas influências gravitacionais mútuas. Ela dá vida à simulação, atualizando dinamicamente o gráfico a cada quadro.

Inicializando os Parâmetros da Simulação

Antes de iniciar a simulação, inicialize os parâmetros de tempo, posição e velocidade da Terra e de Júpiter.

## Initialization
ti, tf = 0, 120  ## Initial and final time in years
N = 100 * tf     ## 100 points per year
t = np.linspace(ti, tf, N)  ## Time array
h = t[1] - t[0]  ## Time step

## Position and Velocity Initialization
r = np.zeros([N, 2])         ## Position of Earth
v = np.zeros([N, 2])         ## Velocity of Earth
r_jupiter = np.zeros([N, 2])  ## Position of Jupiter
v_jupiter = np.zeros([N, 2])  ## Velocity of Jupiter

## Initial Conditions
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]

Nesta etapa, configuramos as condições iniciais e os parâmetros para a simulação, o que é crucial para iniciar a animação do movimento da Terra e de Júpiter. Aqui está um resumo do que está sendo feito:

1. Inicialização do Tempo:
   • ti e tf são definidos como os tempos inicial e final da simulação, medidos em anos (0 a 120 anos).
   • N é definido como o número total de pontos na simulação, calculado como 100 pontos por ano.
   • t é uma matriz criada usando np.linspace para representar os passos de tempo do tempo inicial ao tempo final.
   • h é o passo de tempo, calculado como a diferença entre os dois primeiros elementos da matriz t.
2. Inicialização da Posição e Velocidade:
   • As matrizes r e v são inicializadas para armazenar a posição e a velocidade da Terra em cada passo de tempo. Elas são inicializadas com zeros e têm uma forma para acomodar duas coordenadas (x e y) para cada passo de tempo.
   • Da mesma forma, r_jupiter e v_jupiter são inicializadas para armazenar a posição e a velocidade de Júpiter.
3. Definindo as Condições Iniciais:
   • A posição inicial da Terra (r[0]) é definida como sua distância do Sol, normalizada pela Unidade Astronômica (AU).
   • A posição inicial de Júpiter (r_jupiter[0]) é definida como 5,2 UA do Sol, refletindo sua posição real no sistema solar.
   • A velocidade inicial da Terra (v[0]) é calculada com base na força gravitacional exercida pelo Sol.
   • A velocidade inicial de Júpiter (v_jupiter[0]) é definida como um valor específico que reflete sua velocidade orbital real.

Esta etapa é fundamental, pois estabelece o ponto de partida para a simulação. As posições e velocidades iniciais são cruciais para calcular o movimento subsequente de ambos os planetas sob as forças gravitacionais.

Executando a Simulação

Execute a simulação ao longo do período de tempo definido usando o solucionador RK4 e atualize as posições dos planetas.

## Running the simulation
for i in trange(N - 1, desc="Generating Animation"):
    r[i + 1], v[i + 1] = RK4Solver(t[i], r[i],
                                   v[i], h, 'earth', r_jupiter[i], v_jupiter[i])
    r_jupiter[i + 1], v_jupiter[i +
                                1] = RK4Solver(t[i], r_jupiter[i], v_jupiter[i], h, 'jupiter', r[i], v[i])

Nesta etapa, executamos o loop principal para rodar a simulação gravitacional. É aqui que o movimento da Terra e de Júpiter é computado ao longo do período de tempo especificado usando a função RK4Solver. Aqui está uma explicação simples deste processo:

1. Executando o Loop da Simulação:
   • Um loop é configurado para rodar por N - 1 iterações, onde N é o número total de passos de tempo na simulação. Este loop é crucial para avançar a simulação através de cada passo de tempo.
   • A função trange do módulo tqdm é usada para iterar sobre os passos de tempo. Isso fornece uma barra de progresso (descrita como "Gerando Animação") para mostrar o progresso da simulação.
2. Atualizando as Posições e Velocidades da Terra e de Júpiter:
   • Dentro de cada iteração do loop, a função RK4Solver é chamada duas vezes:
     • Uma vez para atualizar a posição da Terra (r[i + 1]) e a velocidade (v[i + 1]) no próximo passo de tempo.
     • Uma vez para atualizar a posição de Júpiter (r_jupiter[i + 1]) e a velocidade (v_jupiter[i + 1]) no próximo passo de tempo.
   • A função RK4Solver recebe a posição e a velocidade atuais do planeta, juntamente com a posição e a velocidade do outro planeta, para calcular o novo estado.
3. Simulando Interações:
   • Este loop essencialmente simula a interação gravitacional entre a Terra e Júpiter (considerando sua influência mútua e a influência do Sol) em cada pequeno passo de tempo, levando a uma representação realista de suas órbitas ao longo do tempo.

Ao final deste loop, temos as matrizes r, v, r_jupiter e v_jupiter preenchidas com as posições e velocidades da Terra e de Júpiter em cada passo de tempo, prontas para serem animadas na próxima fase do projeto. Esta etapa é onde a física central e os métodos numéricos são aplicados para simular a dinâmica celeste.

Exibindo a Animação

Finalmente, execute a animação e exiba os resultados.

## Setting Up the Animation
fig, ax, line_earth, line_jupiter, ttl = setup_animation()
## Adding Scale and Labels
ax.plot([-6,-5],[6.5,6.5],'r-')
ax.text(-4.5,6.3,r'1 AU = $1.496 \times 10^8$ km')

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

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

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

## Creating the Animation
anim = animation.FuncAnimation(
    fig, animate, frames=4000, interval=1, blit=False)

## Displaying the Animation
plt.show()

Na etapa final do projeto, exibimos a animação da simulação gravitacional que mostra o movimento da Terra e do hipotético "Super Júpiter". Esta etapa envolve a visualização das posições calculadas dos planetas ao longo do período de simulação.

Agora que concluímos todas as etapas, podemos executar o código no ambiente de desktop usando o seguinte comando:

cd ~/project
python simulation.py

Esta etapa é onde podemos apreciar visualmente os resultados da simulação, observando como o massivo "Super Júpiter" influencia a órbita da Terra.

Resumo

Neste projeto, desenvolvemos efetivamente uma simulação gravitacional com a Terra e Júpiter usando Python. Empregamos o método de Runge-Kutta de 4ª ordem (RK4) para uma integração numérica precisa e Matplotlib para uma visualização clara e envolvente. Este projeto não apenas oferece uma aplicação prática de princípios de física e codificação, mas também incentiva os alunos a experimentar, alterando o código para simular corpos celestes de várias massas, explorando assim uma gama de interações e dinâmicas gravitacionais.