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

pustakaan Institut Teknologi Bandung, dan terbuka untuk umum dengan ke-

tentuan bahwa hak cipta ada pada penulis dengan mengikuti aturan HaKI

yang berlaku di Institut Teknologi Bandung. Referensi kepustakaan diperke-

nankan dicatat, tetapi pengutipan atau peringkasan hanya dapat dilakukan

seizin pengarang dan harus disertai dengan kebiasaan ilmiah untuk menye-

butkan sumbernya.

Memperbanyak atau menerbitkan sebagian atau seluruh Tugas Akhir harus

atas izin Program Studi Sarjana Astronomi, Institut Teknologi Bandung.

i

Prakata

Bismillaahirrahmaanirrahiim

Alhamdulillaah, segala puji penulis panjatkan ke hadirat Allah SWT, Tu-

han semesta alam, yang berkat izin-Nya penulis dapat menyelesaikan Tu-

gas Akhir ini. Shalawat serta salam tidak lupa senantiasa terucap kepada

junjungan Rasulullah Muhammad SAW, yang diharapkan pertolongan dan

syafa’atnya 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 mem-

bantu 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 memberi-

kan banyak bantuan, baik yang langsung maupun tidak langsung.

• Dosen-dosen di Program Studi Astronomi, terima kasih atas bimbin-

gannya 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 mene-

mani dan mendengarkan keluh kesah penulis selama mengerjakan tugas

akhir ini.

• Segenap elemen di Observatorium Bosscha yang selalu setia dalam mengek-

splorasi keindahan langit di Indonesia.

• Teman-teman Astronomi 2011, yang telah berjuang bersama penulis se-

menjak 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 membang-

gakan 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 diper-

lukan agar Tugas Akhir ini dapat lebih bermanfaat ke depannya. Semoga

Astronomi Indonesia menjadi lebih baik, hingga mampu menunjukkan kon-

tribusinya 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 regu-

larisasi Kustaanheimo-Stiefel (KS) yang secara khusus memecahkan masalah

papasan dekat antar 2-benda. Ide dari metode regularisasi ini adalah trans-

formasi 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 dimin-

imalkan. 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 de-

ngan 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 regu-

larisasi 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 hap-

pen between binary star. To get a good result we use a regularization method,

Kustaanheimo-Stiefel Regularization, which is specifically solving problem ab-

out close encounter problem between two-body. The idea of this regularization

method is transforming the coordinates and using varying timestep. The bi-

nary 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, two-

body simulation.

v

Daftar Isi

Pedoman Penggunaan Tugas Akhir i

Prakata ii

Abstrak iv

Abstract v

Daftar Isi vii

Daftar Tabel viii

Daftar Gambar ix

I Pendahuluan 1

I.1 Latar Belakang . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

I.2 Tujuan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

I.3 Metodologi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

I.4 Satuan, Notasi, dan Konvensi . . . . . . . . . . . . . . . . . . . 3

I.5 Sistematika Penulisan . . . . . . . . . . . . . . . . . . . . . . . . 3

II Masalah N-benda 5

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

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

II.3 Time-symmetrization . . . . . . . . . . . . . . . . . . . . . . . . 11

II.4 Metode Regularisasi . . . . . . . . . . . . . . . . . . . . . . . . 12

IIIRegularisasi Kustaanheimo-

Stiefel 15

III.1 Transformasi KS . . . . . . . . . . . . . . . . . . . . . . . . . . 15

III.2 KS Hermite Scheme . . . . . . . . . . . . . . . . . . . . . . . . 17

III.3 KS Timestep . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

III.4 Hubungan KS Timestep dan

Physical Timestep . . . . . . . . . . . . . . . . . . . . . . . . . . 19

III.5 Integrasi KS Hermite Scheme . . . . . . . . . . . . . . . . . . . 20

vi

IVHasil 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. . . . . . . 6

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

jadi 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 an-

tar 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 re-

laksasi 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 2

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

nakan. 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. Seba-

liknya, 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 mengi-

jinkan program kita untuk menggunakan timestep yang adaptif. Salah satunya

yaitu dengan regularisasi. Secara sederhana apabila kita menggunakan regu-

