Simulasi 2-Benda Menggunakan Metode Regularisasi KS

SIMULASI 2-BENDA MENGGUNAKAN METODE
REGULARISASI KUSTAANHEIMO-STIEFEL
TUGAS AKHIR
Karya tulis sebagai salah satu syarat
untuk memperoleh gelar Sarjana dari
Institut Teknologi Bandung
Oleh
MUHAMMAD ISNAENDA IKHSAN

NIM: 10311012
(Program Studi Sarjana Astronomi)
FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM
INSTITUT TEKNOLOGI BANDUNG

2015
SIMULASI 2-BENDA MENGGUNAKAN METODE

REGULARISASI KUSTAANHEIMO-STIEFEL
Oleh:
MUHAMMAD ISNAENDA IKHSAN

NIM: 10311012
Program Studi Sarjana Astronomi

Fakultas Matematika dan Ilmu Pengetahuan Alam
Institut Teknologi Bandung
Menyetujui,
Bandung, 10 September 2015
Dosen Pembimbing
Dr. rer. nat. Mochamad Ikbal Arifyanto

NIP: 197405192006041015
Tim Penguji:
1. Dr. rer. nat. Hesti Retno Tri Wulandari
2. Dr. Budi Dermawan
3. Dr. Muhammad Irfan Hakim
Pedoman Penggunaan Tugas Akhir

Tugas Akhir Sarjana yang tidak dipublikasikan terdaftar dan tersedia di Perpustakaan Institut Teknologi Bandung, dan terbuka untuk umum dengan ketentuan bahwa hak cipta ada pada penulis dengan mengikuti aturan HaKI
yang berlaku di Institut Teknologi Bandung. Referensi kepustakaan diperkenankan dicatat, tetapi pengutipan atau peringkasan hanya dapat dilakukan
seizin pengarang dan harus disertai dengan kebiasaan ilmiah untuk menyebutkan sumbernya.
Memperbanyak atau menerbitkan sebagian atau seluruh Tugas Akhir harus
atas izin Program Studi Sarjana Astronomi, Institut Teknologi Bandung.
Prakata
Bismillaahirrahmaanirrahiim
Alhamdulillaah, segala puji penulis panjatkan ke hadirat Allah SWT, Tuhan semesta alam, yang berkat izin-Nya penulis dapat menyelesaikan Tugas Akhir ini. Shalawat serta salam tidak lupa senantiasa terucap kepada
junjungan Rasulullah Muhammad SAW, yang diharapkan pertolongan dan
syafaatnya di hari akhir nanti.
Tugas Akhir Sarjana ini merupakan sebuah karya yang diselesaikan dengan
dukungan dari berbagai pihak. Penulis mohon maaf atas segala kekurangan
dan kesalahan dalam pengerjaan Tugas Akhir ini. Selanjutnya, penulis juga
ingin menyampaikan terima kasih kepada:
Bapak Burhan Isnanto, Ibu Endang Susilowati, Isnafinda K.A, Hanenda
N.A.I, Mbah Kakung dan Putri, Pakdhe Adib, Budhe Rus, Bulik Nunik,
Om Yanto, Om Bambang, Bulik Wati, Om Anang, dan Bulik Yayuk
selaku keluarga besar penulis di Bantul dan Magelang, serta sepupu
yang selalu menjadi teman bermain dan berbicara, yaitu Mbak Anggun,
Deisna, Hana, Tifa, Salwa, Yudha, Dika, Jihan, Hafid, dan yang paling
kecil Lia.
Bapak M. Ikbal Arifyanto, sebagai dosen pembimbing yang selalu sabar
dan pengertian, serta selalu memberikan semangat dan banyak membantu dalam menyelesaikan Tugas Akhir ini.
Bu April, selaku dosen wali semenjak masa TPB hingga semester enam.
Dr. Budi Dermawan, Dr. M. Irfan Hakim, dan Dr. rer. nat Hesti Retno
Tri Wulandari yang telah bersedia menjadi dosen penguji dalam Tugas
Akhir ini.
Pak Dhani Herdiwijaya, selaku Kaprodi Astronomi yang telah memberikan banyak bantuan, baik yang langsung maupun tidak langsung.
Dosen-dosen di Program Studi Astronomi, terima kasih atas bimbingannya selama ini. Semoga Allah SWT selalu membalas kebaikan dan
ketulusan beliau dalam membagikan ilmunya untuk orang lain.
ii
Staf Program Studi Astronomi. Bu Ina yang selalu semangat menjaga

perpustakaan. Bu Ati dan Bu Isna, Tata Usaha paling baik hati di ITB
yang pernah penulis temui.
Nindhita Pratiwi selaku teman terdekat penulis, yang selalu setia menemani dan mendengarkan keluh kesah penulis selama mengerjakan tugas
akhir ini.
Segenap elemen di Observatorium Bosscha yang selalu setia dalam mengeksplorasi keindahan langit di Indonesia.
Teman-teman Astronomi 2011, yang telah berjuang bersama penulis semenjak masa PAM hingga pengerjaan Tugas Akhir ini.
Anggota HIMASTRON ITB, yang telah berkarya bersama penulis dalam
membangun Astronomi Indonesia yang lebih baik.
Teman-teman alumni SMAN 1 Bantul yang secara langsung maupun
tidak langsung memberikan semangat pada penulis untuk membanggakan almamater dengan cara mengerjakan Tugas Akhir ini sebaik mungkin.
ITB dan DIKTI, selaku pemberi berbagai bantuan, termasuk Beasiswa
Bidik Misi.
Pihak-pihak lain yang tidak dapat penulis sebutkan satu per satu, tanpa
mengurangi makna dan terima kasih yang ingin penulis sampaikan.
Tugas Akhir ini masih jauh dari sempurna. Kritik dan saran sangat diperlukan agar Tugas Akhir ini dapat lebih bermanfaat ke depannya. Semoga
Astronomi Indonesia menjadi lebih baik, hingga mampu menunjukkan kontribusinya dalam mengeksplorasi keindahan alam semesta ini.
Bandung, September 2015
Muhammad Isnaenda Ikhsan
iii
Abstrak
Gugus bintang adalah sebuah sistem bintang yang terdiri dari sekumpulan
bintang yang berada di satu lokasi, terikat secara gravitasi, dan mengalami
evolusi secara bersama-sama. Mempelajari evolusi dari gugus bintang menjadi
salah satu studi penting guna memahami evolusi bintang di dalamnya. Bintang
ganda merupakan salah satu faktor penting yang mempengaruhi evolusi gugus
bintang.
Guna mempelajari lebih jauh mengenai evolusi gugus bintang, pada Tugas
Akhir ini akan dibuat sebuah simulasi 2-benda yang secara khusus melihat
interaksi yang terjadi pada sistem bintang ganda. Untuk mendapatkan hasil
simulasi yang baik akan digunakan sebuah metode regularisasi, yaitu regularisasi Kustaanheimo-Stiefel (KS) yang secara khusus memecahkan masalah
papasan dekat antar 2-benda. Ide dari metode regularisasi ini adalah transformasi koordinat dan variasi timestep. Koordinat bintang ganda akan diubah
dari Cartesian ke koordinat KS, sehingga ketika ada kondisi ekstrim, jarak
mendekati nol, perhitungan masih dapat dilakukan dengan kesalahan diminimalkan. Selain itu dengan menggunakan regularisasi maka besarnya nilai
timestep untuk setiap integrasi akan menyesuaikan dengan kondisi bintang
ganda sehingga proses integrasi akan berjalan lebih efisien.
Berdasarkan hasil simulasi yang didapatkan, dapat disimpulkan bahwa
metode regularisasi ini dapat dengan baik mensimulasikan bintang ganda dengan nilai error yang dihasilkan cukup kecil. Metode ini juga cukup stabil
dalam mengintegrasikan interaksi bintang ganda meskipun ditambahkan benda
ke-3 ke dalam sistem. Selain itu, proses pemilihan timestep oleh metode regularisasi KS juga menunjukan hasil yang baik, ditandai dengan nilai timestep
yang bersesuaian dengan besarnya jarak antar anggota bintang ganda.
Kata kunci: regularisasi, Kustaanheimo-Stiefel, bintang ganda, gugus bintang,
simulasi 2-benda.
iv
Abstract
Star cluster is a star system consisting of a group of stars that stay in one
place, gravitationally bound, and evolving together. Studying evolution of star
cluster become one of important aspect to understanding about star evolution.
Binary star is one of important factor that affect star cluster evolution.
To understand more about star cluster evolution, in this study will be made
a two-body simulation that sepecifically simulating an interaction that happen between binary star. To get a good result we use a regularization method,
Kustaanheimo-Stiefel Regularization, which is specifically solving problem about close encounter problem between two-body. The idea of this regularization
method is transforming the coordinates and using varying timestep. The binary star coordinat will be transfromed from Cartesian to KS coordinat system,
so when the system face an extreme condition, such as the distance between
star close to zero, our calculation will still give a good result with minimalizing
the error. Using regularization will make the timestep per integration that we
use adapting the binary star condition, so the integration will be more efficient.
Based on the result that we get from simulation, we can make a conclusion
that the regularization method that we use is good enough to simulate binary
star with the error of the parameter is small. This method is also stable enough
to simulating binary star even there is a third-body added to perturbing the
system. The process of choosing timestep by this method is showing a good
result too, showed by the relation between the value of timestep and distance
of binary star.
Keywords: regularization, Kustaanheimo-Stiefel, binary star, star cluster, twobody simulation.
Daftar Isi
Pedoman Penggunaan Tugas Akhir
Prakata
ii
Abstrak
iv
Abstract
Daftar Isi
vii
Daftar Tabel
viii
Daftar Gambar
I
ix
Pendahuluan
I.1
Latar Belakang . . . . . . . . . . . . . . . . . . . . . . . . . . .
I.2
Tujuan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
I.3
Metodologi
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
I.4
Satuan, Notasi, dan Konvensi . . . . . . . . . . . . . . . . . . .
I.5
Sistematika Penulisan . . . . . . . . . . . . . . . . . . . . . . . .
II Masalah N-benda
II.1 Metode Simulasi N-benda . . . . . . . . . . . . . . . . . . . . .
II.2 Metode Integrasi (Hermite Scheme) . . . . . . . . . . . . . . . .
II.3 Time-symmetrization . . . . . . . . . . . . . . . . . . . . . . . . 11
II.4 Metode Regularisasi . . . . . . . . . . . . . . . . . . . . . . . . 12
III Regularisasi KustaanheimoStiefel
15
III.1 Transformasi KS . . . . . . . . . . . . . . . . . . . . . . . . . . 15
III.2 KS Hermite Scheme
III.3 KS Timestep
. . . . . . . . . . . . . . . . . . . . . . . . 17
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
III.4 Hubungan KS Timestep dan

Physical Timestep . . . . . . . . . . . . . . . . . . . . . . . . . . 19
III.5 Integrasi KS Hermite Scheme . . . . . . . . . . . . . . . . . . . 20
vi
IV Hasil dan Analisis
23
IV.1 Nilai Awal Posisi dan Kecepatan Bintang Ganda dan Benda ke-3 23
IV.2 Hasil Simulasi 2-Benda . . . . . . . . . . . . . . . . . . . . . . . 26
IV.3 Hasil Simulasi 3-Benda . . . . . . . . . . . . . . . . . . . . . . . 28
IV.4 Analisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
V Simpulan dan Saran
33
V.1 Simpulan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
V.2 Saran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Daftar Pustaka
35
A Kode Program N-benda
36
B Kode Program Fungsi Parameter Bintang Ganda
43
C Kode Program Fungsi Nilai Awal
46
D Kode Program Integrasi KS Hermite
48
E Kode Program Fungsi Timestep untuk Integrasi KS Hermite

54
vii
Daftar Tabel
IV.1 Nilai Awal Parameter Orbit Bintang Ganda . . . . . . . . . . . 25
viii
Daftar Gambar
II.1
Skema pembentukan struktur pohon untuk N-benda. . . . . . .
II.2
Diagram alir integrasi Hermite . . . . . . . . . . . . . . . . . . 10
III.1 Diagram alir integrasi menggunakan integrasi KS Hermite . . . 22

