LAPORAN AKHIR

INVERSI GEOFISIKA TG 3004

MODUL KE – 4
INVERSI NON LINEAR

Oleh:
Muhamad Arif Samsudin 120120158

Asisten :
Alifah Iftinan 119120042
Andika Bonardo Sipahutar 119120122
Bernard Cavin Ronlei 119120087
Kiki Harfianza 119120111
Mu'amar Hafiz 119120084
Nisa Nur Azizah 119120027

PROGRAM STUDI TEKNIK GEOFISIKA

JURUSAN TEKNOLOGI PRODUKSI DAN INDUSTRI
INSTITUT TEKNOLOGI SUMATERA
2022/2023
I. TUJUAN

1. Mampu menyelesaikan persamaan inversi dalam bidang geofisika yang menggunakan

metode inversi non linear dengan pendekatan linear, Gradien dan Newton.
2. Mampu menganalisa fungsi dari inversi non linear dengan pendekatan linear, Gradien dan
Newton.

II. DASAR TEORI

Inversi Nonlinear dengan Pendekatan Linear adalah sebuah metode untuk menyelesaikan
masalah inversi yang melibatkan persamaan nonlinear dengan menggunakan pendekatan linear.
Tujuannya adalah untuk mencari solusi yang meminimalkan kesalahan antara nilai yang diukur
dan nilai yang diprediksi oleh model matematika. Dalam pendekatan ini, model matematika yang
digunakan untuk mendefinisikan hubungan antara variabel input dan output direpresentasikan
sebagai fungsi nonlinear. Tujuannya adalah untuk menemukan parameter dalam model ini
sehingga output yang dihasilkan oleh model ini sesuai dengan nilai yang diukur. Metode
pendekatan linear digunakan untuk mengatasi masalah nonlinearity dengan menganggap bahwa
solusi yang diinginkan dapat didekati dengan fungsi linear. Dalam hal ini, persamaan nonlinear
yang menggambarkan model matematika diubah menjadi bentuk linear dengan melakukan
ekspansi deret Taylor di sekitar titik operasi yang tepat. Setelah model linear dibentuk, inversi
dilakukan dengan mencari solusi terbaik yang meminimalkan kesalahan antara nilai yang diukur
dan nilai yang diprediksi oleh model linear. Pendekatan ini diterapkan dengan menghitung gradien
dari kesalahan ini dan menggunakan algoritma optimasi untuk menemukan nilai parameter yang
optimal. Secara umum, pendekatan ini sangat berguna dalam aplikasi di mana model nonlinear
kompleks digunakan untuk memprediksi respons sistem, seperti dalam bioinformatika, geofisika,
dan fisika medis. Namun, pendekatan ini memiliki beberapa kelemahan, seperti keterbatasan dalam
mengatasi masalah nonlinearity yang sangat kompleks dan membutuhkan waktu komputasi yang
cukup lama.

A. INVERSI NON LINEAR DENGAN PENDEKATAN LINEAR

Permasalahan inversi non-linear berupa regresi fungsi eksponensial dapat diselesaikan

menggunakan metode inversi linear setelah melalui transformasi variable. Secara umum,
transformasi variable tidak selalu dapat digunakan untuk memformulasikan kembali suatu
permasalahan inversi sehingga dapat diselesaikan secara lebih mudah. Karena itu diperlukan
metode yang secara khusus dikembangkan untuk menyelesaikan suatu permasalahan inversi
nonlinear. Pada prinsipnya semua formulasi yang telah digunakan untuk menyelesaikan
permasalahan inversi linear dapat diperluas untuk memperoleh solusi inversi nonlinear. Secara
umum sebagian besar permasalahan inversi dalam geofisika adalah inversi non-linear. Meskipun
pada beberapa kasus permasalahan inversi dapat dipilih atau dibuat menjadi linear ataupun non-
linear bergantung pada parameterisasi model yang dipilih.

Hubungan antara data dengan parameter model dapat dinyatakan oleh persamaan berikut:
d = g(m)
Persamaan tersebut dapat pula digunakan untuk menyatakan hubungan antara data dengan
parameter model yang direpresentasikan oleh suatu fungsi non-linear. Dalam hal ini g adalah suatu
fungsi pemodelan ke depan (forward modelling) yang merupakan fungsi non-linear dari parameter
model. Fungsi g dinyatakan dalam notasi vector untuk meyatakan adanya komponen yang
berasosiasi dengan komponen data.
Solusi penyelesaian inversi non linear
Misalkan solusi inversi adalah model m yang merupakan suatu model awal m0 yang diperturbasi
dengan ∆m agar diperoleh kecocokan yang lebih baik antara respons model tersebut dengan data:

Langkah 1:
Melakukan ekspansi taylor orde pertama fungsi g(m) di sekitar suatu model awal m0 dengan
menggunakan notasi komponen. Sehingga

Dimana (δmj) adalahsukusisa yang melibatkanturunanordekedua dan orde-orde lebih tinggi.

Langkah 2:
Prediksi data di pada m = m0 yang diberikandengan
Langkah 3: Menetukan matriks Jacobi atau Jacobian matrix yang didapatkan dari suku ke-dua
pada ruas kanan persamaan (6) adalah komponen turunan parsial fungsi g(m) terhadap suatu
elemen parameter model m, yaitu:

