ccitonline.com

A. Judul Proyek

Optimasi desain geometri airfoil sayap terhadap performa aerodinamika (memaksimalkan lift force) menggunakan parameterisasi CST dan metode Kriging.

B. Nama Lengkap Penulis

Ahmad Husein Martondi Lubis

C. Afiliasi

Departemen Teknik Mesin, Universitas Indonesia

D. Abstrak

Makalah ini menyajikan pendekatan sistematis untuk melakukan optimalisasi lift force pada desain airfoil sayap menggunakan kerangka DAI5. Metodologi ini mengintegrasikan kesadaran sadar, niat, dan prinsip-prinsip teknik yang ketat untuk mengatasi tantangan sistem. Studi kasus menyoroti penerapan kerangka ini untuk mengoptimalkan kinerja, keandalan, dan keberlanjutan.

E. Deklarasi Penulis

1. Deep Awareness (of) I

Menyadari peran penulis dalam menyelaraskan keputusan teknis dengan menjaga ingatan kepada Tuhan Yang Maha Esa. Menekankan tanggung jawab etis dan komitmen terhadap hasil yang memberikan kebermanfaatan kepada masyarakat.

2. Niat Kegiatan Proyek

Mengembangkan pipeline kerja untuk menemukan geometri airfoil yang memiliki lift force paling optimal pada kecepatan tertentu dengan mematuhi prinsip keberlanjutan dan desain etis.

F. Pendahuluan

Dunia aviasi tidak akan terlepas dari trial-error, terutama di pengembangan desain sayap pesawat. Tentu metode-metode yang dilakukan para pelaku industri sangatlah beragam. Dengan keterbatasan, maka penulis sekedar melakukan dengan skala simulasi untuk membuat geometri airfoil sayap.

1. Pemikiran Awal (tentang Masalah):

– **Menganalisis Masalah Secara Sistematis:**

Dalam sistem perancangan aerodinamika konvensional (khususnya untuk body aircraft supersonik Mach 2.0), evaluasi performa sangat bergantung pada simulasi Computational Fluid Dynamics (CFD) penuh. Ketidakefisienan utama dalam sistem ini adalah tingginya biaya operasional komputasi (computationally expensive) dan kehilangan waktu (time-consuming) yang masif.

Jika proses optimasi dilakukan secara manual atau menggunakan metode pencarian langsung (brute force) yang membutuhkan ratusan hingga ribuan kali running solver CFD, hal ini menurunkan keandalan garis waktu riset (research timeline). Keterbatasan perangkat keras sering kali menyebabkan simulasi macet di tengah jalan (stagnant) atau bahkan mengalami kegagalan konvergensi (divergence numerik), yang secara langsung menurunkan produktivitas desain iteratif.

– **Soroti Penelitian Sebelumnya dan Kesenjangan yang Ada:**

• Keterbatasan Efisiensi Sumber Daya: Metode optimasi stokastik murni (seperti Genetic Algorithm konvensional) membutuhkan ribuan evaluasi fungsi CFD secara langsung, yang tidak adaptif untuk kebutuhan industri modern yang menuntut turnaround time cepat.
• Keterbatasan Akurasi Data Minim: Ketika penulis dihadapkan pada situasi riil di mana data sampel sangat sedikit (sparse data akibat limitasi waktu atau kegagalan solver), model regresi standar gagal menangkap tren non-linier dan justru menghasilkan osilasi prediksi yang liar (overfitting).

– **Mengurai Masalah:**

• Mengoptimalkan Distribusi Tekanan: Bagaimana memodifikasi geometri bodi sayap untuk memicu perbedaan tekanan kejut (shock-expansion fan) yang menguntungkan antara permukaan atas dan bawah demi mendongkrak gaya angkat (lift force, FL).
• Reduksi Dimensi Parameter: Bagaimana mengontrol kelengkungan bodi kontinu tanpa kehilangan karakteristik fisisnya. Tantangan ini diilustrasikan dengan memotong ruang pencarian parameter dari 8 dimensi koefisien CST menjadi 4 dimensi dominan (CST_Up_1,2 dan CST_Low_1,2) yang secara spesifik mengontrol area Leading Edge dan ketebalan maksimum bodi tempat gelombang kejut supersonik terbentuk.