IV.1 Penggambaran koordinat dari sistem 3-benda yang digunakan
sebagai nilai awal berdasarkan Funato et al.(1996). . . . . . . . 23
IV.2 Plot error parameter orbit bintang ganda berupa energi total,
momentum sudut, dan eksentrisitas. . . . . . . . . . . . . . . . 27
IV.3 Plot perbandingan timestep dan separasi jarak bintang ganda
terhadap waktu . . . . . . . . . . . . . . . . . . . . . . . . . . 27
IV.4 Plot error parameter orbit bintang ganda akibat benda ke-3 . . 29
IV.5 Plot error parameter orbit bintang ganda akibat benda ke-3
untuk waktu integrasi yang berbeda . . . . . . . . . . . . . . . 30
IV.6 Plot error momentum sudut dan eksentrisitas bintang ganda . . 32
ix
Bab I
Pendahuluan
I.1
Latar Belakang
Gugus bintang adalah sebuah sistem bintang yang terdiri dari sekumpulan
bintang yang berada di satu lokasi, terikat secara gravitasi dan mengalami
evolusi secara bersama-sama. Mempelajari evolusi dari gugus bintang menjadi salah satu studi penting guna memahami evolusi bintang di dalamnya.
Salah satu faktor yang memegang peran penting dalam evolusi gugus bintang
adalah adanya bintang ganda di dalam gugus (Hut et al. 1992). Selain itu,
jika dilihat dari sudut pandang pengamatan, terdapat banyak obyek menarik
yang diduga dihasilkan oleh interaksi bintang ganda, seperti bintang ganda
x-ray, millisecond pulsars, bintang berkecepatan tinggi, dan blue stragglers.
Untuk mempelajari pengaruh bintang ganda terhadap evolusi gugus bintang
dibutuhkan sebuah simulasi 2-benda yang secara khusus melihat interaksi yang
terjadi pada bintang ganda.
Ketika menggunakan simulasi N-benda kita akan menghitung interaksi antar komponen bintang ganda dan bintang lainnya secara bersamaan, artinya
besarnya rentang waktu integrasi yang digunakan sama. Hal ini tentunya
menimbulkan masalah karena ketika kita ingin mempelajari evolusi gugus,
rentang waktu integrasi yang dilakukan anggaplah sama dengan waktu relaksasi gugus, yaitu sekitar 1010 tahun, sedangkan bintang ganda rata-rata
memiliki periode kurang dari satu tahun. Maka agar kita dapat melihat efek
bintang ganda terhadap evolusi gugus, kita setidaknya harus mengintegrasikan
interaksi bintang ganda dengan interval waktu sekitar 1010 kali periode bintang
ganda. Hal ini tentunya akan membutuhkan step integrasi yang sangat besar,
1
I.2. Tujuan
oleh karena itu dibutuhkan sebuah metode agar perhitungan dapat dilakukan
secara lebih efektif.
Selain hal di atas permasalahan lain yang dihadapi oleh simulasi N-benda
saat menghitung interaksi bintang ganda adalah masalah timestep yang digunakan. Program N-benda biasanya menggunakan timestep yang konstan untuk
seluruh sistem. Ketika timestep yang kita ambil terlalu besar saat menghitung
bintang ganda maka akan terdapat kesalahan perhitungan yang muncul saat
anggota bintang ganda saling mendekat satu sama lain karena jarak keduanya
akan mendekati nol, sehingga energinya akan mendekati tak hingga. Sebaliknya, saat timestep yang kita ambil cukup kecil sehingga saat kedua bintang
saling mendekat kesalahan perhitungannya masih dalam batas normal, maka
masalah yang kita hadapi adalah step integrasi yang kita lakukan akan semakin
banyak karena timestep kita nilainya kecil. Semakin banyak step integrasi yang
dilakukan maka perhitungan akan membutuhkan waktu yang lebih lama. Oleh
karena itu penting bagi kita untuk menggunakan suatu metode yang mengijinkan program kita untuk menggunakan timestep yang adaptif. Salah satunya
yaitu dengan regularisasi. Secara sederhana apabila kita menggunakan regularisasi maka timestep integrasi yang kita gunakan akan menyesuaikan dengan
kondisi yang ada. Misalkan kedua bintang saling mendekat satu sama lain
maka timestep akan mengecil, dan sebaliknya.
Dalam kurun waktu beberapa tahun terakhir telah banyak dikembangkan
berbagai program simulasi N-benda. Salah satunya adalah NBODY series
yang dibuat oleh Aarseth (Aarseth 1999). Dalam beberapa seri terakhir dari
program NBODY (NBODY3-NBODY6), Aarseth telah mengembangkan sebuah metode regularisasi, yaitu Regularisasi KS, yang bertujuan untuk secara
khusus mengatasi masalah bintang ganda pada gugus bintang. Regularisasi KS
terbukti dapat secara efisien mensimulasikan pembentukan dan evolusi bintang
ganda di dalam gugus. Oleh karena itu penulis tertarik untuk menulis program
sederhana simulasi N-benda yang menggunakan Regularisasi KS berdasarkan
algoritma yang ada pada paper Funato et al.(Funato et al. 1996).
I.2
Tujuan
Tujuan penelitian ini dapat dinyatakan dalam poin-poin sebagai berikut:
I.3. Metodologi
1. Membuat simulasi 2-Benda dengan menggunakan metode Regularisasi

KS sebagai metode untuk mengatasi masalah bintang ganda pada gugus
bintang.
2. Melihat kestabilan metode regularisasi KS dalam mensimulasikan bintang ganda dengan adanya gangguan bintang ke-3.
I.3
Metodologi
Tugas Akhir ini disusun berdasarkan studi literatur dan juga simulasi. Simulasi merupakan program yang ditulis oleh penulis dengan algoritma mengacu
pada paper Funato et al. 1996. Simulasi ditulis dengan menggunakan bahasa
pemrograman Python. Untuk nilai posisi dan kecepatan awal bintang ganda
dan benda ketiga penulis menggunakan nilai awal yang mengacu pada paper
Funato et al. 1996
I.4
Satuan, Notasi, dan Konvensi
Beberapa aturan yang digunakan dalam penulisan Tugas Akhir ini:

Nilai Konstanta Gravitasi, G, diambil sama dengan satu (G = 1).
Semua besaran massa, posisi, kecepatan, percepatan, waktu, dan lainlain dianggap tidak bersatuan atau dimesionless.
I.5
Sistematika Penulisan
Tugas Akhir ini terdiri dari lima bab yang disusun dengan urutan Bab I
Pendahuluan, Bab II Masalah N-benda, Bab III Regularisasi KustaanheimoStiefel, Bab IV Hasil dan Analisis, dan Bab V Simpulan dan Saran. Bab I berisi
latar belakang, tujuan, metodologi penelitian, penggunaan satuan, notasi, dan
konvensi, serta sistematika penulisan. Bab II berisi pembahasan umum mengenai masalah N-benda, simulasi N-benda, regularisasi secara umum, dan bintang ganda. Bab III berisi penjelasan secara detail mengenai Regularisasi KS
dan KS Hermite Scheme. Bab IV berisi hasil simulasi dan analisis. Bab V
I.5. Sistematika Penulisan
merupakan bab terakhir yang berisi simpulan dan saran dari Tugas Akhir yang
disusun.
Bab II
Masalah N-benda
Gugus bintang mengalamai evolusi secara dinamika dari waktu ke waktu secara terus menerus akibat dari interaksi gravitasi antar bintang di dalamnya
maupun akibat dari pengaruh gravitasi dari luar gugus. Untuk mengamati
evolusi dinamika gugus ini biasanya digunakan suatu simulasi numerik yang
menghitung efek gravitasi yang dialami bintang anggota gugus akibat dari bintang anggota gugus lainnya atau akibat dari gravitasi dari luar gugus. Simulasi
ini biasanya disebut sebagai simulasi N-benda.
II.1
Metode Simulasi N-benda
Terdapat berbagai macam metode yang dapat digunakan untuk memodelkan

masalah N-benda. Yang membedakan metode-metode tersebut adalah mengenai bagaimana cara metode itu menghitung interaksi antar komponen yang
ada di dalam sistem N-benda tersebut. Beberapa metode untuk memodelkan
masalah N-benda antara lain metode langsung (Direct Method ), Tree Code,
Particle-Mesh, dan variasi dari ketiga metode tersebut.
1. Metode langsung (Direct Method )
Metode ini menghitung secara langsung interaksi gravitasi masing-masing
anggota sistem akibat dari anggota sistem yang lainnya (particle-particle).
Dengan menggunakan metode ini program akan melakukan sebanyak
O(N 2 ) hitungan per timestep.
Metode ini menggunakan persamaan
gerak gravitasi Newton untuk menghitung efek yang dialami anggota

sistem akibat dari gravitasi anggota sistem yang lainnya. Bentuk per-
II.1. Metode Simulasi N-benda
samaan gerak partikel i pada sistem yang berjumlah N partikel

ri
N
X
mj (ri rj )
= G
.
|ri rj |3
i=1;j6=i
(II.1)
Dengan r, G, m, dan r berturut-turut merupakan percepatan, Konstanta

Gravitasi, posisi dan massa. Ruas kiri dari persamaan diatas dapat dianggap sebagai gaya per satuan massa, Fi . Jika nilai massa, m, posisi, r,
dan kecepatan awal,r untuk tiap partikel diketahui maka dengan menggunakan persamaan di atas dapat didapatkan solusi posisi dan kecepatan
tiap partikel setiap waktu t. Namun untuk metode ini, kita harus memperhatikan partikel yang mengalami papasan jarak dekat. Dapat dilihat
pada persamaan di atas bahwa saat partikel mengalami papasan dekat,
nilai gaya gravitasi per satuan massanya akan membesar dan mengakibatkan eror dalam perhitungan. Untuk itu perlu dilakukan perlakuan
khusus terhadap partikel-partikel yang mengalami papasan dekat tersebut agar eror perhitungannya dapat dikurangi.
2. Metode Tree Code
Metode ini dikenalkan oleh Josh Barnes dan Piet Hut pada tahun 1986,
dan diciptakan dengan tujuan mengurangi waktu perhitungan per timestep
yang dilakukan program sehingga waktu perhitungannya akan lebih efektif daripada metode langsung. Metode ini akan melakukan perhitungan
sebanyak O(N logN ) perhitungan per timestep (Barnes Hut 1986). Algoritma dari metode ini memiliki tiga langkah dasar yaitu pembentukan
pohon (tree), perhitungan gaya, dan pembaharuan simulasi. Berikut
adalah skema pembentukan pola pohon untuk N-benda.
Gambar. II.1: Skema pembentukan struktur pohon untuk N-benda.
II.2. Metode Integrasi (Hermite Scheme)
Dengan pola pohon seperti di atas, saat dilakukan perhitungan gaya gravitasi, efek gravitasi dari sekelompok anggota yang berada pada jarak
yang jauh dapat didekati dengan menganggapnya sebagai efek gravitasi dari satu anggota saja namun dengan massa lebih besar. Perhitungan dengan menggunakan metode ini memang lebih efisien dan cepat
karena terdapat banyak pendekatan yang dilakukan, namun kekurangannya adalah metode ini tidak dapat digunakan untuk melihat interaksi
jarak dekat antar anggota sistem. Sehingga apabila kami ingin melihat secara detail interaksi antar anggota sistem, keakuratannya kurang
dibandingkan dengan menggunakan metode langsung.
3. Metode Particle-mesh
Metode ini tidak menghitung interaksi antar anggota secara langsung,
namun interaksinya dihitung dari efek medan gravitasi yang ditimbulkan
oleh massa anggota sistem. Konsep dasar metode ini adalah dengan
membuat sebuah jala (mesh), yang nantinya jala tersebut akan diisi oleh
partikel anggota sistem. Nantinya masing-masing jala akan dihitung
potensial gravitasinya menggunakan misal: persamaan Poisson. Kemudian, dari potensial tersebut akan dihitung medan gravitasi yang ditimbulkan. Dari medan gravitasi ini kemudian akan dihitung gaya gravitasi
yang diterima oleh masing-masing partikel. Kelebihan dari metode ini
tentunya perhitungan yang dilakukan akan lebih cepat, namun kekurangannya dengan menggunakan metode ini kita tidak dapat secara akurat
melihat interaksi jarak dekat antar anggota sistem.
II.2
Metode Integrasi (Hermite Scheme)
Metode integrasi dibutuhkan untuk mencari solusi numerik dari persamaan

gerak sistem N-benda. Terdapat beberapa macam metode integrasi yang dapat digunakan pada kasus masalah N-benda, yaitu metode integrasi Euler,
Leapfrog, dan Hermite.
- Metode integrasi Euler merupakan integrator berorde satu yang paling
sederhana. Berikut adalah bentuk matematis dari metode integrasi Eu-
ler,
re = rb + vb dt
(II.2)
ve = vb + ab dt
(II.3)
dengan v dan a merupakan kecepatan dan percepatan dan subskrip b

dan e menunjukan nilai variabel pada awal (beginning) dan akhir (end )
iterasi, dan dt didefinisikan sebagai selisih waktu antara iterasi step pertama dan step berikutnya dt = te tb . Kekurangan metode ini adalah
tingkat akurasinya rendah namun karena algoritmanya sederhana maka
proses perhitungannya dilakukan secara cepat.
- Metode integrasi Leapfrog merupakan integrator berorde dua sehingga
tingkat akurasinya lebih baik daripada Euler. Ide dari integrator ini
adalah posisi dan kecepatan dihitung pada waktu yang berbeda sehingga
proses perhitungan posisi dan kecepatan saling meloncati satu sama
lain. Untuk mempermudah, dapat ditulis dalam bentuk persamaan,
ri = ri1 + v11/2 dt,
v1+1/2 = v11/2 + ai dt,
(II.4)
(II.5)
dengan kecepatan dihitung pada waktu ti , ti+1 , ti+2 , ..., dengan selang
waktu dt, sedangkan kecepatan dihitung pada waktu setengah dari waktu
posisi, yaitu ti i 1/2, ti+1/2 , ti+3/2 , ..., dengan ti+1 ti+1/2 = ti+1/2
ti+1 = dt/2. Metode integrasi ini ideal digunakan pada kasus yang tidak
membutuhkan akurasi yang sangat tinggi.
- Metode integrasi Hermite merupakan sebuah integrator berorde empat
dengan skema predictor-corrector. Jadi pada dasarnya, metode ini pada
awal iterasi menghitung prediksi posisi dan kecepatan, kemudian pada
akhir iterasi posisi dan kecepatan akan dikoreksi. Proses tersebut akan
diulang hingga posisi dan kecepatan konvergen.
Berikut ini akan dijelaskan secara detail bagaimana skema integrasi Hermite
bekerja berdasarkan algoritma yang ada pada buku Moving Stars Around (Hut
Makino 2003-4),
1. Prediksi posisi dan kecepatan menggunakan persamaan berikut,

1
1
rpred = rb + vb t + ab t2 + j + bt3 ,
2
6
(II.6)
1
vpred = vb + ab t + jb t2 ,
2
(II.7)
dengan j merupakan jerk . Jerk merupakan turunan pertama terhadap

waktu dari percepatan. Percepatan dan jerk tiap benda dapat dihitung
menggunakan,
m
r,
r3
v
(r.v)r
j = Gm[ 3 3 5 ],
r
r
a = G
(II.8)
(II.9)
dengan r dan v di sini merupakan posisi dan kecepatan relatif bintang

