Difference between revisions of "John Patrick Anhar"

From ccitonlinewiki
Jump to: navigation, search
(Tugas Minggu 4)
(46 intermediate revisions by the same user not shown)
Line 13: Line 13:
 
Saya adalah mahasiswa FTUI angkatan 2018 dari jurusan Teknik Mesin dan saya adalah salah satu ciptaan terbaik dari Tuhan Yang Maha Esa, karena pada prinsipnya Tuhan Yang Maha Esa itu mendesain manusia dengan sebaik-baiknya makhluk.
 
Saya adalah mahasiswa FTUI angkatan 2018 dari jurusan Teknik Mesin dan saya adalah salah satu ciptaan terbaik dari Tuhan Yang Maha Esa, karena pada prinsipnya Tuhan Yang Maha Esa itu mendesain manusia dengan sebaik-baiknya makhluk.
  
Saya mengikuti kuliah Teknik Mesin karena saya menyukai di bidang otomotif sejak saya kecil dan jurusan ini sungguh berkaitan dengan bidang tersebut. Di jurusan Teknik Mesin ini ada banyak mata kuliah yang saya ikuti, salah satunya yaitu mata kuliah Metode Numerik.
+
Saya mengikuti kuliah Teknik Mesin karena saya menyukai bidang otomotif sejak saya masih kecil dan jurusan ini sangatlah berkaitan dengan bidang otomotif juga. Di jurusan Teknik Mesin ini ada banyak mata kuliah yang saya ikuti, salah satunya yaitu mata kuliah Metode Numerik.
  
 
__TOC__
 
__TOC__
Line 19: Line 19:
 
== Tujuan Mempelajari Metode Numerik ==
 
== Tujuan Mempelajari Metode Numerik ==
 
Tujuan dari mempelajari metode numerik adalah:
 
Tujuan dari mempelajari metode numerik adalah:
 +
 
*Memahami konsep dasar metode numerik dengan baik.
 
*Memahami konsep dasar metode numerik dengan baik.
 +
 
*Mampu menerapkan konsep metode numerik.
 
*Mampu menerapkan konsep metode numerik.
 +
 
*Mampu menerapkan metode numerik untuk menyelesaikan berbagai persoalan teknik.
 
*Mampu menerapkan metode numerik untuk menyelesaikan berbagai persoalan teknik.
 +
 
*Mendapat nilai tambah/adab agar menjadi manusia yang beradab.
 
*Mendapat nilai tambah/adab agar menjadi manusia yang beradab.
  
 
== Metode Numerik ==
 
== Metode Numerik ==
Saya telah mengikuti mata kuliah ini selama setengah semester dan saya sudah mempelajari beberapa hal, seperti apa itu penyelesaian matematika menggunakan metode numerik, error-error dalam perhitungan secara numerik, turunan forward centered dan backward, cara-cara melakukan interpolasi dan regresi, serta cara mencari akar dari suatu persamaan secara numerik seperti menggunakan metode Newton-Raphson, metode Bisection, dan metode Secant.
+
Saya telah mengikuti mata kuliah ini selama setengah semester bersama dengan Pak Engkos Achmad Kosasih dan saya sudah mempelajari beberapa hal, yaitu:
 +
 
 +
*penyelesaian matematika menggunakan metode numerik
 +
 
 +
*error-error dalam perhitungan secara numerik
 +
 
 +
*turunan forward centered dan backward
 +
 
 +
*cara-cara melakukan interpolasi dan regresi
 +
 
 +
*cara mencari akar dari suatu persamaan secara numerik menggunakan: metode Newton-Raphson, metode Bisection, dan metode Secant.
  
 
===Pertemuan Minggu 1 (11 November 2020)===
 
===Pertemuan Minggu 1 (11 November 2020)===
Line 107: Line 121:
 
<youtube width="200" height="100">lOakm5B7byk</youtube>
 
<youtube width="200" height="100">lOakm5B7byk</youtube>
  
 +
Pada coding saya mengenai tugas tersebut, saya masih menggunakan fitur solve eliminasi Gauss yang memang sudah disediakan di openmodelica karena saya masih belajar untuk dapat menggunakan openmodelica.
  
 
===Pertemuan Minggu 3 (25 November 2020)===
 
===Pertemuan Minggu 3 (25 November 2020)===
Pada pertemuan kali ini, saya mempelajari banyak hal baru. Salah satunya yaitu belajar tentang cara membuat fungsi sendiri tanpa menggunakan fitur yang disediakan oleh OpenModelica. Pada kesempatan ini saya diberikan penjelasan oleh beberapa teman saya yaitu Josiah Enrico dan Christopher Salendu Erwin mengenai fungsi array dengan menggunakan metode Newton Raphson dan juga cara membuat fungsi Gauss Jordan di OpenModelica dengan sangat jelas.
+
Pada pertemuan kali ini, saya mempelajari banyak hal baru. Salah satunya yaitu belajar tentang cara membuat fungsi sendiri tanpa menggunakan fitur yang disediakan oleh OpenModelica. Pada kesempatan ini saya diberikan penjelasan oleh beberapa teman saya yaitu Josiah Enrico dan Christopher Salendu Erwin mengenai fungsi array dengan menggunakan metode Newton Raphson dan juga cara untuk membuat fungsi Gauss Jordan di OpenModelica dengan sangat jelas.
 
Pseudocode fungsi yang dijelaskan oleh Christopher adalah sebagai berikut:
 
Pseudocode fungsi yang dijelaskan oleh Christopher adalah sebagai berikut:
 
'''GaussJordan.mo'''
 
'''GaussJordan.mo'''
Line 473: Line 488:
  
 
Setelah di simulate, diperoleh nilai displacement (U) dan gaya reaksi (R) sebagai berikut:
 
Setelah di simulate, diperoleh nilai displacement (U) dan gaya reaksi (R) sebagai berikut:
                                              [[File:Up.png|240px]] [[File:Rp.png|240px]]
+
 
 +
<div class="center" style="width: auto; margin-left: auto; margin-right: auto;">
 +
 
 +
[[File:Up.png|240px]] [[File:Rp.png|240px]]
 +
 
 +
</div>
 +
 
  
 
Berikut video penjelasan saya mengenai penyelesaian soal diatas:
 
Berikut video penjelasan saya mengenai penyelesaian soal diatas:
Line 485: Line 506:
 
Aplikasi metode numerik dalam kasus optimasi
 
Aplikasi metode numerik dalam kasus optimasi
  
Pada hari ini kami akan mempelajari mengenai optimasi dengan menggunakan metode numerik. Optimasi adalah teknik untuk memperoleh nilai optimum dari suatu sistem. Topik optimasi kali ini akan dibawakan oleh Bu Candra. Metode optimasi yang digunakan adalah metode Golden Ratio Method. Pseudocodenya sebagai berikut:
+
Pada hari ini kami akan mempelajari mengenai optimasi dengan menggunakan metode numerik. Optimasi adalah teknik untuk memperoleh nilai optimum dari suatu sistem. Topik optimasi kali ini akan dibawakan oleh Bu Candra. Metode optimasi yang digunakan adalah metode Golden Ratio Method. Dalam metode Golden Ratio akan dapat diperoleh nilai yang paling efisien dari suatu sistem. Pseudocode aplikasi metode Golden Ratio didalam openmodelica adalah sebagai berikut:
  
 
'''FungsiObjek.mo'''
 
'''FungsiObjek.mo'''
Line 499: Line 520:
  
 
Setelah membuat fungsi objek tersebut, kemudian akan dipanggil kedalam model seperti berikut ini:
 
Setelah membuat fungsi objek tersebut, kemudian akan dipanggil kedalam model seperti berikut ini:
 +
 
'''Golden_Ratio.mo'''
 
'''Golden_Ratio.mo'''
 +
 
  model Golden_Ratio
 
  model Golden_Ratio
 
   
 
   
Line 540: Line 563:
  
 
===Pertemuan Minggu 7 (23 Desember 2020)===
 
===Pertemuan Minggu 7 (23 Desember 2020)===
Pada pertemuan ini, diadakan kuis dimana kami diminta untuk menghitung defleksi yang dialami sistem yang menjadi tugas besar kami. Untuk menghitung defleksi ini, kami diminta untuk menyelesaikannya dengan menggunakan program yang sudah kami buat. Berikut ini adalah pseudocode yang sudah saya buat:
 
  
'''Kuis2MetNum.mo'''
+
Pada pertemuan ini, diadakan kuis dimana kami diminta untuk menghitung defleksi yang dialami oleh sistem yang menjadi tugas besar kami. Untuk menghitung defleksi ini, kami diminta untuk menyelesaikannya dengan menggunakan program yang sudah dibuat dan kemudian diupload.
  class Kuis2MetNum
+
 
 +
===Tugas Besar Metode Numerik===
 +
'''Latar Belakang'''
 +
 
 +
Optimasi merupakan suatu langkah yang dilakukan untuk mendapatkan nilai optimum. Dalam proses desain suatu objek, optimasi memegang peranan yang penting sebab dengan melakukan optimasi maka dapat diperoleh kualitas yang baik dengan harga yang serendah-rendahnya.
 +
 
 +
 
 +
'''Tujuan'''
 +
 
 +
Memperoleh desain struktur truss terbaik dalam artian diperoleh harga yang serendah-rendahnya dengan kemampuan menahan beban yang sesuai dengan target.
 +
 
 +
 
 +
Rangka yang dianalisis dalam tugas besar adalah sebagai berikut:
 +
 
 +
[[File:Rangkatugasbesarp.jpeg|720px|center]]
 +
 
 +
Dan berikut adalah keterangannya:
 +
 
 +
[[File:Datatubesp.jpeg|720px|center]]
 +
 
 +
'''Asumsi'''
 +
 
 +
-Truss yang bersentuhan dengan lantai fixed
 +
 
 +
-Lokasi beban F1 dan F2 berada di tengah dari truss sehingga beban terbagi menjadi dua pada sudutnya
 +
 
 +
-Tidak terjadi bending
 +
 
 +
Penomoran node dan ukuran tinggi dari truss ditunjukkan pada gambar berikut
 +
 
 +