Langkah 4:
Mengkombinasikan langkah 3 dengan langkah sebelumnya, sehingga didapatkan persamaan:

Sehingga didapatkan notasi matriks berikut:

J0 adalah matriks Jacobi yang dievaluasi pada m=m0. Dengan menganggap ∆d0= d g(m0)dengan
∆m0
Langkah 5: Menyelesaikan solusi inversi dalam bentuk ∆mo dari suatu permasalahan yang dapat
dinyatakan sebagai berikut:

Persamaan di atas pada dasarnya menyatakan perturbasi yang diperlukan terhadap suatu model
awal m0 agar diperoleh model yang lebih baik, yaitu m = m0 + ∆m0. Respons model m diharapkan
lebih fit dengan data. Untuk memperoleh solusi inversi atau model optimum diperlukan perturbasi
secara iteratif suatu model awal mo. Dengan demikian pada iterasi ke-(n+1) perturbasi dilakukan
terhadap model hasil iterasi sebelumnya dengan menggunakan persamaan berikut:

B. Newton
Metode Newton untuk penyelesaian inversi non linear didasarkan pada prinsip yang sama dengan
metode Newton untuk memperkirakan nilai fungsi y = f(x) = 0, solusi yang dicari adalah
perpotongan fungsi dengan sumbu mendatar.

Dengan memasukkan harga fungsi x=xn maka a dapat di eliminasi

Untuk menghindari kesulitan dalam menghitung turunan kedua fungsi pemodelan maka :

C. Gradien
Gradien suatu fungsi menyatakan arah peningkatan terbesar fungsi sehingga arah yang berlawanan
(negatif) dari gradien bersesuaian dengan penurunan harga fungsi.
Model pada setiap iterasi dikoreksi dengan arah negatif gradien E sehingga :

Metode gradien akan cepat di awal, tetapi melambat di akhir, sedangkan metode gauss akan cepat
di akhir. Kombinasi keduanya metode Levenberg-Marquardt.
III. LANGKAH PENGERJAAN

a) Langkah Kerja
Problem 1
1. Melakukan input data berupa kecepatan gelombang gempa yang terekam pada setiap
stasiun.
import numpy as np
import matplotlib.pyplot as plt
import copy
from numpy.linalg import inv

#Start Position
x = [0, 10, 20, 30]
z = [0,0,0,0]
n = len(x)
#True Hiposenter
xo = 12
zo = 10
to = 0
#Velocity
v = 7
t = []
for i in range(n):
t.append((1/v)*np.sqrt((z[i]-zo)**2+(x[i]-xo)**2))
#Add noise
noise = np.random.rand()*0.03*np.mean(t) #kita makai 0.01 karna
disoal ditambah 1% atau 0.01
ti = t + noise
2. Melakukan tebakan awal
#Guess the initial position
m = [50, 40] # 50, 40 #15,30
init_position = copy.deepcopy(m)
m1 = []
3. Metode inversi dengan formulasi linear dan hubungan data dengan parameter model
Nilai d=Gm Rumus Tcal yang dipakai pada matlab adalah:

4. Proses inversi dilakukan dengan menentukan model terlebih dahulu dan juga jacobi
5. Menghitung ERMS dan plotting
#Inversion with non linear method
xhipo=[init_position[0]]
yhipo=[init_position[1]]
erms=[]
for niter in range(4): #4 #7
gm=[]
dgm_dm1=[]
dgm_dm2=[]
 for i in range(n):
gm.append(to+(1/v)*(np.sqrt((x[i]-m[0])**2+(z[i]-m[1])**2)))
dgm_dm1.append((1/v)*(-1*(x[i]-m[0]))/(np.sqrt((x[i]-
m[0])**2+(z[i]-m[1])**2)))
dgm_dm2.append((1/v) * (-1*(z[i]-m[1]))/(np.sqrt((x[i]-
m[0])**2 +(z[i]-m[1])**2)))

j=np.zeros((n,2))
for i in range(n): #Matriks jacobian, reshape adalah tadi
matriksnya sejajar menjadi mendatar
j[i][0]=dgm_dm1[i]
j[i][1]=dgm_dm2[i]

mo=copy.deepcopy(m)
mo=np.reshape(mo,(2,1))
ti = np.reshape(ti, (n, 1))
gm = np.reshape(gm, (n, 1))
model=np.mat(mo)+np.mat(inv(np.mat(j.transpose())*np.mat(j)))*np.m
at(j.transpose())*(np.mat(ti)-np.mat(gm))
m=[model[0][0],model[1][0]]
data =model.tolist()
xhipo.append(data[0][0])
yhipo.append(data[1][0])
dt=ti-gm
erms.append(np.sqrt(np.average(dt**2)))

plt.plot(m[0], m[1],'o',label='Initial Position', color='black') #2.

