LAPORAN AKHIR

ASISTENSI GEOTOMOGRAFI

Disusun Oleh
Kelompok 5, Kelas B

1. Eka Harris Suryawan 03411540000005

2. Dinda Indiana Bounigeta 03411540000018
3. Gregorio Adri Prawira 03411540000020
4. Erdyanti Rinta Bi Tari 03411540000024
5. Sugeng Kurniawan 03411540000030
6. Silvia Veronica 03411540000046

DEPARTEMEN TEKNIK GEOFISIKA

FAKULTAS TEKNIK SIPIL, LINGKUNGAN, DAN KEBUMIAN
INSTITUT TEKNOLOGI SEPULUH NOPEMBER
SURABAYA
2018
 DAFTAR ISI
DAFTAR ISI.............................................................................................................................. 2
DAFTAR GAMBAR ................................................................................................................. 3
BAB I DASAR TEORI ............................................................................................................. 4
1.1 Back Projection Technique (BPT) ................................................................................... 4
1.2 Algebraic Reconstruction Technique (ART) ................................................................... 4
1.3 Simultaneous Iterative Reconstruction Technique (SIRT) .............................................. 5
1.4 Pseudo-invers Inversion................................................................................................... 7
1.5 Bi-Conjugate Gradient Method (Bi-CG) ......................................................................... 8
1.6 Least Square QR Factorization Method (LSQR) ............................................................ 9
BAB II METODOLOGI PENELITIAN ................................................................................. 11
2.1 Back Projection Technique (BPT) ................................................................................. 11
2.2 Algebraic Reconstruction Technique (ART) ................................................................. 12
2.3 Simultaneous Iterative Reconstruction Technique (SIRT) ............................................ 13
2.4 Pseudo-invers Inversion................................................................................................. 14
2.5 LSQR Inversion .............................................................................................................. 15
2.6 Bi-Conjugate Gradient (Bi-CG) Inversion .................................................................... 16
BAB III HASIL DAN PEMBAHASAN ................................................................................. 17
3.1 Model dan Raypath ........................................................................................................ 17
3.2 Back Projection Techniques (BPT) ............................................................................... 18
3.3 Algebraic Reconstruction Techniques (ART) ................................................................ 19
3.4 Simultaneous Iterative Reconstruction Techniques (SIRT) ........................................... 20
3.5 Inversi Least-Square ...................................................................................................... 21
3. 6 Inversi BiCG ................................................................................................................. 22
3.7 Pseudoinverse dengan Singular Value Decomposition (SVD) ..................................... 23
3.8 Memori yang digunakan ................................................................................................ 24
3.9 Rekapitulasi Semua Metode .......................................................................................... 25
BAB IV KESIMPULAN ......................................................................................................... 29
DAFTAR PUSTAKA .............................................................................................................. 30
LAMPIRAN ............................................................................................................................. 31

2
 DAFTAR GAMBAR
Gambar 2.1 Diagram alir fungsi BPT ...................................................................................... 11
Gambar 2.2 Diagram alir fungsi ART ..................................................................................... 12
Gambar 2.3 Diagram alir fungsi SIRT ..................................................................................... 13
Gambar 2.4 Diagram alir fungsi pseudo invers inversion ....................................................... 14
Gambar 2.5 Diagram alir fungsi LSQR inversion ................................................................... 15
Gambar 2.6 Diagram alir fungsi Bi-CG inversion ................................................................... 16
Gambar 3.1 Model sebenarnya ................................................................................................ 17
Gambar 3.2 Ray path ............................................................................................................... 17

3
 BAB I
DASAR TEORI
1.1 Back Projection Technique (BPT)
Back Projection Technique (BPT) yang disebut juga sebagai teknik proyeksi ke
belakang adalah metode paling sederhana dalam tomografi inversi linear. Metoda ini
menggunakan prinsip trigonometri yang dirancang untuk meniru proses akuisisi data dengan
cara terbalik (reverse). Dasar dari metode ini adalah menerapkan secara langsung slowness
rata-rata dari suatu sinar ke dalam slowness lokal yang dilaluinya. Misalnya sejumlah
gelombang seismik yang merambat dari sumber ke penerima dicatat sebagai N, selanjutnya
masing-masing gelombang direpresentasikan oleh gelombang-i (i= 1,2,…,N). Medum dibagi
atas M sel. Rata-rata slowness (Si) yang dilalui gelombang ini dapat dituliskan sebagai
(Monalia, 2011):
𝑇𝑜𝑖
𝑠̅𝑖 = (1.1)
𝐿𝑖
dengan:

𝐿𝑖 = ∑ 𝑙𝑖𝑗 (1.2)
𝑗=1

yang mana 𝑇𝑜𝑖 adalah waktu tempuh dari gelombang ke – i berdasarkan pengamatan, dan
𝐿𝑖 adalah total panjang lintasan gelombang ke – i dari titik sumber ke titik penerima. Jika 𝑙𝑖𝑗
adalah panjang lintasan gelombang– i di sel– j (j = 1,2,.…,M), maka slowness pada sel ke– j
(Sj) dapat ditulis sebagai:

∑𝑁 ̅
𝑖=1 𝑙𝑖𝑗 𝑆𝑖
𝑆𝑗 = 𝑁 (1.3)
∑𝑖=1 𝑙𝑖𝑗
Bedanya dengan rekonstruksi inversi matriks, algoritma pada rekonstruksi back
projection dapat ‘mengetahui’ sudut akuisisi serta posisi dari susunan detektor yang ebrkaitan
dengan masing-masing jejak gelombang. Metoda ini memungkinkan proses dilakukan dengan
cepat namun memiliki hasil yang kurang baik (Gideon, 2015)

1.2 Algebraic Reconstruction Technique (ART)

Metoda ini pertama kali diperkenalkan oleh Kaczmarz pada tahun 1937. Metoda ini
merupakan metoda inversi non-linier dengan cara memperbaharui data kelambatan tiap sel
dengan empat langkah utama. Langkah tersebut antara lain; pembuatan gambar awal,

4
perhitungan koreksi, pembaharuan nilai dan tes konvergensi. Proses ART disajikan dalam
langkah berikut ini (Oliveira dkk., 2011):

1. Pembuatan model sinar awal dengan “N” elemen terparameterisasi j, biasanya bernilai
0.
2. Perhitungan proyeksi P’(i) untuk semua gelombang berdasarkan persamaan:

∑𝑁 𝑖
𝑗=1 𝑓 (𝑗). 𝑤𝑖𝑗 = 𝑃′𝑖 i = 1,2,3…...M (1.4)

3. Dilakukan perhitungan untuk menentukan perbedaan nilai antara poyeksi original P(i)
dan P’(i)
4. Dilakukan penjumlahan bobot tiap gelombang

𝑊𝑖 = ∑𝑁 2
𝑗=1 𝑤𝑖𝑗 (1.5)

5. Perbaikan untuk tiap gelombang i

∆𝑃𝑖
𝛼𝑖 = (1.6)
𝑊𝑖

6. Pembaruan untuk setiap sel j sepanjang gelombang i

𝑓 ′ 𝑘 (𝑗) = 𝑓 ′ 𝑘−1 (𝑗) + 𝜆. 𝑤𝑖𝑗 . 𝛼𝑖 (1.7)

Yang mana λ adalah parameter relaksasi yang bernilai antara 0 dan 2

7. Pengulangan langkah 2 sampai 6 untuk setiap gelombang
8. Dilakukan sumasi untuk tiap pixel gambar

𝑓1𝑘 −𝑓1𝑘−1
Δ𝑓 = ∑𝑁
𝑗−1 (1.8)
𝑓1𝑘

9. Iterasi ke-k berakhir.

