Гравитационная симуляция | Python | Астрономия | Физика | Вычислительная модель

Введение

В этом проекте мы разработаем симуляцию гравитации с использованием Python, демонстрируя взаимодействие между Землей и гипотетическим «Супер Юпитером», планетой с массой в 500 раз превышающей массу Юпитера. Эта симуляция旨在 показать влияние такого массивного тела на движение Земли, учитывая огромные гравитационные силы, действующие на объекты. Этот проект подходит для студентов и любителей физики, астрономии и вычислительных симуляций. Для этого мы будем использовать библиотеки Python, такие как NumPy для численных вычислений и Matplotlib для визуализации динамических движений планет.

👀 Предпросмотр

🎯 Задачи

В этом проекте вы научитесь:

Как понять и применить Закон всемирной гравитации Ньютона для моделирования взаимодействия небесных тел.
Как использовать программирование на Python для создания вычислительной модели гравитационной системы.
Как использовать библиотеку NumPy для эффективных численных вычислений в Python.
Как моделировать орбитальную механику Земли в присутствии «Супер Юпитера» с массой в 500 раз превышающей массу Юпитера.
Как анализировать и интерпретировать результаты симуляции, чтобы понять влияние массивных небесных тел на орбитальную динамику.
Как реализовать Matplotlib для создания визуальных представлений симуляции, демонстрирующих орбитальные траектории и относительные позиции планет.
Как изучать концепции силы, массы и ускорения в космическом контексте.
Как настраивать параметры симуляции, такие как масса, расстояние и временные интервалы, для различных сценариев.
Как развивать навыки отладки и оптимизации кода Python для научных вычислений.

🏆 Достижения

После завершения этого проекта вы сможете:

Применять фундаментальные принципы физики, в частности Закон всемирной гравитации Ньютона, в практическом, вычислительном контексте.
Создавать и запускать физическую симуляцию с использованием Python.
Демонстрировать навыки использования NumPy для эффективной обработки大规模数值计算。
Визуализировать сложные данные и симуляции с использованием Matplotlib, повышая интерпретируемость научных результатов.
Понять динамику планетарного движения и влияние гравитационных сил от массивных тел.
Анализировать и интерпретировать результаты симуляции, чтобы сделать осмысленные выводы о небесной механике.
Настраивать и экспериментировать с параметрами симуляции, чтобы получить более глубокое понимание орбитальной механики.
Показать улучшенные навыки решения задач и отладки в программировании, особенно в контексте научных вычислений.
Демонстрировать основное знание того, как гравитационные силы влияют на движение небесных тел, открывая дорогу для дальнейшего исследования в астрофизике и вычислительной моделировании.

Настройка среды

Во - первых, нам нужно настроить наши проектные файлы и импортировать необходимые библиотеки.

Создайте файл Python с именем simulation.py:

touch ~/project/simulation.py

Затем импортируйте следующие библиотеки:

## 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

В этом начальном этапе проекта по симуляции гравитации импортируются несколько важных библиотек Python для настройки окружения для нашей симуляции:

typing: В частности, из модуля typing импортируется Tuple. Это используется для подсказок типов в Python, что помогает в чтении кода и отладке. Позволяет указывать, какие типы значений могут быть сгруппированы в кортеже, обеспечивая согласованность и ясность в определениях функций.
numpy: Библиотека numpy, импортированная как np, является фундаментальной для научных вычислений в Python. Она обеспечивает поддержку для больших многомерных массивов и матриц, а также огромное количество высокоуровневых математических функций для работы с этими массивами. Она至关重要 для обработки численных вычислений в симуляции.
pylab: Импортированный как py, pylab - это модуль в Matplotlib, который устанавливается вместе с Matplotlib. Он предоставляет интерфейс, похожий на MATLAB, особенно полезный для интерактивных вычислений и построения графиков. Однако его использование обычно не рекомендуется в пользу явного импорта matplotlib.pyplot и numpy.
matplotlib.pyplot: Этот модуль, импортированный как plt, используется для создания статических, анимированных и интерактивных визуализаций в Python. Это важный аспект этого проекта для построения траекторий небесных тел.
matplotlib.animation: Этот подмодуль Matplotlib обеспечивает функциональность для создания анимаций. Он необходим для визуализации динамического движения планет в гравитационной симуляции.
matplotlib.lines.Line2D: Этот класс из библиотеки Matplotlib используется для создания объектов линий, которые можно нарисовать на графиках. Он полезен для более детального или настраиваемого построения графиков в симуляции.
tqdm.trange: trange из модуля tqdm - это вариант функции range в Python с встроенным счетчиком прогресса. Он полезен для отображения прогресса циклов в симуляции, особенно при работе с extensive вычислениями.

