PDE diatas dapat diubah menjadi bentuk seperti berikut.

𝜕 2𝑐 𝑐𝑖+1,𝑗 + 𝑐𝑖−1,𝑗 − 2 ∙ 𝑐𝑖,𝑗

2
≈
𝜕𝑥 (∆𝑥)2
𝜕 2𝑐 𝑐𝑖,𝑗+1 + 𝑐𝑖,𝑗−1 − 2 ∙ 𝑐𝑖,𝑗
2
≈
𝜕𝑦 (∆𝑦)2
Setelah kedua persamaan diatas di olah dan dimanipulasi menjadi persamaan berikut, dengan
∆𝑥 = ∆𝑦
𝑘 ∙ (∆𝑥)2
𝑐𝑖+1,𝑗 + 𝑐𝑖−1,𝑗 + 𝑐𝑖,𝑗+1 + 𝑐𝑖,𝑗−1 + (−1) (4 + ) ∙ 𝑐𝑖,𝑗 = 0
𝐷

Persamaan diatas berlaku juga pada tembok di soal, namun node pada tembok tidak memiliki 4
buah node tetangga, node pada tembok hanya memiliki kurang dari 4 yaitu 2 atau 3 node
tetangga maka persamaan yang dibentuk akan disesuaikan dengan posisi node. Persamaan
diatas perlu dibuat menjadi persamaan linear dalam bentuk matriks [K]{c} = {R}. Matriks [K] berisi
koefisien node konsentrasi yang belum diketahui dan matriks {R} berisi matriks hasil yang didapat
dari kondisi batas. Jika persamaan matriks ini diselesaikan akan didapat nilai matriks {c}, lalu
konsentrasi tiap node akan ditampilkan pada sebuah grafik kontur.
Untuk memetakan node dua dimensi kepada baris di matriks [K], {𝑐}, dan {R}, diperlukan
fungsi yang dinamai map_grid:

def map_grid(Ny, Nw, i, j):

# INPUT
# Ny: jumlah grid komputasi pada arah y
# Nw: indeks sumbu-x ujung tembok bawah
# i dan j: posisi grid
# OUTPUT
# index: indeks grid komputasi untuk menandakan
# baris matriks [K], {c}, dan {R}.
if (i >= Nw and j > 0):
# Untuk grid di atas batas terbuka bawah
assert j != 0
index = Ny * (i - 1) + j - (i + 1 - Nw)
else:
index = Ny * (i - 1) + j
return index
def main():
# Tes kebenaran fungsi map_grid
Ny = 6
Nw = 10
i = 15
j=3
print(map_grid(Ny, Nw, i, j))
if __name__ == '__main__':
main()

Distribusi konsentrasi dihitung menggunakan program berikut:

def main():
# Program ini akan menyelesaikan distribusi
# konsentrasi fluida pada tangki.

# Impor library yang dibutuhkan

from map_grid import map_grid
import numpy as np
import matplotlib.pyplot as plt
# Inisialisasi variabel yang dibutuhkan
# Konsentrasi pada batas terbuka kiri dan kanan bawah
cl = float (40)
cb = float (100)
D = 0.5
k = 0.1
# Dimensi
h = float (10)
l = float (30)
e = float (10)
# Input delta_x. Pada program ini delta_x = delta_y.
dx = 0.4
# Jumlah node ada 2: node total dan node komputasi.
# Jumlah node total total
Nx = int (1 + l / dx)
Ny = int (1 + h / dx)
Ng = int (Nx * Ny)
Nw = int ((l - e) / dx)
# Node komputasi
Nc = int ((Nx - 1) * Ny - (1 + e / dx))
# Konsentrasi c pada titik (x,y) akan dihitung
# dengan menyelesaikan matriks [K]{c} = {R}.
# Inisialisasi matriks:
K = np.zeros([Nc, Nc])
R = np.zeros(Nc)
coeff = float(-1 * (4 + k * dx**2 / D))
# Isi matriks [K] dan {c}
imax = int(Nx - 1)
jmax = int(Ny - 1)
i=1
k=0
while (i < Nx):
j=0
while (j < Ny):
if (i >= Nw and j == 0):
# Node pada batas terbuka bawah dilewat
j += 1
continue
K [k, map_grid(Ny, Nw, i, j)] = coeff
if i == 1:
# Node ada tepat di sebelah kanan batas terbuka kiri
R[k] = float (-1 * cl)
if (j == 0):
# Node di tembok bawah
K [k, map_grid(Ny, Nw, i+1, j)] = float(1)
K [k, map_grid(Ny, Nw, i, j+1)] = float(2)
# Nilai koefisien sama dengan 2 karena kondisi batas
elif (j == jmax):
# Node di tembok atas
K [k, map_grid(Ny, Nw, i, j-1)] = float(2)
K [k, map_grid(Ny, Nw, i+1, j)] = float(1)
else:
# Node lainnya
K [k, map_grid(Ny, Nw, i, j+1)] = float(1)
K [k, map_grid(Ny, Nw, i, j-1)] = float(1)
K [k, map_grid(Ny, Nw, i+1, j)] = float(1)
elif (j == 0 and i < Nw):
# Node ada di tembok bawah, tetapi tidak di batas terbuka
kanan
K [k, map_grid(Ny, Nw, i-1, j)] = float(1)
K [k, map_grid(Ny, Nw, i+1, j)] = float(1)
K [k, map_grid(Ny, Nw, i, j+1)] = float(2)
elif (i == imax and j > 0):
# Node ada di tembok kanan
if (j == 1):
# Node di atas batas terbuka
R[k] = float (-1 * cb)
K [k, map_grid(Ny, Nw, i-1, j)] = float(2)
K [k, map_grid(Ny, Nw, i, j+1)] = float(1)
elif (j == jmax):
# Node di pojok
K [k, map_grid(Ny, Nw, i-1, j)] = float(2)
K [k, map_grid(Ny, Nw, i, j-1)] = float(2)
else:
# Node lainnya
K [k, map_grid(Ny, Nw, i, j+1)] = float(1)
 K [k, map_grid(Ny, Nw, i, j-1)] = float(1)