tersebut akibat dari bintang yang mempengaruhinya.
2. Hitung nilai percepatan ae dan jerk je menggunakan posisi dan kecepatan
hasil prediksi.
3. Koreksi nilai posisi dan kecepatan menggunakan persamaan berikut,
1 (5) 5
1 (4) 4
rb t +
r t ,
24
120 b
1 (4)
1 (5)
ve = vpred + rb t3 + rb t4 ,
6
24
re = rpred +
(II.10)
(II.11)
(i)
dengan rb merupakan turunan ke i yang dihitung menggunakan,

(4)
1
[6(ab ae ) t(4jb + 2je )],
t2
1
=
[12(ab ae ) + t(jb + je )].
t3
rb =
(5)
rb
(II.12)
(II.13)
(II.14)
4. Ulangi langkah 2-3 hingga nilai re dan ve konvergen.

Berikut merupakan diagram alir yang menggambarkan metode integrasi
Hermite bekerja untuk setiap stepnya.
10
Gambar. II.2: Diagram alir ini adalah gambaran umum integrasi Hermite
bekerja pada tiap stepnya.
II.3. Time-symmetrization
II.3
11
Time-symmetrization
Pada Tugas Akhir ini kami akan menggunakan skema integrasi Hermite yang
dikombinasikan dengan teknik time-symmetrization yang mengacu pada paper
Funato et al. (Funato et al. 1996). Ide dari teknik ini adalah memodifikasi cara
menghitung stepsize sehingga ketika dilakukan iterasi, variabel yang dipakai
akan konvergen lebih cepat. Berikut ini akan dijelaskan cara mendapatkan
stepsize yang bersifat time-symmetric. Pertama, anggap sebuah skema integrasi dengan stepsize konstan. Integrasi dengan stepsize konstan t dapat
dituliskan sebagai berikut,
e = f (b , e , t),
(II.15)
dengan menunjukan variabel ruang-fase, yaitu = (r, v).

Jika skema integrasi yang dipakai merupakan time-symmetric maka akan
berlaku,
= f (e , b , t) = b .
(II.16)
Sekarang ditinjau sebuah skema time-symmetric dengan stepsize yang tidak

konstan. Jika skema yang dipakai time-symmetric maka akan berlaku,
e = f (b , e , tb ),
b = f (e , b , te ),
(II.17)
dengan tb dan te merupakan stepsize yang dihitung pada awal dan akhir
step sebagai fungsi dari (), yaitu,
tb = (b , e ),
te = (e , b ).
(II.18)
Maka agar persamaan II.17 terpenuhi, stepsize harus memenuhi kriteria berikut,
(b , e ) = (e , b ).
(II.19)
Salah satu cara yang dapat dilakukan agar persamaan II.19 terpenuhi adalah
dengan menghitung besar stepsize yang dihitung pada awal dan akhir step
integrasi, yaitu,
1
(b , e ) = [s(b ) + s(e )],
2
(II.20)
II.4. Metode Regularisasi
12
atau
r
(b , e ) =
1
[s(b )2 + s(e )2 ],
2
(II.21)
dengan s(b ) dan s(e ) merupakan suatu fungsi yang digunakan untuk menghitung stepsize pada awal dan akhir step integrasi.
II.4
Metode Regularisasi
Gerak dari benda-benda langit sesuai dengan hukum gravitasi Newton, yang
menyatakan bahwa gaya tarik antar benda berbanding lurus dengan massa
kedua benda dan berbanding terbalik dengan kuadrat jarak kedua benda
tersebut. Saat dua benda mengalami tumbukan, jarak antar keduannya akan
menjadi nol sehingga menurut hukum gravitasi Newton akan terjadi sebuah
singularitas. Regularisasi merupakan sebuah metode yang digunakan untuk
menghindari singularitas yang terjadi saat terjadinya peristiwa tumbukan tersebut.
Ada tiga langkah dasar yang dilakukan saat akan menggunakan regularisasi
(Celletti 2006) yaitu:
1. Transformasi koordinat; untuk melakukan regularisasi perlu dilakukan
transformasi koordinat, dari koordinat kartesian ke koordinat regularisasi, misalnya transformasi Levi-Civita1 .
2. Adanya waktu khayal (fictitius time); digunakan untuk menghindari nilai
kecepatan menjadi tak terhingga saat terjadinya singularitas.
3. Penggunakan hukum kekekalan energi; digunakan untuk mengubah persamaan diferensial yang singular menjadi persamaan diferensial biasa,
menggunakan cara pemanjangan fase ruang (extended phase space).
Anggap ada dua benda, P1 dan P2 dengan massa m1 dan m2 yang berinteraksi sesuai dengan hukum Newton. Asumsikan bahwa kedua benda bergerak
1
Transformasi Levi-Civita merupakan sebuah transformasi koordinat yang digunakan un-
tuk memecahkan kasus regularisasi dua benda yang kerangka acuannya berada pada bidang
planar
13
dengan lintasan garis lurus, dengan P2 sebagai pusat dari kerangka acuan yang
digunakan. Maka persamaan gerak P1 akibat dari P2 adalah,
x +
K
= 0,
x2
(II.22)
dengan x dan x merupakan kecepatan dan percepatan, dan juga K = G(m1 +

m2 ). Maka energi ikat kedua benda tersebut adalah,
K 1 2
x .
(II.23)
x
2
q
Oleh karena itu maka kecepatan x = 2( Kx h) akan menjadi tak terhingga
h =
saat terjadinya tumbukan, yaitu saat x = 0. Ubah koordinat kartesian menjadi

koordinat regularisasi; untuk kasus ini dapat ditulis sebagai,
x = u2 .
(II.24)
Sehingga persamaan gerak dalam koordinat yang baru menjadi,

K
1
u + u 2 + 5 = 0,
u
2u
(II.25)
sedangkan energinya menjadi,

K
2uu 2 .
u2
h =
Persamaan kecepatannya menjadi,
r
u =
K
h
,
2u4 2u2
(II.26)
(II.27)
untuk persamaan di atas, saat terjadi tumbukan u = 0, singularitas masih

tetap terjadi. Oleh karena itu diperkenalkan fictitious time untuk mengontrol
peningkatan kecepatan pada saat terjadi tumbukan. Oleh karena itu digunakanlah fictitious time s yang didefinisikan sebagai,
dt = xds = u2 ds
Dengan mendefinisikan u0
atau
(II.28)
du
,maka
ds
du
du ds
=
=
dt
ds dt
1 d 1
u = 2 ( 2 u0 ) =
u ds u
u =
dt
= x = u2 .
ds
1 0
u,
u2
1 00
2
u 5 u02 .
4
u
u
(II.29)
(II.30)
14
Sehingga persamaan gerak dan energinya menjadi,

1
K
u00 u02 +
= 0,
u
2u
h=
K
2u02
.
u2
u2
(II.31)
Ubah bentuk persamaan gerak menjadi,

1 K
2u02
u + ( 2 2 )u = 0,
2 u
u
00
(II.32)
sehingga dengan menggunakan persamaan energi h, persamaan gerak dapat

diubah menjadi,
h
u00 + u = 0.
2
(II.33)
Persamaan gerak dalam koordinat baru tersebut telah menjadi persamaan

diferensial biasa yang tidak singular saat terjadi tumbukan, yaitu u = 0.
Bab III
Regularisasi KustaanheimoStiefel
Regularisasi Kustaanheimo-Stiefel (KS) merupakan salah satu metode regularisasi yang biasa digunakan untuk menghindari kasus singularitas yang terjadi
pada interaksi antar dua benda dengan kerangka acuan 3 dimensi. Seluruh
penurunan mengenai regularisasi KS yang ada pada bab ini mengacu pada
paper Funato et al. yang memperlajari mengenai Time-Symmetrized KS Regularization (Funato et al. 1996).
III.1
Transformasi KS
Untuk mengubah koordinat Cartesian ke koordinat baru maka dibutuhkan

sebuah matriks yaitu,
u1 u2 u3
u2
A(u) =
u
3
u1
u4
u4 u3
u4
u4 u3
u1
u2
u2 u1
(III.1)
matriks ini merupakan generalisasi dari matriks 2 2 Levi-Civita (Aarseth

2003). Maka selanjutnya koordinat baru dapat dihitung,
15
III.1. Transformasi KS
16

u1
r1

r2
= A(u) u2
u
r
3
3
u4
0
u1 u2
u2 u1
=
u
3 u4
u4 u3
u3
u4
u1
u2

u1

u3
u2

u2
u3
u1
u4
u4
(III.2)
Sehingga komponen r dapat dituliskan sebagai,

r1 = u21 u22 u23 + u24 ,
r2 = 2(u1 u2 u3 u4 ),
r3 = 2(u1 u3 + u2 u4 ),
r4 = 0.
(III.3)
Dari keempat komponen di atas apabila dihitung akar dari kuadrat jumlahnya
maka r dapat dituliskan dalam u1 , u2 , u3 , dan u4 yaitu,
r = u21 + u22 + u23 + u24 .
(III.4)
Setelah mengubah koordinat Cartesian ke dalam koordinat KS, maka selanjutnya harus dicari suatu cara untuk mengubah koordinat KS menjadi koordinat Cartesian kembali. Hal ini dibutuhkan karena koordinat KS hanya
akan digunakan saat interaksi antar benda membutuhkan regularisasi. Saat
interaksi antar benda sudah dapat dihitung dengan persamaan gerak biasa
maka persamaan gerak harus dipecahkan dalam koordinat Cartesian bukan
koordinat KS lagi.
Untuk mengubah koordinat KS menjadi koordinat Cartesian akan digunakan persamaan pertama dari III.3 dan persamaan III.4. Jika r1 > 0 maka
dengan menggabungkan persamaan pertama dari III.3 dan persamaan III.4
didapatkan,
1
u21 + u24 = (r1 + r).
2
(III.5)
III.2. KS Hermite Scheme
17
Dengan memilih nilai u4 = 0 maka akan didapatkan hubungan,

1
u1 = [ (r1 + r)]1/2 ,
2
1 r2
u2 =
,
2 u1
1 r3
u3 =
.
2 u1
(III.6)
Jika r1 < 0 maka dengan mengurangkan persamaan pertama dari III.3 dan
persamaan III.4 akan didapatkan,
1
u22 + u23 = (r r1 ).
2
(III.7)
Dengan memilih nilai u3 = 0 maka akan didapatkan hubungan,

1
u2 = [ (r r1 )]1/2 ,
2
1 r2
u1 =
,
2 u2
1 r3
u4 =
.
2 u2
III.2
(III.8)
KS Hermite Scheme
Sebelum menggunakan KS Hermite Scheme perlu didefinisikan gerak dari

pusat masa dari dua benda yang interaksinya dihitung menggunakan regularisasi. Hal ini karena interaksi yang dihitung antara benda ketiga dan kedua
benda tersebut hanya dianggap sebagai interaksi dua benda biasa, yaitu benda
ketiga dan pusat masa benda kesatu dan kedua. Posisi dan kecepatan pusat
massa sistem dua benda,
m1 r1 + m2 r2
,
m1 + m2
m1 v1 + m2 v2
=
,
m1 + m2
rcm =
vcm
(III.9)
(III.10)
dan gerak relatif,

r = r2 r1
dr
= v = v2 v 1 .
dt
(III.11)
(III.12)
III.2. KS Hermite Scheme
18
Sedangkan percepatan diungkapkan sebagai,

dv
(m1 + m2 )r
=
+ P,
dt
|r|3
F1 + F2
dvcm
=
,
dt
m1 + m2
(III.13)
(III.14)
dengan P pada persamaan III.14 adalah perturbasi,

P=
F1
F2
.
m2 m1
(III.15)
Berikut adalah persamaan integrasi Hermite yang sudah diubah kedalam

koordinat KS,
1
1 (2)
(1)
(2)
ue = ub + (u(1)
(ue ub ) 2
e + ub )
2
10
1
(3)
+
(u(3) + ub ) 3 ,
120 e
1
1 (3)
(1)
(2)
(3)
u(1)
= ub + (u(2)
(ue ub ) 2 ,
e
e + ub )
2
12
1 (2)
1 (1)
(1)
(2)
he = hb + (h0 + h1 ) (h1 h0 ) 2 ,
2
12
(III.16)
(III.17)
(III.18)
dengan ui merupakan turunan ke i dari u terhadap variabel . Contoh,

d2 u
= u(2) .
d 2
(III.19)
Turunan kedua dan ketiga dihitung menggunakan (Aarseth 1985),

(2)
ub
(3)
ub
h(1)
1
1
hb ub + rb ATb (ub )Pb ,
2
2
1
1 (1)
1 d
(1)
hb ub + hb ub +
[rb ATb (ub )Pb ]
=
2
2
2 d
1
1 (1)
1 d
(1)
=
hb ub + hb ub +
[rb ATb (ub )]Pb
2
2
2 d
1
T
+ rb Ab (ub )rb Jp,b ,
2
= 2u(1) .AT (u)P,
=
(III.20)
(III.21)
(III.22)
h(2) = 2[u(2) .AT (u)P + u(1) .AT (u(1) )P + u(1) .AT (u)rJp ]. (III.23)
Notasi Jp merupakan turunan pertama terhadap waktu dari P dan AT merupakan transpose dari matriks A.
III.3. KS Timestep
III.3
19
KS Timestep
Ketika menggunakan teknik regularisasi untuk menghitung interaksi antar

