Metnum03-Samuel Sitompul

Biodata

Nama: Samuel Albert B C H Sitompul

NPM : 1606907556

Hobi: Membaca Buku

Pertemuan Minggu Kedua Metode Numerik 03 (16 November 2020)

Pada pertemuan kedua kali ini, Kami diminta oleh Pak Dai untuk menunjukkan pemahaman kami mengenai tugas minggu lalu, yaitu mempelajari OpenModelica. Lalu kami melakukan simulasi dengan membuat program sederhana didalam OpenModelica untuk menjumlahkan 10 angka pada variabel.

Setelah kelas, Pak Dai memberikan tugas kepada kita untuk membuat simulasi untuk menyelesaikan persamaan aljabar simultan (bisa metode eliminasi gauss, metode gauss seidel, dsb.) Berikut adalah hasil percobaan saya untuk menyelesaikan sistem persamaan aljabar. Untuk simulasi ini, saya menggunakan metode eliminasi gauss untuk menyelesaikan permasalahan aljabar simultan.

Metode eliminasi gauss merupakan salah satu metode dalam menyelesaikan sebuah sistem persamaan dengan mengubah sistem persamaan tersebut kedalam bentuk matrix. Setelah diubah, lalu matrix yang berisi angka dipindah-ruaskan lalu diselesaikan sehingga didapat nilai-nilai dari variabel yang kita cari.

Berikut adalah model simulasi yang saya buat:

Saya mencoba menyelesaikan 5 sistem persamaan linier dengan metode eliminasi gauss dengan perintah "Modelica.Math.Matrices.solve(A,b)". Setelah melakukan pengecekan model, saya menjalankan simulasi dan melakukan plotting seusai simulasi. Berikut adalah hasil plotting tersebut:

dapat dilihat bahwa tiap garis menunjukkan penyelesaian dari sistem persamaan tersebut. Terdapat 5 solusi dari 5 sistem persamaan dengan 5 variabel

Pertemuan Minggu Ketiga Metode Numerik 03 (23 November 2020)

Di pertemuan hari ini, Pak Dai menjelaskan tentang aplikasi metode numerik untuk permasalahan-permasalahan teknik. Salah satunya adalah permasalahan sistem pegas-massa.

Setelah kelas, Pak Dai memberikan tugas untuk menyelesaikan soal berikut:

Untuk menyelesaikan soal ini perlu dilakukan pengelompokan menjadi node dan elemen seperti pada tabel berikut:

lalu perlu dilakukan perhitungan nilai kekakuan pada elemen. Untuk elemen 1,3,5, dan 6 nilai kekakuannya adalah 4,22 x 10^5 lb/in. sedangkan untuk elemen 2, dan 4 nilai kekakuannya adalah 2,98 x 10^5 lb/in.

setelah itu perlu dilakukan analisis kekakuan pada tiap elemen dalam matriks koordinat global, kemudian dijumlahkan untuk mendapatkan K global. berikut adalah hasil penjumlahan dari nilai kekakuan tiap elemen:

disederhanakan menjadi

setelah mendapat matriks kekakuan, diterapkan kondisi batas dan beban. Untuk node 1 dan 3 adalah fixed, maka U1X=0, U1Y=0, U3X=0, U3Y=0 dan beban diberikan pada node 4 dan 5 sebesar F4Y= -500lb dan F5Y= -500lb

dengan menggunakan Hukum Hooke yaitu F=k.x, maka didapatkan persamaan defleksi menjadi

Persamaan diatas kemudian diselesaikan dengan OpenModelica, berikut saya lampirkan coding yang saya buat

setelah melakukan pengecekan dan simulasi, saya melakukan plotting. berikut hasil plotting simulasi tersebut.

hasil dapat dilihat pada panel di bagian kanan bawah gambar.

Untuk mendapatkan gaya reaksi, persamaannya adalah:

{R}=[K].{U}-{F}

diterapkan matriks-matriks yang sudah diketahui, didapat:

Persamaan diatas dapat diselesaikan oleh openmodelica. berikut adalah coding yang saya buat

hasil simulasi tersebut di plot sebagai berikut:

nilai R tiap node dapat dilihat di bagian kanan bawah gambar

QUIZ I METODE NUMERIK (30 November 2020)