[[File:KoordinatStrukturTubesp.jpg|720px|center]]
 +
 
 +
Kemudian saya melakukan perhitungan Displacement dan Reaction Force dengan asumsi bahwa material yang digunakan adalah Stainless Steel SS316L dengan cross-sectional area sebesar 0,000171m² dan diperoleh hasil sebagai berikut
 +
 
 +
[[File:ReactionTubes.png|300px]] [[File:DisplacementTubesp.png|300px]]
 +
 
 +
dan juga diperoleh stress sebesar
 +
 
 +
[[File:StressTubesjp.png|300px]]
 +
 
 +
'''Metodologi Pengerjaan'''
 +
 
 +
Untuk mengerjakan tugas besar ini, akan digunakan coding untuk dapat mengoptimasi material yang dapat menahan beban dengan baik (memiliki kekuatan tinggi dan safety factor yang baik dalam menahan beban yang diberikan) namun dengan harga yang paling baik.
 +
 
 +
Ada 2 metode yang digunakan untuk melakukan optimasi ini:
 +
 
 +
1. Menentukan jenis material yang digunakan terlebih dahulu dan kemudian melakukan perhitungan terhadap harga, safety factor, dan rasio perbandingan safety factor dengan harga dengan memvariasikan cross-sectional area yang berbeda-beda.
 +
 
 +
2. Menentukan cross-sectional area besi siku terlebih dahulu dan kemudian melakukan perhitungan terhadap harga, safety factor, dan rasio perbandingan safety factor dengan harga dengan memvariasikan material yang berbeda-beda.
 +
 
 +
 
 +
'''Perhitungan'''
 +
 
 +
'''1. Elasticity Locked'''
 +
 
 +
Dalam perhitungan ini material yang saya tentukan terlebih dahulu adalah Stainless Steel SS316L yang ''properties''nya sebagai berikut:
 +
 
 +
  Material              : '''Stainless Steel SS316L'''
 
   
 
   
  //Urutan Penulisan: [Truss, Node 1, Node 2, Cx, Cy, Cz, A, E, L]
+
Yield Strength        : 290 MPa
  parameter Real [:,9] inisiasi = [ 1,  1,  2,    0,    1,    0,  9e-4, 190e9, 0.75;
+
                                    2,  2,  3,    1,    0,    0,  9e-4, 190e9,  0.6;
+
Modulus of Elasticity : 193 GPa
                                    3,  3,  4,    0,  -1,    0,  9e-4, 190e9, 0.75;
+
 
                                    4,  1,  4,    1,    0,    0,  9e-4, 190e9,  0.6;
+
Kemudian dilakukan perhitungan dengan menggunakan Excel sehingga diperoleh data sebagai berikut:
                                    5, 5,  6,    0,    1,    0,  9e-4, 190e9, 0.75;
+
 
                                    6,  6,  7,    1,    0,    0,  9e-4, 190e9, 0.6;
+
[[File:ElasticityLockedp.png]]
                                    7, 7,  8,    0,  -1,    0, 9e-4, 190e9, 0.75;
+
 
                                    8,  5,  8,    1,    0,    0,  9e-4, 190e9,  0.6;
+
Untuk harga besi siku yang digunakan saya mengambil referensi harga dari ''http://aspdistributor.blogspot.com/2016/11/harga-stainless-steel-siku-ss304.html''. (dalam link refernsi tersebut terdapat juga harga Stainless Steel SS316L meskipun pada URL hanya tertulis SS304)
                                    9,  9, 10,    0,    1,    0,  9e-4, 190e9, 0.75;
+
 
                                  10, 10, 11,    1,    0,    0,  9e-4, 190e9,  0.6;
+
Lalu selanjutnya dilakukan optimasi dan hasilnya adalah sebagai berikut:
                                  11, 11, 12,    0,  -1,    0, 9e-4, 190e9, 0.75;
+
 
                                  12,  9, 12,    1,    0,    0,  9e-4, 190e9,  0.6;
+
[[File:Xopttubesmaterialp.png]]
                                  13,  1,  5,    0,    0,    1,  9e-4, 190e9, 0.75;
+
 
                                  14, 2, 6,    0,    0,    1, 9e-4, 190e9, 0.75;
+
  '''Kesimpulan'''
                                  15,  3,  7,    0,    0,    1, 9e-4, 190e9, 0.75;
+
   
                                  16, 4, 8,    0,    0,    1, 9e-4, 190e9, 0.75;
+
  Dari optimasi diperoleh bahwa cross-sectional area yang optimal untuk struktur truss dalam tugas besar ini apabila materialnya adalah Stainless Steel SS316L adalah sebesar 0,0000890954m²
                                  17, 5, 9,   0,    0,    1,  9e-4, 190e9, 0.75;
+
 
                                  18, 6, 10,   0,    0,    1,  9e-4, 190e9, 0.75;
+
'''2. Area Locked'''
                                  19, 7, 11,   0,    0,    1, 9e-4, 190e9, 0.75;
+
 
                                  20,  8, 12,    0,   0,   1, 9e-4, 190e9, 0.75;
+
Dalam perhitungan ini cross-sectional area yang saya tentukan terlebih dahulu luasnya adalah 0,000171m² yang merupakan luas penampang dari besi siku dengan dimensi 30x30mm dengan ketebalan 3mm.
                                  21, 9, 13,    0,    0,    1,  9e-4, 190e9,  0.3;
+
 
                                  22, 10, 14,    0,    0,    1, 9e-4, 190e9,  0.3;
+
Kemudian dilakukan perhitungan dengan menggunakan Excel sehingga diperoleh data sebagai berikut:
                                  23, 11, 15,    0,    0,    1, 9e-4, 190e9,  0.3;
+
 
                                  24, 12, 16,    0,    0,    1, 9e-4, 190e9,  0.3];
+
[[File:AreaLockedjp.png]]
                                 
+
 
  parameter Integer [:,2] node = [ 1, 2;
+
Lalu selanjutnya dilakukan optimasi dan hasilnya adalah sebagai berikut:
                                  2, 3;
+
 
                                  3, 4;
+
[[File:Xopttubesareap.png]]
                                  1, 4;
+
 
                                  5, 6;
+
  '''Kesimpulan'''
                                  6, 7;
+
   
                                  7, 8;
+
  Dari optimasi diperoleh bahwa elastisitas yang optimal untuk struktur truss dalam tugas besar ini apabila cross-sectional areanya adalah sebesar 0,000171m² adalah sebesar 203,9366GPa dan material yang memiliki karakteristik yang paling mendekati adalah Stainless Steel SS201.
                                  5, 8;
+
 
                                  9, 10;
+
 
                                  10, 11;
+
'''Lampiran'''
                                  11, 12;
+
 
                                  9, 12;
+
'''Code'''
                                  1, 5;
+
 
                                  2, 6;
+
  '''TugasBesar_MetNum.mo'''
                                  3, 7;
+
   
                                  4, 8;
+
  model TugasBesar_MetNum
                                  5, 9;
+
   
                                  6, 10;
+
  //define initial variable
                                  7, 11;
+
  parameter Integer Points=size(P,1);   //Number of Points
                                  8, 12;
+
  parameter Integer Trusses=size(C,1);   //Number of Trusses
                                  9, 13;
+
  parameter Real Yield=290e6;   //Yield Strength (Pa)
                                  10, 14;
+
  parameter Real Area=0.000171;   //Area L Profile (Dimension=0.03, Thickness=0,003) (m2)
                                  11, 15;
+
  parameter Real Elas=193e9;     //Elasticity SS 316L (Pa)
                                  12, 16];
+
   
                                 
+
  //define connection
  parameter Integer y = size(node,1);
+
  parameter Integer C[:,2]=[1,5;  
    
+
                          2,6;
  parameter Integer x = 3*(size(node_load,1));
+
                          3,7;
    
+
                          4,8;
  parameter Integer z = size(Boundary,1);
+
                          5,6; //1st floor
    
+
                          6,7; //1st floor
  parameter Integer [:] Boundary = {13,14,15,16};
+
                          7,8; //1st floor
 +
                          5,8; //1st floor
 +
                          5,9;
 +
                          6,10;
 +
                          7,11;
 +
                          8,12;
 +
                          9,10; //2nd floor
 +
                          10,11;//2nd floor
 +
                          11,12;//2nd floor
 +
                          9,12; //2nd floor
 +
                          9,13;
 +
                          10,14;
 +
                          11,15;
 +
                          12,16;
 +
                          13,14;//3rd floor
 +
                          14,15;//3rd floor
 +
                          15,16;//3rd floor
 +
                          13,16];//3rd floor
 +
                                                             
 +
//define coordinates (please put orderly)
 +
parameter Real P[:,6]=[  0,    0,    0,  1,1,1;     //1
 +
                          0, 0.75,    0,   1,1,1;     //2
 +
                        0.6, 0.75,    0,   1,1,1;     //3
 +
                        0.6,    0,    0,   1,1,1;     //4
 
                                
 
                                
  parameter Real [:,4] node_load = [ 1, 0, 1000, 0;
+
                          0,    0, 0.35,   0,0,0;   //5
                                    2, 0, 1000, 0;
+
                          0, 0.75, 0.35,   0,0,0; //6
                                    3, 0,  500, 0;
+
                        0.6, 0.75, 0.350,0,0;   //7
                                    4, 0,  500, 0;
+
                        0.6,   0, 0.35,   0,0,0;   //8
                                    5, 0,     0, 0;
+
                           
                                    6, 0,     0, 0;
+
                          0,    0, 1.05,   0,0,0;   //9
                                    7, 0,     0, 0;
+
                          0, 0.75, 1.05,   0,0,0; //10 
                                    8, 0,     0, 0;
+
                        0.6, 0.75, 1.05,   0,0,0;   //11
                                    9, 0,     0, 0;
+
                        0.6,    0, 1.05,   0,0,0;   //12
                                    10, 0,     0, 0;
+
                           
                                    11, 0,     0, 0;
+
                          0,    0,  1.8,   0,0,0;   //13
                                    12, 0,     0, 0;
+
                          0, 0.75,  1.8,   0,0,0; //14
                                    13, 0,     0, 0;
+
                        0.6, 0.75, 1.8,   0,0,0;   //15
                                    14, 0,     0, 0;
+
                        0.6,   0, 1.8,   0,0,0];   //16
                                    15, 0,     0, 0;
+
                             
                                    16, 0,     0, 0];
