LAPORAN AKHIR PROYEK

KOMPUTASI NUMERIK

KELOMPOK 5
MODEL GERAK PLANET

Nama anggota : Arif Darma Leksono

Fajar Alif Ramadhan
Raina Sesilia Nurfitrieni Sugandi
NPM : 140310200018
140310200029
140310200013
Hari/Tanggal : Selasa, 14 Juni 2021
Asisten : Ratu Kila

LABORATORIUM KOMPUTASI
DEPARTEMEN FISIKA
FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM
UNIVERSITAS PADJADJARAN
2021
 BAB I

PENDAHULUAN

1.1 Latar Belakang

Seorang ilmuwan bernama Johannes Kepler menemukan hukum yang mengatur pergerakan bumi
mengelilingi matahari, khususnya yang menyangkut perubahan jarak bumi ke matahari. Hukum-
hukum Kepler tentang peredaran bumi mengelilingi matahari dapat dinyatakan sebagai berikut:
pertama, semua planet bergerak dalam orbit ellips dengan matahari berada di salah satu fokusnya.
Kedua, garis yang menghubungkan tiap planet ke matahari menyapu luasan yang sama dalam
waktu yang sama. Ketiga, kuadrat periode tiap planet sebanding dengan pangkat tiga jarak rata-
rata planet terhadap matahari
Pada era modern, hukum Kepler digunakan untuk mengaproksimasi orbit satelit dan benda-benda
yang mengorbit matahari, yang semuanya belum ditemukan pada saat Kepler hidup (planet luar
dan asteroid). Hukum ini kemudian diaplikasikan untuk semua benda kecil yang mengorbit benda
lain yang jauh lebih besar, walaupun beberapa aspek seperti gesekan atmosfer (gerakan di orbit
rendah), atau relativitas dan keberadaan benda lainnya dapat membuat hasil hitungan tidak akurat
dalam berbagai keperluan.
Kajian tentang lintasan dan gerak planet dapat disimulasikan dengan metode komputasi. Proyek
ini akan menggambarkan bagaimana gerak yang dihasilkan oleh planet meliputi kecepatan dan
posisi setiap saat yang dialami oleh planet. Proyek ini akan menganalisis aplikasi metode tersebut
dalam simulasi delapan planet yang saling berinteraksi satu sama lain dan dengan matahari.
1.2 Rumusan Masalah

1.2.1 Bagaimana menentukan kecepatan dan posisi planet secara numerik dengan
menggunakan metode Runge Kutta Orde 4 ?
1.2.2. Bagaimana Grafik lintasan gerak planet?
1.2.3. Bagaimana cara menentukan kecepatan planet pada waktu tertentu menggunakan
metode interpolasi Lagrange ?

1.3 Tujuan

1.3.1 Dapat menentukan kecepatan dan posisi planet secara numerik dengan menggunakan
metode Runge Kutta Orde 4
1.3.2 Dapat menampilkan Grafik lintasan gerak planet
1.3.3 Dapat menentukan kecepatan planet pada waktu tertentu menggunakan
metode interpolasi Lagrange
 BAB II

TEORI DASAR

2.1 Tinjuan Pustaka Secara Fisika

2.1.1 Hukum Gravitasi Newton

Hukum gravitasi newton menyatakan bahwa dua objek yang bermassa akan mengalami
gaya tarik menarik yang besarnya sebanding dengan perkalian dari massa kedua objek tersebut
dan berbanding terbalik dengan kuadrat jarak antara pusat kedua objek tersebut. Secara matematis,
persamaan tersebut dapat dituliskan seperti berikut :

𝑚 1 𝑚2
𝐹=𝐺
𝑟2

Dimana : G adalah konstanta gravitasi (6.674× 10−11)

m adalah massa dari objek
R adalah jarak antara titik pusat kedua objek
F adalah gaya gravitasi
Persamaan ini juga dapat kita tinjau dengan menggunakan vektor. Perhatikan gambar
berikut :
Pada gambar di atas kita memiliki dua buah partikel. Partikel pertama memiliki massa m dan
berada pada koordinat (x,y,z). Sementara itu kita memiliki partikel dengan massa m’ dan berada
pada (x’,y’,z’) . Berdasarkan hukum gravitasi newton, gaya tarik menarik yang dituimbulkan oleh
kedua partikel tersebut adalah :

𝑚 𝑚′
𝐹=𝐺 𝑟̂
𝑟2
Kita dapat mencari jarak antara kedua partikel (r) dengan menggunakan persamaan :

𝑟 = √(𝑥′ − 𝑥)2 + (𝑦′ − 𝑦)2 + (𝑧′ − 𝑧)2

2.1.2 Model Gerak Planet

