LAPORAN PRAKTIKUM

INVERSI GEOFISIKA TG 3004

MODUL KE – 02
INVERSI LINEAR MENGGUNAKAN BOBOT
Oleh:

Mutiara Islamia (118120080)

Asisten :
Wahyu Eko Junian
Lestari Sukma Apriliana
Dwinda Aldatri
Mustika
Rury Delvatiwi Martianda
Yola Wulanda Masri

PROGRAM STUDI TEKNIK GEOFISIKA

JURUSAN TEKNOLOGI PRODUKSI DAN INDUSTRI

INSTITUT TEKNOLOGI SUMATERA

2020/2021
I. Tujuan Praktikum:
Mampu mendemonstrasikan pengaruh ketidak pastian data pada solusi inversi linier dan
ketidakpastian solusi pada inversi linier.
II. Dasar teori
Metode inversi yang baik hendaknya dapat memperhitungkan kesalahan data atau
ketelitian data dalam proses penyelesaian inversi. Dengan demikian solusi yang diperoleh
secar objektif sesuai dengan kualitas data. Umumnya pengaruh data dengan kesalahan
cukup besar (atau tingkat ketelitian rendah). Harus diminimumkan agar hasil inversinya
merupakan representasi data dengan tingkat ketelitian yang baik. Hal tersebut dapat
dilakukan melalui pemboboan data dalam penyelesaian masalah inversi.
Pada dasarnya kita dapat memberikan bobot relatif pada data sedemikian hingga
data dengan kesalahan besar tidak akan berpengaruhpada solusi inversi. Dengan kata lain,
solusi inversi akan lebih ditentukan oleh data yang berkualitas baik. Faktor pembobot data
ke-i atau wi dimasukkan pada perhitungan kesalahan kuadratik sehingga diperoleh:

Jika data dianggap memiliki kesalahan cukup besar maka diberi bobot kecil agar kontribusi
pada penjumlahan tidak terlau signifikan. Jika informasi mengenai tingkat ketelitian data
tersedia lebih lengkap maka pembobotan dapat dilakukan dengan mengacu pada tingkat
ketelitian data tersebut dan tidak bersifat subjektif dengan menggunakan harga ekstrim.
Pemberian bobot secara objektif dapat dilakukan dengan menggunakan standar
deviasi data sebagai bobot sehingga persamaan menjadi.

Dalam hal ini wi = σi-2 adalah kuadrat dari standar deviasi atau variansi. Data dengan
ketelitian rendah memiliki standar deviasi yang besar sehingga bobotnya kecil dan
sebaliknya data dengan ketelitian tinggi memiliki standar deviasi sehingga bobotnya besar.
Penggunaan standar deviasi sebagai bobot juga dapat diartikan bahwa data yang
tidak terlalu akurat (dengan standar deviasi cukup besar) akan memberikan toleransi yang
juga cukup besar pada prediksi dcal untuk dianggap cocok dengan data hasil pengamatan.
Demikian pula sebaliknya, perbedaan kecil antara data perhitungan dengan data
pengamatan yang cukup teliti (dengan standar deviasi kecil ) akan memberikan konstribusi
cukup besar pada perhitungan kesalahan kuadratik total yang harus diminimumkan. Oleh
karen aitu harus dicari model yang respon nya sangat dekat dengan data yang yang cukup
teliti tersebut agar mengahsilkan kesalahan total minimun.
Secara lebih umum pembobotan data dapat dinyatakan dalam bentuk matriks.
Dalam notasi matriks dapat dituliskan sebagai berikut :

Pada kasus pembobotan subyejtif sebagaimana dicontohkan doatas atau pembobotan

menggunakan standar deviasi data maka matriks We adalah matriks diagonal dengana
elemen dioagonal berisi [wi ]=[ σi-2 ] seingga lengkap matriks We adalah :

Untuk kasus lebih umum maka We bukan berbentuk matriks diagonal, namun We = Cd-1
dimana Cd disebut sebagai matriks ko-variansi (covaiance) dengan elemen – elemen
sebagai berikut :

Ko-variansi adalah fungsi dari variansi masing – masing data dan koefiensi korelasi
yang menyatakan keterkaitan antara satu data dengan lainnya jika i = j makan
elemen diagonal matriks Cd adalah variansi data ke-i atau cii = σi2 .
Solusi permasalahan inversi linera dengan pembobotan data dapat diperoleh
dengan cara sam aseperti pada penurunan persamaan dan dapat
dibuktikan bahwa hasilnya adalah sebagai berikut :

Pada umumnya untuk menyederhanakan masalah maka data dianggap tidak terkorelasi satu
dengan yang lainnya atau independen sehingga matriks pembobotan We adalah matriks
diagonal dengan elemen diagonal adalah variansi data. Inversi linear dengan pembobtan
 data sangat umum digunakan untuk memperoleh solusi optimal. Metode inversi linear