+
//define external force (please put orderly)
                                   
+
parameter Real F[Points*3]={0,0,   0,
  parameter Real [x] load = {0, 1000, 0,  
+
                             0,0,   0,  
                             0, 1000, 0,  
+
                             0,0,   0,  
                             0, 500, 0,
+
                             0,0,   0,  
                             0, 500, 0,
+
                             0,0,   0,  
                             0,   0, 0,
+
                             0,0,   0,  
                             0,   0, 0,
+
                             0,0,   0,  
                             0,   0, 0,
+
                             0,0,   0,  
                             0,   0, 0,
+
                             0,0,   0,  
                             0,   0, 0,
+
                             0,0,   0,  
                             0,   0, 0,
+
                             0,0,   0,  
                             0,   0, 0,
+
                             0,0,   0,  
                             0,   0, 0,
+
                             0,0,-1000,  
                             0,   0, 0,
+
                             0,0, -500,  
                             0,   0, 0,
+
                             0,0, -500,  
                             0,   0, 0,  
+
                             0,0,-1000};
                             0,   0, 0};
+
                                 
+
//solution
  Real [y] k;
+
Real displacement[N], reaction[N];
 +
Real check[3];
 +
 +
Real stress1[Trusses];
 +
Real safety[Trusses];
 +
Real dis[3];
 +
Real Str[3];  
 
   
 
   
   Real [y,6,6] Ke;
+
protected
 +
parameter Integer N=3*Points;
 +
Real q1[3], q2[3], g[N,N], G[N,N], G_star[N,N], id[N,N]=identity(N), cx, cy, cz, L, X[3,3];
 +
Real err=10e-10, ers=10e-4;
 +
 +
algorithm
 +
//Creating Global Matrix
 +
G:=id;
 +
for i in 1:Trusses loop
 +
  for j in 1:3 loop
 +
    q1[j]:=P[C[i,1],j];
 +
    q2[j]:=P[C[i,2],j];
 +
   end for;
 +
       
 +
    //Solving Matrix
 +
    L:=Modelica.Math.Vectors.length(q2-q1);
 +
    cx:=(q2[1]-q1[1])/L;
 +
    cy:=(q2[2]-q1[2])/L;
 +
    cz:=(q2[3]-q1[3])/L;
 +
    X:=(Area*Elas/L)*[cx^2,cx*cy,cx*cz;
 +
                      cy*cx,cy^2,cy*cz;
 +
                      cz*cx,cz*cy,cz^2];
 
    
 
    
  Real [y,x,x] Kg;
+
    //Transforming to global matrix
 +
    g:=zeros(N,N);
 +
    for m,n in 1:3 loop
 +
      g[3*(C[i,1]-1)+m,3*(C[i,1]-1)+n]:=X[m,n];
 +
      g[3*(C[i,2]-1)+m,3*(C[i,2]-1)+n]:=X[m,n];
 +
      g[3*(C[i,2]-1)+m,3*(C[i,1]-1)+n]:=-X[m,n];
 +
      g[3*(C[i,1]-1)+m,3*(C[i,2]-1)+n]:=-X[m,n];
 +
    end for;
 
    
 
    
   Real [x,x] KgTot;
+
   G_star:=G+g;
 +
  G:=G_star;
 +
end for;
 
    
 
    
  Real [x,x] KgB;
+
//Implementing boundary
 +
for x in 1:Points loop
 +
  if P[x,4] <> 0 then
 +
    for a in 1:Points*3 loop
 +
      G[(x*3)-2,a]:=0;
 +
      G[(x*3)-2,(x*3)-2]:=1;
 +
    end for;
 +
  end if;
 +
  if P[x,5] <> 0 then
 +
    for a in 1:Points*3 loop
 +
      G[(x*3)-1,a]:=0;
 +
      G[(x*3)-1,(x*3)-1]:=1;
 +
    end for;
 +
  end if;
 +
  if P[x,6] <> 0 then
 +
    for a in 1:Points*3 loop
 +
      G[x*3,a]:=0;
 +
      G[x*3,x*3]:=1;
 +
    end for;
 +
  end if;
 +
end for;
 +
 +
//Solving displacement
 +
displacement:=Modelica.Math.Matrices.solve(G,F); 
 +
 +
//Solving reaction
 +
reaction:=(G_star*displacement)-F;
 +
 +
//Eliminating float error
 +
for i in 1:N loop
 +
  reaction[i]:=if abs(reaction[i])<=err then 0 else reaction[i];
 +
  displacement[i]:=if abs(displacement[i])<=err then 0 else displacement[i];
 +
end for;
 +
 +
//Checking Force
 +
check[1]:=sum({reaction[i] for i in (1:3:(N-2))})+sum({F[i] for i in (1:3:(N-2))});
 +
check[2]:=sum({reaction[i] for i in (2:3:(N-1))})+sum({F[i] for i in (2:3:(N-1))});
 +
check[3]:=sum({reaction[i] for i in (3:3:N)})+sum({F[i] for i in (3:3:N)});
 +
 
 +
for i in 1:3 loop
 +
  check[i] := if abs(check[i])<=ers then 0 else check[i];
 +
end for;
 +
 +
//Calculating stress in each truss
 +
for i in 1:Trusses loop
 +
  for j in 1:3 loop
 +
    q1[j]:=P[C[i,1],j];
 +
    q2[j]:=P[C[i,2],j];
 +
    dis[j]:=abs(displacement[3*(C[i,1]-1)+j]-displacement[3*(C[i,2]-1)+j]);
 +
  end for;
 +
       
 +
    //Solving Matrix
 +
    L:=Modelica.Math.Vectors.length(q2-q1);
 +
    cx:=(q2[1]-q1[1])/L;
 +
    cy:=(q2[2]-q1[2])/L;
 +
    cz:=(q2[3]-q1[3])/L;
 +
    X:=(Elas/L)*[cx^2,cx*cy,cx*cz;
 +
                  cy*cx,cy^2,cy*cz;
 +
                  cz*cx,cz*cy,cz^2];
 +
   
 +
    Str:=(X*dis);
 +
    stress1[i]:=Modelica.Math.Vectors.length(Str);
 +
end for;
 +
 +
//Safety factor
 +
for i in 1:Trusses loop
 +
  if stress1[i]>0 then
 +
    safety[i]:=Yield/stress1[i];
 +
  else
 +
    safety[i]:=0;
 +
  end if;
 +
end for;
 +
 +
end TugasBesar_MetNum;
 +
 
 +
'''CurveFitting.mo'''
 +
 +
class CurveFitting
 +
 +
parameter Real X[''jumlah plot'']={''plot''};
 +
parameter Real Y[''jumlah plot'']={''plot''};
 +
Real Coe[3];
 
    
 
    
  Real [x] U;
+
algorithm
 
+
Coe:=F_CurveFitting(X,Y,2);
  Real [x] R;
+
 
+
end CurveFitting;
  equation
+
 
  k = {(inisiasi[i,7] * inisiasi[i,8] / inisiasi[i,9]) for i in 1:y};
+
'''F_CurveFitting.mo'''
 +
 +
function F_CurveFitting
 +
 +
input Real X[:];
 +
input Real Y[size(X,1)];
 +
input Integer order=2;
 +
output Real Coe[order+1];
 +
 +
  protected
 +
  Real Z[size(X,1),order+1];
 +
Real ZTr[order+1,size(X,1)];
 +
Real A[order+1,order+1];
 +
Real B[order+1];
 +
 +
algorithm
 +
 +
for i in 1:size(X,1) loop
 +
  for j in 1:(order+1) loop
 +
  Z[i,j]:=X[i]^(order+1-j);
 +
  end for;
 +
end for;
 +
ZTr:=transpose(Z);
 
   
 
   
  Ke = MatriksKekakuanElemen(inisiasi);
+
  A:=ZTr*Z;
 +
B:=ZTr*Y;
 +
Coe:=Modelica.Math.Matrices.solve(A,B);
 
   
 
   
  Kg = MatriksKekakuanGlobal(node, x, y, Ke);
+
  end F_CurveFitting;
 +
 
 +
'''Golden Section'''
 
   
 
   
  KgTot = MatriksTotalKekakuanGlobal(x, y, Kg);
+
  model Opt_Gold
 
   
 
   
  KgB = MatriksKekakuanGlobalDenganBoundary(x, z, KgTot, Boundary);
+
  parameter Real xd[:];
 +
parameter Real yd[size(xd,1)];
 +
parameter Real xlo=87e-6;
 +
parameter Real xhi=504e-6;
 +
parameter Integer N=10; // maximum iteration
 +
parameter Real es=0.0001; // maximum error
 
   
 
   
  U = FungsiGaussJordan(x, KgB, load);
+
  Real f1[N], f2[N], x1[N], x2[N], ea[N], y[3];
 +
Real xopt,  fx;
 +
protected
 +
Real d, xl, xu, xint, R=(5^(1/2)-1)/2;
 
   
 
   
  R = FungsiReactionForce(x, KgTot, U, load);
+
  algorithm
 +
xl := xlo;
 +
xu := xhi;
 +
y  := Curve_Fitting(xd,yd);
 +
 
 +
for i in 1:N loop
 +
  d:= R*(xu-xl);
 +
  x1[i]:=xl+d;
 +
  x2[i]:=xu-d;
 +
  f1[i]:=y[1]*x1[i]^2+y[2]*x1[i]+y[3];
 +
  f2[i]:=y[1]*x2[i]^2+y[2]*x2[i]+y[3];
 +
  xint:=xu-xl;
 +
 
 +
  if f1[i]>f2[i] then
 +
    xl:=x2[i];
 +
    xopt:=x1[i];
 +
    fx:=f1[i];
 +
    else
 +
      xu:=x1[i];
 +
      xopt:=x2[i];
 +
      fx:=f2[i];
 +
  end if;
 +
 
 +
  ea[i]:=(1-R)*abs((xint)/xopt);
 +
  if ea[i]<es then
 +
    break;
 +
  end if;
 +
