Musyafi Albar

From ccitonlinewiki
Revision as of 17:25, 23 December 2020 by Musyafi Albar (talk | contribs)
Jump to: navigation, search
Biodata
Mus.jpg
Nama Musyafi Albar
NPM 1906379094
Email musyafi.albar@ui.ac.id


Musyafi Albar

Perkenalkan nama saya Musyafi Albar (NPM 1906379094) biasa dipanggil Mus. Saya Adalah mahasiswa Teknik Mesin angkatan 2019 dari Fakultas Teknik Universitas Indonesia. Saya memiliki ketertarikan kepada bidang mesin karena dirasa jurusan tersebut memiliki rana yang luas untuk dunia kerjanya. Pada Pelajaran metnum sebelumnya saya telah mempelajari tentang persamaan, istilah algoritma, kurva, regresi, differensial, parsial

Catatan Minggu Pertama (11 November 2020)

Tujuan Pembelajaran

  • Memahami konsep dan prinsip dasar metode numerik
  • Dapat menerapkan pemahaman yang didapatkan dalam mata kuliah Metode Numerik
  • Mampu menerapkan pemahaman metode numerik dalam bidang keteknikan
  • Membentuk kita menjadi orang yang lebih beradab

Manfaat Belajar bagi Diri Saya Sendiri

Menurut saya, pembelajaran adalah suatu proses penambahan kualitas diri. Saya merasa dengan belajar kita bisa memahami berbagai macam hal yang dapat menambah kualitas pada diri sendiri. Hasil dari penambahan kualitas tersebut berupa pemanfaatan hal yang telah dipelajari, diaplikasikan di kehidupan nyata. Sebagai contoh kita belajar pendidikan dari sd hingga sma untuk menambah kualitas diri dan digunakan untuk menempuh belajar di Kuliah.

Komputer dalam Metode Numerik

Komputer merupakan alat hitung yang cepat. Kualitas dari komputer bergantung pada spesifikasi pembuatannya. Penggunaan dari alat tersebut juga bergantung pada pemakainya.

Tugas 1

Berikut merupakan video penjelasan aplikasi OpenModelica untuk menyelesaikan suatu Sistem Persamaan

Catatan Minggu kedua (18 November 2020)

Pembahasan

Pada kuliah pertemuan ke 2 dibahas tentang penggungan Openmodelica

Sesi Tanya jawab :

Mengapa menggunakan openmodelica : Karena openmodelica merupakan bahasa permodolen yang gratis. Apa Perbedaan constan real dengan parameter real : untuk mengganti variabel pada simulasi jika menggunakan comand constan real diperlukan simulate ulangsedangkan dengan menggunakan comand parameter real tidak perlu simulate ulang hanya dengan mengganti variabel xnya

Penyataan Penting Openmodelica merupakan object oriented. Pada modelica specialization model digunakan untuk menyelesaikan suatu fungsi sedangankan class digunakan untuk penggabungan fungsi-fungsi. Setiap specializtion digunakan untuk tujuan yang berbeda-beda dengan mempunyai kelebihan dan kelemahan.

Tugas 2

Membuat open modecalica dengan specializtion Class persamaan aljabar simultan

function 

function p
input Real A[4,4];
input Real B[4];
output Real X[4]; 
algorithm
X:=Modelica.Math.Matrices.solve(A,B);
end p;

class 

class o
parameter Real P[4,4]=[8,-9,1,-8;
                      -3,-1,5,4;
                      -2,-1,-3,8;
                      -2,-8,-1,2];
Q[4]={80,7,-30,18};
Real X[4];
equation
X=o(P,Q);
end SPL;

Video tugas

Catatan Minggu ketiga (25 November 2020)

Pengaplikasian dalam Open Modelica, kita akan membuat code untuk menyelesaikan persamaan 9.12 pada buku Chapra yaitu mengenai eliminasi Naïve Gauss. Pseudocode untuk eliminasi Naïve Gauss diberikan pada Fig.9.4:

1.PNG

pseudocode dibuat kedalam bahasa Open Modelica

....

Penggunaan code dengan menyelesaikan

21.PNG

....

Tugas Minggu ketiga (25 November 2020)

menyelesaikan permalasahan truss berikut:

Problem 3 tedi veradino.jpeg

Class 

class Trusses_Tugas3_d29

parameter Integer N=8; //Global matrice = 2*points connected
parameter Real A=0.001; //m^2
parameter Real E=200e9; //Pa
Real G[N,N]; //global
Real Ginitial[N,N]; //global
Real Sol[N]; //global displacement
Real X[N]={0,0,-1035.2762,-3863.7033,0,0,-1035.2762,-3863.7033};
Real R[N]; //global reaction force
Real SolMat[N,1];
Real XMat[N,1];