– **Dekonstruksi ke Prinsip-Prinsip Dasar:**

• Dinamika Fluida Kompresibel: Menggunakan Persamaan Euler/Navier-Stokes untuk menganalisis pembentukan gelombang kejut terlampir (attached shock) pada kecepatan Mach 2.0, di mana gaya angkat dihasilkan dari integrasi distribusi tekanan statis di sepanjang chord length.
• Statistik dan Teori Probabilitas: Memanfaatkan landasan Proses Gaussian (Kriging) untuk memprediksi nilai kontinuitas ruang spasial berdasarkan korelasi spasial antar titik sampel melalui fungsi kernel Matern 3/2.
• Aljabar Linier Numerik: Menerapkan teknik regularisasi numerik (nugget effect / penyisipan parameter noise alpha = 10^(-2) pada matriks identitas) untuk menstabilkan inversi matriks kovarians yang ill-conditioned akibat keterbatasan 13 sampel data.

– **Analisis State-of-the-Art:**

Kemajuan teknologi saat ini telah melahirkan konsep Surrogate Modeling (Metamodeling) atau Model Pengganti cerdas berbasis pembelajaran mesin. Pendekatan state-of-the-art ini memungkinkan kita melatih model perkiraan matematika (seperti Kriging) menggunakan data sampel awal (DoE lewat Latin Hypercube Sampling), lalu menginterogasi model tersebut menggunakan algoritma optimasi berbasis gradien (L-BFGS-B) dalam fraksi detik tanpa menyentuh solver CFD berulang kali.

