BAB 25: PERSAMAAN DIFERENSIAL BIASA (ODE)

 

BAB 25: PERSAMAAN DIFERENSIAL BIASA (ODE)

 

A.    Konsep Dasar ODE

1.     Definisi ODE

a.     ODE (Ordinary Differential Equation) adalah persamaan yang melibatkan fungsi dan turunan-turunannya terhadap satu variabel bebas (biasanya waktu t)

b.     Contoh: dV/dt = -(1/RC)V — pengisian kapasitor

c.     Orde ODE = turunan tertinggi yang muncul (orde-1, orde-2, dst)

d.     Solusi ODE adalah fungsi yang memenuhi persamaan tersebut

e.     Banyak fenomena fisika dan elektronika dimodelkan dengan ODE

2.     Mengapa ODE Penting dalam Elektronika?

a.     Rangkaian RC, RL, RLC dimodelkan dengan ODE

b.     Osilator, filter, dan sistem kontrol dimodelkan dengan ODE

c.     Respons transien dan steady-state dianalisis dengan ODE

d.     Desain sistem kontrol (PID) melibatkan ODE

e.     Simulasi rangkaian (SPICE) menyelesaikan ODE secara numerik

3.     ODE Orde-1 vs Orde-2

a.     Orde-1: dV/dt = f(V,t) — hanya melibatkan turunan pertama

b.     Orde-2: d²V/dt² = f(V, dV/dt, t) — melibatkan turunan kedua

c.     Orde-2 dapat diubah menjadi dua ODE orde-1 (state-space)

d.     Contoh orde-1: rangkaian RC, RL

e.     Contoh orde-2: rangkaian RLC, osilator

4.     Solusi Analitik vs Numerik

a.     Solusi analitik: ekspresi matematika eksak (jika ada)

b.     Solusi numerik: pendekatan menggunakan komputasi

c.     Banyak ODE tidak memiliki solusi analitik

d.     Solusi numerik selalu berupa pendekatan

e.     Aplikasi: simulasi sistem non-linear (misal: rangkaian dengan dioda)

B.    Metode Euler

1.     Prinsip Metode Euler

a.     Metode Euler adalah metode paling sederhana untuk menyelesaikan ODE

b.     Prinsip: y(t+h) = y(t) + h × f(y(t), t)

c.     h = step size (langkah waktu)

d.     Semakin kecil h, semakin akurat hasilnya

e.     Error: O(h) (error sebanding dengan step size)

2.     Algoritma Metode Euler

a.     Tentukan kondisi awal y(t₀) = y₀

b.     Untuk setiap langkah: y_{n+1} = y_n + h × f(y_n, t_n)

c.     t_{n+1} = t_n + h

d.     Ulangi hingga t mencapai t_akhir

e.     Contoh kode Python: def euler(f, y0, t0, tf, h): ...

3.     Contoh: Simulasi Pengisian Kapasitor (RC)

a.     Persamaan: dV/dt = (V_s - V) / (R × C)

b.     Kondisi awal: V(0) = 0V

c.     Solusi analitik: V(t) = V_s × (1 - e^(-t/RC))

d.     Metode Euler: V_{n+1} = V_n + h × (V_s - V_n)/(R×C)

e.     Perbandingan dengan solusi analitik

4.     Kelemahan Metode Euler

a.     Error akumulasi: error bertambah seiring waktu

b.     Membutuhkan step size sangat kecil untuk akurasi yang baik

c.     Tidak stabil untuk ODE "stiff" (sistem yang cepat berubah)

d.     Tidak cocok untuk simulasi jangka Panjang

e.     Solusi: metode yang lebih akurat (Runge-Kutta)

C.    Metode Runge-Kutta Orde 2 (Heun)

1.     Prinsip Metode Heun

a.     Metode Heun (RK2) menggunakan dua evaluasi fungsi per Langkah

b.     Prinsip: koreksi terhadap prediksi Euler

c.     Error: O(h²) (lebih akurat dari Euler)

d.     Juga disebut sebagai "Modified Euler"

e.     Trade-off: lebih akurat tetapi lebih lambat (2× evaluasi)

2.     Algoritma Metode Heun

a.     k₁ = f(y_n, t_n) — prediksi Euler

b.     k₂ = f(y_n + h·k₁, t_n + h) — koreksi

c.     y_{n+1} = y_n + (h/2) × (k₁ + k₂)

d.     t_{n+1} = t_n + h

e.     Contoh: simulasi rangkaian RC dengan akurasi lebih baik

3.     Perbandingan Euler vs Heun

a.     Euler: error O(h)

b.     Heun: error O(h²)

c.     Heun 10× lebih akurat untuk step size yang sama

d.     Heun stabil untuk step size yang lebih besar

e.     Contoh: simulasi osilasi dengan RK2 (lebih stabil)

D.    Metode Runge-Kutta Orde 4 (RK4)

1.     Prinsip Metode RK4

a.     RK4 menggunakan 4 evaluasi fungsi per Langkah

b.     Error: O(h⁴) (sangat akurat)

c.     Metode paling populer untuk simulasi ODE

d.     Trade-off: lebih lambat (4× evaluasi dari Euler)

e.     Standar: digunakan di MATLAB, Python (scipy.integrate.solve_ivp)

2.     Algoritma Metode RK4

a.     k₁ = f(y_n, t_n)

b.     k₂ = f(y_n + (h/2)·k₁, t_n + h/2)

c.     k₃ = f(y_n + (h/2)·k₂, t_n + h/2)

d.     k₄ = f(y_n + h·k₃, t_n + h)

e.     y_{n+1} = y_n + (h/6) × (k₁ + 2k₂ + 2k₃ + k₄)