larisasi 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 se-

buah 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 3

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

tang ganda dengan adanya gangguan bintang ke-3.

I.3 Metodologi

Tugas Akhir ini disusun berdasarkan studi literatur dan juga simulasi. Simu-

lasi 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 lain-

lain 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 Kustaanheimo-

Stiefel, 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 menge-

nai masalah N-benda, simulasi N-benda, regularisasi secara umum, dan bin-

tang 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 4

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

cara 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 bin-

tang 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 menge-

nai 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(N2) 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-

5

II.1. Metode Simulasi N-benda 6

samaan gerak partikel i pada sistem yang berjumlah N partikel

ri = −GN∑

i=1;j 6=i

mj(ri − rj)

|ri − rj|3. (II.1)

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

Gravitasi, posisi dan massa. Ruas kiri dari persamaan diatas dapat di-

anggap sebagai gaya per satuan massa, Fi. Jika nilai massa, m, posisi, r,

dan kecepatan awal,r untuk tiap partikel diketahui maka dengan meng-

gunakan persamaan di atas dapat didapatkan solusi posisi dan kecepatan

tiap partikel setiap waktu t. Namun untuk metode ini, kita harus mem-

perhatikan 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 mengaki-

batkan eror dalam perhitungan. Untuk itu perlu dilakukan perlakuan

khusus terhadap partikel-partikel yang mengalami papasan dekat terse-

but 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 efek-

tif daripada metode langsung. Metode ini akan melakukan perhitungan

sebanyak O(NlogN) perhitungan per timestep (Barnes Hut 1986). Al-

goritma 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) 7

Dengan pola pohon seperti di atas, saat dilakukan perhitungan gaya gra-

vitasi, efek gravitasi dari sekelompok anggota yang berada pada jarak

yang jauh dapat didekati dengan menganggapnya sebagai efek gravi-

tasi dari satu anggota saja namun dengan massa lebih besar. Perhitun-

gan dengan menggunakan metode ini memang lebih efisien dan cepat

karena terdapat banyak pendekatan yang dilakukan, namun kekurang-

annya adalah metode ini tidak dapat digunakan untuk melihat interaksi

jarak dekat antar anggota sistem. Sehingga apabila kami ingin meli-

hat 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. Kemu-

dian, dari potensial tersebut akan dihitung medan gravitasi yang ditim-

bulkan. 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 kekurang-

annya 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 da-

pat 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 + vbdt (II.2)

