Agus Daud

Nyoba Stability Challenge

August 17, 2021

Kali ini mau nyoba stability challenge yang diadakan oleh blog opensees di sini A Verry Stable Challenge. Ini bukan masalah jawabannya, karena jawabannya bisa dibaca di sini Stability Challenge Results.

Ini lebih kepada bagaimana cara untuk menyelesaikannya, bagaimana script opensees yang sesuai dengan strategi yang diberikan oleh blog tersebut?

I’m just try to understand the strategy written on the blog and try to write an opensees script that seems to fit the problem.

Baik, soalnya sebagai berikut:

Berapakah nilai faktor pengali (Lambda), sehingga terjadi perpindahan horizontal 0,25 inch di puncak struktur?

Strategi pertama,

yaitu dengan menganggap struktur sebagai rangka batang elastik (truss) biasa.

Analisis dilakukan dengan menggunakan openseespy, maka ditulis script dengan bahaya Python sebagai berikut:

from openseespy.opensees import *
import openseespy.preprocessing.DiscretizeMember as opsdm
import openseespy.postprocessing.Get_Rendering as opsplt
import matplotlib.pyplot as plt
import numpy as np
%matplotlib notebook

wipe()
model('basic','-ndm',2,'-ndf',2)

E = 3000.0
Px = 100.0
Py = 50.0

node(1,0.0,0.0)   ; fix(1,1,1,0)
node(2,144.0,0.0) ; fix(2,1,1,0)
node(3,168.0,0.0) ; fix(3,1,1,0)
node(4,72.0,96.0)

uniaxialMaterial("Elastic", 1, E)
element("Truss",1,1,4,10.0,1)
element("Truss",2,2,4,5.0,1)
element("Truss",3,3,4,5.0,1)

timeSeries("Linear",1)
pattern("Plain",1,1)

# input beban
load(4,Px,-Py)

dMax = 0.25
Nsteps = 50

# analisis
system("BandSPD")
numberer("RCM")
constraints("Plain")
integrator("DisplacementControl",4,1,dMax/Nsteps)
algorithm("Linear")
test("NormUnbalance",1e-8,30)
analysis("Static")

disp1 = []
factor1 = []

currentDisp = 0.0
ok = 0

while ok == 0 and currentDisp < dMax:
    ok = analyze(1)
    if ok == 0:
        test("NormDispIncr",1e-8,1000,0)
        algorithm("ModifiedNewton",'-initial')
        ok = analyze(1)
        test("NormDispIncr",1e-8,6,0)
        algorithm("Newton")
    currentDisp = nodeDisp(4,1)
    disp1.append(nodeDisp(4,1))
    factor1.append(getLoadFactor(1))
    
print(disp1[-1],factor1[-1])
plt.xlabel('Perpindahan Horizontal (inch)')
plt.ylabel('Faktor Pengali (Lambda)')
plt.plot(disp1,factor1,Label="Linear Truss")
plt.grid()
plt.legend()
plt.show()

Hasilnya sebagai berikut:

Dengan strategi pertama ini, untuk memperoleh perpindahan horizontal 0,25 inch di puncak struktur; diperoleh faktor pengali Lambda = 0,47.

Nilai ini sama dengan tiga partisipan lain. Berikut hasil dari partisipan lain.

Strategi kedua

Dijelaskan dalam blog tersebut, bahwa tiga partisipan mempertimbangkan non linear geometri, transformasi P-∆ atau Corotational; kemudian merubah elemen rangka menjadi elemen balok (beam). Sedangkan hasilnya akan tetap sama seperti strategi pertama yang hanya menggunakan elemen rangka.

Soal ini adalah masalah P-δ bukan P-∆; terlihat betapa pentingnya ketelitian melihat soal/kondisi struktur yang akan dianalisis.

Efek P-δ disimulasikan dengan membagi elemen balok (beam) menjadi beberapa elemen diskrit. Misalnya setiap balok dibagi menjadi 4 elemen.

Inilah yang dilakukan oleh dua partisipan yang lain memperoleh nilai yang lebih kecil yaitu sebesar Lambda = 0,11.

Berikut script analisis dengan openseespy.

from openseespy.opensees import *
import openseespy.preprocessing.DiscretizeMember as opsdm
import openseespy.postprocessing.Get_Rendering as opsplt
import matplotlib.pyplot as plt
import numpy as np
import math
%matplotlib notebook

wipe()
model('basic','-ndm',2,'-ndf',3)

A = [10.0,5.0]
Iz = []
E = 3000.0
Px = 100.0
Py = 50.0

for val in A:
    b = math.sqrt(val)
    Iz.append(b**4/12)

node(1,0.0,0.0)   ; fix(1,1,1,0)
node(2,144.0,0.0) ; fix(2,1,1,0)
node(3,168.0,0.0) ; fix(3,1,1,0)
node(4,72.0,96.0)

geomTransf("Corotational",1)
section('Elastic',1,E,A[0],Iz[0])
section('Elastic',2,E,A[1],Iz[1])
beamIntegration('Legendre',1,1,10)
beamIntegration('Legendre',2,2,10)

#(ndI, ndJ, numEle, eleType, integrTag, transfTag, nodeTag, eleTag)
nEle = 4
opsdm.DiscretizeMember(1,4,nEle,'dispBeamColumn',1,1,5,1)
opsdm.DiscretizeMember(2,4,nEle,'dispBeamColumn',2,1,8,5)
opsdm.DiscretizeMember(3,4,nEle,'dispBeamColumn',2,1,11,9)

timeSeries("Linear",1)
pattern("Plain",1,1)
load(4,Px,-Py,0.0)

# analisis
Nsteps = 50
dMax = 0.25

integrator("DisplacementControl",4,1,dMax/Nsteps)
system("BandGeneral")
numberer("RCM")
constraints("Plain")

algorithm("Newton")
#test("NormDispIncr",1e-8,30)
analysis("Static")

disp2 = []
factor2 = []

currentDisp = 0.0
ok = 0

while ok == 0 and currentDisp < dMax:
    ok = analyze(1)
    if ok != 0:
        #test("NormDispIncr",1e-8,10000,0)
        #algorithm("ModifiedNewton",'-initial')
        ok = analyze(1)
        test("NormDispIncr",1e-8,100,0)
        algorithm("Newton")
        
    currentDisp = nodeDisp(4,1)
    disp2.append(nodeDisp(4,1))
    factor2.append(getLoadFactor(1))

print(disp2[-1],factor2[-1])
#opsplt.plot_model()

plt.plot(disp1,factor1)
plt.plot(disp2,factor2)
plt.xlabel('Perpindahan Horizontal (inch)')
plt.ylabel('Faktor Pengali (Lambda)')
plt.grid()
plt.show()

Hasilnya.. dengan cara ini diperoleh faktor pengali Lambda = 0,11. Sama dengan dua partisipan lain.

Merubah elemen rangka (truss) menjadi balok (beam), akan menyebabkan terjadinya momen pada join puncak. Kondisi ini disiasati dengan menambahkan node ekstra tambahan di puncak (saling menimpa); kemudian dihubungkan dengan perintah equalDOF.

Sayangnya nilai Lambda = 0,11 lebih besar dari batas bawah yaitu sebesar Lambda = 0,0606.

Nilai ini merupakan rasio kapasitas tekuk elastik (tekuk Euler) batang bagian paling kanan Pcr = 3,35 kip , dengan gaya tekan yang terjadi (pada Lambda = 1) sebesar Pc = 55,3 kip. Atau Lambda = Pcr / Pc = 3,35/55,3 = 0,0606.

Untuk mendapatkan hasil dengan nilai batas bawah Lambda = 0,0606, maka perlu ditambahkan nilai δ awal (ketidak-sempurnaan geometri) di node tengah setiap elemen sebesar L/1000 sampai L/500.

