Step 1: Konveksi linear 1-D

Konveksi linear 1-D adalah PDE paling sederhana yang bisa dipakai buat belajar fondasi CFD. Persamaan ini memodelkan gelombang yang merambat dengan kecepatan konstan tanpa berubah bentuk. Walaupun kelihatan remeh, hampir semua ide inti CFD — diskritisasi, time-stepping, stabilitas, numerical diffusion — udah muncul di sini.

Persamaan

$\frac{\partial u}{\partial t} + c \frac{\partial u}{\partial x} = 0$

Simbol	Arti	Analogi
$u (x, t)$	besaran yang diangkut (mis. konsentrasi)	tinggi air / asap di angin
$c$	kecepatan rambat (konstan)	kecepatan angin
$\partial u / \partial t$	laju perubahan di satu titik seiring waktu	"seberapa cepat berubah sambil gua diem nunggu"
$\partial u / \partial x$	kemiringan spasial	"beda gua dengan sensor sebelah"

Cara baca (disusun ulang): $\partial u / \partial t = - c \partial u / \partial x$ → perubahan terhadap waktu di suatu titik ditentukan oleh kemiringan spasial di titik itu, dikali kecepatan. Informasi datang dari arah hulu (upstream).

Solusi eksak

Dengan kondisi awal $u (x, 0) = u_{0} (x)$ :

$u (x, t) = u_{0} (x - c t)$

Artinya: bentuk awal digeser ke kanan sejauh $c t$ , tanpa berubah bentuk. Puncak yang awalnya di $x = 5$ pada waktu $t$ ada di $x = 5 + c t$ .

Solusi eksak ini penting sebagai alat verifikasi: kalau hasil numerik menyimpang, kita tahu itu salah metode, bukan salah fisika. (Konsep terkait: Method of Manufactured Solutions.)

Analogi: estafet bisik-bisik

Anak-anak berdiri sejajar, jarak antar anak = Δx.
Tiap ronde (Δt), pesan cuma boleh dibisikkan ke tetangga sebelah.

   o    o    o    o    o    o        ← sensor / titik grid
   |----|
     Δx

Gelombang lari dengan kecepatan c.
Dalam satu ronde, gelombang menempuh jarak c·Δt.

c·Δt ≤ Δx  → gelombang TIDAK menyalip pesan → simulasi aman
c·Δt > Δx  → gelombang menyalip → anak "ngarang" → MELEDAK

Diskritisasi

Komputer tidak mengerti turunan (konsep limit / jarak tak-hingga kecil). Yang dia punya cuma:

Grid ruang: titik $x_{i}$ , $i = 0 \dots N$ , jarak $Δ x$ → index array
Langkah waktu: foto ke- $n$ , selisih $Δ t$ → iterasi loop

Notasi $u_{i}^{n}$ = "nilai u di titik ke-i, pada langkah waktu ke-n" = u[i] pada iterasi ke-n. Superscript n bukan pangkat.

Mengganti turunan dengan pengurangan

Dari definisi turunan, buang limit-nya (justifikasi formal: Deret Taylor):

Turunan	Skema	Aproksimasi	Alasan pemilihan
$\partial u / \partial t$	Forward difference	$\frac{u_{i}^{n + 1} - u_{i}^{n}}{Δ t}$	kita mau maju ke masa depan
$\partial u / \partial x$	Backward difference	$\frac{u_{i}^{n} - u_{i - 1}^{n}}{Δ x}$	informasi datang dari kiri (hulu) → Skema Upwind

Persamaan diskrit

$\frac{u_{i}^{n + 1} - u_{i}^{n}}{Δ t} + c \frac{u_{i}^{n} - u_{i - 1}^{n}}{Δ x} = 0$

Satu-satunya yang tidak diketahui: $u_{i}^{n + 1}$ (masa depan). Pindah ruas:

$u_{i}^{n + 1} = u_{i}^{n} - c \frac{Δ t}{Δ x} (u_{i}^{n} - u_{i - 1}^{n})$

Bahasa manusia: nilai baru = nilai lama − koreksi berdasarkan selisih dengan tetangga kiri.

Paradigma: time-stepping / marching

state SEKARANG + ATURAN perubahan  →  state SEBENTAR LAGI
       ↑                                      |
       └────────────── ulangi ────────────────┘

frame 0 → frame 1 → frame 2 → frame 3 → ...

Paradigma yang sama dipakai di prakiraan cuaca, orbit satelit, molecular dynamics, dan physics engine game. Yang berbeda cuma aturannya (PDE-nya) dan ukuran grid-nya.