Импортируя эти библиотеки и модули, мы создаем основу для сложных численных вычислений и визуализаций, требуемых в проекте по симуляции гравитации. Эта настройка является критической для последующих этапов, где будет реализована фактическая физика и логика анимации.

Определение констант

Определите константы, которые будут использоваться в нашей симуляции. Это включает в себя гравитационную постоянную, астрономические единицы и нормализованные массы Земли, Юпитера и Солнца.

## 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

В этом этапе мы определяем несколько важных констант для гравитационной симуляции. Эти константы являются фундаментальными для точного моделирования небесной механики и гравитационных взаимодействий в симуляции:

Гравитационная постоянная (G): Установлена равной 6.673e-11 (в СИ единицах), эта постоянная至关重要 в законе всемирной гравитации Ньютона. Она представляет силу гравитации и используется для вычисления гравитационной силы между двумя массами.
Астрономическая единица (AU): Определена как 1.496e11 километров, она представляет среднее расстояние от Земли до Солнца. Эта единица используется для выражения расстояний в солнечной системе более удобным способом.
Год (YEAR): Вычисляется как 365*24*60*60.0, он представляет количество секунд в году. Это используется для преобразования времени - связанных вычислений в годы, более интуитивный единицы времени для астрономических симуляций.
Нормализующая масса (MM): Установлена равной 6e24, это значение используется в качестве эталонной массы для нормализации других масс в симуляции. Она примерно равна массе Земли.
Нормализованная масса Земли (ME): Вычисляется как 6e24/MM, она представляет массу Земли в нормализованных единицах. Она по существу установлена равной 1, так как нормализующая масса (MM) основана на массе Земли.
Нормализованная масса Солнца (MS): Установлена равной 2e30/MM, она представляет массу Солнца в нормализованных единицах. Масса Солнца является важным фактором при моделировании гравитационного притяжения на планеты.
Нормализованная масса Юпитера (MJ): Особенно, в этой симуляции масса Юпитера увеличена до 500*1.9e27/MM для представления сценария "Супер Юпитера". Эта значительно большая масса покажет влияние гораздо более массивной планеты на орбиту Земли.
Гравитационная постоянная для симуляции (GG): Это гравитационная постоянная, скорректированная для масштаба и единиц симуляции, вычисляется как (MM*G*YEAR**2)/(AU**3). Она адаптирует реальную гравитационную постоянную к нормализованным единицам, используемым в симуляции.

Определив эти константы, мы имеем необходимые параметры для точной симуляции гравитационных сил и движений небесных тел, таких как Земля и этот гипотетический "Супер Юпитер". Этот этап важен для обеспечения того, чтобы вычисления симуляции отражали реальные астрономические динамики. В то же время вы можете изменить эти константы по своему усмотрению, чтобы наблюдать разные результаты в конце.

Создание функции гравитационной силы

Теперь мы определим функцию для вычисления гравитационной силы между двумя телами. Эта функция будет至关重要 для определения движения планет.

## 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

В этом этапе мы определяем функцию gravitational_force для вычисления гравитационной силы между двумя небесными телами. Эта функция является важной частью симуляции, так как она применяет закон всемирной гравитации Ньютона для определения силы, действующей между любыми двумя массами в пространстве. Вот разбор функции:

Определение функции: Функция gravitational_force принимает три аргумента:
- m1 и m2: Массы двух тел (значения типа float).
- r: Массив NumPy, представляющий вектор смещения между двумя телами.
Вычисление величины силы (F_mag):
- Функция сначала вычисляет величину гравитационной силы по формуле F_mag = GG * m1 * m2 / (np.linalg.norm(r) + 1e-20)**2.
- GG - это гравитационная постоянная для симуляции.
- np.linalg.norm(r) вычисляет евклидово расстояние между двумя телами. К малому числу (1e-20) добавляется, чтобы избежать деления на ноль.
Определение направления (theta и F):
- Угол theta вычисляется с использованием np.arctan2 для нахождения угла вектора силы в полярных координатах. Опять же, к знаменателю добавляется малое число (1e-20), чтобы избежать деления на ноль, когда смещение по оси x (r[0]) равно нулю.
- Затем вектор силы F вычисляется с использованием F_mag и угла theta, с компонентами по осям x и y ([np.cos(theta), np.sin(theta)]).
Корректировка направления силы:
- Вектор силы F умножается на -np.sign(r), чтобы обеспечить, чтобы сила всегда была притяжной (направлена к другому телу) согласно законам гравитации.
Возвращение вектора силы:
- Наконец, функция возвращает вектор гравитационной силы F.

Реализуя эту функцию, мы узнаем, как применить физические законы в вычислительной среде. Функция является важной для вычисления гравитационных взаимодействий между Землей и "Супер Юпитером" в симуляции, что повлияет на их соответствующие траектории.

Реализация решения методом Рунге-Кутты 4-го порядка

Реализуйте метод Рунге - Кутты 4-го порядка для решения дифференциальных уравнений движения. Этот метод широко используется для численного решения обыкновенных дифференциальных уравнений.

## 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

В этом этапе мы реализуем функцию под названием RK4Solver, которая использует метод Рунге - Кутты 4-го порядка (RK4) для решения дифференциальных уравнений. Этот метод至关重要 для точной симуляции движения планет в нашей гравитационной модели. Вот обзор того, что делает функция RK4Solver:

Определение функции:
- RK4Solver принимает несколько параметров:
  - t: Текущее время.
  - r: Текущий вектор позиции планеты.
  - v: Текущий вектор скорости планеты.
  - h: Шаг времени для симуляции.
  - planet: Строка, указывающая, какая планета (Земля или Юпитер) моделируется.
  - r_other и v_other: Векторы позиции и скорости другой планеты.
Вспомогательные функции внутри RK4Solver:
- dr_dt(v: np.ndarray) -> np.ndarray: Эта функция возвращает скорость изменения позиции, которая просто равна скорости v.
- dv_dt(r: np.ndarray, planet: str) -> np.ndarray: Эта функция вычисляет ускорение планеты под действием гравитационных сил. Она использует функцию gravitational_force, определенную ранее, для вычисления сил, действующих от Солнца и другой планеты (Земли или Юпитера), и возвращает ускорение.
Вычисления методом Рунге - Кутты:
- Метод RK4 включает в себя вычисление четырех "наклонностей" (k11, k21, k12, k22, k13, k23, k14, k24) в различных точках внутри шага времени и затем комбинирование их, чтобы получить точную оценку позиции и скорости на следующем шаге времени.
- Эти наклонности вычисляются с использованием текущей позиции и скорости, а также производных позиции (dr_dt) и скорости (dv_dt).
Обновление позиции и скорости:
- Функция вычисляет следующую позицию (y0) и скорость (y1) планеты с использованием взвешенного среднего этих наклонностей в соответствии с формулой RK4.
Возвращение результатов:
- Наконец, функция возвращает обновленные векторы позиции и скорости (y0, y1) для планеты.

