Kelompok 12

Perkenalkan, kami kelompok 12 dengan anggota kelompok sebagai berikut:

1. Elvin

2. Khairun Naziri Batubara

3. Adam Ilham Maulana

Tugas Metode Eliminasi Gauss

Video diatas merupakan penjelasan program eliminasi Gauss yang dibuat pada python. Rangkaian kode dari video diatas ditampilkan sebagai berikut:

Tugas Finite Element Analysis dengan Eliminasi Gauss

Dengan kode yang telah dibuat untuk menyelesaikan masalah pada sistem persamaan linear, kode tersebut juga dapat diaplikasikan pada simulasi Finite Element Analysis Contoh Soal

Seperti pada gambar diatas, suatu struktur diberikan gaya P keatas pada jarak 1 m dari lantai dan gaya F kebawah pada ujung struktur, hitunglah nodal displacement yang terjadi.

Penyelesaian

• untuk menyelesaikan masalah ini, kita dapat membagikan struktur tersebut menjadi 3 element dengan tinggi 1 meter dengan luas penampang rata-rata berturut-turut dari lantai 950 m2, 850 m2, dan 750 m2
• dengan rumus stiffness k = A*E/L kita dapat menghitung k1, k2, k3 berturut-turut 9500 N/m, 8500 N/m, dan 7500 N/m
• kemudian kita masukkan nilai-nilai stiffness k dan gaya F dan P beserta constraint yang ada ke matriks untuk penyelesaian

Penyelesaian yang didapatkan akan seperti berikut

dan didapatkan nodal displacement secara berturut-turut 0,00526 , 0,0170 , dan 0,030 kearah bawah

berikut adalah video penjelasan untuk tugas ini

Tugas metode Runge Kutta pada pegas

1. Persoalan dan analisis fisika

terdapat sebuah sistem pegas dan massa yang menempel pada dinding. Pegas tersebut memiliki konstanta sebesar 75 N/m dan Benda bermassa 2,5 kg. Gaya P yang diberikan pada sistem menjauhi dinding dengan besaran 10t apabila terjadi saat t<2s dan 20N apabila terjadi saat t>=2s. Terdapat juga persamaan untuk percepatan sistem yaitu y"= (P(t)/m)-((k/m)y). Disini kita harus mencari perpindahan maksimum sistem, dan diplotkan pada grafik perubahan posisi sistem terhadap waktu dimana sistem awal berada pada keadaan diam (v=0)

Analisis Fisika pada keadaan tersebut berlaku Hukum Newton ke-2 yaitu F=a.m, dimana a=percepatan benda dan m = massa benda. Selain itu berlaku juga hukum tentang gaya pegas, f=k.y, dimana k = konstanta pegas dan y = perubahan panjang pegas. Kedua gaya ini dapat memengaruhi perpindahan benda. Dikarenakan adany gaya tarik P dan gaya reaksi oleh pegas yang berlawanan dengan gaya tarik P atau dapat dirumuskan. Gaya total = gaya yang diberikan pada sistem - gaya reaksi pegas. m.y"=P(t)-ky dan apabila kedua ruas dibagi dengan massa maka persamaan akan menjadi y"=P(t)/m-(k/m)y

2. algoritma penyelesaian

terdapat pegas dengan konstanta 75 N/m. yang dihubungkan dengan benda bermassa 2,5 kg kemudian benda itu ditarik dengan gaya P(t). jika gaya ditarik kurang dari 2 detik maka gaya yang berlaku adalah 10t N. dan jika gaya ditarik lebih dari sama dengan 2 detik maka yang gaya yang berlaku 20 N. dengan gaya-gaya itu akan menghasilkan regangan. dan regangan terjauh dapat diselesaikan dengan metode runge kutta brdasarkan persamaan y"= (p(t)/m)-(k.y/m).

kode untuk menyelesaikan metode runge kutta

1. Di sini, kita akan menggunakan x0 dan y sebagai titik asal, x sebagai t yang diinginkan, dan h sebagai increment. Kita menggunakan h = 0.01.

x0 = 0 list =[]

y = 0 h = 0.01 x = float(input("Masukkan nilai t: ")) if 0 <= x < 2:

 # dydx menyatakan persamaan awal dalam soal.
 # Didapat hasil 4x - 30y karena dipakai massa m = 2,5 kg dan konstanta pegas k = 75 N/m.
 # P(t) dinyatakan dalam x. 
 def dydx(x, y): 
   return (4*x - 30*y) 
 # Ini merupakan implementasi perhitungan Runge-Kutta.
 def rungeKutta(x0, y0, x, h): 
   n = (int)((x - x0)/h)  
   y = y0 
   for i in range(1, n + 1): 
      k1 = h * dydx(x0, y) 
      k2 = h * dydx(x0 + 0.5 * h, y + 0.5 * k1) 
      k3 = h * dydx(x0 + 0.5 * h, y + 0.5 * k2) 
      k4 = h * dydx(x0 + h, y + k3) 

      # untuk y selanjutnya 
      y = y + (1.0 / 6.0)*(k1 + 2 * k2 + 2 * k3 + k4) 

      # untuk x selanjutnya
      x0 = x0 + h 
      list.append(y)
   return y 
 print("Nilai y pada t =", x, "adalah", rungeKutta(x0, y, x, h))