benda, kami tidak lagi menggunakan timestep biasa (t), namun kami harus
mendefinisikan timestep baru dalam koordinat KS yaitu .
Formula standar Aarseth (Aarseth 1985) untuk menghitung KS timestep,
yang telah banyak digunakan dalam berbagai program N-benda adalah,
s
|u(4) ||u(2) | + |u(3) |2
= s(u) = (5) (3)
,
(III.24)
|u ||u | + |u(4) |2
dengan adalah parameter akurasi.
Untuk kasus masalah N-benda biasa, formula di atas bekerja cukup baik,
namun untuk kasus dua benda dengan regularisasi KS kami menggunakan
formula yang lebih sederhana agar lebih efisien. Contoh formula yang dapat
digunakan yaitu,
=
|u|
u(1)
(III.25)
atau
s
= s(u) =
|u(2) ||u| + |u(1) |2

.
|u(3) ||u(1) | + |u(2) |2
(III.26)
Persamaan III.25 dan III.26 lebih sederhana daripada persamaan III.24

karena tidak membutuhkan turunan u berorde tinggi seperti u(4) dan u(4) .
Sehingga iterasi akan konvergen lebih cepat.
III.4
Hubungan KS Timestep dan

Physical Timestep
Kami tinjau suatu kasus dua benda (bintang ganda) dan benda ketiga. Integrasi akan berjalan seperti yang akan dijelaskan selanjutnya. Pada awal
langkah integrasi, posisi dan kecepatan bintang ganda dalam koordinat KS
telah diketahui. Posisi dan kecepatan benda ketiga diberikan dalam koordinat
Cartesian. Perturbasi terhadap bintang ganda P dan turunan terhadap waktunya Jp dihitung menggunakan koordinat Cartesian. Kemudian posisi relatif
III.5. Integrasi KS Hermite Scheme
20
dari komponen bintang ganda diprediksi dalam koordinat KS dan KS timestep

, sedangkan pusat massa bintang ganda dan benda ketiga dihitung dalam
koordinat Cartesian dan physical timestep t yang merupakan fungsi dari
dan u.
Besar nilai dan t harus dihitung sedemikian rupa agar dapat berlaku
untuk seluruh sistem N-benda. Berikut ini merupakan formula untuk menghitung t sebagai fungsi dari dan u,
t1 = t0 + t,
(III.27)
(1)
(3)
t = T ( ) = t 1 + t 1
24
(5)
+ t1
2
.
1920
(III.28)
(1)
Dengan t 1 merupakan turunan ke-i ketika = 0 + 0.5 pada waktu KS

2
yang dihitung menggunakan,

(1)
t1
= r = u.u,
(III.29)
= 2(u.u(2) + u(1) .u(1) ),
(III.30)
= 2[u.u(4) + 4(u(1) .u(3) ) + 3(u(2) .u(2) )],
(III.31)
(3)
t1
(5)
t1
2
dengan,
u 1 = u0 +
2
(1) 2 (2) 3 (3) 4 (4)

u +
u +
u +
u ]
2 0
8 0
48 0
384 0
5 (5)
u ,
3840 0
2 (2)
(1)
u0 +
u +
2 0
3 (3)
(2)
u0 +
u +
2 0
4 (4)
(3)
u0 +
u +
2 0
5 (5)
(4)
u0 +
u .
2 0
+
(1)
u1
(2)
u1
(3)
u1
(4)
u1
2
III.5
(III.32)
3 (3)
u +
8 0
4 (4)
u +
8 0
5 (5)
u ,
8 0
4 (4) 5 (5)
u +
u ,
48 0
384 0
5 (5)
u ,
48 0
(III.33)
(III.34)
(III.35)
(III.36)
Integrasi KS Hermite Scheme
Integrator yang digunakan ini merupakan integrator Hermite Scheme yang

telah diubah kedalam koordinat KS dan juga menggunakan teknik time-symmetrized
pada bagian perhitungan stepsize. Berikut merupakan langkah detail perhitungan setiap step dari integrasi time-symmetrized KS Hermite scheme.
21
1. Prediksi posisi dan kecepatan partikel untuk semua benda, untuk komponen bintang ganda posisi, kecepatan, dan energi ikat harus diprediksi
dalam koordinat KS. Untuk prediksi komponen bintang ganda dapat
menggunakan formula (Por 2014):
1 (2)
1 (3)
(1)
upred = ub + ub + ub 2 + ub 3 ,
2
6
1
(1)
(1)
(2)
(3)
upred = ub + ub + ub 2 ,
2
1 (2)
(1)
hpred = hb + hb + hb 2 .
2
(III.37)
(III.38)
(III.39)
2. Kemudian hitung kembali percepatan dan jerk untuk seluruh partikel

menggunakan posisi dan kecepatan hasil prediksi.
3. Hitung turunan keempat dan kelima dari posisi relatif komponen bintang
ganda dalam koordinat KS pada awal dan akhir step dengan menggunakan formula:
(4)
ub
(5)
ub
1
(2)
(3)
(3)
[6(ub u(2)
e ) + 2b (2ub + ue )],
2
b
1
(2)
(3)
(3)
=
[12(ub u(2)
e ) + 6b (ub + ue )],
3
b
=
(3)
(4)
(III.40)
(III.41)
u(4)
= ub + b ub ,
e
(III.42)
(4)
(III.43)
u(5)
= ub .
e
4. Hitung besarnya nilai KS timestep dan physical timestep t.

1
[s(ub ) + s(ue )],
2
t = T (new ).
new =
(III.44)
(III.45)
Perhitungan new di atas merupakan aplikasi dari skema KS timesymmetric.

5. Koreksi nilai u dan u(1) menggunakan new ,
1 (2) 2
(1)
+
ue = ub + ub new + ub new
2
1 (3) 3
1 (4) 4
1 (5) 5
ub new + ub new
+
u new , (III.46)
6
24
120 b
1 (3) 2
1 (4) 3
(1)
(2)
u(1)
= ub + ub new + ub new
+ ub new
e
2
6
1 (5) 4
+ ub new .
(III.47)
24
22
6. Ulangi langkah 2-5 hingga nilai , u, dan u(1) konvergen.

Berikut merupakan diagram alir yang menggambarkan proses secara keseluruhan dari integrasi KS Hermite ini.
Gambar. III.1: Diagram alir integrasi menggunakan integrasi KS Hermite.
Bab IV
Hasil dan Analisis
IV.1
Nilai Awal Posisi dan Kecepatan Bintang

Ganda dan Benda ke-3
Untuk masukan nilai awal posisi dan kecepatan bintang ganda dan benda ke-3
yang kami pakai pada Tugas Akhir ini, kami akan menggunakan nilai awal
sesuai dengan paper Funato et al. (Funato et al. 1996).
Gambar. IV.1: Penggambaran koordinat dari sistem 3-benda yang digunakan

sebagai nilai awal berdasarkan Funato et al.(1996).
Gambar IV.1 merupakan gambaran posisi awal dari sistem bintang ganda
dan benda ke-3 yang kami pakai pada Tugas Akhir ini. Pusat kerangka acuan
berada pada pusat massa dari bintang ganda. Massa anggota bintang ganda
23
IV.1. Nilai Awal Posisi dan Kecepatan Bintang Ganda dan Benda ke-3
24
dianggap sama yaitu m1 = m2 = m = 1/2. Sedangkan posisi dan kecepatan

anggota bintang ganda diungkapkan sebagai,
r1 = (r1 cos , r1 sin ),
(IV.1)
v1 = (r1 cos r1 sin , r1 sin + r1 cos ),
(IV.2)
r2 = (r2 cos , r2 sin ),
(IV.3)
v2 = (r2 cos r2 sin , r2 sin + r2 cos ),
(IV.4)
dengan merupakan anomali benar dari bintang ganda. Sedangkan untuk

gerak benda ke-3 dianggap sebagai gerak melingkar mengelilingi pusat massa
bintang ganda. Posisi benda ke-3 diungkapkan sebagai,
r3 = (R cos , R sin ),
(IV.5)
dengan R merupakan jarak benda ke-3 dari pusat massa bintang ganda dan
merupakan anomali benar dari orbit benda ke-3.
Karena m1 = m2 , r1 = r2 = r, dengan r sebagai setengah dari jarak antar
anggota bintang ganda. Maka percepatan yang diterima oleh anggota bintang
ganda akibat dari benda ke-3 adalah,
a1 = m3
(R cos r cos ), (R sin r sin )
,
3
[R2 + r2 2Rr cos phi psi] 2
(R cos + r cos ), (R sin + r sin )
a2 = m3
.
3
[R2 + r2 + 2Rr cos ] 2
(IV.6)
(IV.7)
Besar nilai r, r,
dan dihitung menggunakan,
a(1 e2 )
,
2(1 + e cos )
Ae sin
r1 = r2 = r =
,
2a(1 e2 )
A
A(1 + e cos phi)2
=
=
,
4r2
a2 (1 e2 )
r1 = r2 = r =
(IV.8)
(IV.9)
(IV.10)
dengan a, e, dan A merupakan setengah sumbu panjang, eksentrisitas, dan

p
momentum sudut untuk bintang ganda, A = a(1 e2 ). Nilai parameter
orbit yang dipakai pada Tugas Akhir ini dapat dilihat pada Tabel IV.1.
IV.1. Nilai Awal Posisi dan Kecepatan Bintang Ganda dan Benda ke-3
25
Tabel. IV.1: Nilai Awal Parameter Orbit Bintang Ganda
Bintang ganda
m1
m2
0.5
0.5
1.0
0.5
0.9
0.01 10.1 0.05 0.0
Benda ke-3
Kemudian untuk kebutuhan analisis kami perlu menghitung nilai parameter orbit bintang ganda pada tiap step integrasi. Kami menggunakan cara
berikut untuk menghitung nilai parameter orbit bintang ganda berupa a, e,
dan energi. Energi total bintang ganda dapat diungkapkan menggunakan persamaan,
1 Gm1 m2
.
2
a
Apabila didefinisikan sebagi massa tereduksi yaitu,
m1 m2
=
,
m1 + m2
maka dapat dituliskan E sebagai energi per massa tereduksi,
E=
(IV.11)
(IV.12)
E
1 G(m1 + m2 )
1K
E
=
atau
E =
,
(IV.13)
2
a
2a
dan momentum sudut per massa tereduksi diungkapkan sesuai dengan persamaan,
A2 = Ka(1 e2 ).
(IV.14)
Dengan menggunakan persamaan energi total maka dapat diungkapkan a sebagai,

K
,
(IV.15)
2E
dan dengan menggunakan persamaan momentum sudut maka dapat diungkapa=
kan,
A2
.
(IV.16)
Ka
Kemudian untuk menghitung nilai error, kami menggunakan formula berikut
e2 = 1
untuk masing-masing parameter,

Ei Ei1
,
Ei
A = Ai Ai1 ,
(IV.18)
e = ei ei1 .
(IV.19)
E/E =
(IV.17)
IV.2. Hasil Simulasi 2-Benda
IV.2
26
Hasil Simulasi 2-Benda
Berdasarkan nilai awal yang diuraikan sebelumnya, maka dilakukan simulasi

dengan masukan nilai awal sesuai dengan uraian tersebut. Simulasi dilakukan
menggunakan komputer dengan spesifikasi Prosesor Intel i5, RAM 8 GB, dan
sitem operasi Ubuntu. Simulasi membutuhkan waktu sekitar 30 menit untuk
setiap kali running dengan 200 kali periode bintang ganda. Untuk mengetahui
apakah program kami berjalan dengan baik atau tidak, maka pertama-tama
kami hanya akan mensimulasikan bintang ganda saja tanpa adanya benda ke3. Setelah dilakukan simulasi, dihasilkan beberapa plot yang menggambarkan
kestabilan parameter bintang ganda ketika disimulasikan.
Gambar IV.2 merupakan hasil plot parameter-parameter orbit bintang ganda
berupa energi, momentum sudut, dan eksentrisitas yang diplot terhadap waktu.
Dapat dilihat bahwa nilai skala sumbu y, yaitu nilai error parameter orbit yang
ditunjukkan pada ketiga plot cukup kecil, yaitu antara 1014 1015 . Untuk
sumbu x, yaitu waktu dalam satuan jumlah periode bintang ganda, dapat
dilihat bahwa meskipun telah diintegrasikan selama 200 kali periode bintang
ganda, ketiga plot tetap menunjukan kecenderungan yang sama, yaitu berada
pada nilai sekitar nol.
Kemudian untuk memeriksa apakah metode regularisasi KS bekerja dengan
baik saat menentukan stepsize pada setiap integrasinya, kami juga membuat
plot besar nilai dt terhadap waktu dan sebagai pembanding, kami juga membuat plot besar perubahan separasi bintang ganda r terhadap waktu yang
ditunjukkan pada Gambar IV.3. Plot IV.3a merupakan plot nilai dt terhadap
waktu, dan plot IV.3b merupakan plot nilai separasi bintang ganda terhadap
waktu. Dapat dilihat bahwa plot untuk dt dan separasi bintang ganda memiliki pola yang serupa yang menunjukan bahwa dt dan jarak separasi bintang
ganda saling berkaitan.
27
(a)
(b)
(c)
Gambar. IV.2: Ketiga plot ini menggambarkan error parameter orbit bintang
ganda terhadap waktu. Berturut-turut plot a, b, dan c, menunjukan error
energi ikat, momentum sudut, dan eksentrisitas.
(a)
(b)
Gambar. IV.3: Kedua plot ini menggambarkan perubahan nilai stepsize dt

terhadap waktu (a) dan juga plot separasi bintang ganda terhadap waktu (b).
IV.3
28
Hasil Simulasi 3-Benda
Setelah kami menguji program simulasi menggunakan bintang ganda, maka