Peta lengkap dari fisika ke kode:

PDE (fisika)        = aturan alam
Finite difference   = terjemahan aturan → aritmetika array
Persamaan update    = resep: frame[n+1] = f(frame[n])
Loop time-stepping  = jalankan resep berulang
CFL                 = batas kecepatan biar tidak ngaco

Skema ini tipe explicit (masa depan dihitung langsung dari masa kini). Alternatifnya Metode Implicit — lebih mahal per langkah, tapi bebas batas CFL; relevan buat HPC karena explicit = embarrassingly parallel / GPU-friendly.

Implementasi

import numpy as np

nx = 81                    # jumlah titik grid
dx = 2 / (nx - 1)          # jarak antar titik
nt = 25                    # jumlah langkah waktu
dt = 0.02                  # ukuran langkah waktu (cek CFL!)
c  = 1.0                   # kecepatan gelombang

# kondisi awal: fungsi topi (hat function)
u = np.ones(nx)
u[int(0.5/dx):int(1/dx + 1)] = 2

for n in range(nt):
    un = u.copy()          # WAJIB: simpan state lama
    for i in range(1, nx):
        u[i] = un[i] - c * dt/dx * (un[i] - un[i-1])

Bug klasik pemula: lupa un = u.copy(). Semua titik harus di-update pakai nilai langkah n, bukan nilai yang setengah ter-update. Hasilnya sekilas mirip, tapi fisikanya salah.

Catatan gaya: jangan langsung di-vectorize. Nested loop dulu biar fisikanya kelihatan; vectorize (u[1:] = un[1:] - c*dt/dx*(un[1:] - un[:-1])) sebagai exercise terpisah + bahan benchmark loop vs vectorized vs numba.

Kondisi CFL (Courant–Friedrichs–Lewy)

$CFL = \frac{c Δ t}{Δ x} \leq 1$

CFL	Kondisi	Perilaku
≤ 1	gelombang menempuh ≤ 1 sel grid per langkah waktu	stabil
> 1	gelombang "menyalip" informasi grid	osilasi zigzag tumbuh eksponensial → meledak

Intuisi: informasi fisik tidak boleh lari lebih cepat daripada informasi numerik. Stabilitas ditentukan kombinasi c, Δt, dan Δx — bukan Δt sendirian. Pembuktian formal: Analisis von Neumann.

Numerical diffusion

Fenomena: sudut-sudut tajam gelombang kotak makin lama makin tumpul/melengkung, padahal solusi eksak bentuknya tetap.

Ini bukan bug — efek samping error truncation dari skema backward difference orde-1
Error-nya berperilaku seperti suku difusi (makanya disebut numerical diffusion)
Trade-off akurasi vs stabilitas adalah tema besar di CFD; skema orde tinggi mengurangi ini tapi bawa masalah lain
Detail: Numerical Diffusion, Error Truncation

Kertas vs komputer

Pembagian kerja di scientific computing:

Kerjaan komputer	Kerjaan kertas (tidak bisa di-outsource)
menghitung solusi PDE (menjalankan resep)	menurunkan resep update dari Taylor series
menjalankan jutaan iterasi	analisis stabilitas (von Neumann → dari mana CFL ≤ 1)
	verifikasi kode via solusi eksak
	debugging fisika: "bug di kode, atau memang perilaku matematisnya?"

Analogi: kertas itu posisinya kayak assembly buat programmer Rust — bukan tempat produksi, tapi tempat memahami dan mendiagnosis. Porsi realistis: ~90% ngoding, ~10% coret-coretan, tapi 10% itu yang membedakan "bisa menjalankan notebook" dari "mengerti CFD".

Checklist penguasaan

[x] Paham arti fisik persamaan konveksi (aturan estafet)
[x] Paham solusi eksak u₀(x − ct) dan fungsinya sebagai alat verifikasi
[x] Paham notasi u_i^n (i = index ruang, n = index waktu)
[x] Bisa menurunkan persamaan update dari persamaan diskrit
[x] Paham intuisi CFL (gelombang vs kecepatan informasi grid)
[x] Paham numerical diffusion itu bukan bug
[ ] Implement Step 1 sendiri di NumPy (tanpa lihat notebook)
[ ] Reproduce ledakan CFL di matplotlib (coba CFL = 1.1)
[ ] Eksperimen: plot hasil pada CFL = 0.5 vs 0.9 vs 1.0 — bandingkan ketumpulan sudut
[ ] Vectorize loop + benchmark vs nested loop
[ ] Bonus: turunkan sendiri forward difference dari ekspansi Taylor