Need to add:
– interior nodes of the corotational mesh with a small out of straightness L/1000 to L/500.

Update 19 Agustus 2021

Di kolom komentar Prof. Scott menyarankan metode yang bisa digunakan untuk me-release momen di node puncak.

Selain itu, untuk memasukkan ketidak-sempurnaan geometri (initial imperfection); saya mencoba cara lain yaitu dengan memasukkan beban notional, Ni (horizontal) di tengah balok sebesar Pc/500 = 55,3/500 = 0,1.

Namun, karena pembebanan menggunakan faktor pengali; maka untuk mendapatkan gaya notional yang sesuai, gaya notional dibagi dengan faktor beban atau Ni = 0,1/0,0606 = 1,7 Kip.

Instead using corotational mesh with a small out of straightness L/1000 to L/500; to simulate initial imperfection, I try to put notional load at mid interior node of compression member by

Notional force, Ni = (Pc/500) / 0,0606 = 1,7 Kip

Berikut script opensees yang digunakan,

from openseespy.opensees import *
import openseespy.preprocessing.DiscretizeMember as opsdm
import openseespy.postprocessing.Get_Rendering as opsplt
import matplotlib.pyplot as plt
import numpy as np
import math
%matplotlib notebook

wipe()
model('basic','-ndm',2,'-ndf',3)

A = [10.0,5.0]
Iz = []
E = 3000.0
Px = 100.0
Py = 50.0

for val in A:
    b = math.sqrt(val)
    Iz.append(b**4/12)

node(1,0.0,0.0)   ; fix(1,1,1,0)
node(2,144.0,0.0) ; fix(2,1,1,0)
node(3,168.0,0.0) ; fix(3,1,1,0)
node(4,72.0,96.0) ; fix(4,0,0,1)
node(144,72.0,96.0); equalDOF(4,144,1,2)
node(244,72.0,96.0); equalDOF(4,244,1,2)
node(344,72.0,96.0); equalDOF(4,344,1,2)

geomTransf("Corotational",1)
section('Elastic',1,E,A[0],Iz[0])
section('Elastic',2,E,A[1],Iz[1])
beamIntegration('Legendre',1,1,10)
beamIntegration('Legendre',2,2,10)

#(ndI, ndJ, numEle, eleType, integrTag, transfTag, nodeTag, eleTag)
nEle = 4
opsdm.DiscretizeMember(1,144,nEle,'dispBeamColumn',1,1,5,1)
opsdm.DiscretizeMember(2,244,nEle,'dispBeamColumn',2,1,8,5)
opsdm.DiscretizeMember(3,344,nEle,'dispBeamColumn',2,1,11,9)

timeSeries("Linear",1)
pattern("Plain",1,1)
load(4,Px,-Py,0.0)
load(9,1.7,0.0,0.0)
load(12,1.7,0.0,0.0)


# analisis
Nsteps = 50
dMax = 0.25

integrator("DisplacementControl",4,1,dMax/Nsteps)
system("BandGeneral")
numberer("RCM")
constraints("Plain")
algorithm("Newton")
analysis("Static")

disp3 = []
factor3 = []

currentDisp = 0.0
ok = 0

while ok == 0 and currentDisp < dMax:
    ok = analyze(1)
    if ok != 0:
        test("NormDispIncr",1e-8,10000,0)
        algorithm("ModifiedNewton",'-initial')
        ok = analyze(1)
        test("NormDispIncr",1e-8,100,0)
        algorithm("Newton")
        
    currentDisp = nodeDisp(4,1)
    disp3.append(nodeDisp(4,1))
    factor3.append(getLoadFactor(1))

print(disp3[-1],factor3[-1])

plt.plot(disp1,factor1,Label="Linear Truss")
plt.plot(disp2,factor2,Label="NL Geometri")
plt.plot(disp3,factor3,Label="Non Geometri, M.Release, & init. imperfect")
plt.xlabel('Perpindahan Horizontal (inch)')
plt.ylabel('Faktor Pengali (Lambda)')
plt.grid()
plt.legend()
plt.show()

Hasilnya.. resulte Lambda = 0,060596

Dengan ini diperoleh nilai Lambda = 0,060596 mendekati nilai batas bawah yaitu sebesar Lambda = 0,0606.

Nyoba SSI Modeling Challenge

July 24, 2021
Sebenarnya challenge ini dilaksanakan dari 15 Juli 2020 (tanggal postingan) sampai 31 Agustus 2020. Tapi, tidak ada salahnya untuk dicoba.

Jika ingin membaca postingan soal aslinya silahkan ke sini SSI Model Challenge.

Dan hasilnya dapat dibaca di sini SSI Modeling Challenge Results.

Oke.. baiklah.. mari kita mulai

Diberikan kasus pilar-fondasi jembatan diberikan gaya horizontal P = 1 kN di puncaknya seperti gambar berikut.

Ditanyakan berapakah perpindahan lateral di puncak pilar?

Cukup rumit bila ditinjau interaksi tanah-struktur (soil-struktur interaction, SSI). Untuk itu mari kita coba dengan cara yang lebih sederhana.

Diasumsikan pilar sebagai balok kantilever (linear elastik), kemudian perpindahan dihitung dengan rumus;
perpindahan = PL^3 / 3EI.

P = gaya horizontal di puncak pier = 1 kN
L = panjang kantilever
E = Modulus elastisitas tiang = 25 GPa = 25 x 10^6 kN/m3
I = inersia tiang = pi x D^4 / 64 = 0,071832 m4

Seperti yang kita ketahui, jepit atau kekangan tanah tidak berada di permukaan tanah. Umumnya diasumsikan kekangan tanah berada pada jarak Lp/3 dari permukaan tanah. Lp = panjang tiang yang tertanam.

Sehingga panjang kantilever menjadi, L = Lp/3 + h = 20/3 + 6,1 = 12,76 m

Maka, diperoleh perpindahan lateral dipuncak sebesar disp = PL^3 / 3EI = 0,385 mm

Jika diplot dalam grafik hasil modelling dari 7 partisipan lain, terlihat perpindahan masuk dalam rentang (min/max) dan mendekati nilai median sebesar 0,31 mm.

Perlu diperhatikan, persamaan di atas (asumsi 1) belum menggunakan parameter tanah dalam perhitungan. Kedalaman kekangan/jepit tanah hanya sebatas asumsi Lp/3. Oleh karena itu, mari kita coba gunakan persamaan FEMA 55 (Equation 10.4), kedalaman kekangan dihitung dengan rumus:

D = 1,8 x (EI / nh)^(1/5)

Dimana modulus subgrade tanah (nh) = 41 MN/m3; diperoleh dari hasil plot grafik hubungan kepadatan relative Dr = 90% dan modulus subgrade sebagai berikut.

Grafik korelasi kerapatan relatif dan modulus subgrade tanah (sumber)

Kedalaman kekangan menjadi D = 1,8 x (EI / nh)^(1/5) = 3,83 m

Total panjang kantilver (asumsi 2) menjadi, L = H + D = 6,1 + 3,83 = 9,93 m

Maka, diperoleh perpindahan lateral (asumsi 2) sebesar disp = PL^3 / 3EI = 0,182 mm

Jika diplot lagi kedalam grafik hasil partisipan lain, terlihat perpindahan lebih kecil namun masih masuk dalam range. Hasil yang pertama (warna merah) lebih konservatif dari hasil kedua (warna hijau).

Baiklah..

Mari kita dicoba asumsi ke 3.

Dengan menggunakan paket program Anastruct, tiang dibagi dalam beberapa elemen diskrit. Diberikan tumpuan spring arah horizontal, setiap meter kedalaman tiang. Di dasar tiang diasumsikan tumpuan sendi. Nilai parameter EI tiang sesuai soal di atas.