pada sub-bab ini kami kemudian akan mengujii program kami dengan menambahkan benda ke-3 dengan nilai awal benda ke-3 mengikuti nilai awal yang
telah dipaparkan pada sub-bab IV.1. Proses running program untuk 3 benda
ini kurang lebih membutuhkan waktu yang sama dengan simulasi 2 benda.
Karena sebenarnya ketika mensimulasikan sistem 3-benda ini, hanya akan terdapat 2 interaksi yang dihitung, yaitu interaksi antar bintang ganda yang
dihitung menggunakan regularisasi KS dan interaksi antara benda ke-3 dan
pusat massa bintang ganda yang dihitung menggunakan interaksi 2-benda biasa. Gambar IV.4 merupakan hasil plot parameter orbit bintang ganda namun
dengan dipengaruhi oleh adanya benda ke-3.
Untuk melihat lebih detail perubahan nilai parameter orbit terhadap waktu,
kami juga membuat plot dengan waktu integrasi lebih pendek yaitu 20 kali
periode bintang ganda yang ditunjukkan pada Gambar IV.5. Dengan menggunakan plot ini kami ingin mengamati perubahan parameter-parameter orbit
bintang ganda, baik yang dipengaruhi benda ke-3 maupun perubahan akibat
dari kesalahan numerik.
29
(a)
(b)
(c)
(d)
Gambar. IV.4: Plot di atas menggambarkan error parameter orbit bintang

ganda akibat dari gangguan benda ke-3 terhadap waktu. Panel a, b, c, menunjukan error energi ikat, momentum sudut, dan ekstentrisitas. Sedangkan
panel d merupakan plot jarak benda ke-3 terhadap pusat massa bintang ganda.
IV.4. Analisis
30
(a)
(b)
(c)
(d)
Gambar. IV.5: Sama seperti Gambar IV.4 namun untuk integrasi selama 20
periode bintang ganda.
IV.4
Analisis
Berdasarkan plot error parameter simulasi 2-benda dan 3-benda, dapat dilihat
adanya perbedaan antara plot error parameter bintang ganda ketika hanya
mensimulasikan bintang ganda dan ketika mensimulasikan bintang ganda ditambah benda ke-3.
Untuk kasus bintang ganda saja dapat ditinjau Gambar IV.2 dan Gambar IV.3. Plot pada Gambar IV.2 menunjukkan bahwa error yang dihasilkan
saat mensimulasikan bintang ganda cukup kecil. Ketika dilihat untuk ketiga
parameter, yaitu energi ikat, momentum sudut, dan eksentrisitas, ketiganya
menunjukan nilai error yang hampir sama, yaitu sekitar orde 1015 1014 .
IV.4. Analisis
31
Selain itu jika dilihat untuk simulasi selama 200 periode bintang ganda, nilai
error untuk ketiga parameter tetap stabil pada nilai sekitar nol. Selain itu
untuk melihat apakah penentuan stepsize oleh metode regularisasi KS bekerja
dengan baik, dapat dilihat Gambar IV.3. Pada Gambar IV.3 dapat dilihat
bahwa nilai dt nilainya berubah-ubah sesuai dengan berubahnya nilai separasi
jarak antar bintang ganda. Semakin dekat jarak antar bintang ganda maka
nilai dt akan semakin kecil, dan sebaliknya, semakin jauh jarak antar bintang
ganda maka nilai dt akan semakin besar.
Untuk kasus 3 benda, dapat dilihat Gambar IV.4. Pada Gambar IV.4
dapat dilihat plot error energi, momentum sudut, dan eksentrisitas yang di plot
terhadap waktu. Di sini dapat dilihat hubungan antara error yang dihasilkan
pada parameter orbit akibat dari benda ketiga dengan melihat kaitan antara
plot IV.5a-c dengan plot IV.5d. Plot IV.5d merupakan plot jarak benda ke-3
terhadap pusat massa bintang ganda. Dapat dilihat pada plot IV.5d ketika
jarak benda ke-3 mendekat maka error yang ditimbulkan pada plot IV.5a-c ikut
membesar, sebaliknya saat jarak benda ke-3 menjauh error yang ditimbulkan
akan mengecil. Meskipun begitu ketiga parameter tetap menunjukkan nilai
eror yang stabil disekitar nol meskipun telah diintegrasikan sebanyak 200 kali
periode bintang ganda. Untuk parameter benda ke-3 yaitu jarak dari pusat
massa bintang ganda, terlihat benda ke-3 semakin lama jaraknya semakin
dekat ke pusat massa bintang ganda . Hal ini juga menunjukan bahwa proses
perhitungan interaksi benda ke-3 dengan pusat massa bintang ganda yang
menggunakan metode simulasi N-benda biasa tanpa menggunakan regularisasi,
juga bekerja cukup baik meskipun ternyata sistem antara benda ke-3 dan pusat
massa bintang ganda tidak terlalu stabil jika dilihat dari jarak benda ke-3 yang
semakin mendekat ke pusat.
Untuk melihat lebih detail mengenai perubahan nilai error untuk ketiga parameter orbit, dapat ditinjau Gambar IV.5 yang menunjukan plot error ketiga
parameter orbit namun dengan jumlah periode yang lebih sedikit. Dapat dilihat bahwa nilai error selain berosilasi bergantung pada jarak benda ke-3, juga
memiliki bentuk osilasi lain yang lebih kecil, yang mungkin disebabkan oleh
kesalahan numerik dari program. Apabila diamati masing-masing plot pada
gambar IV.5, meskipun ketiga gambar IV.5a-c sama-sama memiliki keterkaitan
dengan gambar IV.5d namun pola ketiganya terlihat berbeda. Terlihat bahwa
IV.4. Analisis
32
pola yang dimiliki plot error eksentrisitas terlihat berkebalikan dengan pola error momentum sudut, saat error eksentrisitas membesar, justru nilai error momentum sudut terlihat mengecil atau stabil, hal ini mungkin disebabkan oleh
p
nilai A yang bergantung pada nilai e sesuai dengan rumus, A = a(1 e2 ).
Sehingga nilai error momentum sudut dan eksentrisitas memberikan hubungan
seperti kedua plot tersebut.
Namun apabila dibandingkan dengan hasil yang ada pada paper Funato et
al. (Funato et al. 1996), yang ditunjukkan pada Gambar IV.6 maka terlihat
ada perbedaan antara plot error yang didapat dengan yang dihasilkan pada
paper. Hal ini mungkin disebabkan oleh perbedaan gerak benda ke-3 yang ada
pada paper dan yang kami buat pada Tugas Akhir ini. Jika mengacu pada paper, gerak benda ke-3 seharusnya memiliki orbit lingkaran mengelilingi pusat
massa bintang ganda, namun saat dicoba pada simulasi, benda ke-3 tidak bergerak dengan lintasan lingkaran sempurna melainkan sedikit berosilasi. Selain
itu karena penulis hanya mengacu pada algoritma yang ada pada paper tersebut tanpa melihat kode program yang dipakai pada paper tersebut, sehingga
mungkin terdapat beberapa perbedaan cara penulisan program sehingga hasil
yang diberikan berbeda, dan juga perbedaan bahasa pemrograman yang dipakai mungkin juga mempengaruhi hasil yang diberikan.
Gambar. IV.6: Plot ini merupakan plot error momentum sudut (a) dan eksentrisitas (b) yang ada pada paper Funato et al. (Funato et al. 1996)
Bab V
Simpulan dan Saran
V.1
Simpulan
Berdasarkan pembahasan pada bab-bab sebelumnya, beberapa hal yang dapat

disimpulkan yakni:
1. Program simulasi menggunakan metode regularisasi KS bekerja cukup
baik saat digunakan untuk menghitung interaksi bintang ganda. Hal ini
ditunjukan dengan adanya error yang bernilai cukup kecil yang muncul
pada plot parameter orbit bintang ganda.
2. Metode regularisasi KS juga dapat dengan baik menghitung interaksi
bintang ganda meskipun dengan kondisi yang ekstrim (e = 0.9), dan
tetap stabil meskipun dalam jangka waktu yang lama, yaitu 200 kali
periode bintang ganda.
3. Meskipun memberikan error yang cukup besar saat dilakukan simulasi
dengan benda ke-3, namun metode ini tetap menghasilkan hasil yang
stabil meskipun telah diintegrasikan selama 200 periode bintang ganda.
4. Variasi stepsize yang dihasilkan metode regularisasi KS bekerja dengan
cukup baik, dilihat dari hubungan antara stepsize dt dengan jarak antar
bintang ganda yang saling berkaitan.
33
V.2. Saran
V.2
34
Saran
Pekerjaan lebih lanjut yang dapat dilakukan adalah membuat simulasi Nbenda dengan metode regularisasi yang dapat memecahkan kasus sistem 3
benda atau lebih. Karena dengan mempelajari mengenai interaksi yang terjadi pada sistem 3 benda, akan didapatkan berbagai macam informasi mengenai evolusi secara dinamika sistem tersebut. Misalkan contoh kasus 3-benda,
ada pasangan bintang ganda kemudian ada bintang ke-3. Saat bintang ke3 bergerak mendekati bintang ganda, ada beberapa kemungkinan yang terjadi, misalkan bintang ke-3 mengganggu sistem hingga akhirnya bintang ganda
akan saling lepas dari sistem, atau salah satu bintang ganda akan lepas kemudian salah satunya akan berinteraksi dengan bintang ke-3 membentuk bintang
ganda baru, atau bisa juga ketiganya membentuk sistem triple-star yang stabil. Setelah meninjau aplikasi simulasi N-benda pada sistem 3-benda, dapat
juga ditinjau aplikasi simulasi N-benda sistem yang lebih luas, misalkan gugus
terbuka dan gugus bola. Simulasi 2-benda maupun 3-benda ini cukup penting untuk mengamati evolusi gugus bintang, karena adanya interaksi bintang
ganda dengan bintang lain yang ada di dalam gugus memberikan pengaruh
yang cukup besar terhadap proses evolusi dinamika suatu gugus. Sehingga
ketika ingin membuat suatu simulasi sistem N-benda untuk gugus maka penting untuk memasukkan pengaruh dari interaksi bintang ganda atau sistem
3-bintang yang dihitung menggunakan metode khusus seperti regularisasi agar
hasil yang diberikan lebih akurat. Apabila telah dapat membuat simulasi Nbenda untuk gugus, maka selanjutnya dapat dibuat simulasi N-benda untuk
galaksi yang memasukan berbagai faktor di atas mulai dari evolusi dinamika
gugus, hingga interaksi antar bintang yang terjadi di dalam gugus, sehingga
akan dihasilkan suatu simulasi N-benda yang memiliki skala besar, namun interaksi yang dihitung menyeluruh hingga interaksi antar bintang. Mungkin
untuk saat ini simulasi seperti ini akan membutuhkan step komputasi yang
rumit dan memakan waktu lama, namun di masa yang akan datang mungkin
akan ada bantuan dari supercomputer dan metode simulasi N-benda baru yang
dapat melakukan tugas ini secara cepat dan efisien.
Daftar Pustaka
Aarseth, S.J. 1985. Multiple Time Scales. Academic. New York.
Aarseth, S.J. 1999. From NBODY1 to NBODY6: The Growth of an Industry.
PASP, 111: 1333.
Aarseth, S.J. 2003. Gravitational N-body Simulation:Tools and Algorithm.
Cambridge University Press. New York.
Barnesh, J. & Hut, P. 1986. A Hierarchical O(N logN ) Force-calculation Algorithm. Nature, 324: 446.
Celletti, A. 2006. Basics of Regularization Theory, in Chaotic Worlds: From
Order to Disorder in Gravitational N-Body Dynamical System. Springer.
Netherland. pp.203-203.
Funato, Y., Hut, P., McMillan, S., & Makino, J. 1996. Time-Symmetrized
Kustaanheimo-Stiefel Regularization. AJ, 112: 1697.
Hut, P., McMillan, S., Goodman, J., Mateo, M., Phinney, E. S., Ptyor, C.,
Richer, H. B., Verbunt, F., & Weinberg, M. 1992. Binaries in Globular Clusters. PASP, 104: 981.
Hut,
P.,&
[manuscript
Makino,
on
The
J.
Art
2003-4.
of
Moving
Computational
Stars
Around
Science
site].(www.artcompsci.org/kali/pub/msa/title.html)
Por, E. 2014. Post-Newtonian N-body Dynamics. Universiteit Leiden.
35
web
36
37
Appendix A
Kode Program N-benda
#Import modul yang akan dipakai

