Difference between revisions of "Metnum03-Muhammad Bagus Pratama"

From ccitonlinewiki
Jump to: navigation, search
(→‎Tugas Besar)
(→‎UAS METODE NUMERIK)
 
(13 intermediate revisions by the same user not shown)
Line 325: Line 325:
  
 
4.Parameter yang kita ambil untuk Ke adalah Theta, StiffTrig, Stifftrans, k_vec, dan Floating error.
 
4.Parameter yang kita ambil untuk Ke adalah Theta, StiffTrig, Stifftrans, k_vec, dan Floating error.
 +
 +
Dan ini adalah hasil coding dari Ahmad Muhammad Fahmi yang saya pelajari :
 +
 +
{| class="wikitable"
 +
|-
 +
| style='border-style: none  none  solid  solid;' |
 +
'''Stiffness Matrix Element Function'''
 +
 +
  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 cos_z;
 +
    Real [6] StiffTrig;
 +
    Real [6,6] StiffTrans;
 +
    Real [size(inisiasi_mat,1)] L;
 +
    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)};
 +
  // 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,2]/L[i];
 +
    cos_y := inisiasi_mat[i,3]/L[i];
 +
    cos_z := inisiasi_mat[i,4]/L[i];
 +
  // {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;
 +
 +
|}
 +
 +
{| class="wikitable"
 +
|-
 +
| style='border-style: none  none  solid  solid;' |
 +
'''Stiffness Matrix Global Function'''
 +
 +
function StiffnessMatrixGlobal
 +
  input Integer x;
 +
  input Integer [:,2] n;
 +
  input Real [:,6,6] Ke_mat;
 +
  output Real [size(Ke_mat,1),3*x,3*x] Kg_mat;
 +
algorithm
 +
  Kg_mat := zeros(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;
 +
 +
|}
 +
 +
{| class="wikitable"
 +
|-
 +
| style='border-style: none  none  solid  solid;' |
 +
''' Sum Stiffness Matrix Element Function'''
 +
 +
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;
 +
 +
|}
 +
 +
{| class="wikitable"
 +
|-
 +
| style='border-style: none  none  solid  solid;' |
 +
''' Boundary Stiffness Matrix Global Function'''
 +
 +
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;
 +
 +
|}
 +
 +
{| class="wikitable"
 +
|-
 +
| style='border-style: none  none  solid  solid;' |
 +
'''Gauss Jordan Function'''
 +
 +
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;
 +
 +
|}
 +
 +
{| class="wikitable"
 +
|-
 +
| style='border-style: none  none  solid  solid;' |
 +
'''Reaction Force Function'''
 +
 +
function ReactionForce
 +
  input Real [:,:] KgTot_met;
 +
  input Real [size(KgTot_met,1)] U_met;
 +
  input Real [size(KgTot_met,1)] load_met;
 +
  output Real [size(KgTot_met,1)] 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;
 +
 +
|}
 +
 +
{| class="wikitable"
 +
|-
 +
| style='border-style: none  none  solid  solid;' |
 +
'''Check Force Function'''
 +
 +
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;
 +
 +
|}
 +
 +
 +
 +
{| class="wikitable"
 +
|-
 +
| style='border-style: none  none  solid  solid;' |
 +
'''Class'''
 +
 +
class QuizSoal1
 +
  //inisiasi = [ elemen#, dX, dY, dZ, A, E]
 +
  parameter Real [:,6] inisiasi = [1,  6,  0, -3, 1.56, 10.6e6; //isi sesuai data
 +
                                  2,  0,  0, -6, 1.56, 10.6e6;
 +
                                  3,  0,  6, -3, 1.56, 10.6e6;
 +
                                  4, -6,  0, -3, 1.56, 10.6e6;
 +
                                  5, -6,  6,  0, 1.56, 10.6e6;
 +
                                  6,  0,  6,  3, 1.56, 10.6e6];
 +
 +
  //node = [ i, j]                               
 +
  parameter Integer [size(inisiasi,1),2] node = [1, 2; //isi sesuai data
 +
                                                1, 3;
 +
                                                1, 4;
 +
                                                2, 3;
 +
                                                2, 4;
 +
                                                3, 4];
 +
 +
  //jumlah node
 +
  parameter Integer n = 4; //isi sesuai data
 +
 +
  //titik node boundary xyz
 +
  parameter Integer [:] Boundary_xyz = {1}; //isi sesuai data
 +
 +
  //titik node boundary xy
 +
  parameter Integer [:] Boundary_xy = {4}; //isi sesuai data
 +
 +
  //titik node boundary xz
 +
  parameter Integer [:] Boundary_xz = {0}; //isi sesuai data
 +
 +
  //titik node boundary yz
 +
  parameter Integer [:] Boundary_yz = {0}; //isi sesuai data
 +
 +
  //titik node boundary x
 +
  parameter Integer [:] Boundary_x = {3}; //isi sesuai data
 +
 +
  //titik node boundary y
 +
  parameter Integer [:] Boundary_y = {0}; //isi sesuai data
 +
 +
  //titik node boundary z
 +
  parameter Integer [:] Boundary_z = {0}; //isi sesuai data
 +
                           
 +
  //load = [ F1x, F1y, F1z,..., Fnx, Fny, Fnz]
 +
  parameter Real [3*n] load = {0,    0, 0,  //isi sesuai data
 +
                              0, -200, 0,
 +
                              0,    0, 0,
 +
                              0,    0, 0};
 +
 +
  Real [size(inisiasi,1)] L;
 +
  Real [size(inisiasi,1)] k;
 +
  Real [size(inisiasi,1),6,6] Ke;
 +
  Real [size(inisiasi,1),3*n,3*n] Kg;
 +
  Real [3*n,3*n] KgTot;
 +
  Real [3*n,3*n] KgB;
 +
  Real [3*n] U;
 +
  Real [3*n] R;
 +
 +
  //check force
 +
  Real [3] F;
 +
 +
equation
 +
L = {(sqrt(inisiasi[i,2]^2 + inisiasi[i,3]^2 + inisiasi[i,4]^2)) for i in 1:size(inisiasi,1)};
 +
 +
k = {(inisiasi[i,5] * inisiasi[i,6] / L[i]) for i in 1:size(inisiasi,1)};
 +
 +
Ke = StiffnessMatrixElement(inisiasi);
 +
 +
Kg = StiffnessMatrixGlobal(n, node, Ke);
 +
 +
KgTot = SumStiffnessMatrixGlobal(Kg);
 +
 +
KgB = BoundaryStiffnessMatrixGlobal(KgTot, Boundary_xyz, Boundary_xy, Boundary_xz, Boundary_yz, Boundary_x, Boundary_y, Boundary_z);
 +
 +
U = GaussJordan(KgB, load);
 +
 +
R = ReactionForce(KgTot, U, load);
 +
 +
F = CheckForce(load,R);
 +
 +
end QuizSoal1;
 +
 +
|}
 +
  
 
'''Tugas 4'''
 
'''Tugas 4'''
Line 363: Line 772:
 
[[File:Soaltubesbagus.png|600px|center]]
 
[[File:Soaltubesbagus.png|600px|center]]
  
−
Asumsi dan Constraint
+
'''Flow Chart'''
 +
 
 +
1. Mendefinisikan masalah
 +
 
 +
2. Menentukan asumsi dan constraint
 +
 
 +
3. Researh data profil besi siku
 +
 
 +
4. Permodelan Numerik
 +
 
 +
5. Komputasi
 +
 
 +
6. Optimasi 1 (Area Locked)
 +
 
 +
7. Optimasi 2 (Elasticity Locked)
 +
 
 +
8. Penentuan akhir material
 +
 
 +
 
 +
'''Asumsi dan Constraint'''
  
 
Asumsi:  
 
Asumsi:  
Line 389: Line 817:
 
Berikut merupakan coding curve fitting yang digunakan pada excel :
 
Berikut merupakan coding curve fitting yang digunakan pada excel :
  
−
  function Curve_Fitting
+
'''Permodelan Numerik'''
 +
 
 +
3D Trusses Model
 +
 
 +
  //define initial variable
 +
  parameter Integer Points=size(P,1); //Number of Points
 +
  parameter Integer Trusses=size(C,1); //Number of Trusses
 +
  parameter Real Yield= (nilai yield) ; //Yield Strength Material(Pa)
 +
  parameter Real Area= (nilai area) ;  //Luas Besi Siku (Dimension=30x30x3mm)
 +
  parameter Real Elas= (nilai elastisitas) ; //Elasticity Material (Pa)
 +
//define connection
 +
parameter Integer C[:,2]=[1,5;  // (Elemen 1)
 +
                        2,6;  // (Elemen 2)
 +
                        3,7;  // (Elemen 3)
 +
                        4,8;  // (Elemen 4)
 +
                        5,6;  // (Elemen 5)
 +
                        6,7;  // (Elemen 6)
 +
                        7,8;  // (Elemen 7)
 +
                        5,8;  // (Elemen 8)
 +
                        5,9;  // (Elemen 9)
 +
                        6,10; // (Elemen 10)
 +
                        7,11; // (Elemen 11)
 +
                        8,12; // (Elemen 12)
 +
                        9,10; // (Elemen 13)
 +
                        10,11;// (Elemen 14)
 +
                        11,12;// (Elemen 15)
 +
                        9,12; // (Elemen 16)
 +
                        9,13; // (Elemen 17)
 +
                        10,14;// (Elemen 18)
 +
                        11,15;// (Elemen 19)
 +
                        12,16;// (Elemen 20)
 +
                        13,14;// (Elemen 21)
 +
                        14,15;// (Elemen 22)
 +
                        15,16;// (Elemen 23)
 +
                        13,16];//(Elemen 24)
 +
//define coordinates (please put orderly)
 +
parameter Real P[:,6]=[  0  ,0  ,0,1,1,1; //node 1
 +
                          0.75,0  ,0,1,1,1; //node 2
 +
                          0.75,0.6,0,1,1,1; //node 3
 +
                          0  ,0.6,0,1,1,1; //node 4
 +
                         
 +
                          0  ,0  ,0.3,0,0,0; //node 5
 +
                          0.75,0  ,0.3,0,0,0; //node 6
 +
                          0.75,0.6,0.3,0,0,0; //node 7
 +
                          0  ,0.6,0.3,0,0,0; //node 8
 +
                         
 +
                          0  ,0  ,1.05,0,0,0; //node 9
 +
                          0.75,0  ,1.05,0,0,0; //node 10 
 +
                          0.75,0.6,1.05,0,0,0; //node 11
 +
                          0  ,0.6,1.05,0,0,0; //node 12
 +
                         
 +
                          0  ,0  ,1.8,0,0,0; //node 13
 +
                          0.75,0  ,1.8,0,0,0;  //node 14
 +
                          0.75,0.6,1.8,0,0,0; //node 15
 +
                          0  ,0.6,1.8,0,0,0]; //node 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-15, ers=10e-8;
 +
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 Trusses_3D_Tugas_Besar;
 +
 
 +
'''function Curve_Fitting'''
  
 
  input Real X[:];
 
  input Real X[:];
Line 395: Line 999:
 
  input Integer order=2;
 
  input Integer order=2;
 
  output Real Coe[order+1];
 
  output Real Coe[order+1];
−
 
 
  protected
 
  protected
 
  Real Z[size(X,1),order+1];
 
  Real Z[size(X,1),order+1];
Line 410: Line 1,013:
 
  end for;
 
  end for;
 
  ZTr:=transpose(Z);
 
  ZTr:=transpose(Z);
−
 
 
  A:=ZTr*Z;
 
  A:=ZTr*Z;
 
  B:=ZTr*Y;
 
  B:=ZTr*Y;
 
  Coe:=Modelica.Math.Matrices.solve(A,B);
 
  Coe:=Modelica.Math.Matrices.solve(A,B);
 
  //Coe:=fill(2,size(Coe,1));
 
  //Coe:=fill(2,size(Coe,1));
−
 
 
  end Curve_Fitting;
 
  end Curve_Fitting;
 
  /*
 
  /*
Line 428: Line 1,029:
 
Berikut merupakan coding selanjutnya :
 
Berikut merupakan coding selanjutnya :
  
−
  model callcurve
+
  '''model callcurve'''
 +
 
 
  parameter Real [3] X={3289473.684,1461988.304,651041.6667};
 
  parameter Real [3] X={3289473.684,1461988.304,651041.6667};
 
  parameter Real [3] Y={1016800,2301500,5083900};
 
  parameter Real [3] Y={1016800,2301500,5083900};
Line 439: Line 1,041:
  
 
[[File:Soaltubesbagus1.png|600px|center]]
 
[[File:Soaltubesbagus1.png|600px|center]]
 +
 +
Karena pada percobaan diatas saya belum merasa yakin, Lalu saya kembali membuat coding dengan angka yang berbeda :
 +
 +
'''model callcurve'''
 +
 +
parameter Real [3] X={304e-6,684e-6,1536e-6};
 +
parameter Real [3] Y={1016800,2301500,5083900};
 +
Real [3] Coe;
 +
 +
algorithm
 +
Coe:=Curve_Fitting(X,Y);
 +
end callcurve;
 +
 +
[[File:Soaltubesbagus2.png|600px|center]]
 +
 +
Dan ini adalah grafiknya :
 +
 +
[[File:Soaltubes3.png|600px|center]]
 +
 +
=='''UAS METODE NUMERIK'''==
 +
 +
Assalamualikum Wr. Wb Berikut adalah hasil dari UAS Metode Numerik yang saya kerjakan :
 +
 +
[[File:UASMetnumBagus.JPG|600px|center]]
 +
 +
 +
[[File:UASMetnumBagus1.JPG|600px|center]]
 +
 +
 +
[[File:UASMetnumBagus2.JPG|600px|center]]
 +
 +
 +
[[File:UASMetnumBagus3.JPG|600px|center]]
 +
 +
 +
[[File:UASMetnumBagus44.JPG|600px|center]]
 +
 +
 +
[[File:UASMetnumBagus5.JPG|600px|center]]
 +
 +
 +
[[File:UASMetnumBagus6.JPG|600px|center]]
 +
 +
'''Jawaban UAS nomor 7'''
 +
 +
[[File:UASmetnumbagus7.PNG|600px|center]]
 +
 +
 +
[[File:UASmetnumbagus8.PNG|600px|center]]
 +
 +
 +
[[File:UASmetnumbagus9.PNG|600px|center]]

Latest revision as of 02:03, 14 January 2021

بِسْمِ اللّهِ الرَّحْمَنِ الرَّحِيْ

السَّلاَمُ عَلَيْكُمْ وَرَحْمَةُ اللهِ وَبَرَكَاتُهُ


BIODATA DIRI

Photo on 20-04-20 at 13.22.jpg

Nama : Muhammad Bagus Pratama

NPM : 1806181792

Fakultas/ Jurusan : Teknik/ Teknik Mesin

Tempat dan Tanggal lahir :Sukabumi, 23 Augustus 2000

Pertemuan 1: 9 November 2020

Assalamualaikum Wr. Wb, Perkenalkan nama saya Muhammad Bagus Pratama dari kelas Metode Numerik 03,kali ini daya akan menjelaskan apa yang sudah saya pelajari tentang Metode Numerik. Metode numerik merupakan teknik penyelesaian permsalahn yang diformulasikan secara matematis dengan menggunakan operasi hitungan (aritmatik) yaitu operasi tambah, kurang, kali, dan bagi. Metode ini digunakan karena banyak permasalahan matematis tidak dapat diselesaikan menggunakan metode analitik. Jikapun terdapat penyelesaiannya secara analitik, proses penyelesaiaannya sering kali cukup rumit dan memakan banyak waktu sehingga tidak efisien.

Terdapat keuntungan dan kerugian terkait penggunaan metode numerik. Keuntungan dari metode ini antara lain:

1. Solusi persoalan selalu dapat diperoleh.

2. Dengan bantuan komputer, perhitungan dapat dilakukan dengan cepat serta hasil yang diperoleh dapat dibuat sedekat mungkin dengan nilai sesungguhnya.

3. Tampilan hasil perhitungan dapat disimulasikan.

Adapun kelemahan metode ini antara lain:

1. Nilai yang diperoleh berupa pendekatan atau hampiran.

2. Tanpa bantuan komputer, proses perhitungan akan berlangsung lama dan berulang-ulang.

1. Menentukan Akar-Akar

Ada beberapa metode yang dapat digunakan untuk menyelesaikan suatu persamaan. Metode ini merupakan penyelesaian perkiraan, tetapi lebih sistematis untuk menghitung akar-akar persamaan. Dalam metode numerik, pencarian akar f(x)=0 dilakukan secara lelaran (iteratif). Secara umum, semua metode pencarian akar dapat dikelompokkan menjadi 2 golongan besar :

• Metode Tertutup

Metode yang termasuk ke dalam golongan ini mencari akar di dalam selang [a,b]. Selang [a,b] sudah dipastikan berisi minimal satu buah akar, karena itu metode jenis ini selalu berhasil menemukan akar. Dengan kata lain, lelarannya selalu konvergen (menuju) ke akar, karena itu metode tertutup kadang-kadang dinamakan juga metode konvergen.

Metode yang termasuk dalam golongan ini antara lain :

a. Metode Biseksi atau Metode Setengah Interval ini merupakan Metode dengan bentuk paling sederhana diantara beberapa metode yang akan dipelajari.

b. Metode Regula Falsi atau Metode Interpolasi Linier adalah metode mudah tapi tidak efisien. Untuk mendapatkan hasil yang mendekati nilai eksak diperlukan langkah iterasi yang cukup panjang. Metode Regula Falsi dapat menutup kekurangan itu. Metode Regula Falsi didasarkan pada interpolasi antara dua nilai dari fungsi yang mempunyai tanda berlawanan

• Metode Terbuka

Yang diperlukan pada metode ini, adalah tebakan awal akar, lalu dengan prosedur lelaran, kita menggunakannya untuk menghitung hampiran akar yang baru. Pada setiap lelaran, hampiran akar lama yang dipakai untuk menghitung hampiran akar yang baru. Mungkin saja hampiran akar yang baru mendekati akar sejati (konvergen), atau mungkin menjauhinya (divergen). Karena itu, metode terbuka tidak selalu berhasil menemukan akar, kadang-kadang konvergen, kadangkala ia divergen.

Metode yang termasuk dalam golongan ini antara lain :

a. Metode Newton Raphson,Metode ini paling banyak digunakan dalam mencari akar-akar dari suatu persamaan.

b. Metode Secant,Kekurangan Metode Newton Raphson adalah diperlukannya turunan pertama (differensial) dari f(x) dalam hitungan. Kadang-kadang sulit untuk mendiferensialkan persamaan yang diselesaikan. Untuk itu maka bentuk diferensial didekati dengan nilai perkiraan berdasarkan diferensial beda hingga.

c. Metode Iterasi,Dalam metode iterasi ini digunakan suatu persamaan untuk memperkirakan nilai akar persamaan. Persamaan tersebut dikembangkan dari fungsi f(x) = 0 sehingga parameter x berada disisi kiri dari persamaan, yaitu :

X= g(x)

Persamaan ini menunjukkan bahwa nilai x merupakan fungsi dari x, sehingga dengan memberi nilai perkiraan awal dari akar dapat dihitung perkiraan baru dengan rumus iteratif berikut :

Xi+1 = g ( xi )

Besar kesalahan dihitung dengan rumus berikut :

∈a = | (Xi+1 – Xi )/(Xi+1 ) | X 100%

2. Regresi Linier

Regresi merupakan alat ukur yg digunakan untuk mengetahui ada tidaknya korelasi antarvariabel. Analisis regresi lebih akurat dlm analisis korelasi karena tingkat perubahan suatu variabel terhdp variabel lainnya dpt ditentukan). Jadi pada regresi, peramalan atau perkiraan nilai variabel terikat pada nilai variabel bebas lebih akurat pula.

Regresi linier adalah regresi yang variabel bebasnya (variabel X) berpangkat paling tinggi satu. Utk regresi sederhana, yaitu regresi linier yg hanya melibatkan dua variabel (variabel X dan Y).

Y = a + bX

Keterangan :

Y = variabel terikat

X = variabel bebas

a = intersep / konstanta

b = koefisien regresi / slop

Persamaan regresi linear di atas dpt pula dituliskan dlm bentuk :


Regresibagus.png

3. Turunan Numerik

Ini digunakan untuk menentukan nilai turunan fungsi f yang diberikan dalam bentik tabel. Ada 3 pendekatan zalm menghitung Turunan Numerik :

1. Hampiran selisih-maju (forward difference approximation)

Maju bagus.png

2. Hampiran selisih-mundur (backward difference approximation)

Mundur bagus.png

3. Hampiran selisih-pusat (central difference approximation)

Pusat bagus.png

Pertemuan 2: 16 November 2020

Assalamualaikum Wr Wb,pada pertemuan kedua ini, Pak Dai emulai kelas dengan pemaparan pemahaman masing-masing mengenai OpenModelica. Setelah itu kami diminta untuk membuat sebuah program sederhana untuk menjumlahkan angka dan juga mencari rata-rata.

Berikut merupakan algoritma yang saya buat untuk penjumlahan angka

Openmodel1.PNG

Setelah itu dapat dilihat grafik input dan hasil sebagai berikut, dengan nilai input x=6 didapatkan hasil y=16. Kita juga dapat melakukan simulasi kembali apabila ingin merubah nilai x.

Openmodel2.PNG

Tugas 2 : Memecahkan suatu Persamaan Aljabar Simultan

Assalamualaikum Wr,Wb, Dalam menyelesaikan tugas kedua ini saya menggunakan 3 persamaan sebagai berikut :

x1+4x2+6x3=7

3x1+5x2+2x3=6

x1+3x2+2x3=4

Langkah pertama yang saya lakukan adalah membuat modelica class baru dengan tipe class dan membruta fungsi dan variabel real seperti A[3,3] , B[3] dan parameter X, dimana X adalah akar yang akan ticari setelah dilakukan simulasi. Class yang saya gunakan adalah tipe class yang bisa menyelesaikan persamaan yaitu class tipe function. Berikut basil rangkaian bahasa modelica yang Sudan di cek dengan berisikan 15 persamaan dan 15 variabel yang Sudan benar :

Model 4 berhasill.PNG

Selanjutnya saya melakukan setting simulation sebagai berikut :

Model 5 simulasi setup.PNG

Setelah dilakukan simulasi, didapatkan akar- akar dari persamaan eliminasi gauss yaitu :

X1 = 9,25186e-16

X2 = 1

X3 = 0,5

Berikut adalah basil simulasi yang telah saya lakukan :

Grafik akhir.PNG

Pertemuan 3 : 23 November 2020

Assalamualaikum Wr.Wb, Pada hari ini kelas akan diadakan oleh Pak Dai menghimbau kami untuk membaca materi mengenai permodelan pegas di buku metode numerik terlebih dahulu.

Zoomtadi.PNG

Kemudian, pak Dai menjelaskan bagaimana cara mengaplikasikan metode numerik ke permodelan teknik. Masalah teknik -> analisis teknik -> model matematis -> model numerik -> komputer -> solusi

Prtadi.PNG

Lalu Pak Dai menjelaskan bagaimana permodelan aplikasi pegas. Mulai dari masalah tekniknya yaitu merupakan sistem pegas. kemudian pada analisis teknik kita menentukan hal-hal apa saja yang kita ketahui dalam persamaan tersebut. Lalu dengan hukum hooke kita membuat model matematisnya.

Selanjutnya, pak Dai memberikan tugas untuk menyelesaikan permasalahan pada pegas massa, dan berikut adalah hasil dari pembuatan class yang telah dibuat : .Menggunakan matriks 3x3 sesuai permasalahan yang ada

.Mengunakan asumsi nilai k yaitu 10N/m untuk disubtitusi ke persamaan

.Menggunakan salah satu metode aljabar simultan yaitu gauss elimination

.Terdapat 15 persamaan dan 15 variabel,12 trivial equation

Kemudian Pak Dai menghimbau kami untuk membuktikan matriks sistem pegas yang ada di buku dengan perhitungan pada openmodelica.

Berikut koding pada open modelica saya :

Springbagus1.PNG


Springbagus2.PNG


Springbagus3.PNG


Springbagus4.PNG

Dari basil tersebut di dapatkan x1, x2, dan x3. Berikut adalah hasilnya, dimana x1 = 7.5 N, x2 = 10.25N, dan x3 = 12.75 N.


Demikian basil Openmodelica dari saya, Terima Kasih. Wassalamualaikum Wr,Wb

Tugas 3

Gaussbagus0.1.png

Ada 4 cara pertama Dalam menyelesaikan soal diatas :

1.Mengubah problem menjadi node dan elemen

2.Menentukan nilai Konstanta kekakuan/stiffness constant dari elemen

3.Membuat persamaan untuk elemen

4.Menyusun dan menggabungkan matriks elemen-elemen

4 cara diatas ada pada buku "Finite Element Analysis" pada halaman 60-70 :

Buku11.png
Buku12.png
Buku13.png
Buku14.png
Buku15.png
Buku16.png

Disitu terdapat matriks yang akan saya lakukan percoban pada aplikasi Openmodelica.

Berikut basil percobaan matriks pada aplikasi OpenModelica :

Gaussbagus1.PNG

Setelah melakukan simulasi saya melakukan plotting pada asilo simulasi tersebut :

Gaussbagus11.png
Gaussbagus12.png

Karena di soal ingin mencari gaya reaksi, maka perlu dilakukan perhitungan pada gaya reaksi dengan persamaan yang ada pada buku "Finite Element Analysis" pada halaman 60-70 :

Gaussbagus13.png

Berikut basil plottingnya :

Gaussbagus14.png
Gaussbagus15.png

Untuk menghitung normal stress, perlu dilakukan transformasi dari hasil defleksi ditinjau dari koordinat global menjadi transformasi lokal, berikut adalah persamaan yang ada pada buku "Finite Element Analysis" pada halaman 60-68 dan damat digunakan untuk menganalisis hasi dengan aplikasi Openmodelica :

Gaussbagus16.png

Berikut basil plottingnya :

Gaussbagus17.png
Gaussbagus18.png

kemudian didapatkan :

U2x=-0.00976 inch

U6x=-0.01209 inch

Untuk mencari basil Internal Force dapat menggunakan rumus yang ada di buku sehingga didapatkan hasil sebagai berikut :

Internal force = 696lb.

Kemudian untuk mencari hasil normal stress data menggunakan rumus yang ada di buku sehingga didapatkan hasil sebagai berikut :

Normal stress = 87lb/in^2

Berikut adalah basil dari tugas 3 saya, Wassalamualaikum wr,wb

Pertemuan 4: 30 November 2020

Assalamualaikum Wr,Wb Pak Dai membahas tentang perbedaan statis dan dinamis yaitu Statis bebannya tetap, sepanjang waktu tetap, kalau dinamis, bebannya bisa berulang atau mengalami penambahan atau pengurangan terhadap waktu. Kemudian Pak Dai membahas tentang tugas 3 yang kumarin dan kemudian Pak Dai memberikan Quiz dan menyuruh kita untuk mengumpulkan Flow Chart terlebih dahulu. Berikut Soal dan Flow Chart yang saya buat :

Soalkuis10.png

Soal Quiz :

Soalkuis11.png
Soalkuis12.png

Berikut Flow Chart yang saya bikin :

F46EA262-303A-4630-A7F5-71B8F129DEC0.jpeg
5404F765-3DF8-4775-AD4F-43C39DE1196F.jpeg

Wassalamualaikum Wr,Wb

Pertemuan 5: 7 Desember 2020

Assalamualaikum Wr. Wb. Pada pertemuan hari ini Pak Dai memberikan kesempatan bagi mahasiswa yang telah mengerjakan kuis untuk menjelaskan flow chart dan juga hasil dari pengerjaan yang dilakukan. Pada kesempatan tersebut Ahmad Mohammad Fahmi yang telah berhasil menyelesaikan soal quiz yang diberikan, menjelaskan hasil pengerjaanya. Berdasarkan dari pembahasan tersebut, Ahmad Mohammad Fahmi menggunakan sistem looping untuk perhitungan dengan banyak data.

Lalu ahmad menjelaskan mengenai flowchart yang dia telah buat ahmad juga menjelaskan mengenai tahapan untuk menyelesaikan soal. Berikut tahapan yang Ahmad jelaskan :

1.Solve stiffness

2.Membuat dan menyelesaikan Matrix global dari setiap elemen

3.Mengimplementasikan boundary condition, kemudian didapatkan U.

Kemudian pak Dai memberikan kami tugas mengenai pembahasan oleh saudara Ahmad Mohammad Fahmi tentang kodingan yang dibuat olehnya mengenai kuis nomer 4 dan 8. Untuk membantu pembelajaran kami, Ahmad memberikan video rekaman tutorial yang berisi diskusi pada link dibawah ini :

https://drive.google.com/file/d/1n0zvwmn-3G4DWYCSPD48-Xfrp9_kT3R0/view?usp=sharing

Dalam video tersebut Ahmad menjelaskan tenting kodingan yang dia buat.

1.Untuk mengerjakan nomer 4, Ahmad membuat beberapa function yang nanti akan digunakan dan 1 class untuk membuat penyelesaian atas soal yang diberikan. Pada class, Saudara ahmad memasukkan parameter REAL (inisiasi) yang berisi element, theta, A, E, L.

2.Kemudian kita menginput node - node yang ada dengan memasukkan matriks dengan parameter integer. Pada parameter integer kita memanggil matriks inisiasi pada kolom satu untuk di sesuaikan dengan node-node yang bersangkutan.

3.Lalu kita masukan jumlah node yaitu n=4 dan Boundaries pada node. Boundaries pada node ini yaitu pada titik 1 dan 3 karena mereka merupakan tumpuan. Setelah itu, kita memasukkan load dengan menginput parameter real (2*n). Kita mengalikan n dengan 2 karena disini gaya ada 2 arah yaitu x dan y.

4.Sesudah mengisi load, kita menginput equation dengan fungsi-fungsi yang sudah dibuat juga pada function oleh Ahmad.

Pembahasan dari function :

1.Lihat terlebih dahulu dari function stiffnessmatrixelement.

2.Input matriks inisiasi (:,5) dan outputnya adalah matriks dari Ke yang tadi ada pada equation pada class

3.Gunakan protected maka parameter dapat dipanggil. Fungsinya adalah agar kita bisa memasuki parameter tanpa harus menulis ulang pada function dengan memanggil parameter pada Class

4.Parameter yang kita ambil untuk Ke adalah Theta, StiffTrig, Stifftrans, k_vec, dan Floating error.

Dan ini adalah hasil coding dari Ahmad Muhammad Fahmi yang saya pelajari :

Stiffness Matrix Element Function 

 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 cos_z;
   Real [6] StiffTrig;
   Real [6,6] StiffTrans;
   Real [size(inisiasi_mat,1)] L;
   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)};
 // 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,2]/L[i];
    cos_y := inisiasi_mat[i,3]/L[i];
    cos_z := inisiasi_mat[i,4]/L[i];
 // {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;

Stiffness Matrix Global Function 

function StiffnessMatrixGlobal
 input Integer x;
 input Integer [:,2] n;
 input Real [:,6,6] Ke_mat; 
 output Real [size(Ke_mat,1),3*x,3*x] Kg_mat;
algorithm
 Kg_mat := zeros(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 Stiffness Matrix Element Function 

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;

Boundary Stiffness Matrix Global Function 

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 

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 

function ReactionForce
 input Real [:,:] KgTot_met;
 input Real [size(KgTot_met,1)] U_met;
 input Real [size(KgTot_met,1)] load_met;
 output Real [size(KgTot_met,1)] 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;

Check Force Function 

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;


Class 

class QuizSoal1
 //inisiasi = [ elemen#, dX, dY, dZ, A, E]
 parameter Real [:,6] inisiasi = [1,  6,  0, -3, 1.56, 10.6e6; //isi sesuai data
                                  2,  0,  0, -6, 1.56, 10.6e6;
                                  3,  0,  6, -3, 1.56, 10.6e6;
                                  4, -6,  0, -3, 1.56, 10.6e6;
                                  5, -6,  6,  0, 1.56, 10.6e6;
                                  6,  0,  6,  3, 1.56, 10.6e6];

 //node = [ i, j]                                 
 parameter Integer [size(inisiasi,1),2] node = [1, 2; //isi sesuai data
                                                1, 3;
                                                1, 4;
                                                2, 3;
                                                2, 4;
                                                3, 4];

 //jumlah node
 parameter Integer n = 4; //isi sesuai data

 //titik node boundary xyz
 parameter Integer [:] Boundary_xyz = {1}; //isi sesuai data

 //titik node boundary xy
 parameter Integer [:] Boundary_xy = {4}; //isi sesuai data

 //titik node boundary xz
 parameter Integer [:] Boundary_xz = {0}; //isi sesuai data

 //titik node boundary yz
 parameter Integer [:] Boundary_yz = {0}; //isi sesuai data

 //titik node boundary x
 parameter Integer [:] Boundary_x = {3}; //isi sesuai data

 //titik node boundary y
 parameter Integer [:] Boundary_y = {0}; //isi sesuai data

 //titik node boundary z
 parameter Integer [:] Boundary_z = {0}; //isi sesuai data
                            
 //load = [ F1x, F1y, F1z,..., Fnx, Fny, Fnz]
 parameter Real [3*n] load = {0,    0, 0,  //isi sesuai data
                              0, -200, 0, 
                              0,    0, 0, 
                              0,    0, 0}; 

 Real [size(inisiasi,1)] L;
 Real [size(inisiasi,1)] k;
 Real [size(inisiasi,1),6,6] Ke;
 Real [size(inisiasi,1),3*n,3*n] Kg;
 Real [3*n,3*n] KgTot;
 Real [3*n,3*n] KgB;
 Real [3*n] U;
 Real [3*n] R;

 //check force
 Real [3] F;

equation
L = {(sqrt(inisiasi[i,2]^2 + inisiasi[i,3]^2 + inisiasi[i,4]^2)) for i in 1:size(inisiasi,1)}; 

k = {(inisiasi[i,5] * inisiasi[i,6] / L[i]) for i in 1:size(inisiasi,1)};

Ke = StiffnessMatrixElement(inisiasi);

Kg = StiffnessMatrixGlobal(n, node, Ke);

KgTot = SumStiffnessMatrixGlobal(Kg);

KgB = BoundaryStiffnessMatrixGlobal(KgTot, Boundary_xyz, Boundary_xy, Boundary_xz, Boundary_yz, Boundary_x, Boundary_y, Boundary_z);

U = GaussJordan(KgB, load);

R = ReactionForce(KgTot, U, load);

F = CheckForce(load,R);

end QuizSoal1;


Tugas 4

Pak Dai memberikan soal nomor 3.3 Dalam tugas ini, saya diminta untuk mencari matrix displacement dimana U = {U1x, U1y, U1z,..., Unx, Uny, Unz} ; matrix gaya reaksi dimana R = {R1x, R1y, R1z,...,Rnx, Rny, Rnz}; dan matrix gaya total pada sumbu x, y, dan z dan berikut merupakan coding yang saya lakukan didalam OpenModelica

Quiz4bagus5.png


Quiz4bagus.png


Quiz4bagus1.png


Quiz4bagus2.png


Quiz4bagus3.png


Quiz4bagus4.png

Pertemuan 6

Assalamualaikum Wr, Wb Pada pertemuan kali ini Pak Ahmad Indra memberikan kita tugas muhasabah diri, Untuk pemahaman saya pada kelas Metode Numerik ini adalah relatif, Karena ada beberapa materi yang Alhamdulillah Judah bisa saya pahami, tetapi ada juga beberapa materi yang sepertinya bisa saya pelajari lagi agar saya lebih bisa memahami materi tersebut. Jika dilihat dari pemahana yang saya dapatkan selama belalar metode numerik ini.

Pertemuan 7

Assalamualikum Wr, Wb. Kelas pada lari ini diadakan oleh Pak Ahmad Indra

Tugas Besar

Assalamualikum Wr,Wb

Berikut merupakan soal dari Tugas Besar :

Soaltubesbagus.png

Flow Chart

1. Mendefinisikan masalah

2. Menentukan asumsi dan constraint

3. Researh data profil besi siku

4. Permodelan Numerik

5. Komputasi

6. Optimasi 1 (Area Locked)

7. Optimasi 2 (Elasticity Locked)

8. Penentuan akhir material


Asumsi dan Constraint

Asumsi:

- Diasumsikan tidak ada bending karena bersifat truss

- Beban terdistribusi pada node

- Safety Factor = 2

- Batas displacement 0,001m sebelum terjadi buckling

- Variabel bebas

Constraint:

- Node 1,2,3,4 (lantai dasar) fixed

- Beban F1 dan F2 terdistribusi ke node sekitaranya, sehingga:

1. Node 13 & 16 = 1000N

2. Node 14 & 15 = 500N

Berikut merupakan coding curve fitting yang digunakan pada excel :

Permodelan Numerik

3D Trusses Model 

//define initial variable
 parameter Integer Points=size(P,1);		//Number of Points
 parameter Integer Trusses=size(C,1); 		//Number of Trusses
 parameter Real Yield= (nilai yield) ;		//Yield Strength Material(Pa)
 parameter Real Area= (nilai area) ;   	//Luas Besi Siku (Dimension=30x30x3mm)
 parameter Real Elas= (nilai elastisitas) ;	//Elasticity Material (Pa)
//define connection
parameter Integer C[:,2]=[1,5;  // (Elemen 1)
                        2,6;  // (Elemen 2)
                        3,7;  // (Elemen 3)
                        4,8;  // (Elemen 4)
                        5,6;  // (Elemen 5)
                        6,7;  // (Elemen 6)
                        7,8;  // (Elemen 7)
                        5,8;  // (Elemen 8)
                        5,9;  // (Elemen 9)
                        6,10; // (Elemen 10)
                        7,11; // (Elemen 11)
                        8,12; // (Elemen 12)
                        9,10; // (Elemen 13)
                        10,11;// (Elemen 14)
                        11,12;// (Elemen 15)
                        9,12; // (Elemen 16)
                        9,13; // (Elemen 17)
                        10,14;// (Elemen 18)
                        11,15;// (Elemen 19)
                        12,16;// (Elemen 20)
                        13,14;// (Elemen 21)
                        14,15;// (Elemen 22)
                        15,16;// (Elemen 23)
                        13,16];//(Elemen 24)
//define coordinates (please put orderly)
parameter Real P[:,6]=[   0   ,0  ,0,1,1,1;	//node 1
                         0.75,0  ,0,1,1,1;	//node 2
                         0.75,0.6,0,1,1,1;	//node 3
                         0   ,0.6,0,1,1,1;	//node 4
                         
                         0   ,0  ,0.3,0,0,0;	//node 5
                         0.75,0  ,0.3,0,0,0;	//node 6
                         0.75,0.6,0.3,0,0,0;	//node 7
                         0   ,0.6,0.3,0,0,0;	//node 8
                         
                         0   ,0  ,1.05,0,0,0;	//node 9
                         0.75,0  ,1.05,0,0,0;	//node 10  
                         0.75,0.6,1.05,0,0,0;	//node 11
                         0   ,0.6,1.05,0,0,0;	//node 12
                         
                         0   ,0  ,1.8,0,0,0;	//node 13
                         0.75,0  ,1.8,0,0,0;  //node 14
                         0.75,0.6,1.8,0,0,0;	//node 15
                         0   ,0.6,1.8,0,0,0];	//node 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-15, ers=10e-8;
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 Trusses_3D_Tugas_Besar;

function Curve_Fitting

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);
//Coe:=fill(2,size(Coe,1));
end Curve_Fitting;
/*
for i in 1:3 loop
for j in 1:Points loop
 R[j]:=reaction[3*(j-1)+i];
end for;
Sur[i]:=sum(R);
end for;
*/

Berikut merupakan coding selanjutnya : 

model callcurve

parameter Real [3] X={3289473.684,1461988.304,651041.6667};
parameter Real [3] Y={1016800,2301500,5083900};
Real [3] Coe;
algorithm
Coe:=Curve_Fitting(X,Y);
end callcurve;

Dan ini merupakan progress dari Tugas Besar saya :

Soaltubesbagus1.png

Karena pada percobaan diatas saya belum merasa yakin, Lalu saya kembali membuat coding dengan angka yang berbeda :

model callcurve 

parameter Real [3] X={304e-6,684e-6,1536e-6};
parameter Real [3] Y={1016800,2301500,5083900};
Real [3] Coe;

algorithm 

Coe:=Curve_Fitting(X,Y);
end callcurve;
Soaltubesbagus2.png

Dan ini adalah grafiknya :

Soaltubes3.png

UAS METODE NUMERIK

Assalamualikum Wr. Wb Berikut adalah hasil dari UAS Metode Numerik yang saya kerjakan :

UASMetnumBagus.JPG


UASMetnumBagus1.JPG


UASMetnumBagus2.JPG


UASMetnumBagus3.JPG


UASMetnumBagus44.JPG


UASMetnumBagus5.JPG


UASMetnumBagus6.JPG

Jawaban UAS nomor 7

UASmetnumbagus7.PNG


UASmetnumbagus8.PNG


UASmetnumbagus9.PNG
Retrieved from "http://air.eng.ui.ac.id/index.php?title=Metnum03-Muhammad_Bagus_Pratama&oldid=55591"