Model gerak suatu planet dapat kita cari dengan menggabungkan persamaan gaya gravitasi
dengan hukum kedua newton. Hukum kedua newton menyatakan bahwa gaya yang dialami suatu
benda besarnya sama besar dengan perkalian percepatan benda tersebut dengan massanya. Untuk
proyek ini, kita akan mencari model gerak planet pada bidang dua dimensi sehingga kita harus
posisi dari planet tersebut pada sumbu x dan juga sumbu y. Hal ini berarti gaya gravitasi yang
dialami planet juga harus ditinjau pada sumbu x serta sumbu y. Secara matematis persamaannya
dapat ditulis sebagai berikut:

𝑑2𝑥
𝐹𝑥 = 𝑚
𝑑𝑡 2
𝑑2𝑦
𝐹𝑦 = 𝑚
𝑑𝑡 2
 Setelah membahas hukum gravitasi pada bagian sebelumnya kita mengetahui bahwa gaya
gravitasi memiliki arah. Kita akan membagi gaya gravitasi menjadi dua yaitu gaya gravitasi pada
sumbu x dan sumbu y. Persamaannya dapat dituliskan seperti berikut :

𝑥′ − 𝑥
𝐹𝑥 = 𝐹
𝑟
𝑦′ − 𝑦
𝐹𝑦 = 𝐹
𝑟

Untuk mendapatkan persamaan model gerak planet, kita akan menggabungkan kedua
persamaan sehingga kita mendapatkan :
𝑑2 𝑥 𝑥′ − 𝑥
𝑚 = 𝐹
𝑑𝑡 2 𝑟
2
𝑑 𝑦 𝑦′ − 𝑦
𝑚 = 𝐹
𝑑𝑡 2 𝑟

Dengan memasukkan persamaan gaya gravitasi kedalam persamaan diatas, kita akan
mendapatkan persamaan diferensial berikut :
𝑑2 𝑥 𝑥′ − 𝑥
= − 𝐺𝑚′
𝑑𝑡 2 𝑟3
2
𝑑 𝑦 𝑦′ − 𝑦
= − 𝐺𝑚′
𝑑𝑡 2 𝑟3
Dimana m’ merupakan massa dari objek yang sedang diorbit (contoh: matahari) , (x’-x)
adalah jarak antara kedua objek pada sumbu x, dan r adalah jarak dari titik pusat kedua objek.
Karena kita meninjau persamaan ini secara dua dimensi , maka r dapat dicari dengan menggunakan
persamaan :

𝑟 = √(𝑥′ − 𝑥)2 + (𝑦′ − 𝑦)2

 Untuk menjadikan persamaan diatas menjadi PDB orde-1 kita dapat mengganti turunan
kedua dari posisi dengan turunan pertama dari kecepatan.

𝑑𝑣𝑥 𝑥′ − 𝑥
= −𝐺𝑚′
𝑑𝑡 𝑟3
𝑑𝑣𝑦 𝑦′ − 𝑦
= −𝐺𝑚′
𝑑𝑡 𝑟3
Persamaan diferensial orde satu di atas adalah persamaan yang akan digunakan untuk
menghitung model gerak planet.

2.2 Tinjauan Pustaka Secara Numerik

2.2.1 Metode Runge-Kutta Orde-4

Metode runge kutta orde-4 adalah sebuah metode numerik yang digunakan untuk
menyelesaikan atau mencari solusi dari sebuah persamaan diferensial biasa. Metode ini dapat
menghasilkan perhitungan dengan akurasi tinggi seperti pada deret taylor tanpa memerlukan
turunan-turunan bertingkat tinggi. Pada metode runge kutta, semakin tinggi ordenya semakin
tinggi pula akurasinya. Untuk proyek ini, kita akan menggunakan metode runge kutta orde-4.
Metode ini akan kita gunakan untuk mencari kecepatan planet pada sumbu x dan y pada waktu
tertentu. Dengan menggunakan metode runge kutta, kita dapat menuliskan solusi dari PDB pada
bagian 2.1.2 sebagai berikut :
Untuk sumbu x :
1
𝑉𝑥𝑖+1 = 𝑉𝑥𝑖 + (𝑘1 + 2𝑘2 + 2𝑘3 + 𝑘4 )𝛥𝑡
6
𝑖+1
𝑥 = 𝑥 𝑖 − 𝑉𝑥𝑖+1 𝛥𝑡
Dimana :
𝑥′ − 𝑥
𝑘1 = −𝐺𝑚′
𝑟3
𝑥′−𝑥
𝑘2 = −𝐺𝑚′ 𝑟 3 - 0.5𝑘1 𝛥𝑡
𝑥′−𝑥
𝑘3 = −𝐺𝑚′ - 0.5𝑘2 𝛥𝑡
𝑟3
𝑥′−𝑥
𝑘4 = −𝐺𝑚′ +𝑘3 𝛥𝑡
𝑟3
 Untuk sumbu y :
