MAKALAH TUGAS AKHIR
PEMROGRAMAN ANALISA ELEMEN STRUKTUR SHELL DENGAN BANTUAN VISUAL BASIC 6.0
HINGGA
PADA
FINITE ELEMENT ANALYSIS OF SHELL STRUCTURE PROGRAMMING USING VISUAL BASIC 6.0 RISKAL MAJID 3105 100 075 Dosen Pembimbing Tavio, ST. MT. Ph.D JURUSAN TEKNIK SIPIL Fakultas Teknik Sipil dan Perencanaan Institut Teknologi Sepuluh Nopember Surabaya 2010
PEMROGRAMAN ANALISA ELEMEN HINGGA PADA STRUKTUR SHELL DENGAN BANTUAN VISUAL BASIC 6.0 Nama Mahasiswa
: Riskal Majid
NRP
: 3105 100 075
Jurusan
: Teknik Sipil FTSP ITS
Dosen Konsultasi
: Tavio, ST. MT. Ph.D
ABSTRAK Aplikasi analisa struktur telah mempunyai peranan yang signifikan dalam dunia desain dan konstruksi dalam beberapa dekade belakangan ini. Saat ini ada begitu banyak program bantu teknik sipil yang tersedia. Hanya saja program-program komersial tersebut tidak hanya mahal tapi juga memiliki aturan lisensi yang ketat. Hal ini menjadi salah satu kekhawatiran para pengguna aplikasi analisa struktur. Alasan-alasan tersebut mendorong lahirnya ide untuk mengembangkan sebuah softwareyang dapat menjadi alternatif untuk menganalisis berbagai tipe struktur Pengembangan program analisa struktur alternatif telah dilakukan di jurusan teknik sipil ITS. Namun, masih terbatas pada analisa elemen frame dengan beban statis dan dinamis. Program alternatif ini jelas masih membutuhkan pengembangan lebih lanjut. Salah satu yang dapat dikembangkan adalah pemrograman analisa struktur pada struktur shell berbentuk kuadritelateral. Pengembangan program dilakukan berbasiskan metode elemen hingga. Dari hasil penelitian, dapat disimpulkan bahwa hasil perhitungan program yang dikembangkan menunjukkan nilai yang mendekati dengan hasil perhitungan program profesional analisis struktur yang populer, yaitu SAP.
Kata kunci: aplikasi analisa struktur, metode elemen hingga, elemen shell, elemen kuadrilateral
FINITE ELEMENT ANALYSIS OF SHELL STRUCTURE PROGRAMMING USING VISUAL BASIC 6.0 Name of Student
: Riskal Majid
Registration Number : 3105 100 075 Department
: Civil Engineering FTSP ITS
Supervisor
: Tavio, ST. MT. Ph.D
ABSTRACT Structural analysis programs have been playing a significant role in the design offices and construction works for the past few decades. Nowadays, there are numerous commercial computer-aided softwares available in civil engineering. Unfortunately, those programs not only use at very high prices but also in firm license. This will certainly hinder the efforts of the users to implement such structure analysis programs. These reasons bring an idea to develop a software that can be used as an alternative tool for analyzing various types of structure. An alternative structure analysis program had been developed at Civil Engineering Departement, ITS Surabaya. But it could only analyze a space frame structure under various types of static and dinamic loading. Shell element in quadrilateral form is one of the structure types that can be developed. Analysis of this structure type using finite element method (FEM). From this investigation, it can be concluded that the results of the analysis obtained from the developed program show good agreement with the results fro the well-known commercial structure analysis software SAP.
Keywords : structure analysis aplication, finite element method, shell element, quadrilateral.
.BAB I PENDAHULUAN
1.1 Latar Belakang Dalam menyelesaikan pekerjaan yang membutuhkan analisa panjang ataupun pekerjaan gambar yang membutuhkan waktu yang cukup lama, sebagian besar pelaku teknik sipil lebih memilih memanfaatkan aplikasi komputer. Salah satu jenis aplikasi komputer yang memberikan manfaat cukup besar adalah aplikasi komputer untuk analisa struktur. Proses analisa struktur manual yang memakan waktu lama dapat dipersingkat dengan memanfaatkan beberapa aplikasi analisa struktur, seperti SAP2000, ANSYS, ETABS dan sebagainya, yang hingga saat ini masih sangat mudah didapatkan. Namun pada kenyataannya, para pengguna aplikasi komputer untuk analisa struktur, khususnya mahasiswa teknik sipil, masih menyisakan kekhawatiran terhadap nilai yang dihasilkan dari proses running program analisa struktur yang ada. Hal ini disebabkan karena program yang digunakan selama ini bukanlah program yang full licensed, sehingga hasilnya pun belum dapat diyakini 100 %. Selain itu masalah yang lebih besar lagi adalah semakin ketatnya peraturan tentang penggunaan aplikasiaplikasi komputer berlisensi (Sumber: UndangUndang No. 19 Tahun 2002 tentang Hak Cipta) dan dikhawatirkan suatu saat untuk mendapatkan program analisa struktur akan lebih sulit dan tentu saja sangat mahal. Sehingga perlu dilakukan sebuah usaha mandiri dalam menyusun program-program analisa struktur yang kelak dapat diperoleh lebih mudah dan murah terutama bagi mahasiswa. Di Jurusan Teknik Sipil ITS sudah ada beberapa mahasiswa yang mengembangkan program komputer dalam bidang analisa struktur (Sumber: Rama Ditasuwita, Pemrograman Analisa Struktur Menggunakan Visual Basic dengan Metode Kekakuan Langsung). Program yang telah disusun adalah analisa struktur space frame dengan metode kekakuan langsung yang merupakan bagian dari metode elemen hingga. Terdapat 2 aplikasi yang telah disusun dengan 2 jenis beban berbeda yaitu beban statis dan juga beban dinamis. Pembuatan dua aplikasi ini kemudian akan di hubungkan sehingga program
yang pada awalnya dibuat dengan beberapa keterbatasan bisa semakin berkembang. Program analisa yang telah dibuat di atas dibatasi hanya menghitung pada frame, sementara untuk shell, plat dan elemen lain belum disusun. Sehingga untuk kembali mengembangkan program-program yang ada diperlukan usaha untuk menyusun programprogram baru yang nantinya dapat melengkapi program-program yang telah ada. Karena itu, penulis berusaha mengambil satu bagian dalam mengembangkan program yang sudah ada, yaitu analisa struktur elemen shell dengan metode elemen hingga. Dalam menyusun program analisa struktur elemen shell diperlukan beberapa hal seperti pemahaman tentang metode elemen hingga, pemahaman terhadap shell itu sendiri, dan tentu saja diperlukan juga kemampuan programming yang cukup. Dengan pemahaman yang cukup tentang inti permasalahan maka diharapkan dapat memudahkan dalam menyusun algoritma program yang direncanakan. Algoritma program merupakan dasar yang perlu diketahui agar proses mendesain program juga menjadi lebih mudah. Kemudian agar program komputer bisa diterima secara ilmiah, maka diperlukan beberapa pengujian melalui perbandingan dengan program analisa struktur elemen shell profesional. Pada penyusunan program ini, penulis menggunakan bahasa pemrograman Visual Basic 6.0. Selain untuk memudahkan dalam menghubungkan program ini dengan program sebelumnya (yang juga menggunakan Visual Basic 6.0), Visual Basic 6.0 juga lebih mudah dalam hal interface dan desain, sehingga penulis bisa lebih fokus pada permasalahan analisa struktur daripada permasalahan tampilan program. Diharapkan dengan penyusunan program ini dapat semakin melengkapi programprogram yang telah disusun sebelumnya. Program yang dulunya terbatas pada analisa struktur pada space frame dengan beban statis dan dinamis, dengan adanya program ini program berkembang sampai perhitungan analisa struktur pada elemen shell. Selain itu, program ini juga masih bisa dikembangkan lagi. Harapannya program ini akan semakin berkembang dan kompleks, sehingga dapat menjadi salah satu software alternatif ketika suatu saat penggunaan software analisa struktur yang ada sekarang semakin dipersulit dengan adanya lisensi yang ketat.
1.2 Perumusan Masalah 1.2.1 Permasalahan utama Bagaimana melakukan analisa struktur elemen shell menggunakan metode elemen hingga dengan bantuan bahasa pemrograman Visual Basic 6.0?
3. Beban yang dikenakan pada struktur adalah beban statis berupa beban terpusat sejajar bidang pada titik nodal dan beban tarik permukaan pada 4 sisi shell. 4. Program dibuat dengan menggunakan bahasa pemrograman Visual Basic 6.0. 5. Output hasil analisa dibandingkan hanya dengan output dari program SAP. 1.5 Manfaat
1.2.2 Rincian permasalahan 1. Bagaimana cara menyusun algoritma pemrograman analisa struktur elemen shell dengan metode elemen hingga? 2. Bagaimana cara mendesain interface program analisa struktur elemen shell dengan “Metode Elemen Hingga” sehingga mudah digunakan oleh pelaku teknik sipil. 3. Apakah output yang dihasilkan dari program tersebut dapat dipertanggungjawabkan secara ilmiah?
Manfaat yang bisa didapatkan dari penulisan Tugas Akhir ini adalah : 1. Penyusun dapat lebih memahami cara penyusunan algoritma program analisa struktur. 2. Penyusunan program ini akan melengkapi program yang telah disusun sebelumnya. 3. Dengan semakin lengkapnya penyusunan program analisa struktur ini, maka harapan akan adanya sebuah program analisa struktur alternatif, yang lebih murah dan mudah untuk didapatkan, semakin realistis untuk diupayakan.
1.3 Tujuan 1. Menyusun algoritma pemrograman komputer untuk analisa struktur elemen shell dengan “Metode Elemen Hingga” 2. Mendesain program analisa struktur elemen shell dengan “Metode Elemen Hingga” dengan lebih sederhana sehingga mudah diaplikasikan oleh pelaku teknik sipil. 3. Mendesain program yang memiliki output yang dapat dibuktikan kebenarannya melalui perbandingan dengan output program analisa struktur shell yang lain. 1.4 Batasan Masalah Pada penulisan Tugas Akhir ini, penulis membatasi permasalahan yang dibahas pada halhal berikut ini : 1. Analisa struktur shell menggunakan metode elemen hingga. 2. Program analisa struktur ini dibuat hanya untuk menganalisa struktur shell berbentuk kuadriteral (segi-empat).
BAB III METODOLOGI Tahapan penyusunan tugas akhir ini dapat dilihat pada diagram alir berikut ini.
3.2 Alur Pemrograman Susunan program secara umum dibuat menurut diagram alir Gambar 3.2 dan untuk analisa elemen shell menurut diagram alir Gambar 3.3.
Gambar 3.1 Metodologi 3.1 Studi Literatur Pada tahap pertama ini dilakukan studi literatur tentang materi-materi yang berkaitan dengan pemrograman analisa elemen hingga pada shell. Mulai dari konsep dasar tentang metode analisa struktur menggunakan elemen hingga, kemudian penerapan analisa elemen hingga pada shell, sampai pada penyusunan algoritma program pada Visual Basic 6.0. Sumber-sumber yang digunakan antara lain : 1. Chandrakant S. Desai, Dasar-dasar Metode Elemen Hingga. 2. Daryl L. Logan, A First Course in the Finite Element Method. 3. William Weaver Jr., Matrix Structural Analysis with an Introduction to Finite Elements. 4. O. C. Zienkiewicz The Finite Element Method (The third, expanded and revised edition of The Finite Element Method in Engineering Sciences) 5. Wiryanto Dewobroto, Aplikasi Sains dan Teknik dengan Visual Basic 6.0. 6. Wiryanto Dewobroto, Aplikasi Rekayasa Konstruksi dengan SAP2000 (Edisi Baru). 7. SAP2000 Analysis Reference, Integrated Finite Element Analysis and Design of Structures.
Gambar 3.2 Flowchart program utama
⎤ ⎡ 1 v 0 ⎥ ⎢ [C ] = E 2 ⎢v 1 0 ⎥ 1− v ⎢ 1− v⎥ ⎥ ⎢0 0 2 ⎦ ⎣ 3.2.3 Perhitungan matriks jacobi Matriks jacobi pada setiap elemen dapat dihitung berdasarkan data koordinat tiap nodal, dengan menggunakan rumus berikut
J =
1 [(x13 y 24 − x24 y13 ) + s(x34 y12 − x12 y34 ) + t (x23 y14 − x14 y 8
dimana
xij = xi − x j y ij = y i − y j
3.2.4 Perhitungan matriks B
Gambar 3.3 Diagram alir analisa elemen shell 3.2.1 Identifikasi Data input diidentifikasi ke dalam matriksmatriks data : 1. Data material yang berisi modulus elastisitas (E) dan poisson’s ratio (v). 2. Data nodal beserta koordinatnya. 3. Data elemen yang berisi informasi nodal j1,j2,j3, dan j4 serta data material pada setiap elemen. 4. Data perletakan di nodal, yang akan digunakan untuk memberikan kondisi batas pada rumus [K].{D}={Q}, berisi indeks nodal dan batasan pada tiap DOF-nya. 5. Data beban, baik beban tarik permukaan maupun beban di titik nodal sejajar permukaan.
3.2.2 Perhitungan matriks C Untuk mendapatkan matriks C, digunakan data-data yang teridentifikasi sebagai data material yaitu modulus elastisitas (E) dan poisson’s ratio (v). Berikut ini merupakan rumus perhitungan untuk mendapatkan matriks C
Setelah mendapatkan matriks Jacobi, maka matriks B dapat dibentuk. Matriks B dihitung untuk setiap titik integrasi, dengan menggunakan rumus berikut :
B11 =
1 ( y 24 − y34 s − y 23t ) 8J
B21 =
1 (− x24 + x34 s + x23t ) 8J
B12 =
1 (− y13 + y34 s + y14 t ) 8J
1 (x13 − x34 s − x14 t ) 8J 1 (− y 24 + y12 s − y14 t ) B13 = 8J 1 (x24 − x12 s + x14 t ) B23 = 8J 1 ( y13 − y12 s + y 23t ) B14 = 8J B22 =
B24 =
1 (− x13 + x12 s − x23t ) 8J
Hasil perhitungan tersebut dimasukkan dalam matriks B berorde 3 x 8 berikut ini : ⎡ B11 [B] = ⎢⎢ 0 ⎢B ⎣ 21
B
12
0
B
22
B
13
0
0
0
B
B B
B B
B B
14
0
B
B
0
23
24
21
11
22
12
23
13
0 ⎤ ⎥ B24⎥ B14 ⎥⎦
3.2.5 Pembentukan matriks kekakuan lokal Matriks kekakuan lokal tiap elemen dibentuk dengan menggunakan rumus berikut, N
proses reduksi, persamaan diselesaikan dengan eliminasi Gauss dengan pivoting, menghasilkan matriks perpindahan {D}.
3.2.8 Perhitungan reaksi perletakan (joint reaction) Untuk mendapatkan reaksi perletakan, maka hasil matriks perpindahan tereduksi {D} harus dirubah kembali menjadi matriks perpindahan utuh {d}. Baru kemudian reaksi perletakan diperoleh dengan rumus, {R}=[K].{d}
[k ] = ∑ [B(si , t i )] [C ][B(si , t i )] J (si , t i ) T
i =1
3.2.9 Perhitungan forces) 3.2.6 Pembentukan matriks kekakuan global Matriks kekakuan lokal setiap elemen kuadrilateral memiliki orde (8,8), sementara matriks kekakuan global memiliki orde (2xjumlah nodal, 2xjumlah nodal). Sehingga diperlukan penyesuaian matriks kekakuan lokal terhadap matriks kekakuan global. Hal ini dilakukan dengan cara meletakkan menempatkan matriks kekakuan lokal berdasarkan nodal global. Setelah dilakukan penyesuaian matriks kekakuan lokal terhadap matriks kekakuan global. Maka matriks kekakuan struktur dapat dibentuk dengan rumus berikut ini, elemen
[K ] = ∑ [K ]i i =1
3.2.7 Perhitungan perpindahan nodal (nodal displacement) Setelah pembentukan matriks kekakuan global, dilakukan penyusunan matriks beban lokal yang kemudian disusun menjadi matriks beban global. Kemudian perhitungan perpindahan nodal {D} disusun melalui penyelesaian rakitan elemen berikut ini, [K].{D}={Q} Agar dan kekakuan kondisi batas restraint yang
bisa diselesaikan maka matriks beban struktur harus direduksi sesuai dengan (boundary condition) akibat adanya telah diidentifikasi sebelumnya. Setelah
gaya
Gaya dalam menggunakan rumus,
dalam
(element
dihitung
dengan
{σ}=[C].[B].{d}
3.3 Pembuatan Program Pembuatan program terdiri dari 3 tahap, yaitu :
3.3.1 Penyusunan bahasa pemrograman Kegiatan penyusunan pemrograman, dimulai dengan mempelajari bahasa pemrograman Visual Basic 6.0. Setelah mengetahui bahasa pemrograman Visual Basic 6.0, dilanjutkan dengan penyusunan program analisa elemen shell berbasis metode elemen hingga Selain itu, karena program Visual Basic tidak mampu untuk memberikan output berupa kontur, sehingga proses pemrograman akan dilanjutkan dengan program Matlab yang dapat membantu dalam memberikan output berupa kontur.
3.3.2 Running program Langkah selanjutnya adalah menjalankan program yang telah jadi dengan menggunakan beberapa contoh kasus
3.3.3 Verifikasi output Untuk mengetahui kebenaran output program, maka output akan dibandingkan dengan hasil perhitungan contoh kasus di atas dengan menggunakan program SAP. 3.4 Perbaikan Tampilan Setelah kebenaran output dari program telah teruji, langkah terakhir adalah memperbaiki tampilan (interface) agar lebih menarik dan mudah untuk digunakan oleh semua kalangan.
2. Form input, merupakan form yang dibuat sebagai tempat untuk memasukkan data-data struktur sebagai input. Ada beberapa form input yang disusun, yaitu form informasi umum (General Information.frm), form data material (Input Material.frm), form koordinat (Input Coordinate.frm), form elemen (Input Element.frm), form perletakan (Input Restraints.frm), form beban tarik permukaan (Input Surface Load.frm), form beban nodal sejajar bidang (Input Joint Load.frm), form editor (Editor.frm). Berikut ini tampilan utama program SEAP (Shell Element Analysis Program)
BAB IV PENYUSUNAN PROGRAM 4.1
Penjelasan Program
Program bantu analisa struktur ini dibuat berdasarkan pola alur analisa elemen hingga umum seperti yang telah tertera pada bab sebelumnya. Namun untuk keperluan programming maka diagram alir tersebut dimodifikasi sesuai dengan kebutuhan agar dapat diselesaikan dalam bahasa Basic. Program analisa struktur ini ditulis menjadi beberapa bagian. Hal ini bertujuan untuk memudahkan proses debugging bila terjadi kesalahan saat pengerjaan program maupun untuk keperluan pengembangan. Bagian utama dari program ini dibagi menjadi 3:
1. Modul file manager, berisi prosedurprosedur pengelola file, input dan output data, pengatur format tabel dan form. Modul ini disimpan dengan nama “File Manager.bas”. 2. Modul analisa struktur, berisi kode-kode untuk analisa data input yang diberikan oleh file manager. Modul ini disimpan dengan nama “Struc Analysis.bas”. 3. Modul plot 2 dimensi, berisi kode-kode untuk plotting 2 dimensi model struktur yang dianalisa. Modul ini disimpan dengan nama “2D Graph.bas”. Kode pemrograman yang terdapat pada modul-modul diatas kemudian dipanggil dari beberapa form, sesuai dengan interface yang telah dirancang di awal. Form yang dibuat antara lain : 1. Form utama, merupakan form yang menampilkan input, output dan hasil plotting. Form ini disimpan dengan nama “Main Form.frm”.
Gambar 4.1 Tampilan utama program SEAP
Gambar 4.2a Diagram alir program SEAP
C
Tampilkan data output
Preplot : Xmax, Xmin Ymax, Ymin Xshift, Yshift
Set parameter plot: Ixy_angle dYYShift, dXXShift Prespctv, zoom dispfactor
Plot frame Plot support Plot label dan koordinat Plot loading
Finish
Gambar 4.2b Diagram alir program SEAP (sambungan)
Gambar 4.2c Diagram alir program SEAP (sambungan)
4.1.1
Prosedur baca data
Data input dari user pada jendela Editor berupa susunan text dengan format tertentu disimpan ke lokasi yang ditentukan sebelumnya secara langsung dengan filestream: Set filestream = filedata.CreateTextFile(xfile, True) str = txtEditor.Text filestream.Write (str) filestream.Close
Stream data kemudian dibaca ke dalam variabel-variabel yang dideklarasikan dalam modul analisa: 1. Array data material data_material() dengan tipe data user-defined data_material yang terdiri dari variabel mod, pr dan mname.
2. Array data nodal node() dengan tipe data user-defined data_node terdiri dari variabel yang menyatakan koordinat x, dan y. 3. Array data elemen element() dengan tipe data user-defined data_element terdiri dari variabel-variabel j1, j2, j3, j4, E, dan v. 4. Matriks perletakan (joint restraint list) jrl() dengan tipe data integer. 5. Vektor beban tarik permukaan pada sload() dan vektor beban nodal sejajar bidang pada jload() masing-masing disimpan dengan tipe data double.
4.1.2
Prosedur matriks C
Setiap elemen yang dibentuk dari data nodal yang dimasukkan, akan memiliki nilai modulus elastisitas dan poisson’s ratio masing-masing sehingga matriks C dibentuk berdasarkan data input material setiap elemen. Kemudian prosedur yang sama diulang untuk setiap elemen hingga elemen terakhir For i = 1 To je With element(i) B(1, 1) = 1 B(1, 2) = .v B(1, 3) = 0 B(2, 1) = .v B(2, 2) = 1 B(2, 3) = 0 B(3, 1) = 0 B(3, 2) = 0 B(3, 3) = (1 - .v) / 2 A = .E / (1 - (.v ^ 2)) For j = 1 To 3 For l = 1 To 3 mtrxC(j, l, i) = A * B(j, l) Next l Next j End With Next i
4.1.3
Prosedur matriks jacobi
Dari data nodal yang dimasukkan didapatkan Xij dan Yij yang dikodekan sebagai nodes(). Kemudian matriks jacobian dihitung pada setiap elemen dengan menggunakan masing-masing titik integrasi yang dikodekan sebagai area(). For i = 1 To je With element(i) A=(nodes(.j1,.j3).X*nodes(.j2,.j4 ).Y)nodes(.j2,.j4).X*nodes(.j1, .j3).Y) B=(nodes(.j3,.j4).X*nodes(.j1,.j2 ).Y)(nodes(.j1,.j2).X*nodes(.j3,.j4). Y)
C=(nodes(.j2,.j3).X*nodes(.j1,.j4 ).Y)- (nodes(.j1,.j4).X*nodes(.j2,3).Y) For j = 1 To 4 jac(j, i)=0.125*(A+(area(j).s*B)+(area(j).t*C) ) Next j End With Next i
4.1.4
Prosedur matriks B
Matriks B dihitung dengan menggunakan hasil prosedur matriks Jacobian sebelumnya. Karena matriks B harus dihitung di setiap titik integrasi dan titik integrasi dalam satu elemen kuadrilateral berjumlah 4, sehingga dibentuk tipe data user-defined matrix_B berisi B1, B2, B3, dan B4 For j = 1 To je With element(j) i = 1 A = 1 / (8 * jac(i, j)) mtrxB(1, 1, j).B1 = A * (nodes(2, 4).Y (nodes(3, 4).Y * area(i).s) (nodes(2, 3).Y * area(i).t)) mtrxB(1, 2, j).B1 = A * (nodes(1, 3).Y + (nodes(3, 4).Y * area(i).s) + (nodes(1, 4).Y * area(i).t)) mtrxB(1, 3, j).B1 = A * (nodes(2, 4).Y + (nodes(1, 2).Y * area(i).s) (nodes(1, 4).Y * area(i).t)) mtrxB(1, 4, j).B1 = A * (nodes(1, 3).Y (nodes(1, 2).Y * area(i).s) + (nodes(2, 3).Y * area(i).t)) mtrxB(1, 5, j).B1 = 0 mtrxB(1, 6, j).B1 = 0 mtrxB(1, 7, j).B1 = 0 mtrxB(1, 8, j).B1 = 0 mtrxB(2, 1, j).B1 = 0 mtrxB(2, 2, j).B1 = 0 mtrxB(2, 2, j).B1 = 0 mtrxB(2, 3, j).B1 = 0 mtrxB(2, 5, j).B1 = A * (nodes(2, 4).X + (nodes(3, 4).X * area(i).s) + (nodes(2, 3).X * area(i).t)) mtrxB(2, 6, j).B1 = A * (nodes(1, 3).X (nodes(3, 4).X * area(i).s) (nodes(1, 4).X * area(i).t)) mtrxB(2, 7, j).B1 = A * (nodes(2, 4).X (nodes(1, 2).X * area(i).s) + (nodes(1, 4).X * area(i).t)) mtrxB(2, 8, j).B1 = A * (nodes(1, 3).X + (nodes(1, 2).X * area(i).s) (nodes(2, 3).X * area(i).t)) mtrxB(3, 1, j).B1 = mtrxB(2, 5, j).B1 mtrxB(3, 2, j).B1 = mtrxB(2, 6, j).B1
mtrxB(3,
3,
j).B1
=
mtrxB(2,
mtrxB(3,
4,
j).B1
=
mtrxB(2,
mtrxB(3,
5,
j).B1
=
mtrxB(1,
mtrxB(3,
6,
j).B1
=
mtrxB(1,
mtrxB(3,
7,
j).B1
=
mtrxB(1,
mtrxB(3,
8,
j).B1
=
mtrxB(1,
7, j).B1 8, j).B1 1, j).B1 2, j).B1 3, j).B1 4, j).B1
dan seterusnya dengan merubah nilai i menjadi 2, 3, dan 4, serta merubah komponen .B1 menjadi .B2, .B3, dan .B4.
4.1.5
Prosedur matriks kekakuan
Karena perhitungan matriks kekakuan melibatkan matriks transpose dari matriks B maka prosedur yang pertama kali dilakukan adalah prosedur transpose matriks B untuk setiap titik integrasi. For l = 1 To je With element(l) For i = 1 To 3 'transpose matriks B For j = 1 To 8 mtrxBT(j, i, l).B1 = mtrxB(i, j, l).B1 mtrxBT(j, i, l).B2 = mtrxB(i, j, l).B2 mtrxBT(j, i, l).B3 = mtrxB(i, j, l).B3 mtrxBT(j, i, l).B4 = mtrxB(i, j, l).B4 Next j Next i
Setelah itu baru kemudian dilanjutkan dengan prosedur perkalian matriks antara matriks B transpose dengan matriks C.
n,
n,
n,
n,
For i = 1 To 8 For j = 1 To 3 Sum1 = 0 Sum2 = 0 Sum3 = 0 Sum4 = 0 For n = 1 To 3 Sum1 = Sum1 l).B1 * mtrxC(n, j, l)) Sum2 = Sum2 l).B2 * mtrxC(n, j, l)) Sum3 = Sum3 l).B3 * mtrxC(n, j, l)) Sum4 = Sum4 l).B4 * mtrxC(n, j, l)) Next n A1(i, j) = Sum1 A2(i, j) = Sum2
A3(i, j) = Sum3 A4(i, j) = Sum4 Next j Next i
Hasil perkalian kedua matriks tersebut kemudian dikalikan kembali dengan matriks B. Pembentukan matriks kekakuan di empat titik integrasi , yang dikodekan sebagai mtrxK(), dilakukan dengan mengalikan hasil perkalian tiga matriks sebelumnya dengan nilai jacobian sesuai titik integrasi masingmasing. For i = 1 To 8 'matriks k di titik integrasi For j = 1 To 8 Sum5 = 0 Sum6 = 0 Sum7 = 0 Sum8 = 0 For n = 1 To 3 Sum5 = Sum5 + (A1(i, n) * mtrxB(n, j, l).B1) Sum6 = Sum6 + (A2(i, n) * mtrxB(n, j, l).B2) Sum7 = Sum7 + (A3(i, n) * mtrxB(n, j, l).B3) Sum8 = Sum8 + (A4(i, n) * mtrxB(n, j, l).B4) Next n mtrxK(i, j, l).k1 = Sum5 * jac(1, l) mtrxK(i, j, l).k2 = Sum6 * jac(2, l) mtrxK(i, j, l).k3 = Sum7 * jac(3, l) mtrxK(i, j, l).k4 = Sum8 * jac(4, l) Next j Next i
Setelah itu matriks kekakuan di tiap titik integrasi dijumlahkan, sehingga menghasilkan matriks kekakuan lokal elemen yang dikodekan sebagai mtrxStiffnessLoc().
+ (mtrxBT(i,
+ (mtrxBT(i,
+ (mtrxBT(i,
+ (mtrxBT(i,
For i = 1 To 8 For j = 1 To 8 mtrxStiffnessLoc(i, j, l) = mtrxK(i, j, l).k1 + mtrxK(i, j, l).k2 + _ mtrxK(i, j, l).k3 + mtrxK(i, j, l).k4 Next j Next i
Matriks kekakuan lokal yang telah didapatkan harus disesuaikan dengan orde matriks kekakuan struktur (2.jumlah node x 2.jumlah node). Hasil penyesuaian ini disebut matriks kekakuan global elemen yang dikodekan sebagai mtrxStiffnessGlo(). 'matriks lokal -> matriks global
mtrxStiffnessGlo(node(.j1).dirX, node(.j1).dirX, l) mtrxStiffnessLoc(1, 1, l) mtrxStiffnessGlo(node(.j1).dirX, node(.j2).dirX, l) mtrxStiffnessLoc(1, 2, l) mtrxStiffnessGlo(node(.j1).dirX, node(.j3).dirX, l) mtrxStiffnessLoc(1, 3, l) mtrxStiffnessGlo(node(.j1).dirX, node(.j4).dirX, l) mtrxStiffnessLoc(1, 4, l) mtrxStiffnessGlo(node(.j1).dirX, node(.j1).dirY, l) mtrxStiffnessLoc(1, 5, l) mtrxStiffnessGlo(node(.j1).dirX, node(.j2).dirY, l) mtrxStiffnessLoc(1, 6, l) mtrxStiffnessGlo(node(.j1).dirX, node(.j3).dirY, l) mtrxStiffnessLoc(1, 7, l) mtrxStiffnessGlo(node(.j1).dirX, node(.j4).dirY, l) mtrxStiffnessLoc(1, 8, l) mtrxStiffnessGlo(node(.j2).dirX, node(.j1).dirX, l) mtrxStiffnessLoc(2, 1, l) mtrxStiffnessGlo(node(.j2).dirX, node(.j2).dirX, l) mtrxStiffnessLoc(2, 2, l) mtrxStiffnessGlo(node(.j2).dirX, node(.j3).dirX, l) mtrxStiffnessLoc(2, 3, l) mtrxStiffnessGlo(node(.j2).dirX, node(.j4).dirX, l) mtrxStiffnessLoc(2, 4, l) mtrxStiffnessGlo(node(.j2).dirX, node(.j1).dirY, l) mtrxStiffnessLoc(2, 5, l) mtrxStiffnessGlo(node(.j2).dirX, node(.j2).dirY, l) mtrxStiffnessLoc(2, 6, l) mtrxStiffnessGlo(node(.j2).dirX, node(.j3).dirY, l) mtrxStiffnessLoc(2, 7, l) mtrxStiffnessGlo(node(.j2).dirX, node(.j4).dirY, l) mtrxStiffnessLoc(2, 8, l)
=
4.1.6 Pembentukan matriks beban lokal dan global
=
Pembentukan matriks beban diawali dengan menyusun matriks beban tarik permukaan dan matriks beban nodal dengan menggunakan data-data yang sebelumnya telah diidentifikasi sebagai sload() dan
=
jload(). =
=
=
For i = 1 To je With element(i) For j = 1 To 4 mtrxSLoad(j, i) = 0.5 (sload(i, j).SxL + sload(i, Abs(j - 5)).SxL) Next j
*
=
=
=
=
=
=
=
=
=
=
dan seterusnya hingga mtrxStiffnessLoc(8, 8, l).
Setelah matriks kekakuan global tiap elemen terbentuk, barulah matriks kekakuan struktur dihitung dengan (mtrxStiffness())dapat menjumlahkan nilai-nilai pada matriks kekakuan global tiap elemen. 'matriks struktur = sum(matriks global) For i = 1 To RM For j = 1 To RM mtrxStiffness(i, j) = mtrxStiffness(i, j) + mtrxStiffnessGlo(i, j, l) Next j Next i Next l
For j = 5 To 8 l = j - 4 mtrxSLoad(j, i) = 0.5 (sload(i, l).SyL + sload(i, Abs(l - 5)).SyL) Next j mtrxJLoad(1, mtrxJLoad(2, mtrxJLoad(3, mtrxJLoad(4, mtrxJLoad(5, mtrxJLoad(6, mtrxJLoad(7, mtrxJLoad(8,
i) i) i) i) i) i) i) i)
= = = = = = = =
*
jload(.j1).jx jload(.j2).jx jload(.j3).jx jload(.j4).jx jload(.j1).jy jload(.j2).jy jload(.j3).jy jload(.j4).jy
Lalu membentuk matriks beban lokal, mtrxLoadLoc(), dengan dikodekan sebagai menjumlahkan matriks beban yang telah dibentuk sebelumnya. For j = 1 To 8 mtrxLoadLoc(j, mtrxSLoad(j, i) + mtrxJLoad(j, i) Next j
i)
=
Matriks beban lokal elemen, sama halnya dengan matriks kekakuan lokal elemen, perlu dirubah menjadi matriks beban global elemen, dikodekan sebagai mtrxLoadGlo(), agar kemudian dapat dibentuk menjadi matriks beban struktur yang dikodekan sebagai mtrxLoad(). 'matriks beban lokal -> matriks beban global mtrxLoadGlo(node(.j1).dirX, i) = mtrxLoadLoc(1, i) mtrxLoadGlo(node(.j2).dirX, i) = mtrxLoadLoc(2, i) mtrxLoadGlo(node(.j3).dirX, i) = mtrxLoadLoc(3, i) mtrxLoadGlo(node(.j4).dirX, i) = mtrxLoadLoc(4, i) mtrxLoadGlo(node(.j1).dirY, i) = mtrxLoadLoc(5, i)
mtrxLoadGlo(node(.j2).dirY, mtrxLoadLoc(6, i) mtrxLoadGlo(node(.j3).dirY, mtrxLoadLoc(7, i) mtrxLoadGlo(node(.j4).dirY, mtrxLoadLoc(8, i)
i)
=
i)
=
i)
=
'Assemble structural load matrix For j = 1 To RM mtrxLoad(j) = mtrxLoad(j) mtrxLoadGlo(j, i) Next j End With Next i
+
Next n Next m
4.1.8 Prosedur {Q}=[K]×{D}
condition
dan
reduksi
Kondisi batas atau boundary condition diperlukan dalam perhitungan analisa matriks agar persamaan Q=K×D bisa diselesaikan. Pada kondisi awal matriks kekakuan global struktur [K] adalah matriks singular yang tidak mempunyai invers. Pada keadaan sebenarnya hal ini berarti struktur tidak stabil, tidak bisa berdiri kokoh walau tanpa beban sekalipun. Pemberian kondisi batas dilakukan dengan memberikan batasan displacement berupa perletakan (restraint). Dalam analisa, nilai matriks displacement pada nodal dengan restraint adalah sama dengan nol. Setelah menentukan kondisi batas, hal selanjutnya adalah mereduksi matriks-matriks kekakuan global [K], displacement {D} dan gaya/beban {Q} pada baris dan kolom yang bersesuaian dengan kondisi batas. Matriks-matriks tersebut direduksi sesuai dengan array indeks matriks tereduksi yang dibentuk berdasarkan array joint restraint list yang telah didefinisikan pada prosedur baca data. Adapun variabel matriks-matriks tereduksi adalah K(), Load(), dan Disp().
persamaan
Penyelesaian persamaan kekakuan dalam program ini menggunakan metode eliminasi GaussJordan, yaitu dengan menjadikan matriks [K] menjadi matriks identitas untuk proses subtitusi balik untuk memperoleh nilai [D]. 200:
4.1.7 Boundary matriks
penyelesaian
'normalization For j = l + 1 To n A(l, j) = A(l,
j)
/
A(l, l) Next j B(l) = B(l) / A(l, l) If i = n Then GoTo 300 Else GoTo 250
220:
'pivoting For i = l + 1 To n If A(i, l) <>
0
Then
GoTo 230
230:
Next i 'matrix is singular GoTo 300 For j = l + 1 To n t = A(l, j) A(l, j) = A(i, j) A(i, j) = t Next j t = B(l) B(l) = B(i) B(i) = t GoTo 200
'elimination For i = 1 To n If i = l Then For j = l + 1 A(i, j) = A(i, l)*A(l,j) Next j B(i) = B(i) B(l) 265: Next i Next l X = B 250:
'indexing reduced matrix BMR = 0 For i = 1 To RM If irm(i) = 0 Then BMR = BMR + 1 End If Next i ReDim idm(BMR) As Integer m = 0 For i = 1 To RM If irm(i) = 0 Then m = m + 1 idm(m) = i End If Next i 'reducing matrix ReDim K(BMR, BMR) As Double ReDim load(BMR) As Double For m = 1 To BMR load(m) = mtrxLoad(idm(m)) For n = 1 To BMR K(m, n) = mtrxStiffness(idm(m), idm(n))
GoTo 265 To n A(i, j) -
A(i, l) *
Listing kode metode Gauss-Jordan tersebut adalah prosedur umum untuk menyelesaikan persamaan linier [A]{X}={B}. Sehingga untuk keperluan penyelesaian persamaan kekakuan prosedur tersebut perlu dipanggil: Call gauss_jordan(K, Load, Disp, BMR)
sehingga [A]=K(), {X}=Disp(), {B}=Load(), dan n=BMR, dimana BMR adalah dimensi matriks tereduksi.
4.1.9 Prosedur pembentukan perpindahan nodal
matriks
Penyelesaian persamaan {Q}=[K]×{D} akan menghasilkan perpindahan pada nodal yang dihitung. Untuk membentuk matriks perpindahan nodal struktur, maka perpindahan nodal yang didapatkan kembali disesuaikan dengan orde matriks perpindahan nodal struktur yang berjumlah 2 kali jumlah nodal. For m = 1 To BMR If Disp(m) <> mtrxDisp(idm(m)) = Disp(m) Next m
0
Then
4.1.10 Prosedur reaksi perletakan Reaksi perletakan dihitung dengan menggunakan hasil penyesuaian matriks perpindahan tereduksi, yang dikodekan sebagai Disp(), menjadi matriks perpindahan utuh, yang dikodekan sebagai mtrxDisp(). Kemudian membentuk matriks reaksi perletakan, yang dikodekan sebagai mtrxReaction(), dengan mengalikan matriks kekakuan utuh dengan matriks perpindahan utuh. For i = 1 To RM Sum = 0 For j = 1 To RM Sum = Sum + mtrxStiffness(i, j) * mtrxDisp(j) Next j mtrxReaction(i) = Sum - mtrxLoad(i) Next i
4.1.11 Prosedur gaya elemen
Gaya elemen dihitung dengan menggunakan rumus {σ}=[C].[B].{d}. Karena matriks C dan matriks B merupakan matriks yang disusun pada tiap elemen sehingga perhitungan gaya elemen membutuhkan matriks perpindahan lokal yang dikodekan sebagai mtrxDispLoc(). Sehingga matriks perpindahan global yang telah didapatkan sebelumnya harus disesuaikan dengan orde matriks perpindahan lokal yaitu (8 x 1), yang dikodekan sebagai mtrxDispLoc().
mtrxDispLoc(4, mtrxDisp(node(.j4).dirX) mtrxDispLoc(5, mtrxDisp(node(.j1).dirY) mtrxDispLoc(6, mtrxDisp(node(.j2).dirY) mtrxDispLoc(7, mtrxDisp(node(.j3).dirY) mtrxDispLoc(8, mtrxDisp(node(.j4).dirY)
i)
=
i)
=
i)
=
i)
=
i)
=
Setelah penyesuaian itu barulah kemudian penghitungan gaya elemen dilakukan dengan mengalikan matriks C dengan matriks B, kemudian dilanjutkan dengan mengalikan hasil perkalian sebelumnya dengan matriks perpindahan lokal. For j = 1 To 3 For m = 1 To 8 Sum1 = 0 Sum2 = 0 Sum3 = 0 Sum4 = 0 For l = 1 To 3 Sum1 = Sum1 (mtrxC(j, l, i) * mtrxB(l, m, i).B1) Sum2 = Sum2 (mtrxC(j, l, i) * mtrxB(l, m, i).B2) Sum3 = Sum3 (mtrxC(j, l, i) * mtrxB(l, m, i).B3) Sum4 = Sum4 (mtrxC(j, l, i) * mtrxB(l, m, i).B4) Next l C1(j, m, i) = Sum1 C2(j, m, i) = Sum2 C3(j, m, i) = Sum3 C4(j, m, i) = Sum4 Next m Next j
+
+
+
+
For j = 1 To 3 Sum5 = 0 Sum6 = 0 Sum7 = 0 Sum8 = 0 For l = 1 To 8 Sum5 = Sum5 + (C1(j, l, i) * mtrxDispLoc(l, i)) Sum6 = Sum6 + (C2(j, l, i) * mtrxDispLoc(l, i)) Sum7 = Sum7 + (C3(j, l, i) *
'matriks displacement local For i = 1 To je With element(i) mtrxDispLoc(1, mtrxDisp(node(.j1).dirX) mtrxDispLoc(2, mtrxDisp(node(.j2).dirX) mtrxDispLoc(3, mtrxDisp(node(.j3).dirX)
mtrxDispLoc(l, i)) Sum8 = Sum8 + (C4(j, l, i) * i)
=
i)
=
i)
=
mtrxDispLoc(l, i)) Next l mtrxForce(4 * i - 3, j, i) = Sum5 mtrxForce(4 * i - 2, j, i) = Sum6
mtrxForce(4 * i - 1, j, i) = Sum7 mtrxForce(4
*
i,
j,
i)
=
Sum8 Next j End With Next i
4.1.12 Pemanggilan prosedur-prosedur Setelah prosedur analisa struktur selesai, eksekusi program dilakukan dengan memanggil setiap prosedur secara berurutan seperti berikut ini. matrix_C jacobian matrix_B matrix_k matrix_load boundary_condition Call gauss_jordan(K,
Gambar 4.3 Tampilan GUI jendela utama SEAP load,
Disp,
BMR) matrix_displacement node_reaction element_forces
4.2
System Requirement
Program bantu analisa struktur ini tidak membutuhkan banyak resource sehingga cukup ringan bila digunakan pada komputer-komputer umum sekarang. Adapun perkiraan spesifikasi minimum komputer yang dibutuhkan adalah: 1. Prosesor Intel Pentium 4 atau yang sekelas 2. RAM 512 mb (tergantung tingkat kompleksitas struktur yang dianalisa) 3. VGA 32 mb dengan resolusi monitor 1024×768
4.3
Untuk memulai Project baru klik menu File > New, atau tekan Ctrl-N untuk mengosongkan input yang telah ada. Selanjutnya ketik nama project baru yang akan dihitung melalui menu Input>General Information, atau tekan F1.
Gambar 4.4 Input nama proyek Isikan nama project. Klik OK untuk keluar dari jendela input General Information. Kemudian klik menu Input > Material Properties atau tekan F2 untuk membuka jendela input material.
Pengoperasian Program
Setelah program dibuka, akan muncul tampilan pertama jendela utama program SEAP ini.
Gambar 4.5 Input material properties Nilai yang perlu dimasukkan sebagai input adalah nama material, Modulus Elastis E dan rasio
Poisson v. Klik Add untuk memasukkan ke daftar Material. Klik OK. Di langkah berikutnya adalah jendela input koordinat titik nodal (Gambar 4.6). Klik menu Input>Nodal Coordinate. Koordinat yang digunakan adalah koordinat kartesian global, dengan bidang X-Y sebagai bidang dasar (denah/plan).
menu dropdown Joint label pilih letak joint perletakan, klik Fast Restraints untuk restraints instan.
Gambar 4.8 Input perletakan Gambar 4.6 Input koordinat nodal Selanjutnya klik menu Input>Elements atau tekan F4 untuk menampilkan jendela input elemen. Pilih jenis material untuk elemen. Kemudian pilih nodal yang diinginkan untuk menjadi joint 1 sampai joint 4 pada elemen. Nilai modulus elastisitas dan poisson’s ratio akan secara otomotis terbaca sesuai dengan jenis material yang dipilih.
Gambar 4.7. Input elemen Langkah berikutnya adalah input data joint restraint. klik menu Input>Joint Restraints atau tekan F5 untuk menampilkan jendela input perletakan setiap joint. Joint-joint yang menjadi perletakan dikunci deformasinya sesuai dengan jenis perletakannya. Pada
2 langkah berikutnya berturut-turut adalah input beban tarik permukaan dan beban titik nodal sejajar bidang elemen. Klik menu Input>Surface Pressure Load atau tekan F6 untuk menampilkan jendela input beban tarik permukaan. Pilih elemen yang ingin diberikan beban, kemudian tentukan sisi (face) berapa yang ingin diberi beban. Kemudian tambahkan nilai beban.
Gambar 4.9 Input beban tarik permukaan Klik menu Input>Joint Loads atau tekan F7 untuk menampilkan jendela input beban di titik nodal sejajar bidang. Pilih nodal yang ingin diberikan beban, Kemudian tambahkan nilai beban.
Gambar 4.12 Jendela SEAP editor
Gambar 4.10 Input beban di titik nodal sejajar bidang Setelah semua data diinputkan, klik menu Analyze > Run Analysis untuk memulai proses analisa dan menampilkan data input, data output dan grafik pada jendela utama program bantu analisa struktur ini. Proses pembacaan data untuk analisa dilakukan secara berurutan sesuai urutan input data.
Adapun data dalam SEAP Editor harus ditulis dengan format atau urut-urutan tertentu agar bisa dianalisa oleh SEAP. 1. 2. 3. 4.
Keterangan Gambar 4.13 dan Gambar 4.14: Tab Input, berisi tabel-tabel nilai masukan. Tab 3-D View, menampilkan bentuk pemodelan struktur yang dianalisa. Frame View Control, panel kontrol untuk mengatur tampilan gambar model. Tab Output, berisi tabel-tabel nilai hasil analisa (node displacement, support reaction dan elemen force).
2
1 Gambar 4.11 Rekam hasil input Data disimpan dalam file berekstensi .seap (SEAP input file) atau .txt (Text file). File ini dapat dibuka langsung menggunakan text editor semacam Notepad atau SEAP Editor (gambar 4.12).
3 Gambar 4.13 Jendela utama SEAP (Tab Input)
X12
-1
Y12
0
X13
-1
Y13
-1
X14
0
Y14
-1
X23
0
Y23
-1
X24
1
Y24
-1
X34
1
Y34
0
Perhitungan |J|
4
Untuk (s1,t1) |J| =
Untuk (s2,t2) 0,25
Untuk (s3,t3)
Gambar 4.14 Jendela utama SEAP (Tab Output)
|J| =
|J| =
0,25
Untuk (s4,t4) 0,25
|J| =
0,25
Untuk (s1,t1)
B11
-0,789
Untuk (s2,t2)
B11
-0,789
Untuk (s3,t3)
B11
-0,212
Untuk (s4,t4) Tot al
B11
-0,212
B11
-2,000
Untuk (s1,t1)
B13
0,212
Untuk (s2,t2)
B13
0,212
Untuk (s3,t3)
B13
0,789
Untuk (s4,t4) Tot al
B13
0,789
B13
2,000
Untuk (s1,t1)
B21
-0,789
Untuk (s2,t2)
B21
-0,212
Untuk (s3,t3)
B21
-0,212
Untuk (s4,t4) Tot al
B21
-0,789
B21
-2,000
Untuk (s1,t1)
B12
0,789
Untuk (s2,t2)
B12
0,789
Untuk (s3,t3)
B12
0,212
Untuk (s4,t4) Tot al
B12
0,212
B12
2,000
Perhitungan B
BAB V STUDI KASUS
B11
Untuk mengetahui kebenaran dan ketelitian program bantu analisa struktur ini dalam melakukan proses perhitungan, maka diperlukan uji perbandingan hasil output program terhadap perhitungan manual dan program bantu profesional SAP2000.
5.1 Contoh Kasus 1
B13
Contoh kasus pertama yang digunakan berasal dari buku ”Dasar-dasar Metode Elemen Hingga” yang ditulis oleh C.S. Desai Data-data elemen: - Modulus elastisitas = 10000 kg/cm2 - Poisson’s ratio = 0,3 - Data koordinat elemen: - Joint 1 = 0, 0 - Joint 2 = 1,0 - Joint 3 = 1,1 - Joint 4 = 0,1 - Beban tarik permukaan : - Pada sisi 2 - Tx = 1 kg/cm
5.1.1 Perhitungan Manual Perhitungan matriks [B]
Perhitungan Xij & Yij Xij = Xi - Xj Yij = Yi - Yj
B21
B12
8
B14 Untuk (s1,t1)
B14
-0,212
Untuk (s2,t2)
B14
-0,212
Untuk (s3,t3)
B14
-0,789
Untuk (s4,t4) Tot al
B14
-0,789
B14
-2,000
700 4
1 119 1 288 3
4
1
166 1
378
247 4
494
150
253 9
664
320
150
664
494 288 3
B22 Untuk (s1,t1)
B22
-0,212
Untuk (s2,t2)
B22
-0,789
Untuk (s3,t3)
B22
-0,789
Untuk (s2,t2)
Untuk (s4,t4) Tot al
B22
-0,212
B22
-2,000
700 4
119 1
619 1
288 3
184 1
B23 Untuk (s1,t1)
B23
0,212
Untuk (s2,t2)
B23
0,789
Untuk (s3,t3)
B23
0,789
Untuk (s4,t4) Tot al
B23
0,212
B23
2,000
922 4
140 8 559 444 1 922 4
247 4 253 9
222 2 247 4
559
140 8 619 1 119 1 700 4
184 1 288 3
166 1 494 247 4 119 1 150 378 664
Untuk (s1,t1)
B24
0,789
Untuk (s2,t2)
B24
0,212
Untuk (s3,t3)
B24
0,212
Untuk (s4,t4) Tot al
B24
0,789
B24
2,000
Untuk (s3,t3) 664
Perhitungan C
320
150
664
494 288 3
E
=
10989,011
3296,703
3296,703
0
166 1 119 1
0
10989,011
0
378
700 4
v2
-
10989,011 {C} =
247 4 119 1 559 140 8
119 1 247 4 184 1 619 1
922 4
444 1 922 4
0 3846,154
166 1 378 247 4 222 2 619 1 140 8 700 4
Perhitungan K Untuk (s1,t1) 922 4
222 2 247 4 378 166 1 119 1 700 4
378 150 119 1 247 4 494 166 1 320 664
B24
1
1
444 1 922 4
619 1 140
184 1 559
247 4 119
119 1 247
559 184
140 8 619
Untuk (s4,t4) 288 3
119 1
150
494
247 4
253 9
559
494 150 253 9 247 4 184 1 559 119 1 288 3
184 1
700 4
378
166 1
222 2
247 4
664
320
166 1
494
664
378 700 4
150 119 1 288 3
140 8 247 4 119 1 619 1 184 1 922 4
619 1 119 1 247 4 140 8 559 444 1 922 4
Matriks kekakuan struktur
[k] =
494 4
178 6
178 6 302 0
494 4
137 247 4 178 6 551 137
137 551 178 6 247 4 137 302 0
302 0 137 494 4 178 6 551 137 247 4 178 6
137 551 178 6 494 4 137 302 0 178 6 247 4
247 4 178 6
178 6 247 4
137
137 302 0
494 4
178 6
178 6 302 0
494 4
551
137
551
{q}
[k]
x
494 4 178 6
178 6 494 4
=
0
v1
0
u2
u2
v2
=
137 247 4 178 6 302 0 137
551
551 137
137 302
178 6 247 4 137 551 178 6 494 4
0
u3
u3
v3
0
u4
0
v4
0
{q}
=
302 0
137
137
551
{Q} 247 4 178
178 6 247
-137 247 4 178 6
551 178 6 247 4
494 4 178 6 551 137 247 4
0 247 4
551
494 4
137
137 302 0
494 4
178 6
178 6 302 0
178 6 302 0
494 4
137
137
137
551
137 302 0
494 4 178 6
178 6 247 4 137
u2 0 u3
551 178 6
0 0
494 4
0
178 6
178 6 247 4
4944
u2
+
551
u3
=
0,5
551
u2
+
4944
u3
=
0,5
551 137
137 302 0
Pemasukan syarat-syarat batas
u1
137
4
178 6
137 302 0
Eliminasi Gauss
494 4 178 6
137
6 302 0
0 0
a
4944
551
0,5
b
551
4944
0,5
a
4944
551
0,5
b
0
4882
0,44
4882
b - (551/4944)a
u3
=
0,44
u3
=
9,10E-05
u2
=
9,10E-05
5.1.2 Perhitungan SAP
5.1.4 Kesimpulan contoh kasus 1 5.1.3 Perhitungan SEAP Didapatkan hasil yang tidak berbeda antara hasil perhitungan manual dan perhitungan program SAP dengan perhitungan SEAP. Perbedaan tanda disebabkan perbedaan sistem koordinat yang digunakan.
5.2 Contoh Kasus 2 Contoh kasus kedua digunakan untuk menguji kemampuan program SEAP menganalisa elemen dengan bentuk kuadriteral tapi tidak bujur sangkar. Kasus kali ini menggunakan elemen berbentuk trapesium Gambar 5.1a Output displacement kasus 1 dengan SEAP
Data-data elemen: - Modulus elastisitas = 25000 kg/cm2 - Poisson’s ratio = 0,2 - Data koordinat elemen: - Joint 1 = 0, 0 - Joint 2 = 2,0 - Joint 3 = 1,1 - Joint 4 = 0,1 - Beban tarik permukaan : - Pada sisi 2 - Tx = 2 kg/cm
5.2.1 Perhitungan Manual Perhitungan matriks [B]
Gambar 5.1b Output reaction kasus 1 dengan SEAP
Perhitungan Xij & Yij Xij = Xi - Xj Yij = Yi - Yj X12 X13 X14 X23 X24 X34
-2 -1 0 1 2 1
Y12 Y13 Y14 Y23 Y24 Y34
0 -1 -1 -1 -1 0
Perhitungan |J|
Gambar 5.1c Output element forces kasus 1 dengan SEAP
Untuk (s1,t1) |J| =
0,447125
Untuk (s2,t2) |J| =
0,447125
Untuk (s3,t3) |J| =
0,302875
Untuk (s4,t4) |J| =
0,302875
Perhitungan B
B11
Total
B23
2,769
Untuk (s1,t1)
B11
-0,441
Untuk (s2,t2)
B11
-0,441
Untuk (s1,t1)
B24
0,763
Untuk (s3,t3)
B11
-0,175
Untuk (s2,t2)
B24
0,118
Untuk (s4,t4)
B11
-0,175
Untuk (s3,t3)
B24
-0,302
Total
B11
-1,231
Untuk (s4,t4)
B24
0,651
Total
B24
1,231
B24
B13 Untuk (s1,t1)
B13
0,118
Untuk (s2,t2)
B13
0,118
Untuk (s3,t3)
B13
0,651
Untuk (s4,t4)
B13
0,651
Total
B13
1,538
Perhitungan C E 1
{C} =
B21 Untuk (s1,t1)
B21
-0,882
Untuk (s2,t2)
B21
-0,559
Untuk (s3,t3)
B21
-0,349
Untuk (s4,t4)
B21
-0,825
Total
B21
-2,615
-
B12
0,441
Untuk (s2,t2)
B12
0,441
Untuk (s3,t3)
B12
0,175
Untuk (s4,t4)
B12
0,175
Total
B12
1,231
Untuk (s1,t1)
B14
-0,118
Untuk (s2,t2)
B14
-0,118
Untuk (s3,t3)
B14
-0,651
Untuk (s4,t4)
B14
-0,651
Total
B14
-1,538
Untuk (s1,t1)
B22
-0,118
Untuk (s2,t2)
B22
-0,441
Untuk (s3,t3)
B22
-0,651
Untuk (s4,t4)
B22
-0,175
Total
B22
-1,385
v
26041,667 5208,333 0
26041,667
5208,333 26041,667 0
0 0 10416,667
Perhitungan K Untuk (s1,t1) 13160
B12 Untuk (s1,t1)
= 2
6074
-3976
-3778
-3530
-1629
-5655
-
22271
-1482 5207
691 -815 2389
-1629 1066 1013 947
-5974 397 -185 437 1602
-2963 -2298 3579 1517 795 6436
16 1 -2
-2713 13382 1482 -9580 1629 20392
669
4 -1 15
B14 Untuk (s2,t2) 8318
3852
-2494
-1555
-6493
10166
741 7086
4395 -3037 7086
-4394 -2692 3778 8463
B22
Untuk (s3,t3) 2064
B23 Untuk (s1,t1)
B23
0,237
Untuk (s2,t2)
B23
0,882
Untuk (s3,t3)
B23
1,302
Untuk (s4,t4)
B23
0,349
952
1573
-43
-7693
3492
866 5206
5600 -1775
-3551 -5866
11349
161 28681
-3551 13019 -3229 20879 13238 48538
-199 -1901 815 722 -397 510
-1
-1 -1 2 -
4056
2
1732 -914
3 4
1658 15122 -6458
3
-9
-1800 14639 -400 11979 30682204 10812 6783 Untuk (s4,t4) 7891
2252
707
-1342
-5961
-5914
18060
-433 1111
3435 -476 1111
-3433 2324 43 12301
-8689 -866 -404 3551 7587
-1804
3004
-2208
-3404
-792
-1804
13812
-2804
-8617
26833 -800
3004
-2208
-3404
-792
-1804
13812
-1800
-4808 15229
-1800
0
-400
2204 10812
0
-2431
3004
u2
3004
-2208
0
0 u3
v3
0
u4
0
v4
0
[k]
x
{q}
=
{Q}
12619
5408
-2202
-2804
-8617
5408
21031
-200
5010
-4808
-2202
-200
7410
-2404
-1800
-2804
5010
-2404
8010
2204
-400 10812
-8617
-4808 15229
-1800
2204 10812
16620
6009
-6203
-3404
u3
6009
26833
-800
-792
0
-400
16183
5.2.2 Perhitungan SAP
u2
u3
u3
-792 -1804
6009 -6203
=
16620
-800 11412
2204 16620
-400 -2431
8010 2204 10812 3004
v2
=
x
-2208 -3404
-2404 -1800
u2
u2
-1800
3004 -6203
5010 -4808 15229 -400 10812
=
=
1 1,243
-2804 -8617
0
=
u3
-1800 16183
-4808 -1800
0
u3
16620
a -400 b -2431
5010 -2404
v1
-1800
+
2204 108127410 3004 0
-200 7410
u1
+
1 1
Pemasukan syarat-syarat batas
-4808
11412
-1800 16620
21031 -200
{q}
-800
-1800
b
5408 -2202
2204
-6203
-2637 5004 7410 u2 1614 12807 -1800 u2 -914 1775 1775 -41427410 -8664 -161 -1800 3229 1505 15444 -6619 154447410 a
-4808 15229 -400 10812 6009
-4808 -1800
3004
Eliminasi Gauss
Matriks kekakuan struktur 12619 5408 -2202
[k] =
-2431
b - (551/4944)a
u3
=
1,24
u3
=
7,68E-05
u2
=
1,54E-04
5.2.3 Perhitungan SEAP
Gambar 5.2.a Output displacement kasus 2 dengan SEAP
Gambar 5.2.b Output joint reaction kasus 2 dengan SEAP
Gambar 5.2.c Output element forces kasus 2 dengan SEAP
Perhitungan |J|
5.2.4 Kesimpulan contoh kasus 2 Didapatkan hasil yang tidak berbeda antara hasil perhitungan manual dan perhitungan program SAP dengan perhitungan SEAP. Perbedaan tanda disebabkan perbedaan sistem koordinat yang digunakan.
Untuk (s1,t1) |J| = Untuk (s3,t3) |J| = Perhitungan B
0,25
Untuk (s2,t2) |J| =
0,25
0,25
Untuk (s4,t4) |J| =
0,25
B11
5.3 Contoh Kasus 3
Contoh terakhir digunakan jumlah elemen lebih dari satu. Data-data elemen: Elemen 1 - Modulus elastisitas = 10000 kg/cm2 - Poisson’s ratio = 0,3 - Data koordinat elemen: - Joint 1 = 0, 0 - Joint 2 = 1,0 - Joint 3 = 1,1 - Joint 4 = 0,1 - Beban tarik permukaan : - Pada sisi 2 - Tx = 1 kg/cm
Untuk (s1,t1)
B11
-0,789
Untuk (s2,t2)
B11
-0,789
Untuk (s3,t3)
B11
-0,212
Untuk (s4,t4)
B11
-0,212
Total
B11
-2,000
Untuk (s1,t1)
B13
0,212
Untuk (s2,t2)
B13
0,212
Untuk (s3,t3)
B13
0,789
Untuk (s4,t4)
B13
0,789
Total
B13
2,000
Untuk (s1,t1)
B21
-0,789
Untuk (s2,t2)
B21
-0,212
Untuk (s3,t3)
B21
-0,212
Untuk (s4,t4)
B21
-0,789
Total
B21
-2,000
Untuk (s1,t1)
B12
0,789
Untuk (s2,t2)
B12
0,789
Untuk (s3,t3)
B12
0,212
Untuk (s4,t4)
B12
0,212
Total
B12
2,000
Untuk (s1,t1)
B14
-0,212
Untuk (s2,t2)
B14
-0,212
Untuk (s3,t3)
B14
-0,789
Untuk (s4,t4)
B14
-0,789
Total
B14
-2,000
Untuk (s1,t1)
B22
-0,212
Untuk (s2,t2)
B22
-0,789
Untuk (s3,t3)
B22
-0,789
Untuk (s4,t4)
B22
-0,212
B13
B21
Elemen 2 - Modulus elastisitas = 25000 kg/cm2 - Poisson’s ratio = 0,2 - Data koordinat elemen: - Joint 1 = 0, 1 - Joint 2 = 1,1 - Joint 3 = 1,2 - Joint 4 = 0,2
B12
5.3.1 Perhitungan Manual
Elemen 1 : B14
Perhitungan Xij & Yij Xij = Xi - Xj Yij = Yi - Yj X12 X13 X14 X23 X24 X34
-1 -1 0 0 1 1
Y12 Y13 Y14 Y23 Y24 Y34
0 -1 -1 -1 -1 0
B22
Total
B22
-2,000
Untuk (s1,t1)
B23
0,212
Untuk (s2,t2)
B23
0,789
Untuk (s3,t3)
B23
0,789
Untuk (s4,t4)
B23
0,212
Total
B23
2,000
664
B23 Untuk (s3,t3) 664
320
150
378
664
494
1661 1191
2883 B24 Untuk (s1,t1)
B24
0,789
Untuk (s2,t2)
B24
0,212
Untuk (s3,t3)
B24
0,212
Untuk (s4,t4)
B24
0,789
Total
B24
2,000
Perhitungan C elemen 1 E = 1
-
v
10989,011
7004
9224
4441
2883
9224
6191 1408 7004
1841 -559 1191 2883
2474 1191
1191 2474
1661
378
-559 1841 2474
494 664
150 320 664
2539 150 494 2883
Untuk (s2,t2) 7004
1191
6191
2883
1841 9224
1408 -559 4441 9224
2474 2539
2222 2474
-559
1408 6191 1191 7004
1841 2883
1661 -494 2474 1191 150 -378 664
9224
4441
1661
494
378 2474
150
2222 6191 1408 7004
3296,703 10989,011 0 10989,011 {C}= 3296,703 0 0 0 3846,154 Perhitungan Matriks Kekakuan Lokal Elemen 1 Untuk (s1,t1)
-559 1408
1191 2474 1841 6191
9224
Untuk (s4,t4)
2
2474 1191
1661
2474 2222
2539 2474
-320
1661
-494
664
-378
150
7004
1191 2883
1191
150
-494
7004
-378 664
1408 6191 2222 2474 Hasil 378Akhir 1661 u1 1191 4944 7004 1786 3020 [k1] -378 = -137 150 2474 1191 1786 2474 551 -494 1661 137 -320
-559 1408 2474 1191 6191 1841 9224
v1
u2
1786
3020
4944
137
137
4944 1786
551 1786 2474 -137 3020
551 -137 2474 1786
v2 -137 551 1786
u3
v3
2474 1786
1786 2474
551
u4 551 -137 2474
4944
137
-137 3020
137 3020
4944
1786
1786 3020
1786 3020
4944
137
137
-137
551
4944 1786
1786 2474
2539 2474 1841 -559 1191 2883
1841 6191 1191 2474 1408 -559 4441 9224
v4 137 3020 1786 2474 -137
u1 v1 u2 v2 u3 v3
551 1786
u4
4944
v4
B22
Untuk (s1,t1) Untuk (s2,t2) Untuk (s3,t3) Untuk (s4,t4) Total
B22 B22 B22 B22 B22
-0,212 -0,789 -0,789 -0,212 -2,000
Untuk (s1,t1) Untuk (s2,t2) Untuk (s3,t3) Untuk (s4,t4) Total
B23 B23 B23 B23 B23
0,212 0,789 0,789 0,212 2,000
Untuk (s1,t1) Untuk (s2,t2) 0,25 Untuk (s3,t3) 0,25 Untuk (s4,t4) Total
B24 B24 B24 B24 B24
0,789 0,212 0,212 0,789 2,000
Elemen 2 : Perhitungan Xij & Yij Xij = Xi - Xj Yij = Yi - Yj X12 X13 X14 X23 X24 X34 Perhitungan |J| Untuk (s1,t1) |J| = Untuk (s3,t3) |J| = Perhitungan B B11
B13
B21
B12
B14
-1 -1 0 0 1 1 0,25 0,25
0 B23 -1 -1 -1 -1 0 B24 Untuk (s2,t2) |J| = Untuk (s4,t4) |J| = Y12 Y13 Y14 Y23 Y24 Y34
Untuk (s1,t1) Untuk (s2,t2) Untuk (s3,t3) Untuk (s4,t4) Total
B11 B11 B11 B11 B11
Untuk (s1,t1) Untuk (s2,t2) Untuk (s3,t3) Untuk (s4,t4) Total
B13 B13 B13 B13 B13
Untuk (s1,t1) B21 Untuk (s2,t2) B21 Untuk (s3,t3) B21 Untuk (s4,t4) Total B21
B21
Perhitungan C elemen 2 E 1 v2 -0,789 -0,789 26041,667 -0,212 {C}= 5208,333 -0,212 0 -2,000
=
26041,667
5208,333 26041,667 0
0 0 10416,667
Perhitungan Matriks Kekakuan Lokal Elemen 2 Untuk (s1,t1) 0,212 0,212 0,789 22667 9715 14454 -5608 -6080 0,789 22667 -1501 -2133 -2606 2,000 16657 -2606 3877 7641 1504 1631 -0,789
-2606
-2133
-6080 403 572 699 1631
-5608 -6080 6709 572 1504 7641
-3704 -6080 1501 5608 14454 7641 2606 16657
3877 -1504 -6080
-403 572 2606
2606 572 -403 1631
-6080 -1504 3877 -699 1631
-0,212 -0,212 -0,789 -2,000
Untuk (s1,t1) Untuk (s2,t2) Untuk (s3,t3) Untuk (s4,t4) Total
B12 B12 B12 B12 B12
0,789 0,789 0,212 0,212 2,000
Untuk (s1,t1) Untuk (s2,t2) Untuk (s3,t3) Untuk (s4,t4) Total
B14 B14 B14 B14 B14
-0,212 -0,212 -0,789 -0,789 -2,000
Untuk (s2,t2) 16657
2606 14454 7641 5608 22667
1501 -2133 -9715 22667
Untuk (s3,t3)
-6080 -6709 -2133
-1501 14454 3704 -6080 403 3877 -2606 16657
1631
699 1631
572 1504 7641
403 3877 -2606 16657
Untuk (s4,t4) 7641
-6080 -2606 -2133
-2606 -6080 -5608 -1501 14454
3877 403 -6080
1504 572 6709
3704 22667 9715 14454 22667 -1501 16657
-6080
2606
572
-1504
-6080
-6709
16657
-403 1631
3877 -699 1631
-3704 3877 -403
-6080 -1504 572
16657
2606 7641
-5608 -2133 -2606 7641
-2133
5608 1501 14454 -6080 2606 2606 -6080 14454 1501 5608 -2133 22667 -9715 22667
Hasil Akhir v4 u3 v3 u5 v5 u6 v6 u4 12149 3906 -6941 -1302 -6080 -3906 872 1302 3906 12149 1302 872 -3906 -6080 -1302 -6941 -6941 1302 12149 -3906 872 -1302 -6080 3906 [k2] = -1302 872 -3906 12149 1302 -6941 3906 -6080 -6080 -3906 872 1302 12149 3906 -6941 -1302 -3906 -6080 -1302 -6941 3906 12149 1302 872 872 -1302 -6080 3906 -6941 1302 12149 -3906 1302 -6941 3906 -6080 -1302 872 -3906 12149
Selanjutnya matriks kekakuan lokal diubah menjadi matriks kekakuan global elemen. Hal ini dilakukan dengan cara melakukan penyesuaian terhadao orde dari matriks kekakuan struktur yang berjumlah 2 kali jumlah joint. Untuk soal ini orde matriks kekakuan struktur adalah 2 kali 6 joint, yaitu 12 x 12. Matriks kekakuan global elemen
u4 v4 u3 v3 u5 v5 u6 v6
Pemasukan Syarat Batas
{q}=
[k]
Matriks kekakuan struktur
x
u1 v1
0
0
0
0
u2
0
0,5
v2
0
0
u3 v3
u3 0
0,5 0
=
{Q}
=
u4
0
0
v4
0
0
u5 v5
u5 0
0 0
u6
0
0
v6
0
0
{q}
=
{Q}
Eliminasi Gauss 17093 872
+ +
u3 u3
872 12149
17093 872
872 12149
a
17093
872
b
872
12149
a
17093
872
b
0
12105
12105
5.3.2 Perhitungan SAP
u5 u5
= =
0,5 0
x
u3 u5
=
0,5 0
0,5 b0 (872/17093)a 0,5 0,026
u5 u5 u3
= = =
-0,03 -0,0000021 0,0000294
5.3.3 Perhitungan SEAP
Gambar 5.3.c Output element force kasus 3 dengan SEAP
5.3.4 Kesimpulan contoh kasus 3
Gambar 5.3.a Output displacement kasus 3 dengan SEAP
Didapatkan hasil yang sama antara hasil perhitungan manual dengan perhitungan SEAP. Tapi terdapat perbedaan antara perhitungan SEAP dengan perhitungan SAP Untuk nilai displacement terdapat perbedaan sebesar 0,000003 pada joint 3 dan 5. Untuk nilai joint reaction terdapat perbedaan sekitar 0,02 hingga 0,03. Untuk nilai element forces terdapat perbedaan sekitar 0,2 hingga 0,3. Perbedaan yang mungkin bisa terjadi karena pada perhitungan SEAP tidak menyertakan matriks transformasi atau bisa juga karena terdapat perbedaan metode perhitungan SAP untuk jumlah elemen lebih dari satu.
BAB VI PENUTUP 6.1 Kesimpulan
Gambar 5.3.b Output joint reaction kasus 3 dengan SEAP
Dari uji coba perbandingan hasil analisa program SEAP dengan perhitungan manual dan program SAP dapat disimpulkan bahwa: 1. Perhitungan dengan SEAP memiliki hasil yang sama atau mendekati dengan hasil analisa dari SAP. Perbedaan yang ada disebabkan oleh pembulatan angka dibelakang koma. 2. Program SEAP cukup user friendly, dengan keterangan input yang jelas dalam form-form input terpisah juga didukung dengan tampilan berbasis grafis 3 dimensi yang dapat memudahkan pengguna mengecek bentuk elemen, beban-beban yang dikenakan dan arah displacement joint. 3. Untuk keperluan pengembangan program di masa mendatang, SEAP telah disusun dalam modul-modul terpisah untuk proses analisa, pengelola file dan data serta plot grafis 3 dimensi, sehingga dapat lebih memudahkan pemahaman tentang alur program.
6.2 Saran Untuk mencapai hasil yang lebih baik di masa mendatang utamanya untuk keperluan pengembangan lebih lanjut maka perlu dipertimbangkan saran-saran sebagai berikut: 1. Program SEAP ini dibuat juga sebagai sarana pembelajaran metode elemen hingga pada elemen shell, sehingga metode penulisan program masih mengacu pada alur-alur
perhitungan secara manual. Hal ini terlihat dari bagaimana matriks-matriks kekakuan disimpan secara utuh dan tidak efisien sehingga akan banyak menguras memori komputer pengguna, utamanya pada penggunaan untuk analisa struktur yang kompleks. 2. Program ini adalah program analisa sederhana dimana pembebanan akan dihitung secara langsung sesuai input pengguna tanpa ada klasifikasi beban mati, hidup, gempa dan sebagainya, juga kasus kombinasi beban, sehingga untuk kepentingan pengembangan diperlukan kiranya untuk menambahkan kasus kombinasi beban. 3. Program ini belum memasukkan proses meshing, padahal proses meshing merupakan proses yang sangat berguna untuk semakin mematangkan hasil analisa, sehingga pengembangan program dengan menyediakan fasilitas meshing akan semakin meningkatkan ketelitian hasil analisa.