//boundary condition
Integer b1=1;
Integer b2=3;

//truss 1
parameter Real X1=0; //degree between trusses
Real k1=A*E/1;
Real K1[4,4]; //stiffness matrices
Integer p1a=1;
Integer p1b=2;
Real G1[N,N];

//truss 2
parameter Real X2=0; //degree between trusses
Real k2=A*E/1;
Real K2[4,4]; //stiffness matrices
Integer p2a=2;
Integer p2b=3;
Real G2[N,N];

//truss 3
parameter Real X3=90; //degree between trusses
Real k3=A*E/1.25;
Real K3[4,4]; //stiffness matrices
Integer p3a=2;
Integer p3b=4;
Real G3[N,N];
 
//truss 4
parameter Real X4=90+38.6598; //degree between trusses
Real k4=A*E/1.6;
Real K4[4,4]; //stiffness matrices
Integer p4a=1;
Integer p4b=4;
Real G4[N,N];

//truss 5
parameter Real X5=90-38.6598; //degree between trusses
Real k5=A*E/1.6;
Real K5[4,4]; //stiffness matrices
Integer p5a=3;
Integer p5b=4;
Real G5[N,N];

/*
for each truss, ensure pXa is lower then pXb (X represents truss element number)
*/

algorithm

//creating global matrice
K1:=Stiffness_Matrices(X1);
G1:=k1*Local_Global(K1,N,p1a,p1b);

K2:=Stiffness_Matrices(X2);
G2:=k2*Local_Global(K2,N,p2a,p2b);

K3:=Stiffness_Matrices(X3);
G3:=k3*Local_Global(K3,N,p3a,p3b);

K4:=Stiffness_Matrices(X4);
G4:=k4*Local_Global(K4,N,p4a,p4b);

K5:=Stiffness_Matrices(X5);
G5:=k5*Local_Global(K5,N,p5a,p5b);

G:=G1+G2+G3+G4+G5;
Ginitial:=G;

//implementing boundary condition
for i in 1:N loop
 G[2*b1-1,i]:=0;
 G[2*b1,i]:=0;
 G[2*b2-1,i]:=0;
 G[2*b2,i]:=0;
end for;

G[2*b1-1,2*b1-1]:=1;
G[2*b1,2*b1]:=1;
G[2*b2-1,2*b2-1]:=1;
G[2*b2,2*b2]:=1;

//solving displacement
Sol:=Gauss_Jordan(N,G,X);

//solving reaction force
SolMat:=matrix(Sol);
XMat:=matrix(X);
R:=Reaction_Trusses(N,Ginitial,SolMat,XMat);

end Trusses_Tugas3_d29;

Function Stiffness_Matrices 

function Stiffness_Matrices

input Real A;
Real Y;
output Real X[4,4];
Real float_error = 10e-10;

final constant Real pi=2*Modelica.Math.asin(1.0);

algorithm

Y:=A/180*pi;
    
X:=[(Modelica.Math.cos(Y))^2,Modelica.Math.cos(Y)*Modelica.Math.sin(Y),-(Modelica.Math.cos(Y))^2,-Modelica.Math.cos(Y)*Modelica.Math.sin(Y);

Modelica.Math.cos(Y)*Modelica.Math.sin(Y),(Modelica.Math.sin(Y))^2,-Modelica.Math.cos(Y)*Modelica.Math.sin(Y),-(Modelica.Math.sin(Y))^2;

-(Modelica.Math.cos(Y))^2,-Modelica.Math.cos(Y)*Modelica.Math.sin(Y),(Modelica.Math.cos(Y))^2,Modelica.Math.cos(Y)*Modelica.Math.sin(Y);

-Modelica.Math.cos(Y)*Modelica.Math.sin(Y),-(Modelica.Math.sin(Y))^2,Modelica.Math.cos(Y)*Modelica.Math.sin(Y),(Modelica.Math.sin(Y))^2];

for i in 1:4 loop
 for j in 1:4 loop
   if abs(X[i,j]) <= float_error then
     X[i,j] := 0;
   end if;
 end for;
end for;

end Stiffness_Matrices;

Function Gauss-Jordan 

function Gauss_Jordan

input Integer N;
input Real A[N,N];
input Real B[N];
output Real X[N];
Real float_error = 10e-10;

algorithm
X:=Modelica.Math.Matrices.solve(A,B);

for i in 1:N loop
  if abs(X[i]) <= float_error then
    X[i] := 0;
  end if;
end for;

end Gauss_Jordan;

Function Reaction_Trusses 