Penentuan modulus reaksi subgrade horizontal, mengikuti langkah-langkah dalam buku Bowles, Example 16.9.

Berikut script analisa struktur yang ditulis menggunakan bahasa Python dengan paket program Anastruct.
Hasilnya sebagai berikut:
```
from anastruct.fem.system import SystemElements
import matplotlib.pyplot as plt
import math

d = 1.1
A = (math.pi*d**2)/4
I = (math.pi*d**4)/64
E = 25*10**6
nh = 41000
s = 1

# geometri tiang
Px = 1
H = 6.1
L = 20

ss = SystemElements(EA=E*A, EI=E*I)
ss.add_multiple_elements([[0, 0], [0, L]], 20)
ss.add_multiple_elements([[0, L], [0, L+H]], 6)

for i in range(1,L+2):
    if i == 1:
        ss.add_support_hinged(node_id=[i])
    elif i == L+1:
        kh = (nh*d*s/2)/2
        ss.add_support_spring(node_id=i, translation=1, k=kh)
    else:
        z = L+s-i
        #kh = nh*(z/d)*s*d
        kh = (nh*s*d)/2
        ss.add_support_spring(node_id=i, translation=1, k=kh)

ss.point_load(node_id=27, Fx=Px)

ss.solve()
disp = ss.get_node_displacements(node_id=27)
x_disp= round(disp["ux"]*1000,4)

print("Perpindahan horizontal di puncak tiang; disp = ",x_disp," mm")

list_disp = ss.get_node_result_range('ux')
list_disp_mili = []
for val in (list_disp):
    x = val*1000
    list_disp_mili.append(x)

f = plt.figure()
plt.xlabel('Perpindahan Lateral (mm)')
plt.ylabel('Elevasi tiang (m)')
plt.plot(list_disp_mili,range(-L,7))

f.set_figwidth(6)
f.set_figheight(10)
plt.grid()
plt.show()
#print(list_disp)

ss.show_structure()
ss.show_displacement(factor=20000)
ss.show_bending_moment()
```
Model Struktur

Diagram Momen

Grafik Perpindahan

Cara ke tiga ini diperoleh perpindahan sebesar disp = 0,207 mm
Jika diplot lagi ke dalam grafik hasil,

Kesimpulan:
Challenge ini adalah analisa interaksi tanah-struktur (SSI). Karena berhubungan dengan tanah, sehingga diperoleh nilai perpindahan yang bervariasi. Behubung modulus subgrade pasir padat juga bervariasi (ada nilai minimum dan maksimumnya).

Hasil perhitungan menunjukkan cara paling sederhana (asumsi 1) cukup konservatif untuk digunakan. Lebih besar dari nilai median (garis putus-putus dalam grafik). Cukup baik digunakan untuk kepentingan desain pendahuluan, penentuan dimensi awal. Kemudian dapat dilakukan analisa struktur yang lebih detail, seperti mengasumsikan kekakuan tanah sebagai tumpuan spring.
Mempercepat Waktu Analisis/Revisi Dengan Program Anastruct

May 11, 2021
Sudah lama sejak terakhir kali nulis di blog ini. Mungkin sudah beberapa bulan lalu bersamaan dengan pekerjaan yang menumpuk.

Kali ini saya mau cerita sedikit tentang apa sih kelebihan paket program struktur? jika dibandingkan dengan software yang sudah banyak saat ini? seperti SAP2000 atau ETABS.

Paket program struktur yang saya maksud adalah “alat” analisa struktur yang ditulis dalam suatu bahasa pemrograman. Seperti paket program (package) Anastruk yang ditulis dalam bahasa pemrograman Python, yang akan kita bahas disini.

Untuk menggunakan ini, tentunya kita harus belajar bahasa Python lagi. Selain itu, tidak ada tersedia tombol/menu/tool seperti SAP2000. Pengguna harus menulis code/syntax sesuai aturan, untuk melakukan analisa struktur.

Ribet..?

Yah lumayan, lalu apa kelebihannya dibandingkan software yang sudah ada?

Pembuatan model yang sangat cepat.

Dari segi fitur pastinya ada beberapa kekurangan. Namun, kecepatan pembuatan/merevisi model merupakan keunggulan yang sangat signifikan membantu engineer.

Kita tahu, bahwa di dunia kerja engineer dituntut untuk bekerja cepat dan tepat. Belum lagi, terkadang revisi dilakukan secara berulang-ulang.

Sebagai contoh; membuat portal sederhana 1 tingkat, dengan cara menulis code menggunakan paket Anastruct dalam bahasa Python sebagai berikut:
```
from anastruct.fem.system import SystemElements
ss = SystemElements()

# Tambahkan Material/Properti Penampang
EA = 5e9
EI = 8000

# Geometri
h = 3.         # tinggi portal
L = 6          # lebar portal

# Tambah element balok/kolom
ss.add_element(location=[[0,0], [0,h]], EA=EA, EI=EI)
ss.add_element(location=[[L,0], [L,h]], EA=EA, EI=EI)
ss.add_element(location=[[0,h], [L,h]], EA=EA, EI=EI)

# Tampilkan gambar struktur
ss.show_structure()
```
Setelah kita Run (shift+enter) code di atas, maka akan tampil model sebagai berikut:

Dengan 18 line code di atas kita sudah dapat membuat portal sederhana. Cepat bukan?

Oke.. sampai di sini gimana? Biasa saja..?

Mari kita tambahkan beban merata dan tumpuan, dengan cara merubah code menjadi berikut:
```
from anastruct.fem.system import SystemElements
ss = SystemElements()

# Material/Properti Penampang
EA = 5e9
EI = 8000

# Geometri
h = 3.
L = 6

# Tambah element balok/kolom
ss.add_element(location=[[0,0], [0,h]], EA=EA, EI=EI)
ss.add_element(location=[[L,0], [L,h]], EA=EA, EI=EI)
ss.add_element(location=[[0,h], [L,h]], EA=EA, EI=EI)
    
# Tambah beban merata pada balok
ss.q_load(element_id=3, q=-13)

# Tambah tumpuan
ss.add_support_fixed(node_id=1)
ss.add_support_fixed(node_id=3)

# Tampilkan gambar struktur
ss.show_structure()
```
Maka tampilannya menjadi

Analisa struktur selanjutnya dapat dilakukan dengan menambahkan code berikut di bagian akhir code sebelumnya.
```
# Run Analisis
ss.solve()

# Tampilkan gambar reaksi perletakan, diagram Momen, geser, aksial, dan deformasi 
ss.show_reaction_force()
ss.show_bending_moment()
ss.show_shear_force()
ss.show_axial_force()
ss.show_displacement()
```
Setelah Running lagi shift+enter, maka akan tampil gambar diagram gaya berikut.

Gambar Reaksi Perletakan

Diagram Momen

Diagram Gaya Geser

Diagram Gaya Aksial

Gambar Deformasi Struktur

Masalah akan timbul jika Owner atau Arsitek ingin merubah desain. Contoh mereka meminta untuk menambahkan tinggi portal menjadi 4 m misalnya. Jika ini dilakukan menggunakan SAP2000 misalnya, maka kita harus mengedit grid lagi dan menarik garis lagi merubah geometri portal.