import math
from matplotlib import pyplot as pl
import numpy as np
from numpy import array
import os
from random import random, uniform, seed
from mpl_toolkits.mplot3d import Axes3D
from finding_binary import *
from ks_function import *
from timeit import default_timer
from init_function import *
start = default_timer()
#timer untuk running program
rand=int(uniform(1,10000))
#generate bilangan random
seed(rand)
#nilai konstanta
T
=6.2639
#periode bintang ganda
dt
=0.02
#timestep awal
t_end
=200*T
#batas akhir integrasi
n
=3
#jumlah n-benda
#konstanta
G2 = 1
#inisiasi list dan array yang akan digunakan
data_x = np.zeros(n)
data_y = np.zeros(n)
data_z = np.zeros(n)
data_vx = np.zeros(n)
data_vy = np.zeros(n)
data_vz = np.zeros(n)
m = np.zeros(len(data_x))
v = np.zeros((len(data_x), 3))
r = np.zeros((len(data_x), 3))
a = np.zeros((len(data_x), 3))
jk = np.zeros((len(data_x), 3))
data_n = len(data_x)
old_r = np.zeros((data_n, 3))
old_v = np.zeros((data_n, 3))
old_a = np.zeros((data_n, 3))
old_j = np.zeros((data_n, 3))
#nilai parameter bintang ganda
ax = 1.
ax2= 10.1
e = 0.9
e2= 0.0
phi = 20
PHI = 45
initial = init(ax,e,ax2,e2,phi,PHI) #fungsi yang berfungsi untuk men-generate
#nilai awal bintang ganda
r = initial[0]
v = initial[1]
m = initial[2]
#mencari a dan jk awal
for i in range (0,data_n,1):
for k in range (0,3,1):
a[i,k] = jk[i,k] = 0.
for j in range (i+1,data_n,1):
rji = np.zeros(3)
vji = np.zeros(3)
rji[k] = r[j,k] - r[i,k]
vji[k] = v[j,k] - v[i,k]
38
r2 = 0.
r2 = r2 + (rji[k]**2)
r3 = r2 * math.sqrt(r2)
rv = 0.
rv = rv + (rji[k] * vji[k])
rv = rv/r2
a[i,k] = a[i,k] + G2*m[j]*rji[k] /r3
a[j,k] = a[j,k] - G2*m[i]*rji[k] /r3
jk[i,k] = jk[i,k] + G2*(m[j]*(vji[k] - 3 * rv * rji[k])/r3)
jk[j,k] = jk[j,k] - G2*(m[i]*(vji[k] - 3 * rv * rji[k])/r3)
#nilai a awal ditambahkan pengaruh benda ke-3 (jika ada)
a[2] = a[2]+initial[3][0]
a[1] = a[1]+initial[3][1]
#menghitung energi awal
ekin = 0.
epot = 0.
rji = np.zeros(3)
r2 = 0.
r2 = r2 + (rji[k]**2)
epot = (epot - G2*m[i] * m[j] / math.sqrt(r2))
ekin = (ekin + 0.5 * m[i] * v[i,k] *v[i,k])
e_in = ekin + epot
#energi total awal
print "inital total energy E_in",e_in
dt_out = 0.01
t_out = dt_out
#pemindahan direktori untuk penyimpanan output berupa gambar
current_dir = os.getcwd()
target_dir = current_dir + "/final"
os.chdir(target_dir)
e,d_e,d_energi,R_3,R_2,delta_t,A,d_A,t_arr,t_arr3,energi=[],[],[],[],[],[],[],[],[],[],[]
n = 0
t=0.
dat=1
en=1
loop=1
while t<t_end:
if t==0.0:
data_bin=list(find_bin(m,r,v,data_n))
data_bg=data_bin[0]
jml_bin=data_bin[1]
jml_bin_member=int(jml_bin*2)
data_n = data_n - jml_bin
if t<t_end:
#memisahkan anggota bintang ganda
m_bin=np.zeros((jml_bin_member))
r_bin=np.zeros((jml_bin_member,3))
v_bin=np.zeros((jml_bin_member,3))
a_bin=np.zeros((jml_bin_member,3))
jk_bin=np.zeros((jml_bin_member,3))
member=np.zeros((jml_bin_member))
k=0
m_cm=0.
for i in range (0,jml_bin,1):
for j in range (0,jml_bin_member,1):
member[k] = int(data_bg[i,j])
m_bin[k]=m[member[k]]
m_cm += m[member[k]]
for l in range (0,3,1):
r_bin[k,l] = r[member[k],l]
v_bin[k,l] = v[member[k],l]
a_bin[k,l] = a[member[k],l]
39
jk_bin[k,l] = jk[member[k],l]
k+=1
for i in range (0,jml_bin_member,1):
for j in range (i+1,jml_bin_member,1):
r_cm = np.zeros((3))
v_cm = np.zeros((3))
a_cm = np.zeros((3))
jk_cm = np.zeros((3))
r_cm[k] = (m[i]*r_bin[i,k] +m[j]*r_bin[j,k])/(m_cm)
v_cm[k] = (m[i]*v_bin[i,k] +m[j]*v_bin[j,k])/(m_cm)
a_cm[k] = (m[i]*a_bin[i,k] +m[j]*a_bin[j,k])/(m_cm)
jk_cm[k] = (m[i]*jk_bin[i,k] +m[j]*jk_bin[j,k])/(m_cm)
#menghitung nilai parameter bintang ganda untuk analisis
data_bin=list(find_bin(m_bin,r_bin,v_bin,jml_bin_member))
ecc = data_bin[2]
Am = data_bin[3]
sma = data_bin[4]
r_2 = data_bin[5]
A = np.append(A,Am)
e = np.append(e,ecc)
if t > 0.:
d_ecc = e[dat]-e[dat-1]
d_Am = A[dat]-A[dat-1]
dat+=1
R_2=np.append(R_2,r_2)
d_e = np.append(d_e,d_ecc)
d_A = np.append(d_A,d_Am)
t_arr = np.append(t_arr,t)
r_new = np.delete(r,(data_bg),0)
r_new = np.vstack((r_new,r_cm))
v_new = np.delete(v,(data_bg),0)
v_new = np.vstack((v_new,v_cm))
a_new = np.delete(a,(data_bg),0)
a_new = np.vstack((a_new,r_cm))
jk_new = np.delete(jk,(data_bg),0)
jk_new = np.vstack((jk_new,v_cm))
m_new = np.delete(m,member)
m_new = np.append(m_new,m_cm)
m=m_new
r=r_new
v=v_new
a=a_new
jk=jk_new
rji = np.zeros(3)
rji[k] = r[i,k] - 0
r_3_sq=0.
r_3_sq += (rji[k]**2)
if t>0.:
r_3=math.sqrt(r_3_sq)
R_3=np.append(R_3,r_3)
#memanggil fungsi regularisasi KS untuk digunakan
ks_result=list(ks_reg(m_bin,r_bin,v_bin,a_bin,jk_bin,r_cm,v_cm,a_cm,jk_cm,jml_bin_member,dt))
r_ks=ks_result[0]
v_ks=ks_result[1]
dt = ks_result[2]
r_bin = r_ks
v_bin = v_ks
#menghitung error energi bintang ganda
e_bind = ks_result[3]
energi = np.append(energi,e_bind)
e = np.append(e,ecc)
if t > 0.:
d_erg = (energi[en]-energi[en-1])/energi[en]
en+=1
d_energi = np.append(d_energi,d_erg)
delta_t = np.append(delta_t,dt)
#1. Prediksi r dan v
40
old_r[i,k] = r[i,k]
old_v[i,k] = v[i,k]
old_a[i,k] = a[i,k]
old_j[i,k] = jk[i,k]
r[i,k] += v[i,k]*dt + a[i,k]*dt*dt/2 + jk[i,k]*dt*dt*dt/6
v[i,k] += a[i,k]*dt + jk[i,k]*dt*dt/2
#2. Evaluasi nilai a dan jk
iterasi =0.
while iterasi<1:
r_awal = r
v_awal = v
a[i,k] = jk[i,k] = 0.0
rji = np.zeros(3)
vji = np.zeros(3)
vji[k] = v[j,k] - v[i,k]
r2 = 0.
r2 += (rji[k]*rji[k])
r3=r2*math.sqrt(r2)
rv=0.
rv += rji[k]*vji[k]
rv = rv/r2
a[i,k] += G2*(m[j]*rji[k] /r3)
a[j,k] -= G2*(m[i]*rji[k] /r3)
jk[i,k] += G2*(m[j]*(vji[k] - 3 * rv * rji[k])/r3)
jk[j,k] -= G2*(m[i]*(vji[k] - 3 * rv * rji[k])/r3)
selisih_r = np.zeros((4))
v[i,k] = old_v[i,k] + ((old_a[i,k] + a[i,k])*dt/2) + (old_j[i,k] - jk[i,k])*dt*dt/12
r[i,k] = old_r[i,k] + ((old_v[i,k] + v[i,k])*dt/2) + (old_a[i,k] - a[i,k])*dt*dt/12
selisih_r[k]=abs(r[i,k]-r_awal[i,k])
selisih_r_tot = math.sqrt(selisih_r[0]**2 +selisih_r[1]**2 +selisih_r[2]**2)
r_tot = math.sqrt(r[0,0]**2 +r[0,1]**2 +r[0,2]**2)
if selisih_r_tot < abs(r_tot*10**-10):
iterasi +=1
else:
iterasi =0.
print selisih_r, 'selisih r',t
'''======gabungkan ks ke cartesian======'''
for l in range (0,3,1):
r_cm[l] = r[-1,l]
v_cm[l] = v[-1,l]
a_cm[l] = a[-1,l]
jk_cm[l] = jk[-1,l]
m_end = np.delete(m,-1,0)
m_end = np.append(m_end,m_bin[1])
m_end = np.append(m_end,m_bin[0])
r_end = np.delete(r,-1,0)
v_end = np.delete(v,-1,0)
a_end = np.delete(a,-1,0)
jk_end = np.delete(jk,-1,0)
r_bin = np.zeros((jml_bin_member,3))
v_bin = np.zeros((jml_bin_member,3))
for i in range (0,jml_bin_member,1):
for j in range (i+1,jml_bin_member,1):
r_bin[i,k]=r_ks[i,k]
r_bin[j,k]=r_ks[j,k]
v_bin[i,k]=v_ks[i,k]
v_bin[j,k]=v_ks[j,k]
a_bin[i,k]=a_cm[k]+a_bin[i,k]
a_bin[j,k]=a_cm[k]+a_bin[j,k]
jk_bin[i,k]=jk_cm[k]+jk_bin[i,k]
jk_bin[j,k]=jk_cm[k]+jk_bin[j,k]
41
r_end = np.vstack((r_end,r_bin))
v_end = np.vstack((v_end,v_bin))
a_end = np.vstack((a_end,a_bin))
jk_end = np.vstack((jk_end,jk_bin))
m =m_end
r =r_end
v =v_end
a =a_end
jk=jk_end
fig = pl.figure(n)
pl.xlim(-31,31)
pl.ylim(-31,31)
for i in range (0,data_n+1,1):
pl.scatter (r[i,0],r[i,1], s=m[i]*50)
if (n%1) == 0.:
#pl.savefig("plot_"+str(n)+".png")
pl.close(fig)
print t, t_end
t+=dt
n = n + 1
print rand,"random"
fig = pl.figure(5)
#pl.xlim(-1e-3,6)
pl.ylim(-5e-3,5e-3)
pl.plot(t_arr[1::]/T,d_e[1::])
pl.xlabel("t/P",fontsize=20)
pl.ylabel(r"$\Delta$e",fontsize=20)
#pl.title(r"plot $\Delta$e vs t ")
pl.savefig("plot d_e vs t "+str(rand)+".png")
pl.close(fig)
fig = pl.figure(6)
#pl.ylim(-5e-3,5e-3)
pl.plot(t_arr[1::]/T,d_A[1::])
pl.ylabel(r"$\Delta$A",fontsize=20)
#pl.title("plot d_A vs t ")
pl.savefig("plot d_A vs t "+str(rand)+".png")
pl.close(fig)
fig = pl.figure(7)
#pl.ylim(-5e-3,5e-3)
pl.plot(t_arr[1::]/T,d_energi[1::])
pl.ylabel(r"$\Delta$E/E",fontsize=20)
#pl.title("plot d_E vs t ")
pl.savefig("plot d_Energi vs t "+str(rand)+".png")
pl.close(fig)
fig = pl.figure(10)
#pl.ylim(8,12)
pl.plot(t_arr[1::]/T,R_3[1::])
pl.ylabel("R",fontsize=20)
#pl.title("plot R vs t benda ke 3")
pl.savefig("plot R vs t benda ke 3 "+str(rand)+".png")
pl.close(fig)
fig = pl.figure(11)
#pl.ylim(0,0.5)
pl.plot(t_arr[1::]/T,delta_t[1::])
pl.ylabel(r"$\Delta$t",fontsize=20)
#pl.title(r"plot $\Delta$t vs t")
pl.savefig("plot dt vs t "+str(rand)+".png")
pl.close(fig)
fig = pl.figure(12)
#pl.ylim(8,12)
pl.plot(t_arr[1::]/T,R_2[1::])
pl.ylabel("r",fontsize=20)
#pl.title("plot r vs t")
42
pl.savefig("plot r_2 vs t "+str(rand)+".png")

pl.close(fig)
#os.chdir(current_dir)
epot = ekin=0.0
r2 = 0
for k in range (0,k,1):
r2 += rji[k] * rji[k]
epot -= G2*m[i]*m[j]/math.sqrt(r2)
ekin += 0.5 * m[i] * v[i,k] *v[i,k]
e_out
print
print
print
= ekin + epot
('Final total energi='),e_out
('absolut energy error : E-out - E_in='), e_out-e_in
('relative error'),(e_out - e_in) / e_in
duration= default_timer() - start

print "Waktu running = ",duration/60.,"menit"
43
44
Appendix B
Kode Program Fungsi Parameter
Bintang Ganda
def find_bin(m,r,v,data_n):
import math
import numpy as np
import os
r_snap = np.zeros((data_n, 3))
v_snap = np.zeros((data_n, 3))
m_snap = np.zeros(data_n)
data_bg= np.empty(shape=[0,2])
R_2=[]
global sma
global e
#print "menghitung binary"
m_snap[i]=m[i]
r_snap[i,k]=r[i,k]
v_snap[i,k]=v[i,k]
#finding binary
rji = np.zeros(3)
rji[k] = r_snap[j,k] - r_snap[i,k]
r_2_sq=0.
print rji
r_2_sq += (rji[k]**2)
r_2=math.sqrt(r_2_sq)
#R_2=np.append(R_2,r_2)
print r_2,"r binary"
ndim=3
delr=np.zeros(ndim)
delv=np.zeros(ndim)
jml_bin=0
ii=0
for i in range (0,data_n-1,1):
delr_sq=0.
delv_sq=0.
for k in range (0,ndim,1):
delr[k]
delv[k]
delr_sq
delv_sq
= r_snap[j,k]-r_snap[i,k]
= v_snap[j,k]-v_snap[i,k]
+= delr[k] * delr[k]
+= delv[k] * delv[k]
45
m_tot = m_snap[i] + m_snap[j]

