User:LuthfiShafwan

From ccitonlinewiki
Revision as of 13:18, 1 November 2024 by LuthfiShafwan (talk | contribs) (→‎Komputasi Teknik Pertemuan 1 (Pasca UTS) 29/10/2024)
Jump to: navigation, search

Introduction

IMG-20240516-WA0001.jpg

Nama saya muhammad luthfi shafwan, saya adalah mahasiswa S2 Teknik Mesin, Teknologi dan Sumber Daya Maritim angkatan 2024

Komputasi Teknik Pertemuan 1 (Pasca UTS) 29/10/2024

Pada pertemuan pertama ini, mahasiswa diperkenalkan dengan sebuah framework bernama DAI-5, yang dikembangkan oleh Dr. Ir. Ahmad Indra Siswantara. Framework ini didasari oleh konsep conscious thinking atau berpikir secara sadar. Landasan dari framework ini adalah falsafah yang beliau utarakan, yaitu "I'm my consciousness," yang menegaskan pentingnya kesadaran dalam setiap tindakan. Sebagai inisiator, beliau merumuskan framework ini menjadi empat tahapan penting: (1) Intention, (2) Initial Thinking, (3) Idealization, dan (4) Instruction Set. Tahapan-tahapan ini merepresentasikan pentingnya pendekatan sistematis dalam berbagai aspek kehidupan.

PERTANYAAN 1. (Can you derive finite element equations from 1D PDE governing equations using weighted residual in a very simple way along with an example?) Pernyataan Masalah PDE 1D Pertimbangkan persamaan konduksi panas dalam keadaan tunak satu dimensi: \frac{d}{dx}\left(k\frac{du}{dx}\right)+f=0 dengan ketentuan: u\left(x\right) adalah fungsi yang tidak diketahui (misalnya, suhu), k adalah konstanta (konduktivitas termal), f adalah istilah sumber yang diketahui. Misalkan persamaan ini berlaku pada domain 0\le x\le L. Langkah 1: Diskritisasi Domain Kita akan membagi domain [0,L] menjadi n elemen hingga. Untuk kesederhanaan, kita menggunakan elemen linier (setiap elemen memiliki dua titik node). Langkah 2: Mendefinisikan Solusi Pendekatan Dalam metode elemen hingga, kita mendekati u\left(x\right) dengan menggunakan himpunan fungsi bentuk N_i\left(x\right) dan nilai nodal U_i: u\left(x\right)\approx\buildrel u\over u\sim\left(x\right)=\sum_{i=1}^{n+1}N_i\left(x\right)U_i dengan ketentuan: N_i\left(x\right) adalah fungsi bentuk yang dipilih agar linier di setiap elemen, U_i adalah nilai nodal dari u\left(x\right) pada titik-titik node. Langkah 3: Formulasi Residu Berbobot (Metode Galerkin) Definisikan residu R\left(x\right) dari persamaan diferensial sebagai: R\left(x\right)=\frac{d}{dx}\left(k\frac{d\buildrel u\over u\sim}{dx}\right)+f Untuk metode Galerkin, kita mensyaratkan bahwa residu berbobot adalah nol untuk setiap fungsi uji N_j: \int_{0}^{L}N_jR\left(x\right)\thinsp dx=0 Substitusikan R\left(x\right) ke dalam persamaan ini, sehingga kita mendapatkan: \int_{0}^{L}N_j\left(\frac{d}{dx}\left(k\frac{d\buildrel u\over u\sim}{dx}\right)+f\right)dx=0 Langkah 4: Menerapkan Integrasi Parsial Untuk mengurangi orde turunan pada \buildrel u\over u\sim, kita lakukan integrasi parsial: \int_{0}^{L}N_j\frac{d}{dx}\left(k\frac{d\buildrel u\over u\sim}{dx}\right)dx=-\int_{0}^{L}\frac{dN_j}{dx}k\frac{d\buildrel u\over u\sim}{dx}\thinsp dx+\left[N_jk\frac{d\buildrel u\over u\sim}{dx}\right]_0^L Dengan asumsi kondisi batas alami dimana k\frac{d\buildrel u\over u\sim}{dx}=0 pada batas (yaitu, tidak ada aliran panas di x=0 dan x=L), suku batas akan hilang, sehingga menjadi: -\int_{0}^{L}\frac{dN_j}{dx}k\frac{d\buildrel u\over u\sim}{dx}\thinsp dx+\int_{0}^{L}N_jf\thinsp dx=0 Langkah 5: Substitusi Solusi Pendekatan \buildrel u\over u\sim\left(x\right) Substitusi \buildrel u\over u\sim\left(x\right)=\sum_{i=1}^{n+1}N_i\left(x\right)U_i ke dalam persamaan: -\int_{0}^{L}\frac{dN_j}{dx}k\sum_{i=1}^{n+1}\frac{dN_i}{dx}U_i\thinsp dx+\int_{0}^{L}N_jf\thinsp dx=0 Atur kembali untuk mendapatkan sistem persamaan: \sum_{i=1}^{n+1}\left(\int_{0}^{L}\frac{dN_j}{dx}k\frac{dN_i}{dx}\thinsp d x\right)U_i=\int_{0}^{L}N_jf\thinsp dx Definisikan matriks kekakuan elemen K_{ji} dan vektor beban F_j sebagai: K_{ji}=\int_{0}^{L}\frac{dN_j}{dx}k\frac{dN_i}{dx}\thinsp dx, Fj=0LNjf dx Persamaan yang dihasilkan untuk setiap titik node j menjadi: \sum_{i=1}^{n+1}K_{ji}U_i=F_j Contoh Pertimbangkan kasus spesifik dimana: k=1 (konduktivitas termal satuan), f=1 (istilah sumber konstan), Domain [0,1] dibagi menjadi dua elemen, masing-masing memiliki panjang h=0.5. Menggunakan fungsi bentuk linier N_1\left(x\right)=1-\frac{x}{h} dan N_2\left(x\right)=\frac{x}{h} di setiap elemen, kita dapat menghitung: Matriks Kekakuan Elemen: K_{ji}=\frac{1}{h}\left[\begin{matrix}1&-1\\-1&1\\\end{matrix}\right] untuk setiap elemen. Vektor Beban: F_j=\frac{fh}{2}\left[\begin{matrix}1\\1\\\end{matrix}\right]. Susun ini ke dalam matriks kekakuan global dan vektor beban untuk menyelesaikan nilai nodal U_i. Pendekatan ini menunjukkan proses perumusan persamaan elemen hingga dari PDE 1D menggunakan metode residu berbobot (Galerkin).