Di sinilah kelebihan paket program Anastruk. Kita dengan mudah merubah tinggi dalam code sebelumnya dari nilai 3 menjadi 4. Kemudian shift+enter.. simple kan? codenya menjadi:
```
from anastruct.fem.system import SystemElements
ss = SystemElements()

# Material/Properti Penampang
EA = 5e9
EI = 8000

# Geometri
h = 4     # ganti untuk merubah tinggi 
L = 6     # ganti untuk merubah lebar 

# Tambah element balok/kolom
ss.add_element(location=[[0,0], [0,h]], EA=EA, EI=EI)
ss.add_element(location=[[L,0], [L,h]], EA=EA, EI=EI)
ss.add_element(location=[[0,h], [L,h]], EA=EA, EI=EI)
    
# Tambah beban merata pada balok
ss.q_load(element_id=3, q=-13)

# Tambah tumpuan
ss.add_support_fixed(node_id=1)
ss.add_support_fixed(node_id=3)

# Run Analisis
ss.solve()

# Tampilkan gambar reaksi perletakan, diagram Momen, geser, aksial, dan deformasi 
ss.show_reaction_force()
ss.show_bending_moment()
ss.show_shear_force()
ss.show_axial_force()
ss.show_displacement()
```
Maka, diagram momen menjadi seperti berikut:

Diagram Momen (tinggi portal 4m)

Bagaimana? cepat bukan?

Oke.. struktur di atas masih sederhana. Mungkin tidak terlalu menyita waktu jika ada revisi.

Bagaimana jika Owner ingin gedung menjadi 7 tingkat?, dengan tinggi menjadi 6 m dan bentang balok menjadi 10m..?

Dengan menggunakan code sebelumnya, namun dengan beberapa baris perubahan code menjadi seperti berikut:
```
from anastruct.fem.system import SystemElements
ss = SystemElements()

# Material/Properti Penampang
EA = 5e9
EI = 8000

# Geometri
h = 6
L = 10
n_tingkat = 7

for i in range(n_tingkat):
    # Tambah element balok/kolom
    ss.add_element(location=[[0,i*h], [0,(i+1)*h]], EA=EA, EI=EI)
    ss.add_element(location=[[L,i*h], [L,(i+1)*h]], EA=EA, EI=EI)
    ss.add_element(location=[[0,(i+1)*h], [L,(i+1)*h]], EA=EA, EI=EI)
    
    # Tambah beban merata pada balok
    ss.q_load(element_id=(i+1)*3, q=-13)

# Tambah tumpuan
ss.add_support_fixed(node_id=1)
ss.add_support_fixed(node_id=3)

# Run Analisis
ss.solve()

# Tampilkan gambar struktur
ss.show_structure()
ss.show_reaction_force()
ss.show_bending_moment()
ss.show_axial_force()
ss.show_displacement()
```
Maka, dengan Running shit+enter lagi langsung diperoleh diagram sebagai berikut.

Gambar Geometri Struktur

Reaksi Perletakan

Gambar Digram Momen

Gambar Gaya Aksial

Gambar Deformasi Struktur

Dengan menggunakan paket program analisa struktur, pembuatan/revisi model sangat cepat dilakukan. Walaupun kondisi penambahan tingkat di atas dapat dilakukan dengan fitur Replicate pada program SAP2000 atau ETABS, namun tetap kecepatan tidak melebihi paket program.

Adanya tampilan antar muka (Graphical User Interface/GUI) pada software sekarang memang sangat memudahkan user pemula dalam membuat model struktur. Selain itu software struktur mempunyai fitur yang banyak baik itu fitur analysis dan desain.

User biasanya akan stack jika ditanyakan tentang lisensi/izin. Maka, paket program seperti Anastruct dan Openseespy dapat digunakan, program ini tersedia secara gratis untuk semua orang.

Referensi:

https://anastruct.readthedocs.io/en/latest/
8 blog terbaik untuk calon insinyur sipil

June 12, 2020
Blog terbaik? Harus ada alasan dong!

Baiklah.. intro dulu lah sebelum menuju ke daftar blognya.

Untuk menjadi seorang insinyur handal, tentunya harus belajar sama ahlinya, benar bukan?

Begitu banyak ahli di luar sana, namun hanya sedikit yang menuangkan ilmu dan pengalamannya ke dalam tulisan untuk disebarkan secara gratis.

Mungkin karena sibuk urus proyek ya?

Well.. berikut beberapa alasan yang perlu Anda notice, mengapa blog berikut menjadi bacaan terbaik:
- Membahas esensi, bukan sekedar pakai rumus ataupun comot SNI.
- Update informasi perkembangan dunia teknik sipil
- Pengalaman pribadi sebagai seorang ahli/praktisi maupun akademisi
- Tulisan blog menggunakan bahasa dan analogi yang lebih mudah dimengerti. Tidak seperti kebanyakan buku teks yang njelimet.
Oke langsung saja..

#1. http://wiryanto.blog (Bahasa Indonesia)

Tulisan personal Prof. Wiryanto Dewabroto. Recommended buat Anda yang lagi ngulik struktur baja, dan SAP2000. Beliau juga telah menerbitkan buku untuk kedua topik tersebut yang banyak dipakai oleh akademisi maupun praktisi di dunia teknik sipil. Yang utama, beliau akan dengan senang hati menjawab curahan hati, komentar, masalah yang sering dihadapi di lapangan, dan tentunya memberikan solusi atas pertanyaan tersebut.

#2. https://ryanrakhmats.wordpress.com (Bahasa Indonesia)

Ryan Rakhmat Setiyadi, Senior structural engineer, PT. ARUP Indonesia. Bagi Anda yang menyukai pembahasan advance structural analysis dan design, penurunan rumus praktis, beton bertulang, seluk beluk SNI dan code luar negeri, beban angin dan gempa, silahkan go to this blog.

#3. http://syont.blogspot.com atau https://syont.wordpress.com (Bahasa Indonesia)

Suyono Nt. Bagi kalian yang bergelut di bidang pemodelan struktur, khususnya finite element modeling software, struktur baja dan all about modelling.

#4. https://www.thestructuralmadness.com (Bahasa Inggris)

Personal blog Jinal Doshi, Project Engineer, di perusahaan DCI Engineer, Seatle, US. Structural engineer dengan segudang pengalaman di berbagai perusahaan konstruksi. Bagi yang suka pembahasan mendalam mengenai gempa, esensi dari daktilitas, disipasi energi, respon spektrum dan lain sebagainya silahkan jalan-jalan ke blog tersebut.

#5. https://www.ritchievink.com (Bahasa Inggris)

Ritchie Vink, seorang structural engineer, data scientist, dan data engineer. Saya pribadi sangat berminat dengan aplikasi open source anaStruct buatannya. Pembahasan mengenai python, algoritma, neural network, dan aplikasi machine learning dalam dunia teknik sipil.

#6. http://portwooddigital.com (Bahasa Inggris)

Semua tentang OpenSees. Tips n trick pengunaan OpenSees, ada pula tantangan atau challenge inteaktif untuk lebih memahami tentang opsi pemodelan. Oh ya jangan lupa, di sini juga Anda akan bertemu dengan orang-orang dengan minat yang sama di kolom komentar.

#7. https://simplesupports.wordpress.com (Bahasa Inggris)

Pembahasan mengenai code beton, gempa, prinsipal engineering, dan yang unik adalah mengenai sejarah seperti, asal muasal beban desain minimum, Mengapa beton era Romawi lebih tahan dari beton sekarang? dan sebagainya. Sayangnya penulis sekarang tidak aktif lagi, namun artikel terdahulu masih dapat di akses.

#8. https://arinisputri.wordpress.com (Bahasa Indonesia)

Arini S Putri, jurusan matematika ITB. Walaupun di luar topik teknik sipil, blog ini recommended sebagai bacaan tambahan bagaimana kita bermatematika dalam kehidupan sehari-hari. Blog ini membahas topik tentang Matematika, Fisika, Fisika Kuantum, beliau juga aktif menulis dalam platform Quora.

Update 11 Desember 2021

#9. https://gouw2007.wordpress.com/ (Bahasa Indonesia)

Dr. Gouw TL, beliau ada seorang pakar di bidangnya yaitu geoteknik. Bagi Anda yang sedang mendalami bidang geoteknik, silahkan langsung menuju blog ini.