ini ditambah M[0] , M[1]
plt.plot(xhipo,yhipo,'o',label='Hypocenter Inversion')
plt.plot(xhipo,yhipo,label='Hypocenter Inversion')
plt.plot(xo,zo,'o', alpha=0.5,color='yellow', label='True Hypocenter')
plt.title('Hypocenter Determination_120120158')
plt.xlabel('X Coordinate')
plt.ylabel('Y Coordinate')
plt.legend()
plt.figure()
plt.plot(erms)
plt.title('Kurva RMS Error vs N Iterasi_120120158')
plt.ylabel('RMS Error')
plt.xlabel('N Iterasi')
plt.show()
Problem 2

1. Input data (sama seperti problem1)

2. Tentukan initial position (sama seperti problem 1)
3. Membuat forward modelling
# forward modelling untuk menghitung travel time dari hyposenter ke
station
t = []
for i in range(n):
t.append((1 / Vp) * np.sqrt((z[i] - z0) ** 2 + (x[i] - x0) ** 2))
4. Menggunakan metode gradien. Misalkan posisi tebakan awal
# tebakan awal posisi hiposenter
M = [50, 40]
init_position = copy.deepcopy(M)
M1 = []

I = np.eye(2)
E = 0.1*I

xhipo = [init_position[0]]
yhipo = [init_position[1]]
Erms = []
5. Menentukan minimum error
#Menentukan minimum error
P = 10 #nilai tebakan minimum error
HypoX = []
HypoY = []
X0 = np.arange(0,50,1)
Y0 = np.arange(0,50,1)
6. Mengeplot titik hiposenter dan Error
plt.plot(12, 30, 'o', label='initial Position', color='black')
plt.plot(xhipo, yhipo, 'o', label='hyposenter inversion')
plt.plot(xhipo, yhipo, label='hyposenter inversion')
plt.plot(x0, z0, 'o', alpha=0.5, color='red', label='True Hypocenter')
plt.title('Hypocenter Determination_120120158')
plt.xlabel('X Coordinate')
plt.ylabel('Y coordinate')
plt.legend()
plt.figure()
plt.plot(Erms)
plt.title('Kurva RMS eror vs N Iterasi_120120158')
plt.xlabel('N Iterasi')
plt.ylabel(' RMS Eror')
plt.show()
Problem 3

1. Membuat forward modelling

# Step 1: Membuat forward modelling
n = 10
x = np.random.rand(n)*20
z = np.random.rand(n)*20
ti = np.random.rand(n)*2
2. Menghitung grid search untuk plot minimum error
# Step 2: Menghitung grid search untuk plot minimum error
x_grid = np.linspace(0, 20, 100)
z_grid = np.linspace(0, 20, 100)
E_grid = np.zeros((100, 100))

for i, xi in enumerate(x_grid):
for j, zj in enumerate(z_grid):
tc = []
for k in range(n):
tc.append((1 / v) * np.sqrt((z[k] - zj) ** 2 + (x[k] - xi)
** 2))
E_grid[i, j] = np.sqrt(np.sum((ti - tc) ** 2))

x_min, z_min = np.unravel_index(E_grid.argmin(), E_grid.shape)

3. Menentukan tebakan awal
# Step 3: Menentukan tebakan awal
xo = x_grid[50]
zo = z_grid[40]
tc1 = []
for i in range(n):
tc1.append((1 / v) * np.sqrt((z[i] - zo) ** 2 + (x[i] - xo) ** 2))
E1 = np.sqrt(np.sum((ti - tc1) ** 2))
4. Mengeplot tiap iterasi
# Step 4: Mengeplot tiap iterasi
plt.figure()
plt.contourf(x_grid, z_grid, E_grid)
plt.colorbar()
plt.scatter(xo, zo, marker='*', color='Gold')
plt.xlabel('x (km)')
plt.ylabel('z (km)')
plt.title('Grid search for minimum error_120120158')
plt.show()
5. Menghitung random search
# Step 5: Menghitung random search
n_iter = 4
E = [E1]
xo_list = [xo]
zo_list = [zo]
for i in range(n_iter):
dx = np.random.rand() * 2 - 1
dz = np.random.rand() * 2 - 1
x_new = xo + dx
z_new = zo + dz
tc = []
for k in range(n):
tc.append((1 / v) * np.sqrt((z[k] - z_new) ** 2 + (x[k] - x_new)
** 2))
E_new = np.sqrt(np.sum((ti - tc) ** 2))
if E_new < E[-1]:
xo_list.append(x_new)
zo_list.append(z_new)
E.append(E_new)
xo = x_new
zo = z_new
6. Menghitung Tcalculated dan error
# Step 6: Menghitung Tcalculated dan error
tc = []
for k in range(n):
tc.append((1 / v) * np.sqrt((z[k] - zo) ** 2 + (x[k] - xo) ** 2))
E_final = np.sqrt(np.sum((ti - tc) ** 2))
7. Mengeplot titik hiposenter dan Error
# Step 7: Mengeplot titik hiposenter dan Error
plt.figure()
plt.contourf(x_grid, z_grid, E_grid)
plt.colorbar()
plt.scatter(xo_list, zo_list, marker='x', color='red')
plt.plot(xo_list, zo_list, color='red')
plt.xlabel('x (km)')
plt.ylabel('z (km)')
plt.title('Inversion result')
b) Diagram Alir
1) Problem 1