PERTANYAAN 2. (Can you provide algorithm, flow chart and python code?) Algorithm for 1D Finite Element Analysis (FEA) using Weighted Residuals Algoritma untuk Analisis Elemen Hingga 1D (FEA) menggunakan Metode Residu Tertimbang Parameter Masukan: Tentukan panjang domain L dan jumlah elemen n. Tetapkan sifat material: konduktivitas termal k dan suku sumber f. Tetapkan kondisi batas (misalnya, Dirichlet atau Neumann). Pembuatan Mesh: Bagi domain menjadi n elemen, dengan panjang setiap elemen h=L/n. Tentukan posisi node dan inisialisasi nilai awal node jika diperlukan. Mendefinisikan Fungsi Bentuk: Gunakan fungsi bentuk linear dalam setiap elemen: N_1\left(x\right)=1-\frac{x}{h}, N2x=xh Pembentukan Matriks Elemen: Untuk setiap elemen: Hitung matriks kekakuan elemen K_e. Hitung vektor beban elemen F_e. Kumpulkan ke dalam matriks kekakuan global K dan vektor beban global F. Menerapkan Kondisi Batas: Modifikasi matriks global K dan vektor F sesuai dengan kondisi batas. Menyelesaikan Sistem Persamaan: Selesaikan sistem linier KU=F untuk mendapatkan nilai nodal U. ________________________________________ Diagram Alir (Flowchart) +-----------------------------------+ | Mulai | +-----------------------------------+ 

           |
           v

+-----------------------------------+ | Tentukan domain, sifat material, | | dan nilai batas | +-----------------------------------+ 

           |
           v

+-----------------------------------+ | Diskretisasi domain menjadi elemen| +-----------------------------------+ 

           |
           v

+-----------------------------------+ | Tentukan fungsi bentuk dan | | inisialisasi matriks kekakuan | | global (K) dan vektor beban (F) | +-----------------------------------+ 

           |
           v

+-----------------------------------+ | Loop untuk setiap elemen: | | - Bentuk matriks kekakuan | | elemen (K_e) | | - Bentuk vektor beban elemen | | (F_e) | | - Kumpulkan ke K dan F | +-----------------------------------+ 

           |
           v

+-----------------------------------+ | Terapkan kondisi batas pada K, F | +-----------------------------------+ 

           |
           v