1
𝑉𝑦𝑖+1 = 𝑉𝑦𝑖 + (𝑘1 + 2𝑘2 + 2𝑘3 + 𝑘4 )𝛥𝑡
6
𝑖+1
𝑦 = 𝑦 𝑖 − 𝑉𝑦𝑖+1 𝛥𝑡
Dimana :
𝑦′ − 𝑦
𝑘1 = −𝐺𝑚′
𝑟3
𝑦′−𝑦
𝑘2 = −𝐺𝑚′ - 0.5𝑘1 𝛥𝑡
𝑟3
𝑦′−𝑦
𝑘3 = −𝐺𝑚′ 3 - 0.5𝑘2 𝛥𝑡
𝑟
𝑦′−𝑦
𝑘4 = −𝐺𝑚′ 3 +𝑘3 𝛥𝑡
𝑟
Jadi dengan menggunakan metode Runge-Kutta orde-4, kita dapat menghitung kecepatan
dari planet pada waktu tertentu. Kita kemudian dapat menggunakan kecepatan tersebut untuk
menghitung posisi dari planet pada sumbu x dan y. Setelah kita memliki data posisi planet tersebut
mulai dari titik awal hingga akhir, kita dapat memplotkannya kedalam grafik sehingga kita
memiliki model gerak planet.
 2.2.2 Metode Interpolasi Lagrange

Metode interpolasi lagrange adalah sebuah metode untuk mencari persamaan polinomial
dengan menggunakan titik-titk data yang sembarang atau tidak berselang sama. Misalkan kita
memiliki fungsi f(x) kontinu & diferensiabel sampai turunan (n+1) dalam interval buka (a,b).
Diberikan (n+1) titik (x0,y0), (x1,y1), …, (xn,yn) dengan nilai x tidak perlu berjarak sama dengan
yang lainnya, dan akan dicari suatu polinom berderajat n. Maka, persamaan interpolasi lagrange
dapat dinyatakan dengan :

Dengan :

Dimana n adalah orde dari persamaan polinomial dan x adalah variabel dari persamaan
polinomial . Untuk menghitung interpolasi berorde n, kita harus memiliki setidaknya n+1 pasangan
data. Pada program ini, interpolasi akan digunakan untuk menentukan kecepatan dari sebuah
planet pada waktu tertentu. Ketika kita telah menghitung kecepatan dari planet menggunakan
metode runge-kutta orde-4, masih terdapat titik-titik data yang tidak diketahui. Hal ini disebabkan
oleh perhitungan metode runge kutta yang menggunakan step size. Di antara suatu data dan data
sesudahnya terdapat data yang tidak diketahui nilainya. Dengan menggunakan interpolasi
lagrange, kita dapat mengetahui kecepatan dari planet pada rentang data yang tidak diketahui
tersebut.
 BAB III

HASIL dan PEMBAHASAN

3.1 Flowchart
3.2 Hasil

3.2.1 Listing program

import matplotlib.pyplot as plt
import numpy as np
#data
g=6.67408*(10**-11)
M=1.989*(10**30)
R=151760000
#data planet
r1=0.39*R
v1=48
r2=0.72*R
v2=35
r3=R
v3=30
r4=1.523*R
v4=24
r5=5.2*R
v5=13
r6=9.55*R
v6=9.7
r7=19.19*R
v7=6.8
r8=30.11*R
v8=5.4
P=[0,88,224,365,687,4331,10747,30589,59800]