Update 30 Agustus 2022

#10. https://irawanfirmansyah.wordpress.com/ (Bahasa Indonesia)

Bapak Ir. Irawan Firmansyah, MSCE. Beliau adalah seorang geotechnical engineer specialist high rise building. Bagi teman-teman yang lagi nyari referensi kondisi tanah sekitar Ibukota Jakarta, blog ini adalah tempat yang tepat.

Ada rekomendasi blog lain? silahkah tinggal komentar di bawah ini.

Demikian, semoga bermanfaat.

Opensees: Analisis Elastik Orde-2

June 9, 2020

Sebelumnya telah dibahas mengenai anaStruct: Tekuk Elastik dan Opensees: Perkenalan. Maka, kali ini saya ingin mencoba eksplor bagaimana sih, hasil analisis elastic buckling menggunakan OpenSeespy.

Sama dengan anaStruct, Openseespy juga merupakan program open source alias gratis dan tentunya non-GUI. Namun, Openseespy dibekali dengan banyak fasilitas hingga mampu memodelkan struktur, geoteknik maupun kedua secara bersamaan. Lebih dikenal dengan soil structure interaction (SSI).

Dengan soal yang sama yaitu kolom baja sederhana 8,5 m, dalam artikel anaStruct: Tekuk Elastik, dilakukan analisis elastik orde-2. Berikut souce code yang ditulis menggunakan bahasa python3 dan package openseespy.

import openseespy.opensees as ops
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.pyplot import figure
import openseespy.postprocessing.Get_Rendering as opsplt
import openseespy.preprocessing.DiscretizeMember as opsdm
%matplotlib inline

ops.wipe()
ops.model('basic', '-ndm', 2, '-ndf', 3)

cm = 1/100. # m
kg = 0.00981 #kN

# Data Penampang
A = 39.65 *cm**2
I = 563. *cm**4
MPa = 1000. # kPa
w = 31.1 *kg

# Data material
E0 = 200000.*MPa
L = 8.5

Nsteps = 25
Py = -160.
Px = 0.002*160

# membuat node
ops.node(1, 0.0, 0.0)
ops.node(2, 0.0, L)

# tumpuan
ops.fix(1, 1,1,0)
ops.fix(2, 1,0,0)

# elemen
ops.geomTransf('Corotational', 1)
ops.section('Elastic',1,E0,A,I)
ops.beamIntegration('Lobatto',1,1,10)
opsdm.DiscretizeMember(1, 2, 8, 'elasticBeamColumn', 1, 1, 3, 1)

ops.timeSeries("Linear", 1)
ops.pattern("Plain", 1, 1)
ops.load(2, 0., Py, 0.)
ops.load(5, Px, 0., 0.)


# Analisis
ops.system("ProfileSPD") # create SOE
ops.numberer("Plain") # create DOF number
ops.constraints("Plain") # create constraint handler
ops.integrator("LoadControl", 1.0/Nsteps, 10) # create integrator
ops.algorithm("Newton") # create algorithm
ops.analysis("Static") # create analysis object

data = np.zeros((Nsteps+1,2))
for j in range(Nsteps):
    ops.analyze(1)
    data[j+1,0] = ops.nodeDisp(5,1)
    data[j+1,1] = ops.getLoadFactor(1)*Py*-1

#Plot data dalam grafik
figure(num=None, figsize=(5, 5), dpi=80, facecolor='w', edgecolor='k')
plt.plot(data[:,0], data[:,1],'-',label='anaStruct Pcr = 153.60 kN')
plt.plot([0,1.25],[153.815,153.815],'r--',label='Exact = 153.815 kN')
plt.xlabel('Lateral Displacement at Mid Point(m))')
plt.ylabel('Vertical Load at top (kN)')
plt.legend(bbox_to_anchor=(0.5, 0.2), loc='upper center', borderaxespad=0.)
plt.show()

Dari grafik di atas, terlihat perubahan perpindahan lateral yang tiba-tiba dan besar, yang menandakan terjadinya tekuk. Hasil analisa diperoleh kuat tekuk kritis (Pcr) sebesar 153,6 kN. Maka, dapat dibandingkan dari hasil analisa sebelumnya sebagai berikut.

===> geser tabel

Analisis	Euler	SAP2000	anaStruct	Opensees
Eksak	153,815
Linear Elastic		153,820	153,820
Elastic Orde-2		153,600	153,000	153,600

Terlihat bahwa hasil yang diperoleh dengan SAP2000 sama persis dengan Openseespy, yaitu sebesar 153,60 kN. Dengan demikian pemodelan dianggap sudah mendekati nilai eksak sebesar 153,815 kN.

*Catatan:

Opensees adalah program yang ditulis dalam bahasa Tcl, sedangkan Openseespy merupakan program yang ditulis dalam bahasa Python3.6. Oleh karena itu untuk membuka opensees harus dipersiapkan terlebih dahulu persyaratannya. Dapat dilihat di halaman berikut:

Opensees: https://opensees.berkeley.edu/
Openseespy: https://openseespydoc.readthedocs.io/en/latest/

anaStruct: Tekuk Elastik

June 6, 2020
Kali ini, saya mencoba membahas problem tekuk elastis pada analisis kolom baja. I’m not going deep, cause I can’t. Hanya sekadar menguji performa anaStruct yang digratiskan oleh Richie Vink, dengan menggunakan contoh soal dalam tulisan Pak Wir.

Target utama yaitu untuk menganalisis kuat tekan kritis (Pcr) menggunakan aplikasi dan membandingkan hasil yang diperoleh dengan nilai tekuk eksak dari persamaan Euler. Dalam analisis dilakukan dengan dua pendekatan, yaitu (1) elastic buckling analysis dan (2) second order elastic analysis. Informasi detail mengenai dua metode ini, akan dijelaskan seiring pembahasan berikut.

Sedikit intro tentang aplikasi yang digunakan, anaStruct merupakan package python dalam analisa struktur non-linear menggunakan metode elemen hingga (finite element method). Aplikasi ini non-GUI, tidak seperti aplikasi analisa struktur lainnya seperti SAP 2000.

Baiklah.. akan dianalisa kolom baja sederhana seperti yang terlihat dalam gambar (bagian a.) berikut.

Data:
Profil baja H, dengan:
Tinggi kolom (L) = 8,5 m
Luas penampang (A) = 39,65 cm^2
Inersia (I) = 563.0 cm^4
Berat/meter = 31,1 Kg/m

Elastisitas (E) = 200.000 Mpa
kuat leleh (fy) = 250 Mpa

Kondisi tumpuan
tumpuan bawah = sendi
tumpuan atas = sendi roll

Berdasarkan persamaan Euler, diperoleh tekuk kritis:

Pcr = (phi² x EI) / L² = 153.815 kN

(1) Analisa Tekuk Elastik (Elastic Buckling Analysis)
Strategi dalam pendekatan ini yaitu mencari nilai faktor pengali beban yang menyebabkan terjadinya tekuk atau dikenal dengan faktor tekuk (buckling factor).

Nah.. faktor tekuk dianalisis dengan memberikan beban (P) sebesar 1 kN di puncak kolom. Secara otomatis kuat tekan kritis diperoleh sama dengan faktor tekuk,

Pcr = 1 x faktor tekuk = faktor tekuk.

Sebagai perbandingan, kolom baja 8,5 m tersebut akan dibagi dalam beberapa elemen diskrit yaitu 1 elemen, 2 lemen, 4 elemen dan 8 elemen seperti yang terlihat dalam gambar di atas.