elif x >= 2:

 # Ketika x >= 2, maka variabel x sudah tidak lagi memengaruhi persamaan.
 def dydx(x, y): 
   return (8 - 30*y) 
 def rungeKutta(x0, y0, x, h): 
   n = (int)((x - x0)/h)  
   y = y0 
   for i in range(1, n + 1): 
      k1 = h * dydx(x0, y) 
      k2 = h * dydx(x0 + 0.5 * h, y + 0.5 * k1) 
      k3 = h * dydx(x0 + 0.5 * h, y + 0.5 * k2) 
      k4 = h * dydx(x0 + h, y + k3) 
      y = y + (1.0 / 6.0)*(k1 + 2 * k2 + 2 * k3 + k4)
      x0 = x0 + h 
      list.append(y)
   return y 
 print("Nilai y pada t =", x, "adalah", rungeKutta(x0, y, x, h))

else:

 print("Mohon masukkan nilai t positif.")

print(list) print("nilai maksimal adalah ", max(list))

sehingga apabila memasukkan t=1 akan didapat

dan apabila memasukkan t=2 maka akan didapat

Tugas Airfoil

Untuk tugas ini, kami menggunakan referensi airfoil NACA-0009 9.0% smoothed untuk mendapatkan nilai drag force dan lift force pada kecepatan 30 m/s

Variabel pada tugas ini adalah angle airfoil dari -15° hingga 90°

dengan bantuan aplikasi CFDSOF dan Paraview

didapatkan nilai-nilai sebagai berikut

Grafik Drag

Grafik Lift

Hasil Optimasi

import numpy as np
from scipy.optimize import minimize

def drag(x):#drag
    x = x[0]
    d = 0.0001*x**4 -0.0049*x**3 + 0.1194*x**2 - 1.38*x - 6.927
    return d

def lift(x): #lift
    x = x[0]
    l =  -0.00006*x**4 + 0.0066*x**3 - 0.0652*x**2 + 1.7418*x + 24.193
    return l

def obj(x): #sudut yang diminimalkan
    return drag(x)

def c1(x): #variable SUDUT yang meminimalkan persamaan garis drag
    return drag(x)
def c2(x): #variable SUDUT yang meminimalkan persamaan garis lift
    return lift(x)


con1=({'type':'ineq','fun':c1})
con2=({'type':'ineq','fun':c2})
cons = (con1,con2)

a = (10,90)
batas = [a]

x1_guess = 20

x0 = np.array([x1_guess])

sol = minimize(obj,x0, method='SLSQP', bounds=batas, constraints=cons, options={'disp':True})

xopt = sol.x
fopt = -sol.fun

dopt = drag(xopt) # drag optimal
lopt = lift(xopt) # lift optimal

print ('sudut optimal = '+str(xopt[0]), "\n", 'total force optimal = '+str(fopt), "\n", 'drag force optimal = '+str(-dopt), "\n", 'lift force optimal = '+str(lopt))

Aplikasi ANN pada Data CFD

Koding ANN (Dengan Google Colab)

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Flatten, Dense
import numpy as np
import pandas as pd
print(tf.__version__)

from google.colab import files
uploaded = files.upload()

import io
database = pd.read_excel(io.BytesIO(uploaded['ANN ELVIN.xlsx']))

x = database['angle of attack']
#y1 = dataset['Fdrag']
#y2 = dataset['Flift']
y = database['drag/lift']

import matplotlib.pyplot as plt
plt.plot(x,y)

norm_x = [(a-np.min(x))/(np.max(x)-np.min(x))  
                             for a in x]
norm_y = [(a-np.min(y))/(np.max(y)-np.min(y))  
                             for a in y]

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(norm_x, norm_y, test_size = 0.3, random_state = 
0)

x_train = np.asarray(x_train)
x_test = np.asarray (x_test)
y_train = np.asarray (y_train)
y_test = np.asarray (y_test)


import matplotlib.pyplot as plt
unnorm_y_awal=  [a*(np.max(y)-np.min(y))+np.min(y)  
                              for a in y_test]
plt.suptitle('Output Real')
plt.plot(unnorm_y_awal)

model = Sequential()
model.add(Dense(3, activation='relu', input_dim = 1)) # input layer
model.add(Dense(4, activation='relu')) # hidden layer
model.add(Dense(1, activation = 'sigmoid'))

model.compile(optimizer='adam', loss = 'binary_crossentropy', metrics=['accuracy'])

history = model.fit(x_train, y_train, batch_size = 64, epochs = 5, verbose = 1, validation_split = 0.16)

Train on 3 samples, validate on 1 samples
Epoch 1/5
3/3 [==============================] - 0s 34ms/sample - loss: 0.7800 - acc: 0.0000e+00 - val_loss: 0.8347 - val_acc: 0.0000e+00
Epoch 2/5
3/3 [==============================] - 0s 2ms/sample - loss: 0.7782 - acc: 0.0000e+00 - val_loss: 0.8323 - val_acc: 0.0000e+00
Epoch 3/5
3/3 [==============================] - 0s 1ms/sample - loss: 0.7765 - acc: 0.0000e+00 - val_loss: 0.8299 - val_acc: 0.0000e+00
Epoch 4/5
3/3 [==============================] - 0s 1ms/sample - loss: 0.7748 - acc: 0.0000e+00 - val_loss: 0.8275 - val_acc: 0.0000e+00
Epoch 5/5
3/3 [==============================] - 0s 2ms/sample - loss: 0.7731 - acc: 0.0000e+00 - val_loss: 0.8252 - val_acc: 0.0000e+00

unnorm_x=  [a*(np.max(x)-np.min(x))+np.min(x)  
                             for a in x_test]
unnorm_y=  [a*(np.max(y)-np.min(y))+np.min(y)  
                             for a in y_test]

plt.suptitle('Output Real vs Output Prediction ANN')
plt.subplot(2, 1, 1)
plt.plot(unnorm_y_awal)
plt.subplot(2, 1, 2)
plt.plot(unnorm_y)

Hasil

Dapat dilihat bahwa output real dengan output prediction ANN sama persis