function Reaction_Trusses

input Integer N;
input Real A[N,N];
input Real B[N,1];
input Real C[N,1];
Real X[N,1];
output Real Sol[N];
Real float_error = 10e-10;

algorithm
X:=A*B-C;

for i in 1:N loop
 if abs(X[i,1]) <= float_error then
   X[i,1] := 0;
 end if;
end for;

for i in 1:N loop
 Sol[i]:=X[i,1];
end for;

end Reaction_Trusses;

Function Local_Global 

function Local_Global

input Real Y[4,4];
input Integer B;
input Integer p1;
input Integer p2;
output Real G[B,B];

algorithm

for i in 1:B loop
 for j in 1:B loop
     G[i,j]:=0;
 end for;
end for;

G[2*p1,2*p1]:=Y[2,2];
G[2*p1-1,2*p1-1]:=Y[1,1];
G[2*p1,2*p1-1]:=Y[2,1];
G[2*p1-1,2*p1]:=Y[1,2];

G[2*p2,2*p2]:=Y[4,4];
G[2*p2-1,2*p2-1]:=Y[3,3];
G[2*p2,2*p2-1]:=Y[4,3];
G[2*p2-1,2*p2]:=Y[3,4];

G[2*p2,2*p1]:=Y[4,2];
G[2*p2-1,2*p1-1]:=Y[3,1];
G[2*p2,2*p1-1]:=Y[4,1];
G[2*p2-1,2*p1]:=Y[3,2];

G[2*p1,2*p2]:=Y[2,4];
G[2*p1-1,2*p2-1]:=Y[1,3];
G[2*p1,2*p2-1]:=Y[2,3];
G[2*p1-1,2*p2]:=Y[1,4];

end Local_Global;

Quiz class diagram dan flowchart Minggu keempat (2 Desember 2020)

253564.jpg

Tugas Minggu keempat (2 Desember 2020)

No8 d29.jpeg

Class 