Реализуя функцию RK4Solver, мы узнаем эффективный и точный метод для численного решения обыкновенных дифференциальных уравнений. Это особенно важно в симуляциях，涉及复杂系统，таких как движение планет, где точность является ключом для получения реальных результатов. Метод RK4 нахождение хорошего баланса между вычислительной эффективностью и точностью, что делает его популярным выбором в многих научных и инженерных приложениях.

Настройка анимации

Прежде чем запустить симуляцию, нам нужно настроить анимацию. Этот этап включает в себя создание графика и инициализацию линий и маркеров, представляющих планеты.

## 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

В этом этапе мы определяем функцию под названием setup_animation, которая настраивает график для анимации гравитационной симуляции. Эта функция настраивает визуальные компоненты симуляции, такие как область графика, маркеры планет и начальную позиционирование.

Эта функция至关重要 для визуализации моделируемых орбит Земли и Юпитера. Она создает основу для динамической части симуляции, где позиции этих планет будут обновляться кадр за кадром для создания анимации.

Создание функции анимации

Создайте функцию, которая будет обновлять позиции планет для каждого кадра анимации.

## 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

В этом этапе мы определяем функцию animate, которая является ядром создания анимации для симуляции движения планет. Эта функция вызывается многократно для обновления позиций Земли и Юпитера на графике, создавая эффект движения в течение времени. Вот что происходит в функции animate:

Длина следов для Земли и Юпитера:
- Переменные earth_trail и jupiter_trail задаются, определяя, сколько предыдущих позиций (след) каждой планеты отображается. Это создает эффект визуального следа, показывая путь, по которому каждая планета прошла.
Обновление отображения времени:
- Вычисляется пройденное время (tm_yr) и устанавливается в качестве текста объекта текста ttl. Это отображает время симуляции в годах на анимации.
Обновление позиции Земли:
- line_earth.set_data обновляет позицию Земли в анимации. Она использует срез массива позиций r для создания эффекта следа, показывая, где Земля находилась недавно в своей орбите.
Обновление позиции Юпитера:
- Аналогично, line_jupiter.set_data обновляет позицию Юпитера с использованием среза массива r_jupiter. Большая длина следа для Юпитера отражает его более крупный орбит.
Возвращение обновленных объектов:
- Функция возвращает обновленные объекты Line2D (line_earth, line_jupiter) и объект текста (ttl). Эти элементы изменяются в каждом кадре анимации.

Эта функция animate至关重要 для визуализации симуляции, показывая, как Земля и Юпитер движутся в течение времени под влиянием их взаимной гравитации. Она придает симуляции жизнь, динамически обновляя график на каждом кадре.

Инициализация параметров симуляции

Прежде чем начать симуляцию, инициализируйте параметры времени, позицию и скорость Земли и Юпитера.

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

В этом этапе мы настраиваем начальные условия и параметры для симуляции, что至关重要 для запуска анимации движения Земли и Юпитера. Вот обзор того, что делается:

Инициализация времени:
- ti и tf задаются как начальное и конечное время симуляции, измеренное в годах (от 0 до 120 лет).
- N определяется как общее количество точек в симуляции, вычисленное как 100 точек в год.
- t - это массив, созданный с использованием np.linspace, чтобы представить шаги времени от начального до конечного времени.
- h - это шаг времени, вычисленный как разница между первыми двумя элементами массива t.
Инициализация позиции и скорости:
- Массивы r и v инициализируются для хранения позиции и скорости Земли на каждом шаге времени. Они инициализируются нулями и имеют форму, которая позволяет вместить две координаты (x и y) для каждого шага времени.
- Аналогично, r_jupiter и v_jupiter инициализируются для хранения позиции и скорости Юпитера.
Установка начальных условий:
- Начальная позиция Земли (r[0]) задается как ее расстояние от Солнца, нормализованное на астрономическую единицу (AU).
- Начальная позиция Юпитера (r_jupiter[0]) задается как 5,2 AU от Солнца, что отражает его фактическую позицию в солнечной системе.
- Начальная скорость Земли (v[0]) вычисляется на основе гравитационной силы, действующей от Солнца.
- Начальная скорость Юпитера (v_jupiter[0]) задается конкретным значением, которое отражает его фактическую орбитальную скорость.