+-----------------------------------+ | Selesaikan sistem KU = F untuk U | +-----------------------------------+ 

           |
           v

+-----------------------------------+ | Tampilkan solusi U | +-----------------------------------+ 

           |
           v

+-----------------------------------+ | Selesai | +-----------------------------------+ ________________________________________ Kode Python Berikut ini adalah cuplikan kode Python yang menerapkan analisis elemen hingga 1D menggunakan fungsi bentuk linear dan proses perakitan matriks elemen ke dalam sistem global. import numpy as np

  1. Definisikan parameter masukan

L = 1.0 # Panjang domain n_elements = 2 # Jumlah elemen k = 1.0 # Konduktivitas termal f = 1.0 # Sumber term h = L / n_elements # Panjang setiap elemen

  1. Jumlah node

n_nodes = n_elements + 1

  1. Inisialisasi matriks kekakuan global K dan vektor beban F

K = np.zeros((n_nodes, n_nodes)) F = np.zeros(n_nodes)

  1. Definisikan matriks kekakuan elemen dan vektor beban untuk setiap elemen

K_e = (k / h) * np.array([[1, -1], [-1, 1]]) F_e = (f * h / 2) * np.array([1, 1])

  1. Proses perakitan: isi K dan F global

for e in range(n_elements): 

   # Nomor node global untuk elemen ini
   n1 = e     # Node awal elemen e
   n2 = e + 1 # Node akhir elemen e
   
   # Kumpulkan kekakuan elemen ke dalam matriks kekakuan global
   K[n1, n1] += K_e[0, 0]
   K[n1, n2] += K_e[0, 1]
   K[n2, n1] += K_e[1, 0]
   K[n2, n2] += K_e[1, 1]
   
   # Kumpulkan vektor beban elemen ke dalam vektor beban global
   F[n1] += F_e[0]
   F[n2] += F_e[1]
  1. Terapkan kondisi batas (asumsi u(0) = 0, bebas di x=L)

K[0, :] = 0 K[0, 0] = 1 # Kondisi Dirichlet pada node 0 F[0] = 0

  1. Selesaikan sistem linier KU = F untuk nilai nodal U

U = np.linalg.solve(K, F)

  1. Tampilkan solusi

print("Nilai nodal (U):", U) Penjelasan Kode Parameter Masukan: Mendefinisikan panjang domain L, jumlah elemen, konduktivitas termal k, suku sumber f, dan panjang elemen h. Matriks Global: Matriks kekakuan K dan vektor beban F diinisialisasi sebagai array nol. Matriks dan Vektor Elemen: Matriks kekakuan K_e dan vektor beban F_e untuk setiap elemen dihitung. Proses Perakitan: Setiap matriks elemen ditambahkan ke matriks global sesuai dengan posisi node elemen tersebut. Kondisi Batas: Memodifikasi matriks K dan vektor F untuk menerapkan u\left(0\right)=0. Menyelesaikan Sistem: Menyelesaikan KU=F untuk menemukan solusi nodal U, yang mewakili distribusi suhu dalam kasus ini. Keluaran Program ini akan menampilkan nilai nodal (misalnya, suhu di setiap node), yang merupakan solusi aproksimasi dari PDE 1D. Setup ini memberikan kerangka dasar untuk FEA dalam 1D dan dapat diperluas ke masalah yang lebih kompleks dan dimensi yang lebih tinggi.



PERTANYAAN 3. (What is np. Can you elaborate it?) np adalah alias umum yang digunakan untuk mengimpor pustaka NumPy dalam bahasa pemrograman Python. NumPy adalah pustaka yang sangat kuat untuk komputasi numerik dan analisis data. Berikut adalah beberapa penjelasan lebih lanjut mengenai NumPy dan kegunaannya: Apa itu NumPy? Pustaka untuk Komputasi Numerik: NumPy menyediakan dukungan untuk array multidimensi (seperti vektor dan matriks) dan berbagai fungsi untuk operasi matematis. Ini membuatnya sangat berguna untuk aplikasi ilmiah dan teknik. Array: NumPy memperkenalkan objek array yang efisien. Ini lebih cepat dan lebih fleksibel dibandingkan dengan daftar Python standar, terutama saat menangani data besar. Operasi Vektor dan Matriks: NumPy memungkinkan operasi matematis yang dilakukan pada seluruh array tanpa memerlukan loop eksplisit, yang dikenal sebagai operasi vektorisasi. Ini mempercepat perhitungan dan mengurangi jumlah kode yang perlu ditulis. Fungsi Matematika dan Statistik: NumPy dilengkapi dengan banyak fungsi untuk melakukan perhitungan matematis dan statistik, seperti mean, median, dan berbagai fungsi aljabar linier. Contoh Penggunaan Berikut adalah beberapa contoh penggunaan NumPy: import numpy as np

  1. Membuat array 1D