berbobot sering sebagai weighted linear inversion.
III. Langkah Pengerjaan
1. Buka python atau google collab.
2. Tulis script problem 1 untuk Melakukan perhitungan inversi linear berbobot versus
non berbobot (forward modeling)
3. input data yang digunakan
4. Input rumus yang akan digunakan
5. Ketik print yang nantinya akan menampilkan hasil run
6. jika sudah selesai klik kanan dan cari tulisan RUN.
7. Setelah mucul hasilnya, screenshoot hasil dan analisis.
8. Jika sudah semuah ulangi tahap-tahap diatas pada percobaan problem 2 untuk
Melakukan perhitungan non berbobot dan berbobot. problem 3 untuk Melakukan
perhitungan inversi Aplikasi Inversi Linear Berbobot pada Tomografi Seismik.
Diagram alir

Mulai

Input
modul

Input
data

Mengubah data ke bentuk

matriks

Melakukan
perhitungan inversi

Plot hasil

selesai
 IV. Hasil dan Pembahasan
Problem 1 :

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

#Generated data dummy(misal data kedalaman)

N=20
Zmin=0
Zmax=10
Z=np.sort(np.random.uniform(Zmin,Zmax,N))

#generated data observasi, misal data temparatur Tobs=a+b*Z+noise

a=2
b=2
sd=0.5
Tobs = a+b*Z+np.random.normal(0,sd,N)

#create outlier data

Tobs[N-1] = 1

#create weighted matrix:subjective

w=np.eye(N)
w[N-1][N-1] =0.1

#bobot=0.01
#for i in range(N):
#w[i][i]=bobot

#create matriks kernel

G=np.zeros((N,2))
for i in range(N):
G[i][0]=1
G[i][1]=Z[i]

#print(w)
d=np.reshape(Tobs,(N,1))

#calculate model estimation with weighted scheme

m=np.mat(inv(np.mat(G.transpose())*np.mat(w)*np.mat(G)))*np.mat(G.transpose())*np
.mat(w)*np.mat(d)
m=m.tolist()
b0=m[0][0]
b1=m[1][0]

inv_weighted=[]
for i in range(len(Z)):
inv_weighted.append(b0+b1*Z[i])

#calculate model estimation without weighted scheme

m2=np.mat(inv(np.mat(G.transpose()) * np.mat(G))) * np.mat(G.transpose()) * np.ma
t(d)
m2=m2.tolist()
a0=m2[0][0]
a1=m2[1][0]

inv_without_weighted=[]
for i in range(len(Z)):
inv_without_weighted.append(a0+a1*Z[i])

#calculate misfit data with and without weighted

E=np.mat(np.transpose(np.reshape(inv_weighted, (N,1))-
d))*np.mat(w)*np.mat(np.reshape(inv_weighted,(N,1))-d)
E1=np.mat(np.transpose(np.reshape(inv_weighted, (N,1))-
d))*np.mat(np.reshape(inv_weighted,(N,1))-d)

print('Misfit with weighted :', E)

print('Misfit without weighted : ', E1)
plt.plot(Z, Tobs, '*r')
plt.plot(Z, inv_weighted, label='weighted')
plt.plot(Z, inv_without_weighted, label='without weighted')
plt.title('inversi linear berbobot vs non bobot')
plt.ylabel('temp(C)')
plt.xlabel('Depth(km)')
plt.legend()
plt.grid()
plt.show()
import matplotlib as mpl
mpl.rcParams['figure.dpi']=150
output :

Problem 2 (dengan bobot) :

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

# Station Position
x = [8, 10, 15, 20]
z = [0, 0, 0, 0]
n = len(x)

# Hiposenter
x0 = 15
z0 = 12
t0 = 0

# Model Kecepatan Gelombang 1 layer

v = 7

# Forward modelling untuk menghitung travel time dari hiposenter ke station

t = []
for i in range (n):
t.append((1/v) * np.sqrt((z[i]- z0)**2 + (x[i] - x0)**2 ))
# Tambahkan noise pada travel time
noise = np.random.rand() * 0.03 * np.mean(t)
ti = t + noise

# Tambahkan data outlier

ti[n-1] = ((1/v) * np.sqrt((z[n-1]- z0)**2 + (x[n-
1] - x0)**2 )) + np.random.rand() * 0.5 * np.mean(t)

# tebakan awal posisi hiposenter

M = [15, 30]
init_position = copy.deepcopy(M)
M1 = []

# Buat Matriks Bobot

W = np.eye(n)

# Menetapkan matrik bobot

W [n-1][n-1] = 0.1

print(W)

xhipo = [init_position[0]]
yhipo = [init_position[1]]
Erms = []

