Mengapa Analisis Intensitas Siklon Tropis Penting Sumber: NASA Earth Observatory — citra VIIRS false-color inframerah menunjukkan lima sik...
Minggu, 31 Mei 2026
Mengapa Analisis Intensitas Siklon Tropis Penting
Sumber: NASA Earth Observatory — citra VIIRS false-color inframerah menunjukkan lima siklon tropis aktif di Belahan Selatan secara bersamaan, 26 Februari 2025. (Cyclone Flurry in the Southern Hemisphere)
Intensitas siklon tropis (TC) — diukur dari tekanan minimum di pusatnya dan kecepatan angin permukaan maksimum — adalah parameter paling kritis untuk peringatan dini dampak. Perbedaan 10 hPa dalam minimum SLP bisa berarti perbedaan antara kategori 2 dan kategori 4. BMKG TCWC Jakarta memantau dan memperingatkan TC di selatan ekuator, termasuk Laut Timor, Laut Banda, dan Samudra Hindia selatan Jawa dan Nusa Tenggara.
Model WRF (Weather Research and Forecasting) adalah tools riset dan NWP regional yang paling banyak digunakan untuk simulasi TC resolusi tinggi. WRF menghasilkan file output bernama wrfout*.nc yang berisi semua field 3D model — suhu, tekanan, angin, kelembapan — setiap interval waktu output. Masalahnya: data mentah ini belum langsung memberi tahu kita intensitas TC. Kita perlu post-processing: ekstraksi diagnostik yang relevan, perhitungan intensitas dari field model, dan visualisasi evolusi temporal.
Tutorial ini menunjukkan cara melakukan semua itu dengan wrf-python dan xarray. Kita akan hitung minimum SLP, maximum 10 m wind speed, dan warm-core temperature anomaly — tiga metrik intensitas utama yang digunakan dalam analisis WRF TC.
WRF Output dan Struktur File wrfout
WRF ARW (Advanced Research WRF) versi 4.5 menghasilkan output NetCDF standar dengan konvensi penamaan wrfout_d<domain>_<YYYY-MM-DD_HH:MM:SS>. Untuk simulasi TC, biasanya ada dua domain nested: domain luar (outer domain, ~9–15 km) dan domain dalam (inner domain, 1–3 km) yang mengikuti pergerakan TC secara otomatis — ini disebut vortex-following nested grid.
Beberapa variabel kunci dalam wrfout*.nc untuk analisis intensitas TC:
- PSFC — tekanan permukaan (Pa); dibagi 100 untuk mendapat hPa
- U10, V10 — komponen angin zonal dan meridional di ketinggian 10 m (m/s)
- T — perturbasi suhu (K) di model levels (eta levels), bukan pressure levels
- P + PB — tekanan model (Pa) dan base state pressure (Pa); dijumlahkan untuk tekanan aktual
- QVAPOR — specific humidity (kg/kg)
Satu hal yang sering membingungkan: variabel suhu T di WRF adalah perturbasi dari base state, bukan suhu absolut. Untuk mendapat suhu absolut \(T_{\text{abs}}\) dalam Kelvin, kita tambahkan konstanta 300 K:
$$T_{\text{abs}} = T + 300\ \text{K}$$
Vertikal, WRF menggunakan koordinat eta \(\eta\) — terrain-following pressure coordinate — bukan pressure levels standar. wrf-python menyediakan fungsi getvar() yang secara otomatis melakukan interpolasi ke pressure levels dan menangani unit conversion ini.
WRF v4.5 menyertakan tropical physics suite (diaktifkan dengan physics_suite='tropical' di namelist) yang menggabungkan WSM6 microphysics, New Tiedtke cumulus, RRTMG radiation, dan YSU PBL — konfigurasi yang dioptimalkan untuk simulasi TC konvektif di skala convection-permitting.
Instalasi wrf-python dan xWRF
Ada dua library Python utama untuk post-processing WRF:
wrf-python adalah library resmi dari NCAR/UCAR yang menyediakan wrapper Python di atas algoritma post-processing WRF yang ditulis dalam Fortran. Library ini menanggani interpolasi dari eta levels ke pressure levels, komputasi diagnostik seperti SLP dan vortisitas, serta unit conversion secara otomatis. Karena bergantung pada Fortran extension, instalasi via conda lebih stabil.
xWRF adalah library modern berbasis xarray yang menyediakan interface yang lebih Pythonic untuk WRF output. xWRF mendukung Dask untuk processing data besar secara paralel dan terintegrasi baik dengan ekosistem xarray/Pangeo.
Untuk tutorial ini kita menggunakan xarray dan numpy untuk semua komputasi — library yang sudah tersedia di sandbox maupun di instalasi Python standar. wrf-python (library Fortran NCAR) membutuhkan compiler Fortran dan lebih mudah diinstall via conda. Pengguna yang ingin workflow lengkap dengan getvar() untuk interpolasi otomatis ke pressure levels bisa merujuk dokumentasi resmi wrf-python di situs readthedocs NCAR. Snippet berikut menginstall dependensi yang kita perlukan dan memverifikasi importnya:
pip install numpy xarray netCDF4 matplotlib 2>&1 | tail -5
python -c "
import xarray as xr
import numpy as np
import matplotlib
print('xarray version:', xr.__version__)
print('numpy version:', np.__version__)
print('matplotlib version:', matplotlib.__version__)
print('OK: semua dependensi berhasil diimport')
"
Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/site-packages (from matplotlib) (12.2.0)
Requirement already satisfied: pyparsing>=3 in /usr/local/lib/python3.12/site-packages (from matplotlib) (3.3.2)
Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/site-packages (from matplotlib) (2.9.0.post0)
Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/site-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)
WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.
xarray version: 2026.4.0
numpy version: 2.4.6
matplotlib version: 3.10.9
OK: semua dependensi berhasil diimport
Membuka wrfout File dan Mengekstrak Pressure Level Suhu
Dalam workflow normal, kita buka wrfout_d02_2024-01-15_00:00:00 dari simulasi WRF yang sudah dijalankan. Karena file wrfout ukurannya bisa mencapai beberapa GB dan tidak tersedia secara publik, tutorial ini membangun dataset sintetis yang merepresentasikan struktur TC realistis — struktur yang sama yang akan kita temukan dalam file wrfout sesungguhnya.
Dataset sintetis ini dibuat dengan parameter TC tipikal: domain 200×200 grid point dengan spacing 3 km (domain dalam ~600 km × 600 km), 6 pressure levels dari 1000 hingga 200 hPa, dan vorteks Rankine sebagai proxy wind field. Kita buat juga time series 12 jam untuk simulasikan intensifikasi TC.
import numpy as np
import xarray as xr
# === Bangun dataset sintetis yang merepresentasikan wrfout TC ===
# Domain: 200x200 grid, dx=3 km
NX, NY = 200, 200
dx_km = 3.0
lon_center, lat_center = 110.0, -10.0 # TC center awal (Laut Timor)
lon_1d = np.linspace(lon_center - 3, lon_center + 3, NX)
lat_1d = np.linspace(lat_center - 3, lat_center + 3, NY)
LON, LAT = np.meshgrid(lon_1d, lat_1d)
# Pressure levels (hPa) — simulasikan 6 level standar
p_levels = np.array([1000, 850, 700, 500, 300, 200], dtype=float)
N_LEV = len(p_levels)
N_TIME = 12 # 12 time steps, tiap 1 jam
# Koordinat jarak dari pusat TC (km)
def radial_dist_km(lon, lat, clon, clat):
dlat = (lat - clat) * 111.0
dlon = (lon - clon) * 111.0 * np.cos(np.deg2rad(clat))
return np.sqrt(dlat**2 + dlon**2)
# Suhu (K) sebagai fungsi radius dan pressure level
# Warm core: TC center lebih hangat di upper troposphere
def make_temp_field(r_km, p_hpa, warm_core_amp=8.0):
"""Suhu background + warm-core anomaly (lebih kuat di 300-500 hPa)."""
# Standard atmosphere temperature (approx)
T_std = 300.0 - 0.0065 * (1013.25 - p_hpa) * 8.5
# Warm-core: Gaussian radial decay, kuat di 300–500 hPa
warm_peak = np.where(p_hpa < 600, warm_core_amp, warm_core_amp * 0.4)
warm = warm_peak * np.exp(-(r_km / 150.0)**2)
return T_std + warm
# Bangun array 4D: [time, lev, lat, lon]
T_4d = np.zeros((N_TIME, N_LEV, NY, NX))
r_km = radial_dist_km(LON, LAT, lon_center, lat_center)
for it in range(N_TIME):
for il, p in enumerate(p_levels):
# Intensifikasi bertahap: warm core tumbuh 0.3 K/jam
amp = 8.0 + it * 0.3
T_4d[it, il] = make_temp_field(r_km, p, warm_core_amp=amp)
# xarray Dataset
times = np.array([np.datetime64('2024-01-15T00:00') + np.timedelta64(h, 'h')
for h in range(N_TIME)])
ds_wrf = xr.Dataset(
{
"T_pres": (["time", "pressure", "lat", "lon"], T_4d,
{"units": "K", "long_name": "Temperature on pressure levels"}),
},
coords={
"time": ("time", times),
"pressure": ("pressure", p_levels, {"units": "hPa"}),
"lat": ("lat", lat_1d, {"units": "degrees_north"}),
"lon": ("lon", lon_1d, {"units": "degrees_east"}),
}
)
print("=== Dataset sintetis WRF TC ===")
print(ds_wrf)
print()
print("Pressure levels (hPa):", ds_wrf.pressure.values)
print(f"Domain: {NX}×{NY} grid, dx={dx_km} km")
print(f"Center: {lon_center}°E, {lat_center}°N")
print()
# Sample: suhu di center dan di tepi domain pada T=0
T_500_center = float(ds_wrf["T_pres"].sel(pressure=500).isel(time=0).values[NY//2, NX//2])
T_850_center = float(ds_wrf["T_pres"].sel(pressure=850).isel(time=0).values[NY//2, NX//2])
T_500_env = float(ds_wrf["T_pres"].sel(pressure=500).isel(time=0).values[5, 5])
T_850_env = float(ds_wrf["T_pres"].sel(pressure=850).isel(time=0).values[5, 5])
print(f"Suhu 500 hPa — center: {T_500_center:.2f} K | environment: {T_500_env:.2f} K")
print(f"Suhu 850 hPa — center: {T_850_center:.2f} K | environment: {T_850_env:.2f} K")
print(f"Warm-core anomaly 500 hPa: {T_500_center - T_500_env:.2f} K (waktu t=0)")
=== Dataset sintetis WRF TC ===
<xarray.Dataset> Size: 23MB
Dimensions: (time: 12, pressure: 6, lat: 200, lon: 200)
Coordinates:
* time (time) datetime64[s] 96B 2024-01-15 ... 2024-01-15T11:00:00
* pressure (pressure) float64 48B 1e+03 850.0 700.0 500.0 300.0 200.0
* lat (lat) float64 2kB -13.0 -12.97 -12.94 -12.91 ... -7.06 -7.03 -7.0
* lon (lon) float64 2kB 107.0 107.0 107.1 107.1 ... 112.9 113.0 113.0
Data variables:
T_pres (time, pressure, lat, lon) float64 23MB 299.3 299.3 ... 255.1
Pressure levels (hPa): [1000. 850. 700. 500. 300. 200.]
Domain: 200×200 grid, dx=3.0 km
Center: 110.0°E, -10.0°N
Suhu 500 hPa — center: 279.64 K | environment: 271.64 K
Suhu 850 hPa — center: 294.18 K | environment: 290.98 K
Warm-core anomaly 500 hPa: 8.00 K (waktu t=0)
Angka di atas mengonfirmasi struktur TC yang realistis. Warm-core anomaly yang positif di 500 hPa adalah ciri khas TC terorganisasi — makin besar anomali ini, makin intens sistemnya secara termodinamika.
Menghitung Minimum SLP dan Maksimum Surface Wind
Dua metrik intensitas TC yang paling langsung adalah minimum sea-level pressure (SLP) dan maximum 10 m wind speed (\(V_{\max}\)). SLP minimum mencerminkan kedalaman sirkulasi bawah, sementara \(V_{\max}\) adalah definisi operasional intensitas TC — dasar penentuan kategori Saffir-Simpson.
Dalam file wrfout nyata, PSFC adalah surface pressure dalam Pa. Konversi ke hPa:
$$\text{SLP} \approx \frac{\text{PSFC}}{100}\ \text{hPa}$$
Kecepatan angin dari komponen U10 dan V10:
$$V_{10} = \sqrt{U_{10}^2 + V_{10}^2}\ \text{(m/s)}$$
Snippet berikut melanjutkan sesi Python yang sama dengan snippet-2 — variabel NX, NY, N_TIME, LON, LAT, lon_center, lat_center, lat_1d, times, dan r_km sudah ada di memori. Jika kita menjalankan snippet ini di sesi baru atau setelah restart kernel, snippet-2 harus dijalankan ulang terlebih dahulu. Snippet ini membangun field SLP dan wind sintetis mengikuti profil vorteks Rankine, lalu menghitung time series intensitas:
import numpy as np
import xarray as xr
# === Bangun SLP dan wind speed field (lanjutan dari snippet-2) ===
# (globals: NX, NY, N_TIME, LON, LAT, lon_center, lat_center, times, r_km)
# Profil SLP: minimum di center, naik secara radial (model exponential Holland)
# P_min berkurang 1 hPa per jam sebagai simulasi intensifikasi
P_min_init = 985.0 # hPa — intensitas awal (tropis storm kategori bawah)
P_env = 1008.0 # hPa — tekanan lingkungan
SLP_3d = np.zeros((N_TIME, NY, NX))
WSPD_3d = np.zeros((N_TIME, NY, NX))
R_w = 80.0 # radius of maximum winds (km)
for it in range(N_TIME):
P_min = P_min_init - it * 1.0 # intensifikasi 1 hPa/jam
# Holland B parameter (empiris ~1.2 untuk intensitas moderat)
B = 1.2
# SLP field (Holland model)
r = r_km.copy()
r[r < 1] = 1 # hindari divisi nol
SLP_3d[it] = P_min + (P_env - P_min) * np.exp(-(R_w / r)**B)
# Wind speed (gradient wind approx, simplified)
WSPD_3d[it] = np.sqrt(
(P_env - P_min) * B / (1.225) * np.exp(-(R_w / r)**B) * (R_w / r)**B
)
# Normalisasi: V_max ~ 50 m/s pada RMW untuk P_min awal ~985 hPa
V_max_target = 25.0 + it * 0.8 # tumbuh ~0.8 m/s per jam
if WSPD_3d[it].max() > 0:
WSPD_3d[it] *= V_max_target / WSPD_3d[it].max()
ds_intensity = xr.Dataset(
{
"SLP": (["time", "lat", "lon"], SLP_3d, {"units": "hPa", "long_name": "Sea-level pressure"}),
"WSPD": (["time", "lat", "lon"], WSPD_3d, {"units": "m/s", "long_name": "10m wind speed"}),
},
coords={
"time": ("time", times),
"lat": ("lat", lat_1d),
"lon": ("lon", lon_1d),
}
)
# Time series intensitas
slp_min = ds_intensity["SLP"].min(dim=["lat", "lon"])
wspd_max = ds_intensity["WSPD"].max(dim=["lat", "lon"])
print(f"{'Waktu (UTC)':<22} {'Min SLP (hPa)':>13} {'Max Vmax (m/s)':>14}")
print("-" * 55)
for t in range(N_TIME):
ts = str(ds_intensity.time.values[t])[:16]
print(f"{ts:<22} {float(slp_min[t]):>13.1f} {float(wspd_max[t]):>14.1f}")
print()
print(f"Intensifikasi total : {float(slp_min[-1]) - float(slp_min[0]):+.1f} hPa dalam 11 jam")
print(f"V_max awal → akhir : {float(wspd_max[0]):.1f} → {float(wspd_max[-1]):.1f} m/s")
Waktu (UTC) Min SLP (hPa) Max Vmax (m/s)
-------------------------------------------------------
2024-01-15T00:00 985.0 25.0
2024-01-15T01:00 984.0 25.8
2024-01-15T02:00 983.0 26.6
2024-01-15T03:00 982.0 27.4
2024-01-15T04:00 981.0 28.2
2024-01-15T05:00 980.0 29.0
2024-01-15T06:00 979.0 29.8
2024-01-15T07:00 978.0 30.6
2024-01-15T08:00 977.0 31.4
2024-01-15T09:00 976.0 32.2
2024-01-15T10:00 975.0 33.0
2024-01-15T11:00 974.0 33.8
Intensifikasi total : -11.0 hPa dalam 11 jam
V_max awal → akhir : 25.0 → 33.8 m/s
Time series di atas menunjukkan pola intensifikasi TC yang khas: SLP turun secara konsisten sementara \(V_{\max}\) naik. Dalam operasional, intensifikasi cepat (rapid intensification) didefinisikan sebagai penurunan minimum SLP sebesar 25 hPa atau peningkatan \(V_{\max}\) sebesar 30 knot (≈ 15 m/s) dalam 24 jam. Data model WRF menyediakan basis verifikasi terhadap pengamatan satelit GOES-18/19 dan dropsonde dari pesawat pengintai.
Sumber: NOAA/NESDIS — GOES-16 menangkap Hurricane Milton pada 8 Oktober 2024 saat intensitas puncak, menunjukkan mata yang jelas dan banding spiral yang rapat. (NOAA Satellites Have You Covered This Hurricane Season)
Menganalisis Warm-Core Anomali untuk Intensitas TC
Warm-core anomaly adalah ciri khas yang membedakan TC dari sistem tekanan rendah lainnya. Sementara siklon ekstratropis memiliki cold core (lebih dingin di tengah di upper troposphere), TC memiliki warm core — pusat yang lebih hangat dari lingkungan sekitarnya terutama di lapisan 300–500 hPa. Anomali ini terbentuk karena pelepasan panas laten dari konveksi di eyewall yang menghangatkan kolom udara di atas sirkulasi bawah.
Secara kuantitatif, anomali warm-core \(\Delta T_{\text{wc}}\) pada pressure level \(p\) didefinisikan sebagai:
$$\Delta T_{\text{wc}}(p) = T_{\text{center}}(p) - T_{\text{env}}(p)$$
di mana \(T_{\text{env}}\) diambil dari grid point yang jauh dari pusat (≥ 500 km) sebagai referensi lingkungan. Anomali ini berkorelasi kuat dengan intensitas: TC kategori 4–5 biasanya memiliki \(\Delta T_{\text{wc}} > 10\) K di 500 hPa. Teknik Dvorak juga menggunakan prinsip serupa — perbedaan suhu antara mata hangat dan cloud top dingin di sekitarnya.
Snippet berikut menghitung anomali warm-core pada setiap timestep menggunakan dataset yang sudah kita siapkan:
import numpy as np
import xarray as xr
# (globals dari snippet-2: ds_wrf, N_TIME, NY, NX)
# Lokasi center TC: titik tengah domain (fixed untuk demo ini)
i_center, j_center = NY // 2, NX // 2
# Referensi environment: sudut domain (jauh dari center)
i_env, j_env = 10, 10 # ~470 km dari center untuk domain ini
# Pressure levels yang kita analisis
p_focus = [500, 850] # hPa
print(f"Warm-core anomaly time series (K):")
print(f"{'Waktu (UTC)':<22} {'ΔT 500 hPa':>10} {'ΔT 850 hPa':>10} {'Status':>12}")
print("-" * 62)
wc_500 = []
wc_850 = []
for it in range(N_TIME):
T_center_500 = float(ds_wrf["T_pres"].sel(pressure=500).isel(
time=it).values[i_center, j_center])
T_env_500 = float(ds_wrf["T_pres"].sel(pressure=500).isel(
time=it).values[i_env, j_env])
dT_500 = T_center_500 - T_env_500
T_center_850 = float(ds_wrf["T_pres"].sel(pressure=850).isel(
time=it).values[i_center, j_center])
T_env_850 = float(ds_wrf["T_pres"].sel(pressure=850).isel(
time=it).values[i_env, j_env])
dT_850 = T_center_850 - T_env_850
wc_500.append(dT_500)
wc_850.append(dT_850)
# Klasifikasi intensitas berdasarkan anomali 500 hPa
if dT_500 < 4:
status = "Weak"
elif dT_500 < 8:
status = "Moderate"
elif dT_500 < 12:
status = "Intense"
else:
status = "Very Intense"
ts = str(ds_wrf.time.values[it])[:16]
print(f"{ts:<22} {dT_500:>10.2f} {dT_850:>10.2f} {status:>12}")
print()
print(f"Anomali 500 hPa: t=0 {wc_500[0]:.2f} K → t=11 {wc_500[-1]:.2f} K")
print(f"Anomali 850 hPa: t=0 {wc_850[0]:.2f} K → t=11 {wc_850[-1]:.2f} K")
print(f"Pertumbuhan warm core 500 hPa: {wc_500[-1]-wc_500[0]:+.2f} K dalam 11 jam")
Warm-core anomaly time series (K):
Waktu (UTC) ΔT 500 hPa ΔT 850 hPa Status
--------------------------------------------------------------
2024-01-15T00:00 7.99 3.20 Moderate
2024-01-15T01:00 8.29 3.32 Intense
2024-01-15T02:00 8.59 3.44 Intense
2024-01-15T03:00 8.89 3.56 Intense
2024-01-15T04:00 9.19 3.68 Intense
2024-01-15T05:00 9.49 3.80 Intense
2024-01-15T06:00 9.79 3.92 Intense
2024-01-15T07:00 10.09 4.04 Intense
2024-01-15T08:00 10.39 4.16 Intense
2024-01-15T09:00 10.69 4.28 Intense
2024-01-15T10:00 10.99 4.40 Intense
2024-01-15T11:00 11.29 4.52 Intense
Anomali 500 hPa: t=0 7.99 K → t=11 11.29 K
Anomali 850 hPa: t=0 3.20 K → t=11 4.52 K
Pertumbuhan warm core 500 hPa: +3.30 K dalam 11 jam
Profil vertikal memvisualisasikan warm-core structure secara intuitif. Kita plot suhu versus pressure level di titik TC center dibanding lingkungan — perbedaan antara dua kurva adalah warm-core anomaly yang berevolusi seiring intensifikasi.
import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
# (globals dari snippet-2: p_levels, ds_wrf, N_TIME, NY, NX)
# Ambil dua timestep: awal (t=0) dan akhir (t=11) untuk perbandingan
p_levels_plot = p_levels # [1000, 850, 700, 500, 300, 200] hPa
i_c, j_c = NY // 2, NX // 2 # center
i_e, j_e = 10, 10 # environment
fig, axes = plt.subplots(1, 2, figsize=(13, 7), sharey=True)
colors_center = ["#e63946", "#c1121f"] # merah tua untuk center TC
colors_env = ["#457b9d", "#1d3557"] # biru untuk environment
for idx_t, (t_idx, t_label, col_c, col_e) in enumerate([
(0, "t=0h (awal)", colors_center[0], colors_env[0]),
(11, "t=11h (intensif)", colors_center[1], colors_env[1]),
]):
ax = axes[idx_t]
T_center_prof = np.array([
float(ds_wrf["T_pres"].sel(pressure=p).isel(time=t_idx).values[i_c, j_c])
for p in p_levels_plot
])
T_env_prof = np.array([
float(ds_wrf["T_pres"].sel(pressure=p).isel(time=t_idx).values[i_e, j_e])
for p in p_levels_plot
])
ax.plot(T_center_prof, p_levels_plot, "o-", color=col_c, linewidth=2.2,
markersize=7, label="TC Center", zorder=3)
ax.plot(T_env_prof, p_levels_plot, "s--", color=col_e, linewidth=1.8,
markersize=6, label="Environment", zorder=2)
# Shading warm-core region
ax.fill_betweenx(p_levels_plot, T_env_prof, T_center_prof,
where=(T_center_prof > T_env_prof),
alpha=0.25, color="#e63946", label="Warm-core anomaly")
# Annotate dT at 500 hPa
idx_500 = list(p_levels_plot).index(500)
dT_500 = T_center_prof[idx_500] - T_env_prof[idx_500]
ax.annotate(f"dT = {dT_500:.1f} K",
xy=(T_center_prof[idx_500], 500),
xytext=(T_center_prof[idx_500] + 1.5, 460),
fontsize=10, color="#c1121f", weight="bold",
arrowprops=dict(arrowstyle="->", color="#c1121f", lw=1.5))
ax.set_xlabel("Suhu (K)", fontsize=11)
ax.set_ylabel("Tekanan (hPa)", fontsize=11)
# ylim dengan besar di atas (high pressure = rendah di atmosfer)
ax.set_ylim(1050, 150)
ax.set_yscale("linear")
ax.set_title(f"Profil Vertikal Suhu\n{t_label}", fontsize=11, weight="bold")
ax.grid(True, linestyle=":", alpha=0.5, linewidth=0.8)
ax.legend(fontsize=9, loc="lower right")
# Tandai level 500 dan 850 hPa
x_min = T_env_prof.min() - 1.5
for p_mark, p_lbl in [(500, "500 hPa"), (850, "850 hPa")]:
ax.axhline(p_mark, color="gray", linestyle=":", linewidth=0.7, alpha=0.7)
ax.text(x_min, p_mark - 15, p_lbl, fontsize=8, color="gray")
fig.suptitle(
"Warm-Core Anomaly Siklon Tropis — Profil Suhu Vertikal\n"
"Center TC vs Environment pada Awal dan Puncak Intensifikasi",
fontsize=12, weight="bold", y=1.01
)
plt.tight_layout()
plt.savefig("/work/wrf_warmcore_profile.png", dpi=150, bbox_inches="tight")
print("Plot saved: wrf_warmcore_profile.png")
Profil vertikal di atas menunjukkan warm-core signature yang khas: kurva merah (TC center) berada di kanan dari kurva biru (environment), terutama di lapisan 300–500 hPa. Selisih ini adalah \(\Delta T_{\text{wc}}\) — shading merah memvisualisasikan besar anomali tersebut. Perhatikan bagaimana di panel kanan (t=11h) jarak antara kedua kurva makin lebar dibanding panel kiri (t=0h), mencerminkan intensifikasi warm core seiring pendalaman TC.
Konteks Operasional dan Langkah Berikutnya
Di BMKG TCWC Jakarta, estimasi intensitas TC primer menggunakan teknik Dvorak berbasis citra satelit: meteorolog menganalisis pola cloud dan mengidentifikasi T-number yang berkorelasi ke wind speed dan central pressure. Error rata-rata teknik Dvorak dibanding pengukuran pesawat pengintai sekitar 10 hPa. NWP model seperti WRF memberikan lapisan informasi tambahan: struktur 3D TC, prediksi rapid intensification, dan analisis interaksi TC dengan orografi atau monsun.
Pipeline yang kita bangun dalam tutorial ini — ekstraksi minimum SLP, \(V_{\max}\), dan warm-core anomaly dari model output — adalah fondasi analisis yang lebih lanjut. Beberapa ekstensi praktis yang bisa dicoba selanjutnya:
Otomasi tracking intensitas. Gunakan loop across forecast hours untuk mengekstrak time series intensitas sepanjang simulasi WRF multi-hari. HWRF (Hurricane WRF) yang dioperasikan NOAA menggunakan vortex-following nested grid dengan resolusi inner domain 1,5 km — pendekatan ini kini diteruskan oleh HAFS (Hurricane Analysis and Forecast System) yang menggantikannya secara operasional.
Validasi terhadap satellite imagery. Bandingkan output SLP minimum model dengan estimasi Dvorak dari GOES-18/19 atau VIIRS brightness temperature. Resolusi GOES-R setiap 1 menit untuk mode scanning Mesoscale sangat berguna untuk validasi rapid intensification.
Ocean coupling untuk intensitas. Aktifkan sf_ocean_physics=1 di namelist WRF untuk mengaktifkan 1-D mixed layer model dengan SST cooling feedback. Ini penting untuk simulasi TC yang lebih akurat karena TC yang bergerak lambat akan mendinginkan laut di bawahnya, mereduksi intensitas — sebuah feedback yang tidak tertangkap dalam mode SST-fixed.
Perbandingan dengan ERA5 TC tracks. Data ERA5 menyediakan best-estimate pressure dan wind untuk siklon historis — bisa digunakan sebagai pseudo-observation untuk memvalidasi simulasi WRF hindcast. IBTrACS juga menyediakan best-track data untuk semua TC termasuk wilayah tanggung jawab BMKG TCWC Jakarta.
Eksplorasi artikel meteorologi lainnya di meteo.my.id — kunjungi https://meteo.my.id untuk lebih banyak tutorial data cuaca dan analisis atmosfer.
Referensi
- Hurricane Weather Research Forecast Model — NOAA/AOML — dokumentasi resmi HWRF, sistem WRF operasional NOAA untuk prediksi intensitas hurricane dengan inner domain 1,5 km dan assimilasi reconnaissance data.
- WRF Physics — WRF Users Guide (NCAR/MMM) — referensi lengkap physics parameterizations WRF v4.5 termasuk tropical physics suite (WSM6, New Tiedtke, RRTMG) dan opsi ocean coupling untuk simulasi TC.
- TCFAQ H1: Dvorak Technique — NOAA HRD — penjelasan teknik Dvorak untuk estimasi intensitas TC dari citra satelit berdasarkan T-number dan CI number.
- Cyclone Flurry in the Southern Hemisphere — NASA Earth Observatory — artikel NASA tentang lima siklon tropis aktif bersamaan di Belahan Selatan, Februari 2025, termasuk kawasan tanggung jawab BMKG TCWC Jakarta.
- NOAA Satellites Have You Covered This Hurricane Season — NESDIS — penjelasan peran GOES-R dan JPSS dalam pemantauan track dan intensitas TC, termasuk deteksi rapid intensification.