arr_1d = np.array([1, 2, 3, 4, 5]) print("Array 1D:", arr_1d)

  1. Membuat array 2D

arr_2d = np.array([[1, 2, 3], [4, 5, 6]]) print("Array 2D:\n", arr_2d)

  1. Operasi matematis

sum_arr = arr_1d + 5 # Menambahkan 5 ke setiap elemen print("Array setelah ditambah 5:", sum_arr)

  1. Menghitung mean

mean_value = np.mean(arr_1d) print("Mean dari Array 1D:", mean_value)

  1. Matriks perkalian

matrix_a = np.array([[1, 2], [3, 4]]) matrix_b = np.array([[5, 6], [7, 8]]) result = np.dot(matrix_a, matrix_b) # Perkalian matriks print("Hasil perkalian matriks:\n", result) Mengapa Menggunakan NumPy? Kecepatan: Operasi yang dilakukan di NumPy sering kali lebih cepat daripada yang dilakukan menggunakan struktur data Python murni. Konsistensi dan Kemudahan Penggunaan: NumPy menawarkan antarmuka yang konsisten dan mudah digunakan untuk berbagai operasi. Dukungan untuk Data Besar: NumPy dirancang untuk menangani data besar dengan efisien, yang penting dalam analisis data dan pemrosesan numerik. Jika Anda ingin menggunakan NumPy, Anda dapat menginstalnya menggunakan pip: (Pip install numpy) Setelah itu, Anda dapat mulai menggunakan NumPy dalam proyek Python Anda.







PERTANYAAN 4. (Can you make it much simpler?) Apa itu np? np adalah singkatan untuk NumPy, sebuah pustaka (library) di Python yang digunakan untuk mengolah angka dan data. Kenapa Pakai NumPy? Array: NumPy memungkinkan kita membuat dan mengelola array (seperti daftar, tetapi lebih cepat dan efisien). Operasi Matematika: Kita bisa melakukan operasi matematika seperti penjumlahan dan perkalian pada seluruh array tanpa menggunakan loop, yang membuat kode lebih ringkas dan cepat. Fungsi Statistik: NumPy menyediakan fungsi untuk menghitung nilai seperti rata-rata, median, dan lain-lain. Contoh Penggunaan Berikut adalah contoh sederhana menggunakan NumPy: import numpy as np # Mengimpor NumPy

  1. Membuat array

array = np.array([1, 2, 3, 4, 5]) print("Array:", array)

  1. Menambahkan 5 ke setiap elemen

array_plus_5 = array + 5 print("Setelah ditambah 5:", array_plus_5)

  1. Menghitung rata-rata