end for;
 
   
 
   
  end Kuis2MetNum;
+
  end Opt_Gold;
  
===Tugas Besar Metode Numerik===
+
==Ujian Akhir Semester==
Rangka yang dianalisis dalam tugas besar adalah sebagai berikut:
 
  
[[File:Rangkatugasbesarp.jpeg|720px|center]]
+
Berikut ini adalah jawaban saya untuk Ujian Akhir Semester Metode Numerik:
  
Dan berikut adalah keterangannya:
+
===Jawaban Ujian Akhir Semester===
  
[[File:Datatubesp.jpeg|720px|center]]
+
*'''Nomor 1'''
 +
[[File:Jawaban 1 JP.jpeg|600px]]
 +
*'''Nomor 2'''
 +
[[File:Jawaban 2 JP.jpeg|600px]]
 +
*'''Nomor 3'''
 +
[[File:Jawaban 3 JP.jpeg|600px]]
 +
*'''Nomor 4'''
 +
[[File:Jawaban 4 JP.jpeg|600px]]
 +
*'''Nomor 5'''
 +
[[File:Jawaban 5 JP.jpeg|600px]]
 +
*'''Nomor 6'''
 +
[[File:Jawaban 6 JP.jpeg|600px]]
 +
*'''Nomor 7'''
 +
[[File:Jawaban 7 JP.jpeg|600px]]
  
Untuk tugas besar ini saya mengasumsikan bahwa cross-sectional area dari truss sebagai variabel bebasnya dan nilai yang ingin diperoleh adalah harga-nya. Untuk harga besi siku yang digunakan saya mengambil referensi harga dari ''https://www.indonetwork.co.id/product/besi-siku-6401732''. Setelah mendapatkan harga dari besi siku tersebut, saya memasukannya kedalam excel dan melakukan curve fitting sehingga diperoleh hasil sebagai berikut:
+
*'''Coding OpenModelica'''
 +
'''UAS.mo'''
 +
model UAS  // John Patrick Anhar - 1806201062
 +
 +
//define initial variable
 +
parameter Integer Points=4; //Number of Points
 +
parameter Integer Trusses=3; //Number of Trusses
 +
parameter Real Yield=290e6; //Yield Strength (Pa)
 +
parameter Real Area=25;  //Area L Profile
 +
parameter Real Elas=193e9;    //Elasticity SS 316L  (Pa)
 +
 +
//define connection
 +
parameter Integer C[:,2]=[1,2;
 +
                          1,3;
 +
                          1,4];
 +
         
 +
//define coordinates (please put orderly)
 +
parameter Real P[:,6]=[  0,  0,  0,0,0,0;    //1
 +
                        6.5,6.5,  36.5,1,1,1;    //2
 +
                        6.5,6.5,  36.5,1,1,1;    //3
 +
                        6.5,6.5,  36.5,1,1,1];    //4
 +
                           
 +
//define external force (please put orderly)
 +
parameter Real F[Points * 3] = {0,0,0,0,3708180,0,0,3708180,0,0,3708180,0};
 +
 +
//solution
 +
Real displacement[N], reaction[N];
 +
Real check[3];
 +
 +
Real stress1[Trusses];
 +
Real safety[Trusses];
 +
Real dis[3];
 +
Real Str[3];
 +
 +
protected
 +
parameter Integer N=3*Points;
 +
Real q1[3], q2[3], g[N,N], G[N,N], G_star[N,N], id[N,N]=identity(N), cx, cy, cz, L, X[3,3];
 +
Real err=10e-10, ers=10e-4;
 +
 +
algorithm
 +
//Creating Global Matrix
 +
G:=id;
 +
for i in 1:Trusses loop
 +
  for j in 1:3 loop
 +
    q1[j]:=P[C[i,1],j];
 +
    q2[j]:=P[C[i,2],j];
 +
  end for;
 +
       
 +
    //Solving Matrix
 +
    L:=Modelica.Math.Vectors.length(q2-q1);
 +
    cx:=(q2[1]-q1[1])/L;
 +
    cy:=(q2[2]-q1[2])/L;
 +
    cz:=(q2[3]-q1[3])/L;
 +
    X:=(Area*Elas/L)*[cx^2,cx*cy,cx*cz;
 +
                      cy*cx,cy^2,cy*cz;
 +
                      cz*cx,cz*cy,cz^2];
 +
 
 +
    //Transforming to global matrix
 +
    g:=zeros(N,N);
 +
    for m,n in 1:3 loop
 +
      g[3*(C[i,1]-1)+m,3*(C[i,1]-1)+n]:=X[m,n];
 +
      g[3*(C[i,2]-1)+m,3*(C[i,2]-1)+n]:=X[m,n];
 +
      g[3*(C[i,2]-1)+m,3*(C[i,1]-1)+n]:=-X[m,n];
 +
      g[3*(C[i,1]-1)+m,3*(C[i,2]-1)+n]:=-X[m,n];
 +
    end for; 
 +
 
 +
  G_star:=G+g;
 +
  G:=G_star;
 +
end for;
 +
 
 +
//Implementing boundary
 +
for x in 1:Points loop
 +
  if P[x,4] <> 0 then
 +
    for a in 1:Points*3 loop
 +
      G[(x*3)-2,a]:=0;
 +
      G[(x*3)-2,(x*3)-2]:=1;
 +
    end for;
 +
  end if;
 +
  if P[x,5] <> 0 then
 +
    for a in 1:Points*3 loop
 +
      G[(x*3)-1,a]:=0;
 +
      G[(x*3)-1,(x*3)-1]:=1;
 +
    end for;
 +
  end if;
 +
  if P[x,6] <> 0 then
 +
    for a in 1:Points*3 loop
 +
      G[x*3,a]:=0;
 +
      G[x*3,x*3]:=1;
 +
    end for;
 +
  end if;
 +
end for; 
 +
 +
//Solving displacement
 +
displacement:=Modelica.Math.Matrices.solve(G,F);
 +
 +
//Solving reaction
 +
reaction:=(G_star*displacement)-F;
 +
 +
//Eliminating float error
 +
for i in 1:N loop
 +
  reaction[i]:=if abs(reaction[i])<=err then 0 else reaction[i];
 +
  displacement[i]:=if abs(displacement[i])<=err then 0 else displacement[i];
 +
end for;
 +
 +
//Checking Force
 +
check[1]:=sum({reaction[i] for i in (1:3:(N-2))})+sum({F[i] for i in (1:3:(N-2))});
 +
check[2]:=sum({reaction[i] for i in (2:3:(N-1))})+sum({F[i] for i in (2:3:(N-1))});
 +
check[3]:=sum({reaction[i] for i in (3:3:N)})+sum({F[i] for i in (3:3:N)});
 +
 
 +
for i in 1:3 loop
 +
  check[i] := if abs(check[i])<=ers then 0 else check[i];
 +
end for;
 +
 +
//Calculating stress in each truss
 +
for i in 1:Trusses loop
 +
  for j in 1:3 loop
 +
    q1[j]:=P[C[i,1],j];
 +
    q2[j]:=P[C[i,2],j];
 +
    dis[j]:=abs(displacement[3*(C[i,1]-1)+j]-displacement[3*(C[i,2]-1)+j]);
 +
  end for;
 +
       
 +
    //Solving Matrix
 +
    L:=Modelica.Math.Vectors.length(q2-q1);
 +
    cx:=(q2[1]-q1[1])/L;
 +
    cy:=(q2[2]-q1[2])/L;
 +
    cz:=(q2[3]-q1[3])/L;
 +
    X:=(Elas/L)*[cx^2,cx*cy,cx*cz;
 +
                  cy*cx,cy^2,cy*cz;
 +
                  cz*cx,cz*cy,cz^2];
 +
   
 +
    Str:=(X*dis);
 +
    stress1[i]:=Modelica.Math.Vectors.length(Str);
 +
end for;
 +
 +
//Safety factor
 +
for i in 1:Trusses loop
 +
  if stress1[i]>0 then
 +
    safety[i]:=Yield/stress1[i];
 +
  else
 +
    safety[i]:=0;
 +
  end if;
 +
end for;
 +
 +
end UAS;
 +
 
 +
dan setelah di-''simulate'' diperoleh hasil sebagai berikut:
 +
  [[File:Hasil Modellica JP.jpeg|600px]]

Revision as of 19:16, 13 January 2021

John Patrick Anhar

Biodata Diri

Nama : John Patrick Anhar

NPM  : 1806201062

TTL  : Jakarta, 21 Oktober 2000

Hobi : Berenang


Saya adalah mahasiswa FTUI angkatan 2018 dari jurusan Teknik Mesin dan saya adalah salah satu ciptaan terbaik dari Tuhan Yang Maha Esa, karena pada prinsipnya Tuhan Yang Maha Esa itu mendesain manusia dengan sebaik-baiknya makhluk.

Saya mengikuti kuliah Teknik Mesin karena saya menyukai bidang otomotif sejak saya masih kecil dan jurusan ini sangatlah berkaitan dengan bidang otomotif juga. Di jurusan Teknik Mesin ini ada banyak mata kuliah yang saya ikuti, salah satunya yaitu mata kuliah Metode Numerik.

Tujuan Mempelajari Metode Numerik

Tujuan dari mempelajari metode numerik adalah:

  • Memahami konsep dasar metode numerik dengan baik.
  • Mampu menerapkan konsep metode numerik.
  • Mampu menerapkan metode numerik untuk menyelesaikan berbagai persoalan teknik.
  • Mendapat nilai tambah/adab agar menjadi manusia yang beradab.

Metode Numerik

Saya telah mengikuti mata kuliah ini selama setengah semester bersama dengan Pak Engkos Achmad Kosasih dan saya sudah mempelajari beberapa hal, yaitu:

  • penyelesaian matematika menggunakan metode numerik
  • error-error dalam perhitungan secara numerik
  • turunan forward centered dan backward
  • cara-cara melakukan interpolasi dan regresi
  • cara mencari akar dari suatu persamaan secara numerik menggunakan: metode Newton-Raphson, metode Bisection, dan metode Secant.

