Difference between revisions of "Kelompok 16"

From ccitonlinewiki
Jump to: navigation, search
(→‎Sistem Pegas)
(→‎Optimasi drag force pada mobil)
 
(13 intermediate revisions by 2 users not shown)
Line 115: Line 115:
  
 
   print(F1)
 
   print(F1)
 +
 +
== Persamaan diferensial dengan Runge Kutta Method ==
 +
[[File:RangeKuttaKutaahe.mp4]]
 +
 +
x = float(input("Masukkan nilai t untuk displacement of mass yang ingin dicari: "))
 +
x0 = 0
 +
y = 0
 +
h = 0.01
 +
if 0 <= x < 2:
 +
    def jarak(x, y):
 +
        return (2 * x**2 - 30 * y * x)
 +
 +
    def runge_kutta(x0, y0, x, h):
 +
        n = (int)((x - x0) / h)
 +
        y = y0
 +
        for i in range(1, n + 1):
 +
            k1 = h * jarak(x0, y)
 +
            k2 = h * jarak(x0 + 0.5 * h, y + 0.5 * k1)
 +
            k3 = h * jarak(x0 + 0.5 * h, y + 0.5 * k2)
 +
            k4 = h * jarak(x0 + h, y + k3)
 +
 +
            y = y + (1.0 / 6.0) * (k1 + 2 * k2 + 2 * k3 + k4)
 +
 +
            x0 = x0 + h
 +
        return y
 +
    print("Displacement of mass pada t = ", x, "s  adalah", runge_kutta(x0, y, x, h), "meter"),
 +
elif x >= 2:
 +
    def jarak(x, y):
 +
        return (8 - 30 * y * x)
 +
 +
    def runge_kutta(x0, y0, x, h):
 +
        n = (int)((x - x0) / h)
 +
        y = y0
 +
        for i in range(1, n + 1):
 +
            k1 = h * jarak(x0, y)
 +
            k2 = h * jarak(x0 + 0.5 * h, y + 0.5 * k1)
 +
            k3 = h * jarak(x0 + 0.5 * h, y + 0.5 * k2)
 +
            k4 = h * jarak(x0 + h, y + k3)
 +
            y = y + (1.0 / 6.0) * (k1 + 2 * k2 + 2 * k3 + k4)
 +
            x0 = x0 + h
 +
        return y
 +
    print("Displacement of mass pada t = ", x, "s adalah", runge_kutta(x0, y, x, h), "meter"),
 +
 +
else:
 +
    print("t yang dimasukan negatif. Silakan masukkan t secara positif.")
 +
 +
Algoritma diatas merupakan algoritma untuk displacement mass spring system
 +