Pada pertemuan minggu ke IV hari ini, Pak Dai mengadakan kuis untuk menguji kemampuan inidvidu kami, para peserta diberikan 2 buah soal kuis dan diminta untuk menuliskan flowchartynya. Berikut merupakan kedua soal kuisnya.

dan berikut merupakan tampilan flowchart pengerjaan sebagai jawaban soal kuis tersebut yang telah saya buat. Mengingat alur pengerjaan kedua soal tersebut hampir sama, maka tampilan flowchart tersebut merepresentasikan keduanya.

Tugas

Soal no.4

untuk soal nomor 4, langkah pertama yang dilakukan adalah mendefinisikan node dan elemen sebagai berikut

Lalu mencari nilai kekakuan dari tiap elemen

- elemen 1,2

 k=AE/L=(10 x 10^-4)(200 x 10^9)/1= 2 x 10^8 

- elemen 3

 k=AE/L=(10 x 10^-4)(200 x 10^9)/1,25= 1,6 x 10^8 

- elemen 4,5

 k=AE/L=(10 x 10^-4)(200 x 10^9)/1,6= 1,25 x 10^8

Lalu membuat matriks kekakuan untuk tiap elemen

- elemen 1,2

- elemen 3

- elemen 4,5

setelah membuat matriks lokal, diubah menjadi matriks global

setelah membuat matriks global, dilakukan penjumlahan untuk semua matriks global

300px

diketahui kondisi batas:

 U1X=0, U1Y=0, U3X=0, U3Y=0

diketahui gaya eksternal di titik 2 dan 4

 F2X=F4X=0.01827698159; F2Y=F4Y=3.999958244

dengan persamaan F=k.x, maka didapatkan

namun karena pada titik 1 dan 3 tidak bergerak, maka baris dan kolom 1,2,5,6 dihilangkan

persamaan diatas lalu diselesaikan dengan metode eliminasi gauss oleh openmodelica

 U2X=0,018277 ; U2Y=3.99996 ; U4X=0,018277 ; U4Y=3.99996

lalu untuk mencari gaya reaksi, digunakan persamaan

R=[K]{U}-{F}

berikut penyelesaian menggunakan openmodelica

terdapat permasalahan pada software openmodelica yang belum bisa saya temui pemecahannya, sehingga tidak dapat menyelesaikan persamaan tersebut.

Pertemuan 7 Desember 2020

pemanfaatan fungsi input automatis unutk mengurangi kesalahan input manual, berikut beberapa gambaran alur proses coding. ==>oleh edward josua, melihat codingnya josiah.

• banyak digunakan fungsi panggil dalam algoritma ini, diantaranya unutk mencari kekakuan , mencari matriks reaksi, serta untuk eliminasi gauss jordan, sehingga fungsi lebih simpel

• kemudain algoritma terdiri dari matriks lokal kemudian di gunakan fungsi stiffness yang dapat menjumlahkan matriks global , lokal. sehingga didaptkan jumlah matriks global. kemudain diterapkan booundary condition, boundary condition sebagai parameter untuk loop function

• kemudian digunakan fungsi gauss jordan untuk menenutkan defleksi, hasil komputasi di bentuk dalam matriks defleksi, kemudain dimasukan kedalamfunsi reaction trusses sehingga didapatkan solusi.

Dari penjelasan Ahmad Mohammad Fahmi,

gambar berikut menunjukan kembali alur proses pemikiran coding dari tugas trusses ini.

• fahmi menjelaskan juga dengan class yang sesuai akan mempermudah penyusunan coding karena akan di gunakan banyak proses looping untuk menghitung nilai defleksinya.

Kesimpulan tugas,

• menerapkan yang di coding oleh fahmi,kemudian menambahkan coding utnuk mengecek hasi sigam Fx Fy Fz, sehingga hasil lebih akurat(perhitungan coding tidak salah).

• menggunakan contoh soal dari pak dai yang di kirim di whatsapp;

• Mengupdate dan menulis di wiki, kemudian memberikan masukan untuk menyempurnakan coding tersebut.

Tugas 05