Pertemuan Minggu 1 (11 November 2020)

Pada pertemuan minggu pertama ini, saya belajar bahwa sebagai manusia kita sebaiknya dapat mengetahui apa saja hal-hal yang kita pahami dan tidak kita pahami. Lalu berikutnya saya juga belajar bahwa komputer dapat membantu kita manusia untuk menyelesaikan berbagai persoalan. Namun meskipun teknologi komputer dan pengetahuan manusia saat ini sudah sangat berkembang, manusia dan komputer masih memiliki limitasi tertentu seperti contohnya tidak mampu menentukan nilai 1/0 dimana hanya Tuhan yang tahu nilainya. Oleh karena itu manusia tidak boleh melupakan Tuhan sebab hanya Tuhan yang Maha Tahu.

Tugas Minggu 1

Pada minggu ini, mahasiswa diberikan tugas untuk membuat video mengenai tutorial penggunaan software OpenModelica. Berikut ini video tutorial dasar-dasar penggunaan OpenModelica yang saya buat:


Pertemuan Minggu 2 (18 November 2020)

Pada pertemuan minggu kedua ini, kami diminta memberikan penjelasan mengenai apa yang sudah kami kerjakan pada pertemuan minggu pertama dan apa saja hal-hal yang sudah kami lakukan menggunakan OpenModelica.

Pada pertemuan ini juga kami dijelaskan oleh Pak Dai alasan mengapa aplikasi yang digunakan adalah OpenModelica dan bukan aplikasi lainnya seperti Python. Alasannya adalah karena OpenModelica merupakan aplikasi yang fungsi utamanya adalah modelling dan bukan programming, dimana sebenarnya modelling ini lebih tepat untuk seorang engineer. Simulasi yang dilakukan OpenModelica memang sedikit lebih lama dibandingkan aplikasi lainnya, karena bahasa yang ditulis di OpenModelica akan dikonversi terlebih dahulu kedalam bahasa C++ baru diproses datanya sebab OpenModelica tidak memiliki bahasa pemrograman tersendiri.

Lalu, kami pun diajarkan mengenai jenis-jenis file pada OpenModelica. Pada kesempatan kali ini kami mempelajari mengenai jenis file function dan file class. Contoh fungsi yang kami buat adalah sebagai berikut: FungsiTambahX1.mo

function FungsiTambahX1

input Real X;
output Real Y;

algorithm
Y:=X+10;

end FungsiTambahX1;

Lalu, kami juga diajarkan cara untuk memanggil fungsi tersebut ke dalam suatu class, yaitu contohnya seperti berikut ini:

Panggil.mo

class Panggil

parameter Real X1=5;
Real Hasil10TambahX1;

equation
Hasil10TambahX1=FungsiTambahX1(X1);

end Panggil;

Dalam fungsi 'FungsiTambahX1.mo' input nya adalah sebuah variabel misalnya X dan output dari fungsinya adalah Y yang merupakan hasil penjumlahan X+10. Ketika fungsi ini dipanggil ke class 'Panggil.mo', nilai input fungsi ini diisi dengan nilai X1.

Tugas Minggu 2

Pada minggu ini, mahasiswa diberikan tugas untuk mencoba memanggil suatu fungsi kedalam suatu class seperti yang sudah dicontohkan, namun menggunakan persamaan aljabar simultan dan variable array. Persamaan aljabar simultan merupakan persamaan yang kompleks dimana persamaan ini terdiri dari banyak variabel yang perlu dicari valuenya. Variable array merupakan kumpulan variabel yang disimpan dalam nama yang sama namun tetap memiliki nilai yang berbeda-beda.

Untuk itu, pada tugas ini saya akan mencoba menyelesaikan 4 persamaan dengan 4 variabel yang akan dicari nilai dari masing-masing variabel tersebut. Contoh yang saya ambil ialah sebagai berikut:

ContohSoalGauss2.png

Untuk menjawab persoalan tersebut pertama-tama saya membuat fungsi Gauss seperti berikut ini: FungsiGauss.mo

function FungsiGauss

input Real U[4,4];
input Real V[4];
output Real O[4];

algorithm
W:=Modelica.Math.Matrices.solve(U,V);

end FungsiGauss;

Fungsi tersebut saya panggil kedalam class berikut ini: ClassGauss.mo

class ClassGauss

parameter Real A[4,4]=[1,-4,2,3;2,1,3,-1;4,1,2,-3;3,-4,-2,2];
parameter Real B[4]={2,0,1,8};
Real O[4];

equation
O=FungsiGauss(A,B);

end ClassGauss;

Berikut video penjelasan yang saya buat:

Pada coding saya mengenai tugas tersebut, saya masih menggunakan fitur solve eliminasi Gauss yang memang sudah disediakan di openmodelica karena saya masih belajar untuk dapat menggunakan openmodelica.

Pertemuan Minggu 3 (25 November 2020)

Pada pertemuan kali ini, saya mempelajari banyak hal baru. Salah satunya yaitu belajar tentang cara membuat fungsi sendiri tanpa menggunakan fitur yang disediakan oleh OpenModelica. Pada kesempatan ini saya diberikan penjelasan oleh beberapa teman saya yaitu Josiah Enrico dan Christopher Salendu Erwin mengenai fungsi array dengan menggunakan metode Newton Raphson dan juga cara untuk membuat fungsi Gauss Jordan di OpenModelica dengan sangat jelas. Pseudocode fungsi yang dijelaskan oleh Christopher adalah sebagai berikut: GaussJordan.mo

function GaussJordan

input Real [:,:] A; //matrix yang ingin di OBE
output Real [:,:] B; //matrix yang sudah diproses OBE

protected // untuk local variable
Integer h = 1;    //pivot row
Integer k = 1;    //pivot column
Integer m = size(A,1); //Number of row
Integer n = size(A,2); //Number of column
Integer c = 0;
Integer max_row; // Row index of max number in pivot column

Real [:] pivot_column;
Real [:] pivot_row;
Real [:,:] temp_array;
Real r;

Real float_error = 10e-10;


algorithm

//input A ke matrix B 
B := A;

//dealing with error  
while h <= m and k <= n loop

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

//Mencari pivot 
  pivot_column:= {B[i,h] for i in h:m};
  
    //Mencari baris terbawah yang mempunyai nilai pivot terbesar
    c:=h-1;
    for element in pivot_column loop
      c:= c+1;
      if abs(element)== max(abs(pivot_column)) then
        max_row :=c;
      end if;
    end for;
    
  //Jika tidak ada pivot di kolom ini, pindah ke kolom selanjutnya
  if B[max_row,k] == 0 then
    k:=k+1;
   
  else 
    //tukar row h dengan max_row
    temp_array := B;
    temp_array[h] := B[max_row];
    temp_array[max_row] := B[h];
    B:= temp_array;
    
    //bagi pivot row dengan pivot number
     B[h] := B[h]/B[h,k];
     
     for i in (h+1) :m loop
       r := B[i,k]/B[h,k];
      
      B[i,k]:=0;
      
      for j in (k+1) : n loop
        B[i,j] := B[i,j]-B[h,j] * r;
      end for;
    end for;
    
    //pindah ke pivot column dan row selanjutnya
    h := h+1;
    k := k+1;
    
  end if;
  
end while;

// proses dari kanan atas
h :=m;
k :=n;

while h >=1 and k>=1 loop
  
  //dealing with error
  for i in 1:m loop
    for j in 1:n loop
      if abs(B[i,j]) <=float_error then
        B[i,j]:=0;
      end if;
    end for;
  end for; 

//mencari pivot 
    pivot_row := {B[h,i] for i in 1:k};
    
    //Get position index k of pivot 
    c := 0;
    for element in pivot_row loop
      c := c+1;
      if element <> 0 then
        break;
      end if;
    end for;
    k:= c;
    
  // jika tidak ada pivot, maka pindah ke row berikutnya
  if B[h,k] == 0 then 
    h:= h-1;
    
  else
    for i in 1:(h-1) loop
      r := B[i,k];
      B[i] := B[i] - B[h] *r;
    end for;
    
    //pindah ke pivot row dan column berikutnya
    h:=h+1;
    k:=k+1;
    
  end if;
  
end while;
    
     
end GaussJordan;

Tugas Minggu 3

Pada pertemuan minggu ini juga kami diberikan tugas untuk membuat program sederhana menggunakan OpenModelica untuk menyelesaikan suatu kasus terkait struktur seperti pada gambar berikut:

Pr3-1.png

Maka, saya membuatnya menggunakan cara seperti yang dicontohkan di buku untuk example 3.1 dan pseudocodenya seperti ini: Truss.mo

class Truss

parameter Real E=200e9;
parameter Real A=0.001;
Real L1=1;
Real L2=1;
Real L3=1.6;
Real L4=1.25;
Real L5=1.6; 

Real tetha1=DEGtoRAD(0); //DEGtoRAD untuk mengubah satuan sudut
Real tetha2=DEGtoRAD(0);
Real tetha3=DEGtoRAD(231.34);
Real tetha4=DEGtoRAD(270);
Real tetha5=DEGtoRAD(308.66);

Real U[8]; //Displacement
Real R[8]; //Reaction 

//Hitung K masing-masing Truss

//Truss1
Real [8,8] K1 = (E*A/L1)*
[(cos(tetha1))^2,(cos(tetha1)*sin(tetha1)),-(cos(tetha1))^2,-(cos(tetha1)*sin(tetha1)),0,0,0,0;
(cos(tetha1)*sin(tetha1)),(sin(tetha1))^2,-(cos(tetha1)*sin(tetha1)),-(sin(tetha1))^2,0,0,0,0;
-(cos(tetha1))^2,-(cos(tetha1)*sin(tetha1)),(cos(tetha1))^2,(cos(tetha1)*sin(tetha1)),0,0,0,0;
-(cos(tetha1)*sin(tetha1)),-(sin(tetha1))^2,(cos(tetha1)*sin(tetha1)),(sin(tetha1))^2,0,0,0,0;
0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0];