f.      t_{n+1} = t_n + h

3.     Keunggulan RK4

a.     Akurasi sangat tinggi (error ∝ h⁴)

b.     Stabil untuk berbagai jenis ODE

c.     Dapat menggunakan step size yang lebih besar

d.     Implementasi relatif sederhana

e.     Standar dalam library numerik (scipy, MATLAB)

4.     Contoh: Simulasi Osilator RLC

a.     Persamaan RLC: d²V/dt² + (R/L)dV/dt + (1/LC)V = 0

b.     Ubah menjadi 2 ODE orde-1: dV/dt = I/C, dI/dt = -V/L - R·I/L

c.     Kondisi awal: V(0) = V₀, I(0) = 0

d.     RK4 untuk menyelesaikan sistem

e.     Perbandingan dengan solusi analitik (underdamped, overdamped)

E.    Kestabilan Solusi

1.     Definisi Kestabilan Numerik

a.     Solusi numerik stabil jika error tidak membesar seiring waktu

b.     Solusi numerik tidak stabil jika error membesar secara eksponensial

c.     Kestabilan bergantung pada metode dan step size

d.     ODE "stiff" membutuhkan metode implisit untuk stabilitas

e.      Kondisi stabilitas: h ×λ < 2 (untuk metode eksplisit)

2.     Step Size dan Stabilitas

a.      Step size terlalu besar → solusi tidak stabil

b.     Step size terlalu kecil → simulasi lambat

c.     Trade-off: akurasi vs kecepatan

d.     Adaptive step size: mengubah h secara otomatis

e.     Contoh: simulasi rangkaian RLC (butuh step size kecil untuk akurasi)

3.     ODE Stiff

a.     ODE stiff: memiliki komponen yang berubah sangat cepat dan sangat lambat

b.     Metode eksplisit (Euler, RK4) butuh step size sangat kecil

c.     Metode implisit lebih stabil untuk ODE stiff

d.     Contoh: simulasi rangkaian dengan konstanta waktu sangat berbeda

e.     Solusi: gunakan metode implisit (Backward Euler, Trapezoidal)

4.     Metode Implisit

a.     Backward Euler: y_{n+1} = y_n + h × f(y_{n+1}, t_{n+1})

b.     Trapesium: y_{n+1} = y_n + (h/2) × (f(y_n,t_n) + f(y_{n+1},t_{n+1}))

c.     Implisit: memerlukan penyelesaian persamaan non-linear (Newton-Raphson)

d.     Lebih kompleks tetapi lebih stabil

e.     Aplikasi: simulasi rangkaian daya, SMPS

F.     Studi Kasus: Simulasi Rangkaian RC dengan RK4

1.     Model Rangkaian RC

a.     Persamaan: dV_c/dt = (V_s - V_c) / (R × C)

b.     Kondisi awal: V_c(0) = 0

c.     Solusi analitik: V_c(t) = V_s × (1 - e^(-t/(R×C)))

d.     Parameter: R = 10kΩ, C = 10µF, V_s = 5V

e.     τ = R×C = 0.1 detik

2.     Implementasi RK4

a.     def f(V, t): return (V_s - V) / (R*C)

b.     Gunakan algoritma RK4

c.     Step size h = 0.01 detik

d.     Simulasi dari t=0 hingga t=0.5 detik

e.     Bandingkan dengan solusi analitik

3.     Hasil Simulasi

a.     Plot V_c(t) dari RK4 dan solusi analitik

b.     Error vs waktu

c.     Error maksimum < 0.01% (untuk h = 0.01)

d.     Perbandingan dengan Euler (error lebih besar)

e.     Validasi: RK4 sangat akurat

4.     Aplikasi Lain

a.     Rangkaian RL: dI/dt = (V_s - I×R) / L

b.     Rangkaian RLC: osilasi, redaman

c.     Rangkaian dengan dioda: non-linear, butuh Newton-Raphson

d.     Sistem kontrol: PID dengan ODE

e.     Contoh: simulasi motor DC, power supply

G.    Implementasi Praktis

1.     Implementasi Euler

a.     def euler(f, y0, t0, tf, h): t = t0; y = y0; while t < tf: y += h * f(y, t); t += h; return y, t

b.     Sederhana, cepat, tetapi error besar

c.     Gunakan untuk simulasi kasar atau ODE sederhana

d.     Contoh: simulasi RC dengan step size kecil (0.001)

e.     Perbandingan dengan solusi analitik

2.     Implementasi RK4

a.     def rk4(f, y0, t0, tf, h): t = t0; y = y0; while t < tf: k1 = f(y, t); k2 = f(y + h/2k1, t + h/2); k3 = f(y + h/2k2, t + h/2); k4 = f(y + hk3, t + h); y += h/6(k1 + 2k2 + 2k3 + k4); t += h; return y, t

b.     Akurat, stabil, standar

c.     Gunakan untuk simulasi presisi tinggi

d.     Contoh: simulasi RLC, osilator

e.     Perbandingan dengan solusi analitik

3.     Implementasi di Python (scipy)

a.      from scipy.integrate import solve_ivp

b.     sol = solve_ivp(f, [t0, tf], y0, method='RK45')

c.     Metode otomatis memilih step size

d.     Sangat mudah dan akurat

e.     Contoh: simulasi rangkaian kompleks

4.     Implementasi di MATLAB

a.      [t, y] = ode45(@f, [t0 tf], y0)

b.     Ode45 = MATLAB's RK4 implementation

c.     Metode standar untuk simulasi

d.     Sangat mudah dan akurat

e.     Contoh: simulasi sistem kontrol