- Fungsi Matriks Elemen (Stiffness Matrix Element)

  function StiffnessMatrixElement
    input Real [:,6] inisiasi_mat;
    output Real [size(inisiasi_mat,1),6,6] Ke_mat;
   protected
    Real cos_x;
    Real cos_y; 
    Real [6] StiffTrig; 
    Real [6,6] StiffTrans;
    Real [size(inisiasi_mat,1)] k_vec;
  algorithm
    L := {(sqrt(inisiasi_mat[i,2]^2 + inisiasi_mat[i,3]^2 + inisiasi_mat[i,4]^2)) for i in 1:size(inisiasi_mat,1)};
    k_vec := {(inisiasi_mat[i,5] * inisiasi_mat[i,6] / L[i]) for i in 1:size(inisiasi_mat,1)};
    for i in 1:size(inisiasi_mat,1) loop
     StiffTrig := zeros(6);
     StiffTrans := zeros(6,6);
     cos_x := inisiasi_mat[i,2]/L[i];
     cos_y := inisiasi_mat[i,3]/L[i];
     cos_z := inisiasi_mat[i,4]/L[i];
     StiffTrig := {(cos_x)^2,
                   (cos_y)^2,
                   (cos_z)^2,
                   (cos_x*cos_y),
                   (cos_x*cos_z),
                   (cos_y*cos_z)};
     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]];
   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;

- Stiffness Matrix Global
  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
     Kg_mat:=zero(size(ke_mat,1),3*x,3*x);
    for i in 1:size(Ke_mat,1) 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;

- Sum of Stiffness Matrix Global
  function SumStiffnessMatrixGlobal
    input Real [:,:,:] Kg_mat;
    output Real [size(Kg_mat,2),size(Kg_mat,2)] KgTot_mat;
   algorithm
    for a in 1:size(Kg_mat,2) loop
     for b in 1:size(Kg_mat,2) loop
      KgTot_mat[a,b] := sum(Kg_mat [:,a,b]);
     end for;
    end for;
  end SumStiffnessMatrixGlobal;

- Implement Boundary Condition
  function BoundaryStiffnessMatrixGlobal
    input Real [:,:] KgTot_met;
    input Integer[:] Boundary_xyz;
    input Integer[:] Boundary_xy;
    input Integer[:] Boundary_xz;
    input Integer[:] Boundary_yz;
    input Integer[:] Boundary_x;
    input Integer[:] Boundary_y;
    input Integer[:] Boundary_z;
    output Real [size(KgTot_met,1),size(KgTot_met,1)] KgB_met;
   algorithm
    for a in 1:size(KgTot_met,1) loop
     for b in 1:size(KgTot_met,1) loop
      KgB_met[a,b] := KgTot_met [a,b];
     end for;
    end for; 
    if Boundary_xyz[1] <> 0 then
     for i in 1:size(KgTot_met,1) loop
      for a in 1:size(Boundary_xyz,1) loop
       for b in 0:2 loop
        KgB_met[3*(Boundary_xyz[a])-b,i]:=0;
        KgB_met[3*Boundary_xyz[a]-b,3*Boundary_xyz[a]-b]:=1;
       end for;
      end for;
     end for;
    end if;
    if Boundary_xy[1] <> 0 then
     for i in 1:size(KgTot_met,1) loop
      for a in 1:size(Boundary_xy,1) loop
       for b in 1:2 loop
        KgB_met[3*(Boundary_xy[a])-b,i]:=0;
        KgB_met[3*Boundary_xy[a]-b,3*Boundary_xy[a]-b]:=1;
       end for;
      end for;
     end for;
    end if;
    if Boundary_xz[1] <> 0 then
     for i in 1:size(KgTot_met,1) loop
      for a in 1:size(Boundary_xz,1) loop
       for b in 0:2:2 loop
        KgB_met[3*(Boundary_xz[a])-b,i]:=0;
        KgB_met[3*Boundary_xz[a]-b,3*Boundary_xz[a]-b]:=1;
       end for;
      end for;
     end for;
    end if;
    if Boundary_yz[1] <> 0 then
     for i in 1:size(KgTot_met,1) loop
      for a in 1:size(Boundary_yz,1) loop
       for b in 0:1 loop
        KgB_met[3*(Boundary_yz[a])-b,i]:=0;
        KgB_met[3*Boundary_yz[a]-b,3*Boundary_yz[a]-b]:=1;
       end for;
      end for;
     end for;
    end if;
    if Boundary_x[1] <> 0 then
     for i in 1:size(KgTot_met,1) loop
      for a in 1:size(Boundary_x,1) loop
       KgB_met[3*(Boundary_x[a])-2,i]:=0;
       KgB_met[3*Boundary_x[a]-2,3*Boundary_x[a]-2]:=1;
      end for;
     end for;
    end if;
    if Boundary_y[1] <> 0 then
     for i in 1:size(KgTot_met,1) loop
      for a in 1:size(Boundary_y,1) loop
       KgB_met[3*(Boundary_y[a])-1,i]:=0;
       KgB_met[3*Boundary_y[a]-1,3*Boundary_y[a]-1]:=1;
      end for;
     end for;
    end if;
    if Boundary_z[1] <> 0 then
     for i in 1:size(KgTot_met,1) loop
      for a in 1:size(Boundary_z,1) loop
       KgB_met[3*Boundary_z[a],i]:=0;
       KgB_met[3*Boundary_z[a],3*Boundary_z[a]]:=1;
      end for;
     end for;
    end if;
  end BoundaryStiffnessMatrixGlobal;