K [k, map_grid(Ny, Nw, i-1, j)] = float(2)
elif (i >= Nw and j == 1):
# Node di atas batas terbuka bawah
R [k] = float (-1 * cb)
K [k, map_grid(Ny, Nw, i-1, j)] = float(1)
K [k, map_grid(Ny, Nw, i+1, j)] = float(1)
K [k, map_grid(Ny, Nw, i, j+1)] = float(1)
else:
# Node lainnya
if (j == jmax):
# Node di tembok atas
K [k, map_grid(Ny, Nw, i-1, j)] = float(1)
K [k, map_grid(Ny, Nw, i+1, j)] = float(1)
K [k, map_grid(Ny, Nw, i, j-1)] = float(2)
else:
# Node sisanya
K [k, map_grid(Ny, Nw, i-1, j)] = float(1)
K [k, map_grid(Ny, Nw, i+1, j)] = float(1)
K [k, map_grid(Ny, Nw, i, j-1)] = float(1)
K [k, map_grid(Ny, Nw, i, j+1)] = float(1)
j += 1
k += 1
i += 1
# Hitung konsentrasi c pada grid-grid komputasi
c = np.linalg.solve (K, R)
# Cek kebenaran jawaban
for i in range(Nc):
assert c[i] >= 0
check = np.allclose(np.dot(K, c), R)
assert check == True
# Masukkan konsentrasi hasil perhitungan ke matriks konsentrasi
c_show = np.zeros([Nx, Ny])
i=0
while (i < Nx):
j=0
while (j < Ny):
 if (i == 0):
# Masukkan konsentrasi di batas terbuka kiri
c_show[i,j] = cl
elif (j == 0 and i >= Nw):
# Masukkan konsentrasi di batas terbuka kanan bawah
c_show[i,j] = cb
else:
# Konsentrasi hasil perhitungan
c_show[i,j] = c[map_grid(Ny, Nw, i, j)]
j += 1
i += 1
# Matriks ditranspos agar sumbu x dan y sesuai
c_show = np.transpose(c_show)

# Plot kontur
plt.figure ()
CS = plt.contourf (c_show, 30)
plt.title ("Kontur Konsentrasi Cairan pada Tangki")
plt.colorbar ()
plt.axis ("equal")
plt.xlabel ('x')
plt.xticks(np.linspace (0, imax, 16),
np.linspace (0.0, l, 16))
plt.ylabel ('y')
plt.yticks (np.linspace(0, jmax, 6),
np.linspace (0.0, h, 6))
plt.show ()
main ()
Tetapi bila ∆𝑥 diperkecil menjadi 0.2, program memberikan pesan bahwa jawaban yang
didapatkan tidak benar. Hal ini kemungkinan terjadi karena round-off error saat menyelesaikan
persamaan matriks.
Jadi kesimpulan yang dapat diambil adalah secara umum, semakin kecil ∆𝑥 maka kontur yang
didapat semakin halus.
Bahasa pemrograman : Matlab