|
|
| Line 2: |
Line 2: |
| | [[File:Ryanson.jpg|thumb|Ryanson di tahun 2019.]] | | [[File:Ryanson.jpg|thumb|Ryanson di tahun 2019.]] |
| | | | |
| − | '''Ryanson Jonathan''' (lahir di Jakarta, 5 Mei 2000, umur 19) merupakan seorang mahasiswa [http://eng.ui.ac.id Fakultas Teknik Universitas Indonesia], mengambil jurusan Teknik Mesin. Selain itu, Ryanson juga menjalani kanal [http://www.youtube.com/ryansonjonathan YouTube], dan akan mengeluarkan musik dengan nama Pinterbanget. | + | '''Ryanson Jonathan''' (lahir di Jakarta, 5 Mei 2000, umur 22) merupakan seorang mahasiswa [http://eng.ui.ac.id Fakultas Teknik Universitas Indonesia], dengan jurusan Teknik Mesin. |
| − | | |
| − | | |
| − | ==Metode Numerik==
| |
| − | ===Mengapa mahasiswa Teknik Mesin harus mempelajari Kalkulus===
| |
| − | Menurut Ryanson, mahasiswa Teknik Mesin harus belajar Kalkulus karena pada dasarnya Kalkulus adalah hal yang paling mendasar yang diperlukan untuk mempelajari hal-hal yang lebih mendalam. Ilmu-ilmu dan konsep yang dipelajari pada Kalkulus pada nantinya akan dipakai di mata kuliah lain, seperti Termodinamika Dasar dan Matematika Teknik.
| |
| − | | |
| − | ===Mengenal Python===
| |
| − | Python adalah sebuah bahasa ''coding'' atau bahasa pemrograman yang digunakan untuk menyelesaikan suatu masalah.
| |
| − | | |
| − | ===Flowchart===
| |
| − | Terdapat sebuah formula:
| |
| − | T=(x^2-1)/(x-1)
| |
| − | Formula ini dapat diselesaikan menggunakan flowchart, dengan metode sbb:
| |
| − | | |
| − | [[File:letitflowwrj.jpg|frameless|upright=1.5]]
| |
| − | | |
| − | ===Memindahkan flowchart kedalam Python===
| |
| − | Kemudian, flowchart dapat direpresentasikan dalam kode Python sebagai berikut:
| |
| − | | |
| − | [[File:ryansonj_tugas1.png]]
| |
| − | | |
| − | ===Tuples dan Lists===
| |
| − | | |
| − | Pada pertemuan kedua, dibahas mengenai dasar-dasar Python, yang beberapa sudah saya singgung di kode yang sudah digunakan di atas.
| |
| − | Salah satu hal yang dapat dilakukan dalam Python adalah pembentukan Tuples dan Lists, yang mana Tuples berarti data yang terdapat lebih dari 1 dan Lists berarti data dalam bentuk daftar yang nantinya dapat ditambahkan.
| |
| − | | |
| − | tupel = ("Ryanson", "Jonathan", (5,5,2000))
| |
| − | firstname,lastname,date = tupel
| |
| − | print("Halo! Nama saya ", firstname, lastname, ". Saya biasa dipanggil ", firstname, ". Saya lahir tanggal", date[0], ", bulan", date[1], ", tahun ", date[2], ".")
| |
| − | | |
| − | Hasil dari kode diatas: "Halo! Nama saya Ryanson Jonathan. Saya biasa dipanggil Ryanson. Saya lahir tanggal 5, bulan 5, tahun 2000."
| |
| − | | |
| − | daftar = []
| |
| − | daftar.append("Telur")
| |
| − | daftar.append("Tepung")
| |
| − | daftar.append("Susu")
| |
| − | print("Daftar belanja untuk bulan ini: ", daftar)
| |
| − | | |
| − | Hasil dari kode diatas: "Daftar belanja untuk bulan ini: ['Telur', 'Tepung', 'Susu']"
| |
| − | | |
| − | ===Deret Fibonacci===
| |
| − | | |
| − | Pada minggu ketiga, diberikan soal untuk membuat program untuk menyelesaikan deret Fibonacci, sehingga user dapat memasukkan suatu angka (n) dan dapat mengetahui suku ke-n dalam deret Fibonacci.
| |
| − | | |
| − | Dalam menyelesaikan masalah ini, dapat ditentukan 2 pendekatan:
| |
| − | | |
| − | '''1. Loop'''
| |
| − | | |
| − | Metode loop digunakan memakai fungsi def, if, else:
| |
| − | | |
| − | [[File:ryansonfiboloop.png|300px]]
| |
| − | | |
| − | '''2. Function'''
| |
| − | | |
| − | Metode function digunakan memakai rumus yang sudah ada untuk langsung mencari deret Fibonacci:
| |
| − | | |
| − | [[File:ryansonfibofunc.png|300px]]
| |
| − | | |
| − | <youtube width="200" height="100">Ysrz1P3X-_s</youtube>
| |
| − | | |
| − | Pengerjaan dilakukan menggunakan algoritma Gauss seperti yang ada di buku Phyton. Namun, yang membedakan adalah tidak menggunakan ''module'' pada pengerjaan ini. Berikut adalah algoritma yang sudah dirancang berdasarkan soal pada buku Phyton :
| |
| − | | |
| − | Algoritma yang kami gunakan adalah sebagai berikut:
| |
| − | | |
| − | a = [[2,-3,-1], \
| |
| − | [3,2,5], \
| |
| − | [2,4,4]]
| |
| − | b = [[3], \
| |
| − | [-9], \
| |
| − | [-5]]
| |
| − | n = len(b)
| |
| − | for k in range(0, n-1):
| |
| − | for i in range(n-1, k, -1):
| |
| − | if a[i][k] != 0.0:
| |
| − | op= a[i][k]/a[i-1][k]
| |
| − | b[i][0]=b[i][0]-op*b[i-1][0]
| |
| − | for f in range(0,n):
| |
| − | a[i][f]=a[i][f]-op*a[i-1][f]
| |
| − | Hasil=['Hasilnya']
| |
| − | if a[2][2] !=0:
| |
| − | z=b[2][0]/a[2][2]
| |
| − | else:
| |
| − | z=0
| |
| − | if a[0][0] !=0:
| |
| − | y=(b[1][0]-z*a[1][2])/a[1][1]
| |
| − | else:
| |
| − | y=0
| |
| − | if a[0][0] !=0:
| |
| − | x=(b[0][0]-z*a[0][2]-y*a[0][1])/a[0][0]
| |
| − | else:
| |
| − | x=0
| |
| − | hasil=(x,y,z)
| |
| − | print(a)
| |
| − | | |
| − | | |
| − | [[File:Gauss_test_kelompok2.jpg|800px]]
| |
| − | | |
| − | ===Runge-Kutta Method===
| |
| − | <youtube width="200" height="100">QfEgmJaGOAE</youtube>
| |
| − | <youtube width="200" height="100">BMm8E_PxccE</youtube>
| |
| − | | |
| − | | |
| − | Pengerjaan dilakukan dan kode dirancang untuk mengikuti contoh soal.
| |
| − | | |
| − | # 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
| |
| − | y = 0
| |
| − | h = 0.01
| |
| − | x = float(input("Masukkan nilai t: "))
| |
| − | if 0 <= x < 2:
| |
| − | # dydx menyatakan persamaan awal dalam soal. Persamaan harus diintegralkan sekali untuk menghasilkan persamaan kecepatan.
| |
| − | # Didapat hasil 2x^2 - 30xy karena dipakai massa m = 2,5 kg dan konstanta pegas k = 75 N/m.
| |
| − | # P(t) dinyatakan dalam x.
| |
| − | def dydx(x, y):
| |
| − | return (2*x**2 - 30*x*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
| |
| − | return y
| |
| − | print("Nilai y pada t =", x, "adalah", rungeKutta(x0, y, x, h))
| |
| − | elif x >= 2:
| |
| − | # Ketika x >= 2, perhitungan harus diganti karena P(t) sudah konstan di angka 20 N.
| |
| − | def dydx(x, y):
| |
| − | return (8 - 30*x*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
| |
| − | return y
| |
| − | print("Nilai y pada t =", x, "adalah", rungeKutta(x0, y, x, h))
| |
| − | else:
| |
| − | print("Mohon masukkan nilai t positif.")
| |
| − | | |
| − | [[File:Flowdiagram_RungeKutta_Kelompok2.jpg]]
| |
| − | | |
| − | ===KUIS===
| |
| − | | |
| − | '''Problem 2.1 no 6'''
| |
| − | # Untuk memasukkan modul numpy ke dalam program.
| |
| − | from numpy import linalg
| |
| − | import numpy as np
| |
| − | # Matriks a dipecah menjadi 5 baris, dengan baris pertama dinotasikan sebagai a1, baris kedua a2, dst.
| |
| − | # matA sebagai notasi matriks a.
| |
| − | a1 = [0,0,2,1,2]
| |
| − | a2 = [0,1,0,2,-1]
| |
| − | a3 = [1,2,0,-2,1]
| |
| − | a4 = [0,0,0,-1,1]
| |
| − | a5 = [0,1,-1,1,-1]
| |
| − | matA = np.array ([a1,a2,a3,a4,a5])
| |
| − | # Masukkan entri pada matriks b. matB sebagai notasi matriks b.
| |
| − | matB = np.array ([1,1,-4,-2,-1])
| |
| − | # Lakukan perhitungan menggunakan modul Numpy.
| |
| − | hasil = linalg.solve (matA,matB)
| |
| − | x1 = int(hasil[0])
| |
| − | x2 = int(hasil[1])
| |
| − | x3 = int(hasil[2])
| |
| − | x4 = int(hasil[3])
| |
| − | x5 = int(hasil[4])
| |
| − | # Memperlihatkan hasil perhitungan kepada user.
| |
| − | print ("Hasil perhitungan:")
| |
| − | print ("x1=",x1,"x2=",x2,"x3=",x3,"x4=",x4,"dan x5=",x5)
| |
| − | # Kode ini dibuat oleh Ryanson Jonathan (1806149293), menggunakan bantuan modul Numpy.
| |
| − | | |
| − | '''Problem 7.1 no 2'''
| |
| − | # Line dibawah ini menunjukkan x0 dan y0 sebagai titik asal, h sebagai increment.
| |
| − | # Digunakan h = 0.005.
| |
| − | # x = 0.03, sesuai dengan yang diminta soal.
| |
| − | x0 = 0
| |
| − | y0 = 1
| |
| − | h = 0.005
| |
| − | x = 0.03
| |
| − | # "fungsi" menyatakan fungsi awal dalam soal, yang telah diubah sehingga membentuk persamaan y'.
| |
| − | # Mengubah bentuk persamaan dalam soal, y' = x^2-4y.
| |
| − | def fungsi(x, y):
| |
| − | return (x**2 - 4*y)
| |
| − | # Ini merupakan implementasi perhitungan Runge-Kutta, dinotasikan dengan "RK".
| |
| − | def RK(x0, y0, x, h):
| |
| − | n = (int)((x - x0)/h)
| |
| − | y = y0
| |
| − | for i in range(1, n + 1):
| |
| − | k1 = h * fungsi(x0, y)
| |
| − | k2 = h * fungsi(x0 + 0.5 * h, y + 0.5 * k1)
| |
| − | k3 = h * fungsi(x0 + 0.5 * h, y + 0.5 * k2)
| |
| − | k4 = h * fungsi(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
| |
| − | return y
| |
| − | #Memperlihatkan hasil perhitungan kepada user.
| |
| − | print("Nilai y(", x, ") adalah", RK(x0, y0, x, h))
| |
| − | #Kode ini dibuat oleh Ryanson Jonathan (1806149293).
| |
| − | | |
| − | ===UTS===
| |
| − | | |
| − | '''Kasus A'''
| |
| − | # -*- coding: utf-8 -*-
| |
| − | """
| |
| − | Created on Wed Oct 23 17:06:11 2019
| |
| − |
| |
| − | @author: rjsec
| |
| − | """
| |
| − | # Soal UTS no 1A.
| |
| − | # Masukkan modul Numpy ke dalam program.
| |
| − | from numpy import linalg
| |
| − | import numpy as np
| |
| − | # Buat persamaan menjadi suatu matriks, yang kemudian diinvers untuk mencari nilai
| |
| − | # T1, T2, dan T3.
| |
| − | # Mb1 sebagai matriks baris pertama, Mb2 sebagai matriks baris kedua, dan
| |
| − | # Mb3 sebagai matriks baris ketiga.
| |
| − | Mb1 = [1,0,0]
| |
| − | Mb2 = [-1,1,0]
| |
| − | Mb3 = [0,-1,1]
| |
| − | matA = np.array ([Mb1,Mb2,Mb3])
| |
| − | # Masukkan nilai-nilai M1, M2, dan M3.
| |
| − | M1 = float(input("Masukkan nilai M1 (dalam kg): "))
| |
| − | M2 = float(input("Masukkan nilai M2 (dalam kg): "))
| |
| − | M3 = float(input("Masukkan nilai M3 (dalam kg): "))
| |
| − | matB = np.array ([M1,M2,M3])
| |
| − | # Lakukan perhitungan menggunakan modul Numpy.
| |
| − | hasil = linalg.solve (matA,matB)
| |
| − | T1 = int(hasil[0])
| |
| − | T2 = int(hasil[1])
| |
| − | T3 = int(hasil[2])
| |
| − | # Perlihatkan hasil perhitungan kepada pengguna.
| |
| − | print ("Hasil perhitungan tegangan tali:")
| |
| − | print ("T1 =",T1,"N, T2 =",T2,"N, dan T3 =", T3, "N.")
| |
| − | # Kode ini dibuat oleh Ryanson Jonathan (1806149293).
| |
| − | # 23 Oktober 2019.
| |
| − | | |
| − | '''Kasus B'''
| |
| − | # -*- coding: utf-8 -*-
| |
| − | """
| |
| − | Created on Wed Oct 23 17:27:42 2019
| |
| − |
| |
| − | @author: rjsec
| |
| − | """
| |
| − | # Soal UTS no 1B.
| |
| − | v = float(input("Masukkan top speed (dalam m/s): "))
| |
| − | t0 = 0
| |
| − | h = 0.01
| |
| − | v0 = 0
| |
| − | def func(v, t):
| |
| − | return (1200*v/12000+0.3*v**1.5)
| |
| − | def rungee(v0, t0, v, h):
| |
| − | n = (int)((v - v0)/h)
| |
| − | t = t0
| |
| − | for i in range(1, n + 1):
| |
| − | k1 = h * func(v0, t)
| |
| − | k2 = h * func(v0 + 0.5 * h, t + 0.5 * k1)
| |
| − | k3 = h * func(v0 + 0.5 * h, t + 0.5 * k2)
| |
| − | k4 = h * func(v0 + h, t + k3)
| |
| − | t = t + (1/6)*(k1 + 2 * k2 + 2 * k3 + k4)
| |
| − | v0 = v0 + h
| |
| − | return t
| |
| − | print("Waktu untuk mencapai top speed adalah", rungee(v0, t0, v, h), "detik.")
| |
| − | | |
| − | ===Revisi UTS===
| |
| − | | |
| − | <youtube width="200" height="100">Vy-CfSB6PUM</youtube>
| |
| − | | |
| − | | |
| − | '''Kasus A'''
| |
| − | # -*- coding: utf-8 -*-
| |
| − | """
| |
| − | Created on Wed Oct 23 17:06:11 2019
| |
| − |
| |
| − | @author: rjsec
| |
| − | """
| |
| − | # Soal UTS no 1A.
| |
| − | # Masukkan modul Numpy ke dalam program.
| |
| − | from numpy import linalg
| |
| − | import numpy as np
| |
| − | # Asumsi yang dibuat: gravitasi (g) = 10 m/s^2, sudut kemiringan (α) = 5.74°,
| |
| − | # sehingga sin(α) = 1/10.
| |
| − | # Buat persamaan menjadi suatu matriks, yang kemudian diinvers untuk mencari nilai
| |
| − | # T1, T2, dan T3.
| |
| − | # Mb1 sebagai matriks baris pertama, Mb2 sebagai matriks baris kedua, dan
| |
| − | # Mb3 sebagai matriks baris ketiga.
| |
| − | Mb1 = [1,0,0]
| |
| − | Mb2 = [-1,1,0]
| |
| − | Mb3 = [0,-1,1]
| |
| − | matA = np.array ([Mb1,Mb2,Mb3])
| |
| − | # Masukkan nilai-nilai M1, M2, dan M3.
| |
| − | M1 = float(input("Masukkan nilai M1 (dalam kg): "))
| |
| − | M2 = float(input("Masukkan nilai M2 (dalam kg): "))
| |
| − | M3 = float(input("Masukkan nilai M3 (dalam kg): "))
| |
| − | matB = np.array ([M1,M2,M3])
| |
| − | # Lakukan perhitungan menggunakan modul Numpy.
| |
| − | hasil = linalg.solve (matA,matB)
| |
| − | T1 = int(hasil[0])
| |
| − | T2 = int(hasil[1])
| |
| − | T3 = int(hasil[2])
| |
| − | # Perlihatkan hasil perhitungan kepada pengguna.
| |
| − | print ("Hasil perhitungan tegangan tali:")
| |
| − | print ("T1 =",T1,"N, T2 =",T2,"N, dan T3 =", T3, "N.")
| |
| − | # Kode ini dibuat oleh Ryanson Jonathan (1806149293).
| |
| − | # 23 Oktober 2019, disempurnakan 28 Oktober 2019.
| |
| − | | |
| − | '''Kasus B'''
| |
| − | # -*- coding: utf-8 -*-
| |
| − | """
| |
| − | Created on Wed Oct 23 17:27:42 2019
| |
| − |
| |
| − | @author: rjsec
| |
| − | """
| |
| − | # Soal UTS no 1B.
| |
| − | # vKMH sebagai kecepatan akhir (top speed, dinyatakan dalam km/h).
| |
| − | # v sebagai kecepatan akhir (top speed, dinyatakan dalam m/s).
| |
| − | # t0 dan v0 sebagai kecepatan dan waktu awal (pada kasus ini 0).
| |
| − | # h sebagai increment/side step. Digunakan h = 0.01.
| |
| − | vKMH = float(input("Masukkan top speed (dalam km/h): "))
| |
| − | v=vKMH/3.6
| |
| − | t0 = 0
| |
| − | v0 = 0
| |
| − | h = 0.01
| |
| − | # "func" sebagai fungsi persamaan t dalam v,
| |
| − | # dengan v sebagai x dan t sebagai y.
| |
| − | # a sebagai persamaan akselerasi.
| |
| − | # Asumsi yang dibuat: massa mobil (m) = 1200 kg,
| |
| − | # percepatan mobil (a) = 10 m/s^2, gravitasi (g) = 10 m/s^2,
| |
| − | # koef gesek ban (Ч) = 0,5, dan koef gesek udara = 0,3.
| |
| − | a = 6000-0.3*v**1.5
| |
| − | def func(v, t):
| |
| − | return (1200*v/a - t)
| |
| − | # "rungekutta" sebagai fungsi untuk menghasilkan pendekatan
| |
| − | # menggunakan 4th order Runge-Kutta.
| |
| − | def rungekutta(v0, t0, v, h):
| |
| − | n = (int)((v - v0)/h)
| |
| − | t = t0
| |
| − | for i in range(1, n + 1):
| |
| − | k1 = h * func(v0, t)
| |
| − | k2 = h * func(v0 + 0.5 * h, t + 0.5 * k1)
| |
| − | k3 = h * func(v0 + 0.5 * h, t + 0.5 * k2)
| |
| − | k4 = h * func(v0 + h, t + k3)
| |
| − |
| |
| − | #untuk t baru
| |
| − | t = t + (1/6)*(k1 + 2 * k2 + 2 * k3 + k4)
| |
| − |
| |
| − | #untuk v baru
| |
| − | v0 = v0 + h
| |
| − | return t
| |
| − | # Menunjukkan hasil perhitungan kepada pengguna.
| |
| − | print("Waktu yang diperlukan untuk mencapai top speed adalah", rungekutta(v0, t0, v, h), "detik.")
| |
| − | # Kode ini dibuat oleh Ryanson Jonathan (1806149293).
| |
| − | # 23 Oktober 2019, disempurnakan 28 Oktober 2019.
| |
| − | | |
| − | ===Kolom Komentar UTS===
| |
| − | <comments />
| |
| − | | |
| − | '''Kasus Sendiri'''
| |
| − | | |
| − | Deskripsi kasus: orang yang akan melakukan free-fall dari sebuah ketinggian, dicari kecepatan setelah t detik.
| |
| − | # -*- coding: utf-8 -*-
| |
| − | """
| |
| − | Created on Wed Oct 30 17:22:21 2019
| |
| − |
| |
| − | @author: rjsec
| |
| − | """
| |
| − | # Contoh kasus: Orang yang akan melakukan free-fall dari sebuah tempat tinggi.
| |
| − | # Program digunakan untuk menghitung kecepatan orang setelah t detik mengudara.
| |
| − | # Gaya gesek udara diperhitungkan.
| |
| − |
| |
| − | # t sebagai waktu orang mengudara, g sebagai gravitasi, m sebagai massa orang,
| |
| − | # cd sebagai koefisien gesek udara, t0 dan v0 sebagai waktu dan kecepatan awal,
| |
| − | # dan step sebagai increment/step dalam perhitungan Runge-Kutta.
| |
| − | t = float(input("Masukkan waktu orang mengudara (dalam detik): "))
| |
| − | while t < 0:
| |
| − | print("Waktu tidak boleh negatif. Mohon masukkan angka positif.")
| |
| − | t = float(input("Masukkan waktu orang mengudara (dalam detik): "))
| |
| − | g = 9.80665
| |
| − | m = float(input("Masukkan massa orang yang meloncat (dalam kg): "))
| |
| − | while m < 0:
| |
| − | print("Massa tidak boleh negatif. Mohon masukkan angka positif.")
| |
| − | m = float(input("Masukkan massa orang yang meloncat (dalam kg): "))
| |
| − | cd = float(input("Masukkan koefisien gesek udara: "))
| |
| − | while cd > 1 or cd < 0:
| |
| − | print("Koefisien gesek udara harus berada di antara 0 dan 1.")
| |
| − | cd = float(input("Masukkan koefisien gesek udara: "))
| |
| − | t0 = 0
| |
| − | v0 = 0
| |
| − | step = 0.01
| |
| − | # f(t,v) sebagai fungsi (x,y) dimana t diposisikan sebagai x dan v diposisikan sebagai y.
| |
| − | def f(t, v):
| |
| − | return ((m*g-cd*v**1.5)/m)
| |
| − | # rungekutta sebagai fungsi penghitungan 4th order Runge-Kutta.
| |
| − | def rungekutta(t0, v0, t, step):
| |
| − | n = (int)((t - t0)/step)
| |
| − | v = v0
| |
| − | for i in range(1, n + 1):
| |
| − | k1 = step * f(t, v)
| |
| − | k2 = step * f(t + 0.5 * step, v + 0.5 * k1)
| |
| − | k3 = step * f(t + 0.5 * step, v + 0.5 * k2)
| |
| − | k4 = step * f(t + step, v + k3)
| |
| − |
| |
| − | #untuk v baru
| |
| − | v = v + (1/6)*(k1 + 2 * k2 + 2 * k3 + k4)
| |
| − |
| |
| − | #untuk t baru
| |
| − | t0 = t0 + step
| |
| − | return v
| |
| − | # Menunjukkan hasil perhitungan.
| |
| − | print("Kecepatan orang setelah", t, "detik mengudara adalah", rungekutta(t0, v0, t, step), "m/s")
| |
| − | # Kode dibuat oleh Ryanson Jonathan (1806149293).
| |
| − | | |
| − | ===CFD Analysis===
| |
| − | | |
| − | Analysis drag dilakukan terlebih dahulu input data yang diperlukan pada ''CFD-Pre'' dan ''CFD-Solve''. Berikut adalah hasil setelah dilakukan ''Mesh Geometry'' dan ''Run Solver'' dari mobil yang akan dianalisa.
| |
| − | | |
| − | [[File:testcfdkel2_1.jpg|400px]]
| |
| − | | |
| − | Kemudian, pada bagian ''tab'' ''CFD-Post'', dilakukan running dengan aplikasi ''Paraview'' untuk mengetahui drag force yang ingin dicari tahu.
| |
| − | | |
| − | [[File:testcfdkel2_2.jpg|400px]]
| |
| − | | |
| − | Lalu, dilakukan pengerjaan dengan filter ''Generate Surface Normal'', dengan mengapply tampak car_body saja yang terlihat. Kemudian, dilakukan kalkulasi besar P terhadap gaya normal sumbu x. Hasil tersebut kemudian di apply kembali sehingga menghasilkan perhitungan yang diinginkan yaitu ''Drag Force'' yang ditentukan. Didapatkan besarnya setelah dilakukan ''filter'' dan integrasi perhitungan yang ada. Berikut adalah skema yang dilakukan:
| |
| − | | |
| − | [[File:testcfdkel2_3.jpg|400px]]
| |
| − | | |
| − | Kemudian, dilakukan percobaan lainnya dengan variasi V dengan interval 1 dari 10 hingga 20. Akhirnya, didapatkan data yang kemudian dibentuk grafiknya serta ''trendline'' yang berbentuk kurva sebagai berikut:
| |
| − | | |
| − | [[File:testcfdkel2_4.jpg|400px]]
| |
| − | | |
| − | | |
| − | ===Optimasi===
| |
| − | Optimasi untuk kasus airfoil dilakukan menggunakan kode sbb:
| |
| − | | |
| − | # -*- coding: utf-8 -*-
| |
| − | """
| |
| − | Created on Mon Dec 2 14:39:11 2019
| |
| − |
| |
| − | @author: rjsec
| |
| − | """
| |
| − |
| |
| − | import numpy as np
| |
| − | from scipy.optimize import minimize
| |
| − |
| |
| − |
| |
| − | def cdrag(x):
| |
| − | x1 = x[0]
| |
| − | drag = 0.0000003*x1**4-0.00002*x1**3+0.0008*x1**2+0.0026*x1-0.0517
| |
| − | return drag
| |
| − |
| |
| − | def clift(x):
| |
| − | x1 = x[0]
| |
| − | lift = 0.0000001*x1**4+0.00001*x1**3+0.0003*x1**2+0.0052*x1+0.0187
| |
| − | return lift
| |
| − |
| |
| − | def objective(x):
| |
| − | return cdrag(x)
| |
| − |
| |
| − | def constraint1(x):
| |
| − | return 90 - cdrag(x)
| |
| − | def constraint2(x):
| |
| − | return 90 - clift(x)
| |
| − |
| |
| − | con1=({'type':'ineq','fun':constraint1})
| |
| − | con2=({'type':'ineq','fun':constraint2})
| |
| − | cons = (con1,con2)
| |
| − |
| |
| − | x1_guess = 50
| |
| − |
| |
| − | x0 = np.array([x1_guess])
| |
| − |
| |
| − | sol = minimize(objective,x0, method='SLSQP',constraints=cons, options={'disp':True})
| |
| − |
| |
| − | xopt = sol.x
| |
| − | forceopt = -sol.fun
| |
| − |
| |
| − | dragopt = cdrag(xopt)
| |
| − | liftopt = clift(xopt)
| |
| − |
| |
| − | print ("")
| |
| − | print ("Hasil optimasi:")
| |
| − | print ("Sudut optimal = "+str(-xopt[0]))
| |
| − | print ("Total force optimal = "+str(forceopt))
| |
| − | print ("Drag force optimal = "+str(-dragopt))
| |
| − | print ("Lift force optimal = "+str(liftopt))
| |
| − | | |
| − | | |
| − | == Tugas Besar ==
| |
| − | '''Spesifikasi Airfoil'''
| |
| − | [[File:TB1.png]]
| |
| − | Airfoil yang digunakan adalah MH 70 11.08% - Martin Hepperle MH70
| |
| − | Span = 2 mm
| |
| − | Root and Tip Chord = 10 mm
| |
| − | | |
| − | '''Pembuatan model airfoil'''
| |
| − | Airfoil dibuat dengan menggunakan software Autodesk Inventor
| |
| − | [[File:TB2.png]]
| |
| − | | |
| − | '''Simulasi menggunakan CFD'''
| |
| − | Model yang sudah dibuat diimport ke CFDSOF
| |
| − | [[File:TB3.png]]
| |
| − | Model memasuki tahap ''meshing''
| |
| − |
| |
| − | Berikut adalah ''Boundary geometry'' untuk proses ''meshing''
| |
| − | [[File:TB4.png]]
| |
| − |
| |
| − | Model memasuki tahap-tahap analisis sebagai berikut
| |
| − | [[File:TB5.png]]
| |
| − |
| |
| − | [[File:TB6.png]]
| |
| − |
| |
| − | [[File:TB7.png]]
| |
| − |
| |
| − | [[File:TB8.png]]
| |
| − |
| |
| − | [[File:TB9.png]]
| |
| − |
| |
| − | [[File:TB10.png]]
| |
| − |
| |
| − | [[File:TB11.png]]
| |
| − |
| |
| − | [[File:TB12.png]]
| |
| − | | |
| − | '''Perhitungan menggunakan Paraview'''
| |
| − | Model ''meshing'' diimport ke Paraview
| |
| − | Perhitungan dilakukan dengan tahap berikut
| |
| − | [[File:TB12.png]]
| |
| − |
| |
| − | [[File:TB13.png]]
| |
| − |
| |
| − | [[File:TB14.png]]
| |
| − |
| |
| − | [[File:TB15.png]]
| |
| − |
| |
| − | [[File:TB16.png]]
| |
| − |
| |
| − | [[File:TB17.png]]
| |
| − |
| |
| − | [[File:TB18.png]]
| |
| − | | |
| − | '''Hasil Percobaan'''
| |
| − | ''Data Percobaan''
| |
| − | Data Percobaan
| |
| − | [[File:TB19.png]]
| |
| − |
| |
| − | ''Grafik Percobaan''
| |
| − | Berikut adalah grafik lift dan drag kami
| |
| − | [[File:TB20.png]]
| |
| − |
| |
| − | ''Optimasi''
| |
| − | Kode yang digunakan
| |
| − | [[File:TB21.png]]
| |
| − |
| |
| − | Berikut hasil optimasi yang dilakukan
| |
| − | [[File:TB22.png]]
| |
| − |
| |
| − | Grafik hasil optimasi Lift vs Drag
| |
| − |
| |
| − | [[File:TB23.png]]
| |
| − | | |
| − | ===Analytical Neural Network (ANN)===
| |
| − | | |
| − | Analytical Neural Network, atau yang disingkat ANN, adalah sebuah teknik untuk melakukan pengolahan data melalui pengumpulan banyak input dan output supaya program dapat mengira-ngira algoritma yang dimasukkan ke input, supaya dapat dihasilkan output dengan hanya memasukkan input. Metode ini dapat dinamakan machine learning. Yang membedakan ANN dengan machine learning lainnya adalah ANN dibuat sedemikian rupa sehingga jaringannya menyerupai pemikiran manusia.
| |
| − | ANN ada
| |