#input h
def inputh() :
global h
print('\n----------------------------------------------------------------
')
h=float(input("Silahkan masukkan variasi delta t yang diinginkan : "))
ans=str(input('Apakah input yang anda masukkan sudah benar (ya/tidak) ?
'))
if ans == 'ya' or ans == 'Ya' or ans =='y':
start=input('Klik Enter Untuk Memulai Perhitungan... ')
elif ans == 'tidak' or ans == 'Tidak' or ans=='t':
inputh()
else :
print('\n------------------ Maaf input anda belum benar -------------
----')
inputh()

def inputt() :
global td
print('\n----------------------------------------------------------------
')
td=float(input("Silahkan masukkan t (dalam satuan hari) : "))
ans=str(input('Apakah input yang anda masukkan sudah benar (ya/tidak) ?
'))
 if ans == 'ya' or ans == 'Ya' or ans =='y':
start=input('Klik Enter Untuk Memulai Perhitungan... ')
elif ans == 'tidak' or ans == 'Tidak' or ans=='t':
inputt()
else :
print('\n------------------ Maaf input anda belum benar -------------
----')
inputt()

#introduksi program
print("\n| INTRODUKSI PROGRAM |")
print("|--------------------------------------------------------------|")
print("| Program ini akan menggunakan metode runge kutta untuk |")
print("|--------------------------------------------------------------|")
print("|menghasilkan grafik lintasan orbit planet pada tata surya bima|")
print("|--------------------------------------------------------------|")
print("| sakti yang beranggotakan 8 planet, yaitu: Merkurius, Venus, |")
print("|--------------------------------------------------------------|")
print("| Bumi, Mars, Jupiter, Saturnus, Uranus, dan Neptunus |")
print("|--------------------------------------------------------------|")
start=input('Klik Enter untuk memulai program... ')

print('\n----------------------------------------------------------------')
print('\n PROGRAM DIMULAI ')
inputh()

#fungsi RK
#input : x awal,y awal,v awal ,h
#output : array : X,Y,Vx,Vy
def MGP(r,va,h,p) :
#data dan perhitungan x
i=0
xa=r
x=r
v=0
X=np.array([x/R])
Vx=np.array([v])

while x<= xa :
K1=-g*M*x/(r**3)
K2=-g*M*x/(r**3)-(0.5*K1*h)
K3=-g*M*x/(r**3)-(0.5*K2*h)
K4=-g*M*x/(r**3)+(K3*h)
v = v + (h/6)*(K1+(2*K2)+(2*K3)+K4)
x = x + v*(h)
X=np.append(X,x/R)
Vx=np.append(Vx,v)
i = i+1

k = max(Vx)/va
Vx=Vx/k

#data dan perhitungan Y

n=i
v=va*k
y=0
i=0
 Y=np.array([y])
Vy=np.array([v])
while i<n :
K1=-g*M*y/(r**3)
K2=-g*M*y/(r**3)-(0.5*K1*h)
K3=-g*M*y/(r**3)-(0.5*K2*h)
K4=-g*M*y/(r**3)+(K3*h)
v = v + (h/6)*(K1+(2*K2)+(2*K3)+K4)
y = y + v*(h)
Y=np.append(Y,y/R)
Vy=np.append(Vy,v)
i = i+1

Vy=Vy/k
t = np.arange(0, p+p/i , p/i)
return X,Y,Vx,Vy,t

def closest(lst, K):

return lst[min(range(len(lst)), key = lambda i: abs(lst[i]-K))]

#fungsi interpolasi lagrange

#input : Vx/y,t (array),t dicari
#output : Vx/y dicari
def lagrange (V,t,td,p) :
if td>p :
while td>p :
td=td-p
sigma=0
tc=closest(t, td)
N=np.where(t==tc)
ti=int(N[0])
if ti>(len(t)-3) :
V=(V[ti-2],V[ti-1],V[ti],V[-(len(t)-1-ti)],V[1-(len(t)-1-ti)])
t=(t[ti-2],t[ti-1],t[ti],t[-(len(t)-1-ti)],t[1-(len(t)-1-ti)])
else :
V=(V[ti-2],V[ti-1],V[ti],V[ti+1],V[ti+2])
t=(t[ti-2],t[ti-1],t[ti],t[ti+1],t[ti+2])
n=4
for i in range(0,n+1):
pi=1
for j in range (0,i):
pi=pi*((td-t[j])/(t[i]-t[j]))
for j in range (i+1,n+1):
pi=pi*((td-t[j])/(t[i]-t[j]))
sigma=sigma+pi*V[i]
return sigma

#perhitungan
X1,Y1,Vx1,Vy1,t1=MGP(r1,v1,h,P[1])
X2,Y2,Vx2,Vy2,t2=MGP(r2,v2,h,P[2])
X3,Y3,Vx3,Vy3,t3=MGP(r3,v3,h,P[3])
X4,Y4,Vx4,Vy4,t4=MGP(r4,v4,h,P[4])
X5,Y5,Vx5,Vy5,t5=MGP(r5,v5,h,P[5])
X6,Y6,Vx6,Vy6,t6=MGP(r6,v6,h,P[6])
X7,Y7,Vx7,Vy7,t7=MGP(r7,v7,h,P[7])
X8,Y8,Vx8,Vy8,t8=MGP(r8,v8,h,P[8])
#output grafik
plotmgp=plt.figure(1)
plt.plot(X1,Y1,'red',label='Merkuri')
plt.plot(X2,Y2,'blue',label='Venus')
plt.plot(X3,Y3,'green',label='Bumi')
plt.plot(X4,Y4,'purple',label='Mars')
plt.xlabel('X (AU)')
plt.ylabel('Y (AU)')
plt.legend()
plt.grid()
plt.title('Model gerak planet 1-4')

plotmgp=plt.figure(2)
plt.plot(X5,Y5,'cyan',label='Jupiter')
plt.plot(X6,Y6,'yellow',label='Saturnus')
plt.plot(X7,Y7,'magenta',label='Uranus')
plt.plot(X8,Y8,'orange',label='Neptunus')
plt.xlabel('X (AU)')
plt.ylabel('Y (AU)')
plt.legend()
plt.grid()
plt.title('Model gerak planet 5-8')
plt.show()
print('\n----------------------------------------------------------------')
print(' Grafik lintasan gerak planet dapat dilihat di atas ')
print('----------------------------------------------------------------')

print('\nSekarang program akan menghitung Kecepatan masing-masing planet ')

print(' setelah selang waktu t dari titik awal ')
inputt()

#Output hasil interpolasi

vxd1=lagrange(Vx1,t1,td,P[1])
vyd1=lagrange(Vy1,t1,td,P[1])
vxd2=lagrange(Vx2,t2,td,P[2])
vyd2=lagrange(Vy2,t2,td,P[2])
vxd3=lagrange(Vx3,t3,td,P[3])
vyd3=lagrange(Vy3,t3,td,P[3])
vxd4=lagrange(Vx4,t4,td,P[4])
vyd4=lagrange(Vy4,t4,td,P[4])
vxd5=lagrange(Vx5,t5,td,P[5])
vyd5=lagrange(Vy5,t5,td,P[5])
vxd6=lagrange(Vx6,t6,td,P[6])
vyd6=lagrange(Vy6,t6,td,P[6])
vxd7=lagrange(Vx7,t7,td,P[7])
vyd7=lagrange(Vy7,t7,td,P[7])
vxd8=lagrange(Vx8,t8,td,P[8])
vyd8=lagrange(Vy8,t8,td,P[8])

print('\n')
print('---------------------------------------')
print(' Hasil Perhitungan ')
print('---------------------------------------')
print('Planet Vx(km/s) Vy(km/s)')
print('---------------------------------------')
print('Merkuri %.2f %.2f'%(vxd1,vyd1))
print('Venus %.2f %.2f'%(vxd2,vyd2))
print('Bumi %.2f %.2f'%(vxd3,vyd3))
print('Mars %.2f %.2f'%(vxd4,vyd4))
print('Jupiter %.2f %.2f'%(vxd5,vyd5))
print('Saturnus %.2f %.2f'%(vxd6,vyd6))
print('Uranus %.2f %.2f'%(vxd7,vyd7))
print('Neptunus %.2f %.2f'%(vxd8,vyd8))

print('\n--------------- FINISH ----------------')

3.2.2 Tampilan program
3.2.2.1 Input program
- Introduksi program

Gambar 1.1
- Input delta t

Gambar 1.2
- Konfirmasi input

Gambar 1.3
- Jika menjawab ‘tidak’

Gambar 1.4
- Jika menjawab selain ‘ya’ atau ‘tidak’

Gambar 1.5
- Jika menjawab ‘ya’

Gambar 1.6
- Input t

Gambar 1.7
- Jika menjawab ‘ya’

Gambar 1.8
3.2.2.2 Output program
- Grafik lintasan planet Merkurius,Venus,Bumi,dan Mars

Gambar 2.1

- Grafik lintasan planet Jupiter,Saturnus,Uranus,dan Neptunus

Gambar 2.2
 - Hasil Interpolasi Kecepatan planet

Gambar 2.3

3.3 Analisa
Program ini berfungsi untuk menentukan posisi planet dimana program ini menggunakan
runge kutta sebagai metode numeriknya. Pada awal program ditampilkannya introduksi program
yang berfungsi untuk mengenalkan program atau deskripsi program. Lalu selanjutnya program ini
meminta pengguna untuk meng-input nilai dari delta t. Lalu selanjutnya program akan memastikan
bahwa nilai yang di input benar, apabila nilai yang di input benar maka akan dilanjutkan ke
program selanjutnya namun apabila inputan yang dimasukkan salah karena kesalahan pengguna
dan pengguna dapat meng-input tidak dan program akan mengulang kembali meminta input delta
t. Selanjutnya program akan meminta nilai t, dimana nilai t ini adalah variabel yang akan
digunakan pada metode selanjutnya yaitu metode interpolasi forward newton untuk mengetahui
kecepatan benda pada waktu tertentu. Program kembali menanyakan atau memastikan bahwa nilai
yang di-input-kan benar, apabila benar program akan mengeksekusi lanjut. Apabila pengguna
merasa bahwa nilai tersebut salah karena pengguna melakukan kesalahan input dapat meng-input
tidak maka program akan meminta kembali nilai input yang di inginkan oleh program. Setelah
meng-input nilai maka program akan menampilkan hasil program berupa grafik gerak planet pada
orbitnya dan menampilkan kecepatan planet pada waktu tertentu berupa kecepatan pada sumbu-x
dan sumbu-y.
3.3.1 Analisa Input Program
Pada program ini pengguna akan diminta 2 input berupa input delta t kutta dengan tampilan
"Silahkan masukkan variasi delta t yang diinginkan : " dan waktu nilai waktu yang diinginkan
dengan tampilan "Silahkan masukkan t (dalam satuan hari) : ". Pada masing masing input akan
dimasukan pada metode yang berbeda dimana apabila meng-input-kan nilai delta t maka nilai
tersebut akan disubtitusikan pada metode runge kutta yang akan menghasilkan nilai k1,k2,k3, dan
k4 dimana setelah menemukan nilai-nilai k tersebut akan disubtitusikan untuk mendapatkan nilai
x dan v0 (Jarak tempuh dan Kecepatan awal) pada masing masing planet pada tata surya bima
sakti tersebut. Pada metode runge kutta jelas bahwa yang digunakan adalah gerak benda planet 2
dimensi dimana yang akan dihasilkan berupa v0 (Kecepatan awal) pada sumbu-x dan sumbu-y.
Lalu input nilai waktu yang diinginkan akan disubtitusikan pada metode interpolasi hukum
newton, dimana pada metode tersebut digunakan untuk menemukan nilai dari kecepatan benda
planet pada posisi tertentu dan waktu tertentu.

Pada setiap input akan diberi pertanyaan 'Apakah input yang anda masukkan sudah benar
(ya/tidak) ? 'Hal tersebut berguna apabila pengguna melakukan kesalahan pada input data yang
pada akhirnya dapat diperbaiiki dengan cara mengatakan tidak maka input data akan diminta ulang
dan apabila sudah benar pengguna dapat menuliskan ya, maka program akan melanjutkan ke tahap
subtitusi nilai tersebut pada rumus yang telah dibuat. Pada hal tersebut program ini menggunakan
pengkondisian bercabang dengan perintah if, elif, dan else. Pada listing input digunakan fungsi
deff dimana hal tersebut agar listing program tertata rapih yang pada akhirnya pembuat listing
lebih mudah untuk mengidentifikasi kesalahan atau error yang terjadi pada program tersebut.
3.3.2 Analisa Perhitungan Program

Pada program, terdapat dua perhitungan pokok yaitu perhitungan kecepatan dan posisi
planet menggunakan metode Runge Kutta orde-4 dan perhitungan kecepatan planet menggunakan
interpolasi lagrange. Kedua perhitungan ini dilakukan didalam fungsinya masing-masing. Untuk
perhitungan kecepatan dan posisi planet menggunakan metode runge kutta, fungsi yang digunakan
dinamakan MGP. Sementara itu fungsi yang digunakan untuk melakukan interpolasi kecepatan
planet dinamakan lagrange. Fungsi lagrange ini juga menggunakan fungsi pembantu yang
dinamakan closest.

Fungsi MGP memiliki empat input yaitu jarak awal dari matahari, kecepatan awal, step
size atau delta t, dan periode orbit planet. Keempat input ini merupakan data yang harus dimiliki
apabila kita ingin menghitung model gerak planet menggunakan metode runge kutta. Dengan
mengetahui jarak dan kecepatan awal kita dapat menghitung jarak dan kecepatan pada iterasi
selanjutnya. Step size digunakan pada perhitungan setiap iterasi metode runge kutta dan besar dari
step size akan mempengaruhi proses perhitungan. Periode orbit dari planet tidak secara langsung
digunakan dalam perhitungan model gerak planet tetapi periode orbit akan digunakan untuk
memplot kecepatan dan posisi planet terhadap waktu. Fungsi MGP pertama dimulai dengan
menetapkan nilai dari beberapa variabel. Variabel i adalah variabel yang menyatakan jumlah
iterasi dari metode runge kutta. Variabel xa menyatakan posisi awal planet pada sumbu x. Pada
metode ini kita mengasumsikan bahwa posisi awal dari x adalah sama dengan jarak planet dengan
matahari sehingga xa=x=r. Pada metode ini kita juga akan membuat asumsi bahwa kecepatan awal
dari planet adalah sama dengan nol . Setelah itu kita akan membuat dua buah array numpy untuk
menyimpan data posisi dan kecepatan pada sumbu x, array ini dinamakan X dan Vx.
 Bagian inti dari fungsi ini berada pada perulangan while. Dalam perulangan ini program
akan menghitung kecepatan planet dengan menggunakan metode runge kutta orde-4. Setelah
menghitung kecepatan dan posisi pada suatu iterasi, program akan memasukkan nilai kecepatan
dan posisi yang telah dihitung kedalam array Vx dan X. Perulangan ini akan berlangsung selama
jarak pada sumbu x planet tidak lebih besar daripada jarak awalnya. Ketika posisi x telah lebih
besar dari posisi awalnya kita mengetahui bahwa planet telah melakukan satu kali orbit terhadap
matahari sehingga perulangan dapat dihentikan.

Perhitungan pada sumbu y cukup sama dengan pada sumbu. Perbedaan utamanya ada pada
kondisi awal. Pada metode ini kita mengasumsikan posisi y awal dari planet adalah nol dan
kecepatan awal dari planet adalah sama dengan kecepatan rata-rata orbit planet. Untuk perhitungan
y ini, kita juga perlu membuat dua array numpy yang akan digunakan untuk menyimpan data posisi
dan kecepatan planet. Setelah itu program akan memasuki perulangan while. Perhitungan dalam
perulangan ini sama dengan pada sumbu . Namun syarat dari perulangan while nya berbeda. Pada
perulangan ini syaratnya adalah jumlah iterasi harus lebih kecil dari jumlah iterasi perhitungan
pada sumbu x. Hal ini menyebabkan jumlah iterasi perhitungan pada sumbu x dan y menjadi sama.
Hal ini penting karena ketika jumlah iterasi berbeda, kita tidak dapat memplot posisi x dengan y
karena keduanya tidak memiliki jumlah data yang sama. Pada bagian akhir dari program ini, fungsi
akan membuat sebah array numpy menggunakan numpy arange . Array ini menyatakan waktu dari
setiap posisi dan kecepatan planet. Jumlah data pada array ini pun juga dibuat sama dengan jumlah
iterasi perhitungan. Array ini akan dimulai dengan t=0 dan berakhir dengan t=p dimana p adalah
periode orbit.
 Fungsi selanjutnya yang akan digunakan pada program adalah fungsi lagrange. Fungsi ini
akan menghitung kecepatan dari sebuat planet pada waktu tertentu menggunakan interpolasi
lagrange. Fungsi ini memiliki empat input yaitu array kecepatan (bisa x atau y),array waktu, waktu
dimana kecepatan planet ditanya (td), dan periode orbit. Keempat input ini memiliki perannya
masing-masing. Fungsi akan dimulai dengan menetapkan beberapa hal seperti nilai dari td.
Walaupun nilai dari td telah diinputkan kedalam fungsi, apabila td lebih besar dari periode orbit
maka program tidak memiliki data untung menghitung interpolasinya. Sehingga kita melakukan
sebuah pengkondisian dimana ketika td lebih besar dari periode orbit, program akan terus menerus
mengulangi td dengan periode orbit hingga td lebih kecil dari periode orbit. Fungsi ini juga
menggunakan fungsi pembantu yang dinamakan closest. Fungsi closest ini akan mencari nilai yang
paling dekat dengan sebuah nilai x (yang di input) pada sebuah array atau list. Fungsi ini akan
mencari nilai pada array t yang paling dekat dengan td yang diinput. Selanjutnya program akan
mengambil lima data dari masing-masing array waktu dan kecepatan yang akan digunakan sebagai
data utama perhitungan interpolasi. Hal ini dilakukan karena ketika kita menggunakan seluruh data
dari array kecepatan dan waktu hasil interpolasi pada t yang nilainya mendekati periode orbit akan
tidak akurat sama sekali. Hal ini juga disebabkan oleh metode lagrange yang tidak stabil dalam
menghitung interpolasi yang menggunakan banyak data. Selain itu, fungsi dari kecepatan apabila
kita gambar pada grafik akan berbentuk sinusoidal. Fungsi sinusoidal merupakan fungsi yang sulit
untuk diinterpolasikan dengan menggunakan metode lagrange dan memerlukan interpolasi khusus
yang dinamakan “interpolasi trigonometri”.

Setelah mengambil data dari kedua array program akan melakukan perhitungan interpolasi
sesuai dengan metode lagrange. Metode lagrange menggunakan sigma sehingga kita
menggunakan perulangan pada fungsi ini. Perulangan pada fungsi ini digunakan untuk menghitung
sigma dan juga pi pada metode lagrange. Setelah program telah mencapai iterasi terakhir, fungsi
akan mengoutputkan kecepatan yang dicari.
 Setelah kedua fungsi tersebut telah ditetapkan program dapat mulai memasuki proses
perhitungan. Dalam proses perhitungan ini kita cukup memasukkan besaran-besaran planet
kedalam fungsi MGP . Output dari fungsi tersebut adalah posisi x, posisi y, kecepatan x, kecepatan
y , dan array t planet. Output ini akan disimpan ke dalam arraynya masing-masing yang nantinya
akan digunakan kembali. Posisi x dan y planet akan digunakan untuk memplot posisi planet pada
grafik. Sementara itu kecepatan x dan y planet serta array t akan digunakan pada perhitungan
interpolasi kecepatan planet. Dengan itu bagian perhitungan program pun selesai. Bagian
perhitungan dari program ini berada pada fungsi MGP dan lagrange. Dengan menggunakan fungsi
kita dapat mempersingkat program. Ketika kita ingin menghitung sesuatu, kita tinggal
memasukkan besaran-besaran planet ke dalam fungsi dan kita akan mendapatkan hasilnya. Salah
satu ‘kekurangan’ dari program ini adalah waktu perhitungannya relatif cukup lama (sekitar 4-5
detik ). Namun hal ini wajar karena program menggunakan banyak perulangan dalam proses
perhitungannya .
3.3.3 Analisa Output Program

Program ini menghasilkan dua output, yaitu grafik lintasan gerak planet dan data hasil
perhitungan kecepatan pada waktu tertentu pada sumbu x dan sumbu y. Untuk output grafik
lintasan digunakan library matplotlib agar hasil perhitungan dapat di plot ke dalam grafik. Fungsi
- fungsi dari library matplotlib ini selain digunakan untuk memplot grafik tetapi juga digunakan
untuk membuat grafiknya tampak lebih rapi, untuk memanggil library matplotlib ini pada program
diperlukan prefix plt untuk setiap perintahnya.

Fungsi yang digunakan untuk memplot grafik adalah plt.plot , yang di plot pada grafik
adalah hasil perhitungan dari Metode Runge Kutta Orde 4. Fungsi lain yang digunakan adalah
colors dan label, dikarenakan ada 8 grafik lintasan planet oleh karena itu setelah itu hasil lintasan
yang di plot diberikan warna dan keterangan agar dapat dibedakan. Setelah itu digunakan juga
fungsi plt.xlabel dan plt.ylabel , digunakan untuk memberikan keterangan besaran dan satuan
pada sumbu x dan y. Untuk judul pada grafik digunakan fungsi plt.title. Agar keterangan pada
grafik muncul maka digunakan fungsi plt.legend, dan untuk mempermudah pengguna membaca
grafik maka diberikan kotak kotak atau grid dengan menggunakan fungsi plt.grid. Terakhir, untuk
menampilkan hasil grafik lintasan planet maka digunakan fungsi plt.show. Pada program akan
ditampilkan 2 grafik, agar mempermudah penngguna melihat perbedaan antar lintasan planet.

Output kedua yang akan ditampilkan pada program adalah menampilkan data hasil
perhitungan kecepatan pada waktu tertentu pada sumbu x dan sumbu y. Fungsi yang digunakan
untuk menampilkan data tersebut adalah dengan menggunakan fungsi print(). Data yang di print
adalah data hasil perhitngan pada Metode Interpolasi Lagrange. Fungsi print() ini adalah mencetak
data hasil perhitungan data hasil perhitungan yang ditampilkan adalah kecepatan pada sumbu x
dan sumbu y.
 Agar mempermudah pengguna dalam membaca hasil output data kecepatan maka dibuat
agar hasil output yang ditampilkan menjadi sebuah tabel dengan fungsi print(). Untuk membuat
tabel hasil data perlu di print “---” sebagai garis pada tabel, keterangan tabel seperti nama planet,
kecepatan pada sumbu x (Vx(km/s)) dan kecepatan pada sumbu y (Vy(km/s)). Untuk data pada
keterangan nama planet perlu memasukan ke delapan nama planet sedangkan untuk Vx dan Vy
merupakan hasil perhitungan Interpolasi Lagrange, dengan menggunakan fungsi %.2f , agar data
hasil perhitungan yang dihasilkan menampilkan angka desimal 2 angka setelah koma. Untuk
penempatan data tersebut diperlukan kesesuaian agar membuat sebuah tabel.
 BAB IV

KESIMPULAN

4.1 Dengan menggunakan Metode Runge Kutta Orde 4 dapat ditentukan kecepatan dan posisi
planet dengan menggunakan data data delapan planet yang telah diketahui dan diinputkan pada
program selanjutnya dengan input fungsi Model Gerak Planet dan fungsi Runge Kutta Orde 4
diproses dengan melakukan iterasi, serta pengguna diminta untuk menginput variasi delta t yang
berfungsi sebagai stepsize agar dapat dilakukan proses perhitugan sehingga dapat didapatkan
kecepatan dan posisi ke delapan planet tersebut.

4.2 Telah didapatkan kecepatan dan posisi secara numerik dengan Metode Runge Kutta Orde 4,
maka model lintasan planet dapat di plot kan ke dalam grafik dengan menggunakan library
matplotlib dalam program, seperti yang dapat dilihat pada Gambar 2.1 dan Gambar 2.2
menampilkan grafik lintasan planet.

4.3 Dengan menggunakan Metode Interpolasi Lagrange dapat ditentukan kecepatan planet pada
waktu tertentu pada sumbu x maupun y, pengguna diminta untuk menginput waktu untuk proses
perhitungan, maka akan ditampilkan hasil perhitungan kecepatan planet pada sumbu x dan y pada
saat waktu tertentu. Seperti pada gambar Gambar 2.3 ditampilkan data kecepatan hasil
perhitungan pada sumbu x dan sumbu y.
 DAFTAR PUSTAKA

Jaan Kiusalaas. 2010. NUMERICAL METHODS IN ENGINEERING. Edisi ke-2. Cambridge

University Press. New York,USA.

Steven C. Chapra dan Raymond P. Canale. 2010. Numerical Methods for Engineers. Edisi ke-6.
McGraw-Hill. New York, USA.

Qingkai Kong ,Timmy Siauw,Alexandre Bayen.2020. Python Programming and Numerical

Methods. Edisi pertama

Suraina, Yudha Arman , Boni Pahlanop Lapanporo.2015.SIMULASI ORBIT PLANET DALAM

TATA SURYA DENGAN METODE EULER, LEAPFROG DAN RUNGE-KUTTA.Universitas
Tanjungpura Pontianak.

Moh. Ba’its Sulthon.2013.ANALISIS SOLUSI NUMERIK MODEL GERAK PLANET DENGAN

METODE RUNGE-KUTTA.UNIVERSITAS JEMBER.