Masalah yang Belum Terselesaikan & Justifikasi Pendekatan Baru: Masalah krusial yang tersisa adalah tingginya tingkat galat kuantitatif (surrogate error) jika data latihan terlampau tipis (seperti kasus 13 sampel yang memprediksi FL = 132.97 N padahal aktual SU2 mencapai 4709.98 N. Hal ini menjustifikasi kebutuhan akan pendekatan baru yang diterapkan secara taktis: memposisikan model surrogate bukan sebagai prediktor nilai mutlak, melainkan sebagai penunjuk arah kecenderungan kualitatif (trend director). Pendekatan ini membuktikan bahwa meskipun sampel sangat terbatas, metode numerik ini tetap berhasil memandu algoritma menemukan geometri bodi optimal yang terbukti menghasilkan lonjakan performa signifikan saat divalidasi ulang.

G. Metode & Langkah-langkah Solusi

1. Idealisasi:

Dalam studi numerik ini, kompleksitas fisik dari aliran fluida kompresibel di sekitar sayap supersonik disederhanakan melalui beberapa tahapan idealisasi numerik agar komputasi tetap efisien pada kondisi data minim:

1. Idealisasi Dimensi (2D Airfoil): Fenomena tiga dimensi (3D wing tip vortices dan efek downwash) diabaikan. Sistem disederhanakan menjadi pemodelan dua dimensi (2D) kontinu yang berfokus pada penampang melintang (cross-section) bodi untuk mengisolasi pengaruh parameterisasi geometri CST secara murni.
2. Kondisi Aliran (Inviscid Flow): Persamaan pengatur fluida diidealisasikan menggunakan Persamaan Euler 2D (mengabaikan efek viskositas dan lapisan batas/boundary layer). Langkah ini diambil karena pada kecepatan Mach 2.0, hambatan gelombang (wave drag) jauh lebih mendominasi gaya aerodinamika dibandingkan hambatan gesek (skin friction drag).
3. Penyederhanaan Ruang Desain (Feature Truncation): Ruang pencarian parameter didekonstruksi dari sistem 8-Dimensi (4 variabel upper, 4 variabel lower) menjadi ruang 4-Dimensi (CST_Up_1, CST_Up_2, CST_Lo_1, CST_Lo_2). Variabel sisa pada sektor Trailing Edge dikunci pada nilai transisi konstan 0.10.

Penyusunan algoritma dan interpretasi hasil dipandu oleh beberapa pilar teoretis berikut:

• Shock-Expansion Theory: Prinsip termodinamika aliran kompresibel menyatakan bahwa setiap belokan geometri bodi yang membelokkan aliran ke dalam dirinya sendiri (compressive turn) akan memicu shockwave yang menaikkan tekanan statis. Sebaliknya, belokan yang menjauhi arah aliran (expansive turn) memicu gelombang ekspansi yang menurunkan tekanan statis. Teori ini memandu desain optimasi dalam memanfaatkan parameter bodi bawah yang cembung guna mengumpulkan tekanan tinggi di bawah sayap.
• Teori Proses Gaussian (Kriging): Prinsip statistik spasial yang menyatakan bahwa titik-titik dalam ruang parameter yang saling berdekatan memiliki korelasi performa yang lebih tinggi dibandingkan titik yang berjauhan. Korelasi ini diatur secara matematis oleh fungsi jarak kernel Matern 3/2.

2. Instruksi (Set):

H. Hasil dan Diskusi

Berikut ini merupakan hasil optimasi dari metode Kriging dengan kombinasi parameter CST dan prediksi FL.

Lantas penulis memasukkan parameter-parameter tersebut ke program python CST untuk memvisualisasikan airfoilnya sebagai berikut :

Lalu berikut ini adalah hasil simulasi airfoil tersebut pada CFD SU2 :

Terlihat konvergen terjadi sekitar iterasi 450 hingga 452. Simulasi ini menyatakan bahwa konfigurasi airfoil optimum berdasarkan Kriging parameter CST menghasilkan CL di angka 0.016601381 pada kecepatan Mach 2, Angle of Attack 3.0 degree, serta chord length 1 meter. Lift Force yang dimiliki oleh airfoil tersebut pada idealisasi ini adalah sebesar 4709.978 N (CL dikalikan RefForce) yang justru jauh melampaui prediksi Kriging.

I. Kesimpulan, Penutup, Rekomendasi

Ringkasan Kontribusi Kerangka Kerja

Tugas Besar ini berhasil mendemonstrasikan kontribusi nyata dari integrasi kerangka kerja Surrogate Modeling berbasis Kriging dalam mempercepat proses desain sistem aerodinamika. Melalui metode ini, interogasi ruang sampel untuk mencari bentuk bodi optimal tidak lagi memerlukan ratusan kali evaluasi solver CFD yang memakan waktu dan biaya komputasi besar.

Meskipun dihadapkan pada kendala keterbatasan data (sparse data, 13 sampel valid), kerangka kerja ini berkontribusi secara kualitatif sebagai penunjuk arah kecenderungan (trend director). Integrasi ini berhasil memandu algoritma optimasi gradien L-BFGS-B menuju wilayah kombinasi parameter CST asimetris yang secara fisis terbukti melipatgandakan gaya angkat aktual (FL) hingga menyentuh angka 4709.98 N pada pengujian validasi SU2.

Penelitian ini membuka potensi metodologi baru untuk digunakan pada industri sehingga menghasilkan kebermanfaatan untuk umat manusia terkait percepatan proses pengembangan geometri sayap aviasi.

Rekomendasi Studi Lanjutan

Untuk mengatasi kelemahan error kuantitatif (surrogate error) yang muncul akibat keterbatasan data sampel pada penelitian ini, direkomendasikan beberapa poin studi lanjutan:

Eksplorasi Material dan Struktur Sayap: Mengintegrasikan model aerodinamika ini dengan analisis elemen hingga (Finite Element Analysis / FEA) untuk menguji kekuatan struktural material bodi terhadap beban tekanan ekstrem yang dihasilkan oleh geometri asimetris hasil optimasi pada kecepatan Mach 2.0.

Strategi Kontrol dan Infill Sampling Canggih: Menerapkan algoritma pengondisian sampel sekuensial seperti Efficient Global Optimization (EGO) menggunakan kriteria Expected Improvement (EI). Strategi ini akan mengontrol penambahan sampel baru secara otomatis hanya pada area dengan tingkat ketidakpastian (standard deviasi) tertinggi untuk mempercepat konvergensi akurasi model Kriging.

J. Ucapan Terima Kasih

Penulis menyampaikan rasa terima kasih yang sebesar-besarnya kepada dosen pengampu mata kuliah Metode Numerik atas bimbingan, arahan, dan ilmu pengetahuan yang telah diberikan selama perkuliahan. Penulis juga mengucapkan terima kasih kepada seluruh pihak yang telah bersedia berbagi referensi kode program dan menyediakan bantuan teknis, sehingga kendala kompilasi data pada solver CFD open-source SU2 dan script Python Kriging ini dapat diselesaikan dengan baik demi menuntaskan Tugas Besar ini tepat pada waktunya.

K. Referensi yang Dikutip

Kulfan, B. M. (2008). Universal Parametric Geometry Representation Method – “CST”. Journal of Aircraft, 45(1), 142–158.

Rasmussen, C. E., & Williams, C. K. I. (2006). Gaussian Processes for Machine Learning. MIT Press.

Scikit-Learn Developers. (2026). Gaussian Processes: Gaussian Process Regression (GPR). Scikit-Learn User Guide.

SU2 International Open Source Project. (2026). SU2: An Open-Source Suite for Multiphysics Simulation and Design. Code Documentation and User Tutorials.

L. Lampiran

1. Beberapa hasil LHS oleh python :

2. Kombinasi parameter CST dan performa aerodinamikanya untuk airfoil yang lolos seleksi (tanpa intersect).

3. Persamaan parameterisasi geometri airfoil dengan metode CST menggunakan 8 parameter untuk generate sampling dan 4 parameter untuk visualisasi hasil optimasi LF (karena keterbatasan sampel valid).

4. Ekspresi persamaan pemodelan Kriging :

5. Script coding generate sampling

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd  # Ditambahkan untuk handle pembuatan CSV
import os
from scipy.special import comb
from scipy.stats import qmc

def bernstein_poly(i, n, x):
    """Menghitung polinomial Bernstein."""
    return comb(n, i) * (x**i) * ((1 - x)**(n - i))

def cst_airfoil(x, weights_upper, weights_lower, dz_te=0):
    """Menghasilkan koordinat y atas dan bawah."""
    n = len(weights_upper) - 1
    
    # Class Function untuk Supersonik (n1=1.0, n2=1.0 menghasilkan biconvex tajam)
    C = x**1.0 * (1 - x)**1.0
    
    # Shape Function
    S_upper = sum(w * bernstein_poly(i, n, x) for i, w in enumerate(weights_upper))
    S_lower = sum(w * bernstein_poly(i, n, x) for i, w in enumerate(weights_lower))
    
    y_upper = C * S_upper + x * dz_te
    y_lower = C * S_lower - x * dz_te 
    
    return y_upper, y_lower


# 1. SETUP DISTRIBUSI TITIK X
x = np.linspace(0, 1, 200)

w_upper = [0.15, 0.20, 0.15, 0.10]
w_lower = [0.10, 0.10, 0.10, 0.10]

# 2. SAMPLING LATIN HYPERCUBE (LHS)
n_samples = 50
n_weights = len(w_upper) # 4 koefisien

# Ditambahkan seed=42 agar variasi sampel konsisten dan bisa direproduksi kembali
sampler = qmc.LatinHypercube(d=n_weights * 2, seed=500) 
sample_raw = sampler.random(n=n_samples)

# Menjaga bobot antara 0.05 (tipis) dan 0.25 (tebal)
l_bounds = [0.05] * (n_weights * 2)
u_bounds = [0.25] * (n_weights * 2)
weights_samples = qmc.scale(sample_raw, l_bounds, u_bounds)

# 3. LOOP EKSPOR GEOMETRI & PEMBUATAN DATASET CSV
cst_rows = [] # List untuk menampung baris parameter matriks Kriging

for i, sample in enumerate(weights_samples):
    w_u = sample[:n_weights]
    w_l = sample[n_weights:]
    
    # Catat parameter koefisien ke dalam dictionary row
    row_data = {'Airfoil_ID': f'airfoil_{i}'}
    for idx, wu in enumerate(w_u):
        row_data[f'CST_Up_{idx+1}'] = round(wu, 6)
    for idx, wl in enumerate(w_l):
        row_data[f'CST_Lo_{idx+1}'] = round(wl, 6)
        
    cst_rows.append(row_data)
    
    # Hitung koordinat bodi
    y_up, y_lo = cst_airfoil(x, w_u, w_l)
    
    # Format koordinat awal (Selig format: TE -> LE -> TE)
    x_raw = np.concatenate([x[::-1], x[1:]])
    y_raw = np.concatenate([y_up[::-1], y_lo[1:]])
    
    # PROSES FILTER: Menghilangkan Duplikasi Titik Berurutan
    cleaned_coords = []
    last_pt = None
    for pt_x, pt_y in zip(x_raw, y_raw):
        current_pt = (round(pt_x, 6), round(pt_y, 6))
        if current_pt != last_pt:
            cleaned_coords.append(current_pt)
            last_pt = current_pt
            
    cleaned_coords = np.array(cleaned_coords)
    
    # Simpan file koordinat .dat yang sudah bersih
    np.savetxt(f'airfoil_{i}.dat', cleaned_coords, fmt='%.6f\t%.6f')

# 4. SIMPAN MATRIKS INPUT KRIGING KE CSV
df_cst = pd.DataFrame(cst_rows)
df_cst.to_csv('parameter_cst.csv', index=False)

print(f"--> Berhasil menghasilkan {n_samples} file .dat yang telah DIFILTER BERSIH.")
print("--> File 'parameter_cst.csv' berhasil dibuat untuk input model Kriging.")

6. Script generate mesh untuk CFD SU2

import gmsh
import os
import numpy as np

def create_su2_mesh(dat_filepath, output_su2path):
    gmsh.initialize()
    gmsh.model.add("airfoil_mesh")
    
    # 1. Load koordinat dari file .dat
    coords = []
    with open(dat_filepath, 'r') as f:
        for line in f:
            if line.strip() and not line.startswith('#'):
                parts = line.split()
                if len(parts) >= 2:
                    try:
                        coords.append([float(parts[0]), float(parts[1]), 0.0])
                    except ValueError:
                        continue
    
    # Bersihkan duplikasi jika ada
    coords = np.array(coords)
    
    # 2. Masukkan poin-poin airfoil ke Gmsh
    airfoil_points = []
    lc_airfoil = 0.02  
    
    for i, pt in enumerate(coords):
        if pt[0] < 0.05 or pt[0] > 0.95:
            local_lc = 0.008  
        else:
            local_lc = lc_airfoil
        p = gmsh.model.geo.addPoint(pt[0], pt[1], 0.0, local_lc)
        airfoil_points.append(p)
        

    if airfoil_points[0] != airfoil_points[-1]:
        airfoil_points.append(airfoil_points[0])
        
    # Buat satu kurva utuh secara instan
    airfoil_spline = gmsh.model.geo.addSpline(airfoil_points)
    airfoil_lines = [airfoil_spline]
        
    airfoil_loop = gmsh.model.geo.addCurveLoop(airfoil_lines)
    # 3. Buat Domain Luar (Farfield) - Lingkaran besar radius 25x chord
    lc_farfield = 2.0
    c1 = gmsh.model.geo.addPoint(0.5, 0.0, 0.0, lc_farfield)
    c2 = gmsh.model.geo.addPoint(25.0, 0.0, 0.0, lc_farfield)
    c3 = gmsh.model.geo.addPoint(-24.0, 0.0, 0.0, lc_farfield)
    
    arc1 = gmsh.model.geo.addCircleArc(c2, c1, c3)
    arc2 = gmsh.model.geo.addCircleArc(c3, c1, c2)
    
    farfield_loop = gmsh.model.geo.addCurveLoop([arc1, arc2])
    
    # 4. Buat Surface
    surface = gmsh.model.geo.addPlaneSurface([farfield_loop, airfoil_loop])
    
    gmsh.model.geo.synchronize()
    
    # 5. Definisikan Physical Groups (Boundary untuk SU2_cfg)
# 5. Definisikan Physical Groups (Gunakan cara aman agar nama ter-compile di file .su2)
    airfoil_group = gmsh.model.addPhysicalGroup(1, airfoil_lines)
    gmsh.model.setPhysicalName(1, airfoil_group, "airfoil")
    
    farfield_group = gmsh.model.addPhysicalGroup(1, [arc1, arc2])
    gmsh.model.setPhysicalName(1, farfield_group, "farfield")
    
    fluid_group = gmsh.model.addPhysicalGroup(2, [surface])
    gmsh.model.setPhysicalName(2, fluid_group, "fluid")
    
    # 6. Generate Mesh 2D
    gmsh.model.mesh.generate(2)
    
    # 7. Simpan langsung ke format SU2
    gmsh.write(output_su2path)
    gmsh.finalize()
    print(f"Mesh sukses dibuat: {output_su2path}")

# Test run untuk airfoil_1
if __name__ == "__main__":
    current_dir = os.path.dirname(os.path.abspath(__file__))
    dat_file = os.path.join(current_dir, "airfoil_optimum.dat")
    su2_output = os.path.join(current_dir, "airfoil_optimum.su2")
    create_su2_mesh(dat_file, su2_output)

7. Script untuk simulasi CFD SU2

import subprocess
import os

# Definisikan direktori kerja
working_dir = os.path.dirname(os.path.abspath(__file__))

# Nama file konfigurasi SU2 yang ada di folder proyek Anda
config_file = os.path.join(working_dir, "inv_airfoil.cfg")

print("Memulai simulasi SU2 dari VS Code...")

try:
    # Memanggil SU2_CFD melalui terminal Windows secara otomatis

    result = subprocess.run(
        ["SU2_CFD", config_file], 
        cwd=working_dir,          # Memastikan SU2 berjalan di folder proyek saat ini
        text=True, 
        capture_output=True       # Menangkap log output terminal SU2
    )
    
    # Menampilkan log akhir jika selesai
# Menampilkan log akhir jika selesai
    if result.returncode == 0:
        print("Simulasi Selesai Sukses! File history.csv telah dibuat.")
    else:
        print("Terjadi kesalahan pada solver SU2. Log Error:")
        print(result.stdout)  # <--- Ubah dari result.stderr menjadi result.stdout

except FileNotFoundError:
    print("Error: Perintah 'SU2_CFD' tidak ditemukan. Pastikan Langkah 3 (Environment Variables) sudah benar dan restart VS Code Anda.")

8. Script konfigurasi SU2

% ---- JENIS SOLVER ----
SOLVER= EULER
RESTART_SOL= NO

% ---- KONDISI ALIRAN BEBAS (FREESTREAM) ----
MACH_NUMBER= 2.0
AOA= 3.0
FREESTREAM_PRESSURE= 101325.0
FREESTREAM_TEMPERATURE= 288.15

% ---- PARAMETER REFERENSI GEOMETRI & GAYA ----
REF_LENGTH= 1.0
REF_AREA= 1.0
REF_ORIGIN_MOMENT_X= 0.25
REF_ORIGIN_MOMENT_Y= 0.00
REF_ORIGIN_MOMENT_Z= 0.00

% ---- DEFINISI PENANDA BATAS KONTUR (SENSITIF HURUF KECIL) ----
MARKER_EULER= ( airfoil )
MARKER_NEARFIELD= ( farfield )

% ---- PARAMETER INTEGRASI GAYA AERODINAMIKA ----
MARKER_MONITORING= ( airfoil )


% ---- METODE NUMERIK RUANG (JST MURNI & STABIL) ----
NUM_METHOD_GRAD= GREEN_GAUSS
CONV_NUM_METHOD_FLOW= JST
MUSCL_FLOW= NO

% Naikkan disipasi Orde ke-2 (angka pertama) untuk meredam fluktuasi di shockwave
JST_SENSOR_COEFF= ( 1.0, 0.01 )

CFL_NUMBER= 1.0
ITER= 500
CONV_FIELD= RMS_DENSITY
CONV_RESIDUAL_MINVAL= -6.0

% ---- PENGATURAN FILE OUTPUT SIMULASI ----
MESH_FILENAME= airfoil_optimum.su2
MESH_FORMAT= SU2
TABULAR_FORMAT= CSV
CONV_FILENAME= history
RESTART_FILENAME= restart_flow.dat
VOLUME_FILENAME= flow.dat
SURFACE_FILENAME= surface_flow.dat

% ---- PERINTAH OUTPUT DATA KE CSV ----
HISTORY_OUTPUT= (ITER, RMS_RES, AERO_COEFF)
SCREEN_OUTPUT= (ITER, RMS_RES, AERO_COEFF)