지구와 슈퍼 목성의 중력 시뮬레이션

소개

이 프로젝트에서는 Python 을 사용하여 중력 시뮬레이션을 개발할 것입니다. 이는 지구와 가상의 "슈퍼 목성 (Super Jupiter)" 간의 상호 작용을 보여주며, 슈퍼 목성은 목성 질량의 500 배에 달하는 행성입니다. 이 시뮬레이션은 이러한 거대한 천체가 지구의 움직임에 미치는 영향을 보여주는 것을 목표로 하며, 작용하는 엄청난 중력의 힘을 고려합니다. 이 프로젝트는 물리학, 천문학, 그리고 계산 시뮬레이션에 열정을 가진 학생 및 취미 활동가에게 적합합니다. 이를 위해 수치 계산에는 NumPy 와 같은 Python 라이브러리를, 행성의 역학적 움직임을 시각화하는 데는 Matplotlib 을 사용할 것입니다.

👀 미리보기

🎯 과제

이 프로젝트를 통해 다음을 배우게 됩니다:

• 만유인력의 법칙 (Newton's Law of Universal Gravitation) 을 이해하고 적용하여 천체 간의 상호 작용을 모델링하는 방법.
• Python 프로그래밍을 사용하여 중력 시스템의 계산 모델을 만드는 방법.
• Python 에서 효율적인 수치 계산을 위해 NumPy 라이브러리를 사용하는 방법.
• 목성 질량의 500 배에 달하는 "슈퍼 목성"이 존재할 때 지구의 궤도 역학을 시뮬레이션하는 방법.
• 시뮬레이션 결과를 분석하고 해석하여 거대한 천체가 궤도 역학에 미치는 영향을 이해하는 방법.
• Matplotlib 을 구현하여 시뮬레이션의 시각적 표현을 만들고, 행성의 궤도 경로와 상대적 위치를 보여주는 방법.
• 우주적 맥락에서 힘, 질량, 가속도의 개념을 탐구하는 방법.
• 다양한 시나리오에 맞게 질량, 거리, 시간 간격과 같은 시뮬레이션 매개변수를 미세 조정하는 방법.
• 과학적 계산을 위한 Python 코드 디버깅 및 최적화 기술을 개발하는 방법.

🏆 성과

이 프로젝트를 완료하면 다음을 수행할 수 있습니다:

• 물리학의 기본 원리, 특히 만유인력의 법칙을 실제적인 계산 컨텍스트에 적용할 수 있습니다.
• Python 을 사용하여 물리 기반 시뮬레이션을 생성하고 실행할 수 있습니다.
• 대규모 수치 계산을 효율적으로 처리하기 위해 NumPy 를 사용하는 능력을 입증할 수 있습니다.
• Matplotlib 을 사용하여 복잡한 데이터와 시뮬레이션을 시각화하여 과학적 결과의 해석 가능성을 향상시킬 수 있습니다.
• 행성 운동의 역학과 거대한 천체의 중력의 영향에 대해 이해할 수 있습니다.
• 시뮬레이션 결과를 분석하고 해석하여 천체 역학에 대한 의미 있는 결론을 도출할 수 있습니다.
• 시뮬레이션 매개변수를 조정하고 실험하여 궤도 역학에 대한 더 깊은 이해를 얻을 수 있습니다.
• 프로그래밍 환경, 특히 과학적 컴퓨팅 컨텍스트에서 향상된 문제 해결 및 디버깅 기술을 보여줄 수 있습니다.
• 중력의 힘이 천체의 움직임을 어떻게 형성하는지에 대한 기본적인 지식을 보여주어 천체 물리학 및 계산 모델링에 대한 추가 탐구를 위한 길을 열 수 있습니다.

환경 설정

먼저, 프로젝트 파일을 설정하고 필요한 라이브러리를 가져와야 합니다.

simulation.py라는 Python 파일을 생성합니다:

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 라이브러리를 가져옵니다:

1. typing: 특히, typing 모듈에서 Tuple을 가져옵니다. 이는 Python 에서 타입 힌팅 (type hinting) 에 사용되며, 코드 가독성과 디버깅에 도움이 됩니다. 튜플에 어떤 유형의 값을 그룹화할 수 있는지 지정하여 함수 정의의 일관성과 명확성을 보장합니다.
2. numpy: np로 가져온 numpy 라이브러리는 Python 에서 과학적 계산을 위한 기본적인 패키지입니다. 대규모 다차원 배열과 행렬을 지원하며, 이러한 배열에서 작동하는 광범위한 고급 수학 함수를 제공합니다. 시뮬레이션에서 수치 계산을 처리하는 데 필수적입니다.
3. pylab: py로 가져온 pylab는 Matplotlib 과 함께 설치되는 Matplotlib 의 모듈입니다. MATLAB 과 유사한 인터페이스를 제공하며, 특히 대화형 계산 및 플로팅에 유용합니다. 그러나 matplotlib.pyplot와 numpy를 명시적으로 가져오는 것이 일반적으로 권장됩니다.
4. matplotlib.pyplot: plt로 가져온 이 모듈은 Python 에서 정적, 애니메이션 및 대화형 시각화를 생성하는 데 사용됩니다. 이는 천체의 궤적을 플로팅하는 이 프로젝트의 핵심 측면입니다.
5. matplotlib.animation: Matplotlib 의 이 하위 모듈은 애니메이션을 생성하는 기능을 제공합니다. 중력 시뮬레이션에서 행성의 동적 움직임을 시각화하는 데 필수적입니다.
6. matplotlib.lines.Line2D: Matplotlib 라이브러리의 이 클래스는 플롯에 그릴 수 있는 선 객체를 생성하는 데 사용됩니다. 시뮬레이션에서 더 자세하거나 사용자 정의된 플로팅에 유용합니다.
7. tqdm.trange: tqdm 모듈의 trange는 진행률 미터가 내장된 Python 의 range 함수의 변형입니다. 특히 광범위한 계산을 처리할 때 시뮬레이션에서 루프의 진행률을 표시하는 데 유용합니다.

이러한 라이브러리와 모듈을 가져옴으로써 중력 시뮬레이션 프로젝트에 필요한 복잡한 수치 계산 및 시각화를 위한 기반을 마련합니다. 이 설정은 실제 물리학 및 애니메이션 로직이 구현될 다음 단계에 매우 중요합니다.

상수 정의

시뮬레이션에 사용될 상수를 정의합니다. 여기에는 중력 상수, 천문 단위, 지구, 목성 및 태양의 정규화된 질량이 포함됩니다.

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

이 단계에서는 중력 시뮬레이션에 필요한 몇 가지 필수 상수를 정의합니다. 이러한 상수는 시뮬레이션에서 천체 역학 및 중력 상호 작용을 정확하게 모델링하는 데 기본이 됩니다:

1. 중력 상수 (G): 6.673e-11 (SI 단위) 로 설정된 이 상수는 뉴턴의 만유인력의 법칙에서 매우 중요합니다. 중력의 세기를 나타내며 두 질량 사이의 중력의 힘을 계산하는 데 사용됩니다.
2. 천문 단위 (AU): 1.496e11 킬로미터로 정의되며, 지구에서 태양까지의 평균 거리를 나타냅니다. 이 단위는 태양계 내의 거리를 더 쉽게 관리할 수 있는 방식으로 표현하는 데 사용됩니다.
3. 년 (YEAR): 365*24*60*60.0으로 계산되며, 1 년의 초 수를 나타냅니다. 이는 시간 관련 계산을 천문 시뮬레이션에 더 직관적인 시간 단위인 연도로 변환하는 데 사용됩니다.
4. 정규화 질량 (MM): 6e24로 설정된 이 값은 시뮬레이션에서 다른 질량을 정규화하기 위한 참조 질량으로 사용됩니다. 이는 대략 지구의 질량과 같습니다.
5. 지구의 정규화된 질량 (ME): 6e24/MM으로 계산되며, 정규화된 단위로 지구의 질량을 나타냅니다. 이는 정규화 질량 (MM) 이 지구의 질량을 기반으로 하기 때문에 본질적으로 1 로 설정됩니다.
6. 태양의 정규화된 질량 (MS): 2e30/MM으로 설정되며, 정규화된 단위로 태양의 질량을 나타냅니다. 태양의 질량은 행성에 대한 중력의 영향을 시뮬레이션하는 데 중요한 요소입니다.
7. 목성의 정규화된 질량 (MJ): 이 시뮬레이션에서는 "슈퍼 목성" 시나리오를 나타내기 위해 목성의 질량이 500*1.9e27/MM으로 증폭됩니다. 이 훨씬 더 큰 질량은 훨씬 더 거대한 행성이 지구 궤도에 미치는 영향을 보여줍니다.
8. 시뮬레이션용 중력 상수 (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를 정의합니다. 이 함수는 시뮬레이션의 중요한 구성 요소이며, 뉴턴의 만유인력의 법칙을 적용하여 공간에서 임의의 두 질량 사이에 작용하는 힘을 결정합니다. 다음은 함수의 세부 정보입니다:

1. 함수 정의: gravitational_force 함수는 세 개의 인수를 받습니다:
   • m1 및 m2: 두 물체의 질량 (부동 소수점 값).
   • r: 두 물체 사이의 변위 벡터를 나타내는 NumPy 배열.
2. 힘 크기 계산 (F_mag):
   • 함수는 먼저 F_mag = GG * m1 * m2 / (np.linalg.norm(r) + 1e-20)**2 공식을 사용하여 중력의 힘 크기를 계산합니다.
   • GG는 시뮬레이션에 대한 중력 상수입니다.
   • np.linalg.norm(r)은 두 물체 사이의 유클리드 거리를 계산합니다. 0 으로 나누는 것을 방지하기 위해 작은 숫자 (1e-20) 가 추가됩니다.
3. 방향 결정 (theta 및 F):
   • theta 각도는 np.arctan2를 사용하여 극좌표에서 힘 벡터의 각도를 찾아서 계산합니다. 마찬가지로, x 방향의 변위 (r[0]) 가 0 일 때 0 으로 나누는 것을 방지하기 위해 작은 숫자 (1e-20) 가 분모에 추가됩니다.
   • 그런 다음 힘 벡터 F는 F_mag와 각도 theta를 사용하여 x 및 y 축을 따라 구성 요소 ([np.cos(theta), np.sin(theta)]) 로 계산됩니다.
4. 힘 방향 조정:
   • 힘은 중력 법칙에 따라 항상 인력 (다른 물체를 향함) 이 되도록 힘 벡터 F에 -np.sign(r)을 곱합니다.
5. 힘 벡터 반환:
   • 마지막으로, 함수는 중력 힘 벡터 F를 반환합니다.

이 함수를 구현함으로써 계산 환경에서 물리 법칙을 적용하는 방법을 배웁니다. 이 함수는 시뮬레이션에서 지구와 "슈퍼 목성" 사이의 중력 상호 작용을 계산하는 데 필수적이며, 이는 각 궤도에 영향을 미칩니다.

RK4 Solver 구현

미분 방정식을 풀기 위해 Runge-Kutta 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

이 단계에서는 미분 방정식을 풀기 위해 4 차 Runge-Kutta (RK4) 방법을 사용하는 RK4Solver라는 함수를 구현합니다. 이 방법은 중력 모델에서 행성의 움직임을 정확하게 시뮬레이션하는 데 매우 중요합니다. RK4Solver 함수가 수행하는 작업에 대한 개요는 다음과 같습니다.

1. 함수 정의:
   • RK4Solver는 여러 매개변수를 사용합니다:
     • t: 현재 시간.
     • r: 행성의 현재 위치 벡터.
     • v: 행성의 현재 속도 벡터.
     • h: 시뮬레이션의 시간 단계.
     • planet: 어떤 행성 (지구 또는 목성) 을 시뮬레이션하는지 나타내는 문자열.
     • r_other 및 v_other: 다른 행성의 위치 및 속도 벡터.
2. RK4Solver 내의 도우미 함수:
   • dr_dt(v: np.ndarray) -> np.ndarray: 이 함수는 위치 변화율을 반환하며, 이는 단순히 속도 v입니다.
   • dv_dt(r: np.ndarray, planet: str) -> np.ndarray: 이 함수는 중력에 의한 행성의 가속도를 계산합니다. 이전에 정의된 gravitational_force 함수를 사용하여 태양과 다른 행성 (지구 또는 목성) 에 의해 가해지는 힘을 계산하고 가속도를 반환합니다.
3. Runge-Kutta 계산:
   • RK4 방법은 시간 단계 내의 다른 지점에서 네 개의 "기울기"(k11, k21, k12, k22, k13, k23, k14, k24) 를 계산한 다음, 이를 결합하여 다음 시간 단계에서 위치와 속도에 대한 정확한 추정치를 얻는 것을 포함합니다.
   • 이러한 기울기는 현재 위치와 속도, 그리고 위치 (dr_dt) 와 속도 (dv_dt) 의 도함수를 사용하여 계산됩니다.
4. 위치 및 속도 업데이트:
   • 함수는 RK4 공식에 따라 이러한 기울기의 가중 평균을 사용하여 행성의 다음 위치 (y0) 와 속도 (y1) 를 계산합니다.
5. 결과 반환:
   • 마지막으로, 함수는 행성에 대한 업데이트된 위치 및 속도 벡터 (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 함수에서 일어나는 일은 다음과 같습니다.

1. 지구와 목성의 궤적 길이:
   • earth_trail 및 jupiter_trail 변수가 설정되어 각 행성의 이전 위치 (궤적) 가 얼마나 표시되는지 결정합니다. 이는 각 행성이 이동한 경로를 보여주는 시각적 궤적 효과를 생성합니다.
2. 시간 표시 업데이트:
   • 경과 시간 (tm_yr) 이 계산되어 ttl 텍스트 객체의 텍스트로 설정됩니다. 이는 애니메이션에서 시뮬레이션 시간을 연 단위로 표시합니다.
3. 지구 위치 업데이트:
   • line_earth.set_data는 애니메이션에서 지구의 위치를 업데이트합니다. 위치 배열 r의 슬라이스를 사용하여 궤적 효과를 생성하여 지구의 최근 궤도를 보여줍니다.
4. 목성 위치 업데이트:
   • 마찬가지로, line_jupiter.set_data는 r_jupiter 배열의 슬라이스를 사용하여 목성의 위치를 업데이트합니다. 목성의 더 긴 궤적 길이는 더 큰 궤도를 반영합니다.
5. 업데이트된 객체 반환:
   • 함수는 업데이트된 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]

이 단계에서는 지구와 목성의 움직임에 대한 애니메이션을 시작하는 데 중요한 시뮬레이션의 초기 조건과 매개변수를 설정합니다. 수행되는 작업에 대한 요약은 다음과 같습니다.

1. 시간 초기화:
   • ti와 tf는 시뮬레이션의 시작 시간과 종료 시간으로 연 단위로 설정됩니다 (0~120 년).
   • N은 시뮬레이션의 총 점 수로 정의되며, 연간 100 점으로 계산됩니다.
   • t는 np.linspace를 사용하여 초기 시간부터 최종 시간까지의 시간 단계를 나타내도록 생성된 배열입니다.
   • h는 시간 단계이며, t 배열의 처음 두 요소의 차이로 계산됩니다.
2. 위치 및 속도 초기화:
   • 배열 r과 v는 각 시간 단계에서 지구의 위치와 속도를 저장하도록 초기화됩니다. 이들은 0 으로 초기화되고 각 시간 단계에 대해 두 개의 좌표 (x 및 y) 를 수용하는 모양을 갖습니다.
   • 마찬가지로, r_jupiter와 v_jupiter는 목성의 위치와 속도를 저장하도록 초기화됩니다.
3. 초기 조건 설정:
   • 지구의 초기 위치 (r[0]) 는 천문 단위 (AU) 로 정규화된 태양으로부터의 거리에 설정됩니다.
   • 목성의 초기 위치 (r_jupiter[0]) 는 태양으로부터 5.2 AU 로 설정되어 태양계에서의 실제 위치를 반영합니다.
   • 지구의 초기 속도 (v[0]) 는 태양에 의해 가해지는 중력에 따라 계산됩니다.
   • 목성의 초기 속도 (v_jupiter[0]) 는 실제 궤도 속도를 반영하는 특정 값으로 설정됩니다.

이 단계는 시뮬레이션의 시작점을 설정하므로 기본적인 단계입니다. 초기 위치와 속도는 중력의 영향 아래에서 두 행성의 후속 운동을 계산하는 데 중요합니다.

시뮬레이션 실행

RK4 솔버를 사용하여 정의된 시간 프레임 동안 시뮬레이션을 실행하고 행성의 위치를 업데이트합니다.

## 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 함수를 사용하여 지정된 기간 동안 지구와 목성의 움직임을 계산하는 곳입니다. 이 프로세스에 대한 간단한 설명은 다음과 같습니다.

1. 시뮬레이션 루프 실행:
   • 루프는 시뮬레이션의 총 시간 단계 수인 N - 1번 반복되도록 설정됩니다. 이 루프는 각 시간 단계를 통해 시뮬레이션을 진행하는 데 중요합니다.
   • tqdm 모듈의 trange 함수는 시간 단계를 반복하는 데 사용됩니다. 이는 시뮬레이션 진행 상황을 보여주는 진행률 표시줄 ("Generating Animation"으로 설명됨) 을 제공합니다.
2. 지구와 목성의 위치 및 속도 업데이트:
   • 루프의 각 반복 내에서 RK4Solver 함수가 두 번 호출됩니다.
     • 한 번은 다음 시간 단계에서 지구의 위치 (r[i + 1]) 와 속도 (v[i + 1]) 를 업데이트합니다.
     • 한 번은 다음 시간 단계에서 목성의 위치 (r_jupiter[i + 1]) 와 속도 (v_jupiter[i + 1]) 를 업데이트합니다.
   • RK4Solver 함수는 행성의 현재 위치와 속도, 다른 행성의 위치와 속도를 사용하여 새로운 상태를 계산합니다.
3. 상호 작용 시뮬레이션:
   • 이 루프는 본질적으로 각 작은 시간 단계에서 지구와 목성 간의 중력 상호 작용을 시뮬레이션하여 (서로에 대한 영향과 태양의 영향을 고려하여) 시간이 지남에 따라 궤도를 현실적으로 표현합니다.

이 루프가 끝나면, 지구와 목성의 각 시간 단계에서의 위치와 속도로 채워진 배열 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$ 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()

프로젝트의 마지막 단계에서는 지구와 가상의 "Super Jupiter"의 움직임을 보여주는 중력 시뮬레이션의 애니메이션을 표시합니다. 이 단계는 시뮬레이션 기간 동안 계산된 행성의 위치를 시각화하는 것을 포함합니다.

이제 모든 단계를 완료했으므로 다음 명령을 사용하여 데스크톱 환경에서 코드를 실행할 수 있습니다.

cd ~/project
python simulation.py

이 단계에서 시뮬레이션 결과를 시각적으로 확인할 수 있으며, 거대한 "Super Jupiter"가 지구의 궤도에 어떻게 영향을 미치는지 관찰할 수 있습니다.

요약

이 프로젝트에서 우리는 Python 을 사용하여 지구와 목성을 특징으로 하는 중력 시뮬레이션을 효과적으로 개발했습니다. 정확한 수치 적분을 위해 Runge-Kutta 4 차 (RK4) 방법을 사용했으며, 명확하고 매력적인 시각화를 위해 Matplotlib 을 사용했습니다. 이 프로젝트는 물리학 및 코딩 원리의 실질적인 적용을 제공할 뿐만 아니라, 학생들이 코드를 변경하여 다양한 질량의 천체를 시뮬레이션함으로써 다양한 중력 상호 작용과 역학을 탐구하도록 장려합니다.