# Inversi Tanpa Bobot Faktor

for niter in range(1000):
gm = []
dgm_dm1 = []
dgm_dm2 = []
for i in range(n):
gm.append(t0 + (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((z[i] - M[1]) ** 2 + (x[i] - M[0]) ** 2)))
dgm_dm2.append((1 / v) * (-
1 * (z[i] - M[1])) / (np.sqrt((z[i] - M[1]) ** 2 + (x[i] - M[0]) ** 2)))

J = np.zeros((n, 2))
for i in range(n):
J[i][0] = dgm_dm1[i]
J[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(J.transpose())*np.mat(W) *np.mat(J)))
* np.mat(J.transpose())*np.mat(W) * (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])

# Menghitung rms error

dt = ti - gm
Erms.append(np.sqrt(np.average(dt**2)))

plt.plot(15, 30, 'o', label = 'initial position', color ='black')

plt.plot(xhipo , yhipo ,'o', label = 'Hypocenter Inversion')
plt.plot(xhipo , yhipo , label = 'Hypocenter Inversion')
plt.plot(x0, z0, 'o',alpha = 0.5, color = 'red', label='true hypocenter')
plt.title('Hypocenter Determination(With Weighted)')
plt.xlabel('x koordinat')
plt.ylabel('z koordinat')
plt.legend()
plt.figure()

plt.show()

output :
Problem 2 (tanpa bobot) :

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

# Station Position
x = [8, 10, 15, 20]
z = [0, 0, 0, 0]
n = len(x)

# Hiposenter
x0 = 15
z0 = 12
t0 = 0

# Model Kecepatan Gelombang 1 layer

v = 7

# Forward modelling untuk menghitung travel time dari hiposenter ke station

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

# Tambahkan noise pada travel time

noise = np.random.rand() * 0.03 * np.mean(t)
ti = t + noise

# Tambahkan data outlier

ti[n-1] = ((1/v) * np.sqrt((z[n-1]- z0)**2 + (x[n-
1] - x0)**2 )) + np.random.rand() * 0.5 * np.mean(t)

# tebakan awal posisi hiposenter

M = [15, 30]
init_position = copy.deepcopy(M)
M1 = []

# Buat Matriks Bobot

W = np.eye(n)

# Menetapkan matrik bobot

W [n-1][n-1] = 0.1

print(W)

xhipo = [init_position[0]]
yhipo = [init_position[1]]
Erms = []

# Inversi Tanpa Bobot Faktor

for niter in range(1000):
gm = []
dgm_dm1 = []
dgm_dm2 = []
for i in range(n):
gm.append(t0 + (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((z[i] - M[1]) ** 2 + (x[i] - M[0]) ** 2)))
dgm_dm2.append((1 / v) * (-
1 * (z[i] - M[1])) / (np.sqrt((z[i] - M[1]) ** 2 + (x[i] - M[0]) ** 2)))

J = np.zeros((n, 2))
for i in range(n):
J[i][0] = dgm_dm1[i]
J[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(J.transpose())*np.mat(W) *np.mat(J)))
* np.mat(J.transpose())*np.mat(W) * (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])

# Menghitung rms error

dt = ti - gm
Erms.append(np.sqrt(np.average(dt**2)))

plt.plot(15, 30, 'o', label = 'initial position', color ='black')

plt.plot(xhipo , yhipo ,'o', label = 'Hypocenter Inversion')
plt.plot(xhipo , yhipo , label = 'Hypocenter Inversion')
plt.plot(x0, z0, 'o',alpha = 0.5, color = 'red', label='true hypocenter')
plt.title('Hypocenter Determination(Without Weighted)')
plt.xlabel('x koordinat')
plt.ylabel('z koordinat')
plt.legend()
plt.figure()

plt.show()

output :

Problem 3 :

Script :

import matplotlib.pyplot as plt

import numpy as np
from numpy.linalg import inv

r1=2000; r2=-1000
s1a=0; s1b=-250; s2a=0; s2b=-663; s3a=1000; s3b=0

t1=1.580
t2=1.480
t3=1.160 #0.780 + 0.380

#mencari nilai l
l1=((r1-s1a)**2+(r2-s1b)**2)**0.5
l2=((r1-s2a)**2+(r2-s2b)**2)**0.5
l3=((r1-s3a)**2+(r2-s3b)**2)**0.5

#print(l1,l2,l3)
la=l1/2
lb=l2/2
lc=l3

#print(la,lb,lc)
#mencari V0
v0=((l1/t1)+(l2/t2)+(l3/t3))/3

#print(v0)
#menghitung Tc
tc1=l1/v0
tc2=l2/v0
tc3=l3/v0

#print(tc1,tc2,tc3)
#menghitungde delay time
d1=t1-tc1
d2=t2-tc2
d3=t3-tc3