//Truss2
Real [8,8] K2 = (E*A/L2)*
[0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0;
0,0,(cos(tetha2))^2,(cos(tetha2)*sin(tetha2)),-(cos(tetha2))^2,-(cos(tetha2)*sin(tetha2)),0,0;
0,0,(cos(tetha2)*sin(tetha2)),(sin(tetha2))^2,-(cos(tetha2)*sin(tetha2)),-(sin(tetha2))^2,0,0;
0,0,-(cos(tetha2))^2,-(cos(tetha2)*sin(tetha2)),(cos(tetha2))^2,(cos(tetha2)*sin(tetha2)),0,0;
0,0,-(cos(tetha2)*sin(tetha2)),-(sin(tetha2))^2,(cos(tetha2)*sin(tetha2)),(sin(tetha2))^2,0,0;
0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0]; 

//Truss3
Real [8,8] K3 = (E*A/L3)*
[0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0;
0,0,0,0,(cos(tetha3))^2,(cos(tetha3)*sin(tetha3)),-(cos(tetha3))^2,-(cos(tetha3)*sin(tetha3));
0,0,0,0,(cos(tetha3)*sin(tetha3)),(sin(tetha3))^2,-(cos(tetha3)*sin(tetha3)),-(sin(tetha3))^2;
0,0,0,0,-(cos(tetha3))^2,-(cos(tetha3)*sin(tetha3)),(cos(tetha3))^2,(cos(tetha3)*sin(tetha3));
0,0,0,0,-(cos(tetha3)*sin(tetha3)),-(sin(tetha3))^2,(cos(tetha3)*sin(tetha3)),(sin(tetha3))^2];

//Truss4
Real [8,8] K4 = (E*A/L4)*
[0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0;
0,0,(cos(tetha4))^2,(cos(tetha4)*sin(tetha4)),0,0,-(cos(tetha4))^2,-(cos(tetha4)*sin(tetha4));
0,0,(cos(tetha4)*sin(tetha4)),(sin(tetha4))^2,0,0,-(cos(tetha4)*sin(tetha4)),-(sin(tetha4))^2;
0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0;
0,0,-(cos(tetha4))^2,-(cos(tetha4)*sin(tetha4)),0,0,(cos(tetha4))^2,(cos(tetha4)*sin(tetha4));
0,0,-(cos(tetha4)*sin(tetha4)),-(sin(tetha4))^2,0,0,(cos(tetha4)*sin(tetha4)),(sin(tetha4))^2];

//Truss5
Real [8,8] K5 = (E*A/L5)*
[(cos(tetha5))^2,(cos(tetha5)*sin(tetha5)),0,0,0,0,-(cos(tetha5))^2,-(cos(tetha5)*sin(tetha5));
(cos(tetha5)*sin(tetha5)),(sin(tetha5))^2,0,0,0,0,-(cos(tetha5)*sin(tetha5)),-(sin(tetha5))^2;
0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0;
0,0,0,0,0,0,0,0;
-(cos(tetha5))^2,-(cos(tetha5)*sin(tetha5)),0,0,0,0,(cos(tetha5))^2,(cos(tetha5)*sin(tetha5));
-(cos(tetha5)*sin(tetha5)),-(sin(tetha5))^2,0,0,0,0,(cos(tetha5)*sin(tetha5)),(sin(tetha5))^2];

//Buat ke KGlobal
Real KGlobal [8,8] = K1+K2+K3+K4+K5; 

//Masukkan Boundary Condition
Real KGlobalBoundary [8,8]=
[10^6,0,0,0,0,0,0,0;
0,10^6,0,0,0,0,0,0;
-2e7,0,4e7,38223.5,-2e7,0,-91.3155,-38223.5;
0,0,38223.5,1.5e7,0,0,-38223.5,-1e7;
0,0,0,0,10^6,0,0,0;
0,0,0,0,0,10^6,0,0;
-4e6,-6e6,-91.3155,-38223.5,-4e6,-6e6,9.7e6,51373.2;
6e6,-7e6,-38223.5,-1e7,-6e6,-7e6,51373.2,3.1e7];

//Karena 1 dan 3 static maka F1x,F1y,F3x,F3y = 0
//F2x=F*sin15
//F2y=F*cos15
//F4x=F*sin15
//F4y=F*cos15
Real F[8] = {0,0,-1035.276,3865.703,0,0,-1035.276,3863.703};

equation 

U=FungsiGaussJordan(KGlobalBoundary,F);

R=KGlobal*U-F;

end Truss;

Pseudocode fungsi DEGtoRAD: DEGtoRAD.mo

function DEGtoRAD
 input Real deg;
 output Real rad;
 protected
 constant Real pi = 3.14;
algorithm

rad:=deg*pi/180;

end DEGtoRAD;

Kemudian kami juga diminta untuk membuat pseudocode dari Fig. 9.4 di buku: NaiveGauss.mo

function NaiveGauss

input Real [3,3] A; 
input Real [3] B;   
output Real [3] x;  

protected
Real [3,3] a;
Real [3] b;
Integer m = size(A,1); // kolom 
Integer n = size(A,2); // baris
Real k = 1;      
Real i = 1;       
Real j = 1;       
Real factor = 1; 
Real sum = 1;     
algorithm

// Transfer input matrix (A,B) into variables (a,b)
a := A;
b := B;

// Forward Elimination
for k in 1:(n-1) loop
  for i in (k+1):n loop
    factor := a[i,k] / a[k,k];
    for j in (k+1):n loop
      a[i,j] := a[i,j] - (factor * a[k,j]);
    end for;
    b[i] := b[i] - (factor * b[k]);
  end for;
end for;

// Back Substitution
x[n] := b[n] / a[n,n];
for i in (n-1):(-1) loop
  sum := b[i];
  for j in (i+1):n loop
    sum := sum - (a[i,j] * x[j]);
  end for;
  x[i] := sum / a[i,i];
end for;

end NaiveGauss;

Lalu digunakan untuk menyelesaikan example 9.5


Ex95.mo

class Ex95

parameter Real A[3,3]=[3,-0.1,-0.2;
                       0.1,7,-0.3;
                       0.3,-0.2,10];
parameter Real B[3]={7.85,-19.3,71.4};
Real x[3];

equation
x=NaiveGauss(A,B);       
                       

end Ex95;

Pertemuan Minggu 4 (2 Desember 2020)

Pada pertemuan kali ini, saya diberikan kuis oleh Pak DAI untuk membuat class diagram & flowchart setiap class untuk coding yang dibuat oleh Josiah Enrico.

Kuis Diagram Class dan Flowchart

Q jp.jpg
Classdiajp.jpeg

Tugas Minggu 4

Pada pertemuan minggu ini, saya diberikan tugas oleh Pak DAI untuk mengerjakan soal berikut:

Soal8Metnum.jpeg

Berikut Free Body Diagram yang saya buat:

FBDpp.jpeg

Matriks ditulis dengan urutan sebagai berikut

Inisiasi : [{Truss} , {Node1} , {Node2} , {CosX} , {CosY} , {CosZ} , {A} , {E} , {L}]
Load : [{Node} , {Fx} , {Fy} , {Fz}]

Langkah pertama yaitu membuat Stiffness Matrix Element (per truss) seperti berikut:

StiffnessME.png

Berikutnya, dari matriks tersebut dibuat Stiffness Matrix Global berukuran 12x12 seperti berikut:

StiffnessMGlobal.png

Lalu langkah berikutnya yaitu menjumlahkan matriks global dari masing-masing elemen

SumStiffnessMGlobal.png

Selanjutnya menentukan boundaries

BoundariesStiffnessMGlobal.png

Lalu, mencari nilai displacement (U) menggunakan fungsi Gauss-Jordan

GaussJordanp.png

Selanjutnya untuk mencari nilai gaya reaksinya (R) digunakan fungsi berikut

GayaReaksi.png

Lalu dibuat class yang memproses semua fungsi

PRMetnumNo8.png

Setelah di simulate, diperoleh nilai displacement (U) dan gaya reaksi (R) sebagai berikut:

Up.png Rp.png


Berikut video penjelasan saya mengenai penyelesaian soal diatas:

Kelas Pengganti Minggu 5 (14 Desember 2020)

Kelas Metode Numerik seharusnya diadakan pada hari Rabu setiap minggunya. Namun, pada tanggal 9 Desember 2020 diadakan Pemilihan Kepala Daerah di seluruh Indonesia sehingga dijadikan hari libur nasional. Oleh karena itu pada pertemuan minggu ke 5 ini, diadakan kelas pengganti pada tanggal 23 Desember 2020. Pada minggu ini kami diminta untuk melakukan muhasabah dan melakukan penilaian terhadap kemampuan kami masing-masing mengenai pemahaman kami dalam aplikasi Metode Numerik secara sejujurnya. Kemudian kami juga diminta untuk menjelaskan pemahaman kami tersebut. Lalu, di akhir kelas ini juga kami diberikan tugas besar.

Pertemuan Minggu 6 (16 Desember 2020)

Aplikasi metode numerik dalam kasus optimasi

Pada hari ini kami akan mempelajari mengenai optimasi dengan menggunakan metode numerik. Optimasi adalah teknik untuk memperoleh nilai optimum dari suatu sistem. Topik optimasi kali ini akan dibawakan oleh Bu Candra. Metode optimasi yang digunakan adalah metode Golden Ratio Method. Dalam metode Golden Ratio akan dapat diperoleh nilai yang paling efisien dari suatu sistem. Pseudocode aplikasi metode Golden Ratio didalam openmodelica adalah sebagai berikut:

FungsiObjek.mo

function FungsiObjek
import Modelica.Math;
input Real x;
output Real y;

algorithm
y:= 2*Math.sin(x)-x^2/10;

end FungsiObjek;

Setelah membuat fungsi objek tersebut, kemudian akan dipanggil kedalam model seperti berikut ini:

Golden_Ratio.mo

model Golden_Ratio

parameter Integer n = 8;
Real x1[n];
Real x2[n];
Real xup;
Real xlow;
Real f1[n];
Real f2[n];
Real xopt;
Real yopt;
Real d;

algorithm
xup := 4;
xlow := 0;

