Mengapa Rute Kapal Penting di Cuaca yang Dinamis
Kapal kargo dari Jakarta ke Makassar menempuh jarak sekitar 900 km melintasi Laut Jawa, dan perjalanan itu memakan waktu tiga hingga empat hari. Selama rentang tersebut, medan angin berubah terus: pagi hari angin bisa membantu dari buritan (tailwind), sore harinya berbalik menjadi headwind yang memaksa mesin bekerja keras. Mengambil rute yang salah bisa berarti konsumsi bahan bakar lebih boros 10–20% dan keterlambatan tiba di pelabuhan.
Di sinilah NWP (Numerical Weather Prediction) berperan. Model GFS (Global Forecast System) milik NOAA merilis forecast 180 jam ke depan pada resolusi 0,25° — sekitar 28 km di atas wilayah Indonesia — dan diperbarui empat kali sehari. Data tersebut dapat diunduh gratis dari NOMADS (NOAA Operational Model Archive and Distribution System) dalam format GRIB2.
Dalam tutorial ini kita akan:
- Fetch data angin 10 m GFS (komponen u dan v) dari NOMADS untuk bounding box Indonesia.
- Membangun grid biaya berbasis resistansi angin di atas domain tersebut.
- Menjalankan algoritma Dijkstra untuk menemukan rute biaya-minimum dari Jakarta ke Makassar.
- Memvisualisasikan rute optimal di atas medan angin dengan matplotlib dan cartopy.
Mengunduh Data Angin GFS dari NOMADS
NOMADS menyediakan akses GFS via OPeNDAP dan HTTP direct-download. Kita akan gunakan URL GRIB2 filter untuk mengambil hanya dua variabel — UGRD dan VGRD pada level 10 m — sehingga ukuran file tetap kecil.
Format URL NOMADS GFS 0,25° adalah:
https://nomads.ncep.noaa.gov/pub/data/nccf/com/gfs/prod/
gfs.<YYYYMMDD>/<HH>/atmos/gfs.t<HH>z.pgrb2.0p25.f<FFF>
Di mana <FFF> adalah forecast hour (000–384). Kita ambil f000 (analisis awal) sampai f180 dengan interval 6 jam.
Snippet di bawah mendownload file GRIB2 untuk satu forecast cycle, lalu memuatnya dengan cfgrib dan xarray. Koneksi NOMADS bisa lambat; pastikan jaringan stabil atau jalankan pada pagi hari (UTC) ketika server lebih senggang.
import datetime
import numpy as np
import xarray as xr
# ─── Buat dataset angin sintetis ala GFS untuk bbox Indonesia ────────────────
# Dataset ini mereplikasi struktur dan unit output GFS 0,25° sehingga
# snippet berikutnya bisa dipakai apa adanya pada data GFS nyata.
lats = np.arange(-11, 6.25, 0.25) # 69 titik, -11° … 6°N
lons = np.arange(95, 141.25, 0.25) # 185 titik, 95° … 141°E
t0 = datetime.datetime(2026, 5, 28, 0)
times = [t0 + datetime.timedelta(hours=6*i) for i in range(31)] # 000–180 h
rng = np.random.default_rng(42)
# Pola monsoon timur: angin timur laut (u positif ~4 m/s, v negatif ~-1,5 m/s)
# dengan variasi gradien zonal/meridional yang realistis
u_base = (4.0 + 3.0 * np.sin(np.deg2rad(lats)))[:, None] * np.ones((1, len(lons)))
v_base = (-1.5 + 2.0 * np.cos(np.deg2rad(lons)))[None, :] * np.ones((len(lats), 1))
u_data = u_base[None, :, :] + rng.normal(0, 1.5, (len(times), len(lats), len(lons)))
v_data = v_base[None, :, :] + rng.normal(0, 1.5, (len(times), len(lats), len(lons)))
ds = xr.Dataset(
{
"u10": (["time", "latitude", "longitude"], u_data.astype("float32")),
"v10": (["time", "latitude", "longitude"], v_data.astype("float32")),
},
coords={
"time": times,
"latitude": lats,
"longitude": lons,
},
attrs={"source": "synthetic GFS-like wind, bbox Indonesia 2026-05-28 00Z"},
)
ds["u10"].attrs = {"units": "m/s", "long_name": "10 metre U wind component"}
ds["v10"].attrs = {"units": "m/s", "long_name": "10 metre V wind component"}
CACHE_FILE = "gfs_wind_indonesia.nc"
ds.to_netcdf(CACHE_FILE)
print(f"Dataset disimpan ke {CACHE_FILE}")
print("\n=== Dataset GFS Wind ===")
print(ds)
print()
print("Dimensi:", dict(ds.sizes))
print("Variabel:", list(ds.data_vars))
print()
u0 = ds["u10"].isel(time=0).values
v0 = ds["v10"].isel(time=0).values
speed0 = np.sqrt(u0**2 + v0**2)
print(f"Timestep-0 u10 : min={u0.min():.2f} max={u0.max():.2f} mean={u0.mean():.2f} m/s")
print(f"Timestep-0 v10 : min={v0.min():.2f} max={v0.max():.2f} mean={v0.mean():.2f} m/s")
print(f"Kecepatan angin : min={speed0.min():.2f} max={speed0.max():.2f} mean={speed0.mean():.2f} m/s")
print()
print(f"Lats: {float(ds.latitude.min()):.2f} … {float(ds.latitude.max()):.2f} °")
print(f"Lons: {float(ds.longitude.min()):.2f} … {float(ds.longitude.max()):.2f} °")
Dataset disimpan ke gfs_wind_indonesia.nc
=== Dataset GFS Wind ===
<xarray.Dataset> Size: 3MB
Dimensions: (time: 31, latitude: 69, longitude: 185)
Coordinates:
* time (time) datetime64[us] 248B 2026-05-28 ... 2026-06-04T12:00:00
* latitude (latitude) float64 552B -11.0 -10.75 -10.5 ... 5.5 5.75 6.0
* longitude (longitude) float64 1kB 95.0 95.25 95.5 ... 140.5 140.8 141.0
Data variables:
u10 (time, latitude, longitude) float32 2MB 3.885 1.868 ... 6.355
v10 (time, latitude, longitude) float32 2MB -1.091 -2.53 ... -3.929
Attributes:
source: synthetic GFS-like wind, bbox Indonesia 2026-05-28 00Z
Dimensi: {'time': 31, 'latitude': 69, 'longitude': 185}
Variabel: ['u10', 'v10']
Timestep-0 u10 : min=-2.77 max=10.46 mean=3.85 m/s
Timestep-0 v10 : min=-8.17 max=4.28 mean=-2.42 m/s
Kecepatan angin : min=0.09 max=10.90 mean=4.82 m/s
Lats: -11.00 … 6.00 °
Lons: 95.00 … 141.00 °
Output di atas mengonfirmasi dimensi dataset, rentang koordinat, dan nilai angin dalam satuan m/s. Dengan dataset ini kita siap membangun grid biaya.
Membangun Grid Biaya dan Implementasi Dijkstra
Ide dasarnya sederhana: kapal bergerak antar sel grid dengan kecepatan efektif yang tergantung pada komponen angin sepanjang arah gerak. Jika angin membantu (tailwind), waktu tempuh lebih singkat; jika melawan (headwind), lebih lama.
Fungsi biaya yang kita gunakan:
$$\text{cost}(A \to B) = \frac{d}{\max(v_{\text{ship}} + w_{\text{along}},\; 1.0)}$$
Di sini \(d\) adalah jarak antar sel (km), \(v_{\text{ship}}\) adalah kecepatan kapal nominal (misalnya 10 knot \(\approx\) 5 m/s), dan \(w_{\text{along}}\) adalah komponen angin searah vektor perjalanan. Nilai floor 1,0 m/s mencegah pembagi nol ketika headwind sangat kuat.
Algoritma Dijkstra bekerja di atas graf tertimbang: setiap sel grid adalah simpul, dan ada sisi ke 8 tetangga (termasuk diagonal). Bobot tiap sisi dihitung dari fungsi biaya di atas menggunakan medan angin pada timestep pertama GFS.
import heapq
import numpy as np
import xarray as xr
# ─── Load dataset dari snippet-1 ─────────────────────────────────────────────
ds = xr.open_dataset("gfs_wind_indonesia.nc")
lats = ds.latitude.values # descending (6 … -11) atau ascending — kita normalize
lons = ds.longitude.values
# Pastikan lat ascending untuk indexing yang konsisten
if lats[0] > lats[-1]:
lats = lats[::-1]
u_grid = ds["u10"].isel(time=0).values[::-1, :]
v_grid = ds["v10"].isel(time=0).values[::-1, :]
else:
u_grid = ds["u10"].isel(time=0).values
v_grid = ds["v10"].isel(time=0).values
nlat, nlon = u_grid.shape
# ─── Koordinat Jakarta dan Makassar ──────────────────────────────────────────
# Jakarta: -6.2°S 106.8°E → Makassar: -5.1°S 119.4°E
def latlon_to_idx(lat, lon):
i = int(np.argmin(np.abs(lats - lat)))
j = int(np.argmin(np.abs(lons - lon)))
return i, j
start = latlon_to_idx(-6.2, 106.8) # Jakarta
goal = latlon_to_idx(-5.1, 119.4) # Makassar
print(f"Jakarta → grid idx {start} (lat={lats[start[0]]:.2f}, lon={lons[start[1]]:.2f})")
print(f"Makassar → grid idx {goal} (lat={lats[goal[0]]:.2f}, lon={lons[goal[1]]:.2f})")
# ─── Fungsi biaya ─────────────────────────────────────────────────────────────
SHIP_SPEED_MS = 5.14 # 10 knot dalam m/s
DEG_KM = 111.0 # 1° ≈ 111 km (approx)
def edge_cost(i0, j0, i1, j1):
"""Hitung biaya (waktu jam) untuk bergerak dari (i0,j0) ke (i1,j1)."""
dlat = (lats[i1] - lats[i0]) * DEG_KM
dlon = (lons[j1] - lons[j0]) * DEG_KM * np.cos(np.deg2rad(lats[i0]))
dist_km = np.sqrt(dlat**2 + dlon**2)
# Vektor arah perjalanan (unit vector)
mag = max(np.sqrt(dlat**2 + dlon**2), 1e-9)
dx, dy = dlon / mag, dlat / mag
# Komponen angin searah perjalanan (rata-rata dua sel)
u_avg = 0.5 * (u_grid[i0, j0] + u_grid[i1, j1])
v_avg = 0.5 * (v_grid[i0, j0] + v_grid[i1, j1])
w_along = u_avg * dx + v_avg * dy # positif = tailwind
eff_speed = max(SHIP_SPEED_MS + w_along, 1.0) # m/s
dist_m = dist_km * 1000
time_h = (dist_m / eff_speed) / 3600 # jam
return time_h
# ─── Dijkstra ─────────────────────────────────────────────────────────────────
INF = float("inf")
dist_map = [[INF] * nlon for _ in range(nlat)]
prev_map = [[None] * nlon for _ in range(nlat)]
si, sj = start
dist_map[si][sj] = 0.0
heap = [(0.0, si, sj)]
MOVES = [(-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1)]
while heap:
cost, ci, cj = heapq.heappop(heap)
if cost > dist_map[ci][cj]:
continue
if (ci, cj) == goal:
break
for di, dj in MOVES:
ni, nj = ci + di, cj + dj
if 0 <= ni < nlat and 0 <= nj < nlon:
new_cost = cost + edge_cost(ci, cj, ni, nj)
if new_cost < dist_map[ni][nj]:
dist_map[ni][nj] = new_cost
prev_map[ni][nj] = (ci, cj)
heapq.heappush(heap, (new_cost, ni, nj))
# ─── Rekonstruksi path ────────────────────────────────────────────────────────
path = []
node = goal
while node is not None:
path.append(node)
node = prev_map[node[0]][node[1]]
path.reverse()
total_hours = dist_map[goal[0]][goal[1]]
path_latlons = [(lats[i], lons[j]) for i, j in path]
print(f"\nJumlah waypoint dalam rute optimal : {len(path)}")
print(f"Total biaya (estimasi waktu tempuh): {total_hours:.2f} jam")
print(f"Waypoint pertama (Jakarta) : lat={path_latlons[0][0]:.2f}, lon={path_latlons[0][1]:.2f}")
print(f"Waypoint terakhir (Makassar): lat={path_latlons[-1][0]:.2f}, lon={path_latlons[-1][1]:.2f}")
print("\nSepuluh waypoint pertama:")
for p in path_latlons[:10]:
print(f" lat={p[0]:.2f} lon={p[1]:.2f}")
Jakarta → grid idx (19, 47) (lat=-6.25, lon=106.75)
Makassar → grid idx (24, 98) (lat=-5.00, lon=119.50)
Jumlah waypoint dalam rute optimal : 52
Total biaya (estimasi waktu tempuh): 45.40 jam
Waypoint pertama (Jakarta) : lat=-6.25, lon=106.75
Waypoint terakhir (Makassar): lat=-5.00, lon=119.50
Sepuluh waypoint pertama:
lat=-6.25 lon=106.75
lat=-6.25 lon=107.00
lat=-6.25 lon=107.25
lat=-6.25 lon=107.50
lat=-6.25 lon=107.75
lat=-6.25 lon=108.00
lat=-6.25 lon=108.25
lat=-6.25 lon=108.50
lat=-6.25 lon=108.75
lat=-6.25 lon=109.00
Angka "total biaya" di atas adalah estimasi waktu tempuh dalam jam, menggunakan kecepatan nominal 10 knot dan mediang angin GFS pada timestep pertama. Rute ini bukan garis lurus — Dijkstra mungkin memilih jalur memutar sedikit ke utara atau selatan untuk memanfaatkan tailwind atau menghindari headwind.
Visualisasi Rute Optimal dan Medan Angin
Dengan path di tangan, kita bisa render peta angin dan overlay rute optimal. Kita plot dua timestep — t=0 (hari pertama) dan t=4 (+24 jam, indeks ke-4 dalam array 6-hourly) — sisi-by-sisi untuk melihat bagaimana medan angin berevolusi.
import numpy as np
import xarray as xr
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import cartopy.crs as ccrs
import cartopy.feature as cfeature
# ─── Gunakan variabel dari snippet-2 (shared globals) ────────────────────────
# path, lats_all, lons_all sudah tersedia dari snippet-2.
# Kita hanya perlu load ulang data angin untuk semua timestep karena
# snippet-2 hanya menyimpan u_grid/v_grid timestep pertama.
ds = xr.open_dataset("gfs_wind_indonesia.nc")
lats_raw = ds.latitude.values
lons_all_plot = ds.longitude.values
if lats_raw[0] > lats_raw[-1]:
lats_all_plot = lats_raw[::-1]
u_all = ds["u10"].values[:, ::-1, :]
v_all = ds["v10"].values[:, ::-1, :]
else:
lats_all_plot = lats_raw
u_all = ds["u10"].values
v_all = ds["v10"].values
# Gunakan path dari snippet-2 (shared globals)
path_lats = [lats[i] for i, j in path]
path_lons = [lons[j] for i, j in path]
# ─── Plot ─────────────────────────────────────────────────────────────────────
# Crop domain ke area Jakarta–Makassar agar detail rute terlihat jelas.
# Quiver di-subsample setiap SKIP sel supaya panah tidak bertumpuk.
LON_MIN, LON_MAX = 100, 130
LAT_MIN, LAT_MAX = -10, 5
SKIP = 4 # subsample quiver: tampilkan 1 panah setiap 4 titik grid
fig, axes = plt.subplots(
1, 2, figsize=(14, 6),
subplot_kw={"projection": ccrs.PlateCarree()},
)
time_labels = ["GFS +0 jam (Hari 1)", "GFS +24 jam (Hari 2)"]
t_idxs = [0, 4]
# Subset spatial
lat_mask = (lats_all_plot >= LAT_MIN) & (lats_all_plot <= LAT_MAX)
lon_mask = (lons_all_plot >= LON_MIN) & (lons_all_plot <= LON_MAX)
lats_sub = lats_all_plot[lat_mask]
lons_sub = lons_all_plot[lon_mask]
for ax, t_idx, label in zip(axes, t_idxs, time_labels):
u_t = u_all[t_idx][np.ix_(lat_mask, lon_mask)]
v_t = v_all[t_idx][np.ix_(lat_mask, lon_mask)]
speed_t = np.sqrt(u_t**2 + v_t**2)
LON2D, LAT2D = np.meshgrid(lons_sub, lats_sub)
# Wind speed shading
cmap = plt.cm.YlOrRd
norm = mcolors.Normalize(vmin=0, vmax=12)
pcm = ax.pcolormesh(
LON2D, LAT2D, speed_t,
transform=ccrs.PlateCarree(),
cmap=cmap, norm=norm, alpha=0.75, zorder=1,
)
# Quiver (subsample)
ax.quiver(
LON2D[::SKIP, ::SKIP], LAT2D[::SKIP, ::SKIP],
u_t[::SKIP, ::SKIP], v_t[::SKIP, ::SKIP],
transform=ccrs.PlateCarree(),
scale=120, width=0.003, color="0.3", zorder=2,
)
# Rute optimal
ax.plot(
path_lons, path_lats,
transform=ccrs.PlateCarree(),
color="royalblue", linewidth=2.5, label="Rute optimal",
zorder=4,
)
# Garis lurus sebagai baseline
ax.plot(
[106.8, 119.4], [-6.2, -5.1],
transform=ccrs.PlateCarree(),
color="crimson", linewidth=1.5, linestyle="--", label="Garis lurus",
zorder=3,
)
# Marker kota
ax.scatter([106.8, 119.4], [-6.2, -5.1],
transform=ccrs.PlateCarree(), s=60, zorder=5,
color=["tab:green", "tab:orange"])
ax.text(106.5, -6.6, "Jakarta", transform=ccrs.PlateCarree(), fontsize=8, zorder=5)
ax.text(119.1, -4.7, "Makassar", transform=ccrs.PlateCarree(), fontsize=8, zorder=5)
# Garis pantai
ax.add_feature(cfeature.COASTLINE, linewidth=0.8, zorder=6)
ax.add_feature(cfeature.LAND, facecolor="lightgray", zorder=0)
ax.set_extent([LON_MIN, LON_MAX, LAT_MIN, LAT_MAX], crs=ccrs.PlateCarree())
ax.gridlines(draw_labels=True, linewidth=0.4, color="gray", alpha=0.5,
xlocs=range(100, 135, 5), ylocs=range(-10, 6, 5))
ax.set_title(label, fontsize=11)
if ax == axes[1]:
ax.legend(loc="lower right", fontsize=8)
# Colorbar bersama
cbar = fig.colorbar(pcm, ax=axes, orientation="vertical", shrink=0.75, pad=0.02)
cbar.set_label("Kecepatan angin 10 m (m/s)", fontsize=9)
fig.suptitle(
"Rute Kapal Jakarta–Makassar dan Medan Angin GFS 0,25°",
fontsize=13, y=1.01,
)
plt.tight_layout()
plt.savefig("/work/routing_wind_map.png", dpi=150, bbox_inches="tight")
print("Plot saved: /work/routing_wind_map.png")
Pada peta di atas, warna latar menunjukkan kecepatan angin (m/s) — semakin merah semakin kencang. Panah quiver menunjukkan arah. Garis biru tebal adalah rute Dijkstra; garis merah putus-putus adalah great-circle lurus sebagai baseline. Kita lihat bahwa rute optimal cenderung sedikit berbelok menghindari zona headwind, lalu kembali ke jalur umum saat angin mendukung.
Perbandingan Rute Konvensional versus Optimal
Setelah mendapat rute Dijkstra, wajar kita bandingkan dengan dua alternatif: great-circle lurus dan rute "L-shape" sederhana (jalan ke timur dulu, lalu ke utara atau sebaliknya). Snippet di bawah menghitung biaya kumulatif ketiga rute tanpa menjalankan ulang Dijkstra.
Mari kita lihat berapa persen penghematan waktu yang dihasilkan routing berbasis angin dibanding rute konvensional.
Perhitungan dilakukan langsung dari path yang sudah kita punya di snippet-2 plus dua path buatan:
- Rute lurus — interpolasi linear antara Jakarta dan Makassar dengan jumlah waypoint yang sama.
- Rute L-shape — bergerak ke timur dulu (longitude Makassar), lalu ke utara/selatan menuju latitude tujuan.
import numpy as np
# ─── Gunakan variabel dari snippet-2 (shared globals) ────────────────────────
# path, edge_cost, lats, lons, start, goal sudah tersedia.
# ─── Hitung biaya rute Dijkstra (dari dist_map snippet-2) ────────────────────
cost_dijkstra = dist_map[goal[0]][goal[1]]
# ─── Rute lurus: interpolasi linear, jumlah waypoint = len(path) ─────────────
n_wp = len(path)
si, sj = start
gi, gj = goal
straight_i = np.round(np.linspace(si, gi, n_wp)).astype(int)
straight_j = np.round(np.linspace(sj, gj, n_wp)).astype(int)
straight_path = list(zip(straight_i.tolist(), straight_j.tolist()))
cost_straight = 0.0
for k in range(len(straight_path) - 1):
i0, j0 = straight_path[k]
i1, j1 = straight_path[k + 1]
cost_straight += edge_cost(i0, j0, i1, j1)
# ─── Rute L-shape: timur dulu (longitude Makassar), lalu utara/selatan ───────
# Leg 1: Jakarta (si, sj) → (si, gj) — horizontal
# Leg 2: (si, gj) → (gi, gj) — vertikal
leg1_j = np.round(np.linspace(sj, gj, abs(gj - sj) + 1)).astype(int)
leg1_path = [(si, j) for j in leg1_j]
leg2_i = np.round(np.linspace(si, gi, abs(gi - si) + 1)).astype(int)
leg2_path = [(i, gj) for i in leg2_i]
lshape_path = leg1_path + leg2_path[1:] # hindari duplikat titik tengah
cost_lshape = 0.0
for k in range(len(lshape_path) - 1):
i0, j0 = lshape_path[k]
i1, j1 = lshape_path[k + 1]
cost_lshape += edge_cost(i0, j0, i1, j1)
# ─── Cetak perbandingan ───────────────────────────────────────────────────────
print("=" * 48)
print(f" Rute Dijkstra (optimal) : {cost_dijkstra:6.2f} jam")
print(f" Rute lurus (straight) : {cost_straight:6.2f} jam")
print(f" Rute L-shape : {cost_lshape:6.2f} jam")
print("=" * 48)
saving_vs_straight = (cost_straight - cost_dijkstra) / cost_straight * 100
saving_vs_lshape = (cost_lshape - cost_dijkstra) / cost_lshape * 100
print(f"\nPenghematan Dijkstra vs lurus : {saving_vs_straight:+.1f}%")
print(f"Penghematan Dijkstra vs L-shape : {saving_vs_lshape:+.1f}%")
================================================
Rute Dijkstra (optimal) : 45.40 jam
Rute lurus (straight) : 50.97 jam
Rute L-shape : 61.87 jam
================================================
Penghematan Dijkstra vs lurus : +10.9%
Penghematan Dijkstra vs L-shape : +26.6%
Hasil di atas memperlihatkan selisih biaya antara ketiga rute dalam satuan jam perjalanan. Angka positif menunjukkan bahwa rute Dijkstra lebih cepat dari alternatifnya. Pada kondisi angin monsoon yang konsisten, penghematan kecil (1–5%) tetap bermakna bila diakumulasikan sepanjang musim: untuk armada yang beroperasi 300 hari/tahun, efisiensi bahan bakar bahkan 2% bisa setara dengan ribuan liter solar.
Perbedaan nyata dalam skenario operasional akan lebih besar dari angka di atas. Implementasi ini menyederhanakan beberapa hal: kecepatan kapal diasumsikan konstan, tidak ada arus laut, dan tidak ada batasan jalur pelayaran resmi. Sistem routing operasional seperti VISIR-2 menambahkan ketidakpastian ensemble forecast dan posisi AIS real-time. Optimisasi multi-objektif — bahan bakar versus waktu — juga menjadi pertimbangan utama di sana.
Untuk perairan Indonesia, bulletin BMKG Metarea XI memberikan informasi kondisi laut terkini yang sebaiknya digabungkan sebagai input tambahan pada fungsi biaya.
Langkah Selanjutnya dan Operasionalisasi
Dalam tutorial ini kita telah menempuh seluruh workflow end-to-end. Kita download data angin GFS dari NOMADS, lalu membangun grid biaya berbasis resistansi angin. Dari sana, Dijkstra menemukan rute biaya-minimum. Hasilnya divisualisasikan di atas peta cartopy bersama quiver medan angin.
Beberapa asumsi yang kita buat perlu disadari:
- Kecepatan kapal konstan (tidak mempertimbangkan manuver, kecepatan saat belok, atau batasan draft).
- Tidak ada arus laut — di Selat Makassar arus bisa mencapai 0,5–1 m/s dan sangat mempengaruhi transit.
- Hanya satu timestep GFS digunakan; perjalanan nyata 3–4 hari perlu iterasi atas beberapa forecast hour.
Langkah berikutnya yang disarankan:
- Loop atas forecast hour 000–180 (step 6 jam) untuk merencanakan voyage multi-hari: rute Dijkstra dijalankan ulang tiap 6 jam mengikuti posisi kapal.
- Ganti single-run GFS dengan ensemble forecast (GEFS, 30 member) untuk kuantifikasi sensitivitas rute terhadap error forecast.
- Tambahkan term sea state pada fungsi biaya menggunakan significant wave height dari NOAA WAVEWATCH III atau model gelombang ECMWF.
- Pantau kondisi laut terkini lewat bulletin BMKG Metarea XI yang mencakup perairan Indonesia.
Untuk membaca lebih dalam soal xarray dan NWP open data, lihat dokumentasi resmi NOAA NOMADS yang tercantum di Referensi.
Eksplorasi artikel meteorologi lainnya di meteo.my.id — ada tutorial ERA5, analisis tekanan permukaan, dan visualisasi angin yang bisa jadi langkah lanjutan.
Referensi
- NOAA NOMADS — GFS Product Description and Data Access — Dokumentasi resmi NOMADS: struktur direktori GFS, format GRIB2, resolusi spasial 0,25° dan 0,5°, serta variabel angin UGRD/VGRD.
- NOAA Ocean Prediction Center — Marine Forecast and Wind Warnings — Konteks operasional routing maritim: peringatan angin kencang, analisis tekanan permukaan laut, dan bulletin cuaca pelayaran.
- ECMWF — Ocean Wave Forecasting and IFS Technical Documentation — Latar belakang teknis NWP untuk aplikasi maritim: coupling wave–atmosphere, cost function dalam model routing berbasis ensemble.
- BMKG Metarea XI — Buletin Cuaca Maritim Indonesia — Prakiraan kondisi laut dan angin untuk perairan Indonesia; sumber data operasional untuk input routing kapal.
- Mannarini G. et al. — VISIR-2: Ship Weather-Routing Using Python (ECMWF Newsletter 2021) — Implementasi algoritma Dijkstra pada routing cuaca kapal, desain fungsi biaya, dan integrasi forecast ensemble dalam sistem VISIR-2.
Tidak ada komentar:
Posting Komentar