Untuk file pptnya dapat diakses dari link ini [https://drive.google.com/file/d/1OtuNQpOYE3AwXATGsc-I6j6ZEujO-Kkj/view?usp=sharing]
 +
 +
 +
== Optimasi drag force pada mobil ==
 +
 +
Simulasi ini dilakukan untuk mengetahui bahwa hubungan antara kecepatan angin terhadap drag force yang terjadi.
 +
 +
Langkah - langkah simulasi dilakukan dengan melakukan simulasi airdlow pada aplikasi CFDSOF-NG :
 +
 +
1. Meng-import 3d objek ke dalam aplikasi.
 +
 +
[[File:moil.PNG]]
 +
 +
2. Selanjutnya, kita melakukan simulasi dengan nilai yang sesuai dan variasi kecepatan angin dari 10 m/s sampai 70 m/s.
 +
 +
 +
[[File:simulasi_01.PNG]]
 +
 +
3. Selanjutnya, kita melakukan perhitungan pada aplikasi paraview sehingga mendapatkan nilai drag force.
 +
 +
 +
[[File:simulasi_02.PNG]]
 +
 +
4. Selanjutnya, kita meng-input data ke dalam excel dan meng-convert ke dalam bentuk grafik, sehingga kita mendapatkan persamaan
 +
 +
 +
[[File:D.PNG]]
 +
 +
 +
[[File:Graph_01.jpg]]
 +
 +
== Optimasi drag force dan lift force pada airfoil type NACA 2415 ==
 +
Simulasi drag force dan lift force yang dilakukan untuk mendapatkan sudut optimal bagi airfoil.
 +
Langkah - langkah dalam pengerjaan :
 +
 +
1. Melakukan 3d modelling pada software Inventor.
 +
 +
 +
[[File:Airfoil.jpg]]
 +
 +
2. Melakukan simulasi pada software CFDSOF-NG dan mendapatkan nilai drag force dan lift force di Paraview.
 +
[[File:Paraview.jpg]]
 +
 +
3.Mendapatkan nilai drag force dan lift force yang kemudian diolah excel dan mendapatkan grafik.
 +
 +
[[File:Tabel_force.jpg]]
 +
 +
[[File:Grafik_drag.jpg]]
 +
 +
[[File:Grafik_lift.jpg]]
 +
 +
4. Melakukan optimasi dengan bantuan python
 +
 +
 +
[[File:Optimasi_.JPG]]
 +
 +
[[File:Optimasi_a.JPG]]
 +
 +
[[File:Optimasi_b.JPG]]
 +
 +
[[File:Optimasi_c.JPG]]
 +
 +
Untuk algoritmanya sebagai berikut :
 +
#!/usr/bin/env python
 +
# coding: utf-8
 +
# In[11]:
 +
import numpy as np
 +
from scipy.optimize import minimize
 +
def calc_drag(x):#drag
 +
    x1 = x[0]
 +
    drag = 0.0047*x1**6-0.1804*x1**5+2.5411*x1**4-17.088*x1**3+66.126*x1**2-91.635*x1+29.369
 +
    return drag
 +
def calc_lift(x): #lift
 +
    x1 = x[0]
 +
    lift = -0.0016*x1**6+0.0597*x1**5-0.8644*x1**4+5.1299*x1**3-15.87*x1**2+78.924*x1+61.376
 +
    return lift
 +
def objective(x): #volume yang diminimalkan
 +
    return calc_drag(x)
 +
def constraint1(x): #variable SUDUT yang meminimalkan persamaan garis drag
 +
    return 90 - calc_drag(x)
 +
def constraint2(x): #variable SUDUT yang meminimalkan persamaan garis lift
 +
    return 90 - calc_lift(x)
 +
con1=({'type':'ineq','fun':constraint1})
 +
con2=({'type':'ineq','fun':constraint2})
 +
cons = (con1,con2)
 +
x1_guess = 40
 +
x0 = np.array([x1_guess])
 +
sol = minimize(objective,x0, method='SLSQP',constraints=cons, options={'disp':True})
 +
xopt = sol.x
 +
forceopt = -sol.fun
 +
dragopt = calc_drag(xopt) # drag optimal
 +
liftopt = calc_lift(xopt) # lift optimal
 +
print ('sudut optimal = '+str(-xopt[0]))
 +
print ('total force optimal = '+str(forceopt))
 +
print ('drag force optimal = '+str(-dragopt))
 +
print ('lift force optimal = '+str(liftopt))
 +
 +
# In[10]:
 +
import numpy as np
 +
from scipy.optimize import minimize
 +
def calc_drag(x):#drag
 +
    x1 = x[0]
 +
    drag = 0.0047*x1**6-0.1804*x1**5+2.5411*x1**4-17.088*x1**3+66.126*x1**2-91.635*x1+29.369
 +
    return drag
 +
def calc_lift(x): #lift
 +
    x1 = x[0]
 +
    lift = -0.0016*x1**6+0.0597*x1**5-0.8644*x1**4+5.1299*x1**3-15.87*x1**2+78.924*x1+61.376
 +
    return lift
 +
def objective(x): #volume yang diminimalkan
 +
    return calc_lift(x)
 +
def constraint1(x): #variable SUDUT yang meminimalkan persamaan garis drag
 +
    return 90 - calc_drag(x)
 +
def constraint2(x): #variable SUDUT yang meminimalkan persamaan garis lift
 +
    return 90 - calc_lift(x)
 +
con1=({'type':'ineq','fun':constraint1})
 +
con2=({'type':'ineq','fun':constraint2})
 +
cons = (con1,con2)
 +
x1_guess = 40
 +
x0 = np.array([x1_guess])
 +
sol = minimize(objective,x0, method='SLSQP',constraints=cons, options={'disp':True})
 +
xopt = sol.x
 +
forceopt = -sol.fun
 +
dragopt = calc_drag(xopt) # drag optimal
 +
liftopt = calc_lift(xopt) # lift optimal
 +
print ('sudut optimal = '+str(xopt[0]))
 +
print ('total force optimal = '+str(-forceopt))
 +
print ('drag force optimal = '+str(dragopt))
 +
print ('lift force optimal = '+str(liftopt))
 +
 +
# In[ ]:
 +
 +
Hasilnya adalah
 +
 +
[[File:Vvc.JPG]]

Latest revision as of 12:17, 11 December 2019

Anggota Kelompok 16 :

  1. Eric Delbert
  2. Gabriella E.
  3. Gidion M. H.
  4. Sumardi


Eliminasi Gauss

Eliminasi gauss merupakan sebuah metode penyelesaian aljabar dengan memanfaatkan mmatriks sebagai variabel dalam operasi.

Contoh matriks

Contoh matriks.JPG

Matriks diatas dapat kita selesaikan dengan menggunakan python dengan algoritma dibawah ini

Capture(15).JPG

Hasil dari run file seperti ini

Capture(16).JPG

Untuk rincian cara muncul algoritma seperti diatas, Anda dapat lihat pada file PDF yang telah kami buat [1]

Untuk lebih lengkap inilah video tutorialnya.


Sistem Pegas

Video Teori

Video Programming 

 import numpy as np
 from numpy import array, zeros

 #tentukan jumlah k
 N=eval(input('jumlah k pada sistem?'))

 node = N + 1

 k = np.zeros((node,node), float)

 # define array berisi konstanta pegas

 m_k = np.zeros(N)

 for i in range(0,N):
     print('K',i+1,'?')
     m_k[i]=eval(input())

 # membangun matriks global stiffness
 k[0,0] = m_k[0]
 k[N,N]= m_k[N-1]

 #pola 1
 a = 0
 for b in range (0,N):
     a += 1
     k[b,a]= -(m_k[b])

 #pola 2
 c = 0
 for d in range (0,N):
     c += 1
     k[c,d]=-(m_k[d])

 #pola 3
 e = 0
 for f in range (1,N):
     e +=1
     k[f,e]=m_k[f]+m_k[f-1]

 print (k)

 #gaya yang bekerja
 Fn = eval(input('jumlah force?'))

 #===============================================

 J = k[1:node,1:node]

 n=len(J)
 B=np.zeros(n,float)
 B[n-1]=Fn

 # eliminasi gauss

 for k in range (0,n-1):
     for i in range (k+1, n):
         if J[i,k]!=0 :
             z= J[i,k]/J[k,k]
             J[i,k:n]=J[i,k:n]-(J[k,k:n]*z)
             B[i]=B[i]-(B[k]*z)

 print(J)

 u=np.zeros(n,float)
 for m in range (n-1 , -1, -1):
     u[m]=(B[m]-np.dot(J[m,m+1:n], u[m+1:n]))/J[m,m]
     print('nilai U',m+2,u[m])

 F1=-m_k[0]*u[0]

 print(F1)

Persamaan diferensial dengan Runge Kutta Method

x = float(input("Masukkan nilai t untuk displacement of mass yang ingin dicari: "))
x0 = 0
y = 0
h = 0.01
if 0 <= x < 2:
   def jarak(x, y):
       return (2 * x**2 - 30 * y * x)

   def runge_kutta(x0, y0, x, h):
       n = (int)((x - x0) / h)
       y = y0
       for i in range(1, n + 1):
           k1 = h * jarak(x0, y)
           k2 = h * jarak(x0 + 0.5 * h, y + 0.5 * k1)
           k3 = h * jarak(x0 + 0.5 * h, y + 0.5 * k2)
           k4 = h * jarak(x0 + h, y + k3)

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

           x0 = x0 + h
       return y
   print("Displacement of mass pada t = ", x, "s  adalah", runge_kutta(x0, y, x, h), "meter"),
elif x >= 2:
   def jarak(x, y):
       return (8 - 30 * y * x)

   def runge_kutta(x0, y0, x, h):
       n = (int)((x - x0) / h)
       y = y0
       for i in range(1, n + 1):
           k1 = h * jarak(x0, y)
           k2 = h * jarak(x0 + 0.5 * h, y + 0.5 * k1)
           k3 = h * jarak(x0 + 0.5 * h, y + 0.5 * k2)
           k4 = h * jarak(x0 + h, y + k3)
           y = y + (1.0 / 6.0) * (k1 + 2 * k2 + 2 * k3 + k4)
           x0 = x0 + h
       return y
   print("Displacement of mass pada t = ", x, "s adalah", runge_kutta(x0, y, x, h), "meter"),

else:
   print("t yang dimasukan negatif. Silakan masukkan t secara positif.")

Algoritma diatas merupakan algoritma untuk displacement mass spring system Untuk file pptnya dapat diakses dari link ini [2]


Optimasi drag force pada mobil

Simulasi ini dilakukan untuk mengetahui bahwa hubungan antara kecepatan angin terhadap drag force yang terjadi.

Langkah - langkah simulasi dilakukan dengan melakukan simulasi airdlow pada aplikasi CFDSOF-NG :

1. Meng-import 3d objek ke dalam aplikasi.

Moil.PNG

2. Selanjutnya, kita melakukan simulasi dengan nilai yang sesuai dan variasi kecepatan angin dari 10 m/s sampai 70 m/s.


Simulasi 01.PNG

3. Selanjutnya, kita melakukan perhitungan pada aplikasi paraview sehingga mendapatkan nilai drag force.


Simulasi 02.PNG

4. Selanjutnya, kita meng-input data ke dalam excel dan meng-convert ke dalam bentuk grafik, sehingga kita mendapatkan persamaan


D.PNG


Graph 01.jpg

Optimasi drag force dan lift force pada airfoil type NACA 2415

Simulasi drag force dan lift force yang dilakukan untuk mendapatkan sudut optimal bagi airfoil. Langkah - langkah dalam pengerjaan :

1. Melakukan 3d modelling pada software Inventor.


Airfoil.jpg

2. Melakukan simulasi pada software CFDSOF-NG dan mendapatkan nilai drag force dan lift force di Paraview. Paraview.jpg

3.Mendapatkan nilai drag force dan lift force yang kemudian diolah excel dan mendapatkan grafik.

Tabel force.jpg

Grafik drag.jpg

Grafik lift.jpg

4. Melakukan optimasi dengan bantuan python


Optimasi .JPG

Optimasi a.JPG

Optimasi b.JPG

Optimasi c.JPG

Untuk algoritmanya sebagai berikut : 

#!/usr/bin/env python
# coding: utf-8
# In[11]:
import numpy as np
from scipy.optimize import minimize
def calc_drag(x):#drag
   x1 = x[0]
   drag = 0.0047*x1**6-0.1804*x1**5+2.5411*x1**4-17.088*x1**3+66.126*x1**2-91.635*x1+29.369
   return drag
def calc_lift(x): #lift
   x1 = x[0]
   lift = -0.0016*x1**6+0.0597*x1**5-0.8644*x1**4+5.1299*x1**3-15.87*x1**2+78.924*x1+61.376
   return lift
def objective(x): #volume yang diminimalkan
   return calc_drag(x)
def constraint1(x): #variable SUDUT yang meminimalkan persamaan garis drag
   return 90 - calc_drag(x)
def constraint2(x): #variable SUDUT yang meminimalkan persamaan garis lift
   return 90 - calc_lift(x)
con1=({'type':'ineq','fun':constraint1})
con2=({'type':'ineq','fun':constraint2})
cons = (con1,con2)
x1_guess = 40
x0 = np.array([x1_guess])
sol = minimize(objective,x0, method='SLSQP',constraints=cons, options={'disp':True})
xopt = sol.x
forceopt = -sol.fun
dragopt = calc_drag(xopt) # drag optimal
liftopt = calc_lift(xopt) # lift optimal
print ('sudut optimal = '+str(-xopt[0]))
print ('total force optimal = '+str(forceopt))
print ('drag force optimal = '+str(-dragopt))
print ('lift force optimal = '+str(liftopt))

# In[10]:
import numpy as np
from scipy.optimize import minimize
def calc_drag(x):#drag
   x1 = x[0]
   drag = 0.0047*x1**6-0.1804*x1**5+2.5411*x1**4-17.088*x1**3+66.126*x1**2-91.635*x1+29.369
   return drag
def calc_lift(x): #lift
   x1 = x[0]
   lift = -0.0016*x1**6+0.0597*x1**5-0.8644*x1**4+5.1299*x1**3-15.87*x1**2+78.924*x1+61.376
   return lift
def objective(x): #volume yang diminimalkan
   return calc_lift(x)
def constraint1(x): #variable SUDUT yang meminimalkan persamaan garis drag
   return 90 - calc_drag(x)
def constraint2(x): #variable SUDUT yang meminimalkan persamaan garis lift
   return 90 - calc_lift(x)
con1=({'type':'ineq','fun':constraint1})
con2=({'type':'ineq','fun':constraint2})
cons = (con1,con2)
x1_guess = 40
x0 = np.array([x1_guess])
sol = minimize(objective,x0, method='SLSQP',constraints=cons, options={'disp':True})
xopt = sol.x
forceopt = -sol.fun
dragopt = calc_drag(xopt) # drag optimal
liftopt = calc_lift(xopt) # lift optimal
print ('sudut optimal = '+str(xopt[0]))
print ('total force optimal = '+str(-forceopt))
print ('drag force optimal = '+str(dragopt))
print ('lift force optimal = '+str(liftopt))

# In[ ]:

Hasilnya adalah

Vvc.JPG

Retrieved from "http://air.eng.ui.ac.id/index.php?title=Kelompok_16&oldid=17427"