1.3 Simultaneous Iterative Reconstruction Technique (SIRT)
SIRT merupakan teknik rekonstruksi pengembangan dari ART yang membedakan ialah
perubahan slowness setiap perhitungan pada tiap jejak gelombamg tidak langsung diterapkan
pada masing-masing sel, akan tetapi di simpan terlebih dahulu. Apabila semua persamaan telah
selesai dihitung maka hasil slowness dirata-rata dengan cara menjumlahkan seluruh perubahan
slowness pada seriap sel kemudian dibagi sebanyak jumlah jejak gelombang yang dilewati pada
setiap sel/grid lalu setelah di plot untuk setiap grid.

5
 Teknik ini menghitung secara iterasi, yakni satu persamaan dianalisa dalam waktu
bersamaan, slowness residual lintasan ke-I pada iterasi ke-k dihitung dengan mengurangi waktu
rambat observasi (Toi) dengan waktu rambat perhitungan (Tci) sebagai berikut (Monalia,
2011):

(𝑘) (𝑘)
𝑇𝑐𝑖 = ∑𝑀
𝑗=1 𝐼ϋ 𝑆𝑗 (1.9)

Yang mana:

(𝑘)
𝑇𝑐𝑖 = waktu rambat perhitungan lintasan ke-I pada iterasi ke-k
(𝑘)
𝑆𝑗 = slowness sel ke-j pada iterasi ke-k
M = jumlah sel/grid
Maka waktu tempuh residual yang dilalui oleh lintasan gelombang ke-I pada iterasi ke-k

(𝑘)
∆𝑡ϋ = 𝑇𝑜𝑖 − 𝑇𝑐𝑖 (1.10)

Waktu rambat residual dalam setiap lintasam gelombang kemudian di distribusikan ke setiap
sel dengan persamaan:

(𝑘)
𝐼ϋ ∆𝑇𝑐𝑖
∆𝑡ϋ = (1.11)
𝐿𝑖

Yang mana:

∆𝑡ϋ = Waktu rambat residual lintasan ke-I yang terdistribusikan pada sel ke-j
𝐿𝑖 = Panjang total lintasan ke-i
Selanjutnya factor korelasi slowness tiap sel (∆𝑆𝑗) dihitung dari semua waktu rambat residual
dan dari Panjang lintasan setiap sel dengan persamaan:

∑𝑁
𝑖=1 ∆𝑡ϋ
∆𝑆𝑗 = ∑𝑁
(1.12)
𝑖=1 𝐼ϋ

Yang mana:
N = jumlah lintasan gelombang
Maka slowness sel-j setelah iterasi ke-k+1:

(𝑘)
𝑆𝑗𝑘+1 = 𝑆𝑗 + ∆𝑆𝑗 (1.13)

6
1.4 Pseudo-invers Inversion
Inversi ini merupakan salah satu teknik inversi non-linier dengan pendekatan linier,
yang mana prinsip inversi ini adalah melakukan proses singular value decomposition (SVD).
SVD adalah teknik mendekomposisi matriks yang berukuran apa saja dengan hasil berupa
singular value yang disimpan dalam sebuah matriks diagonal dalam urutan yang sesuai dengan
korespondensi singular vektornya. Dekomposisi nilai singular matruks riil Amxn adalah
faktorisasi 𝐴 = 𝑈 ∑ 𝑉 𝑇 dengan U matriks orthogonal m x m, V matriks orthogonal n x n dan
Σ matriks diagonal m x n bernilai rill tak negatif yang disebut nilai singular.

𝐴 = 𝑈𝑆𝑉 𝑇 (1.14)

Yang mana A adalah matriks ukuran m x n, U adalah singular vektor dari matriks A dan vektor
ini orthonormal, S merupakan diagonal vektor yang menyusun singular value dari
korespondensi singular vektornya dan VT adalah singular vektor dari matriks A yang juga
orthonormal (Sihombing dkk., 2018).
Langkah-langkah penentuan SVD dijelaskan sebagai berikut:
1. Definisikan matriks A (matriks dengan dimensi m x m)
2. Mencari eigen value A melalui persamaan karakteristik:
|𝐴 = 𝜆𝐼| = 0 (1.15)

3. Mencari eigen vektor A

4. Bentuk matriks A dengan cara:
√𝜆1 0 0
𝐴=[ 0 √𝜆2 0 ]
0 0 √𝜆3
5. Mencari matriks U dan matriks V
• Kolom matriks U dari eigen vector normalisasi AAT
• Kolom matriks V dari eigen vector normalisasi ATA
6. Maka diperoleh dekomposisi dari matriks A

𝐴 = 𝑈𝑆𝑉 𝑇 (1.16)

7. Dilakukan invers matriks A untuk memperoleh pseudo-invers

𝐴−1 = (𝑉 𝑇 )−1 𝑆 −1 𝑈 −1 (1.17)

𝐴−1 = 𝑉𝑆 −1 𝑈 𝑇 (1.18)

Berdasarkan hasil dari proses SVD maka dapat ditentukan model sesuai persamaan:

7
 𝑚 = 𝐴−1 𝑏 (1.19)

𝑚 = 𝑉𝑆 −1 𝑈 𝑇 𝑏 (1.20)

1.5 Bi-Conjugate Gradient Method (Bi-CG)

Latar belakang Bi-CG adalah bukan untuk mendefiniskan vektor residual tegak lurus
terhadap subruang L, hal ini dapat dipelajari lebih lanjut dan membuat dua subruang. Inilah
maksud dari istilah “Bi”. Alasan kenapa kita perlu lakukan ialah jika A tidak simetris, maka
transpose-nya bukan adjoint itu sendiri. Ini berarti A* ≠ A. A* didefinisikan sebagai transpose
konjugasi atau dikenal pula sebagai Hermitian Transpose. Transpose konjugat berarti bahwa
salah satu akan dilakukan transpose, dan menghitung kompleks konjugat dari setiap inputan.
Matriks didefinisikan sebagai adjoin sendiri jika transpose konjugasinya sama dengan dirinya.
Mari kita pertimbangkan bahwa kita memiliki subruang K yang didefinisikan sebagai:

𝐾𝑚 = 𝑠𝑝𝑎𝑛{𝑣, 𝐴𝑣, 𝐴2 𝑣, … , 𝐴𝑗 𝑣} (1.21)

Yang berbeda disini ialah pada Bi-Conjugate subruang L diproyeksikan tegak lurus terhadap
subruang K, subruang ini didefinisikan sebagai:

𝐿𝑚 = 𝑠𝑝𝑎𝑛{𝑤, 𝐴𝑇 𝑤, (𝐴𝑇 )2 𝑤, … , (𝐴𝑇 )𝑚−1 𝑤} (1.22)

Ini menghilangkan masalah yang terjadi pada konjugasi gradien, satu tidak dibutuhkan matriks
simetris, karena kita memproyeksikan ke transpose terkonjugasi. Pada metode Bi-CG
dikenalkan 2 vektor bintang r* & p*. Vektor bintang ini digunakan untuk membuat subruang
𝐿𝑚 ke dua dengan perhitungan sebagai berikut:

∗
𝑟𝑖∗ = 𝑟(𝑖−1) − 𝛼𝑖 𝐴𝑇 𝑝𝑖∗ (1.23)
∗ ∗
𝑝𝑖∗ = 𝑟(𝑖−1) − 𝛽𝑖 𝑝(𝑖−1) (1.24)

Algoritma Bi-CG melakukan iterasi hingga didapatkan nilai vektor dengan ketentuan sebagai
berikut

(𝑟𝑖∗ , 𝑟𝑗 ) = 0, 𝑖 ≠ 𝑗 (1.25)

(𝑝𝑖∗ , 𝐴𝑝𝑗 ) = 0, 𝑖 ≠ 𝑗 (1.26)

Tujuan umum dari metode Bi-CG adalah membuat tegak lurus vektor residual r,p kedalam
vektor r* & p*. Vektor r dan p pada subruang K, sedangkan r* & p* pada subruang L.
Kekurangan dari metode Bi-CG adalah nilai numerikal yang tidak stabil. Langkah metode Bi-
CG disajikan dalam uraian berikut ini (Yuvashankar Vinay dkk., 2016):