ve = vb + abdt (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 per-

tama 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 = ri−1 + v1−1/2dt, (II.4)

v1+1/2 = v1−1/2 + aidt, (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 tii− 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,

rpred = rb + vb∆t+1

2ab∆t

2 +1

6j + b∆t3, (II.6)

vpred = vb + ab∆t+1

2jb∆t

2, (II.7)

dengan j merupakan ”jerk”. Jerk merupakan turunan pertama terhadap

waktu dari percepatan. Percepatan dan jerk tiap benda dapat dihitung

menggunakan,

a = Gm

r3r, (II.8)

j = Gm[v

r3− 3

(r.v)r

r5], (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,

re = rpred +1

24r(4)b ∆t4 +

1

120r(5)b ∆t5, (II.10)

ve = vpred +1

6r(4)b ∆t3 +

1

24r(5)b ∆t4, (II.11)

dengan r(i)b merupakan turunan ke i yang dihitung menggunakan,

r(4)b =

1

∆t2[−6(ab − ae)−∆t(4jb + 2je)], (II.12)

r(5)b =

1

∆t3[−12(ab − ae) + ∆t(jb + je)]. (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.


Gambar. II.2: Diagram alir ini adalah gambaran umum integrasi Hermite

bekerja pada tiap stepnya.

II.3. Time-symmetrization 11

II.3 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 in-

tegrasi 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,

δ(ξb, ξe) =1

2[s(ξb) + s(ξe)], (II.20)

II.4. Metode Regularisasi 12

atau

δ(ξb, ξe) =

√1

2[s(ξb)2 + s(ξe)2], (II.21)

dengan s(ξb) dan s(ξe) merupakan suatu fungsi yang digunakan untuk menghi-

tung 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 terse-

but.

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

sasi, 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 per-

samaan 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 berinter-

aksi sesuai dengan hukum Newton. Asumsikan bahwa kedua benda bergerak

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

tuk memecahkan kasus regularisasi dua benda yang kerangka acuannya berada pada bidang

planar


dengan lintasan garis lurus, dengan P2 sebagai pusat dari kerangka acuan yang

digunakan. Maka persamaan gerak P1 akibat dari P2 adalah,

x+K

x2= 0, (II.22)

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

m2). Maka energi ikat kedua benda tersebut adalah,

h =K

x− 1

2x2. (II.23)

Oleh karena itu maka kecepatan x = ±√

2(Kx− h) akan menjadi tak terhingga

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,

u+1

uu2 +

K

2u5= 0, (II.25)

sedangkan energinya menjadi,

h =K

u2− 2uu2. (II.26)

Persamaan kecepatannya menjadi,

u = ±√

K

2u4− h

2u2, (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 digu-

nakanlah fictitious time s yang didefinisikan sebagai,

dt = xds = u2ds ataudt

ds= x = u2. (II.28)

Dengan mendefinisikan u′ ≡ duds

,maka

u =du

dt=du

ds

ds

dt=

1

u2u′, (II.29)

u =1

u2d

ds(

1

u2u′) =

1

u4u′′ − 2

u5u′2. (II.30)


Sehingga persamaan gerak dan energinya menjadi,

u′′ − 1

uu′2 +

K

2u= 0, h =

K

u2− 2u′2

u2. (II.31)

Ubah bentuk persamaan gerak menjadi,

u′′ +1

2(K

u2− 2u′2

u2)u = 0, (II.32)

sehingga dengan menggunakan persamaan energi h, persamaan gerak dapat

diubah menjadi,

u′′ +h

2u = 0. (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 Kustaanheimo-

Stiefel

Regularisasi Kustaanheimo-Stiefel (KS) merupakan salah satu metode regula-

risasi 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 Reg-

ularization (Funato et al. 1996).

III.1 Transformasi KS

Untuk mengubah koordinat Cartesian ke koordinat baru maka dibutuhkan

sebuah matriks yaitu,

A(u) =

u1 −u2 −u3 u4

u2 u1 −u4 −u3u3 u4 u1 u2

u4 −u3 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

r1

r2

r3

0

= A(u)

u1

u2

u3

u4

=

u1 −u2 −u3 u4

u2 u1 −u4 −u3u3 u4 u1 u2

u4 −u3 u2 −u1

u1

u2

u3

u4

(III.2)

Sehingga komponen r dapat dituliskan sebagai,

r1 = u21 − u22 − u23 + u24,

r2 = 2(u1u2 − u3u4),

r3 = 2(u1u3 + u2u4),

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

lanjutnya harus dicari suatu cara untuk mengubah koordinat KS menjadi ko-

ordinat 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 digu-

nakan 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,

u21 + u24 =1

2(r1 + r). (III.5)

III.2. KS Hermite Scheme 17

Dengan memilih nilai u4 = 0 maka akan didapatkan hubungan,

u1 = [1

2(r1 + r)]1/2,

u2 =1

2

r2u1,

u3 =1

2

r3u1. (III.6)

Jika r1 < 0 maka dengan mengurangkan persamaan pertama dari III.3 dan

persamaan III.4 akan didapatkan,

u22 + u23 =1

2(r − r1). (III.7)

Dengan memilih nilai u3 = 0 maka akan didapatkan hubungan,

u2 = [1

2(r − r1)]1/2,

u1 =1

2

r2u2,

u4 =1

2

r3u2. (III.8)

III.2 KS Hermite Scheme

Sebelum menggunakan KS Hermite Scheme perlu didefinisikan gerak dari

pusat masa dari dua benda yang interaksinya dihitung menggunakan regu-

larisasi. 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,

rcm =m1r1 +m2r2m1 +m2

, (III.9)

vcm =m1v1 +m2v2

m1 +m2

, (III.10)

dan gerak relatif,

r = r2 − r1 (III.11)

dr

dt= v = v2 − v1. (III.12)

III.2. KS Hermite Scheme 18

Sedangkan percepatan diungkapkan sebagai,

dv

dt= −(m1 +m2)r

|r|3+ P, (III.13)

dvcm

dt= − F1 + F2

m1 +m2

, (III.14)

dengan P pada persamaan III.14 adalah perturbasi,

P =F2

m2

− F1

m1

. (III.15)

Berikut adalah persamaan integrasi Hermite yang sudah diubah kedalam

koordinat KS,

ue = ub +1

2(u(1)

e + u(1)b )∆τ − 1

10(u(2)

e − u(2)b )∆τ 2

+1

120(u(3)

e + u(3)b )∆τ 3, (III.16)

u(1)e = u

(1)b +

1

2(u(2)

e + u(2)b )∆τ − 1

12(u(3)

e − u(3)b )∆τ 2, (III.17)

he = hb +1

2(h

(1)0 + h

(1)1 )∆τ − 1

12(h

(2)1 − h

(2)0 )∆τ 2, (III.18)

dengan ui merupakan turunan ke i dari u terhadap variabel τ . Contoh,

d2u

dτ 2= u(2). (III.19)

Turunan kedua dan ketiga dihitung menggunakan (Aarseth 1985),

u(2)b =

1

2hbub +

1

2rbA

Tb (ub)Pb, (III.20)

u(3)b =

1

2hbu

(1)b +

1

2h(1)b ub +

1

2

d

dτ[rbA

Tb (ub)Pb]

=1

2hbu

(1)b +

1

2h(1)b ub +

1

2

d

dτ[rbA

Tb (ub)]Pb

+1

2rbA

Tb (ub)rbJp,b, (III.21)

h(1) = −2u(1).AT (u)P, (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 me-

rupakan transpose dari matriks A.

III.3. KS Timestep 19

III.3 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) =

√η|u(4)||u(2)|+ |u(3)|2|u(5)||u(3)|+ |u(4)|2

, (III.24)

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(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. In-

tegrasi 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 wak-

tunya 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 menghi-

tung ∆t sebagai fungsi dari ∆τ dan u,

t1 = t0 + ∆t, (III.27)

∆t = T (∆τ) = t(1)12

∆τ + t(3)12

∆τ 3

24+ t

(5)12

∆τ 5

1920. (III.28)

Dengan t(1)12

merupakan turunan ke-i ketika τ = τ0 + 0.5∆τ pada waktu KS

yang dihitung menggunakan,

t(1)12

= r = u.u, (III.29)

t(3)12

= 2(u.u(2) + u(1).u(1)), (III.30)

t(5)12

= 2[u.u(4) + 4(u(1).u(3)) + 3(u(2).u(2))], (III.31)

dengan,

u 12

= u0 +∆τ

2u(1)0 +

∆τ 2

8u(2)0 +

∆τ 3

48u(3)0 +

∆τ 4

384u(4)0 ]

+∆τ 5

3840u(5)0 , (III.32)

u(1)12

= u(1)0 +

∆τ 2

2u(2)0 +

∆τ 3

8u(3)0 +

∆τ 4

48u(4)0 +

∆τ 5

384u(5)0 , (III.33)

u(2)12

= u(2)0 +

∆τ 3

2u(3)0 +

∆τ 4

8u(4)0 +

∆τ 5

48u(5)0 , (III.34)

u(3)12

= u(3)0 +

∆τ 4

2u(4)0 +

∆τ 5

8u(5)0 , (III.35)

u(4)12

= u(4)0 +

∆τ 5

2u(5)0 . (III.36)

III.5 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 perhi-

tungan setiap step dari integrasi time-symmetrized KS Hermite scheme.


1. Prediksi posisi dan kecepatan partikel untuk semua benda, untuk kom-

ponen bintang ganda posisi, kecepatan, dan energi ikat harus diprediksi

dalam koordinat KS. Untuk prediksi komponen bintang ganda dapat

menggunakan formula (Por 2014):

upred = ub + u(1)b ∆τ +

1

2u(2)b ∆τ 2 +

1

6u(3)b ∆τ 3, (III.37)

u(1)pred = u

(1)b + u

(2)b ∆τ +

1

2u(3)b ∆τ 2, (III.38)

hpred = hb + h(1)b ∆τ +

1

2h(2)b ∆τ 2. (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 menggu-

nakan formula:

u(4)b = − 1

∆τ 2b[6(u

(2)b − u(2)

e ) + 2∆τb(2u(3)b + u(3)

e )], (III.40)

u(5)b =

1

∆τ 3b[12(u

(2)b − u(2)

e ) + 6∆τb(u(3)b + u(3)

e )], (III.41)

u(4)e = u

(3)b + ∆τbu

(4)b , (III.42)

u(5)e = u

(4)b . (III.43)

4. Hitung besarnya nilai KS timestep ∆τ dan physical timestep ∆t.

∆τnew =1

2[s(ub) + s(ue)], (III.44)

∆t = T (∆τnew). (III.45)

Perhitungan ∆τnew di atas merupakan aplikasi dari skema KS time-

symmetric.

5. Koreksi nilai u dan u(1) menggunakan ∆τnew,

ue = ub + u(1)b ∆τnew +

1

2u(2)b ∆τ 2new +

1

6u(3)b ∆τ 3new +

1

24u(4)b ∆τ 4new +

1

120u(5)b ∆τ 5new, (III.46)

u(1)e = u

(1)b + u

(2)b ∆τnew +

1

2u(3)b ∆τ 2new +

1

6u(4)b ∆τ 3new

+1

24u(5)b ∆τ 4new. (III.47)


6. Ulangi langkah 2-5 hingga nilai ∆τ , u, dan u(1) konvergen.

Berikut merupakan diagram alir yang menggambarkan proses secara keselu-

ruhan 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φ)

[R2 + r2 − 2Rr cos phi− psi] 32, (IV.6)

a2 = m3(R cosψ + r cosφ), (R sinψ + r sinφ)

[R2 + r2 + 2Rr cosφ− ψ]32

. (IV.7)

Besar nilai r, r, dan φ dihitung menggunakan,

r1 = r2 = r =a(1− e2)

2(1 + e cosφ), (IV.8)

r1 = r2 = r =Ae sinφ

2a(1− e2), (IV.9)

φ =A

4r2=A(1 + e cos phi)2

a2(1− e2), (IV.10)

dengan a, e, dan A merupakan setengah sumbu panjang, eksentrisitas, dan

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

m1 m2 a h e

Bintang ganda 0.5 0.5 1.0 −0.5 0.9

Benda ke-3 0.01 10.1 −0.05 0.0

Kemudian untuk kebutuhan analisis kami perlu menghitung nilai parame-

ter 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 per-

samaan,

E = −1

2

Gm1m2

a. (IV.11)

Apabila µ didefinisikan sebagi massa tereduksi yaitu,

µ =m1m2

m1 +m2

, (IV.12)

maka dapat dituliskan E sebagai energi per massa tereduksi,

E ≡ E

µ= −1

2

G(m1 +m2)

aatau E = −1

2

K

a, (IV.13)

dan momentum sudut per massa tereduksi diungkapkan sesuai dengan per-

samaan,

A2 = Ka(1− e2). (IV.14)

Dengan menggunakan persamaan energi total maka dapat diungkapkan a se-

bagai,

a = − K

2E, (IV.15)

dan dengan menggunakan persamaan momentum sudut maka dapat diungkap-

kan,

e2 = 1− A2

Ka. (IV.16)

Kemudian untuk menghitung nilai error, kami menggunakan formula berikut

untuk masing-masing parameter,

∆E/E =Ei − Ei−1

Ei

, (IV.17)

∆A = Ai − Ai−1, (IV.18)

∆e = ei − ei−1. (IV.19)

IV.2. Hasil Simulasi 2-Benda 26

IV.2 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 ke-

3. 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 10−14 − 10−15. 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 mem-

buat 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 memi-

liki pola yang serupa yang menunjukan bahwa dt dan jarak separasi bintang

ganda saling berkaitan.


(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 Hasil Simulasi 3-Benda

Setelah kami menguji program simulasi menggunakan bintang ganda, maka

pada sub-bab ini kami kemudian akan mengujii program kami dengan menam-

bahkan 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 ter-

dapat 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 bi-

asa. 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 meng-

gunakan plot ini kami ingin mengamati perubahan parameter-parameter orbit

bintang ganda, baik yang dipengaruhi benda ke-3 maupun perubahan akibat

dari kesalahan numerik.


(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, me-

nunjukan 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 di-

tambah benda ke-3.

Untuk kasus bintang ganda saja dapat ditinjau Gambar IV.2 dan Gam-

bar 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 10−15 − 10−14.

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

rameter orbit, dapat ditinjau Gambar IV.5 yang menunjukan plot error ketiga

parameter orbit namun dengan jumlah periode yang lebih sedikit. Dapat dili-

hat 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 er-

ror momentum sudut, saat error eksentrisitas membesar, justru nilai error mo-

mentum sudut terlihat mengecil atau stabil, hal ini mungkin disebabkan oleh

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

per, gerak benda ke-3 seharusnya memiliki orbit lingkaran mengelilingi pusat

massa bintang ganda, namun saat dicoba pada simulasi, benda ke-3 tidak ber-

gerak dengan lintasan lingkaran sempurna melainkan sedikit berosilasi. Selain

itu karena penulis hanya mengacu pada algoritma yang ada pada paper terse-

but 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 di-

pakai mungkin juga mempengaruhi hasil yang diberikan.

Gambar. IV.6: Plot ini merupakan plot error momentum sudut (a) dan eksen-

trisitas (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 34

V.2 Saran

Pekerjaan lebih lanjut yang dapat dilakukan adalah membuat simulasi N-

benda dengan metode regularisasi yang dapat memecahkan kasus sistem 3

benda atau lebih. Karena dengan mempelajari mengenai interaksi yang ter-

jadi pada sistem 3 benda, akan didapatkan berbagai macam informasi menge-

nai evolusi secara dinamika sistem tersebut. Misalkan contoh kasus 3-benda,

ada pasangan bintang ganda kemudian ada bintang ke-3. Saat bintang ke-

3 bergerak mendekati bintang ganda, ada beberapa kemungkinan yang ter-

jadi, misalkan bintang ke-3 mengganggu sistem hingga akhirnya bintang ganda

akan saling lepas dari sistem, atau salah satu bintang ganda akan lepas kemu-

dian salah satunya akan berinteraksi dengan bintang ke-3 membentuk bintang

ganda baru, atau bisa juga ketiganya membentuk sistem triple-star yang sta-

bil. 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 pen-

ting 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 pen-

ting 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 N-

benda 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 in-

teraksi 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(NlogN) Force-calculation Al-

gorithm. 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 Clus-

ters. PASP, 104: 981.

Hut, P.,& Makino, J. 2003-4. Moving Stars Around

[manuscript on The Art of Computational Science web

site].(www.artcompsci.org/kali/pub/msa/title.html)

Por, E. 2014. Post-Newtonian N-body Dynamics. Universiteit Leiden.

35

37

Appendix A

Kode Program N-benda

#Import modul yang akan dipakaiimport mathfrom matplotlib import pyplot as plimport numpy as npfrom numpy import arrayimport osfrom random import random, uniform, seedfrom mpl_toolkits.mplot3d import Axes3Dfrom finding_binary import *from ks_function import *from timeit import default_timerfrom init_function import *start = default_timer() #timer untuk running program rand=int(uniform(1,10000)) #generate bilangan randomseed(rand)#nilai konstantaT =6.2639 #periode bintang gandadt =0.02 #timestep awalt_end =200*T #batas akhir integrasin =3 #jumlah n-benda#konstantaG2 = 1 #inisiasi list dan array yang akan digunakandata_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 gandaax = 1.ax2= 10.1e = 0.9e2= 0.0phi = 20PHI = 45initial = init(ax,e,ax2,e2,phi,PHI) #fungsi yang berfungsi untuk men-generate #nilai awal bintang gandar = initial[0]v = initial[1]m = initial[2]#mencari a dan jk awalfor i in range (0,data_n,1): for k in range (0,3,1): a[i,k] = jk[i,k] = 0.for i in range (0,data_n,1): for j in range (i+1,data_n,1): rji = np.zeros(3) vji = np.zeros(3) for k in range (0,3,1): rji[k] = r[j,k] - r[i,k] vji[k] = v[j,k] - v[i,k]

38

r2 = 0. for k in range (0,3,1): r2 = r2 + (rji[k]**2) r3 = r2 * math.sqrt(r2) rv = 0. for k in range (0,3,1): rv = rv + (rji[k] * vji[k]) rv = rv/r2 for k in range (0,3,1): 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 awalekin = 0.epot = 0.for i in range (0,data_n,1): for j in range (i+1,data_n,1): rji = np.zeros(3) for k in range (0,3,1): rji[k] = r[j,k] - r[i,k] r2 = 0. for k in range (0,3,1): r2 = r2 + (rji[k]**2) epot = (epot - G2*m[i] * m[j] / math.sqrt(r2)) for k in range (0,3,1): ekin = (ekin + 0.5 * m[i] * v[i,k] *v[i,k])e_in = ekin + epot #energi total awalprint "inital total energy E_in",e_indt_out = 0.01t_out = dt_out#pemindahan direktori untuk penyimpanan output berupa gambarcurrent_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 = 0t=0.dat=1en=1loop=1while 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)) for k in range (0,3,1): 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 for i in range (0,data_n,1): for j in range (i+1,data_n,1): rji = np.zeros(3) for k in range (0,3,1): rji[k] = r[i,k] - 0 r_3_sq=0. for k in range (0,3,1): 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 for i in range (0,data_n,1): for k in range (0,3,1):

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 for i in range (0,data_n,1): for k in range (0,3,1): a[i,k] = jk[i,k] = 0.0 for i in range (0,data_n,1): for j in range (i+1,data_n,1): rji = np.zeros(3) vji = np.zeros(3) for k in range (0,3,1): rji[k] = r[j,k] - r[i,k] vji[k] = v[j,k] - v[i,k] r2 = 0. for k in range (0,3,1): r2 += (rji[k]*rji[k]) r3=r2*math.sqrt(r2) rv=0. for k in range (0,3,1): rv += rji[k]*vji[k] rv = rv/r2 for k in range (0,3,1): 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)) for i in range (0,data_n,1): for k in range (0,3,1): 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): for k in range (0,3,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 + 1print 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.xlabel("t/P",fontsize=20)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.xlabel("t/P",fontsize=20)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.xlabel("t/P",fontsize=20)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.xlabel("t/P",fontsize=20)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.xlabel("t/P",fontsize=20)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.0for i in range (0,data_n,1): for j in range (i+1,data_n,1): for k in range (0,3,1): rji[k] = r[j,k] - r[i,k] r2 = 0 for k in range (0,k,1): r2 += rji[k] * rji[k] epot -= G2*m[i]*m[j]/math.sqrt(r2) for k in range (0,3,1): ekin += 0.5 * m[i] * v[i,k] *v[i,k] e_out = ekin + epotprint ('Final total energi='),e_outprint ('absolut energy error : E-out - E_in='), e_out-e_inprint ('relative error'),(e_out - e_in) / e_in

duration= default_timer() - startprint "Waktu running = ",duration/60.,"menit"

44

Appendix B

Kode Program Fungsi Parameter

Bintang Ganda

def find_bin(m,r,v,data_n): import math from matplotlib import pyplot as pl import numpy as np from numpy import array import os from random import random, uniform, seed 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" for i in range (0,data_n,1): for k in range (0,3,1): m_snap[i]=m[i] r_snap[i,k]=r[i,k] v_snap[i,k]=v[i,k] #finding binary for i in range (0,data_n,1): for j in range (i+1,data_n,1): rji = np.zeros(3) for k in range (0,3,1): rji[k] = r_snap[j,k] - r_snap[i,k] r_2_sq=0. print rji for k in range (0,3,1): 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): for j in range (i+1,data_n,1): delr_sq=0. delv_sq=0. for k in range (0,ndim,1): delr[k] = r_snap[j,k]-r_snap[i,k] delv[k] = v_snap[j,k]-v_snap[i,k] delr_sq += delr[k] * delr[k] delv_sq += 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: r_cross_v_component = delr[0] * delv[1] - delr[1]*delv[0] Ltilde_sq = (r_cross_v_component)*(r_cross_v_component) r_cross_v_component = delr[1] * delv[2] - delr[2]*delv[1] Ltilde_sq += (r_cross_v_component)*(r_cross_v_component) r_cross_v_component = delr[2] * delv[0] - delr[0]*delv[2] 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

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

49

Appendix D

Kode Program Integrasi KS Her-

mite

def ks_reg(m,r,v,a,jk,r_cm,v_cm,a_cm,jk_cm,data_n,dt): 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 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)) ub_2 = np.zeros((4)) ub_3 = np.zeros((4)) ub_4 = np.zeros((4)) ub_5 = np.zeros((4)) ue = np.zeros((4)) ue_1 = np.zeros((4)) ue_2 = np.zeros((4)) ue_3 = np.zeros((4)) ue_4 = np.zeros((4)) ue_5 = np.zeros((4))

LPb = np.zeros((4)) LPb1= np.zeros((4)) LJb = np.zeros((4)) LPe = np.zeros((4)) LPe1= np.zeros((4)) LJe = 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 for i in range (0,data_n,1): for k in range (0,3,1): 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] #print old_a '''=====#konversi dari r ke u=====''' for i in range (0,data_n,1): for j in range (i+1,data_n,1): r_ksb = np.zeros(3) v_ksb = np.zeros(3) for k in range (0,3,1): 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] for k in range (0,4,1): 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] for k in range (0,4,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)) for k in range (0,3,1): 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): for j in range (i+1,data_n,1): Pb = Jb = np.zeros((3))

51

for k in range (0,3,1): 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 for k in range (0,4,1): 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 for k in range (0,4,1): 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) ub_2_total = math.sqrt(ub_2[0]**2 + ub_2[1]**2 + ub_2[2]**2 + ub_2[3]**2) ub_3_total = math.sqrt(ub_3[0]**2 + ub_3[1]**2 + ub_3[2]**2 + ub_3[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)) for k in range (0,4,1): 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] = ue[0] Ae[0,1] = -ue[1] Ae[0,2] = -ue[2] Ae[0,3] = ue[3] Ae[1,0] = ue[1] Ae[1,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" for k in range (0,3,1): 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 for k in range (0,4,1): 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])) for k in range (0,4,1): 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======''' for k in range (0,4,1): 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) ub_1_total = math.sqrt(ub_1[0]**2 + ub_1[1]**2 + ub_1[2]**2 + ub_1[3]**2) ub_2_total = math.sqrt(ub_2[0]**2 + ub_2[1]**2 + ub_2[2]**2 + ub_2[3]**2) ub_3_total = math.sqrt(ub_3[0]**2 + ub_3[1]**2 + ub_3[2]**2 + ub_3[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) ue_2_total = math.sqrt(ue_2[0]**2 + ue_2[1]**2 + ue_2[2]**2 + ue_2[3]**2) ue_3_total = math.sqrt(ue_3[0]**2 + ue_3[1]**2 + ue_3[2]**2 + ue_3[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

for k in range (0,4,1): 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)) for k in range (0,4,1): 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 for i in range (0,data_n,1): for k in range (0,3,1): 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) for i in range (0,data_n,1): for j in range (i+1,data_n,1): r_cm = np.zeros((3)) v_cm = np.zeros((3)) for k in range (0,3,1): 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

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 s1def 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)) u_stgh_2 = np.zeros((4)) u_stgh_3 = np.zeros((4)) u_stgh_4 = np.zeros((4)) u_stgh_5 = 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] u1_dot_u3 = u_stgh_1[0]*u_stgh_3[0] + u_stgh_1[1]*u_stgh_3[1] + u_stgh_1[2]*u_stgh_3[2] + u_stgh_1[3]*u_stgh_3[3] u2_dot_u2 = u_stgh_2[0]*u_stgh_2[0] + u_stgh_2[1]*u_stgh_2[1] + u_stgh_2[2]*u_stgh_2[2] + u_stgh_2[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

Documents

Transcript of Simulasi 2-Benda Menggunakan Metode Regularisasi KS