Diagram Alir Problem 1

2) Problem 2

Diagram Alir Problem 2

3) Problem 3

Diagram Alir Problem 3

IV. HASIL DAN PEMBAHASAN

1) Penentuan lokasi hiposenter gempa dengan inversi non linear pendekatan linear
1.1 Variasi nilai m: [15, 30] dan Iterasi (4)

Hypocenter Determination nilai m: [15, 30] dan Iterasi (4)

Kurva RMS Error vs N Iterasi nilai m: [15, 30] dan Iterasi (4)
1.2 Variasi nilai m: [50, 40] dan Iterasi (4)

Hypocenter Determination nilai m: [50, 40] dan Iterasi (4)

Kurva RMS Error vs N Iterasi nilai m: [50, 40] dan Iterasi (4)
2) Penentuan lokasi hiposenter gempa dengan inversi non linear Gradien
2.1 Variasi nilai m: [15, 30] dan Iterasi (4)

Hypocenter Determination nilai m: [15, 30] dan Iterasi (4)

Kurva RMS Error vs N Iterasi nilai m: [15, 30] dan Iterasi (4)
2.2 Variasi nilai m: [50, 40] dan Iterasi (4)

Hypocenter Determination nilai m: [50, 40] dan Iterasi (4)

Hypocenter Determination nilai m: [50, 40] dan Iterasi (4)

3) Penentuan lokasi hiposenter gempa dengan inversi non linear Newton
3.1 Variasi nilai m: [15, 30] dan Iterasi (4)

3.2 Variasi nilai m: [50, 40] dan Iterasi (4)

PEMBAHASAN

Pada problem 1 dilakukan penentuan lokasi hiposenter gempa dengan inversi non linear
pendekatan linear. Pada permasalahan ini dilakukan dengan mengvariasikan nilai m: [15, 30] dan
[50, 40] dengan nilai iterasi (4). Adapaun output yang dihasilkan dari pengolahan ini berupa plot
hypocenter determination dan kurva rms error vs n iterasi. Penentuan lokasi hiposenter gempa
bumi dapat dilakukan dengan metode inversi non-linear. Metode inversi non-linear adalah metode
yang lebih kompleks dan memerlukan perhitungan yang lebih rumit. Metode ini didasarkan pada
pendekatan yang lebih akurat dan realistis terhadap model kecepatan gelombang di dalam bumi.
Dalam metode ini, data waktu tiba gelombang dari berbagai stasiun seismik digunakan untuk
menghitung lokasi hiposenter dan model kecepatan gelombang di dalam bumi yang terbaik.
Metode inversi non-linear dapat memberikan hasil yang lebih akurat jika digunakan dengan benar,
namun memerlukan waktu dan sumber daya komputasi yang lebih besar.

Pada problem 2 dilakukan penentuan lokasi hiposenter gempa dengan inversi non linear
Gradien. Pada permasalahan ini dilakukan dengan mengvariasikan nilai m: [15, 30] dan [50, 40]
dengan nilai iterasi (4). Penentuan lokasi hiposenter gempa dengan inversi non-linear gradien
adalah proses untuk menghitung lokasi hiposenter atau pusat dari gempa berdasarkan data yang
diperoleh dari stasiun. Metode ini menggunakan prinsip dasar bahwa gelombang seismik
merambat melalui bumi pada kecepatan yang berbeda-beda, tergantung pada sifat-sifat geologis di
dalam bumi. Dengan mengukur waktu tiba gelombang di stasiun-seismik yang berbeda, kita dapat
menghitung jarak antara stasiun-seismik dan hiposenter. Metode inversi non-linear gradien bekerja
dengan membandingkan data yang diperoleh dari stasiun seismik dengan model teoretis tentang
bagaimana gelombang seharusnya merambat melalui bumi. Model ini mencakup berbagai
parameter seperti kedalaman hiposenter, kecepatan gelombang di dalam lapisan bumi, dan lain-
lain.

Pada hasil hypocenter determination menggambarkan bahwa Initial position (posisi awal)
adalah posisi objek pada saat awal pengamatan atau pengukuran. Ini merupakan titik di mana objek
tersebut berada pada saat pengamatan atau pengukuran dimulai, dan biasanya digunakan sebagai
referensi untuk menghitung pergerakan atau perubahan posisi selanjutnya. Hypocenter inversion
(inversi hiposenter) adalah proses matematika dan komputasi yang digunakan untuk mengestimasi
lokasi hiposenter suatu gempa bumi dengan memanfaatkan data gelombang seismik yang diterima
oleh stasiun seismik. Teknik inversi hiposenter umumnya digunakan untuk meningkatkan akurasi
estimasi posisi hiposenter, karena data yang diterima oleh stasiun seismik memiliki banyak
ketidakpastian dan bias. Dengan menggunakan teknik inversi hiposenter, ketidakpastian dan bias
dalam data tersebut dapat dihilangkan atau dikurangi, sehingga posisi hiposenter yang diestimasi
menjadi lebih akurat. Proses inversi hiposenter melibatkan beberapa langkah, termasuk
pengumpulan data gelombang seismik, pemrosesan data tersebut, dan pemodelan geologis dari
daerah di sekitar gempa bumi. True hypocenter (hiposenter sebenarnya) adalah posisi atau lokasi
di dalam bumi di mana gempa bumi sebenarnya terjadi. True hypocenter sering kali sulit untuk
diukur secara langsung, karena posisinya berada di dalam bumi dan sulit diakses. Oleh karena itu,
metode inversi hiposenter digunakan untuk memperkirakan posisi hiposenter sebenarnya
berdasarkan data gelombang seismik yang diterima oleh stasiun seismik di permukaan bumi.