Dengan soal di atas, kemudian ditulislah ke dalam bahasa python dengan menggunakan Jupyter Notebook.
```
from anastruct import SystemElements
from math import pi
import matplotlib.pyplot as plt

# Konversi Satuan
cm = 10 # mm
m = 1000 # mm
kN = 1000 # N
kg = 9.81 # N

# Data Penampang
A = 39.65 *cm**2
I = 563. *cm**4
w = 31.1 *kg/m

# Data material
E = 200000. # MPa
Fy = 250. # MPa
EA = E * A
EI = E * I
L = 8.5 *m

# Beban
P = 1*kN

# Rumus euler
Pcr = ((pi**2 * EI) / L**2)/kN
print("Rumus Euler, tekuk kritis Pcr = ", round(Pcr,5))

# Elemen dan Geometri Struktur
ss = SystemElements(EA = EA, EI = EI)
ss.add_element(location = [[0, 0],[0, L]])
ss.add_support_hinged(node_id = 1)
ss.add_support_roll(node_id = 2, direction = 1)
ss.point_load(Fy = -P, node_id = 2)

# Jumlah elemen
n = [1,2,4,8]

buckling_factor = []
for value in n:
    discretize_kwargs = {'n':()}
    ss.solve(geometrical_non_linear = True, discretize_kwargs=dict(n=value))
    buckling_factor.append(round(ss.buckling_factor,4))

# Plot jumlah elemen vs buckling factor    
plt.plot(n, buckling_factor,'--o')

for x,y in zip(n, buckling_factor):
    label = "{:.4f}".format(y)
    plt.annotate(label,
                 (x,y),
                 textcoords="offset points",
                 xytext=(0,10),
                 ha='center')

plt.xlabel("Jumlah Elemen (n)")
plt.ylabel("Faktor Tekuk")
plt.show()
```
Perbandingan nilai eksak, dan buckling factor menggunakan SAP2000 v.15 (Wiryanto Dewabroto, 2010)

Buckling factor dengan menggunakan anaStruct

Dari grafik di atas, terlihat faktor tekuk yang diperoleh dengan anaStuct sama dengan hasil yang diperoleh dengan SAP2000 v15. Dengan demikian pemodelan yang dilakukan menggunakan anaStruct dianggap sudah benar.

Faktor tekuk mendekati nilai eksak Euler = 153,815 kN, seiring dengan penambahan elemen diskrit. Dalam hal ini sebesar 153.820 kN untuk 8 elemen diskrit. Berdasarkan percobaan penulis, akan diperoleh hasil yang sama persis dengan eksak jika elemen diskrit sebesar 20 elemen.

*Catatan: dengan jumlah elemen diskrit yang banyak, akan menguras RAM laptop Anda.

Masalah ini juga menjadi poin penting oleh Pak Wir, bahwa meskipun menggunakan aplikasi yang canggih seperti SAP2000, untuk mendapatkan hasil yang tepat masih diperlukan campur tangan insinyur.

Sebaliknya, walaupun hanya menggunakan aplikasi gratis open-source, dengan pengaturan yang baik akan diperoleh hasil tidak kalah baiknya.

Penambahan elemen diskrit atau dalam SAP2000 dikenal dengan meshing, tanpa campur tangan insinyur maka pemodelan akan menggunakan 1 elemen diskrit sehingga diperoleh hasil tekuk kritis sebesar 187,017 kN jauh berbeda dengan hasil eksak sebesar 153,815 kN.

Man behind the gun

(2) Analisa Elastik Orde-2 (Second Order Elastic Analysis)

Perbeda dengan pendekatan sebelumnya yaitu elastic buckling, hasil yang diperoleh berupa faktor tekuk tanpa mengetahui perpindahan yang terjadi.

Nah.. pendekatan analisa elastik orde-2 dilakukan dengan memberikan beban iteratif di puncak kolom kemudian memperhatikan perpindahan yang terjadi di node tengah kolom.

Sebagaimana dijelaskan dalam tulisan Pak Wir, cara ini dikenal dengan nama Direct Analysis Method (DAM) dalam AISC 2010.

Dengan struktur kolom yang sama dengan sebelumnya, kemudian analisis dengan kondisi:

Model A: Tanpa gaya notional

Model B: Dengan gaya notional di tengah bentang sebesar: H = 0,002 x P

Dapat dilihat dalam gambar berikut ini.

Analisa Elastik Orde-2 (Wiryanto Dewabroto, 2010)

Kemudian model di atas dianalisis menggunakan anaStruct, dengan sedikit perubahan dari code sebelumnya, sebagai berikut:

Code Model A: Tanpa Beban Notional
```
# Elemen dan Geometri Struktur
ss = SystemElements(EA = EA, EI = EI)
ss.add_element(location = [[0, 0],[0, L]], g = w)
ss.add_support_hinged(node_id = 1)
ss.add_support_roll(node_id = 2, direction = 1)
ss.discretize(n = 2)

# Beban
# Beban titik = 150 sampai 153 kN, dengan inerval 0.001 kN
P = np.arange(150*kN,153*kN,0.001*kN)

displacement = []
for load in P:
    ss.point_load(Fy = -load, node_id = 3)
    # Mengaktifkan non-linear analisis atau P-Delta
    ss.solve(geometrical_non_linear = True, discretize_kwargs=dict(n=1))
    displacement.append(ss.get_node_displacements(node_id=2))
ss.show_structure()

disp = []
for value in displacement:
    disp.append(value['ux']/1000)

plt.plot(disp,P/1000)
plt.xlabel("Perpindahan (m)")
plt.ylabel("Gaya (kN)")
plt.show
```
Code Model B: Dengan Beban Notional di Tengah Bentang
```
# Numerik
ss = SystemElements(EA = EA, EI = EI)
ss.add_element(location = [[0, 0],[0, L]], g = w)
ss.add_support_hinged(node_id = 1)
ss.add_support_roll(node_id = 2, direction = 1)
ss.discretize(n = 2)

# Beban
# Beban titik = 150 sampai 153 kN, dengan inerval 0.001 kN
P = np.arange(150*kN,153*kN,0.001*kN)

displacement = []
for load in P:
    ss.point_load(Fy = -load, node_id = 3)
    ss.point_load(Fx = load*0.002, node_id = 2) # P Notional
    # Mengaktifkan non-linear analisis atau P-Delta
    ss.solve(geometrical_non_linear = True, discretize_kwargs=dict(n=1))
    displacement.append(ss.get_node_displacements(node_id=2))
ss.show_structure()

disp = []
for value in displacement:
    disp.append(value['ux']/1000)

plt.plot(disp,P/1000)
plt.xlabel("Perpindahan (m)")
plt.ylabel("Gaya (kN)")
plt.show
```
Berikut merupakan hasil analisis tekuk elastis orde-2 dengan SAP2000 v.15 oleh Pak Wir. Hasil berikut berupa grafik hubungan gaya (vertikal axis) dan perpindahan lateral di tengah bentang (horizontal axis).

Dari hasil SAP2000 untuk model A (tanpa gaya notional), tidak terlihat perubahan perpindahan yang besar atau tiba-tiba. Oleh karena itu, kuat tekan kritis (Pcr) tidak dapat ditentukan.

Sedangkan model B (dengan gaya notional) terlihat perubahan perpindahan yang besar dan tiba-tiba, yaitu pada beban P sebesar 153,60 kN. Nilai ini mendekati nilai perhitungan eksak sebesar 153,815 kN.

Hubungan Gaya-Perpindahan dengan SAP2000 v.15 (Wiryanto Dewabroto, 2010)

Dua grafik di bawah ini merupakan hasil yang diperoleh menggunakan anaStruct.

Untuk model A, terlihat perubahan perpindahan yang tiba-tiba. Walaupun tanpa beban notional di tengah bentang, anaStruct sudah mampu memprediksi kuat tekan kritis sebesar 153,0 kN mendekati nilai eksak sebesar 153,815 kN. Meskipun nilai perpindahan yang terlihat sangat kecil, namun terlihat kenaikan perpindahan tiba-tiba yang menandakan kondisi instability pada kolom.