- Gauss-Jordan
  function GaussJordan
    input Real [:,:] KgB_met;
    input Real [size(KgB_met,1)] load_met;
    output Real [size(KgB_met,1)] U_met;
   protected
    Real float_error = 10e-10;
   algorithm
    U_met:=Modelica.Math.Matrices.solve(KgB_met,load_met);
    for i in 1:size(KgB_met,1) loop
     if abs(U_met[i]) <= float_error then
      U_met[i] := 0;
     end if;
    end for;
  end GaussJordan;

- Reaction Force
  function ReactionForce
     input Integer x;
     input Real [:,:] KgTot_met;
     input Real [size(KgTot_met,1)] U_met;
     input Real [size(KgTot_met,1)] load_met;
     output Real [x] R_met;
     protected Real float_error = 10e-10;
   algorithm
     R_met := (KgTot_met*U_met)-load_met;
    for t in 1:size(KgTot_met,1) loop
     if abs(R_met[t]) <= float_error then
      R_met[t] := 0;
     end if;
    end for;
  end ReactionForce;

- Pengecekan kesetimbangan gaya (resultan gaya = 0)
 function CheckForce
   input Real [:] load;
   input Real [size(load,1)] R;
   output Real [3] F;
  protected Real float_error = 10e-10;
  protected
   Real load_x;
   Real load_y;
   Real load_z;
   Real R_x;
   Real R_y;
   Real R_z;
  algorithm
   load_x := sum({load[i] for i in 1:3:(size(load,1)-2)});
   load_y := sum({load[i] for i in 2:3:(size(load,1)-1)});
   load_z := sum({load[i] for i in 3:3:size(load,1)});
   R_x := sum({R[i] for i in 1:3:(size(load,1)-2)});
   R_y := sum({R[i] for i in 2:3:(size(load,1)-1)});
   R_z := sum({R[i] for i in 3:3:size(load,1)});
   F[1] := load_x + R_x;
   F[2] := load_y + R_y;
   F[3] := load_z + R_z;
  for i in 1:3 loop
   if abs(F[i]) <= float_error then
    F[i] := 0;
   end if;
  end for;
 end CheckForce;

Pertemuan 14 Desember 2020 , Muhasabah Pribadi

pada pertemuan ini pak dai memberikan arahan kepada para mahasiswa tentang nilai pribadi masing-masing, dimana pada masa seperti ini orang  -orang selalu mempentingkan nilai yang didapat deibandingkan ilmu yang dimiliki.

• Muhasabah*

saya melihat dalam diri saya selama waktu pembelajaran Kuliah Metode Numerik saya selalu mengikuti Konsep berpikir dan alur/ flowchart dalam menyelesaikan sebuah masalah, pada mata kuilah ini materi atau konsep dasar sudah saya pahami dan mengerti seperti tentang truss, konsep statika struktur dari truss dapat saya mangerti.

Namun Karena basic coding saya kurang saya belum begitu bisa untuk menerjemahkan hasil pemikiran saya tersebut dalam bentuk coding, kemudian hal-hal seperti konsep berpikir looping sudah bisa saya pahami sebgainnya namun masih dikarenakan kurangnya basic coding menyebabjan saya kurang bisa menginrtpretasikan pemikiran saya tesebut ke dalam bentuk coding,

Menimbang hal tersebut saya