rata_rata = np.mean(array) print("Rata-rata:", rata_rata) Kesimpulan NumPy membantu kita dalam pengolahan data dan perhitungan matematis dengan cara yang lebih efisien. Menggunakan np sebagai alias membuat kode lebih ringkas. PERTANYAAN 5. (1D fem Equation derivation?) Derivasi Persamaan FEM 1D Langkah 1: Pernyataan Masalah Kita mempertimbangkan persamaan konduksi panas 1D: \frac{d}{dx}\left(k\frac{du}{dx}\right)+f=0 di mana: u\left(x\right) adalah fungsi yang ingin kita cari (misalnya, suhu), k adalah konduktivitas termal, f adalah sumber yang diketahui. Langkah 2: Diskretisasi Domain Bagi domain [0,L] menjadi n elemen. Misalkan setiap elemen memiliki panjang h=\frac{L}{n}. Langkah 3: Definisikan Solusi Aproksimasi Asumsikan solusi \buildrel u\over u\sim\left(x\right) dalam bentuk fungsi bentuk (shape functions) N_i\left(x\right) dan nilai nodal U_i: u\left(x\right)\approx\buildrel u\over u\sim\left(x\right)=\sum_{i=1}^{n+1}N_i\left(x\right)U_i Langkah 4: Residual Tertimbang (Metode Galerkin) Definisikan residual R\left(x\right): R\left(x\right)=\frac{d}{dx}\left(k\frac{d\buildrel u\over u\sim}{dx}\right)+f Untuk metode Galerkin, kita ingin agar residual tertimbang sama dengan nol: \int_{0}^{L}N_jR\left(x\right)\thinsp dx=0 Langkah 5: Terapkan Integrasi oleh Bagian Integrasi oleh bagian untuk mengurangi urutan turunan: \int_{0}^{L}N_j\frac{d}{dx}\left(k\frac{d\buildrel u\over u\sim}{dx}\right)dx=-\int_{0}^{L}\frac{dN_j}{dx}k\frac{d\buildrel u\over u\sim}{dx}\thinsp dx+\left[N_jk\frac{d\buildrel u\over u\sim}{dx}\right]_0^L Asumsikan kondisi batas natural, sehingga suku batas menghilang. Maka kita punya: -\int_{0}^{L}\frac{dN_j}{dx}k\frac{d\buildrel u\over u\sim}{dx}\thinsp dx+\int_{0}^{L}N_jf\thinsp dx=0 Langkah 6: Substitusi Solusi Aproksimasi Substitusi \buildrel u\over u\sim\left(x\right): -\int_{0}^{L}\frac{dN_j}{dx}k\sum_{i=1}^{n+1}\frac{dN_i}{dx}U_i\thinsp dx+\int_{0}^{L}N_jf\thinsp dx=0 Reorganisasi untuk mendapatkan sistem persamaan: \sum_{i=1}^{n+1}\left(\int_{0}^{L}\frac{dN_j}{dx}k\frac{dN_i}{dx}\thinsp d x\right)U_i=\int_{0}^{L}N_jf\thinsp dx Langkah 7: Definisikan Matriks dan Vektor Definisikan matriks kekakuan K_{ji} dan vektor muatan F_j: K_{ji}=\int_{0}^{L}\frac{dN_j}{dx}k\frac{dN_i}{dx}\thinsp dx, Fj=0LNjf dx Maka persamaan akhir untuk setiap node j: \sum_{i=1}^{n+1}K_{ji}U_i=F_j Contoh Singkat Persamaan yang digunakan: \frac{d}{dx}\left(k\frac{du}{dx}\right)+f=0 Asumsikan: k=1 dan f=1 Bagi domain: Misalkan n=2 elemen di domain 0 hingga 1. Gunakan: Fungsi bentuk linear untuk setiap elemen. Hitung: Matriks kekakuan K dan vektor muatan F sesuai langkah-langkah di atas. Dengan pendekatan ini, kita mendapatkan sistem persamaan linear yang dapat diselesaikan untuk mencari nilai nodal U_i.













PERTANYAAN 6. (What does this mean (how to read/interprete: f = lambda x: 1.0 # Constant source term?) Penjelasan Kode f: Ini adalah nama dari fungsi yang didefinisikan. Anda dapat menggunakan nama ini di bagian lain dalam kode untuk merujuk pada fungsi ini. lambda: Kata kunci ini digunakan untuk membuat fungsi anonim (fungsi tanpa nama) di Python. Fungsi lambda sering digunakan untuk fungsi kecil yang hanya diperlukan satu kali. x: Ini adalah parameter yang diterima oleh fungsi sebagai input. Dalam kasus ini, x bisa mewakili variabel seperti posisi dalam ruang. 1.0: Ini adalah output dari fungsi. Karena fungsi didefinisikan sebagai lambda x: 1.0, ini berarti bahwa tidak peduli berapa nilai dari x, fungsi ini akan selalu mengembalikan 1.0. Interpretasi Pernyataan f = lambda x: 1.0 mendefinisikan fungsi sederhana f yang: Mengambil satu input, yaitu x. Selalu mengembalikan nilai tetap 1.0 untuk setiap input yang diberikan. Cara Menggunakan Anda dapat memanggil fungsi f dengan argumen apa pun, dan ia akan selalu mengembalikan 1.0. Contohnya: result = f (5) # Memanggil fungsi dengan x=5 print(result) # Ini akan mencetak 1.0 Penggunaan dalam Konteks Dalam konteks analisis elemen hingga (FEM) atau metode numerik lainnya, ini bisa merepresentasikan sumber term dalam persamaan diferensial. Misalnya, jika Anda sedang memodelkan persamaan panas di mana terdapat sumber panas yang konstan di seluruh domain, Anda akan menggunakan f = lambda x: 1.0 untuk menunjukkan bahwa intensitas sumber panas selalu 1.0 (konstan) tidak tergantung pada posisi x.

Retrieved from "http://air.eng.ui.ac.id/index.php?title=User:LuthfiShafwan&oldid=74126"