Untuk model B, terlihat perubahan perpindahan yang besar dan tiba-tiba, dengan nilai kuat tekan kritis yang sama yaitu sebesar 153,0 kN.

anaStruc: Model A

anaStruc: Model B

*Catatan: menaikkan beban lebih besar dari 153,0 kN, menyebabkan instabilitas struktur sehingga anaStruct tidak mendapatkan hasil.

Tabel Rekapitulasi kuat tekuk kritis (Pcr)

Analisis Eksak (kN) SAP2000 (kN) anaStruct (kN)
Rumus Euler 153,815
Linear Elastic 153,820 153,820
Second Order Elastic 153,600 153,000

* Catatan:
1. Linear elastic, SAP2000 dan anaStruct dengan 8 elemen diskrit
2. Second Order Elastic, anaStruct dapat memprediksi meskipun tanpa beban notional
3. Jumlah elemen diskrit dan jumlah iterasi sangat mempengaruhi hasil.
4. Memperbanyak elemen diskrit menguras peforma RAM laptop
5. anaStruct, package open-source cukup baik memprediksi hasil dibandingkan dengan software komersial seperti SAP2000.
Referensi:
- Rekaysa Komputer dalam Analisis dan Desain Struktur Baja Studi Kasus Direct Analysis Method (AISC 2010), bagian II: Contoh Aplikasi Praktis. Wiryanto Dewabroto (2010)
- anaStruct: Non linear structural analysis in Python
Dinding Bata dalam Analisa Struktur Gedung Kondisi Gempa

March 5, 2020
Beberapa bulan pasca gempa Palu 28 September 2018, seorang teman datang dan berkata desain gedung yang telah dia buat, ditolak oleh tenaga ahli. Dia bekerja di salah satu instansi di kota Palu. Menurut tenaga ahli struktur instansi tersebut, desainnya tidak aman terhadap gempa. Tenaga ahli tersebut didatangkan dari pulau jawa, lulusan universitas ternama..

Singkat cerita, dia ingin mengecek desainnya, apakah masih aman terhadap gempa. Dari hasil analisa yang saya lakukan, gedung masih aman namun dengan sedikit perubahan pada kolom praktis. Gedung tersebut merupakan gedung sekolah 1 tingkat dengan dinding batu bata. Karena keterbatasan dana, desain diusahakan masih memenuhi anggaran dan tetap aman terhadap gempa.

Kabar terakhir, desain tersebut tetap ditolak. Apalah daya kita lulusan universitas lokal..

Analisa struktur yang saya lakukan memasukkan dinding bata dalam tinjauan struktur tersebut. Namun, tenaga ahli tersebut mengatakan analisa harus menggunakan asumsi Open Frames alias dengan mengabaikan dinding bata. Selain itu, dia juga menambahkan balok (Horizontal) pengaku di setiap 4 sudut ruangan.

Baiklah, bagaimana sebenarnya permasalahan ini?

Dinding bata memang sering diasumsikan tidak memikul beban gempa (komponen non-struktural). Memang saat kuliah, kita selalu diajarkan analisa struktur dengan kondisi open frames. Khususnya analisa struktur kategori bangunan non-engineered atau non-rekayasa tidak pernah diajarkan di bangku kuliah. Namun, kasus ini banyak di hadapi di lapangan. Selain itu, referensi mengenai materi ini juga masih sangat sedikit. Alhasil, perencana struktur akan menganalisa sebagaimana struktur pada umumnya.

Dinding Bata Terkait Periode Struktur

Periode struktur (T) merupakan parameter penting dalam tinjauan beban gempa. Nilai ini menggambarkan perilaku struktur saat dikenai gempa. Sebelum masuk pembahasan periode struktur, sangat penting dibahas prinsip dasar gaya kondisi gempa terlebih dahulu.

Seperti yang kita ketahui, gaya gempa (dinamis) merujuk pada hukum Newton II yaitu gaya sama dengan massa dikali percepatan atau F = ma. Jika massa diasumsikan tetap, semakin besar percepatan (a), maka gaya akan semakin besar pula. Percepatan gempa sangat berhubungan dengan periode struktur, seperti dilihat pada grafik respon spektra berikut.

Respon Spektra Palu, SNI Gempa 2012

Gambar di atas merupakan grafik respon spektra dengan SNI Gempa 2012. Walaupun sudah ada SNI gempa terbaru tahun 2019, grafik di atas cukup menjadi bahan pembelajaran.

Grafik tersebut merupakan hubungan Periode (T) arah x dan Spektra Percepatan arah y. Masing-masing warna mewakili kondisi tanah setempat dimana lokasi struktur tersebut dibangun.

Untuk mendapatkan spektra percepatan, maka periode struktur harus diketahui terlebih dahulu. Maka, berikut ditinjau tipikal ukuran bangunan sekolah satu tingkat. Berdasarkan SNI 1726 2019, periode struktur pendekatan dapat dihitung sebagai berikut:

Ta = 0.0466 x h^0.9 = 0.0466 x (4^0.9) = 0.162 detik (h = tinggi struktur)

Maka, Periode Struktur Ta = 0.162 detik berdasarkan SNI Gempa 2019.

Sebagai perbandingan, periode struktur Open Frames akan dianalisa menggunakan software SAP 2000 versi 7.4 (Student Version). Berikut parameter gempa yang di-input:

Dari hasil analisa menggunakan SAP2000, periode fundamental struktur T = 0.2776 detik lebih besar dari periode berdasarkan SNI yaitu Ta = 0.162 detik. Maka, menurut SNI periode yang digunakan yaitu T= Cu x Ta = 1.4 x 0.162 = 0.2268 detik.

Maka, periode struktur tinjauan tanpa dinding (Open Frames) sebesar 0.2268 detik.

Analisa Struktur Dengan Dinding Bata

Sekarang, analisa periode struktur dilakukan dengan menambahkan dinding bata sebagai elemen shell, dengan data sebagai berikut:
- Elastisitas bata (E) = 3343 Kg/cm2
- Berat isi bata = 1922 Kg/m3
- Angka poisson = 0.15
Periode struktur dengan dinding bata yaitu T = 0.0148 detik. Periode struktur dengan dinding bata lebih kecil dari analisa tanpa dinding 0.0148 detik < 0.2268 detik.

Jika kedua nilai periode struktur di plot ke dalam grafik respon spektra (SNI 2012), akan diperoleh percepatan gempa yang lebih kecil untuk struktur dengan dinding. Sehingga gaya gempa dengan dinding lebih kecil. Sedangkan tanpa dinding menghasilkan percepatan yang lebih besar, sehingga gaya gempa lebih besar pula.

Berikut hasil plot periode struktur untuk mendapatkan spektral percepatan (Sa)

Mengabaikan pengaruh dinding bata, mengakibatkan percepatan struktur berada di puncak grafik percepatan untuk semua kondisi tanah. Sehingga, gaya gempa pada gedung bernilai besar pula. Akibatnya, desain gedung akan sangat boros.

Sedangkan dengan memasukkan pengaruh dinding bata, periode struktur akan lebih kecil. Sehingga gaya gempa pada gedung lebih kecil. Dengan demikian desain gedung lebih ekonomis.

Dengan dinding bata, struktur gedung akan lebih kaku. Dinding berperilaku sebagai dinding geser, yang mana turut memikul beban gempa. Sudah cukup banyak penelitian mengenai dinding geser bata. Seperti salah satu penelitian teman kami Moh. Fahri Afandi, ST di sini Perkuatan Struktur Variasi Dinding Geser.

Pengaruh Soft Storey