Kurva RMS error vs iterasi (kesalahan RMS vs iterasi) adalah grafik yang menunjukkan
perubahan kesalahan akurasi (RMS error) dari suatu model atau algoritma saat dilakukan iterasi
atau pembaruan berulang terhadap model atau algoritma tersebut. Kurva ini digunakan untuk
mengevaluasi kinerja suatu model atau algoritma dan mengoptimalkannya sehingga dapat
mencapai akurasi yang lebih tinggi. Pada awalnya, kesalahan akurasi model atau algoritma dapat
tinggi atau rendah tergantung pada konfigurasi awal atau parameter yang digunakan. Namun,
dengan setiap iterasi atau pembaruan model atau algoritma, kesalahan akurasi biasanya akan
berkurang seiring dengan peningkatan performa model atau algoritma. Kurva RMS error vs iterasi
biasanya menunjukkan tren menurun pada kesalahan akurasi seiring dengan jumlah iterasi atau
pembaruan yang lebih banyak. Namun, pada titik tertentu, peningkatan jumlah iterasi atau
pembaruan tidak akan lagi mengurangi kesalahan akurasi. Pada titik ini, model atau algoritma
dianggap telah mencapai konvergensi, dan kurva akan mencapai suatu nilai yang stabil atau
minimum yang menunjukkan tingkat akurasi yang optimal untuk model atau algoritma tersebut.

Pada problem 3 dilakukan penentuan lokasi hiposenter gempa dengan inversi non linear
Newton, dengan mengvariasikan nilai initial position: [15, 30] dan [50, 40] dengan nilai iterasi (4).
Penentuan lokasi hiposenter gempa dengan metode inversi non-linear Newton adalah suatu teknik
yang dilakukan untuk menghitung posisi hiposenter gempa bumi. Metode ini berdasarkan pada
hubungan antara waktu tiba gelombang seismik pada beberapa stasiun pengamat dan jarak antara
stasiun dengan hiposenter gempa. Metode inversi non-linear Newton memanfaatkan pendekatan
non-linear untuk meminimalkan selisih antara waktu tiba gelombang yang dihitung dari model
hiposenter gempa dan waktu tiba gelombang yang diukur pada stasiun pengamat. Proses inversi
dimulai dengan menghitung model awal hiposenter gempa dan kemudian melakukan iterasi untuk
memperbaiki model tersebut. Pada setiap iterasi, metode inversi non-linear Newton menggunakan
matriks Jacobian yang menggambarkan perubahan waktu tiba gelombang terhadap perubahan
parameter hiposenter gempa, seperti lokasi, kedalaman, dan waktu terjadi gempa. Kemudian,
metode ini menggunakan algoritma Newton untuk memperbarui model hiposenter gempa pada
setiap iterasi, hingga selisih waktu tiba gelombang seismik yang dihitung dan diukur pada stasiun
pengamat minimum. Proses ini berlangsung secara iteratif dan membutuhkan perhitungan yang
cukup kompleks. Ouput pada pengolahan problem 3 ini berupa grid, pembuatan grid ini bertujuan
untuk mencari daerah yang dicurigai sebagai lokasi hiposenter gempa, dan kemudian menghitung
nilai kesalahan waktu tiba gelombang seismik pada setiap titik pada grid. Pada setiap titik pada
grid, metode inversi non-linear Newton digunakan untuk menghitung hiposenter gempa.
Selanjutnya, waktu tiba gelombang dihitung kembali berdasarkan hiposenter gempa yang baru
dihasilkan, dan selisih waktu tiba gelombang seismik yang dihitung dan diukur pada stasiun
pengamat dihitung sebagai nilai kesalahan. Proses ini dilakukan untuk setiap titik pada grid, dan
lokasi hiposenter gempa yang tepat adalah lokasi yang menghasilkan nilai kesalahan waktu tiba
gelombang minimum. Metode ini memastikan bahwa tidak ada lokasi hiposenter gempa yang
terlewatkan dan kemungkinan besar akan menemukan lokasi hiposenter gempa yang tepat.