8
 1: Compute 𝑟0 ≔ 𝑏 − 𝐴𝑥0 . Choose 𝑟0∗ such that 𝑟0 , 𝑟0∗ ≠ 0
2: set, 𝑝0 = 𝑟0 , 𝑝0∗ = 𝑟0∗
3: For 𝑗 = 0,1, …, until convergence do
(𝑟𝑖∗ ,𝑟𝑗 )
4: 𝛼𝑗 ≔ 𝐴𝑝𝑗 ,𝑝𝑗∗

5: 𝑥𝑗+1 ≔ 𝑥𝑗 + 𝛼𝑗 𝑝𝑗

6: 𝑟𝑗+1 ≔ 𝑟𝑗 − 𝛼𝑗 𝐴𝑝𝑗
∗
7: 𝑟𝑗+1 ≔ 𝑟𝑗∗ − 𝛼𝑗 𝐴𝑇 𝑝𝑗∗
∗
(𝑟𝑗+1 ,𝑟𝑗+1 )
8: 𝛽𝑗 ≔ 𝑟𝑗 ,𝑟𝑗∗

9: 𝑝𝑗+1 ≔ 𝑟𝑗+1 + 𝛽𝑗 𝑝𝑗
∗ ∗
10: 𝑝𝑗+1 ≔ 𝑟𝑗+1 − 𝛽𝑗 𝑝𝑗∗ ; end for

1.6 Least Square QR Factorization Method (LSQR)

Metode Least Square QR adalah metode inversi dengan cara least square dengan
faktorisasi matriks A secara QR. Nilai yang didapatkan dari matriks A dan b dari proses
bidiagonalisasi akan digunakan untuk menyelesaikan permasalahan least-squares (𝑚𝑖𝑛 ||𝑏 −
𝐴𝑥 ||).

Nilai dari,

𝑥𝑘 = 𝑉𝑘 . 𝑦𝑘 (1.27)
𝑟𝑘 = 𝑏 − 𝐴𝑥𝑘 (1.28)
𝑡𝑘+1 = 𝛽1 𝑒1 − 𝐵𝑘 𝑦𝑘 (1.29)
Didefinisikan sebagai vektor yk. Persamaan tersebut sesuai dengan persamaan rk,

𝑟𝑘 = 𝑈𝑘+1 . 𝑡𝑘+1 (1.30)

Dimana nilai rk berpegang kepada akurasi dari kerja seluruh. Dikarenakan nilai ||rk||
diminimalkan dan Uk+1 secara teroritis merupakan orthonormal, maka disugestikan memilih yk
untuk meminimalkan ||tk+1||. Oleh karena itu permasalahan least-square adalah:

𝑚𝑖𝑛 ||𝛽1 𝑒1 − 𝐵𝑘 𝑦𝑘 || (1.31)

Persamaan di atas menjadi basis untuk LSQR. Secara komputasi, persamaan 2.24 lebih baik
𝑅
diselesaikan dengan faktorisasi QR standar Bk, yakni sama dengan faktorisasi 𝑄𝑘 𝐵𝑘 = [ 𝑘 ]
0
yang menghubungkan 2 bidiagonalisasi. Hal tersebut membentuk;

9
 (1.32)

Dimana Qk = Qk, Qk+1,…… Nilai Q2,3 Q1,2 adalah produk dari rotasi planar didesain untuk
mengeliminasi subdiagonal β2, β3,….. dari Bk. Vektor dari yk dan tk+1 dapat diketahui dari;

𝑅𝑘 𝑦𝑘 = 𝑓𝑘 (1.33)
0 (1.34)
𝑡𝑘+1 = 𝑄𝑘 𝑇 [ ̅ ]
𝑄𝑘+1
Namun, yk di persamaan 1.32 normalnya tidak mempunyai elemen yang sama dengan yk-1.
Sebagai gantinya dapat dicatat bahwa [Rk fk] adalah sama dengan [Rk-1 fk-1] dengan
ditambahkan baris dan kolom baru. Oleh karena itu, salah satu mengkombinasikan persamaan
1.26 dan 1.32 secara efisien dilakukan menurut dengan;

𝑥𝑘 = 𝑉𝑘 𝑅𝑘 −1 𝑓𝑘 = 𝐷𝑘 𝑓𝑘 (1.35)
Dimana kolom dari Dk= [d1 d2 d3….dk] dapat ditemukan dari sistem 𝑅𝑘𝑇 𝐷𝑘𝑇 = 𝑉𝑘𝑇 dengan
substitusi forward. Dengan d0 = x0 = 0, didapatkan

1 (1.36)
𝑑𝑘 = (𝑉 − 𝜃𝑘 𝑑𝑘−1 )
𝜌𝑘 𝑘
𝑥𝑘 = 𝑥𝑘−1 + 𝜃𝑘 𝑑𝑘 (1.37)
Dan hanya iterasi terbaru yang perlu disimpan.

10
 BAB II
METODOLOGI PENELITIAN
Pada bagian ini akan ditunjukkan diagram alir dari beberapa fungsi sebagai berikut:
2.1 Back Projection Technique (BPT)

Gambar 2.1 Diagram alir fungsi BPT

11
2.2 Algebraic Reconstruction Technique (ART)

Gambar 2.2 Diagram alir fungsi ART

12
2.3 Simultaneous Iterative Reconstruction Technique (SIRT)

Gambar 2.3 Diagram alir fungsi SIRT

13
2.4 Pseudo-invers Inversion

Gambar 2.4 Diagram alir fungsi pseudo invers inversion

14
2.5 LSQR Inversion

Gambar 2.5 Diagram alir fungsi LSQR inversion

15
2.6 Bi-Conjugate Gradient (Bi-CG) Inversion

Gambar 2.6 Diagram alir fungsi Bi-CG inversion

16
 BAB III
HASIL DAN PEMBAHASAN
3.1 Model dan Raypath

Gambar 3.1 Model sebenarnya

Gambar 3.2 Ray path

17
3.2 Back Projection Techniques (BPT)
Hasil Running

18
 Metode rekonstruksi BPT menggunakan konsep menghitung nilai slowness dari nilai
waktu yang dihasilkan dari proses Forward Modeling. Hasil rekonstruksi menggunakan
metode BPT tidak dapat menggambarkan kontras nilai slowness secara akurat. Pada nilai True
Model, terdapat nilai slowness 0.022 pada lapisan 1, sedangkan pada model hasil lapisan
tersebut tidak terlihat kontras warnanya, dan menunjukkan nilai slowness sebesar 0.015. Hal
ini dikarenakan metode BPT melakukan iterasi 1 kali saja dalam melakukan pencarian nilai
slowness, sehingga model slowness yang didapatkan kurang akurat. Nilai error yang
dihasilkan dari metode rekonstruksi ini yaitu sebesar 0.54958% dengan membutuhkan waktu
selama 0.0036809 sekon.

3.3 Algebraic Reconstruction Techniques (ART)

19
 Pada metode ART, model awal menggunakan hasil rekonstruksi dari metode BPT.