Etilde = (-m_tot / math.sqrt(delr_sq)) + 0.5 * delv_sq
#print Etilde,"Etilde_bin"
if Etilde < 0.0:
Ltilde_sq = 0.
if ndim==2:
r_cross_v_component = delr[0] * delv[1] - delr[1]*delv[0]
Ltilde_sq = (r_cross_v_component)*(r_cross_v_component)
if ndim==3:
Ltilde_sq = (r_cross_v_component)*(r_cross_v_component)
Ltilde_sq += (r_cross_v_component)*(r_cross_v_component)
Ltilde_sq += (r_cross_v_component)*(r_cross_v_component)
else:
print ("find binary : ndim = "),ndim
print ('not supported')
sma = -0.5 * m_tot/ Etilde
e_sq = 1 - Ltilde_sq/(m_tot *sma)
if e_sq > 0.:
e = math.sqrt(e_sq)
else:
e = 0.0
a_maks = 1.4
if sma < a_maks:
#print ('star1 ='+str(i)+'star2 ='+str(j))
#print ('a =' + str(sma) + 'e =' + str(e))
bg= np.array([i,j])
data_bg= np.vstack((data_bg,bg))
jml_bin = jml_bin + 1
A = sma*math.sqrt(1-e**2)
#print ('jumlah binary='), jml_bin
return data_bg,jml_bin,e,A,sma,r_2
46
47
Appendix C
Kode Program Fungsi Nilai Awal
def init(a,e,a2,e2,phi,PHI):
import math
import numpy as np
r = np.zeros((3,3))
v = np.zeros((3,3))
acc = np.zeros((2,3))
m = np.zeros((3))
A = math.sqrt(a*(1-e**2))
A2 = math.sqrt(a2*(1-e2**2))
r_1=r_2= (a*(1 - e**2))/(2*(1+e*math.cos(math.radians(phi))))
r_3= ((a2*(1 - e2**2))/((1+e2*math.cos(math.radians(PHI)))))
v_1=v_2= (A*e*math.sin(math.radians(phi)))/(2*a*(1-e**2))
v_3= (A2*e2*math.sin(math.radians(PHI)))/(a2*(1-e2**2))
phi_dot = A/(4*r_1**2)
PHI_DOT = A2/(4*r_3**2)
r[2,0] = r_1 * math.cos(math.radians(phi))
r[2,1] = r_1 * math.sin(math.radians(phi))
r[2,2] = 0.
v[2,0] = ((v_1 * math.cos(math.radians(phi))) - (r_1 * phi_dot * math.sin(math.radians(phi))))
v[2,1] = ((v_1 * math.sin(math.radians(phi))) + (r_1 * phi_dot * math.cos(math.radians(phi))))
v[2,2] = 0.
r[1,0] = -r_2 * math.cos(math.radians(phi))
r[1,1] = -r_2 * math.sin(math.radians(phi))
r[1,2] = 0.
v[1,0] = -((v_2 * math.cos(math.radians(phi))) - (r_2 * phi_dot * math.sin(math.radians(phi))))
v[1,1] = -((v_2 * math.sin(math.radians(phi))) + (r_2 * phi_dot * math.cos(math.radians(phi))))
v[1,2] = 0.
r[0,0] = r_3 * math.cos(math.radians(PHI))
r[0,1] = r_3 * math.sin(math.radians(PHI))
r[0,2] = 0.
v[0,0] = 4*((v_3 * math.cos(math.radians(PHI))) - (r_3 * PHI_DOT * math.sin(math.radians(PHI))))
v[0,1] = 4*((v_3 * math.sin(math.radians(PHI))) + (r_3 * PHI_DOT * math.cos(math.radians(PHI))))
v[0,2] = 0.
m[2]=0.5
m[1]=0.5
m[0]= 0.01
#percepatan
acc[0,0] = m[2]*(r_3*math.cos(math.radians(PHI))-r_1*math.cos(math.radians(phi)))/((r_3**2
r_1**2 - 2*r_3*r_1*math.cos(math.radians(phi-PHI)))**(3./2.))
acc[0,1] = m[2]*(r_3*math.sin(math.radians(PHI))-r_1*math.sin(math.radians(phi)))/((r_3**2
r_1**2 - 2*r_3*r_1*math.cos(math.radians(phi-PHI)))**(3./2.))
acc[0,2] = 0.0
acc[1,0] = m[2]*(r_3*math.cos(math.radians(PHI))+r_1*math.cos(math.radians(phi)))/((r_3**2
r_1**2 + 2*r_3*r_1*math.cos(math.radians(phi-PHI)))**(3./2.))
acc[1,1] = m[2]*(r_3*math.sin(math.radians(PHI))+r_1*math.sin(math.radians(phi)))/((r_3**2
r_1**2 + 2*r_3*r_1*math.cos(math.radians(phi-PHI)))**(3./2.))
acc[1,2] =0.0
return r,v,m,acc
+
+
+
+
48
49
Appendix D
Kode Program Integrasi KS Hermite
def ks_reg(m,r,v,a,jk,r_cm,v_cm,a_cm,jk_cm,data_n,dt):
import math
import numpy as np
import os
from mpl_toolkits.mplot3d import Axes3D
from ks_timestep import *
print a
#fig = pl.figure()
#KS komponen
G2 = 1.
eta=0.005
u = np.zeros((4))
ub = np.zeros((4))
ub_1 = np.zeros((4))
ue = np.zeros((4))
ue_1 = np.zeros((4))
LPb =
LPb1=
LJb =
LPe =
LPe1=
LJe =
np.zeros((4))
np.zeros((4))
np.zeros((4))
np.zeros((4))
np.zeros((4))
np.zeros((4))
#d_tau = np.zeros((data_bin))
#d_tau_new = np.zeros((data_bin))
r_ksb = np.zeros((3))
v_ksb = np.zeros((3))
r_kse = np.zeros((3))
v_kse = np.zeros((3))
#matriks
Ab = np.zeros((3,4))
Ae = np.zeros((3,4))
A1b = np.zeros((3,4))
A1e = np.zeros((3,4))
P = np.zeros((3))
J = np.zeros((3))
old_r = np.zeros((data_n, 3))
old_v = np.zeros((data_n, 3))
50
old_a = np.zeros((data_n, 3))

old_j = np.zeros((data_n, 3))
#print a
old_r[i,k]
old_v[i,k]
old_a[i,k]
old_j[i,k]
#print old_a
=
=
=
=
r[i,k]
v[i,k]
a[i,k]
jk[i,k]
'''=====#konversi dari r ke u====='''

r_ksb = np.zeros(3)
v_ksb = np.zeros(3)
r_ksb[k] = old_r[j,k]-old_r[i,k]
v_ksb[k] = old_v[j,k]-old_v[i,k]
m_total = m[j]+m[i]
ub_2[k] = ub_3[k] = 0.
r_total = math.sqrt((r_ksb[0]**2+r_ksb[1]**2+r_ksb[2]**2))
if r_ksb[0] > 0:
ub[0] = math.sqrt(0.5*(r_ksb[0]+r_total))
ub[1] = 0.5 * r_ksb[1] / ub[0]
ub[2] = 0.5 * r_ksb[2] / ub[0]
ub[3] = 0.
#print ub[i,0]
else :
ub[1] = math.sqrt((0.5*(r_total-r_ksb[0])))
ub[0] = 0.5 * r_ksb[1] /ub[1]
ub[3] = 0.5 * r_ksb[2] /ub[1]
ub[2] = 0.
#transformasi matriks begin
Ab[0,0] = ub[0]
Ab[0,1] = -ub[1]
Ab[0,2] = -ub[2]
Ab[0,3] = ub[3]
Ab[1,0] = ub[1]
Ab[1,1] = ub[0]
Ab[1,2] = -ub[3]
Ab[1,3] = -ub[2]
Ab[2,0] = ub[2]
Ab[2,1] = ub[3]
Ab[2,2] = ub[0]
Ab[2,3] = ub[1]
ub_1[k] = 0.5 * (Ab[0,k]*v_ksb[0] + Ab[1,k]*v_ksb[1] + Ab[2,k]*v_ksb[2])
'''=======sudah konversi r dan v ke u u1======'''
'''=======hitung u2,u3 dan h======'''
r_u = (ub[0]**2+ub[1]**2+ub[2]**2+ub[3]**2)
v_b_tot = math.sqrt(v_ksb[0]**2 + v_ksb[1]**2 + v_ksb[2]**2)
hb = (2.*(ub_1[0]**2+ub_1[1]**2+ub_1[2]**2+ub_1[3]**2)-(G2*m_total))/r_u
#hitung P dan J
Pb = Jb = np.zeros((3))
Pb[k] = old_a[1,k] + old_a[0,k]
Jb[k] = old_j[1,k] + old_j[0,k]
"""for i in range (0,data_n,1):
Pb = Jb = np.zeros((3))
51

print "a"
Pb[k] = old_a[j,k] - old_a[i,k]
Jb[k] = old_j[j,k] - old_j[i,k]"""
#print Pb,"pB"
#Matriks A(u1)
A1b[0,0] = ub_1[0]
A1b[0,1] = -ub_1[1]
A1b[0,2] = -ub_1[2]
A1b[0,3] = ub_1[3]
A1b[1,0] = ub_1[1]
A1b[1,1] = ub_1[0]
A1b[1,2] = -ub_1[3]
A1b[1,3] = -ub_1[2]
A1b[2,0] = ub_1[2]
A1b[2,1] = ub_1[3]
A1b[2,2] = ub_1[0]
A1b[2,3] = ub_1[1]
#hitung A(u)P dan A(u')P dan A(u)rJ
LPb[k] = (Ab[0,k]*Pb[0] + Ab[1,k]*Pb[1] + Ab[2,k]*Pb[2])
LPb1[k] = (A1b[0,k]*Pb[0] + A1b[1,k]*Pb[1] + A1b[2,k]*Pb[2])
LJb[k] = (Ab[0,k]*r_u*Jb[0] + Ab[1,k]*r_u*Jb[1] + Ab[2,k]*r_u*Jb[2])
#hitung h1 dan h2
hb1 = -2*(ub_1[0]*LPb[0]+ub_1[1]*LPb[1]+ub_1[2]*LPb[2]+ub_1[3]*LPb[3])
hb2 = -2*((ub_2[0]*LPb[0]+ub_2[1]*LPb[1]+ub_2[2]*LPb[2]+ub_2[3]*LPb[3])+(ub_1[0]*LPb1[0]+ub_1
[1]*LPb1[1]+ub_1[2]*LPb1[2]+ub_1[3]*LPb1[3])+(ub_1[0]*LJb[0]+ub_1[1]*LJb[1]+ub_1[2]*LJb[2]+ub_1[3]*LJb
[3]))
#hitung u2 dan u3
ub_2[k] = 0.5*hb*ub[k] + 0.5*r_u*LPb[k]
ub_3[k] = 0.5*hb*ub_1[k] + 0.5*hb1*ub[k] + 0.5*r_u*v_b_tot*LPb[k] + 0.5*r_u*LPb1[k] +
0.5*r_u*LJb[k]
'''======didapat u2 dan u3===='''
'''======hitung d_tau====='''
ub_total = math.sqrt(ub[0]**2 + ub[1]**2 + ub[2]**2 + ub[3]**2)
ub_1_total = math.sqrt(ub_1[0]**2 + ub_1[1]**2 + ub_1[2]**2 + ub_1[3]**2)
#print ub_3_total,ub_1_total
d_tau = s1(eta,ub_total,ub_1_total,ub_2_total,ub_3_total)
'''======hitung prediksi u dan u1 dalam KS===='''
pred_u = np.zeros((4))
pred_u1 = np.zeros((4))
ue[k] = ub[k] + ub_1[k]*d_tau + 0.5*ub_2[k]*d_tau**2 + (1./6.)*ub_3[k]*d_tau**3
ue_1[k] = ub_1[k] + ub_2[k]*d_tau + 0.5*ub_3[k]*d_tau**2
he = hb +hb1*d_tau + 0.5*hb2*d_tau**2
pred_u[k] = ue[k]
pred_u1[k] = ue_1[k]
'''======didapat prediksi u dan u1 dalam ks===='''
'''======evaluasi u2,u3,h1====='''
#matriks A(ue)
iterasiks=0
while iterasiks<1:
Ae[0,0]
Ae[0,1]
Ae[0,2]
Ae[0,3]
Ae[1,0]
Ae[1,1]
=
=
=
=
=
=
ue[0]
-ue[1]
-ue[2]
ue[3]
ue[1]
ue[0]
52
Ae[1,2] = -ue[3]
Ae[1,3] = -ue[2]
Ae[2,0] = ue[2]
Ae[2,1] = ue[3]
Ae[2,2] = ue[0]
Ae[2,3] = ue[1]
r_e = (ue[0]**2+ue[1]**2+ue[2]**2+ue[3]**2)
for j in range (0,3,1):
v_kse [j]=0.
for k in range(0,4,1):
v_kse[j] += Ae[j,k]*ue_1[k]
v_kse[j] = v_kse[j]*2./r_e
v_e_tot = math.sqrt(v_kse[0]**2 + v_kse[1]**2 + v_kse[2]**2)
#definisikan P dan J hasil evaluasi
"""for i in range (0,data_n,1):
for j in range (i+1,data_n,1):"""
Pe = Je = np.zeros((3))
#print a[:,:],"percepatan ks"
Pe[k] = a[1,k] + a[0,k]
#print Pe[k]
Je[k] = jk[1,k] + jk[0,k]
#print Pe
#matriks A(ue1)
A1e[0,0] = ue_1[0]
A1e[0,1] = -ue_1[1]
A1e[0,2] = -ue_1[2]
A1e[0,3] = ue_1[3]
A1e[1,0] = ue_1[1]
A1e[1,1] = ue_1[0]
A1e[1,2] = -ue_1[3]
A1e[1,3] = -ue_1[2]
A1e[2,0] = ue_1[2]
A1e[2,1] = ue_1[3]
A1e[2,2] = ue_1[0]
A1e[2,3] = ue_1[1]
#hitung A(u)P dan A(u')P dan A(u)rJ
LPe[k] = (Ae[0,k]*Pe[0] + Ae[1,k]*Pe[1] + Ae[2,k]*Pe[2])
LPe1[k] = (A1e[0,k]*Pe[0] + A1e[1,k]*Pe[1] + A1e[2,k]*Pe[2])
LJe[k] = (Ae[0,k]*r_e*Je[0] + Ae[1,k]*r_e*Je[1] + Ae[2,k]*r_e*Je[2])
he1 = -2*(ue_1[0]*LPe[0]+ue_1[1]*LPe[1]+ue_1[2]*LPe[2]+ue_1[3]*LPe[3])
he2 = -2*((ue_2[0]*LPe[0]+ue_2[1]*LPe[1]+ue_2[2]*LPe[2]+ue_2[3]*LPe[3])+(ue_1[0]*LPe1[0]+ue_1
[1]*LPe1[1]+ue_1[2]*LPe1[2]+ue_1[3]*LPe1[3])+(ue_1[0]*LJe[0]+ue_1[1]*LJe[1]+ue_1[2]*LJe[2]+ue_1[3]*LJe
[3]))
ue_2[k] = 0.5*he*ue[k] + 0.5*r_e*LPe[k]
ue_3[k] = 0.5*he*ue_1[k] + 0.5*he1*ue[k] + 0.5*r_e*v_e_tot*LPe[k] + 0.5*r_e*LPe1[k] +
0.5*r_e*LJe[k]
'''=====hitung turunan ke 4,5======'''
ub_4[k] = (-1./(d_tau**2))*((6*(ub_2[k]-ue_2[k]))+2*d_tau*(2*ub_3[k]+ue_3[k]))
ub_5[k] = (1./(d_tau**3))*((12*(ub_2[k]-ue_2[k]))+6*d_tau*(ub_3[k]+ue_3[k]))
ue_4[k] = ub_3[k] + d_tau*ub_4[k]
ue_5[k] = ub_4[k]
#print ue
'''=====ubah d_tau ke dt===='''
ub_total = math.sqrt(ub[0]**2 + ub[1]**2 + ub[2]**2 + ub[3]**2)
ue_total = math.sqrt(ue[0]**2 + ue[1]**2 + ue[2]**2 + ue[3]**2)
ue_1_total = math.sqrt(ue_1[0]**2 + ue_1[1]**2 + ue_1[2]**2 + ue_1[3]**2)
d_tau_new = 0.5*(s1(eta,ub_total,ub_1_total,ub_2_total,ub_3_total)+ s1
(eta,ue_total,ue_1_total,ue_2_total,ue_3_total))
d_tau=d_tau_new
#delta_dtau =(s1(eta,ub_total,ub_1_total,ub_2_total,ub_3_total) - s1
(eta,ue_total,ue_1_total,ue_2_total,ue_3_total))
53