Berdasarkan hasil grid, perbedaan hasil penentuan lokasi hiposenter gempa dengan inversi
non-linear Newton ketika nilai initial position: [15, 30] dan iterasi (4) dengan saat nilai initial
position: [50, 40] dan iterasi (4) dapat berbeda karena nilai initial position yang berbeda tersebut
dapat menghasilkan hasil yang berbeda dalam proses inversi. Dalam metode inversi non-linear
Newton, nilai initial position dapat mempengaruhi konvergensi iterasi dan akurasi hasil. Nilai
initial position yang lebih dekat dengan lokasi hiposenter gempa yang sebenarnya dapat
menghasilkan konvergensi yang lebih cepat dan akurasi hasil yang lebih tinggi. Jika nilai initial
position pertama berada lebih dekat dengan lokasi hiposenter gempa yang sebenarnya
dibandingkan dengan nilai initial position kedua, maka kemungkinan besar iterasi akan lebih cepat
mencapai konvergensi dan menghasilkan hasil yang lebih akurat. Namun, jika nilai initial position
pertama terlalu jauh dari lokasi hiposenter gempa yang sebenarnya, maka iterasi mungkin
memerlukan waktu yang lebih lama untuk mencapai konvergensi dan hasil yang dihasilkan
mungkin kurang akurat. Dengan demikian, perbedaan hasil penentuan lokasi hiposenter gempa
dengan inversi non-linear Newton ketika nilai initial position: [15, 30] dan iterasi (4) dengan saat
nilai initial position: [50, 40] dan iterasi (4) akan tergantung pada seberapa dekat kedua nilai initial
position tersebut dengan lokasi hiposenter gempa yang sebenarnya, serta seberapa cepat dan akurat
konvergensi iterasi yang dihasilkan oleh metode inversi non-linear Newton.
V. KESIMPULAN

1) Metode inversi non-linear dengan pendekatan linear, Gradien dan Newton dapat digunakan
untuk menyelesaikan persamaan inversi dalam bidang geofisika. Metode inversi non-linear
dengan pendekatan linear umumnya digunakan ketika perubahan parameter yang diinginkan
dalam persamaan inversi relatif kecil dibandingkan dengan nilai parameter aktualnya..
Metode inversi non-linear dengan pendekatan Gradien memperhitungkan perubahan
parameter yang signifikan dalam persamaan inversi dan mampu menghasilkan solusi yang
lebih akurat dibandingkan dengan pendekatan linear. Metode inversi non-linear dengan
pendekatan Newton adalah metode yang paling akurat dan efektif dalam menyelesaikan
persamaan inversi non-linear.
2) Inversi non-linear dengan pendekatan linear, Gradien, dan Newton adalah metode-metode
yang digunakan dalam ilmu geofisika untuk menyelesaikan persamaan inversi non-linear.
Berikut adalah analisis fungsi dari masing-masing metode:
a) Inversi non-linear dengan pendekatan linear
Metode ini mengasumsikan bahwa perubahan parameter yang diinginkan dalam
persamaan inversi relatif kecil dibandingkan dengan nilai parameter aktualnya. Oleh
karena itu, metode ini dapat menghasilkan solusi yang cepat dan mudah
diimplementasikan, namun terkadang kurang akurat.
b) Inversi non-linear dengan pendekatan
Gradien Metode ini memperhitungkan perubahan parameter yang signifikan dalam
persamaan inversi dan mampu menghasilkan solusi yang lebih akurat dibandingkan dengan
pendekatan linear. Dalam metode ini, gradient atau gradien adalah turunan parsial dari
fungsi objektif terhadap parameter yang diukur pada titik tertentu. Metode ini dapat
memerlukan waktu komputasi yang lebih lama, tetapi dapat memberikan hasil yang lebih
akurat.
c) Inversi non-linear dengan pendekatan Newton
Metode ini adalah metode yang paling akurat dan efektif dalam menyelesaikan persamaan
inversi non-linear. Dalam metode ini, solusi iteratif diperoleh melalui iterasi solusi linear
dari sistem linear yang berhubungan dengan turunan parsial fungsi objektif terhadap
parameter. Oleh karena itu, metode ini juga dapat memerlukan waktu komputasi yang lebih
lama dan lebih rumit untuk diimplementasikan, tetapi memberikan hasil yang lebih akurat.
DAFTAR PUSTAKA

1. Setiawan, A. (2017). Analisis inversi linear dan non-linear pada data geolistrik tahanan
jenis dengan menggunakan perangkat lunak RES2DINV. Prosiding Seminar Nasional
Teknik Elektro, 1(1), 31-36.
2. Widodo, A., Irsyam, M., & Meilano, I. (2014). Inversi pemodelan deformasi tanah akibat
gempa bumi berdasarkan pengamatan GPS dan permodelan sumber gempa. Jurnal
Geofisika, 11(2), 107-117.
3. Akbar, A., Ramdhan, M., & Rachmat, R. (2016). Inversi tiga dimensi menggunakan metode
VES pada data geolistrik tahanan jenis di sekitar Gunung Slamet, Jawa Tengah. Prosiding
Seminar Nasional Teknik Elektro dan Informatika, 1(1), 50-54.
4. Handayani, S., Yulianto, S. H., & Kadir, W. G. A. (2015). Inversi pemodelan 3D data
gayaberat dan gaya magnet menggunakan metode iteratif pendekatan Newton pada wilayah
tambang Emas Martabe, Sumatera Utara. Jurnal Fisika Unand, 4(2), 32-39.
5. Tarantola, A. (2005). Inverse problem theory and methods for model parameter estimation.
Society for Industrial and Applied Mathematics.
6. Haber, E., & Hutchinson, R. (2013). Nonlinear inversion using general source priors.
Geophysical Journal International, 192(2), 563-575.
7. Zhang, H., & Han, D. (2016). A fast nonlinear inversion method based on iterative
reweighted L1-norm regularization for seismic data. Geophysics, 81(6), R411-R421.
LAMPIRAN