Dengan memasukkan dinding bata dalam analisa, pengaruh soft storey akan mudah dideteksi. Berikut ini contoh tinjauan tipikal bangunan rumah toko (Ruko) tinggi 4 m dan bentang 4 m.

Dapat dilihat, deformasi struktur soft storey dapat dilihat langsung dengan memasukkan dinding bata. Sedangkan tanpa dinding, deformasi struktur terlihat seperti pada umumnya.

Klik untuk memperbesar gambar..

Selain itu, dengan dinding bata, momen pada kolom lantai dasar sebesar M = 258,33 kN.m sedangkan tanpa dinding momen M = 44,76 kN.m, lima kali lipat perbedaanya. Dapat dilihat dalam gambar gaya momen di atas.

Bagaimana bisa kita mendapatkan gaya yang sesuai, dengan mengasumsikan gedung tanpa dinding secara keseluruhan? tentunya hasilnya akan berbeda sesuai contoh di atas.

Pengaruh Soft Storey adalah kondisi dimana gempa akan mendistribusikan sebagian besar gaya gempa ke lantai yang lebih soft (lunak) atau kekakuan lebih kecil atau dengan kata lain lantai Tanpa Dinding. Sehingga gaya momen pada kolom lantai tersebut akan membengkak, dan menyebabkan keruntuhan gedung. Desain lantai dasar tanpa dinding sudah umum dijumpai, khususnya rumah toko (ruko), kantor, ataupun untuk peruntukan tempat parkir. Padahal kondisi ini akan rawan terhadap gempa.

Gambar berikut merupakan contoh efek soft storey yang terjadi akibat gempa 28 September 2018.

Untuk struktur sederhana Gedung satu atau dua tingkat, keterbatasan anggaran merupakan masalah yang sering dihadapi. Dengan memasukkan dinding bata dalam analisis, hasil akan lebih ekonomis, lebih realistis dan lebih aman.

Rusunawa Lere, Palu

Hotel Roa-Roa, Palu

Rumah Sakit Anutapura, Palu
Dampak Negatif Mengabaikan Penurunan Pondasi

March 4, 2020

Penurunan pondasi terkadang diabaikan, khususnya pada struktur sederhana 1 atau 2 tingkat tergantung tingkat kepentingannya. Apa alasannya? biaya penyelidikan tanah yang relatif mahal.

Penurunan pondasi hanya bisa diperkirakan dari data penyelidikan tanah. Namun, pemilik (Owner) bangunan sederhana seperti kantor atau rumah toko (Ruko), akan berpikir berulang kali apabila ingin mengeluarkan biaya tambahan.

Selain itu, dalam perencanaan struktur gedung terkadang “perencana struktur” mengabaikan penurunan pondasi. Tinjauan keamanan pondasi hanya berdasarkan faktor aman kapasitas dukung tanah.

Bersama-sama pondasi, balok sloof atau balok ikat seringkali tidak dimasukkan dalam proses analisa struktur gedung. Beban hanya berdasarkan asumsi 25% dari gaya pada kolom dan tumpuan diasumsikan jepit. Mengenai sloof akan dibahas seiring dengan pembahasan penurunan pondasi berikut ini.

Seberapa pentingkah tinjauan penurunan pondasi pada struktur gedung?

Bagaimana pengaruh penurunan pondasi terhadap keamanan struktur gedung?

Berikut akan ditinjau struktur portal tinggi 4 m dan bentang 6 m. Pada balok diberi beban 20 kN/m. Ukuran penampang balok, sloof, dan kolom dapat dilihat pada gambar berikut ini.

Digunakan mutu beton K-175 (fc’ 15), dengan kondisi pencampuran manual oleh tukang dan faktor pelaksanaan, akan sulit mendapatkan mutu beton lebih besar dari itu (itupun untung-untungan jika terpenuhi K-175).

Analisa struktur menggunakan software SAP2000 versi 7.4 (lisensi student version). Pakai ini aku, jangan kena tuntutan perusahaannya..

Baiklah, dengan geometri struktur di atas, akan ditinjau beberapa kondisi sebagai berikut:

Kondisi 1

Kondisi tumpuan jepit seperti gambar di atas, mengabaikan penurunan pondasi. Akan ditinjau momen pada balok ikat/sloof seperti pada umumnya.

Kondisi 2

Diberi tambahan penurunan 1 cm = 10 mm pada tumpuan tengah. Asumsi tumpuan masih jepit sempurna.

Kondisi 3

Tanpa beban penurunan. Asumsi menggunakan tumpuan spring pada kolom dan sloof. Menggunakan modulus subgrade 10.000 kN/m3 (Pasir kepadatan sedang) lihat tabel berikut. Asumsi menggunakan pondasi telapak ukuran 1 m x 1 m dan lebar sloof 0.25 m. Maka digunakan input kekakuan spring vertikal dan horizontal sebagai berikut:

Pondasi (Tumpuan Kolom)

kh = 1 m x 1 m x 10.000 kN/m3 = 10.000 kN/m dan kv = 2kh = 20.000 kN/m

Balok ikat atau sloof

kh = 0.25 m x 1 m x 10.000 kN/m3 = 2500 kN/m dan kv = 2kh = 5000 kN/m

Kondisi 4

Diberi penurunan 1 cm = 10 mm di tumpuan kolom tengah. Asumsi tumpuan spring sesuai kondisi 3.

Hasil Analisa Struktur Menggunakan SAP2000 v.7.4

Berikut ini hasil analisa struktur menggunakan SAP 2000 untuk masing masing kondisi di atas.

Bentuk deformasi struktur

Gaya yang terjadi pada struktur

Pembahasan

So.. bagaimana kita membaca gambar di atas?

Pertama, kita akan menghitung momen pada balok ikat seperti pada umumnya. Sebagai berikut:

Dari gambar gaya aksial kondisi 1 diketahui P1= 65,58 kN dan P2 = 170.76 kN

Dimana L = panjang sloof = 6 m

Beban merata (q) balok sloof = [25%(P1 + P2)]/6 = 9,85 kN/m

Momen pada sloof = (9,85 x 6^2)/12 = 29,55 kN.m

Kedua, bisa kita lihat pada gambar momen kondisi 2, akibat penurunan 1 cm, momen pada balok ikat atau sloof sebesar 32,74 kN.m dimana lebih besar dari perhitungan biasa sebesar 29, 55 kNm.

Selain itu, pada kondisi 2 ini terlihat gaya momen kolom pinggir 41,32 kN lebih besar dua kali lipat dari kondisi 1 yaitu 19,85 kN.

Ketiga, pada kondisi 3 dengan tumpuan spring tanpa tambahan penurunan. Terlihat momen pada sloof (tengah) sebesar 55,58 kNm lebih besar dua kali lipat dari perhitungan biasa 19,85 kN.

Sedangkan momen pada balok atas dan kolom kurang lebih sama dengan kondisi 1 (Konservatif). Namun, sebenarnya momen pada balok atas lumayan perbedaanya.

Keempat, kondisi 4 terlihat momen pada sloof sebesar 89,39 kNm lebih besar tiga kali lipat dari perhitungan biasa (kondisi 1) sebesar 29,55 kNm.

Kesimpulan

Dari hasil di atas disimpulkan bahwa mengabaikan penurunan pondasi akan berakibat fatal pada struktur atas, sloof, kolom, maupun balok. Dimana gaya momen diperoleh hingga dua bahkan tiga kali lipat dari perhitungan biasa. Jika penulangan struktur hanya berdasarkan momen tanpa penurunan, maka bisa dikatakan struktur tersebut tidak aman. Struktur akan aman jika penurunan pondasi dianalisa berdasarkan hasil penyelidikan tanah (Sondir ataupun SPT) dan menjamin penurunan tidak menimbulkan gaya yang berlebihan pada struktur atas.

Catatan: penurunan di atas belum memasukkan pengaruh gempa.