Этот этап является фундаментальным, так как устанавливает начальную точку для симуляции. Начальные позиции и скорости至关重要 для вычисления последующего движения обоих планет под действием гравитационных сил.

Запуск симуляции

Выполните симуляцию в определенном временном интервале с использованием решения методом Рунге - Кутты 4-го порядка и обновите позиции планет.

## 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])

В этом этапе мы выполняем главный цикл для запуска гравитационной симуляции. Именно здесь вычисляется движение Земли и Юпитера за указанный период времени с использованием функции RK4Solver. Вот простое объяснение этого процесса:

Запуск цикла симуляции:
- Устанавливается цикл для выполнения N - 1 итераций, где N - это общее количество шагов времени в симуляции. Этот цикл至关重要 для продвижения симуляции через каждый шаг времени.
- Функция trange из модуля tqdm используется для итерации по шагам времени. Это предоставляет прогресс - бар (описанный как "Generating Animation") для отображения прогресса симуляции.
Обновление позиций и скоростей Земли и Юпитера:
- Внутри каждой итерации цикла функция RK4Solver вызывается дважды:
  - Один раз для обновления позиции (r[i + 1]) и скорости (v[i + 1]) Земли на следующем шаге времени.
  - Один раз для обновления позиции (r_jupiter[i + 1]) и скорости (v_jupiter[i + 1]) Юпитера на следующем шаге времени.
- Функция RK4Solver принимает текущую позицию и скорость планеты, а также позицию и скорость другой планеты, чтобы вычислить новое состояние.
Симуляция взаимодействий:
- Этот цикл по существу симулирует гравитационное взаимодействие между Землей и Юпитером (учитывая их влияние друг на друга и влияние Солнца) на каждом малом шаге времени, что приводит к реальному представлению их орбит в течение времени.

По окончании этого цикла у нас есть массивы r, v, r_jupiter и v_jupiter, заполненные позициями и скоростями Земли и Юпитера на каждом шаге времени, готовыми к анимации на следующей стадии проекта. Этот этап - это то, где применяются основные физические и численные методы для симуляции небесных динамических процессов.

Отображение анимации

Наконец, запустите анимацию и отобразите результаты.

## 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$ км')

ax.plot(-6,-6.2,'o', color = '#d2eeff', markerfacecolor = '#0077BE')
ax.text(-5.5,-6.4,'Земля')

ax.plot(-3.3,-6.2,'o', color = '#e3dccb',markersize = 8, markerfacecolor = '#f66338')
ax.text(-2.9,-6.4,'Супер Юпитер (масса в 500 раз больше)')

ax.plot(5,-6.2,'o', markersize = 9, markerfacecolor = "#FDB813",markeredgecolor ="#FD7813")
ax.text(5.5,-6.4,'Солнце')

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

## Displaying the Animation
plt.show()

В заключительном этапе проекта мы отображаем анимацию гравитационной симуляции, которая показывает движение Земли и гипотетического "Супер Юпитера". Этот этап включает визуализацию вычисленных позиций планет за период симуляции.

Теперь, когда мы завершили все этапы, мы можем запустить код в настольной среде, используя следующую команду:

cd ~/project
python simulation.py

На этом этапе мы можем визуально оценить результаты их симуляции, наблюдая, как огромный "Супер Юпитер" влияет на орбиту Земли.

Резюме

В этом проекте мы эффективно разработали гравитационную симуляцию с участием Земли и Юпитера с использованием Python. Мы использовали метод Рунге - Кутты 4-го порядка (RK4) для точной численной интеграции и Matplotlib для ясной и привлекательной визуализации. Этот проект не только представляет практическое применение физических и программистских принципов, но и поощряет студентов экспериментировать, изменяя код для симуляции небесных тел различных масс, тем самым исследуя различные гравитационные взаимодействия и динамику.

Гравитационная симуляция Земли и Супер Юпитера