Apa itu titik embun dan mengapa itu penting dalam meteorologi
Setiap pagi di daerah tropis, kita sering melihat butiran air di atas daun atau kaca jendela yang berembun. Fenomena ini bukan sekadar pemandangan menarik — ia adalah tanda langsung dari konsep paling mendasar dalam meteorologi: titik embun atau dewpoint.
Dewpoint adalah suhu di mana udara menjadi jenuh (saturasi) apabila didinginkan pada tekanan dan kandungan uap air yang konstan. Ketika suhu udara turun ke titik embun, uap air mulai mengkondensasi menjadi tetes air cair. Itulah mengapa embun terbentuk di dini hari ketika permukaan tanah mendingin, dan mengapa kita melihat awan ketika massa udara lembap terangkat dan mendingin adiabatik.
Dalam praktik operasional meteorologi, dewpoint digunakan untuk beberapa tujuan penting. Pertama, dewpoint mengukur kandungan uap air absolut di udara secara langsung — berbeda dengan relative humidity yang bergantung pada suhu. Dua massa udara dengan relative humidity 70% bisa memiliki kandungan uap air yang sangat berbeda jika suhunya berbeda. Dewpoint menghilangkan ambiguitas ini.
Kedua, selisih antara suhu udara dan dewpoint — yang sering disebut dewpoint depression — menunjukkan seberapa jauh udara dari kondisi saturasi. Selisih kecil (kurang dari 3°C) menandakan udara sangat lembap dan berpotensi membentuk awan atau kabut. Selisih besar menandakan udara kering.
Ketiga, distribusi spasial dewpoint pada peta sinoptik membantu prakirawan mengidentifikasi batas massa udara, garis konvergensi, dan potensi curah hujan. Nilai dewpoint di atas 25°C di wilayah tropis, misalnya, sering berkaitan dengan kondisi yang mendukung pembentukan konveksi dalam.
Untuk stasiun pengamatan BMKG maupun data model GFS dan ERA5, temperatur dan relative humidity tersedia secara rutin. Dari kedua variabel itulah kita dapat menghitung dewpoint dengan formula Magnus.
Formula Magnus dan konstantanya
Formula Magnus (sering disebut juga Magnus-Tetens atau Alduchov-Eskridge) adalah aproksimasi analitik yang menghubungkan tekanan uap jenuh (saturation vapor pressure) dengan suhu. Bentuk standar yang paling banyak digunakan adalah:
γ(T, RH) = ln(RH / 100) + (b · T) / (c + T)
Td = c · γ / (b − γ)
di mana: - T = suhu udara dalam °C - RH = relative humidity dalam persen (0–100) - b dan c = konstanta Magnus yang bergantung pada rentang suhu - Td = dewpoint dalam °C
Konstanta Magnus yang paling umum digunakan berasal dari Alduchov & Eskridge (1996): - Untuk suhu di atas 0°C (kondensasi di atas permukaan air cair): b = 17.625, c = 243.04 - Untuk suhu di bawah 0°C (deposisi di atas es): b = 22.587, c = 273.86
Pemilihan konstanta yang tepat penting untuk akurasi. Pada suhu tropis (20–35°C) konstanta Alduchov-Eskridge memberikan kesalahan kurang dari 0.35°C dibandingkan formulasi psikrometri yang lebih ketat (August-Roche-Magnus exact). Aproksimasi ini sangat praktis karena tidak memerlukan tabel uap atau iterasi numerik.
Perlu dicatat bahwa formula Magnus adalah aproksimasi dari hubungan Clausius-Clapeyron, yang secara termodinamika mendeskripsikan bagaimana tekanan uap jenuh bergantung pada suhu. Variabel antara — nilai γ — adalah logaritma dari tekanan uap aktual dibagi tekanan uap jenuh pada 0°C, ditambah koreksi suhu. Dengan memecah persamaan menjadi dua langkah (hitung γ, lalu hitung Td), kita dapat menginspeksi nilai antara untuk keperluan debugging atau analisis lebih lanjut.
Berikut adalah snippet yang mendefinisikan konstanta dan mengekspresikan formula sebagai Python, termasuk kedua set konstanta:
import math
# Konstanta Magnus (Alduchov & Eskridge 1996)
MAGNUS_LIQUID = {"b": 17.625, "c": 243.04} # T >= 0°C (kondensasi di atas air cair)
MAGNUS_ICE = {"b": 22.587, "c": 273.86} # T < 0°C (deposisi di atas es)
def _select_constants(T_C: float) -> dict:
"""Pilih set konstanta Magnus berdasarkan suhu."""
return MAGNUS_LIQUID if T_C >= 0 else MAGNUS_ICE
# Demonstrasikan persamaan gamma untuk beberapa nilai suhu dan RH
test_cases = [
(30.0, 75.0),
(10.0, 60.0),
(-5.0, 80.0),
]
print(f"{'T (°C)':>8} {'RH (%)':>8} {'Konstanta b':>12} {'Konstanta c':>12} {'γ':>10}")
print("-" * 60)
for T, RH in test_cases:
k = _select_constants(T)
b, c = k["b"], k["c"]
gamma = math.log(RH / 100.0) + (b * T) / (c + T)
print(f"{T:8.1f} {RH:8.1f} {b:12.3f} {c:12.3f} {gamma:10.5f}")
T (°C) RH (%) Konstanta b Konstanta c γ
------------------------------------------------------------
30.0 75.0 17.625 243.040 1.64885
10.0 60.0 17.625 243.040 0.18570
-5.0 80.0 22.587 273.860 -0.64319
Menghitung titik embun dari suhu dan kelembaban relatif
Dengan konstanta dan persamaan yang sudah kita definisikan, langkah berikutnya adalah membungkus seluruh logika ke dalam satu fungsi Python yang siap pakai. Fungsi calc_dewpoint di bawah ini mengintegrasikan pemilihan konstanta otomatis, sehingga bisa menangani rentang suhu tropis maupun suhu di bawah beku.
import math
# Set konstanta sudah didefinisikan di snippet-1 — kita gunakan ulang
MAGNUS_LIQUID = {"b": 17.625, "c": 243.04}
MAGNUS_ICE = {"b": 22.587, "c": 273.86}
def _select_constants(T_C: float) -> dict:
return MAGNUS_LIQUID if T_C >= 0 else MAGNUS_ICE
def calc_dewpoint(T_C: float, RH: float) -> float:
"""
Hitung dewpoint (°C) dari suhu udara T_C (°C) dan
relative humidity RH (%) menggunakan formula Magnus.
Parameter:
T_C : suhu udara dalam derajat Celsius
RH : relative humidity dalam persen (1–100)
Kembalikan:
Td : suhu dewpoint dalam derajat Celsius
"""
if not (0 < RH <= 100):
raise ValueError(f"RH harus dalam rentang (0, 100], diterima: {RH}")
k = _select_constants(T_C)
b, c = k["b"], k["c"]
gamma = math.log(RH / 100.0) + (b * T_C) / (c + T_C)
return c * gamma / (b - gamma)
# Contoh: kondisi stasiun tropis di Makassar pukul 14.00 WITA
T_makassar = 33.2 # °C
RH_makassar = 68.0 # %
Td = calc_dewpoint(T_makassar, RH_makassar)
print(f"Suhu udara : {T_makassar:.1f} °C")
print(f"Relative humidity: {RH_makassar:.0f} %")
print(f"Dewpoint : {Td:.2f} °C")
print(f"Dewpoint depression: {T_makassar - Td:.2f} °C")
# Contoh kedua: kondisi pegunungan pada malam hari
T_gunung = 18.0
RH_gunung = 92.0
Td_gunung = calc_dewpoint(T_gunung, RH_gunung)
print()
print(f"Suhu udara (gunung) : {T_gunung:.1f} °C")
print(f"Relative humidity : {RH_gunung:.0f} %")
print(f"Dewpoint : {Td_gunung:.2f} °C")
print(f"Dewpoint depression : {T_gunung - Td_gunung:.2f} °C — udara hampir jenuh")
Suhu udara : 33.2 °C
Relative humidity: 68 %
Dewpoint : 26.50 °C
Dewpoint depression: 6.70 °C
Suhu udara (gunung) : 18.0 °C
Relative humidity : 92 %
Dewpoint : 16.68 °C
Dewpoint depression : 1.32 °C — udara hampir jenuh
Perhatikan dua hal dari hasil ini. Pertama, di Makassar dengan suhu 33.2°C dan RH 68%, dewpoint sekitar 26°C — nilai yang umum di pesisir Indonesia pada siang hari dan menandakan kandungan uap air yang cukup tinggi untuk mendukung konveksi. Kedua, dewpoint depression di stasiun gunung dengan RH 92% sangat kecil, artinya udara sudah mendekati saturasi dan kabut atau awan rendah sangat mungkin terbentuk.
Aplikasi praktis pola kelembaban harian dan titik embun
Di wilayah tropis, suhu udara dan relative humidity berubah secara sistematis sepanjang hari mengikuti siklus radiasi matahari. Suhu mencapai puncak sekitar pukul 13.00–15.00 LT, sementara RH mencapai titik terendahnya pada jam yang sama. Sebaliknya, dini hari adalah waktu suhu paling rendah dan RH paling tinggi.
Yang menarik adalah bahwa dewpoint umumnya lebih stabil sepanjang hari dibandingkan suhu atau RH. Ini karena kandungan uap air absolut di lapisan batas atmosfer tidak berubah drastis dalam skala jam, kecuali ada adveksi massa udara baru atau penguapan/kondensasi yang signifikan.
Snippet berikut mensimulasikan 24 jam pengamatan per jam dengan pola suhu dan RH yang realistis, lalu menghitung dewpoint per jam menggunakan fungsi calc_dewpoint yang sudah didefinisikan di snippet-2.
# calc_dewpoint sudah tersedia dari snippet-2 — tidak perlu didefinisikan ulang
hours = list(range(24))
# Pola suhu sintetis: minimum ~26°C pukul 05.00, maksimum ~34°C pukul 14.00
import math as _math
T_series = [26.0 + 8.0 * _math.sin(_math.pi * (h - 5) / 18) if 5 <= h <= 23 else
26.0 + 8.0 * _math.sin(_math.pi * (h + 19) / 18)
for h in hours]
# Pola RH sintetis: kebalikan suhu — tinggi di dini hari, rendah di siang.
# Clip ke (0, 100] karena formula Magnus tidak terdefinisi di luar rentang ini.
RH_series = [min(100.0, max(1.0,
95.0 - 35.0 * _math.sin(_math.pi * (h - 5) / 18) if 5 <= h <= 23 else
95.0 - 35.0 * _math.sin(_math.pi * (h + 19) / 18)))
for h in hours]
# Hitung dewpoint per jam
Td_series = [calc_dewpoint(T, RH) for T, RH in zip(T_series, RH_series)]
print(f"{'Jam':>4} {'T (°C)':>7} {'RH (%)':>7} {'Td (°C)':>8} {'T-Td':>6}")
print("-" * 42)
for h, T, RH, Td in zip(hours, T_series, RH_series, Td_series):
print(f"{h:4d} {T:7.2f} {RH:7.2f} {Td:8.2f} {T-Td:6.2f}")
print()
Td_min = min(Td_series)
Td_max = max(Td_series)
print(f"Rentang dewpoint: {Td_min:.2f} – {Td_max:.2f} °C (variasi {Td_max - Td_min:.2f} °C)")
print(f"Rentang suhu : {min(T_series):.2f} – {max(T_series):.2f} °C (variasi {max(T_series)-min(T_series):.2f} °C)")
Jam T (°C) RH (%) Td (°C) T-Td
------------------------------------------
0 24.61 100.00 24.61 0.00
1 23.26 100.00 23.26 0.00
2 22.00 100.00 22.00 -0.00
3 20.86 100.00 20.86 0.00
4 19.87 100.00 19.87 0.00
5 26.00 95.00 25.14 0.86
6 27.39 88.92 25.40 1.99
7 28.74 83.03 25.57 3.17
8 30.00 77.50 25.63 4.37
9 31.14 72.50 25.61 5.53
10 32.13 68.19 25.52 6.61
11 32.93 64.69 25.40 7.53
12 33.52 62.11 25.27 8.25
13 33.88 60.53 25.17 8.70
14 34.00 60.00 25.14 8.86
15 33.88 60.53 25.17 8.70
16 33.52 62.11 25.27 8.25
17 32.93 64.69 25.40 7.53
18 32.13 68.19 25.52 6.61
19 31.14 72.50 25.61 5.53
20 30.00 77.50 25.63 4.37
21 28.74 83.03 25.57 3.17
22 27.39 88.92 25.40 1.99
23 26.00 95.00 25.14 0.86
Rentang dewpoint: 19.87 – 25.63 °C (variasi 5.76 °C)
Rentang suhu : 19.87 – 34.00 °C (variasi 14.13 °C)
Dari output ini kita dapat melihat bahwa variasi harian dewpoint jauh lebih kecil dibandingkan variasi suhu. Saat dewpoint depression mengecil di dini hari, kondisi mendekati saturasi dan pembentukan kabut atau awan stratus menjadi mungkin. Ini adalah pola yang konsisten di banyak stasiun pesisir dan pegunungan Indonesia.
Langkah selanjutnya akurasi formula dan data real meteorologi
Formula Magnus memberikan akurasi yang memadai untuk sebagian besar aplikasi meteorologi operasional. Pada rentang suhu tropis (15–40°C) dengan RH di atas 30%, kesalahan absolut relatif terhadap formulasi Wexler (standar WMO) umumnya di bawah 0.5°C. Untuk analisis yang memerlukan presisi lebih tinggi — misalnya kalkulasi equivalent potential temperature atau kajian boundary layer detail — pertimbangkan menggunakan library MetPy yang mengimplementasikan formulasi Bolton (1980) atau persamaan Huang (2018).
Untuk data nyata, beberapa sumber yang dapat kita gunakan:
- BMKG open data: data pengamatan permukaan (stasiun sinoptik) tersedia melalui API publik BMKG.
- ERA5: reanalysis ECMWF menyediakan variabel 2m_dewpoint_temperature langsung, sehingga tidak perlu menghitung secara manual. Namun memahami formula Magnus tetap penting untuk memverifikasi dan menginterpretasikan data tersebut.
- GFS: gridded forecast data dari NCEP/NOAA menyediakan 2m temperature dan 2m specific humidity yang bisa dikonversi ke dewpoint.
# Bandingkan Magnus dengan pendekatan Bolton (1980) — referensi umum di MetPy
import math
def calc_dewpoint(T_C: float, RH: float) -> float:
"""Magnus dewpoint (Alduchov & Eskridge 1996)."""
k = {"b": 17.625, "c": 243.04} if T_C >= 0 else {"b": 22.587, "c": 273.86}
b, c = k["b"], k["c"]
gamma = math.log(RH / 100.0) + (b * T_C) / (c + T_C)
return c * gamma / (b - gamma)
def calc_dewpoint_bolton(T_C: float, RH: float) -> float:
"""
Dewpoint menggunakan formula Bolton (1980), Eq. 10.
Akurat untuk -35°C < T < 35°C.
"""
e = (RH / 100.0) * 6.112 * math.exp((17.67 * T_C) / (T_C + 243.5))
return (243.5 * math.log(e / 6.112)) / (17.67 - math.log(e / 6.112))
# Bandingkan pada beberapa titik suhu dan RH
print(f"{'T':>6} {'RH':>6} {'Magnus Td':>10} {'Bolton Td':>10} {'Selisih':>8}")
print("-" * 48)
test_points = [
(35.0, 85.0), (28.0, 70.0), (20.0, 50.0),
(10.0, 40.0), (0.0, 90.0),
]
for T, RH in test_points:
td_m = calc_dewpoint(T, RH)
td_b = calc_dewpoint_bolton(T, RH)
print(f"{T:6.1f} {RH:6.1f} {td_m:10.4f} {td_b:10.4f} {abs(td_m-td_b):8.4f}")
print()
print("Selisih rata-rata (Magnus vs Bolton): kecil untuk suhu tropis.")
print("Gunakan MetPy atau Bolton untuk presisi lebih tinggi di suhu ekstrem.")
T RH Magnus Td Bolton Td Selisih
------------------------------------------------
35.0 85.0 32.0976 32.1008 0.0032
28.0 70.0 22.0181 22.0240 0.0059
20.0 50.0 9.2611 9.2701 0.0090
10.0 40.0 -2.9931 -2.9843 0.0088
0.0 90.0 -1.4442 -1.4433 0.0009
Selisih rata-rata (Magnus vs Bolton): kecil untuk suhu tropis.
Gunakan MetPy atau Bolton untuk presisi lebih tinggi di suhu ekstrem.
Dengan memahami formula Magnus, kita sudah memiliki alat dasar yang kuat untuk mengolah data temperatur dan relative humidity dari sumber mana pun — baik dari pengamatan manual BMKG, unduhan ERA5 via CDS API, maupun output model WRF lokal.
Memvisualisasikan Permukaan Dewpoint(T, RH)
Formula Magnus paling intuitif saat kita lihat sebagai permukaan dua dimensi: untuk setiap kombinasi T dan RH, ada satu nilai dewpoint. Snippet di bawah membangun matriks 50×50 dewpoint untuk T = 0–40 °C dan RH = 20–100 %, lalu menggambarnya sebagai gradien dengan kontur isolinedewpoint setiap 5 °C.
# Prereq globals (dari snippet-4):
# calc_dewpoint(T_C, RH) — fungsi Magnus yang sudah didefinisikan
import numpy as np
import matplotlib.pyplot as plt
T_grid = np.linspace(0, 40, 60)
RH_grid = np.linspace(20, 100, 60)
TT, HH = np.meshgrid(T_grid, RH_grid)
Td_grid = np.zeros_like(TT)
for i in range(TT.shape[0]):
for j in range(TT.shape[1]):
Td_grid[i, j] = calc_dewpoint(float(TT[i, j]), float(HH[i, j]))
fig, ax = plt.subplots(figsize=(10, 6.5))
mesh = ax.pcolormesh(TT, HH, Td_grid, cmap="viridis", shading="auto",
vmin=-15, vmax=35)
contours = ax.contour(TT, HH, Td_grid, levels=range(-10, 36, 5),
colors="white", linewidths=0.8, alpha=0.9)
ax.clabel(contours, fmt="%d °C", fontsize=9, inline=True)
sat_line = ax.plot([0, 40], [100, 100], color="#E65100", linewidth=2.0,
label="RH 100 % — Td = T")[0]
for T_eg, RH_eg, label in [
(33.2, 68.0, "Makassar siang"),
(18.0, 92.0, "Pegunungan malam"),
]:
td_eg = calc_dewpoint(T_eg, RH_eg)
ax.scatter([T_eg], [RH_eg], s=120, color="white", edgecolor="black",
linewidth=1.4, zorder=5)
ax.annotate(f"{label}\nTd = {td_eg:.1f} °C",
xy=(T_eg, RH_eg),
xytext=(T_eg - 12, RH_eg - 18),
fontsize=9, color="#222",
arrowprops=dict(arrowstyle="->", color="#222", lw=0.8))
ax.set_xlabel("Suhu udara T (°C)", fontsize=11)
ax.set_ylabel("Relative humidity RH (%)", fontsize=11)
ax.set_title("Dewpoint sebagai Fungsi T dan RH (Formula Magnus)",
fontsize=12, weight="bold", pad=10)
plt.colorbar(mesh, ax=ax, label="Dewpoint Td (°C)")
ax.legend(loc="lower right", fontsize=9)
plt.tight_layout()
plt.savefig("dewpoint_surface.png", dpi=150, bbox_inches="tight")
Pola yang muncul: isoline dewpoint membentuk garis miring naik dari kiri-bawah ke kanan-atas. Ini sesuai intuisi — dewpoint tinggi (di atas 25 °C) hanya muncul saat suhu udara cukup tinggi DAN RH cukup tinggi. Pada garis RH = 100 % di paling atas, dewpoint identik dengan suhu udara (kondisi jenuh). Dua titik contoh tertanda menunjukkan kontras maritim siang vs pegunungan malam yang sama-sama menghasilkan dewpoint sekitar 17–27 °C tapi dengan kombinasi T/RH yang sangat berbeda.
Langkah lanjutan yang bisa kita eksplorasi antara lain: menghitung wet-bulb temperature dari dewpoint menggunakan iterasi Davies-Jones, mengintegrasikan kalkulasi dewpoint ke dalam pipeline xarray untuk memproses grid ERA5 secara vektorisasi, atau memvisualisasikan distribusi spasial dewpoint di seluruh kepulauan Indonesia menggunakan cartopy. Setiap teknik tersebut dibangun di atas pemahaman dasar formula Magnus yang telah kita bahas di artikel ini.
Tidak ada komentar:
Posting Komentar