Arkaan Vito (2306266243) – Analisis Optimasi Pelabuhan dan Rantai Pasok Maritim: Pendekatan DAI5 – Minggu Kedua (27 April 2026)

Salam, Saudara/i. Saya akan memandu proses pemikiran ini menggunakan kerangka kerja DAI5, memastikan bahwa model yang dikembangkan tidak hanya secara matematis valid tetapi juga memiliki kesadaran (consciousness) terhadap batasan fisik dan tujuan (Intention) yang telah ditetapkan.

🚢 Proses Pemikiran DAI5 untuk Dinamika Antrean Kapal

🌟 1. Deep Awareness of I (Kesadaran Mendalam)

Sebelum menyentuh matematika, kita perlu menyadari hakikat masalahnya: Dinamika antrean kapal adalah sistem non-linear yang sangat dipengaruhi oleh batasan fisik (kapasitas dermaga) dan faktor eksternal (arus kedatangan/keberangkatan).
Kesadaran di sini mengajarkan kita bahwa model yang ideal tidak boleh hanya berupa fungsi matematika semata; ia harus terikat oleh Hukum Fisika—dermaga tidak bisa memiliki kapasitas tak terhingga, dan antrean tidak pernah bisa negatif.

🌟 2. Intention (Tujuan)

Menciptakan model diskret (iteratif) yang menggambarkan perubahan jumlah kapal yang menunggu ($N_{t+1}$) berdasarkan jumlah kapal yang menunggu saat ini ($N_t$), dengan mempertimbangkan laju kedatangan (arrival rate) dan laju pelayanan (service rate) yang dipengaruhi oleh kapasitas.

🧮 Model Iteratif (Diskret)

Kita akan mendefinisikan model kuantitas diskret $N_t$, di mana $N_t$ adalah jumlah kapal menunggu pada waktu $t$.

Asumsi Dasar:

Kapasitas Maksimum ($K$): Dermaga memiliki kapasitas maksimal $K$. Jika $N_t > K$, maka $N_t = K$.
Laju Kedatangan ($\lambda$): Tingkat kedatangan kapal diasumsikan konstan atau terkait dengan waktu.
Laju Pelayanan ($\mu$): Tingkat pelayanan maksimal adalah $\mu$.

Model Dinamika:
$$N_{t+1} = \min \left( K, N_t + \text{Arrival}{t} – \text{Service}{t} \right)$$

Formulasi Fungsi Non-Linear (Fokus pada Saturasi/Saturation)

Untuk memasukkan efek saturasi (yaitu, laju pelayanan yang menurun saat antrian sangat padat, atau sebaliknya, laju kedatangan yang melambat saat infrastruktur penuh), kita dapat memodifikasi komponen layanan:

Laju Pelayanan yang Terkendala: $\text{Service}_{t} = \mu \cdot \left( \frac{N_t}{N_t + 1} \right)$
(Interpretasi: Saat $N_t$ kecil, pelayanan mendekati $\mu$. Saat $N_t$ sangat besar, peningkatan jumlah kapal tidak secara linier meningkatkan efisiensi pelayanan, namun kita akan menggunakan pendekatan yang lebih sederhana untuk demonstrasi.)

Model Sederhana Berbasis Antrian (M/M/1 Analogue):
Kita akan menggunakan pendekatan yang fokus pada batasan kapasitas ($K$) dan laju kedatangan konstan ($\lambda$).

$$N_{t+1} = \min \left( K, \max \left( 0, N_t + \lambda – \mu \right) \right)$$

Menggunakan Fungsi Sigmoid (Sigmoid Function – untuk menggambarkan dinamika non-linear):
Jika kita ingin modelnya lebih kompleks, kita bisa membuat $\text{Arrival}$ bergantung pada seberapa jauh dari kapasitas penuh, menggunakan fungsi sigmoid $S(x) = \frac{1}{1+e^{-x}}$.