for i in 1:n loop
 d:=((5^(1/2)-1)/2) * (xup-xlow);
 x1[i] := xlow+d;
 x2[i] := xup-d;
 f1[i] := FungsiObjek(x1[i]);
 f2[i] := FungsiObjek(x2[i]);

 if f1[i]>f2[i] then
   xup := xup;
   xlow := x2[i];
   xopt := xup;
   yopt := f1[i];
   else
     xlow :=xlow;
     xup := x1[i];
     xopt := xup;
 end if;
end for;


end Golden_Ratio;

Pertemuan Minggu 7 (23 Desember 2020)

Pada pertemuan ini, diadakan kuis dimana kami diminta untuk menghitung defleksi yang dialami oleh sistem yang menjadi tugas besar kami. Untuk menghitung defleksi ini, kami diminta untuk menyelesaikannya dengan menggunakan program yang sudah dibuat dan kemudian diupload.

Tugas Besar Metode Numerik

Latar Belakang

Optimasi merupakan suatu langkah yang dilakukan untuk mendapatkan nilai optimum. Dalam proses desain suatu objek, optimasi memegang peranan yang penting sebab dengan melakukan optimasi maka dapat diperoleh kualitas yang baik dengan harga yang serendah-rendahnya.


Tujuan

Memperoleh desain struktur truss terbaik dalam artian diperoleh harga yang serendah-rendahnya dengan kemampuan menahan beban yang sesuai dengan target.


Rangka yang dianalisis dalam tugas besar adalah sebagai berikut:

Rangkatugasbesarp.jpeg

Dan berikut adalah keterangannya:

Datatubesp.jpeg

Asumsi

-Truss yang bersentuhan dengan lantai fixed

-Lokasi beban F1 dan F2 berada di tengah dari truss sehingga beban terbagi menjadi dua pada sudutnya

-Tidak terjadi bending

Penomoran node dan ukuran tinggi dari truss ditunjukkan pada gambar berikut

KoordinatStrukturTubesp.jpg

Kemudian saya melakukan perhitungan Displacement dan Reaction Force dengan asumsi bahwa material yang digunakan adalah Stainless Steel SS316L dengan cross-sectional area sebesar 0,000171m² dan diperoleh hasil sebagai berikut

ReactionTubes.png DisplacementTubesp.png

dan juga diperoleh stress sebesar

StressTubesjp.png

Metodologi Pengerjaan

Untuk mengerjakan tugas besar ini, akan digunakan coding untuk dapat mengoptimasi material yang dapat menahan beban dengan baik (memiliki kekuatan tinggi dan safety factor yang baik dalam menahan beban yang diberikan) namun dengan harga yang paling baik.

Ada 2 metode yang digunakan untuk melakukan optimasi ini:

1. Menentukan jenis material yang digunakan terlebih dahulu dan kemudian melakukan perhitungan terhadap harga, safety factor, dan rasio perbandingan safety factor dengan harga dengan memvariasikan cross-sectional area yang berbeda-beda.

2. Menentukan cross-sectional area besi siku terlebih dahulu dan kemudian melakukan perhitungan terhadap harga, safety factor, dan rasio perbandingan safety factor dengan harga dengan memvariasikan material yang berbeda-beda.


Perhitungan

1. Elasticity Locked

Dalam perhitungan ini material yang saya tentukan terlebih dahulu adalah Stainless Steel SS316L yang propertiesnya sebagai berikut:

Material              : Stainless Steel SS316L

Yield Strength        : 290 MPa

Modulus of Elasticity : 193 GPa

Kemudian dilakukan perhitungan dengan menggunakan Excel sehingga diperoleh data sebagai berikut:

ElasticityLockedp.png

Untuk harga besi siku yang digunakan saya mengambil referensi harga dari http://aspdistributor.blogspot.com/2016/11/harga-stainless-steel-siku-ss304.html. (dalam link refernsi tersebut terdapat juga harga Stainless Steel SS316L meskipun pada URL hanya tertulis SS304)

Lalu selanjutnya dilakukan optimasi dan hasilnya adalah sebagai berikut:

Xopttubesmaterialp.png

Kesimpulan

Dari optimasi diperoleh bahwa cross-sectional area yang optimal untuk struktur truss dalam tugas besar ini apabila materialnya adalah Stainless Steel SS316L adalah sebesar 0,0000890954m²

2. Area Locked

Dalam perhitungan ini cross-sectional area yang saya tentukan terlebih dahulu luasnya adalah 0,000171m² yang merupakan luas penampang dari besi siku dengan dimensi 30x30mm dengan ketebalan 3mm.

Kemudian dilakukan perhitungan dengan menggunakan Excel sehingga diperoleh data sebagai berikut:

AreaLockedjp.png

Lalu selanjutnya dilakukan optimasi dan hasilnya adalah sebagai berikut:

Xopttubesareap.png

Kesimpulan

Dari optimasi diperoleh bahwa elastisitas yang optimal untuk struktur truss dalam tugas besar ini apabila cross-sectional areanya adalah sebesar 0,000171m² adalah sebesar 203,9366GPa dan material yang memiliki karakteristik yang paling mendekati adalah Stainless Steel SS201.


Lampiran

Code

TugasBesar_MetNum.mo

model TugasBesar_MetNum

//define initial variable
parameter Integer Points=size(P,1);    //Number of Points
parameter Integer Trusses=size(C,1);    //Number of Trusses
parameter Real Yield=290e6;    //Yield Strength (Pa)
parameter Real Area=0.000171;   //Area L Profile (Dimension=0.03, Thickness=0,003) (m2)
parameter Real Elas=193e9;     //Elasticity SS 316L  (Pa)

//define connection
parameter Integer C[:,2]=[1,5; 
                          2,6;
                          3,7;
                          4,8;
                          5,6;  //1st floor
                          6,7;  //1st floor
                          7,8;  //1st floor
                          5,8;  //1st floor
                          5,9;
                          6,10;
                          7,11;
                          8,12;
                          9,10; //2nd floor
                          10,11;//2nd floor 
                          11,12;//2nd floor
                          9,12; //2nd floor
                          9,13;
                          10,14;
                          11,15;
                          12,16;
                          13,14;//3rd floor
                          14,15;//3rd floor
                          15,16;//3rd floor
                          13,16];//3rd floor
                                                              
//define coordinates (please put orderly)
parameter Real P[:,6]=[  0,    0,    0,   1,1,1;     //1
                         0, 0.75,    0,   1,1,1;     //2
                       0.6, 0.75,    0,   1,1,1;     //3
                       0.6,    0,    0,   1,1,1;     //4
                              
                         0,    0, 0.35,   0,0,0;   //5
                         0, 0.75, 0.35,   0,0,0;  //6
                       0.6, 0.75, 0.35,   0,0,0;   //7
                       0.6,    0, 0.35,   0,0,0;    //8
                            
                         0,    0, 1.05,   0,0,0;   //9
                         0, 0.75, 1.05,   0,0,0;  //10  
                       0.6, 0.75, 1.05,   0,0,0;   //11
                       0.6,    0, 1.05,   0,0,0;    //12
                            
                         0,    0,  1.8,   0,0,0;   //13
                         0, 0.75,  1.8,   0,0,0;  //14
                       0.6, 0.75,  1.8,   0,0,0;   //15
                       0.6,    0,  1.8,   0,0,0];   //16
                             
//define external force (please put orderly)
parameter Real F[Points*3]={0,0,    0,
                            0,0,    0, 
                            0,0,    0, 
                            0,0,    0, 
                            0,0,    0, 
                            0,0,    0, 
                            0,0,    0, 
                            0,0,    0, 
                            0,0,    0, 
                            0,0,    0, 
                            0,0,    0, 
                            0,0,    0, 
                            0,0,-1000, 
                            0,0, -500, 
                            0,0, -500, 
                            0,0,-1000};  

//solution
Real displacement[N], reaction[N];
Real check[3]; 

Real stress1[Trusses];
Real safety[Trusses];
Real dis[3];
Real Str[3]; 

protected
parameter Integer N=3*Points;
Real q1[3], q2[3], g[N,N], G[N,N], G_star[N,N], id[N,N]=identity(N), cx, cy, cz, L, X[3,3];
Real err=10e-10, ers=10e-4;

algorithm
//Creating Global Matrix
G:=id;
for i in 1:Trusses loop
 for j in 1:3 loop
   q1[j]:=P[C[i,1],j];
   q2[j]:=P[C[i,2],j];
 end for;
       
    //Solving Matrix
    L:=Modelica.Math.Vectors.length(q2-q1);
    cx:=(q2[1]-q1[1])/L;
    cy:=(q2[2]-q1[2])/L;
    cz:=(q2[3]-q1[3])/L; 
    X:=(Area*Elas/L)*[cx^2,cx*cy,cx*cz;
                      cy*cx,cy^2,cy*cz;
                      cz*cx,cz*cy,cz^2];
 
    //Transforming to global matrix
    g:=zeros(N,N); 
    for m,n in 1:3 loop
      g[3*(C[i,1]-1)+m,3*(C[i,1]-1)+n]:=X[m,n];
      g[3*(C[i,2]-1)+m,3*(C[i,2]-1)+n]:=X[m,n];
      g[3*(C[i,2]-1)+m,3*(C[i,1]-1)+n]:=-X[m,n];
      g[3*(C[i,1]-1)+m,3*(C[i,2]-1)+n]:=-X[m,n];
    end for;  
 
 G_star:=G+g;
 G:=G_star;
end for;
 
//Implementing boundary
for x in 1:Points loop
  if P[x,4] <> 0 then
    for a in 1:Points*3 loop
      G[(x*3)-2,a]:=0;
      G[(x*3)-2,(x*3)-2]:=1;
    end for;
  end if;
  if P[x,5] <> 0 then
    for a in 1:Points*3 loop
      G[(x*3)-1,a]:=0;
      G[(x*3)-1,(x*3)-1]:=1;
    end for;
  end if;
  if P[x,6] <> 0 then
    for a in 1:Points*3 loop
      G[x*3,a]:=0;
      G[x*3,x*3]:=1;
    end for;
  end if;
end for; 

