Nyoba Stability Challenge

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.

Elemen diskrit

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

Resulte

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

8 blog terbaik untuk calon insinyur sipil

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/

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

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

Demikian, semoga bermanfaat.

Opensees: Analisis Elastik Orde-2

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()
Output

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

AnalisisEulerSAP2000anaStructOpensees
Eksak153,815
Linear Elastic153,820153,820
Elastic Orde-2153,600153,000153,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:

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

anaStruct: Tekuk Elastik

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 (w) = 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 = (phi2 x EI) / L2 = 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)

AnalisisEksak (kN)SAP2000 (kN)anaStruct (kN)
Rumus Euler153,815
Linear Elastic153,820153,820
Second Order Elastic153,600153,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:

Old but Gold

Tulisan berikut mungkin bukan merupakan terjemahan yang tepat untuk tulisan quorawan Gopalkrishna Vishwanath, struktural engineer berkebangsaan India. Yang berjudul:

How do I design a RCC building without using software?

Bagaimana saya dapat mendesain struktur beton bertulang tanpa menggunakan software?

Artikel berikut sudah diterjemahkan dengan beberapa perubahan tanpa merubah arti secara signifikan. Bagi yang suka baca bahasa inggris, silahkan menuju link di atas.

Mulai dari sini yo! Jangan lupa siapkan kopi hangat..

2017-01-bim-model

***

Saya tidak dapat memberikan tips teknis secara lengkap untuk mendesain struktur beton bertulang tanpa menggunakan software dan asumsi awal tanpa menggunakan komputer.

Saya dapat memberikan saran/tips umum mengenai struktur baja dimana merupakan bagian dari proyek industri, dimana saya mempunyai pengalaman disitu.

Saya berbicara tentang periode sebelum tahun 1980. Dimana komputer (PC) dan semua software modern belum ada.

Sebelum tahun 1975, bahkan kalkulator tidak ada pada kami di India, dan kami menggunakan metode Slide Rules (Metode grafis).

Kami membutuhkan waktu yang lama untuk mendesain. Kalkulator kami tidak seakurat sebagaimana hasil komputer saat ini tapi cukup lumayan.

Kami tidak mampu melakukan “Bagaimana jika” (Metode coba-coba) analisis dan eksperimen dengan cara merubah parameter untuk mendapatkan desain yang lebih ekonomis.

Kami menggunkan kertas, pensil, penghapus, mistar, buku catatan, buku referensi yang memberikan rumus momen, geser, dan defleksi, nomogram, grafik, dan referensi desain terdahulu yang telah dilakukan oleh senior berpengalaman. Kemudian membuat perkiraan (Intelligent guesses) tentang kemungkinan ukuran dari balok dan kolom untuk melakukan metode coba-coba (Trial and error) dalam pemilihan ukuran akhir.

Kami menghitung beban dengan menggunakan spread-sheet (lembar kerja) (Benar-benar lembar kerja menggunakan kertas, bukan Excel).

Kami mempunyai lembar kerja standar (semacam patron, anak teknik pasti tahu) dengan baris dan kolom digambar dahulu dengan lebar kolom berbeda-beda dan kemudian dapat digunakan.

Beban vertikal adalah yang paling mudah dihitung. Kami menganggap intensitas beban per feet kuadrat atau meter kuadrat dikali dengan tributari area (Metode Amplop) pada balok dan kolom kemudian menghitung beban rencana pada masing-masing balok dan kolom setiap lantai.

Untuk momen pada balok, berdasarkan pada kondisi tumpuan, kami menggunakan rumus wL^2/8, wL^2/10. Untuk memperkirakan lendutan pada balok, kami menggunakan rumus ML^2/(10EI).

Untuk momen pada kolom, berdasarkan beban angin lateral, kemudian kami mencocokan dengan kolom yang telah didesain terdahulu dengan parameter yang mirip dan telah dipastikan atau dengan melakukan analisa perkiraan.

Kebanyakan metode yaitu dengan memberikan beban angin pada salah satu sisi gedung sebagai beban terdistribusi merata.

Besar beban angin dalam Kg/m2 dikalikan dengan tributasi area lebar dinding pada masing-masing dimana kan menghasilkan beban terdistribusi merata pada sisi angin datang.

Kami menggunakan rumus wL^2/2 untuk moment kantilever pada kolom lantai dasar, dan momen pada kolom yang berada bada satu garis lurus.

Momen lebih banyak diterima oleh kolom eksterior dan sisanya diberikan kepada kolom interior.

Proporsi aktual momen (Momen sebenarnya) pada kolom eksterior dan interior tergantung pada lebar bentang dan ukuran kolom serta momen inersia kolom sepanjang garis yang sama sebagaimana arah datangnya angin.

Dengan percobaan awal momen dan gaya aksial, kami melihat referensi pada grafik dan nomogram yang sudah tersedia untuk mengecek tegangan yang terjadi.

Pada banyak kasus, engineer berpengalaman akan memberikan banyak revisi pada beberapa ukuran dan sampai diperoleh ukuran yang memuaskan. Gambar manual dibuat dengan pensil dan kertas oleh drafter terampil di bawah pengawasan engineer.