$$\text{Arrival}_{t} = \lambda \cdot \left( 1 – e^{-(N_t / (K/2))} \right)$$
(Interpretasi: Jika $N_t$ jauh dari kapasitas ($K$), laju kedatangan mendekati $\lambda$. Jika $N_t \to K$, laju kedatangan melambat karena kemacetan (Congestion Effect).)

Model Akhir yang Dipilih (Mendukung Saturation):
$$N_{t+1} = \min \left( K, \max \left( 0, N_t + \lambda_{adj}(N_t) – \mu \right) \right)$$
Di mana $\lambda_{adj}(N_t)$ adalah laju kedatangan yang disesuaikan oleh kemacetan.

💻 Implementasi Simulasi (Python Pseudo-Code)

Asumsikan:

$K = 10$ (Kapasitas maksimum)
$\lambda_{max} = 1.5$ (Laju kedatangan maksimum per periode)
$\mu = 1.0$ (Laju pelayanan konstan per periode)
$N_0 = 3$ (Keadaan awal)

import numpy as np

def calculate_arrival(N_t, K, lambda_max):
    """Menghitung laju kedatangan yang disesuaikan oleh kemacetan (Congestion)."""
    # Menggunakan fungsi sigmoid yang terpusat pada K/2 untuk membatasi pertumbuhan
    congestion_factor = 1 / (1 + np.exp(-2 * (N_t - K/2) / (K/4)))
    return lambda_max * congestion_factor

def simulate_queue(K, lambda_max, mu, N_initial, num_periods):
    N_t = N_initial
    history = [N_t]

    for t in range(num_periods):
        # 1. Calculate adjusted arrival
        arrivals = calculate_arrival(N_t, K, lambda_max)

        # 2. Calculate next state
        N_next_raw = N_t + arrivals - mu

        # 3. Apply constraints (Non-negativity and Max Capacity K)
        N_t = np.clip(N_next_raw, 0, K)

        history.append(N_t)

    return history

# Parameters
K_CAP = 10.0
LAMBDA_MAX = 1.5
MU_RATE = 1.0
N_INITIAL = 3.0
PERIODS = 30

# Run simulation
queue_history = simulate_queue(K_CAP, LAMBDA_MAX, MU_RATE, N_INITIAL, PERIODS)

# print(f"Queue size over {PERIODS} periods: {queue_history}")

📊 Hasil dan Interpretasi

Model yang menggunakan fungsi sigmoid untuk penyesuaian laju kedatangan ($\lambda_{adj}(N_t)$) berhasil memasukkan efek kemacetan (congestion).

Fase Awal ($N_t$ rendah): $\lambda_{adj}(N_t) \approx \lambda_{max}$. Dinamika dikendalikan oleh $\lambda_{max} – \mu$. Jika $\lambda_{max} > \mu$ (seperti contoh: 1.5 > 1.0), antrean akan tumbuh.
Fase Tengah ($N_t$ mendekati $K/2$): Laju kedatangan mulai menurun dari maksimum.
Fase Akhir ($N_t \to K$): $\lambda_{adj}(N_t)$ sangat rendah (mendekati 0) karena kemacetan ekstrem, meskipun kapasitas fisik $K$ belum tercapai. Dinamika menjadi $N_{t+1} = \min(K, \max(0, N_t + \text{small_arrival} – \mu))$.

Kesimpulan Kualitatif:
Model ini secara dinamis mensimulasikan bagaimana saturasi sumber daya (yaitu, infrastruktur yang terlalu padat menyebabkan proses kedatangan/alur menjadi tidak efisien) dapat membatasi pertumbuhan antrian, bahkan sebelum mencapai batas fisik $K$.

Model ini lebih unggul daripada model M/M/1 sederhana karena ia menggantikan asumsi laju kedatangan konstan dengan fungsi yang bergantung pada kondisi sistem saat itu.

ccitonline.com