Kemudian dilakukan iterasi pada nilai waktu yang dihasilkan dari model slowness kemudian
dilakukan pengurangan antara time hasil model dan dari proses forward, kemudian dilakukan
update nilai slowness untuk tiap ray dengan menggunakan nilai slowness lama. Dari hasil
metode ini memiliki error yang lebih kecil dari metode BPT. Dari hasil running, memiliki
tingkat kesamaan yang tinggi. Hasil ART dapat menunjukkan batas lapisan melalui kontras
warna yang berkorelasi dengan nilai slowness dan dapat menggambarkan posisi fold secara
akurat. Untuk metode ART ini nilai error sebesar 0.014509% selama 1.0389 second. Error
tersebut didapat ketika mencapai iterasi ke 23 dengan nilai konvergensi (kesamaan model
dengan iterasi sebelumnya sebesar 9.8883x10-6.

3.4 Simultaneous Iterative Reconstruction Techniques (SIRT)

Hasil Running

20
 Metode rekosntruksi SIRT memiliki kesamaan dengan metode ART, hanya
perbedaannya penghitungan nilai slowness terbaru dihitung setelah perhitungan tersebut
diselesaikan. Kemudian dilakukan perhitungan t ulang untuk seluruh ray, lalu dihitung nilai
slowness ter-update tiap ray. Metode ini memberikan model rekonstruksi dengan baik. Dapat
menunjukkan batas-batas lipatan melalui nilai slowness, tetapi pada beberapa grid tidak
menunjukkan slowness yang seharusnya. Oleh karena itu, metode ini menghasilkan nilai RMS
yang lebih besar dari metode ART yaitu sebesar 0.12333% dan mencapai titik konvergensi
lebih lama dari ART yaitu selama 0.28092 second, hal ini dapat dilihat dari jumlah iterasi yang
dilakukan. Metode ini juga memerlukan waktu yang relatif lebih lama dari ART karena proses
iterasi dilakukan setelah nilai slowness awal untuk tiap ray didapatkan semua.

3.5 Inversi Least-Square

Hasil Running

21
 Proses inversi menggunakan metode LSQR menghasilkan model dengan nilai RMS
sebesar 0.1918% dengan lama processing 0.036791 seconds. Metode ini tidak dapat
menggambarkan model awal secara baik, hal ini terlihat dari masih acaknya nilai slowness yang
dihasilkan dari model rekonstruksi. Model hasil rekonstruksi tidak dapat menunjukkan batas
antar lapisan 1 dan 2. Hal ini dikarenakan metode ini tidak dilakukan proses iterasi. Perhitungan
hanya dilakukan 1 kali sehingga waktu yang dibutuhkan pun juga tidak terlalu lama dan error
yang dihasilkan juga masih relatif besar. Pada hasil rekonstruksi masih ditemukan nilai
slowness rendah pada lapisan 1 dimana seharusnya pada lapisan tersebut tidak ada nilai
slownesss rendah karena kecepatan yang masih relatif rendah terhadap lapisan 2.

3. 6 Inversi BiCG
Hasil Running

22
 Metode inversi Bi-CG menghasilkan nilai error sebesar 0.029511% dalam 0.076144
seconds. Metode ini melakukan iterasi 2 kali, sehingga menghasilkan model mendekati model
awal dengan nilai RMS error sebesar 0.029511% dalam 0.076144 second. Karena adanya
iterasi selama 2 kali tersebut sehingga membutuhkan waktu lebih lama dari LSQR. Tetapi
model yang dihasilkan juga memiliki kualitas yang lebih baik dari LSQR.

3.7 Pseudoinverse dengan Singular Value Decomposition (SVD)

Hasil Running

Metode PInv dilakukan ketika (𝐺 𝑇 𝐺) berupa matriks singular sehingga tidak dapat
dilakukan proses inversi. Metode ini dilakukan dengan memecah matriks yang akan di invers
menjadi 3 komponen yaitu matriks S, V, dan U. Matrik S berisi matriks yang berukuran sama
23
dengan matriks awal, dan berisi nilai Eigen Value. Sedangkan matriks U dan V, merupakan
matriks persegi. Metode Pinv memberikan hasil model yang sangat mirip dengan model awal.
Metode Pinv memiliki nilai RMS error yang sangat kecil yaitu 1,3223 × 10−14 % nilai ini
jauh berbeda dengan nilai error yang didapatkan dari metode inversi Bi-CG yang menghasilkan
model hamper sama dengan metode PInv. Sedangkan untuk lama waktu prosesing, metode
Pinv membutuhkan waktu 0,087477 sekon.

3.8 Memori yang digunakan

Pada hasil running script MATLAB dapat dilihat besaran memori yang digunakan
dengan menggunakan syntax “memory” yang akan menampilkan: Maximum possible array,
Memory available for all arrays, Memory used by MATLAB, Physical Memory (RAM). Untuk
menganilisis efisiensi suatu program atau script maka yang perlu diperhatikan adalah nilai
Memory used by MATLAB. Memory used by MATLAB menampilkan besaran memori yang
digunakan pada saat suatu operasi sedang berlangsung. Besar kecilnya memori bergantung
pada berbagai faktor seperti banyaknya data yang digunakan, parameter yang perlu dicari dan
dihitung, banyaknya tahapan dan iterasi yang dilakukan, serta output yang dihasilkan.

Pada script yang dibuat diperoleh nilai Memory used by MATLAB yang semakin
meningkat untuk setiap metode yang dilakukan, di asumsikan hal ini dapat terjadi karena dari
metode ART hingga INV_SVD memerlukan perhitungan dan iterasi yang banyak serta
kompleks sehingga beban workload yang dibutuhkan akan memakan memori pada RAM.
Sedangkan waktu yang dibutuhkan untuk menyelesaikan setiap metode bervariasi dan tidak
memiliki trend naik maupun turun, lamanya waktu yang diperlukan pada suatu metode
bergantung metode bergantung pada banyaknya operasi perhitungan yang dilakukan metode
tersebut. Nilai Memory used by MATLAB dan waktu yang dibutuhkan setiap metode apabi;a
dilakukan running script akan selalu berubah, namun pada Memory used by MATLAB selalu
memiliki trend yang meningkat.

Dapat disimpulkan bahwa Memory used by MATLAB tidak dapat menjadi acuan yang
baku untuk melihat apakah program/script tersebut efisien.

24
3.9 Rekapitulasi Semua Metode

25
26
27
28
 BAB IV
KESIMPULAN
Berdasarkan analisis yang telah dilakukan, dapat disimpulkan bahwa:
1. Untuk metode rekonstruksi, metode yang paling efisien adalah metode ART dengan
RMS error 0.014% yang diselesaikan dalam waktu 0.95 detik.
2. Untuk metode inversi, metod eyang paling efisien adalah metode pseudoinvers dengan
RMS error 1.3x10-14 yang diselesaikan dalam waktu 0.06 detik.
3. Penentuan efisiensi metode berdasarkan memori tidak dapat dilakukan, karena nilai
Memory used by MATLAB fluktuatif yang disebabkan memori pada RAM digunakan
secara bersamaan dengan OS (Operating System) sehingga memori yang dibutuhkan
untuk jalannya suatu metode tidak dapat dilihat secara langsung. Namun semakin
kompleks suatu program atau script maka resource memori (RAM) yang dibutuhkan
besar.

29
 DAFTAR PUSTAKA
Gideon, S. (2015), Pembelajaran Simulasi Pencitraan Ct Dengan Menggunakan Prinsip

Rekonstruksi Citra Dalam Software Matlab, Vol.8, hal. 10.

Monalia, P. (2011), Analisis Model Kecepatan Berdasarkan Tomografi Refleksi Waktu Tempuh

(Travel Time Tomography Reflection) Fakultas Matematika dan Ilmu Pengetahuan

Alamm Universitas Indonesia,

Oliveira, E.F., Melo, S.B., Dantas, C.C., Vasconcelos, D.A.A. dan Cadiz, F. (2011),

Comparison Among Tomographic Reconstruction Algorithms With A Limited Data,

hal. 14.

Sihombing, W.L., Ratih N. A. C. Putri Pratama, Yosua H. Lumban Gaol, Istiqomah, Sasti, A.F.

dan Haolia (2018), Singular Value Decomposition untuk Matriks 5x5,

http://doi.org/10.6084/m9.figshare.5946976.

Yuvashankar Vinay, Liu Ash dan Sayari Nejad Mojdeh (2016), Understanding the Bi

Conjugate Gradient Stabilized Method (Bi-CGSTAB),.

30
 LAMPIRAN
Main Script
%Geotomografi B - Kelompok 5
%Simultaneous Iterative Reconstruction Technique_Ver. 03

clc, clear all, close all

%==========================================================================
%--------------------- 1. Inisiasi Parameter Model-------------------------
%==========================================================================
start=tic;
%======================== 1.a. Slowness Model==============================
%-------Input Parameter Model---------
X=(imread('fold_fix.bmp'));
X2= imresize(X,[15 15]);
v=double(X2);

sz_model=size(v);

%-------Pembuatan matriks velocity model-----------

s = 1./v;
sz_model = size(s);
[baris_s kolom_s] = size(s);
n_sel = numel(v);

m = zeros(n_sel,1); %Matriks model (dari persamaan d = G*m)

for i = 1:n_sel
m(i) = s(i);
end
nomor_sel = reshape(1:n_sel,[baris_s kolom_s]);

figure, imagesc(s), colorbar, title('Model Sebenarnya (Slowness)')

figure, imagesc(s), title('Ray Path')
hold on
%==================== 1.b. Posisi Source dan Receiver =====================
disp('-------------------------------------------------------')
disp(' ... Defining Raypath ...')
n_ray=0;
%Ray Relatif Horizontal
for i=1:baris_s
for j=1:baris_s
n_ray=n_ray+1;
SxSyRxRy(n_ray,2)=i;
SxSyRxRy(n_ray,4)=j;
end
end
SxSyRxRy(:,1)=1;
SxSyRxRy(:,3)=max(kolom_s);
n_ray_hor=size(SxSyRxRy,1);

%Ray Relatif Vertikal

for i=1:kolom_s
for j=1:kolom_s
n_ray=n_ray+1;
SxSyRxRy(n_ray,1)=i;
SxSyRxRy(n_ray,3)=j;
end
end

31
SxSyRxRy(n_ray_hor:end,2)=1;
SxSyRxRy(n_ray_hor:end,4)=max(baris_s);
n_ray_hv = size(SxSyRxRy,1);

%Seleksi ray yang berupa titik

k=1;
while k<size(SxSyRxRy,1)
if sum(SxSyRxRy(k,:))==4*SxSyRxRy
SxSyRxRy(k,:)=[];
end
k=k+1;
end

n_ray = size(SxSyRxRy,1);
disp(['Total number of rays : ' num2str(n_ray)])

%==========================================================================
%--------------- 2. Forward Modelling : Travel Time Calculation -----------
%==========================================================================
disp('-------------------------------------------------------')
disp(' ... Forward Modelling ...')
tic_forward=tic;
G = zeros(1,n_sel);
bobot = zeros(sz_model);
for a=1:n_ray
% disp('============================================================')
% disp(['Ray ke-' num2str(a)])
sx = SxSyRxRy(a,1);
sy = SxSyRxRy(a,2);
rx = SxSyRxRy(a,3);
ry = SxSyRxRy(a,4);
[koord,line]=f_lnrnt_imagesc_1b(sz_model,sx,sy,rx,ry);
plot(line(1:2),line(3:4),'-b')
hold on
for b=1:size(koord,1)
G(a,koord(b,3))=koord(b,end);
bobot(koord(b,3))=bobot(koord(b,3))+1;
end
end
figure
imagesc(bobot); colorbar
[n_ray]=size(G,1);

%Menambah ray di pinggir

G(n_ray+1,nomor_sel(:,end))=1;
G(n_ray+1,nomor_sel(end,:))=1;

[n_ray]=size(G,1);
d = G*m;

toc_forward=toc(tic_forward);
disp(['Elapsed time : ' num2str(toc_forward) ' seconds'])

%==========================================================================
%----------------------- 3. Rekonstruksi Model ----------------------------
%==========================================================================
%%
[s_transform]=tomo_transform_1b_pcolor(s);
% close all
% [s_bpt,selisih_bpt,RMS_bpt]=tomo_bpt_2(s,sz_model,G,d);

32
%%
[s_bpt_mo,selisih_bpt_mo,RMS_bpt_mo]=tomo_bpt_monalia(s,sz_model,G,d);
%%
[s_art,selisih_art,RMS_art] = tomo_art7(s,sz_model,G,d,500,10^-5);
% close all, break
%%
[s_sirt,selisih_sirt,RMS_sirt] = tomo_sirt_4(s,sz_model,G,d,500,10^-5);
%%
figure
subplot(1,2,1), imagesc(s), colorbar, title('True Model')
subplot(1,2,2), imagesc(s_transform), colorbar, title('Model Hasil
Transformasi')
figure
subplot(1,2,1), imagesc(s), colorbar, title('True Model')
subplot(1,2,2), imagesc(s_bpt_mo), colorbar, title('Model Hasil BPT')
figure
subplot(1,2,1), imagesc(s), colorbar, title('True Model')
subplot(1,2,2), imagesc(s_art), colorbar, title('Model Hasil ART')
figure
subplot(1,2,1), imagesc(s), colorbar, title('True Model')
subplot(1,2,2), imagesc(s_sirt), colorbar, title('Model Hasil SIRT')

%==========================================================================
%----------------------------- 4. Inversi ---------------------------------
%==========================================================================
%Persamaan inversi linear adalah A.x=b
% A adalah [G'G+lambda*I].
% x adalah [m].
% b adalah [G'*d].
% lambda adalah faktor relaksasi, untuk membuat matriks A tidak singular,
% sehingga inversi bisa lebih stabil.

lambda = 0.1;
A = G'*G+lambda*eye(numel(m));
b = G'*d;

[s_bicg,flag_bicg]=inv_bicg(s,sz_model,A,b);
[s_lsqr,flag_lsqr]=inv_lsqr(s,sz_model,A,b);
[s_pinv]=inv_pinv(s,sz_model,G,d);
[s_svd]=inv_svd(s,sz_model,G,d);

figure
subplot(1,2,1), imagesc(s), colorbar, title('True Model')
subplot(1,2,2), imagesc(s_bicg), colorbar, title('Model Hasil bicg')
figure
subplot(1,2,1), imagesc(s), colorbar, title('True Model')
subplot(1,2,2), imagesc(s_lsqr), colorbar, title('Model Hasil lsqr')
figure
subplot(1,2,1), imagesc(s), colorbar, title('True Model')
subplot(1,2,2), imagesc(s_pinv), colorbar, title('Model Hasil pinv')
figure
subplot(1,2,1), imagesc(s), colorbar, title('True Model')
subplot(1,2,2), imagesc(s_svd), colorbar, title('Model Hasil svd')

%==========================================================================
stop=toc(start);
disp('-------------------------------------------------------')
disp(['Total elapsed time : ' num2str(stop) ' seconds'])

% close all

33
 Fungsi Garis
%WARNING : Posisi (Sx, Sy, Rx, Ry) harus merupakan bilangan cacah bulat !
%sz_model = ukuran model ([baris kolom])
%Sx = posisi source x (grid kolom berapa)
%Sy = posisi source y (grid baris berapa)
%Rx = posisi receiver x (grid kolom berapa)
%Ry = posisi receiver y (grid baris berapa)

%Hasil output adalah koord_yy

%-->> koord_yy = [x, y, index, y_b_garis, dy, ds]
function [koord,line]=f_lnrnt_imagesc_1b(sz_model,Sx,Sy,Rx,Ry)
SxSyRxRy=[Sx,Sy,Rx,Ry];

model=ones(sz_model);
nomor_grid=find(model);
nomor_model=reshape(nomor_grid,sz_model);

if Sy==Ry %horizontal
if Sx<Rx
y1=Sy ; y2=Ry ; x1=Sx ; x2=Rx;
else
y1=Sy ; y2=Ry ; x1=Sx ; x2=Rx;
end
elseif Sx==Rx %vertikal
if Sy<Ry
y1=Sy ; y2=Ry ; x1=Sx ; x2=Rx;
else
y1=Ry ; y2=Sy ; x1=Rx ; x2=Sx;
end
else
if Sy<Ry && Sx<Rx %m>0
y1=Sy ; y2=Ry ; x1=Sx ; x2=Rx;
elseif Sy>Ry && Sx>Rx %m>0
y1=Ry ; y2=Sy ; x1=Rx ; x2=Sx;
elseif Sy>Ry && Sx<Rx %m<0
y1=Sy+1 ; y2=Ry-1 ; x1=Sx ; x2=Rx;
elseif Sy<Ry && Sx>Rx %m<0
y1=Ry+1 ; y2=Sy-1 ; x1=Rx ; x2=Sx;
end
x1=x1-0.5;
x2=x2+0.5;
y1=y1-0.5;
y2=y2+0.5;
end
line=[x1 x2 y1 y2];
m = (y2-y1)/(x2-x1);
teta = atand(m);
% disp(['SxSyRxRy = ' num2str(SxSyRxRy)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% disp(['m = ' num2str(m)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% disp(['teta = ' num2str(teta)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% disp(['x1x2y1y2 = ' num2str(line)])
% disp(' ')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%Persamaan garisnya adalah y = m*x + x1

%==========================================================================
%===== Kondisi 1 : Garis Horizontal
%==========================================================================
if m==0 %Garis horizontal
% disp('Kondisi 1 : Garis Horizontal')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

34
 koord(:,1) = [x1:x2]';
koord(:,2) = [y1*ones((x2-x1+1),1)];

for i = 1:size(koord,1)
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=koord(i,1)-0.5;
koord(i,5)=koord(i,1)+0.5;
koord(i,6)=1;
koord(i,7)=1;
end
s=sqrt((y2-y1)^2+(x2-x1+1)^2);
sigma_ds=sum(koord(:,7));

% disp(['s = ' num2str(s)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% disp(['sigma_ds = '
num2str(sigma_ds)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% disp(' x y index x_kiri x_kanan dx
ds')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%==========================================================================
%===== Kondisi 2 : Garis Vertikal
%==========================================================================
elseif m==Inf %Garis vertikal
% disp('Kondisi 2 : Garis Vertikal')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
koord(:,1) = [x1*ones((y2-y1+1),1)];
koord(:,2) = [y1:y2]';

for i=1:size(koord,1)
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=koord(i,2)-0.5;
koord(i,5)=koord(i,2)+0.5;
koord(i,6)=1;
koord(i,7)=1;
end
s=sqrt((y2-y1+1)^2+(x2-x1)^2);
sigma_ds=sum(koord(:,7));

% disp(['s = ' num2str(s)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% disp(['sigma_ds = '
num2str(sigma_ds)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% disp(' (x) (y) (ind)(y_garis)(dy)
(ds)')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%==========================================================================
%====== Kondisi 3 : KiBa - KaAt, cenderung ke x
%==========================================================================
elseif m<=1 && m>0 %Garis miring, cenderung miring ke sumbu x
% disp('Kondisi 3 : m>0 (Kiri Bawah <-> Kanan Atas); cenderung ke
x')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Penentuan titik
koord=zeros(1,7);
i=0;
for xi = x1:x2-1
i=i+1;
koord(i,1)=xi+0.5;
y_xi=m*(xi+0.5-x1) + y1;
y_kiri = m*(xi-x1) + y1;
y_kanan = m*(xi+1-x1) + y1;
yy(i,:)=[xi round(y_xi) y_kiri y_xi y_kanan];

35
 koord(i,2)=round(y_xi);
% [koord(i,2)-y_kiri -(koord(i,2)-y_kanan)]
if (koord(i,2)-y_kiri<=0.5)&&(y_kanan-koord(i,2)<=0.5)
% disp('a')
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=y_kiri;
koord(i,5)=y_kanan;

elseif (koord(i,2)-y_kiri>0.5)
% disp('b')
koord(i,2)=koord(i,2)-1;
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=y_kiri;
koord(i,5)=koord(i,2)+0.5;

i=i+1;
koord(i,1)=xi+0.5;
koord(i,2)=round(y_xi);
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=koord(i,2)-0.5;
koord(i,5)=y_kanan;

elseif (koord(i,2)-y_kiri<0)||(y_kanan-koord(i,2)>0.5)
% disp('c')
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=y_kiri;
koord(i,5)=koord(i,2)+0.5;

i=i+1;
koord(i,1)=xi+0.5;
koord(i,2)=round(y_xi)+1;
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=koord(i,2)-0.5;
koord(i,5)=y_kanan;
end
end

koord(:,6)=abs(koord(:,5)-koord(:,4));
for i=1:size(koord,1)
koord(i,7)=koord(i,6)/sind(teta);
end

%Membandingkan jumlah ds dan s

s=sqrt((y2-y1)^2+(x2-x1)^2);
sigma_ds=sum(koord(:,end));
% disp(['s = ' num2str(s)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% disp(['sigma_ds = '
num2str(sigma_ds)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% disp(' x y index y_kiri y_kanan dy
ds')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%==========================================================================
%===== Kondisi 4 : KaBa ke KiAt, cenderung ke x
%==========================================================================
elseif m>=-1 && m<0 %Garis miring, cenderung miring ke sumbu x
% disp('Kondisi 4 : m<0 (Kiri Atas <-> Kanan Bawah); cenderung ke
x')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%Penentuan titik
koord=zeros(1,7);

36
 i=0;
for xi = x1:x2-1
i=i+1;
koord(i,1)=xi+0.5;
y_xi=m*(xi-x1+0.5) + y1;
y_kiri = m*(xi-x1) + y1;
y_kanan = m*(xi+1-x1) + y1;
yy(i,:)=[xi round(y_xi) y_kiri y_xi y_kanan];

koord(i,2)=round(y_xi);
if (koord(i,2)-y_kanan<=0.5)&&(y_kiri-koord(i,2)<=0.5)
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=y_kiri;
koord(i,5)=y_kanan;

elseif koord(i,2)-y_kanan>0.5
koord(i,2)=koord(i,2)-1;
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=y_kiri;
koord(i,5)=koord(i,2)+0.5;

i=i+1;
koord(i,1)=xi+0.5;
koord(i,2)=round(y_xi);
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=koord(i,2)-0.5;
koord(i,5)=y_kanan;

elseif (koord(i,2)-y_kanan<0)||(y_kiri-koord(i,2)>0.5)
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=y_kiri;
koord(i,5)=koord(i,2)+0.5;

i=i+1;
koord(i,1)=xi+0.5;
koord(i,2)=round(y_xi)+1;
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=koord(i,2)-0.5;
koord(i,5)=y_kanan;
end
end

koord(:,6)=abs(koord(:,5)-koord(:,4));
for i=1:size(koord,1)
koord(i,7)=-koord(i,6)/sind(teta);
end

%Membandingkan jumlah ds dan s

s=sqrt((y2-y1)^2+(x2-x1)^2);
sigma_ds=sum(koord(:,end));
% disp(['s = ' num2str(s)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% disp(['sigma_ds = '
num2str(sigma_ds)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% disp(' x y index y_kiri y_kanan dy
ds')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%==========================================================================
%======= Kondisi 5 : KiBa <-> KaAt; cenderung ke y

37
%==========================================================================
elseif m>1 && m>0 %Garis miring, cenderung miring ke sumbu y
% disp('Kondisi 5 : m>0 (Kiri Bawah <-> Kanan Atas); cenderung ke
y')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%Penentuan titik
koord=zeros(1,7);
i=0;
for yi = y1:y2-1
i=i+1;
koord(i,2)=yi+0.5;
x_yi=1/m*(yi+0.5-y1) + x1;
x_bawah = 1/m*(yi-y1) + x1;
x_atas = 1/m*(yi+1-y1) + x1;
xx(i,:)=[yi round(x_yi) x_bawah x_yi x_atas];

koord(i,1)=round(x_yi);
% [koord(i,1)-x_bawah x_atas-koord(i,1)]
if (koord(i,1)-x_bawah<=0.5)&&(x_atas-koord(i,1)<=0.5)
% disp('a')
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=x_bawah;
koord(i,5)=x_atas;
elseif koord(i,1)-x_bawah>0.5
% disp('b')
koord(i,1)=koord(i,1)-1;
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=x_bawah;
koord(i,5)=koord(i,1)+0.5;

i=i+1;
koord(i,2)=yi+0.5;
koord(i,1)=round(x_yi);
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=koord(i,1)-0.5;
koord(i,5)=x_atas;
elseif (koord(i,1)-x_bawah<0)||(x_atas-koord(i,1)>0.5)
% disp('c')
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=x_bawah;
koord(i,5)=koord(i,1)+0.5;

i=i+1;
koord(i,2)=yi+0.5;
koord(i,1)=round(x_yi)+1;
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=koord(i,1)-0.5;
koord(i,5)=x_atas;
end
end

koord(:,6)=abs(koord(:,5)-koord(:,4));
for i=1:size(koord,1)
koord(i,7)=koord(i,6)/cosd(teta);
end

%Membandingkan jumlah ds dan s

s=sqrt((y2-y1)^2+(x2-x1)^2);
sigma_ds=sum(koord(:,end));
% disp(['s = ' num2str(s)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

38
% disp(['sigma_ds = '
num2str(sigma_ds)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% disp(' x y index x_kiri x_kanan dx
ds')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%==========================================================================
%====== Kondisi 6 : KaBa <-> KiAt; cenderung ke y
%==========================================================================

elseif m<-1 && m<0 %Garis miring, cenderung miring ke sumbu y

% disp('Kondisi 6 : m<0 (Kanan Bawah <-> Kiri Atas); cenderung ke
y')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%Penentuan titik
koord=zeros(1,7);
i=0;
for yi = y1:-1:y2+1
i=i+1;
koord(i,2)=yi-0.5;
x_yi=1/m*(yi-0.5-y1) + x1;
x_atas = 1/m*(yi-1-y1) + x1;
x_bawah = 1/m*(yi-y1) + x1;
xx(i,:)=[yi round(x_yi) x_bawah x_yi x_atas];

koord(i,1)=round(x_yi);
if (koord(i,1)-x_bawah<=0.5)&&(x_atas-koord(i,1)<=0.5)
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=x_bawah;
koord(i,5)=x_atas;
elseif koord(i,1)-x_bawah>0.5
koord(i,1)=koord(i,1)-1;
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=x_bawah;
koord(i,5)=koord(i,1)+0.5;

i=i+1;
koord(i,2)=yi-0.5;
koord(i,1)=round(x_yi);
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=koord(i-1,5);
koord(i,5)=x_atas;
elseif (koord(i,1)-x_bawah<0)||(x_atas-koord(i,1)>0.5)
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=x_bawah;
koord(i,5)=koord(i,1)+0.5;

i=i+1;
koord(i,2)=yi-0.5;
koord(i,1)=round(x_yi)+1;
koord(i,3)=nomor_model(koord(i,2),koord(i,1));
koord(i,4)=koord(i-1,5);
koord(i,5)=x_atas;
end
end

koord(:,6)=abs(koord(:,5)-koord(:,4));
for i=1:size(koord,1)
koord(i,7)=koord(i,6)/cosd(teta);
end

39
 %Membandingkan jumlah ds dan s
s=sqrt((y2-y1)^2+(x2-x1)^2);
sigma_ds=sum(koord(:,end));
% disp(['s = ' num2str(s)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% disp(['sigma_ds = '
num2str(sigma_ds)])%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% disp(' x y index x_kiri x_kanan dx
ds')%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

end

% disp(koord) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
koord = koord;
% memory

40
Transformasi
function [p_transformasi]=tomo_transform_1b(p)
disp('---------------------------------------------------------------------
------')
disp(' ... Sedang proses transformasi. Harap Tunggu... ')
fprintf('\n WARNING : Ray dibuat ulang dengan arah lurus dan diagonal \n
simetris saja. Hal ini dimaksudkan agar bobot tiap grid \n merata semua
(tiap grid dilalui oleh jumlah ray yang sama. \n Sehingga ray yang ada
hanya ada 6 buah ray (tidak berdasar- \n kan forward yang ada di
"Rekonstruksi_Inversi_xx.m" \n \n')
tic
%Kalibrasi variabel
[zz,xx]=size(p);
dx=1;dz=1;
p_sel = zeros(zz,xx);
jumlah_tembak = 0;
figure
subplot(3,3,5), pcolor(p), title({'pcolor True Model (Slowness)'})

%---tembak ke kiri--
t_kiri = zeros(zz,xx);
L_kiri = zeros(zz,xx); %L adalah matriks yang berisi jarak yang ditempuh
raypath
siji = ones(1,xx);
for i = 1:zz
satu = zeros(zz,xx);
satu(i,:) = siji;
TT = sum(sum(p.*satu.*dx));
tt = satu.*TT;
t_kiri = t_kiri+tt;

ll = sum(sum(dx.*satu));
LL = satu.*ll;
L_kiri = L_kiri+LL;
p_avg_kiri = t_kiri./L_kiri;
p_sel_kiri = ll.*p_avg_kiri./L_kiri;
end
p_sel = p_sel+p_sel_kiri;
jumlah_tembak = jumlah_tembak+1;
subplot(3,3,4)
pcolor(t_kiri)

%---tembak ke atas--
t_atas = zeros(zz,xx);
L_atas = zeros(zz,xx);
siji = ones(1,zz);
for i = 1:xx
satu = zeros(zz,xx);
satu(:,i) = siji;
TT = sum(sum(p.*satu.*dx));
tt = satu.*TT;
t_atas = t_atas+tt;

ll = sum(sum(dx.*satu));
LL = satu.*ll;
L_atas = L_atas+LL;
p_avg_atas = t_kiri./L_atas;
p_sel_atas = ll.*p_avg_atas./L_atas;
end
p_sel = p_sel+p_sel_atas;

41
jumlah_tembak = jumlah_tembak+1;
subplot(3,3,2)
pcolor(t_atas)

%---tembak ke kanan--
t_kanan = zeros(zz,xx);
L_kanan = zeros(zz,xx);
siji = ones(1,xx);
for i = 1:zz
satu = zeros(zz,xx);
satu(i,:) = siji;
TT=sum(sum(p.*satu.*dx));
tt=satu.*TT;
t_kanan = t_kanan+tt;

ll = sum(sum(dx.*satu));
LL = satu.*ll;
L_kanan = L_kanan+LL;
p_avg_kanan = t_kanan./L_kanan;
p_sel_kanan = ll.*p_avg_kanan./L_kanan;
end
p_sel = p_sel+p_sel_kanan;
jumlah_tembak = jumlah_tembak+1;
subplot(3,3,6)
pcolor(t_kanan)

%---tembak ke bawah--
t_bawah = zeros(zz,xx);
L_bawah = zeros(zz,xx);
siji = ones(1,zz);
for i = 1:xx
satu = zeros(zz,xx);
satu(:,i) = siji;
TT=sum(sum(p.*satu.*dx));
tt=satu.*TT;
t_bawah=t_bawah+tt;

ll = sum(sum(dx.*satu));
LL = satu.*ll;
L_bawah = L_bawah+LL;
p_avg_bawah = t_bawah./L_bawah;
p_sel_bawah = ll.*p_avg_bawah./L_bawah;
end
p_sel = p_sel+p_sel_bawah;
jumlah_tembak = jumlah_tembak+1;
subplot(3,3,8)
pcolor(t_bawah)

%--------tembak ke kanan atas-------------

t_kananatas = zeros(zz,xx);
L_kananatas = zeros(zz,xx);
siji = ones(1,length(p));
for i = -zz+1:xx-1
satu=diag(siji,i);
satu=satu(1:zz,1:xx);
TT=sum(sum(p.*satu.*dx*sqrt(2)));
tt=satu.*TT;
t_kananatas=t_kananatas+tt;

ll = sum(sum(dx*sqrt(2).*satu));

42
 LL = satu.*ll;
L_kananatas = L_kananatas+LL;
p_avg_kananatas = t_kananatas./L_kananatas;
p_sel_kananatas = ll.*p_avg_kananatas./L_kananatas;
end
p_sel = p_sel+p_sel_kananatas;
jumlah_tembak = jumlah_tembak+1;
subplot(3,3,3)
pcolor(t_kananatas)

%--------tembak ke kiri atas-------------

t_kiriatas = zeros(zz,xx);
L_kiriatas = zeros(zz,xx);
siji = ones(1,length(p));
for i=-zz+1:xx-1
satu=diag(siji,i);
satu=flip(satu(1:zz,1:xx));
TT=sum(sum(p.*satu.*dx*sqrt(2)));
tt=satu.*TT;
t_kiriatas=t_kiriatas+tt;

ll = sum(sum(dx*sqrt(2).*satu));
LL = satu.*ll;
L_kiriatas = L_kiriatas+LL;
p_avg_kiriatas = t_kiriatas./L_kiriatas;
p_sel_kiriatas = ll.*p_avg_kiriatas./L_kiriatas;
end
p_sel = p_sel+p_sel_kiriatas;
jumlah_tembak = jumlah_tembak+1;
subplot(3,3,1)
pcolor(t_kiriatas)

p_transformasi=p_sel;
time=toc;
disp(['Elapsed time : ' num2str(time) ' seconds'])
disp(' ')
memory

43
BPT
function [s_bpt_mo,selisih,RMS]=tomo_bpt_monalia(s,sz_model,G,d)
tic
disp('---------------------------------------------------------------------
------')
disp(' ... Sedang proses BPT (Monalia). Harap Tunggu... ')
disp(' ')
if size(d,2)>1
d=d';
end

L=(sum(G'))'; %Total panjang tiap ray

m_rata=d./L; %Slowness rata-rata tiap ray
ll=sum(G); %Total panjang ray yang melalui tiap grid
m=(G'*m_rata)'./ll; %Slowness tiap sel

%Perhitungan RMS Error antara model hasil BPT dengan model asli
s_bpt_mo=reshape(m,sz_model);
selisih=abs(s_bpt_mo-s);
RMS = sqrt(sum(sum((selisih.^2)))/numel(m));
disp(['RMS error : ' num2str(RMS*100) '%'])
time=toc;
disp(['Elapsed time : ' num2str(time) ' seconds'])
disp(' ')
memory

44
ART
function [p,selisih,RMS] = tomo_art7(s,sz_model,G,tdata,iter_max,conv_tol)
tic
disp('---------------------------------------------------------------------
------')
disp(' ... Sedang proses ART. Harap Tunggu... ')
disp(' ')

if size(tdata,2) > 1
tdata = tdata';
end

[n,m] = size(G);
N = (sum((G.^2)'))';

%Model awal menggunakan BPT (Mengacu pada function tomo_bpt.m)

L=(sum(G'))'; %Total panjang tiap ray
m_rata=tdata./L; %Slowness rata-rata tiap ray
ll=sum(G); %Total panjang ray yang melalui tiap grid
model=(G'*m_rata)'./ll; %Slowness tiap sel

p_lama = model';

% p_lama = zeros(m,1);
t_cal = G*p_lama;
p_baru=p_lama;
iter=1;
conv=1;
while iter<=iter_max && conv>conv_tol
for i = 1:n %Perhitungan per ray
delta_p = (((tdata(i)-t_cal(i))/N(i,:))*G(i,:)');
p_baru = p_baru+delta_p;
t_cal = G*p_baru;
end

conv = sum(sum((abs(p_baru-p_lama))))/numel(p_baru);
p_lama=p_baru;
iter=iter+1;
end

p = reshape(p_baru, sz_model);
%Perhitungan RMS Error antara model hasil ART dengan model asli
selisih=abs(p-s).^2;
RMS = sqrt(sum(sum(selisih))/numel(p));
time=toc;
disp(['RMS error : ' num2str(RMS*100) '%'])
disp(['Elapsed time : ' num2str(time) ' seconds'])
disp(['Convergency : ' num2str(conv) ])
disp(['Iterasi : ' num2str(iter-1) '(dari iter max : ' num2str(iter_max)
')'])
disp(' ')
memory

45
SIRT
function [p,selisih,RMS] = tomo_sirt_4(s,sz_model,G,tdata,n_iter,conv_tol)
disp('------------------------------------------------------------------')
disp(' ... Sedang proses SIRT. Harap Tunggu... ')
disp(' ')
if size(tdata,2)>1
tdata=tdata';
end
[n,m]=size(G);

G_sqr = G.^2;
L_ray=(sum(G'))';%Jumlah distance per ray
L_grid=sum(G)'; %Jumlah distance grid

%Model awal menggunakan BPT

L=(sum(G'))'; %Total panjang tiap ray
m_rata=tdata./L; %Slowness rata-rata tiap ray
ll=sum(G); %Total panjang ray yang melalui tiap grid
model=(G'*m_rata)'./ll; %Slowness tiap sel

p0=model';
t_iter=G*p0; %Menghitung data dengan model awal p0
p_lama=p0;
p_baru=p_lama;
iter=1;%Inisiasi parameter iterasi
conv=1; %Inisiasi parameter iterasi
delta_p=zeros(size(p_baru));
tic
while iter<=n_iter && conv>conv_tol
for k = 1:n %Perhitungan per ray
%Perbedaan dengan ART adalah update model dilakukan setelah semua
%ray selesai dihitung.
% delta_p = delta_p+((((tdata(k,1)-
t_iter(k,1))/L(k,:))*G(k,:))./L(k,:))';
delta_t = tdata(k,1)-t_iter(k,1);
delta_p = delta_p + (delta_t/L_ray(k,1)*G(k,:)');
end
delta_p = delta_p./L_grid;
p_baru = p_baru + delta_p;
t_iter = G*p_baru;

conv = sum(sum((abs(p_baru-p_lama))))/numel(p_baru);
p_lama=p_baru;
iter=iter+1;
end
time=toc;
p = reshape(p_baru,sz_model);
%Perhitungan RMS Error antara model hasil ART dengan model asli
selisih=abs(p-s).^2;
RMS = sqrt(sum(sum(selisih))/numel(p));
disp(['RMS error : ' num2str(RMS*100) '%'])
disp(['Elapsed time : ' num2str(time) ' seconds'])
disp(['Convergency : ' num2str(conv) ])
disp(['Iterasi : ' num2str(iter-1) '(dari iter max : ' num2str(n_iter)
')'])
disp(' ')
memory

46
Bi-CG
function [s,flag]=inv_bicg(s_true,sz_model,A,b)
tic
disp('---------------------------------------------------------------------
------')
disp(' ... Sedang proses bicg. Harap Tunggu... ')
disp(' ')
[x,flag]=bicg(A,b);
s=reshape(x,sz_model);
selisih=abs(s-s_true).^2;
RMS = sqrt(sum(sum(selisih))/numel(s));
time = toc;
disp(['RMS error : ' num2str(RMS*100) '%'])
disp(['Elapsed time : ' num2str(time) ' seconds'])
disp(' ')
memory

47
LSQR
function [s,flag]=inv_lsqr(s_true,sz_model,A,b)

tic
disp('---------------------------------------------------------------------
------')
disp(' ... Sedang proses lsqr. Harap Tunggu... ')
disp(' ')
[x,flag]=lsqr(A,b);
s=reshape(x,sz_model);
selisih=abs(s-s_true).^2;
RMS = sqrt(sum(sum(selisih))/numel(s));
time=toc;
disp(['RMS error : ' num2str(RMS*100) '%'])
disp(['Elapsed time : ' num2str(time) ' seconds'])
disp(' ')
memory

48
P_Inv
function [s]=inv_pinv(s_true,sz_model,G,d)
tic
disp('---------------------------------------------------------------------
------')
disp(' ... Sedang proses pinv. Harap Tunggu... ')
disp(' ')
pinvG = pinv(G);
s = pinvG*d;
s=reshape(s,sz_model);
selisih=abs(s-s_true).^2;
RMS = sqrt(sum(sum(selisih))/numel(s));
time=toc;
disp(['RMS error : ' num2str(RMS*100) '%'])
disp(['Elapsed time : ' num2str(time) ' seconds'])
disp(' ')
memory

49