//Solving displacement
displacement:=Modelica.Math.Matrices.solve(G,F);  

//Solving reaction
reaction:=(G_star*displacement)-F;

//Eliminating float error
for i in 1:N loop
 reaction[i]:=if abs(reaction[i])<=err then 0 else reaction[i];
 displacement[i]:=if abs(displacement[i])<=err then 0 else displacement[i];
end for;

//Checking Force
check[1]:=sum({reaction[i] for i in (1:3:(N-2))})+sum({F[i] for i in (1:3:(N-2))});
check[2]:=sum({reaction[i] for i in (2:3:(N-1))})+sum({F[i] for i in (2:3:(N-1))});
check[3]:=sum({reaction[i] for i in (3:3:N)})+sum({F[i] for i in (3:3:N)});
  
for i in 1:3 loop
  check[i] := if abs(check[i])<=ers then 0 else check[i];
end for;

//Calculating stress in each truss
for i in 1:Trusses loop
 for j in 1:3 loop
   q1[j]:=P[C[i,1],j];
   q2[j]:=P[C[i,2],j];
   dis[j]:=abs(displacement[3*(C[i,1]-1)+j]-displacement[3*(C[i,2]-1)+j]);
 end for;
       
    //Solving Matrix
    L:=Modelica.Math.Vectors.length(q2-q1);
    cx:=(q2[1]-q1[1])/L;
    cy:=(q2[2]-q1[2])/L;
    cz:=(q2[3]-q1[3])/L; 
    X:=(Elas/L)*[cx^2,cx*cy,cx*cz;
                 cy*cx,cy^2,cy*cz;
                 cz*cx,cz*cy,cz^2];
    
    Str:=(X*dis);
    stress1[i]:=Modelica.Math.Vectors.length(Str);
end for;

//Safety factor
for i in 1:Trusses loop
  if stress1[i]>0 then
    safety[i]:=Yield/stress1[i];
  else
    safety[i]:=0;
  end if; 
end for;

end TugasBesar_MetNum;
CurveFitting.mo

class CurveFitting

parameter Real X[jumlah plot]={plot};
parameter Real Y[jumlah plot]={plot};
Real Coe[3];
 
algorithm
Coe:=F_CurveFitting(X,Y,2);

end CurveFitting;
F_CurveFitting.mo

function F_CurveFitting

input Real X[:];
input Real Y[size(X,1)];
input Integer order=2;
output Real Coe[order+1];

protected
Real Z[size(X,1),order+1];
Real ZTr[order+1,size(X,1)];
Real A[order+1,order+1];
Real B[order+1];

algorithm

for i in 1:size(X,1) loop
 for j in 1:(order+1) loop
 Z[i,j]:=X[i]^(order+1-j);
 end for;
end for;
ZTr:=transpose(Z);

A:=ZTr*Z;
B:=ZTr*Y;
Coe:=Modelica.Math.Matrices.solve(A,B);

end F_CurveFitting;
Golden Section

model Opt_Gold

parameter Real xd[:];
parameter Real yd[size(xd,1)];
parameter Real xlo=87e-6;
parameter Real xhi=504e-6; 
parameter Integer N=10; // maximum iteration
parameter Real es=0.0001; // maximum error

Real f1[N], f2[N], x1[N], x2[N], ea[N], y[3];
Real xopt,  fx;
protected
Real d, xl, xu, xint, R=(5^(1/2)-1)/2;

algorithm
xl := xlo; 
xu := xhi;
y  := Curve_Fitting(xd,yd);
 
for i in 1:N loop
 d:= R*(xu-xl);
 x1[i]:=xl+d;
 x2[i]:=xu-d;
 f1[i]:=y[1]*x1[i]^2+y[2]*x1[i]+y[3];
 f2[i]:=y[1]*x2[i]^2+y[2]*x2[i]+y[3];
 xint:=xu-xl;
 
 if f1[i]>f2[i] then
   xl:=x2[i];
   xopt:=x1[i];
   fx:=f1[i];
   else
     xu:=x1[i];
     xopt:=x2[i];
     fx:=f2[i];
 end if;
 
 ea[i]:=(1-R)*abs((xint)/xopt);
 if ea[i]<es then
   break;
 end if;
end for;

end Opt_Gold;

Ujian Akhir Semester

Berikut ini adalah jawaban saya untuk Ujian Akhir Semester Metode Numerik:

Jawaban Ujian Akhir Semester

  • Nomor 1
Jawaban 1 JP.jpeg
  • Nomor 2
Jawaban 2 JP.jpeg
  • Nomor 3
Jawaban 3 JP.jpeg
  • Nomor 4
Jawaban 4 JP.jpeg
  • Nomor 5
Jawaban 5 JP.jpeg
  • Nomor 6
Jawaban 6 JP.jpeg
  • Nomor 7
Jawaban 7 JP.jpeg
  • Coding OpenModelica
UAS.mo
model UAS   // John Patrick Anhar - 1806201062

//define initial variable
parameter Integer Points=4; //Number of Points
parameter Integer Trusses=3; //Number of Trusses
parameter Real Yield=290e6; //Yield Strength (Pa)
parameter Real Area=25;   //Area L Profile
parameter Real Elas=193e9;     //Elasticity SS 316L  (Pa) 

//define connection
parameter Integer C[:,2]=[1,2; 
                          1,3;
                          1,4];
         
//define coordinates (please put orderly)
parameter Real P[:,6]=[  0,   0,  0,0,0,0;     //1
                       6.5,6.5,  36.5,1,1,1;     //2
                       6.5,6.5,  36.5,1,1,1;     //3
                       6.5,6.5,  36.5,1,1,1];     //4
                            
//define external force (please put orderly)
parameter Real F[Points * 3] = {0,0,0,0,3708180,0,0,3708180,0,0,3708180,0}; 

//solution
Real displacement[N], reaction[N];
Real check[3]; 

Real stress1[Trusses];
Real safety[Trusses];
Real dis[3];
Real Str[3];

protected
parameter Integer N=3*Points;
Real q1[3], q2[3], g[N,N], G[N,N], G_star[N,N], id[N,N]=identity(N), cx, cy, cz, L, X[3,3];
Real err=10e-10, ers=10e-4; 

algorithm
//Creating Global Matrix
G:=id;
for i in 1:Trusses loop
 for j in 1:3 loop
   q1[j]:=P[C[i,1],j];
   q2[j]:=P[C[i,2],j];
 end for;
       
    //Solving Matrix
    L:=Modelica.Math.Vectors.length(q2-q1);
    cx:=(q2[1]-q1[1])/L;
    cy:=(q2[2]-q1[2])/L;
    cz:=(q2[3]-q1[3])/L; 
    X:=(Area*Elas/L)*[cx^2,cx*cy,cx*cz;
                      cy*cx,cy^2,cy*cz;
                      cz*cx,cz*cy,cz^2];
 
    //Transforming to global matrix
    g:=zeros(N,N); 
    for m,n in 1:3 loop
      g[3*(C[i,1]-1)+m,3*(C[i,1]-1)+n]:=X[m,n];
      g[3*(C[i,2]-1)+m,3*(C[i,2]-1)+n]:=X[m,n];
      g[3*(C[i,2]-1)+m,3*(C[i,1]-1)+n]:=-X[m,n];
      g[3*(C[i,1]-1)+m,3*(C[i,2]-1)+n]:=-X[m,n];
    end for;  
 
 G_star:=G+g;
 G:=G_star;
end for;
 
//Implementing boundary
for x in 1:Points loop
  if P[x,4] <> 0 then
    for a in 1:Points*3 loop
      G[(x*3)-2,a]:=0;
      G[(x*3)-2,(x*3)-2]:=1;
    end for;
  end if;
  if P[x,5] <> 0 then
    for a in 1:Points*3 loop
      G[(x*3)-1,a]:=0;
      G[(x*3)-1,(x*3)-1]:=1;
    end for;
  end if;
  if P[x,6] <> 0 then
    for a in 1:Points*3 loop
      G[x*3,a]:=0;
      G[x*3,x*3]:=1;
    end for;
  end if;
end for;  

//Solving displacement
displacement:=Modelica.Math.Matrices.solve(G,F); 

//Solving reaction
reaction:=(G_star*displacement)-F; 

//Eliminating float error
for i in 1:N loop
 reaction[i]:=if abs(reaction[i])<=err then 0 else reaction[i];
 displacement[i]:=if abs(displacement[i])<=err then 0 else displacement[i];
end for; 

//Checking Force
check[1]:=sum({reaction[i] for i in (1:3:(N-2))})+sum({F[i] for i in (1:3:(N-2))});
check[2]:=sum({reaction[i] for i in (2:3:(N-1))})+sum({F[i] for i in (2:3:(N-1))});
check[3]:=sum({reaction[i] for i in (3:3:N)})+sum({F[i] for i in (3:3:N)});
  
for i in 1:3 loop
  check[i] := if abs(check[i])<=ers then 0 else check[i];
end for; 

//Calculating stress in each truss
for i in 1:Trusses loop
 for j in 1:3 loop
   q1[j]:=P[C[i,1],j];
   q2[j]:=P[C[i,2],j];
   dis[j]:=abs(displacement[3*(C[i,1]-1)+j]-displacement[3*(C[i,2]-1)+j]);
 end for;
       
    //Solving Matrix
    L:=Modelica.Math.Vectors.length(q2-q1);
    cx:=(q2[1]-q1[1])/L;
    cy:=(q2[2]-q1[2])/L;
    cz:=(q2[3]-q1[3])/L; 
    X:=(Elas/L)*[cx^2,cx*cy,cx*cz;
                 cy*cx,cy^2,cy*cz;
                 cz*cx,cz*cy,cz^2];
    
    Str:=(X*dis);
    stress1[i]:=Modelica.Math.Vectors.length(Str);
end for; 

//Safety factor
for i in 1:Trusses loop
  if stress1[i]>0 then
    safety[i]:=Yield/stress1[i];
  else
    safety[i]:=0;
  end if; 
end for; 

end UAS;
 

dan setelah di-simulate diperoleh hasil sebagai berikut:

 Hasil Modellica JP.jpeg