Dalam analisa struktur, biasanya ditemukan beban merata yang tidak seragam (non-uniform). Seperti beban akibat tekanan tanah lateral berbentuk segitiga, trapesium atau sembarang bentuk.
Menjadi masalah ketika program tidak menyediakan opsi input beban tidak seragam, seperti package Anastruct hanya menyediakan beban merata (q) uniform atau seragam.
Artikel ini terinspirasi dari blog Syont di sini : Beban titik kesetaran pada elemen balok
Secara ringkas, beliau menggunakan beban titik sebagai solusi analisa beban tidak seragam.
***
Baiklah..
Artikel kali ini akan membahas solusi analisa struktur beban tidak seragam menggunakan Anastruct/ Python.
Strategi Pemodelan
Strategi yang digunakan yaitu dengan membagi elemen dalam elemen pias/diskrit. Kemudian menggunakan beban q rata-rata (q tengah elemen) sebagai beban merata.
Berikut kira-kira ilustrasinya,
1. Membuat fungsi beban
Mulai dari sini pemodelan akan menggunakan Python dan Jupyter Notebook. Langkah pertama adalah membuat fungsi beban. Fungsi ini akan meng-handle beban merata setiap variasi kedalaman (z) atau jarak.
Lateral pressure due to line load Q:
Lateral active earth pressure Rankine theory:
Di sini disiapkan dua fungsi. Yaitu fungsi tekanan tanah Rankine dan tekanan lateral akibat beban garis di atas dinding. Berikut script nya:
import math
def Q_pressure(H, q, x, z):
R = math.sqrt(x**2 + z**2)
sigma_q = 4*q/math.pi * (x**2)*z / (R**4)
return(sigma_q)
def Rankine(phi, gamma, z):
Ka = math.tan(math.radians(45-(phi/2)))**2
sigma_a = gamma*z*Ka
return(sigma_a)
2. Menentukan data dimensi, material, dan pengaturan yang digunakan
Sebagai verifikasi awal, maka akan ditinjau
- Dinding kantilever
- Tinggi total 6 m
- Beban = tekanan tanah aktif teori Rankine
- Jumlah elemen diskrit = 6 elemen
Sehingga panjang setiap elemen menjadi 6/6 = 1 m. Berikut input data keseluruhan:
import numpy as np
import pandas as pd
df = pd.DataFrame()
# Dimensions
H = 6 # wall height (m)
t = H/10 # thickness of the wall (m)
b = 1 # width (m)
A = b*t # area section (m^2)
Ix = (b*t**3)/12 # Momen inertia (m4)
# Materials
## Concrete
fc = 21 # MPa
E = 4700*math.sqrt(fc) * 1000 # concrete modulus elasticity (kPa)
## Soil
gamma = 18 # unit weight of soil
phi = 30 # internal friction angle
# Loads
Q = 112.5 # acting load (kN/m)
x = 2.0 # horizontal distance from wall (m)
# Settings
n_ele = 6 # number of element
dx = H/n_ele # lenght of dicretized element (m)
3. Membuat tabel beban tekanan tanah untuk setiap kedalaman (z)
Pada tahap ini, terlebih dahulu akan dicoba tekanan tanah rankine (beban segitiga).
z_list = [0]
sigma_list = [0]
for n in range(1,n_ele+1,1):
z = n*dx
z_list.append(-z)
sigma_list.append(Rankine(phi,gamma,z)) # Rankine only
#sigma_list.append(Q_pressure(H,Q,x,z)) # Lateral pressure due to line load only
#sigma_list.append(Q_pressure(H,Q,x,z) + Rankine(phi,gamma,z)) # Rankine + Q lateral pressure
df['z (m)'] = z_list
df['sigma (kPa)'] = sigma_list
df
4. Analisa struktur dengan Anastruct
Berdasarkan data di atas, kemudian lakukan analisa struktur dengan Anastruct. Perlu diperhatikan, input beban ke dalam elemen dilakukan pada perintah loop “for i in range ()“; dengan terlebih dahulu dilakukan interpolasi pada kedalaman (z) tengah elemen. Ditunjukkan pada garis <<< assign q load each element.
Perlu perhatian khusus pada tumpuan, disesuaikan dengan dinding tinjauan yaitu fixed pada dasar dinding.
from scipy.interpolate import interp1d
from anastruct import SystemElements
ss = SystemElements(EI=E*Ix, EA=E*A)
ss.add_multiple_elements([[0, H], [0, 0]], n_ele)
##------------Support conditions very important!----------##
# first_node == node on the top of the wall
first_node = 1
last_node = n_ele+1
# ss.add_support_roll(first_node,direction='y')
# ss.add_support_hinged(last_node)
ss.add_support_fixed(last_node)
first_ele_z = dx/2
for i in range(n_ele):
z = (i*dx) + first_ele_z
interp = interp1d(df['z (m)'], df['sigma (kPa)']) # <<< assign q load each element
sigma_interp = interp(-z)
ss.q_load(q=-sigma_interp, element_id = i+1)
# Run Analysis
ss.solve()
# Plot graph
ss.show_structure(verbosity=0)
ss.show_bending_moment(verbosity=1)
ss.show_shear_force(verbosity=1)
# verbosity=0 to show value
Berikut tampilan beban yang telah di input:
Untuk verifikasi hasil reaksi tumpuan di atas dapat dilakukan dengan cara sederhana sebagai berikut:
Ka = tan(45 – 30/2)2 = 0.333
Pa = 0.5 x gamma x H2 x Ka = 107,89 kN ≈ Ranastruct = 108.0 kN (mendekati)
Mo = Pa x H/3 = 215,78 kNm ≈ Manastruct = 219.0 kNm (cukup mendekati nilai teori)
Terlihat reaksi hasil pemodelan cukup mendekati, perlu di perhatikan ini adalah hasil untuk 6 element diskrit. Nilai akan semakin mendekati jika jumlah elemen di perbanyak; misal 100 elemen.
5. Tahapan post processing
Pada tahap ini, gaya dan perpindahan untuk setiap node akan dirangkum dalam table pandas data frame. Kemudian di plot dalam grafik agar lebih mudah dilihat.
moment_list = ss.get_element_result_range('moment')
shear_list = ss.get_element_result_range('shear')
axial_list = ss.get_element_result_range('axial')
for n in range(0,n_ele+1):
if n == n_ele:
df.loc[n,'Moment (kNm)'] = ss.get_node_results_system(node_id=n+1)['Ty']
df.loc[n,'Shear (kN)'] = -ss.get_node_results_system(node_id=n+1)['Fx']
df.loc[n,'Axial (kNm)'] = ss.get_node_results_system(node_id=n+1)['Fy']
else:
df.loc[n,'Moment (kNm)'] = moment_list[n]
df.loc[n,'Shear (kN)'] = shear_list[n]
df.loc[n,'Axial (kNm)'] = axial_list[n]
df.loc[n,'Displacement (mm)'] = 1000 * ss.get_node_results_system(node_id=n+1)['ux']
# Display table
df
Kemudian di plot menggunakan package plotly:
from plotly.subplots import make_subplots
import plotly.graph_objects as go
fig = make_subplots(rows=1, cols=4)
fig.add_trace(go.Scatter(name="Lateral Pressure (kPa)",x=df['sigma (kPa)'], y=df['z (m)'], mode="lines"), row=1, col=1)
fig.add_trace(go.Scatter(name="Bending Moment (kNm)",x=df['Moment (kNm)'], y=df['z (m)'], mode="lines"), row=1, col=2)
fig.add_trace(go.Scatter(name="Shear (kN)",x=df['Shear (kN)'], y=df['z (m)'], mode="lines"), row=1, col=3)
fig.add_trace(go.Scatter(name="Displacement (mm)", x=df['Displacement (mm)'], y=df['z (m)'], mode="lines"), row=1, col=4)
fig.update_yaxes(title_text="Depth, z (m)", row=1, col=1)
fig.update_xaxes(title_text="Lateral Pressure (kPa)", row=1, col=1)
fig.update_xaxes(title_text="Moment (kNm)", row=1, col=2)
fig.update_xaxes(title_text="Shear (kN)", row=1, col=3)
fig.update_xaxes(title_text="Displacement (mm)", row=1, col=4)
fig.update_layout(height=800, width=1000, title_text="Result",)
fig.show()
***
Pemodelan beban distribusi untuk sembarang bentuk
Eksperimen terakhir, akan dicoba pemodelan beban untuk sembarang bentuk sesuai dua fungsi yang telah dibuat (seperti gambar tekanan tanah pada awal artikel). Berikut deskripsi soalnya:
Data:
- Tinggi dinding, H = 6 m
- Kondisi tumpuan = jepit – jepit (fixed)
- Jumlah element diskrit = 100
- Data material sama dengan soal di atas
Tinjauan kondisi beban:
- Beban tekanan tanah aktif Rankine
- Beban tekanan lateral akibat beban garis (Q) di atas dinding
- Kombinasi beban 1 dan 2
Berikut hasilnya..
Bagi yang ingin mencoba silahkan download file jupyter notebook berikut:
Lateral Pressure Due to Surcharge
Bila ada yang ingin didiskusikan, silahkan tinggalkan komentar di bawah ini. Demikian semoga bermanfaat.
Catatan:
- Untuk variasi beban lain dapat dimasukkan dalam tambahan fungsi.
= 31,1 Kg/m
Agus Daud 