Proses ini sangat lambat dan menyiksa, tapi ini bemberikan kepuasan yang luar biasa.

Desainnya sangat mudah diperiksa oleh orang lain dan ini merupakan standar praktis untuk dikerjakan oleh orang yang tidak terlibat sebelumnya. Semuanya sangat terbuka, diijinkan untuk memeriksa buku catatan desain kami. Tidak seperti komputer dan software sekarang ini, dimana seperti kotak hitam (Black box) yang dimasukkan sejumlah data dan secara buta-buta percaya dengan angka yang diberikan oleh komputer. Kami dapat melihat apa yang kami lakukan dan merasa nyaman/aman dengan perbaikan hasil atau mencari hal yang mencurigakan pada beberapa hasil dan kami turun tangan secara langsung. Senior akan memantau proses perhitungan secara umum dan menyerahkan detail pemeriksaan pada junior.

Engineer berpengalaman mengetahui data propertis semua penampang, khususnya berat isi, momen inersia, dan modulus penampang. Mereka tidak sering melihat referensi manual.

Semua ini membuat kita memperoleh “Rasa” (Feel) pada struktur. Senior dapat dengan mudah menemukan sesuatu yang mencurigakan pada desain jika ada atau akan menyuruh kami untuk mengecek kembali. Apabila mereka besar lebih dan lebih berpengalaman, bahkan tidak membutuhkan perhitungan dan analisa untuk struktur sederhana atau dapat membuat gambar tanpa hitungan. Untuk tujuan pencatatan, mereka kemudian menyuruh junior untuk melakukan perhitungan.

Kami menggunakan metode analisis sederhana dan langsung (direct). Saya tidak ingat jika ada yang melakukan analisa P-Delta atau non-linear analisis. Teori beban ultimit atau tegangan batas (Limit state) hanya dibicarakan oleh akademisi, tapi diabaikan oleh praktisi engineer. Hanya struktur yang tinggi seperti cerobong asap yang dicek periode alami strukturnya dan efek dinamik secara kasar. Untuk balok yang memikul beban getaran mesin yang dicek resonansi dan tambahan tegangan menggunakan aturan praktis dan beberapa rumus dari buku saku. Tidak diperlukan melakukan analisis gempa, dimana metode baru dikembangkan kemudian hari. Jika struktur mampu bertahan pada beban angin yang tinggi, maka dapat pula bertahan pada kondisi gempa. Aturan (code) tidak menyaratkan bangunan menerima kedua beban (Angin dan gempa) secara bersamaan.

Saya merujuk pada periode tahun 1970 sampai 1980. Saya bekerja sebagai praktisi selama beberapa tahun. Kemudian saya belajar menggunakan komputer dan memilih program komputer yang masih dikembangkan. Saya juga mengembangkan sendiri. Tapi gambar masih manual. Dari tahun 1990, software gambar sudah mulai tersedia dan kami perlahan-lahan mengganti menggunakan program dalam gambar.

Zaman sekarang merupakan era “Modeling” dengan software seperti Tekla, Bocad, SOD/2 dan lain lain.

Prosaes analisa, desain, gambar digambungkan dalam satu alat (tool) dan diantaranya kebutuhan perencana struktur sekarang berkurang. Karena semua pekerjaan yang membutuhkan banyak waktu dan melelahkan, sekarang sudah tidak ada lagi.

***

Demikian kita dapat melihat bagaimana struktural engineer dahulu berusaha keras untuk belajar dan mendesain serba manual menggunakan pensil dan kertas serta tanpa kalkulator. Belum lagi gambar kerja dibuat juga secara manual. Semua itu membutuhkan waktu dan tenaga yang tidak sedikit. Namun, dengan ini mereka mempunyai “rasa” (feel) yang mana membuat mereka mempuyai engineering judgement. Analisis dan desain bahkan dilakukan tanpa hitungan karena telah mengetahui atau ingat secara mendalam tentang perilaku struktur yang mereka desain. Jika ada keanehan dari hasil analisis dapat dengan mudah diketahui.

Tidak seperti zaman sekarang ini, analisis dilakukan serba menggunakan komputer dan software, dimana hasilnya diterima secara mentah-mentah. Kita tidak mengetahui bagaimana proses yang terjadi dalam software tersebut. Ada yang mengatakan bahwa semua tergantung Man behind the gun, dimana garbage in garbage out artinya sampah yang kita input ke software, sampah pula yang kita peroleh.

Ilmu boleh kuno, namun sangat berarti (Old but gold).

Demikian semoga bermafaat..

Dinding Bata dalam Analisa Struktur Gedung Kondisi Gempa

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

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.

Beban

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

Parameter Gempa

Single non wall

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 Single Storey with wall

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)

Respon Spektra Palu - Copy

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.

Rusunnawa Lere
Rusunawa Lere, Palu

hotel-roa-roa_20180930_120208

Hotel Roa-Roa, Palu

Rumah Sakit Anutapura

Rumah Sakit Anutapura, Palu