1. Script Problem 1

#Muhamad Arif Samsudin_120120158

#Modul4_problem1

import numpy as np
import matplotlib.pyplot as plt
import copy
from numpy.linalg import inv

#Start Position
x = [0, 10, 20, 30]
z = [0,0,0,0]
n = len(x)

#True Hiposenter
xo = 12
zo = 10
to = 0

#Velocity
v = 7

t = []
for i in range(n):
t.append((1/v)*np.sqrt((z[i]-zo)**2+(x[i]-xo)**2))

#Add noise
noise = np.random.rand()*0.03*np.mean(t) #kita makai 0.01 karna disoal ditambah
1% atau 0.01
ti = t + noise

#Guess the initial position

m = [50, 40] # 50, 40 #15,30
init_position = copy.deepcopy(m)
m1 = []

#Inversion with non linear method

xhipo=[init_position[0]]
yhipo=[init_position[1]]
erms=[]
for niter in range(4): #4 #7
gm=[]
dgm_dm1=[]
dgm_dm2=[]
 for i in range(n):
gm.append(to+(1/v)*(np.sqrt((x[i]-m[0])**2+(z[i]-m[1])**2)))
dgm_dm1.append((1/v)*(-1*(x[i]-m[0]))/(np.sqrt((x[i]-m[0])**2+(z[i]-
m[1])**2)))
dgm_dm2.append((1/v) * (-1*(z[i]-m[1]))/(np.sqrt((x[i]-m[0])**2 +(z[i]-
m[1])**2)))
j=np.zeros((n,2))
for i in range(n):

#Matriks jacobian, reshape adalah tadi matriksnya sejajar menjadi mendatar

j[i][0]=dgm_dm1[i]
j[i][1]=dgm_dm2[i]
mo=copy.deepcopy(m)
mo=np.reshape(mo,(2,1))
ti = np.reshape(ti, (n, 1))
gm = np.reshape(gm, (n, 1))
model=np.mat(mo)+np.mat(inv(np.mat(j.transpose())*np.mat(j)))*np.mat(j.transp
ose())*(np.mat(ti)-np.mat(gm))
m=[model[0][0],model[1][0]]
data =model.tolist()
xhipo.append(data[0][0])
yhipo.append(data[1][0])
dt=ti-gm
erms.append(np.sqrt(np.average(dt**2)))

plt.plot(m[0], m[1],'o',label='Initial Position', color='black') #2. ini ditambah

M[0] , M[1]
plt.plot(xhipo,yhipo,'o',label='Hypocenter Inversion')
plt.plot(xhipo,yhipo,label='Hypocenter Inversion')
plt.plot(xo,zo,'o', alpha=0.5,color='yellow', label='True Hypocenter')
plt.title('Hypocenter Determination_120120158')
plt.xlabel('X Coordinate')
plt.ylabel('Y Coordinate')
plt.legend()
plt.figure()
plt.plot(erms)
plt.title('Kurva RMS Error vs N Iterasi_120120158')
plt.ylabel('RMS Error')
plt.xlabel('N Iterasi')
plt.show()
 2. Script Problem 2

#Muhamad Arif Samsudin_120120158

#Modul4_problem2
import numpy as np
import copy
import matplotlib.pyplot as plt
from numpy.linalg import inv
# Hiposenter
x0 = 12
z0 = 10
t0 = 0
# Posisi Station
x = [0, 10, 20, 30]
z = [0, 0, 0, 0]
n = len(x)
# Model Kecepatan Gelombang 1 layer
Vp = 7
# forward modelling untuk menghitung travel time dari hyposenter ke station
t = []
for i in range(n):
t.append((1 / Vp) * np.sqrt((z[i] - z0) ** 2 + (x[i] - x0) ** 2))
# tambahkan noise pada travel time
noise = np.random.rand() * 0.01 * np.mean(t)
ti = t + noise
#tambahkan data outlier
ti[n-1] = ((1/Vp) * np.sqrt((z[n-1]- z0)**2 + (x[n-1]-x0)**2)) + np.random.rand()
* 0.5 * np.mean(t)
M = [50, 40] # tebakan awal posisi hiposenter
init_position = copy.deepcopy(M)
M1 = []
I = np.eye(2)
E = 0.1*I
xhipo = [init_position[0]]
yhipo = [init_position[1]]
Erms = []
#Menentukan minimum error
P = 10 #nilai tebakan minimum error
HypoX = []
HypoY = []
X0 = np.arange(0,50,1)
Y0 = np.arange(0,50,1)
#Iterasi 4
for niter in range(4):
gm = []
dgm_dm1 = []
dgm_dm2 = []
 for i in range(n):
