---
# System prepended metadata

title: '[Private] Tugas Akhir Documentation'

---

<style tyle="text/css">
p {
text-align: justify;
}
</style>

**Lumbung Data Raffie :ear_of_rice:**
### :school: [Raffie's Private] Tugas Akhir Documentation 

#### :book: OPTIMALISASI ALGORITMA ALOKASI SUMBER DAYA RADIO PADA KOMUNIKASI VEHICLE TO VEHICLE (V2V)

:car: :blue_car: :car: :blue_car::car: :blue_car: :tokyo_tower: :satellite_antenna: :satellite: :tokyo_tower: :satellite_antenna: :satellite: :car: :blue_car: :car: :blue_car::car: :blue_car: :tokyo_tower: :satellite_antenna: :satellite: :car: :blue_car: 

:::success
Apa saja yang akan dibahas pada chapter ini.
1. Latar Belakang
2. Sistem Model
3. Algoritma 
4. Codingan 
:::
---
## Chapter 1. Latar Belakang :thinking_face: 
---

![Group 35](https://hackmd.io/_uploads/ByIWJ8BHA.png)

Tugas akhir ini terinspirasi oleh masalah akses internet yang buruk dan tingginya tingkat kecelakaan di jalan tol. Kami mengusulkan penggunaan teknologi komunikasi V2V untuk mengatasi ini. Untuk sinyal, kami membentuk klaster kendaraan dengan pemimpin (ketua platoon) yang dipilih **berdasarkan SNR, posisi, dan level baterai** terbaik untuk membagi sumber daya. Untuk mengurangi kecelakaan, kendaraan akan bergerak dalam formasi platoon bidirectional yang saling berkomunikasi dan mengingatkan, dipimpin oleh ketua platoon.

---
## Chapter 2. Sistem Model :construction_worker: 


---

![image](https://hackmd.io/_uploads/ryJh29rB0.png)

Gambar di atas menggambarkan model sistem dari tugas akhir kami. Sistem ini terdiri dari tiga lintasan, masing-masing dengan panjang 3000 meter. Terdapat dua BTS yang ditempatkan di posisi 750 meter dan 2250 meter, dengan jarak 200 meter dari lintasan, Coverage 1 BTS di range 0 - 1500 m dan 1501 - 3000 m.

Konsep model sistem ini mirip dengan repeater pada perangkat router Wi-Fi. BTS akan memberikan Resource Block (RB) kepada ketua platoon, kemudian ketua platoon akan mendistribusikan RB tersebut kepada mobil-mobil anggota cluster.

Proses pengalokasian Resource Block terdiri dari enam tahapan, yang akan dijelaskan lebih lanjut dalam gambar berikut.

![Flow chart V2V TA](https://hackmd.io/_uploads/HkASMLBBA.jpg)

:::info
**Kalo ditanya begini, gua gimanee?**
Q : Apakah perpindahan cluster akan sering terjadi jika tugas akhir ini di implementasi? jika tidak, lalu berapa lama perpindahan clusternya ?
A : 
Perpindahan cluster dalam implementasi model tugas akhir ini tidak akan sering terjadi karena beberapa alasan:
* Kendaraan bergerak dalam satu barisan dengan jarak tetap dan tidak saling menyalip, sehingga posisi relatif mereka tidak berubah signifikan.
* Pemimpin cluster ditentukan berdasarkan SNR dan level baterai, dan perubahan pada metrik ini cenderung stabil dalam jangka pendek.

Oleh karena itu, perpindahan cluster mungkin hanya perlu dievaluasi setiap beberapa menit atau setiap iterasi simulasi, yang dalam skenario ini mungkin setiap 10 menit. Frekuensi perpindahan cluster akan tergantung pada kecepatan perubahan kondisi SNR dan level baterai kendaraan.
:::

:::info
**Kalo ditanya begini, gua gimanee?**
Q : Bagaimana dengan handoovernya ? jika mobil A yang tadinya dilayani oleb BTS 1 cluster 1, ketika dia maju terus gimana handovernya? 

A : Handover kendaraan dalam model tugas akhir ini dapat dikelola melalui deteksi perubahan SNR dari BTS dan pemimpin cluster. Meskipun model saat ini belum secara eksplisit mengimplementasikan handover (masuk dalam batasan solusi) karena kita by simulasi iterasi, berikut adalah pendekatan yang dapat digunakan untuk penelitian selanjutnya:

Handover Antar BTS:

* Ketika kendaraan A yang awalnya dilayani oleh BTS 1 bergerak ke wilayah jangkauan BTS 2, handover terjadi jika SNR dari BTS 2 lebih tinggi daripada BTS 1.
* Proses handover melibatkan pengalihan layanan dari BTS 1 ke BTS 2 untuk memastikan kendaraan A tetap memiliki koneksi yang optimal.

Handover Antar Cluster:

* Ketika kendaraan A bergerak dari wilayah cluster 1 ke cluster 2, handover antar cluster terjadi jika SNR dari pemimpin cluster 2 lebih tinggi daripada pemimpin cluster 1.
* Pemimpin cluster berkoordinasi untuk memastikan bahwa kendaraan A diterima sebagai anggota baru di cluster 2 dan tetap menerima alokasi resource block yang efisien.

Dengan pendekatan ini, model dapat ditingkatkan untuk mengelola handover secara efektif, memastikan kualitas layanan yang optimal bagi kendaraan yang bergerak di antara BTS dan cluster.
:::
### 2.1 Parameter
Dalam perancangan sistem model, kami menetapkan beberapa parameter kunci yang mendukung keberhasilan sistem saat diuji. Parameter-parameter ini juga berfungsi sebagai pedoman penting untuk memastikan sistem model siap memasuki tahap pengujian berikutnya.

![image](https://hackmd.io/_uploads/BkzCFpSSC.png)

Tahap pengujian dilakukan setelah semua parameter sistem model berhasil dibentuk. Dengan mengikuti standar 3GPP TS 22.185, TS 22.186, TS 22.885 dan TS 22.886  yang menetapkan persyaratan layanan untuk mendukung skenario komunikasi Vehicle-to-Everything (V2X) dalam jaringan 5G. Kami membuat tabel KPI yang perlu di penuhi:

![image](https://hackmd.io/_uploads/rJL92FYSA.png)


### 2.2 Batasan Tugas Akhir
Dalam perancangan sistem model, terdapat beberapa batasan yang penting untuk menjaga fokus penelitian pada solusi awal dan mencegah perluasan masalah. Batasan-batasan ini akan dijelaskan lebih lanjut dalam penjelasan berikut:

1. Kendaraan Masih dalam Satu Barisan Bidirectional dalam Satu Cluster
Kendaraan dalam model ini belum dapat menyalip satu sama lain dan harus bergerak dengan kecepatan yang sama. Hal ini dapat mengurangi realisme model karena dalam kenyataan, kendaraan sering kali bergerak dengan kecepatan berbeda dan melakukan manuver seperti menyalip.

2. Asumsi Jarak Tetap Antar Kendaraan
Dalam model ini, jarak antar kendaraan ditentukan secara acak antara 15-30 meter, namun tetap tidak memperhitungkan variasi jarak yang dapat terjadi karena kondisi jalan, kecepatan kendaraan, dan reaksi pengemudi. Ini bisa menyebabkan kurangnya akurasi dalam merepresentasikan skenario nyata di jalan raya.

3. Tidak Mempertimbangkan Kondisi Lalu Lintas dan Lingkungan
Model ini tidak mempertimbangkan kondisi lalu lintas seperti kepadatan kendaraan, adanya rambu lalu lintas, atau pengaruh cuaca. Faktor-faktor ini dapat memiliki dampak signifikan terhadap performa komunikasi dan harus diperhitungkan untuk analisis yang lebih mendalam.

4. Penggunaan Algoritma FIFO, Greedy, dan Genetic secara Terpisah
Meskipun menggunakan berbagai algoritma untuk alokasi sumber daya (FIFO, Greedy, Genetic), implementasi saat ini tidak menggabungkan keunggulan dari setiap algoritma dalam satu solusi hibrid. Setiap algoritma digunakan secara terpisah, yang mungkin tidak menghasilkan solusi optimal dalam semua situasi.

5. Ketergantungan pada Parameter Acak
Beberapa parameter dalam model ini, seperti nilai shadowing dan posisi kendaraan, dihasilkan secara acak. Meskipun ini dapat membantu dalam beberapa kasus simulasi, ketergantungan pada parameter acak dapat menghasilkan hasil yang kurang konsisten dan mengurangi keandalan dari simulasi.

6. Batasan pada Frekuensi dan Kondisi Pathloss
Model pathloss yang digunakan berdasarkan spesifikasi COST 231 mungkin tidak mencakup semua kondisi dan frekuensi yang digunakan dalam komunikasi kendaraan-ke-kendaraan. Hal ini bisa membatasi keakuratan perhitungan pathloss dan daya penerima dalam berbagai skenario komunikasi.

7. Sederhananya Model Noise
Perhitungan noise hanya berdasarkan pada suhu dan bandwidth, tanpa mempertimbangkan faktor lain seperti interferensi dari sinyal lain, multipath fading, dan refleksi sinyal yang sering terjadi dalam komunikasi kendaraan-ke-kendaraan.

8. Ketidakakuratan dalam Pengukuran SNR
Pengukuran SNR dilakukan dengan asumsi bahwa semua noise memiliki karakteristik yang sama, tanpa memperhitungkan variasi noise yang mungkin terjadi di lingkungan nyata. Ini bisa menyebabkan ketidakakuratan dalam penghitungan SNR.

9. Simplifikasi dalam Penentuan Cluster dan Platoon Leader
Penentuan cluster dan platoon leader didasarkan pada metrik gabungan SNR dan level baterai. Namun, dalam kenyataan, penentuan ini bisa lebih kompleks dan melibatkan lebih banyak parameter seperti jarak antar kendaraan, kecepatan, dan kondisi jalan.

10. Kendala Handover
Model saat ini belum mengimplementasikan mekanisme handover yang memungkinkan kendaraan berpindah dari satu BTS ke BTS lain atau dari satu cluster ke cluster lain saat mereka bergerak. Dalam kondisi nyata, handover sangat penting untuk menjaga kualitas layanan (QoS) dan konektivitas yang berkelanjutan. Perpindahan cluster dan BTS yang tidak dikelola dengan baik dapat menyebabkan penurunan SNR dan gangguan layanan sementara.

---
## Chapter 3. Algoritma :game_die: 
---

Ada 3 algoritma yang digunakan dalam tugas akhir ini, yaitu greedy, FIFO dan Genetic. pada bagian selanjutnya akan dijelaskan bagaimana detail 3 sistem algoritma ini bekerja dalam sistem model. 

### 3.1 Algoritma Greedy
Algoritma Greedy adalah pendekatan di mana keputusan diambil berdasarkan keuntungan terbesar atau biaya terkecil pada setiap langkah tanpa mempertimbangkan konsekuensi jangka panjang. Dalam konteks alokasi RB:

* Implementasi: BTS atau pemimpin konvoi akan mengalokasikan RB ke kendaraan yang memiliki kebutuhan paling mendesak atau yang dapat memberikan keuntungan terbesar saat itu, misalnya kendaraan dengan SNR tertinggi.
* Keuntungan: Greedy cepat dan efisien karena setiap keputusan diambil secara lokal pada saat itu juga, tanpa memerlukan perhitungan yang kompleks.
* Keterbatasan: Algoritma Greedy tidak selalu menghasilkan solusi optimal secara keseluruhan karena tidak mempertimbangkan dampak jangka panjang dari setiap keputusan. Kadang-kadang, solusi lokal yang terbaik mungkin bukan solusi global yang terbaik.
### 3.2 Flowchart Algoritma Greedy

### 3.3 Algoritma FIFO
FIFO adalah metode antrian di mana elemen yang masuk pertama kali akan diproses atau dikeluarkan terlebih dahulu. Dalam konteks alokasi Resource Block (RB) dalam komunikasi V2V:

* Implementasi: Setiap kendaraan yang terhubung ke BTS akan dimasukkan ke dalam antrian. Ketika RB tersedia, kendaraan yang berada di depan antrian akan menerima RB terlebih dahulu.
* Keuntungan: FIFO sederhana dan mudah diimplementasikan. Algoritma ini memastikan bahwa kendaraan yang lebih dulu meminta RB akan dilayani terlebih dahulu, mengurangi risiko starvation (kelaparan) pada kendaraan yang telah lama menunggu.
* Keterbatasan: FIFO tidak mempertimbangkan prioritas berdasarkan kebutuhan atau kondisi kendaraan. Kendaraan dengan kebutuhan mendesak atau kondisi sinyal buruk mungkin harus menunggu lebih lama.
### 3.4 Flowchart Algoritma FIFO

### 3.5 Algoritma Genetic
Algoritma Genetic adalah metode optimasi yang terinspirasi oleh proses evolusi alamiah. Algoritma ini menggunakan mekanisme seleksi alam, crossover (pertukaran bagian), dan mutasi untuk menemukan solusi optimal. Dalam konteks alokasi RB:

* Implementasi:
    * Inisialisasi: Buat populasi awal dari solusi alokasi RB.
    * Seleksi: Evaluasi setiap solusi berdasarkan suatu fungsi fitness (misalnya, total SNR, efisiensi alokasi).
    * Crossover: Gabungkan pasangan solusi untuk menghasilkan solusi baru yang menggabungkan karakteristik dari kedua solusi induk.
    * Mutasi: Modifikasi solusi baru secara acak untuk menjaga keragaman populasi dan menghindari terjebak pada solusi lokal.
    * Iterasi: Ulangi proses seleksi, crossover, dan mutasi sampai tercapai solusi yang optimal atau kondisi berhenti terpenuhi.
* Keuntungan: Algoritma Genetic dapat menemukan solusi yang sangat baik untuk masalah optimasi yang kompleks dan sering kali dapat mendekati solusi optimal global.
* Keterbatasan: Algoritma ini bisa memakan waktu dan sumber daya komputasi yang cukup besar karena melibatkan banyak iterasi dan operasi pada populasi solusi.
### 3.6 Flowchart Algoritma Genetic


---
## Chapter 4. Codingan :snake: 


---

Kode kami terdiri dari dua sistem yang berbeda. Perbedaan ini bertujuan untuk membandingkan dan menentukan sistem mana yang paling baik dan efektif. Berikut adalah kedua sistem tersebut:
**1. Non Clustering + Algoritma**
Sistem pertama adalah sistem model tanpa proses clustering. Pada sistem ini, kendaraan akan disegmentasi setiap 100 meter, kemudian medoid (Ketua platoon) akan ditentukan. setelah ketua platoon ditemukan maka ditambahkan 3 algoritma (Greedy, FIFO, Genetic).
**2. Clustering + Algoritma**
Sistem kedua menggunakan proses clustering. Pada sistem ini, kendaraan tidak disegmentasi setiap 100 meter. Medoid dipilih berdasarkan "Combine Value" yang lebih besar dari 40. Setelah medoid atau ketua platoon ditentukan, tiga algoritma (Greedy, FIFO, Genetic) diterapkan untuk mengoptimalkan alokasi sumber daya.
### 4.1 Code sistem model
#### 4.1.1 Flowchart Sistem Model
![image](https://hackmd.io/_uploads/SksUZCSSR.png)

Analisa flowchart diatas:
* **Inisialisasi Parameter**
Langkah: Memulai proses dengan menginisialisasi parameter yang diperlukan.
Tujuan: Menyiapkan nilai awal dan konfigurasi yang akan digunakan dalam simulasi.

* **Inisialisasi Array dan Matriks**
Langkah: Menginisialisasi array dan matriks sesuai dengan jumlah kendaraan.
Tujuan: Mempersiapkan struktur data untuk menyimpan informasi kendaraan dan perhitungan yang diperlukan.

* **Simulasi Model**
Langkah: Melakukan simulasi model berdasarkan parameter yang telah diinisialisasi.
Tujuan: Memulai proses simulasi untuk mengumpulkan data yang dibutuhkan.

* **Generate Posisi Kendaraan**
Langkah: Menghasilkan posisi kendaraan secara acak dengan jarak antar kendaraan antara 15-30 meter. Juga, menginisialisasi baterai setiap kendaraan secara acak.
Tujuan: Menyimulasikan penempatan kendaraan dalam area yang diinginkan.

* **Menghitung Jarak BTS ke Kendaraan**
Langkah: Menghitung jarak antara BTS dan setiap kendaraan menggunakan fungsi calculate_jarakkebts().
Tujuan: Menentukan seberapa jauh setiap kendaraan dari BTS untuk perhitungan lebih lanjut.

* **Menghitung Pathloss, PRX, dan SNR**
Langkah: Menghitung pathloss, PRX, dan SNR untuk setiap kendaraan dari setiap BTS menggunakan fungsi cal_pathloss_cost231(), cal_prx_mw(), dan cal_noise_mw().
Tujuan: Mengukur kualitas sinyal yang diterima oleh setiap kendaraan.

* **Mengolah dan Menggunakan Data Segmen**
Langkah: Menghitung SNR untuk setiap kendaraan dari BTS terdekat, menghitung jarak minimum kendaraan ke BTS terdekat, dan membuat DataFrame dengan informasi kendaraan.
Tujuan: Mengorganisir data yang dihasilkan untuk analisis lebih lanjut dan pengambilan keputusan dalam alokasi sumber daya.
#### 4.1.2 Code 
Code pada tugas akhir ini menggunakan Python, pada code simulasi model terdapat 2 bagian code:
* Bagian 1 : Simulasi model secara keseluruhan
* Bagian 2 : Visualisasi bagian 1

Penjelasan detail akan dibawah, Cemungutttt !
##### 4.2.2.1 Bagian 1 (Simulasi model secara keseluruhan)
**1. Inisialisasi dan Impor Paket**
```=
import random
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from google.colab import drive

drive.mount('/content/drive')
```
Tujuan: Mengimpor paket-paket yang diperlukan untuk simulasi, seperti random untuk generasi angka acak, numpy untuk operasi numerik, pandas untuk manipulasi data, dan matplotlib untuk visualisasi. Drive di-mount untuk mengakses penyimpanan Google Drive.

**2. Inisialisasi Parameter**
```=
l_road = 3000         # Panjang jalan (meter)
initial_max_vehicles = 60    # Jumlah kendaraan awal
bts_distance = 1500   # Jarak antar BTS (meter)
bts_offset = 200      # Jarak vertikal BTS ke jalan (meter)

f = 1900      # Frekuensi (MHz)
h_tx = 45.0   # Tinggi antena BTS (meter)
h_rx = 1.5    # Tinggi antena mobil (meter)

pt = 20   # Daya antena (dBm)
gt = 1    # Gain antena BTS (dBi)
gr = 1    # Gain antena mobil (dBi)

BOLTZMANN_CONSTANT = 1.38e-23   # Konstanta Boltzmann (Joule/Kelvin)
temperature = 290               # Suhu (Kelvin)
bandwidth = 20e6                # Bandwidth (Hertz)
```
Tujuan: Menginisialisasi parameter model, termasuk panjang jalan, jumlah kendaraan, jarak BTS, frekuensi, tinggi antena, daya antena, gain antena, konstanta Boltzmann, suhu, dan bandwidth.

**3. Inisialisasi Array dan Matriks**
```=
bts_positions = np.arange(750, l_road + 1, bts_distance) # Posisi BTS
jmlbts = len(bts_positions)
```
Tujuan: Menghitung posisi BTS sepanjang jalan dan menentukan jumlah BTS.

**4. Fungsi untuk Menghitung Jarak, Konversi dBm ke mWatt, dan Pathloss**
```=
def calculate_jarakkebts(V_all, bts_positions, bts_offset):
    matrix = np.zeros([len(bts_positions), len(V_all)])
    for i in range(len(V_all)):
        for j in range(len(bts_positions)):
            x = abs(V_all[i] - bts_positions[j])
            y = bts_offset
            matrix[j][i] = (np.sqrt(x**2 + y**2))/1000 # Diubah ke Km
    return matrix

def dbm_mwatt(x):
    return  10**(x / 10)

def generate_shadowing(low=2, high=8):
    return random.uniform(low, high)

def cal_pathloss_cost231(f, d, h_tx, h_rx, shadowing=0):
    dt = (1.1 * np.log10(f) - 0.7) * h_rx - (1.56 * np.log10(f) - 0.8)
    pathloss = 46.3 + 33.9 * np.log10(f) - 13.82 * np.log10(h_tx) - dt + (44.9 - 6.55 * np.log10(h_tx)) * np.log10(d) + shadowing
    return pathloss

def cal_prx_mw(pt, f, d, h_tx, h_rx, gt, gr):
    pathloss_db = cal_pathloss_cost231(f, d, h_tx, h_rx)
    prx_dbm = pt + gt + gr - pathloss_db
    prx_mw = dbm_mwatt(prx_dbm)
    return prx_mw

def cal_noise_mw(temperature, bandwidth):
    noise_mw = BOLTZMANN_CONSTANT * temperature * bandwidth *1000 # Konversi ke mWatt
    return noise_mw
```
Tujuan: 
* calculate_jarakkebts: Menghitung jarak antara setiap kendaraan dan BTS dalam kilometer.
* dbm_mwatt: Mengkonversi daya dari dBm ke miliwatt.
* generate_shadowing: Menghasilkan nilai shadowing secara acak.
* cal_pathloss_cost231: Menghitung pathloss menggunakan model COST 231.
* cal_prx_mw: Menghitung daya penerima (Prx) dalam miliwatt.
* cal_noise_mw: Menghitung noise dalam miliwatt.

**5. Iterasi Simulasi**
```=
for iterasi in range(5):  
    max_vehicles = initial_max_vehicles + (iterasi % 5) * 10
    print(f"Iterasi {iterasi + 1}: Jumlah Kendaraan = {max_vehicles}")

    pathloss_matrix = np.zeros([jmlbts, max_vehicles])
    prxdbm_matrix = np.zeros([jmlbts, max_vehicles])
    prxmw_matrix = np.zeros([jmlbts, max_vehicles])
    SNR_dB_matrix = np.zeros([jmlbts, max_vehicles])
    battery_matrix = np.zeros([max_vehicles])

    try:
        vehicles = []
        vehicle_positions = []
        lane_positions = []

        initial_batteries = [random.randint(1, 100) for _ in range(max_vehicles)]

        pos = 0
        while pos < l_road and len(vehicle_positions) < max_vehicles:
            pos += random.randint(1,50)
            vehicle_positions.append(pos)
            lane_positions.append(random.choice([0, 1, 2]))

        vehicle_positions = np.array(vehicle_positions)
        lane_positions = np.array(lane_positions)
        jarak_bts = calculate_jarakkebts(vehicle_positions, bts_positions, bts_offset)
        d = jarak_bts

        for i in range(jmlbts):
            for j in range(max_vehicles):
                shadowing = generate_shadowing()
                pathloss_matrix[i, j] = cal_pathloss_cost231(f, d[i, j], h_tx, h_rx, shadowing)
                prxmw_matrix[i, j] = cal_prx_mw(pt, f, d[i, j], h_tx, h_rx, gt, gr)
                noise_mw = cal_noise_mw(temperature, bandwidth)
                SNR_dB_matrix[i, j] = 10 * np.log10(prxmw_matrix[i, j] / noise_mw)

        snr_vehicles = SNR_dB_matrix.max(axis=0)
        min_distances = d.min(axis=0)

        vehicles_df = pd.DataFrame({
            'Vehicle Position': vehicle_positions,
            'Lane': lane_positions,
            'SNR ke BTS (dB)': snr_vehicles,
            'Battery Level': initial_batteries,
            'Distance to BTS (km)': min_distances
        })

        output_file = f'/content/drive/MyDrive/AKU_TA/Test/{iterasi}_vehicle_data.csv'
        vehicles_df.to_csv(output_file, index=False)
        print(f"Data telah disimpan ke CSV: {output_file}")

        bts_df = pd.DataFrame({'BTS_Position': bts_positions})
        bts_df.to_csv('/content/drive/MyDrive/AKU_TA/Test/bts_positions.csv', index=False)

    except KeyboardInterrupt:
        print("\nProgram stopped by the user.")
```
Tujuan:
* Iterasi: Menjalankan simulasi untuk beberapa iterasi, menambah jumlah kendaraan pada setiap iterasi.
* Inisialisasi Matriks: Menyiapkan matriks untuk menyimpan pathloss, daya penerima, dan SNR.
* Inisialisasi Baterai: Memberikan nilai baterai acak untuk setiap kendaraan.
* Penentuan Posisi Kendaraan: Menentukan posisi kendaraan secara acak di sepanjang jalan.
* Menghitung Jarak ke BTS: Menggunakan fungsi yang telah didefinisikan untuk menghitung jarak kendaraan ke BTS.
* Menghitung Pathloss dan SNR: Menghitung pathloss, daya penerima, dan SNR untuk setiap kendaraan dari BTS terdekat.
* Menyimpan Hasil: Menyimpan hasil simulasi ke dalam file CSV.

##### 4.2.2.2 Bagian 2 (Visualisasi bagian 1)
**1. Impor Paket dan Mount Google Drive**
```=
import pandas as pd
import matplotlib.pyplot as plt
from google.colab import drive

drive.mount('/content/drive')
```
Tujuan: Mengimpor paket yang diperlukan dan mount Google Drive untuk mengakses data yang disimpan.

**2. Fungsi untuk Menampilkan Grafik Posisi Kendaraan**
```=
def plot_vehicle_positions(iterasi, input_path):
    vehicle_data_file = f'{iterasi}_vehicle_data.csv'
    df = pd.read_csv(input_path + vehicle_data_file)

    positions = df['Vehicle Position'].to_numpy()
    lanes = df['Lane'].to_numpy()

    plt.figure(figsize=(20, 6))
    for lane in [0, 1, 2]:
        lane_vehicles = df[df['Lane'] == lane]
        plt.scatter(lane_vehicles['Vehicle Position'], np.full_like(lane_vehicles['Vehicle Position'], lane), label=f'Lane {lane + 1}')

    plt.xlim(0, 3000)  # Set limit for x-axis to 3000 meters
    plt.xlabel('Position (meter)')
    plt.ylabel('Lane')
    plt.title(f'Vehicle Positions for Iteration {iterasi}')
    plt.legend()
    plt.grid(True)
    plt.show()
```
Tujuan: Fungsi ini membaca data kendaraan dari file CSV dan menampilkan posisi kendaraan pada grafik, diorganisasikan berdasarkan jalur (lane).

**3. Menampilkan Posisi Kendaraan untuk Setiap Iterasi**
```=
input_path = '/content/drive/MyDrive/AKU_TA/Test/'

for iterasi in range(5):
    plot_vehicle_positions(iterasi, input_path)
```
Tujuan: Menjalankan fungsi plot_vehicle_positions untuk setiap iterasi yang telah dilakukan, sehingga posisi kendaraan dapat divisualisasikan untuk setiap iterasi.

**Penjelasan Code ini lebih detail akan dibahas di link** >> [Klik Disini](https://hackmd.io/@4JCBNYqXS7qbp4mZBx63rw/HJ7AvYtBA)

### 4.2 Code Non-Clustering
#### 4.2.1 Flowchart Non-Clustering
![image](https://hackmd.io/_uploads/rymOZCSH0.png)

Analisa flowchart diatas:

* **Muat Data Kendaraan**
Langkah: Memuat data kendaraan yang diperlukan untuk analisis.
Tujuan: Mengumpulkan informasi awal tentang kendaraan yang akan dianalisis.

* **Proses Data Kendaraan**
Langkah: Memproses data kendaraan untuk persiapan analisis lebih lanjut.
Tujuan: Membersihkan dan menyiapkan data agar siap digunakan dalam analisis.

* **Segmentasi Kendaraan**
Langkah: Membagi kendaraan menjadi segmen berdasarkan posisi mereka setiap 300 meter.
Tujuan: Mempermudah analisis dengan membagi kendaraan dalam kelompok yang lebih kecil dan teratur.

* **Hitung Kombinasi Metric**
Langkah: Menghitung metrik gabungan dari SNR dan level baterai untuk setiap kendaraan.
Tujuan: Menilai kendaraan berdasarkan kondisi sinyal dan daya baterai untuk memilih pemimpin kluster yang optimal.

* **Pilih Ketua Platoon**
Langkah: Memilih ketua platoon untuk setiap segmen berdasarkan metrik gabungan tertinggi.
Tujuan: Menentukan kendaraan yang paling mampu memimpin kluster dalam segmen tersebut.

* **Plot Kluster**
Langkah: Memvisualisasikan kluster kendaraan berdasarkan posisi dan pemimpin kluster.
Tujuan: Memperjelas pembagian kluster dan pemimpin kluster secara visual.

* **Perhitungan Anggota Kluster ke Medoid**
Langkah: Menghitung jarak antara anggota kluster dan ketua platoon (medoid), serta menghitung pathloss, Prx, dan SNR untuk setiap anggota kluster terhadap ketua platoon.
Tujuan: Menilai kualitas sinyal dan komunikasi antara anggota kluster dan ketua platoon untuk alokasi sumber daya yang lebih baik.

* **Menampilkan Grafik**
Langkah: Menampilkan hasil perhitungan dan analisis dalam bentuk grafik.
Tujuan: Memberikan gambaran visual tentang hasil analisis dan perhitungan untuk interpretasi yang lebih mudah.
#### 4.2.2 Code
**1. Impor Paket dan Mount Google Drive**
```=
import random
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from google.colab import drive

drive.mount('/content/drive')
```
* Tujuan: Mengimpor paket yang diperlukan untuk manipulasi dan visualisasi data serta mengakses Google Drive.
* Detail:
    * pandas digunakan untuk membaca dan memanipulasi data dalam format tabel.
    * matplotlib.pyplot digunakan untuk membuat grafik.
    * drive.mount('/content/drive') digunakan untuk mengakses data yang disimpan di Google Drive.

**2. Membaca Data BTS dan Menentukan Jalur Input/Output**
```=
# Load Data
bts_position_path = '/content/drive/MyDrive/AKU_TA/Test/bts_positions.csv'
input_path = '/content/drive/MyDrive/AKU_TA/Test/'
output_path = '/content/drive/MyDrive/AKU_TA/Test/'

# Read Data
bts_df = pd.read_csv(bts_position_path)
bts_positions = bts_df['BTS_Position'].to_numpy()
num_bts = len(bts_positions)
```
* Tujuan: Membaca data posisi BTS dari file CSV dan menentukan jalur untuk file input dan output.
* Detail:
    * Membaca file CSV posisi BTS dan mengonversinya ke array numpy.
    * Menentukan jumlah BTS.

**3. Parameter Non Clustering**
```=
# Parameter Pathloss, Prx, Noise, & SNR
RB = 50
bts_offset = 200
f = 1900                       # MHz
h_tx = 1.5                     # Tinggi Antena Mobil - Medoid
h_rx = 1.5                     # Tinggi Antena Mobil - Non Medoid (Anggota)
pt = 35                        # dBm
gt = 3                         # Gain Medoid dBi
gr = 3                         # Gain Non Medoid (Anggota) dBi
temperature = 290              # Temperature in Kelvin
bandwidth = 20e6               # Bandwidth in Hertz
BOLTZMANN_CONSTANT = 1.38e-23  # Boltzmann constant in Joules/Kelvin
```
* Tujuan: Menginisialisasi parameter untuk perhitungan pathloss, daya penerima (Prx), noise, dan SNR.
* Detail:
    * RB: Jumlah Resource Blocks.
    * bts_offset: Offset vertikal BTS dari jalan.
    * f, h_tx, h_rx, pt, gt, gr, temperature, bandwidth, BOLTZMANN_CONSTANT: Parameter teknis untuk perhitungan komunikasi nirkabel.
    
**4. Fungsi Konversi dBm ke mWatt**
```=
def dbm_mwatt(x):
    return 10**(x / 10)
```
* Tujuan: Mengonversi daya dari dBm ke miliwatt (mW).
* Rumus:
![image](https://hackmd.io/_uploads/S1ibB-2B0.png)

**5. Fungsi Generate Shadowing**
```=
def generate_shadowing(low=2, high=3):
    return random.uniform(low, high)
```
* Tujuan: Menghasilkan nilai shadowing acak dalam rentang yang ditentukan.
* Detail: Menggunakan random.uniform untuk menghasilkan nilai acak antara low dan high.

**6. Fungsi Pathloss**
```=
def cal_pathloss_new(d, fc, shadowing=0):
    if d == 0:
        d = 0.01  # Nilai kecil untuk menghindari log(0)
    pathloss = 38.77 + 16.7 * np.log10(d) + 18.2 * np.log10(fc) + shadowing
    return pathloss
```
* Tujuan: Menghitung pathloss berdasarkan jarak dan frekuensi dengan menambahkan shadowing.
* Detail:
![image](https://hackmd.io/_uploads/Sy1tBZ2BC.png)

**7. Fungsi Menghitung Prx (Daya Penerima)**
```=
def cal_prx_mw(pt, d, fc, gt, gr):
    shadowing = generate_shadowing()
    pathloss_db = cal_pathloss_new(d, fc, shadowing)
    prx_dbm = pt + gt + gr - pathloss_db
    prx_mw = dbm_mwatt(prx_dbm)
    return prx_mw  # Output mW
```
* Tujuan: Menghitung daya penerima dalam miliwatt.
* Detail:
    * Menghitung pathloss menggunakan cal_pathloss_new.
    * Menghitung daya penerima dalam dBm:
![image](https://hackmd.io/_uploads/SypfUWnr0.png)
    * Mengonversi daya penerima dari dBm ke mW menggunakan dbm_mwatt.
    
**8. Fungsi Menghitung Noise**
```=
def cal_noise_mw(temperature, bandwidth):
    noise_mw = BOLTZMANN_CONSTANT * temperature * bandwidth * 1000  # Konversi ke mWatt
    return noise_mw
```
* Tujuan: Menghitung noise dalam miliwatt.
* Detail:
![image](https://hackmd.io/_uploads/SycdIW3rC.png)
di mana 𝑘 adalah konstanta Boltzmann, 𝑇 adalah suhu dalam Kelvin, dan 𝐵 adalah bandwidth dalam Hertz.

**9. Fungsi Menghitung Jarak Euclidean**
```=
def calculate_distance(vehicle_position, bts_position, bts_offset):
    return np.sqrt((vehicle_position - bts_position)**2 + bts_offset**2)
```
* Tujuan: Menghitung jarak Euclidean antara posisi kendaraan dan posisi BTS.
* Detail:
    * Menggunakan rumus jarak Euclidean
![image](https://hackmd.io/_uploads/HJUGDbhHA.png)

**10. Fungsi Menghitung Jarak antara Medoid dan Anggota Cluster**
```=
def calculate_medoid_member_distance(medoid_position, medoid_lane, member_position, member_lane):
    if medoid_lane != member_lane:
        distance = np.sqrt((medoid_position - member_position)**2 + (3.5 * abs(medoid_lane - member_lane))**2)
    else:
        distance = abs(medoid_position - member_position)
    return distance
```
* Tujuan: Menghitung jarak antara medoid dan anggota cluster.
* Detail:
    * Jika medoid dan anggota cluster berada di jalur yang berbeda, jarak dihitung dengan menambahkan jarak antar jalur (3.5 meter per jalur).
    * Jika berada di jalur yang sama, jarak adalah selisih posisi medoid dan anggota cluster.

**11. Iterasi Simulasi**
```=
for iterasi in range(100):
    vehicle_data_file = f'{iterasi}_vehicle_data.csv'
    df = pd.read_csv(input_path + vehicle_data_file)

    positions = df['Vehicle Position'].to_numpy()
    lanes = df['Lane'].to_numpy()
    max_snr = df['SNR ke BTS (dB)'].to_numpy()
    battery_levels = df['Battery Level'].to_numpy()

    results = pd.DataFrame({
        'Position': positions,
        'Lane': lanes,
        'SNR': max_snr,
        'Battery Level': battery_levels,
        'Combined Metric': (max_snr + battery_levels) / 2
    })

    bins = np.arange(0, 3000, 300)
    results['Segment'] = pd.cut(results['Position'], bins=bins, labels=bins[:-1])

    medoids = {}
    for seg in results['Segment'].unique():
        segment_vehicles = results[results['Segment'] == seg]
        if not segment_vehicles.empty:
            max_combined_metric_idx = segment_vehicles['Combined Metric'].idxmax()
            medoids[seg] = segment_vehicles.loc[max_combined_metric_idx, ['Position', 'Lane']].to_dict()

    results['Is Medoid'] = results.apply(lambda row: (row['Position'], row['Lane']) in [(medoid['Position'], medoid['Lane']) for medoid in medoids.values()], axis=1)

    df_cluster = results.copy()
    medoids_df = df_cluster[df_cluster['Is Medoid'] == True].reset_index(drop=True)
    medoids_df['Serving BTS'] = medoids_df.apply(lambda row: bts_positions[np.argmin([calculate_distance(row['Position'], bts, bts_offset) for bts in bts_positions])], axis=1)

    hcs_results = pd.DataFrame()

    for index, medoid in medoids_df.iterrows():
        seg_label = medoid['Segment']
        medoid_position = medoid['Position']
        medoid_lane = medoid['Lane']
        serving_bts = medoid['Serving BTS']

        cluster_members = df_cluster[df_cluster['Segment'] == seg_label]
        cluster_members = cluster_members.reset_index(drop=True)

        snr_list_rb = {f'RB{rb+1}': [] for rb in range(RB)}

        for _, member in cluster_members.iterrows():
            member_position = member['Position']
            member_lane = member['Lane']
            distance = calculate_medoid_member_distance(medoid_position, medoid_lane, member_position, member_lane)

            if member_position == 0:
                for rb in range(RB):
                    snr_list_rb[f'RB{rb+1}'].append(0)
            else:
                for rb in range(RB):
                    shadowing = generate_shadowing()
                    prx = cal_prx_mw(pt, distance, f, gt, gr)
                    noise_mw = cal_noise_mw(temperature, bandwidth)
                    snr = 10 * np.log10(prx / noise_mw)
                    if np.isinf(snr):
                        snr = df.loc[df['Vehicle Position'] == member_position, 'SNR ke BTS (dB)'].max()
                    snr_list_rb[f'RB{rb+1}'] = snr_list_rb.get(f'RB{rb+1}', []) + [snr]

        cluster_results = pd.DataFrame({
            'Member Position': cluster_members['Position'],
            'Cluster': seg_label,
            'Serving BTS': serving_bts,
            'Is Medoid': [1 if (member['Position'] == medoid_position and member['Lane'] == medoid_lane) else 0 for _, member in cluster_members.iterrows()],
            'Combined Metric': cluster_members['Combined Metric']
        })

        for rb in range(RB):
            cluster_results[f'RB{rb+1}'] = snr_list_rb[f'RB{rb+1}']

        hcs_results = pd.concat([hcs_results, cluster_results], ignore_index=True)

    output_file = f'{output_path}{iterasi}_NCS.csv'
    hcs_results.to_csv(output_file, index=False)
    print(f"Telah disimpan : {output_file}")

print("All output files have been processed and saved.")
```
* Tujuan: Melakukan iterasi simulasi untuk menghitung dan menyimpan hasil SNR dan metrik gabungan kendaraan dalam segmen tertentu.
* Detail:
    * Pembacaan Data: Membaca data posisi kendaraan, jalur, SNR, dan level baterai dari file CSV.
    * Pembuatan DataFrame: Membuat DataFrame results yang berisi posisi, jalur, SNR, level baterai, dan metrik gabungan kendaraan.
    * Segmentasi Kendaraan: Mengelompokkan kendaraan dalam segmen-segmen berdasarkan posisi mereka.
    * Penentuan Medoid: Menentukan medoid (kendaraan dengan metrik gabungan tertinggi) untuk setiap segmen.
    * Perhitungan SNR untuk Resource Blocks (RB): Menghitung SNR untuk setiap RB dan anggota cluster.
    * Penyimpanan Hasil: Menyimpan hasil perhitungan ke file CSV.

**Penjelasan Code ini lebih detail akan dibahas di link** >> [Klik Disini](https://hackmd.io/@4JCBNYqXS7qbp4mZBx63rw/Byh8_tKS0)

### 4.3 Code Clustering 
#### 4.3.1 Flowchart Clustering
![image](https://hackmd.io/_uploads/SkVjbArBC.png)
* **Penentuan Medoid & Anggota Cluster:**
    * Hitung metrik gabungan SNR dan level baterai untuk setiap kendaraan.
    * Tentukan centroid sebagai area untuk ketua platoon/medoid.
    * Pilih ketua platoon/medoid dengan syarat nilai kombinasi > 15.
    * Hitung BTS yang melayani setiap ketua platoon berdasarkan jarak terdekat.
    * Hitung jarak setiap kendaraan ke ketua platoon untuk menentukan anggota kluster.
* **Perhitungan Anggota Cluster ke Ketua Platoon:**
    * Hitung jarak antara anggota kluster dengan ketua platoon.
    * Dari jarak yang diperoleh, hitung nilai pathloss anggota kluster terhadap ketua platoon.
    * Dari jarak yang diperoleh, hitung nilai Prx anggota kluster terhadap ketua platoon.
    * Hitung SNR untuk setiap anggota kluster terhadap ketua platoon.
    * Lakukan perhitungan SNR sebanyak RB dengan variabel shadowing yang bervariasi.
* **Penjelasan Detail**
    * Langkah 1: Data kendaraan dimuat ke dalam sistem untuk persiapan analisis.
    * Langkah 2: Data diproses dan dibersihkan agar siap digunakan.
    * Langkah 3: Kendaraan dibagi menjadi kelompok berdasarkan kriteria tertentu, seperti posisi.
    * Langkah 4: Kombinasi metrik SNR dan baterai dihitung untuk setiap kendaraan.
    * Langkah 5: Kendaraan dengan metrik gabungan tertinggi dipilih sebagai ketua platoon/medoid.
    * Langkah 6: Kluster kendaraan diplot untuk visualisasi.
    * Langkah 7: Jarak antara anggota kluster dan ketua platoon dihitung untuk mengevaluasi pathloss, Prx, dan SNR.
    * Langkah 8: Hasil perhitungan ditampilkan dalam bentuk grafik untuk interpretasi.
#### 4.3.2 Code
**1. Impor Paket dan Mount Google Drive**
```=
import random
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from google.colab import drive
from sklearn.cluster import KMeans

# Mount Google Drive dengan opsi force_remount
drive.mount('/content/drive', force_remount=True)
```
* Tujuan: Mengimpor paket yang diperlukan untuk manipulasi dan visualisasi data, serta untuk mengakses Google Drive dan menggunakan K-Means clustering.
* Detail:
    * pandas digunakan untuk membaca dan memanipulasi data dalam format tabel.
    * matplotlib.pyplot digunakan untuk membuat grafik.
    * drive.mount('/content/drive', force_remount=True) digunakan untuk mengakses data yang disimpan di Google Drive.

**2. Membaca Data BTS dan Menentukan Jalur Input/Output**
```=
# Path untuk file BTS dan data input/output
bts_position_path = '/content/drive/MyDrive/AKU_TA/Test/bts_positions.csv'
input_path = '/content/drive/MyDrive/AKU_TA/Test/'
output_path = '/content/drive/MyDrive/AKU_TA/Test/'

# "Mengolah Data Posisi BTS"
# Membaca data posisi BTS dari file CSV
bts_df = pd.read_csv(bts_position_path)
bts_positions = bts_df['BTS_Position'].to_numpy()
num_bts = len(bts_positions)
```
* Tujuan: Membaca data posisi BTS dari file CSV dan menentukan jalur untuk file input dan output.
* Detail:
    * Membaca file CSV posisi BTS dan mengonversinya ke array numpy.
    * Menentukan jumlah BTS.

**3. Parameter Sistem**
```=
# "Parameter Pathloss, PRX, Noise, & SNR"
# Definisi parameter sistem
RB = 50
bts_offset = 200
f = 1900  # Frekuensi dalam MHz
h_tx = 1.5  # Tinggi antena medoid dalam meter
h_rx = 1.5  # Tinggi antena anggota kluster dalam meter
pt = 35  # Daya pancar dalam dBm
gt = 3  # Gain antena medoid dalam dBi
gr = 3  # Gain antena anggota kluster dalam dBi
temperature = 290  # Suhu dalam Kelvin
bandwidth = 20e6  # Bandwidth dalam Hertz
BOLTZMANN_CONSTANT = 1.38e-23  # Konstanta Boltzmann dalam Joules/Kelvin
```
* Tujuan: Menginisialisasi parameter untuk perhitungan pathloss, daya penerima (Prx), noise, dan SNR.
* Detail:
    * RB: Jumlah Resource Blocks.
    * bts_offset: Offset vertikal BTS dari jalan.
    * f, h_tx, h_rx, pt, gt, gr, temperature, bandwidth, BOLTZMANN_CONSTANT: Parameter teknis untuk perhitungan komunikasi nirkabel.

**4. Fungsi Konversi dBm ke mWatt**
```=
def dbm_mwatt(x):
    return 10**(x / 10)
```
* Tujuan: Mengonversi daya dari dBm ke miliwatt (mW).
* Rumus:
![image](https://hackmd.io/_uploads/S1ibB-2B0.png)

**5. Fungsi Generate Shadowing**
```=
def generate_shadowing(low=2, high=3):
    return random.uniform(low, high)
```
* Tujuan: Menghasilkan nilai shadowing acak dalam rentang yang ditentukan.
* Detail: Menggunakan random.uniform untuk menghasilkan nilai acak antara low dan high.

**6. Fungsi Pathloss**
```=
def cal_pathloss_new(d, fc, shadowing=0):
    if d == 0:
        d = 0.01  # Nilai kecil untuk menghindari log(0)
    pathloss = 38.77 + 16.7 * np.log10(d) + 18.2 * np.log10(fc) + shadowing
    return pathloss
```
* Tujuan: Menghitung pathloss berdasarkan jarak dan frekuensi dengan menambahkan shadowing.
* Detail:
![image](https://hackmd.io/_uploads/Sy1tBZ2BC.png)

**7. Fungsi Menghitung Prx (Daya Penerima)**
```=
def cal_prx_mw(pt, d, fc, gt, gr):
    shadowing = generate_shadowing()
    pathloss_db = cal_pathloss_new(d, fc, shadowing)
    prx_dbm = pt + gt + gr - pathloss_db
    prx_mw = dbm_mwatt(prx_dbm)
    return prx_mw  # Output mW
```
* Tujuan: Menghitung daya penerima dalam miliwatt.
* Detail:
    * Menghitung pathloss menggunakan cal_pathloss_new.
    * Menghitung daya penerima dalam dBm:
![image](https://hackmd.io/_uploads/SypfUWnr0.png)
    * Mengonversi daya penerima dari dBm ke mW menggunakan dbm_mwatt.
    
**8. Fungsi Menghitung Noise**
```=
def cal_noise_mw(temperature, bandwidth):
    noise_mw = BOLTZMANN_CONSTANT * temperature * bandwidth * 1000  # Konversi ke mWatt
    return noise_mw
```
* Tujuan: Menghitung noise dalam miliwatt.
* Detail:
![image](https://hackmd.io/_uploads/SycdIW3rC.png)
di mana 𝑘 adalah konstanta Boltzmann, 𝑇 adalah suhu dalam Kelvin, dan 𝐵 adalah bandwidth dalam Hertz.

**9. Fungsi Menghitung Jarak Euclidean**
```=
def calculate_distance(vehicle_position, bts_position, bts_offset):
    return np.sqrt((vehicle_position - bts_position)**2 + bts_offset**2)
```
* Tujuan: Menghitung jarak Euclidean antara posisi kendaraan dan posisi BTS.
* Detail:
    * Menggunakan rumus jarak Euclidean
![image](https://hackmd.io/_uploads/HJUGDbhHA.png)

**10. Fungsi Menghitung Jarak antara Medoid dan Anggota Cluster**
```=
def calculate_medoid_member_distance(medoid_position, medoid_lane, member_position, member_lane):
    if medoid_lane != member_lane:
        distance = np.sqrt((medoid_position - member_position)**2 + (3.5 * abs(medoid_lane - member_lane))**2)
    else:
        distance = abs(medoid_position - member_position)
    return distance
```
* Tujuan: Menghitung jarak antara medoid dan anggota cluster.
* Detail:
    * Jika medoid dan anggota cluster berada di jalur yang berbeda, jarak dihitung dengan menambahkan jarak antar jalur (3.5 meter per jalur).
    * Jika berada di jalur yang sama, jarak adalah selisih posisi medoid dan anggota cluster.

**Untuk Iterasi simulasi langsung dijelaskan di link bawah ya !**
**Penjelasan Code ini lebih detail akan dibahas di link** >> [Klik Disini](https://hackmd.io/@4JCBNYqXS7qbp4mZBx63rw/BJmQ_FFHA)

### 4.4 Code Alokasi Sumber Daya Radio
![image](https://hackmd.io/_uploads/HkN0-CHHA.png)

* **Mulai Proses**
Inisiasi proses alokasi sumber daya radio untuk komunikasi kendaraan-ke-kendaraan.

* **Pemilihan Metode Alokasi Sumber Daya**
Tentukan metode yang akan digunakan untuk alokasi sumber daya radio: FIFO, Greedy, atau Genetic.

* **Metode FIFO**
Deskripsi: Mengalokasikan sumber daya berdasarkan urutan kedatangan permintaan.
Tujuan: Prioritaskan permintaan yang datang lebih awal.

* **Metode Greedy**
Deskripsi: Mengalokasikan sumber daya berdasarkan nilai tertinggi pada saat itu (misalnya, SNR tertinggi).
Tujuan: Prioritaskan permintaan dengan nilai tertinggi.

* **Metode Genetic**
Deskripsi: Menggunakan algoritma genetika untuk menemukan kombinasi solusi optimal untuk alokasi sumber daya.
Tujuan: Temukan solusi alokasi yang paling optimal dengan mempertimbangkan berbagai faktor.

* **Evaluasi Kinerja**
Deskripsi: Menghitung kinerja alokasi sumber daya untuk setiap metode.
Tujuan: Mengevaluasi seberapa baik setiap metode dalam mengalokasikan sumber daya.

* **Tampilkan Hasil Perbandingan**
Deskripsi: Menampilkan hasil evaluasi kinerja dari ketiga metode.
Tujuan: Menyediakan data untuk analisis lebih lanjut, seperti tingkat data, rata-rata tingkat data, efisiensi spektral, dan keadilan.

* **Ulang Proses**
Deskripsi: Kembali ke awal proses untuk iterasi berikutnya atau untuk memperbaiki proses yang ada.
Tujuan: Mengulang proses alokasi sumber daya jika diperlukan.

**Output dan Evaluasi**
Setelah alokasi sumber daya dilakukan dengan masing-masing algoritma, hasil simulasi akan dievaluasi berdasarkan beberapa metrik performa:

* Data Rate: Kecepatan data yang diterima oleh setiap kendaraan.
* Average Data Rate: Rata-rata kecepatan data yang diterima oleh semua kendaraan.
* Spectral Efficiency: Efisiensi penggunaan spektrum radio.
* Fairness: Keadilan dalam distribusi sumber daya radio di antara semua kendaraan.

#### 4.4.1 Alokasi Sumber Daya Radio - FIFO

**Penjelasan Code ini lebih detail akan dibahas di link** >> [Klik Disini](https://hackmd.io/@4JCBNYqXS7qbp4mZBx63rw/B1A_OFKrR)
#### 4.4.2 Alokasi Sumber Daya Radio - Greedy

**Penjelasan Code ini lebih detail akan dibahas di link** >> [Klik Disini](https://hackmd.io/@4JCBNYqXS7qbp4mZBx63rw/Bk73OKFSR)
#### 4.4.3 Alokasi Sumber Daya Radio - Genetic

**Penjelasan Code ini lebih detail akan dibahas di link** >> [Klik Disini](https://hackmd.io/@4JCBNYqXS7qbp4mZBx63rw/HJ6sdYYSA)
#### 4.4.4 Key Performance Comparison

**Penjelasan Code ini lebih detail akan dibahas di link** >> [Klik Disini](https://hackmd.io/@4JCBNYqXS7qbp4mZBx63rw/H1FsdYYrR)

## In Case dosen penguji asking-asking

**Penjelasan lebih detail akan dibahas di link** >> [Klik Disini](https://hackmd.io/@4JCBNYqXS7qbp4mZBx63rw/r1stRK2rR)


---

## A Letter for Us :fire: 

Sebuah cerita yang terinspirasi oleh *The lord of the rings.* Sedikit penyemangat untuk kelancaran TA.

![image](https://hackmd.io/_uploads/rJPrp36rA.png)

**Perjalanan Menuju Keberhasilan**

Di dunia Middle-earth, tiga sahabat—Frodo, Sam, dan Aragorn—memulai perjalanan epik untuk menghancurkan Cincin Kekuatan yang jahat dan menyelamatkan dunia mereka dari kegelapan. Meskipun mereka memiliki latar belakang dan keahlian yang berbeda, mereka bersatu dalam tujuan mereka dan saling mendukung dalam setiap langkah perjalanan.

~Awal Perjalanan.
Frodo adalah seorang hobbit yang sederhana, tidak pernah bermimpi bahwa ia akan memikul beban yang begitu besar. Namun, ia memiliki tekad yang kuat dan hati yang murni. Sam, sahabat sejatinya, selalu ada di sampingnya, memberikan dukungan moral dan fisik. Aragorn, seorang pemimpin yang bijaksana dan pemberani, menggunakan pengalamannya untuk membimbing mereka melalui banyak bahaya.

`"Even the smallest person can change the course of the future." — Galadriel`

~Tantangan dan Rintangan.
Perjalanan mereka tidaklah mudah. Mereka menghadapi banyak tantangan—musuh yang kuat, medan yang berbahaya, dan rintangan yang tampaknya tidak bisa diatasi. Namun, setiap kali mereka merasa putus asa, mereka mengingat tujuan mereka dan saling memberi semangat.

`"There is some good in this world, and it’s worth fighting for." — Samwise Gamgee`

Saat menghadapi kesulitan terbesar, Frodo hampir menyerah. Namun, Sam selalu ada untuk mengingatkannya tentang betapa pentingnya tugas mereka. Sam menunjukkan bahwa dengan kerja keras, ketekunan, dan dukungan satu sama lain, mereka bisa melewati segala rintangan.

~Kekuatan Persahabatan
Persahabatan antara Frodo, Sam, dan Aragorn adalah kunci keberhasilan mereka. Mereka saling melengkapi dan mendukung, menggunakan kekuatan masing-masing untuk mengatasi kelemahan satu sama lain. Frodo dengan tekadnya, Sam dengan kesetiaannya, dan Aragorn dengan kepemimpinannya.

`"I can’t carry it for you, but I can carry you." — Samwise Gamgee`

~Kesuksesan dan Keberhasilan.
Setelah perjalanan yang panjang dan penuh tantangan, mereka akhirnya berhasil mencapai tujuan mereka. Cincin Kekuatan dihancurkan, dan kedamaian kembali ke Middle-earth. Perjalanan mereka menunjukkan bahwa tidak ada yang tidak mungkin jika kita bersatu, bekerja keras, dan percaya pada diri sendiri dan teman-teman kita.

`"All we have to decide is what to do with the time that is given us." — Gandalf`

~Pesan untuk kita.
Dalam perjalanan tugas akhir ini, kita mungkin menghadapi banyak tantangan dan rintangan. Namun, seperti Frodo, Sam, dan Aragorn, kita memiliki kekuatan untuk mengatasi semuanya. Gunakan tekad Frodo, kesetiaan Sam, dan kepemimpinan Aragorn sebagai inspirasi. Percayalah pada diri sendiri dan teman-teman Anda, dan ingatlah bahwa kerja keras, ketekunan, dan persahabatan adalah kunci keberhasilan.

`"The greatest adventure is what lies ahead." — J.R.R. Tolkien`

kita memiliki kemampuan dan potensi untuk menyelesaikan tugas akhir ini dengan gemilang. Tetap semangat, terus bekerja keras, dan jangan pernah menyerah. Bersama-sama, Anda bisa mencapai tujuan Anda dan meraih kesuksesan yang Anda impikan.

**Terakhir dari saya:**

`"In the end, it's not the years in your life that count. It's the life in your years." — Abraham Lincoln`