class Tugas4_d29
  parameter Real [:,9] inisiasi = [1, 1, 2, -0.8,    0, -0.6, 15e-4, 70e9, 2.5;
                                   2, 1, 3, -0.8, -0.6,    0, 15e-4, 70e9, 2.5;
                                   3, 1, 4, -0.8,    0,  0.6, 15e-4, 70e9, 2.5];
  parameter Integer [:,2] node = [1, 2;
                                  1, 3;
                                  1, 4];
  parameter Integer y = size(node,1);
  parameter Integer x = 3*(size(node_load,1));
  parameter Integer z = size(Boundary,1);
  parameter Integer [:] Boundary = {2,3,4};
  parameter Real [:,4] node_load = [1, 0, -5000, 0;
                                    2, 0,     0, 0;
                                    3, 0,     0, 0;
                                    4, 0,     0, 0];
  parameter Real [x] load = {0,-5000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  Real [y] k;
  Real [y,6,6] Ke;
  Real [y,x,x] Kg;
  Real [x,x] KgTot;
  Real [x,x] KgB;
  Real [x] U;
  Real [x] R;
  
equation
 k = {(inisiasi[i,7] * inisiasi[i,8] / inisiasi[i,9]) for i in 1:y};
 Ke = StiffnessMatrixElement(inisiasi);
 Kg = StiffnessMatrixGlobal(node, x, y, Ke);
 KgTot = SumStiffnessMatrixGlobal(x, y, Kg);
 KgB = BoundaryStiffnessMatrixGlobal(x, z, KgTot, Boundary);
 U = GaussJordan(x, KgB, load);
 R = ReactionForce(x, KgTot, U, load);

end Tugas4_d29;

Function StiffnessMatrixElement 

function StiffnessMatrixElement

 input Real [:,9] inisiasi_mat;
 output Real [size(inisiasi_mat,1),6,6] Ke_mat;

 protected
   Real cos_x;
   Real cos_y;
   Real cos_z;
   Real [6] StiffTrig;
   Real [6,6] StiffTrans;
   Real [size(inisiasi_mat,1)] k_vec;

algorithm
 k_vec := {(inisiasi_mat[i,7] * inisiasi_mat[i,8] / inisiasi_mat[i,9]) for i in 1:size(inisiasi_mat,1)};

 // Finding stiffness matrix of each element member
 for i in 1:size(inisiasi_mat,1) loop

 // Clearing the matrices
 StiffTrig := zeros(6);
 StiffTrans := zeros(6,6);
 
 // Converting degrees to radians
 cos_x := inisiasi_mat[i,4];
 cos_y := inisiasi_mat[i,5];
 cos_z := inisiasi_mat[i,6];

 // {cos^2, sin^2, sincos}
 StiffTrig := {(cos_x)^2,
               (cos_y)^2,
               (cos_z)^2,
               (cos_x*cos_y),
               (cos_x*cos_z),
               (cos_y*cos_z)};
 
 // Construct stiffness transformation matrix
 StiffTrans := [  StiffTrig[1],    StiffTrig[4],    StiffTrig[5], -1*StiffTrig[1], -1*StiffTrig[4], -1*StiffTrig[5];
                  StiffTrig[4],    StiffTrig[2],    StiffTrig[6], -1*StiffTrig[4], -1*StiffTrig[2], -1*StiffTrig[6];
                  StiffTrig[5],    StiffTrig[6],    StiffTrig[3], -1*StiffTrig[5], -1*StiffTrig[6], -1*StiffTrig[3];
               -1*StiffTrig[1], -1*StiffTrig[4], -1*StiffTrig[5],    StiffTrig[1],    StiffTrig[4],    StiffTrig[5];
               -1*StiffTrig[4], -1*StiffTrig[2], -1*StiffTrig[6],    StiffTrig[4],    StiffTrig[2],    StiffTrig[6];
               -1*StiffTrig[5], -1*StiffTrig[6], -1*StiffTrig[3],    StiffTrig[5],    StiffTrig[6],    StiffTrig[3]];
               
 // Multiply in stiffness constant of element, add final stiffness matrix to Ke_mat
 for m in 1:6 loop
   for n in 1:6 loop
     Ke_mat[i,m,n] := k_vec[i] * StiffTrans[m,n];
   end for;
 end for;

end for;
end StiffnessMatrixElement;

Function StiffnessMatrixGlobal 

function StiffnessMatrixGlobal
 input Integer [:,2] n;
 input Integer x;
 input Integer y;
 input Real [y,6,6] Ke_mat; 
 output Real [y,x,x] Kg_mat;
 
algorithm
 for i in 1:y loop
   for a in 1:x loop
     for b in 1:x loop
       Kg_mat[i,a,b]:=0;
     end for;
   end for;
  end for;

 for i in 1:y loop
   Kg_mat[i,3*n[i,1],3*n[i,1]]:=Ke_mat[i,3,3];
   Kg_mat[i,3*n[i,1],3*n[i,1]-1]:=Ke_mat[i,3,2];
   Kg_mat[i,3*n[i,1],3*n[i,1]-2]:=Ke_mat[i,3,1];
   Kg_mat[i,3*n[i,1]-1,3*n[i,1]]:=Ke_mat[i,2,3];
   Kg_mat[i,3*n[i,1]-1,3*n[i,1]-1]:=Ke_mat[i,2,2];
   Kg_mat[i,3*n[i,1]-1,3*n[i,1]-2]:=Ke_mat[i,2,1];
   Kg_mat[i,3*n[i,1]-2,3*n[i,1]]:=Ke_mat[i,1,3];
   Kg_mat[i,3*n[i,1]-2,3*n[i,1]-1]:=Ke_mat[i,1,2];
   Kg_mat[i,3*n[i,1]-2,3*n[i,1]-2]:=Ke_mat[i,1,1];

   Kg_mat[i,3*n[i,2],3*n[i,2]]:=Ke_mat[i,6,6];
   Kg_mat[i,3*n[i,2],3*n[i,2]-1]:=Ke_mat[i,6,5];
   Kg_mat[i,3*n[i,2],3*n[i,2]-2]:=Ke_mat[i,6,4];
   Kg_mat[i,3*n[i,2]-1,3*n[i,2]]:=Ke_mat[i,5,6];
   Kg_mat[i,3*n[i,2]-1,3*n[i,2]-1]:=Ke_mat[i,5,5];
   Kg_mat[i,3*n[i,2]-1,3*n[i,2]-2]:=Ke_mat[i,5,4];
   Kg_mat[i,3*n[i,2]-2,3*n[i,2]]:=Ke_mat[i,4,6];
   Kg_mat[i,3*n[i,2]-2,3*n[i,2]-1]:=Ke_mat[i,4,5];
   Kg_mat[i,3*n[i,2]-2,3*n[i,2]-2]:=Ke_mat[i,4,4];

   Kg_mat[i,3*n[i,2],3*n[i,1]]:=Ke_mat[i,6,3];
   Kg_mat[i,3*n[i,2],3*n[i,1]-1]:=Ke_mat[i,6,2];
   Kg_mat[i,3*n[i,2],3*n[i,1]-2]:=Ke_mat[i,6,1];
   Kg_mat[i,3*n[i,2]-1,3*n[i,1]]:=Ke_mat[i,5,3];
   Kg_mat[i,3*n[i,2]-1,3*n[i,1]-1]:=Ke_mat[i,5,2];
   Kg_mat[i,3*n[i,2]-1,3*n[i,1]-2]:=Ke_mat[i,5,1];
   Kg_mat[i,3*n[i,2]-2,3*n[i,1]]:=Ke_mat[i,4,3];
   Kg_mat[i,3*n[i,2]-2,3*n[i,1]-1]:=Ke_mat[i,4,2];
   Kg_mat[i,3*n[i,2]-2,3*n[i,1]-2]:=Ke_mat[i,4,1];

   Kg_mat[i,3*n[i,1],3*n[i,2]]:=Ke_mat[i,3,6];
   Kg_mat[i,3*n[i,1],3*n[i,2]-1]:=Ke_mat[i,3,5];
   Kg_mat[i,3*n[i,1],3*n[i,2]-2]:=Ke_mat[i,3,4];
   Kg_mat[i,3*n[i,1]-1,3*n[i,2]]:=Ke_mat[i,2,6];
   Kg_mat[i,3*n[i,1]-1,3*n[i,2]-1]:=Ke_mat[i,2,5];
   Kg_mat[i,3*n[i,1]-1,3*n[i,2]-2]:=Ke_mat[i,2,4];
   Kg_mat[i,3*n[i,1]-2,3*n[i,2]]:=Ke_mat[i,1,6];
   Kg_mat[i,3*n[i,1]-2,3*n[i,2]-1]:=Ke_mat[i,1,5];
   Kg_mat[i,3*n[i,1]-2,3*n[i,2]-2]:=Ke_mat[i,1,4];
 end for;
end StiffnessMatrixGlobal;

Function SumStiffnessMatrixGlobal 

function SumStiffnessMatrixGlobal
 input Integer x;
 input Integer y;
 input Real [y,x,x] Kg_mat;
 output Real [x,x] KgTot_mat;
 
algorithm
  for a in 1:x loop
   for b in 1:x loop
     KgTot_mat[a,b] := sum(Kg_mat [:,a,b]);
    end for;
   end for;

end SumStiffnessMatrixGlobal;

Function BoundaryStiffnessMatrixGlobal 

function BoundaryStiffnessMatrixGlobal
 input Integer x;
 input Integer z;
 input Real [x,x] KgTot_met;
 input Integer[z] Boundary_met;
 output Real [x,x] KgB_met;
 
algorithm
 for a in 1:x loop
   for b in 1:x loop
    KgB_met[a,b] := KgTot_met [a,b];
   end for;
  end for; 
 
 for i in 1:x loop
  for a in 1:z loop
   for b in 0:2 loop
     KgB_met[3*(Boundary_met[a])-b,i]:=0;
   end for;
  end for;
 end for;

 for a in 1:z loop
   for b in 0:2 loop
     KgB_met[3*Boundary_met[a]-b,3*Boundary_met[a]-b]:=1;
   end for;
 end for;
  
end BoundaryStiffnessMatrixGlobal;

Function GaussJordan 

function GaussJordan
 input Integer x;
 input Real [x,x] KgB_met;
 input Real [x] load_met;
 output Real [x] U_met;
 
 protected
 Real float_error = 10e-10;

algorithm
 U_met:=Modelica.Math.Matrices.solve(KgB_met,load_met);

 for i in 1:x loop
   if abs(U_met[i]) <= float_error then
    U_met[i] := 0;
   end if;
 end for;

end GaussJordan;

Function ReactionForce 

function ReactionForce
 input Integer x;
 input Real [x,x] KgTot_met;
 input Real [x] U_met;
 input Real [x] load_met;
 output Real [x] R_met;

algorithm
 R_met := (KgTot_met*U_met)-load_met;
end ReactionForce;

Tugas Minggu ketiga (16 Desember 2020)

Tema : Aplikasi Metoda Numerik dalam Optimasi Desain Struktur Rangka Sederhana

Sinopsis Tugas Besar

Dalam tugas besar ini kami diminta untuk mendesain rangka sesuai yang tertera dibawah dengan menggunakan rangka yang optimal dan cost yang minimum

Soaltubesy.jpeg Soaltubes1.jpeg

Adapun Hal yang Harus Diperhitungkan sebagai Plotting

  • a. Harga material di dapat dari nilai optimum defleksi dan cross section
  • b. Material (Elastisitas properti)
  • c. Area Cross Section Truss (L profile/truss siku), luas cross section sebagai X
  • d. Defleksi sebagai Y
Retrieved from "http://air.eng.ui.ac.id/index.php?title=Musyafi_Albar&oldid=50658"