gm.append(t0 + 1 / Vp * (np.sqrt((z[i] - M[1]) ** 2 + (x[i] - M[0])
**2)))
dgm_dm1.append((1 / Vp) * (-1 * (x[i] - M[0])) / (np.sqrt((z[i] - M[1])
** 2 + (x[i] - M[0]) ** 2)))
dgm_dm2.append((1 / Vp) * (-1 * (z[i] - M[1])) / (np.sqrt((z[i] - M[1])
** 2 + (x[i] - M[0]) ** 2)))
G = np.zeros((n, 2))
for i in range(n):
G[i][0] = dgm_dm1[i]
G[i][1] = dgm_dm2[i]
Mo = copy.deepcopy(M)
# tambah model pertubarsi dari inversi ke Mo
Mo = np.reshape(Mo, (2, 1))
ti = np.reshape(ti, (n, 1))
gm = np.reshape(gm, (n, 1))
Model = np.mat(Mo) + np.mat(inv(np.mat(G.transpose()) * np.mat(G) +
np.mat(E))) * np.mat(G.transpose()) * (np.mat(ti) - np.mat(gm))
M = [Model[0][0], Model[1][0]]
Data = Model.tolist()
xhipo.append(Data[0][0])
yhipo.append(Data[1][0])
# calculate rms eror
dt = ti - gm
Erms.append(np.sqrt(np.average(dt ** 2)))
Erms2 = np.sqrt(np.mean(dt**2))
for i in range (len(X0)):
for j in range(len(Y0)):
if Erms2 < P:
HypoX.append(X0[j])
HypoY.append(Y0[i])
P = Erms2
else: pass
plt.plot(12, 30, 'o', label='initial Position', color='black')
plt.plot(xhipo, yhipo, 'o', label='hyposenter inversion')
plt.plot(xhipo, yhipo, label='hyposenter inversion')
plt.plot(x0, z0, 'o', alpha=0.5, color='red', label='True Hypocenter')
plt.title('Hypocenter Determination_120120158')
plt.xlabel('X Coordinate')
plt.ylabel('Y coordinate')
plt.legend()
plt.figure()
plt.plot(Erms)
plt.title('Kurva RMS eror vs N Iterasi_120120158')
plt.xlabel('N Iterasi')
plt.ylabel(' RMS Eror')
plt.show()
 3. Script problem 3

#Muhamad Arif Samsudin_120120158

#LA04-Problem 3
import numpy as np
import matplotlib.pyplot as plt

# Step 1: Membuat forward modelling

n = 10
x = np.random.rand(n)*20
z = np.random.rand(n)*20
ti = np.random.rand(n)*2

v = 7 # kecepatan gelombang gempa

# Step 2: Menghitung grid search untuk plot minimum error

x_grid = np.linspace(0, 20, 100)
z_grid = np.linspace(0, 20, 100)
E_grid = np.zeros((100, 100))

for i, xi in enumerate(x_grid):
for j, zj in enumerate(z_grid):
tc = []
for k in range(n):
tc.append((1 / v) * np.sqrt((z[k] - zj) ** 2 + (x[k] - xi) ** 2))
E_grid[i, j] = np.sqrt(np.sum((ti - tc) ** 2))

x_min, z_min = np.unravel_index(E_grid.argmin(), E_grid.shape)

# Step 3: Menentukan tebakan awal

xo = x_grid[50]
zo = z_grid[40]
tc1 = []
for i in range(n):
tc1.append((1 / v) * np.sqrt((z[i] - zo) ** 2 + (x[i] - xo) ** 2))
E1 = np.sqrt(np.sum((ti - tc1) ** 2))

# Step 4: Mengeplot tiap iterasi

plt.figure()
plt.contourf(x_grid, z_grid, E_grid)
plt.colorbar()
plt.scatter(xo, zo, marker='*', color='Gold')
plt.xlabel('x (km)')
plt.ylabel('z (km)')
plt.title('Grid search for minimum error_120120158')
plt.show()
# Step 5: Menghitung random search
n_iter = 4
E = [E1]
xo_list = [xo]
zo_list = [zo]
for i in range(n_iter):
dx = np.random.rand() * 2 - 1
dz = np.random.rand() * 2 - 1
x_new = xo + dx
z_new = zo + dz
tc = []
for k in range(n):
tc.append((1 / v) * np.sqrt((z[k] - z_new) ** 2 + (x[k] - x_new) ** 2))
E_new = np.sqrt(np.sum((ti - tc) ** 2))
if E_new < E[-1]:
xo_list.append(x_new)
zo_list.append(z_new)
E.append(E_new)
xo = x_new
zo = z_new

# Step 6: Menghitung Tcalculated dan error

tc = []
for k in range(n):
tc.append((1 / v) * np.sqrt((z[k] - zo) ** 2 + (x[k] - xo) ** 2))
E_final = np.sqrt(np.sum((ti - tc) ** 2))

# Step 7: Mengeplot titik hiposenter dan Error

plt.figure()
plt.contourf(x_grid, z_grid, E_grid)
plt.colorbar()
plt.scatter(xo_list, zo_list, marker='x', color='red')
plt.plot(xo_list, zo_list, color='red')
plt.xlabel('x (km)')
plt.ylabel('z (km)')
plt.title('Inversion result')