#print(d1,d2,d3)
z=[la,lb,lc]
z1=[la,lb,0]
t=[d1,d2,d3]

G=np.zeros((len(z),2))

for i in range (3):

G[i,0] = z1[i]
G[i,1] = z[i]

#membuat pembobotan
w=np.identity(len(z))
bobot =0.313
w1=w*1/(bobot**2)
print ('matriks bobot: ')
print (w1)

d = np.reshape(t,(3,1))

m=np.mat(inv(np.mat(G.transpose())*np.mat(w)*np.mat(G)))*np.mat(G.transpose())*np
.mat(w)*np.mat(d)
m = m.tolist()

a0 = m[0][0]
a1 = m[1][0]

#print(a0,a1)
#menghitung nilai delta v

dv1=-a0*((v0)**2)
dv2=-a1*((v0)**2)

#print(dv1,dv2)
#nilai travel time

V1=v0+dv1
V2=v0+dv2

print('nilai V1: ',V1)

print('nilai V2: ',V2)

output

perhitungan software
perhitungan manual
Pembahasan :

Pada pratikum ini kita melakukan percobaan untuk menampilkan grafik inversi
linear menggunakan bobot. Penggunaan bobot ini berfungsi untuk mengurangi pengaruh
dari oulier pada hasil inversi. Pada script pertama didapatkan grafik inversi berbobot vs
tanpa bobot. Pada hasil, dapat dilihat sebaran data ketika diberi pembobotan mendapatkan
misfit yang kecil atau error yang kecil sehingga data yang dihasilkan mendekati data yang
sebenanrnya. Sedangkan untuk data yang tanpa pembobotan mengahsilkan nilai misfit yang
besar. Pada percobaan ini jika kita mengulang – ulang compile pada pyhthon akan
mengahasilkan misfit yang berbeda-beda hal ini dikarenakan pengaruh dari error nya dan
untuk mengahsilkan misfit ini menggunakan metode trial error atau coba-coba.

Pada percobaan kedua dilakukan percobaan untuk mendapatkan grafik inversi

hiposesenter gempa. Disini kita dapat menghitung nilai waktu tempuh. Bentuk grafik
tersebut juga dihasilkan dari penginputan nilai x0,zo,to,x dan z. dapat dilihat titik merah di
grafik merupakan titik true hiposenternya, posisi titik true hiposenter dipengaruhi oleh
penginputan x nya dan garis warna kuning merupakan garis hasil dari hiposenternya. Pada
percobaan kedua ini digunakan inversi berbobot dan tidak berbobot. Pada output tersebut
ditampilkan jika menggunakan inversi berbobot gambarnya jaraknya lebih pendek
daripada tanpa bobot. Percobaan ini juga mengahasilkan misfit yang tetap karena adanya
pengaruh inputan iterasi pada script sehingga grafik yang ditampilkan tidak berubah – ubah
seperti percobaan pertama.

Pada percobaan ketiga dilakukan percobaan untuk mendapatkan nilai matriks

tomografi, hasil yang diperoleh merupakan perbedaan kecepatan gelombang seismik pada
lapisan satu dan dua. Lapisan pertama memiliki kecepatan 1506.2005094033739 m/s dan
lapisan kedua senilai 1211.7987217160792 m/s. Pada perhitungan tomografi seismic
dengan menggunakan bobot, didapatkan hasil yang tidak jauh dengan perhitungan analitik.
Pada hasil ini didapat kecepatan V1 sebesar 1121,156735 dan V2 sebesar 1203,645698. Hal
ini dimungkinkan adanya kesalahan perhitungan pada anlitik.
V. Kesimpulan
Kesimpulan dari pratikum ini yaitu :
1. kesalahan cukup besar (atau tingkat ketelitian rendah) harus diminimumkan agar
hasil inversi merupakan representasi data dengan tingkat ketelitian yang baik. Hal
tersebut dapat dilakukan melalui pemboboan data dalam penyelesaian masalah
inversi.
2. Dapat menghitung kecepatan awal sebuah benda pada suatu planet, aplikasi regresi
pada Analisa data seismic refraksi, dan menenntukan nilai kecepatan gelombang
seismic dari data-data yang kita peroleh dari observasi. Menngunakan pemboboan
data dalam penyelesaian masalah inversi.

DAFTAR PUSTAKA
Grandis, Hendra., Pengantar Pemodelan Inversi, (2009),Himpunan Ahli Geofisika Indonesia
(HAGI).
Kurniawan, D. 2008. Regresi Linear (Linear Regression). R Foundation for Statistical
computing
Tim Penyusun Modul Pratikum Inversi.2021.Inversi Linear Menggunakan bobot.ITERA
LAMPIRAN