ue_1[k] = ub_1[k] + 0.5*(ub_2[k] + ue_2[k])*d_tau + (1./12.)*(ub_3[k]-ue_3[k])*d_tau**2
ue[k] = ub[k] + 0.5*(ub_1[k] + ue_1[k])*d_tau + (1./12.)*(ub_2[k]-ue_2[k])*d_tau**2
he = hb + 0.5*(hb1 + he1)*d_tau + (1./12.)*(hb2-he2)*d_tau**2
delta_ue=delta_ue1=np.zeros((4))

delta_ue[k] = abs(pred_u[k] - ue[k])
delta_ue1[k] = abs(pred_u1[k] - ue_1[k])
selisih_u = math.sqrt(delta_ue[0]**2 + delta_ue[1]**2 + delta_ue[3]**2 + delta_ue[3]**2)
if selisih_u < abs(ue_total*10**-4):
iterasiks+=1
else:
iterasiks =0
#print delta_ue[0],ue_total*10**-4
old_r[i,k] = r[i,k]
old_v[i,k] = v[i,k]
old_a[i,k] = a[i,k]
old_j[i,k] = jk[i,k]
r[i,k] += v[i,k]*dt + a[i,k]*dt*dt/2 + jk[i,k]*dt*dt*dt/6
v[i,k] += a[i,k]*dt + jk[i,k]*dt*dt/2
dt = fungsi_T(d_tau_new,ue,ue_1,ue_2,ue_3,ue_4,ue_5)
#dt/=10
#print d_tau,dt
r_kse[0] = ue[0]**2 - ue[1]**2 - ue[2]**2 + ue[3]**2
r_kse[1] = 2*(ue[0]*ue[1] - ue[2]*ue[3])
r_kse[2] = 2*(ue[0]*ue[2] + ue[1]*ue[3])
r_kse_total = math.sqrt(r_kse[0]**2 + r_kse[1]**2 + r_kse[2]**2)
r_cm = np.zeros((3))
v_cm = np.zeros((3))
r_cm[k] = (m[j]*old_r[i,k] +m[i]*old_r[j,k])/(m[i]+m[j])
v_cm[k] = (m[j]*old_v[i,k] +m[i]*old_v[j,k])/(m[i]+m[j])
# print v_cm[k], v[i,k],v[j,k],'lama'
#print r_cm[k], r[i,k],r[j,k],'r'
myu = (m[i]*m[j])/(m[j]+m[i])
r[i,k]=r_cm[k] + myu*r_kse[k]/m[i]
r[j,k]=r_cm[k] - myu*r_kse[k]/m[j]
v[i,k]=v_cm[k] + myu*v_kse[k]/m[i]
v[j,k]=v_cm[k] - myu*v_kse[k]/m[j]
#print a
print Pb, "Perturbation"
#print delta_dtau,"Delta Dtau"
return r,v,dt,he
54
55
Appendix E
Kode Program Fungsi Timestep
untuk Integrasi KS Hermite
def s(eta,u,u_1):
s=eta*(u/(u_1))
return s
def s1(eta,u,u_1,u_2,u_3):
import math
s1=math.sqrt(eta*(((u_2*u)+u_1**2)/((u_3*u_1)+u_2**2)))
#s1=eta*(u/(u_1))
'''
a = eta * math.sqrt(u_2*u/(u_3*u_1))
b = eta * math.sqrt(u_1/u_2)
if a<b:
s1=a
else:
s1=b
'''
return s1
def fungsi_T(d_tau,ue,ue_1,ue_2,ue_3,ue_4,ue_5):
import math
import numpy as np
u_stgh = np.zeros((4))
u_stgh_1 = np.zeros((4))
for k in range(0,4,1):
u_stgh[k] = ue[k] + (d_tau/2.)*ue_1[k] + ((d_tau**2)/8.)*ue_2[k] + ((d_tau**3)/48.)*ue_3[k] +
((d_tau**4)/384.)*ue_4[k] + ((d_tau**5)/3840.)*ue_5[k]
u_stgh_1[k] = ue_1[k] + (d_tau/2.)*ue_2[k] + ((d_tau**2.)/8.)*ue_3[k] + ((d_tau**3)/48.)*ue_4
[k] + ((d_tau**4)/384.)*ue_5[k]
u_stgh_2[k] = ue_2[k] + (d_tau/2.)*ue_3[k] + ((d_tau**2.)/8.)*ue_4[k] + ((d_tau**3)/48.)*ue_5
[k]
u_stgh_3[k] = ue_3[k] + (d_tau/2.)*ue_4[k] + ((d_tau**2.)/8.)*ue_5[k]
u_stgh_4[k] = ue_4[k] + (d_tau/2.)*ue_5[k]
u_dot_u =u_stgh[0]*u_stgh[0] + u_stgh[1]*u_stgh[1] + u_stgh[2]*u_stgh[2] + u_stgh[3]*u_stgh[3]
u_dot_u2 = u_stgh[0]*u_stgh_2[0] + u_stgh[1]*u_stgh_2[1] + u_stgh[2]*u_stgh_2[2] + u_stgh
[3]*u_stgh_2[3]
u1_dot_u1 = u_stgh_1[0]*u_stgh_1[0] + u_stgh_1[1]*u_stgh_1[1] + u_stgh_1[2]*u_stgh_1[2] + u_stgh_1
[3]*u_stgh_1[3]
u_dot_u4 = u_stgh[0]*u_stgh_4[0] + u_stgh[1]*u_stgh_4[1] + u_stgh[2]*u_stgh_4[2] + u_stgh
[3]*u_stgh_4[3]
[3]*u_stgh_3[3]
[3]*u_stgh_2[3]
t_stgh_1 = u_dot_u
t_stgh_3 = 2.*(u_dot_u2 + u1_dot_u1)
t_stgh_5 = 2.*(u_dot_u4 + 4*(u1_dot_u3) + 3*(u2_dot_u2))
delta_t = t_stgh_1 * d_tau + t_stgh_3*(d_tau**3.)/24. + t_stgh_5*(d_tau**5.)/1920.
#print t_stgh_1,u_stgh[k],ue[k] , (d_tau/2.)*ue_1[k] , ((d_tau**2)/8.)*ue_2[k] ,
((d_tau**3)/48.)*ue_3[k] , ((d_tau**4)/384.)*ue_4[k] , ((d_tau**5)/3840.)*ue_5[k]#+ t_stgh_3*
(d_tau**3.)/24. + t_stgh_5*(d_tau**5.)/1920.
return delta_t

Simulasi 2-Benda Menggunakan Metode Regularisasi KS

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Simulasi 2-Benda Menggunakan Metode Regularisasi KS

Diunggah oleh

Hak Cipta:

Format Tersedia

SIMULASI 2-BENDA MENGGUNAKAN METODE

MUHAMMAD ISNAENDA IKHSAN

FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM

INSTITUT TEKNOLOGI BANDUNG

SIMULASI 2-BENDA MENGGUNAKAN METODE

MUHAMMAD ISNAENDA IKHSAN

Program Studi Sarjana Astronomi

Dr. rer. nat. Mochamad Ikbal Arifyanto

Pedoman Penggunaan Tugas Akhir

Staf Program Studi Astronomi. Bu Ina yang selalu semangat menjaga

Muhammad Isnaenda Ikhsan

Satuan, Notasi, dan Konvensi . . . . . . . . . . . . . . . . . . .

II.1 Metode Simulasi N-benda . . . . . . . . . . . . . . . . . . . . .

II.2 Metode Integrasi (Hermite Scheme) . . . . . . . . . . . . . . . .

III.4 Hubungan KS Timestep dan

IV Hasil dan Analisis

A Kode Program N-benda

B Kode Program Fungsi Parameter Bintang Ganda

C Kode Program Fungsi Nilai Awal

D Kode Program Integrasi KS Hermite

E Kode Program Fungsi Timestep untuk Integrasi KS Hermite

Skema pembentukan struktur pohon untuk N-benda. . . . . . .

Diagram alir integrasi Hermite . . . . . . . . . . . . . . . . . . 10

III.1 Diagram alir integrasi menggunakan integrasi KS Hermite . . . 22

Tujuan penelitian ini dapat dinyatakan dalam poin-poin sebagai berikut:

1. Membuat simulasi 2-Benda dengan menggunakan metode Regularisasi

Satuan, Notasi, dan Konvensi

Beberapa aturan yang digunakan dalam penulisan Tugas Akhir ini:

I.5. Sistematika Penulisan

Metode Simulasi N-benda

Terdapat berbagai macam metode yang dapat digunakan untuk memodelkan

Metode ini menggunakan persamaan

gerak gravitasi Newton untuk menghitung efek yang dialami anggota

II.1. Metode Simulasi N-benda

samaan gerak partikel i pada sistem yang berjumlah N partikel

Dengan r, G, m, dan r berturut-turut merupakan percepatan, Konstanta

Gambar. II.1: Skema pembentukan struktur pohon untuk N-benda.

II.2. Metode Integrasi (Hermite Scheme)

Metode Integrasi (Hermite Scheme)

Metode integrasi dibutuhkan untuk mencari solusi numerik dari persamaan

II.2. Metode Integrasi (Hermite Scheme)

dengan v dan a merupakan kecepatan dan percepatan dan subskrip b

II.2. Metode Integrasi (Hermite Scheme)

1. Prediksi posisi dan kecepatan menggunakan persamaan berikut,

dengan j merupakan jerk . Jerk merupakan turunan pertama terhadap

dengan r dan v di sini merupakan posisi dan kecepatan relatif bintang

dengan rb merupakan turunan ke i yang dihitung menggunakan,

4. Ulangi langkah 2-3 hingga nilai re dan ve konvergen.

II.2. Metode Integrasi (Hermite Scheme)

dengan menunjukan variabel ruang-fase, yaitu = (r, v).

Sekarang ditinjau sebuah skema time-symmetric dengan stepsize yang tidak

II.4. Metode Regularisasi

Transformasi Levi-Civita merupakan sebuah transformasi koordinat yang digunakan un-

II.4. Metode Regularisasi

dengan x dan x merupakan kecepatan dan percepatan, dan juga K = G(m1 +

saat terjadinya tumbukan, yaitu saat x = 0. Ubah koordinat kartesian menjadi

Sehingga persamaan gerak dalam koordinat yang baru menjadi,

sedangkan energinya menjadi,

untuk persamaan di atas, saat terjadi tumbukan u = 0, singularitas masih

II.4. Metode Regularisasi

Sehingga persamaan gerak dan energinya menjadi,

Ubah bentuk persamaan gerak menjadi,

sehingga dengan menggunakan persamaan energi h, persamaan gerak dapat

Persamaan gerak dalam koordinat baru tersebut telah menjadi persamaan