• Beberapa bulan terakhir involve dalam proyek yang mempunyai data pengujian geoteknik yang sangat banyak. Baik itu data pengujian in-situ (bor SPT, sondir..) dan data laboratorium (triaxial, analisa saringan, direct shear..)

    Pekerjaan pengujian tanah tersebut dilakukan oleh kontraktor geoteknik, kemudian diserahkan ke konsultan untuk analisa lebih lanjut.

    Sayangnya, data yang diberikan ada kemiripan/sama satu sama lain. Kontraktor dicurigai melakukan kecurangan.

    Singkat kata, Bos memerintahkan saya untuk mengecek data laboratorium tersebut. Data apa saja yang sama/mirip dan teridentifikasi kecurangan.

    Sialnya, data yang diberikan hanyalah file pdf. Dan dalam satu file pdf terdapat beberapa format tabel seperti analisa saringan, analisa saringan+hidrometer, geser langsung, triaxial test, berat jenis, dan beberapa uji atterberg.

    Sekitar 1020an halaman khusus data lab (total 2000an) yang akan dicek, dan harus diselesaikan kurang dari 2 hari.

    Ini bisa saja kita lakukan secara manual, melihat dan membandingkan. Namun, saya tidak begitu yakin apakah bisa diselesaikan dengan waktu kurang dari 2 hari dengan hasil akurat.

    Bekerja dengan data yang banyak dan berulang. Disinilah bahasa pemrograman python menjadi senjata ampuh.

    Hal yang dilakukan adalah:

    1. Meng-extract file pdf per page ke dalam file text
    2. Mengidentifikasi page termasuk dalam format data apa? (triaxial, direct shear, sieve analysis.. etc)
    3. Memilah tulisan (angka) yang termasuk dalam data, memasukkan angka tersebut dalam dataframe pandas dan meng-export ke file csv untuk diolah.
    4. Membanding data sesuai jenis pengujian/test, dengan cara menghitung selisih setiap data. Jika selisih = nol (0) maka data dikatakan sama persis
    5. Selesai

    Tugas ini diselesaikan dalam beberapa jam saja. Karena membutuhkan waktu untuk ngulik google, dan perlu debugging codingan error. Selain itu, ternyata proses ekstrasi text pdf per halaman membutuhkan waktu.

    Paling banyak error karena ternyata dalam satu format tabel juga masih beda. Data uji analisa saringan misalnya, ukuran saringan yang digunakan tidak seragam sehingga jumlah baris atau row data berbeda-beda.

    Ini hanyalah contoh kasus sederhana, dimana kita dapat menggunakan python untuk keperluan sehari-hari. Tentunya jika diperlukan analisa lebih lanjut akan lebih mudah. Misal koreksi N-SPT untuk setiap titik pengujian dan per 1,5m kedalaman. Koreksi bisa dilakukan dengan cepat dan akurat (tentunya dengan verifikasi).

    Demikian semoga bermanfaat.

  • Dalam analisa struktur, biasanya ditemukan beban merata yang tidak seragam (non-uniform). Seperti beban akibat tekanan tanah lateral berbentuk segitiga, trapesium atau sembarang bentuk.

    Tekanan tanah lateral (Hardiyatmo, C. 2011)

    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,

    Strategi pemodelan beban tidak seragam

    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:
    \sigma_h = \frac{4Q}{\pi} \frac{x^2z}{R^4} 
    Lateral active earth pressure Rankine theory:
    K_a = \tan (45 - \phi/2)^2 
    \sigma_a = \gamma z K_a

    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)
    
    Persamaan/fungsi tekanan tanah

    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
    
    Tabel tekanan tanah dibuat dalam data frame pandas
    Plot data tekanan tanah

    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:

    Input beban
    Output reaksi perletakan

    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
    
    Tabel output gaya dan perpindahan

    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()
    
    Plot kedalaman (z) vs gaya/ perpindahan

    ***

    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:

    1. Beban tekanan tanah aktif Rankine
    2. Beban tekanan lateral akibat beban garis (Q) di atas dinding
    3. Kombinasi beban 1 dan 2

    Berikut hasilnya..

    Kondisi 1. Tekanan tanah aktif Rankine
    Kondisi 2. Tekanan tanah lateral akibat beban garis Q di atas dinding
    Kondisi 3. Kombinasi tekanan tanah aktif Rankine dan beban garis Q di atas dinding

    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.
  • Artikel kali ini mau nyoba analisis faktor aman lereng terhadap gempa, menggunakan LEMSlope dan membandingkan hasilnya dengan Geostudio Slope/W.

    Metode yang digunakan adalah pseudostatik analisis, dimana beban gempa diberikan dengan cara input koefisien gempa horizontal (kh).

    Tujuan utama analisis kali ini adalah untuk mencari koefisien gempa horizontal yang menghasilkan faktor aman lereng FS = 1,0. Atau dikenal dengan k yield (ky).

    Nilai ky biasanya digunakan untuk menghitung deformasi permanen akibat gempa; namun, perhitungan deformasi tidak akan dibahas kali ini.

    Baiklah..

    Berikut lereng yang akan dianalisis:

    Lereng Tinjauan

    Untuk mendapatkan nilai ky, maka akan dicoba beberapa nilai kh (0 – 0.30g) kemudian akan diplot grafik hubungan antara kh dan faktor aman (FS).

    Berdasarkan soal lereng di atas, maka ditulis script LEMSlope sebagai berikut:

    #~units: m|kN|kPa|kN/m3|degree
    
    import lem
    
    #~materials
    sand = lem.new_material_mohr_coulomb(
    	name = 'sand',
    	color = '#FFFBA9', 
    	unit_weight = 20,
    	c = 5, 
    	phi = 30)
    
    #~base
    base = lem.create_base()
    base.set_limits(
    	left = 0, 
    	right = 40, 
    	bottom = 0)
    base.add_hline(20)
    
    base.assign_material(sand, (1,1))
    
    #~analysis cases
    case1 = lem.new_case('Case 1')
    case1.cut_right_slope(
    	bottom_elevation = 10,
    	slope = '2:1',
    	x = 30,
    	is_top_x = False)
    
    # deskripsi bidang gelincir entry-exit
    	
    case1.set_entry_exit_limits(
    	left_limits = (0,10), 
    	left_points_number = 20, 
    	right_limits = (30, 40), 
    	right_points_number = 20,
    	radius_increment_number = 5, 
    	slice_number = 30, 
    	left_y_limits = [], 
    	right_y_limits = [])
    	
    # input koefisien gempa kh
    case1.apply_seismic_load(
    	horizontal_coefficient = 0.2)
    

    Sebagai contoh untuk koefisien gempa kh = 0,2; diperoleh faktor aman lereng FS = 1,077.

    kh = 0,20 menghasilkan FS = 1,077.

    Adapun nilai faktor aman untuk masing-masing nilai kh, diplot sebagai berikut.

    Plot nilai kh vs FS; dipeoleh ky = 0,25g

    Dari grafik di atas terlihat faktor aman hasil LEMSlope lebih rendah (merah) dibandingkan dengan hasil Geostudio Slope/W (biru). Namun, masih mendekati.

    Untuk kondisi lereng kereng sesuai soal di atas; dari hasil plot nilai FS = 1,0 diperoleh nilai ky = 0,25 g.

    Dengan demikian LEMSlope dianggap sudah memenuhi analisa faktor aman lereng akibat gempa; metode pseudostatik analisis.

    Demikian semoga bermanfaat.

  • Kabar gembira bagi Anda yang minat bidang geoteknik. Mari perkenalkan..

    Maskot Groundhog

    Groundhog

    Groundhog adalah sebuah package python yang bertujuan untuk automasi perhitungan geoteknik.

    Package ini berisi sekumpulan alat/ fungsi/ rumus yang dapat digunakan. Berikut rangkumannya..

    1. General and utility functions
      • Soil profiles
      • Plotting
      • Validation
      • AGS to Pandas converter reference
    2. Site investigations
      • Soil classification
      • Soil parameter correlations
      • In-situ tests
      • Laboratory testing
    3. Pile calculations
      • De Beer and Eurocode 7 calculations
      • Koppejan pile resistance calculations
      • Pile settlement
      • Cavity expansion methods for cast in-situ piles
      • Negative skin friction
    4. Shallow foundations
      • Stress distributions
      • Shallow foundation capacity
      • Settlement
    5. Soil dynamics
      • Liquefaction
      • Cyclic behaviour
      • Dynamic soil property correlations

    Nomor 1 di atas adalah fungsi umum. Sedangkan nomor 2 sampai 5 adalah fungsi untuk perhitungan/analisa.

    Setiap fungsi di atas terdiri dari beberapa metode. Misal: Kapasitas dukung fondasi dangkal (shallow foundation cap.) terdiri dari kondisi undrained, drained, fondasi lingkaran, persegi, mayerhoof, davisbooker, vesic, dan banyak lagi.

    Contoh teori Prandtl failure surface
    Contoh hasil korelasi data sondir (presentasi Bruno Stuyts)

    Package ini pastinya akan sangat membantu dalam perhitungan sehari-hari. Sejalan dengan tujuan yang disebutkan dalam panduannya, artinya kira-kira:

    1. Meningkatkan tingkat akurasi perhitungan, dengan unit-tested function melalui validasi parameter.
    2. Meningkatkan kesadaran tentang data pengujian dan teori yang mendasari korelasi data dan rumus desain.
    3. Memperkenalkan pengembangan software engineering open-souce kepada komunitas insinyur di seluruh dunia.

    Package ini sangat baru bagi Saya pribadi, sehingga masih perlu dipelajari lebih lanjut. Bagi yang ingin mencoba silahkan menuju beberapa sumber di bawah ini:

    1. Webinar youtube Bruno Stuyts: Geotechnical Engineering Automation
    2. Groundhog documentations
    3. Groundhog github
    4. Akun youtube: Bruno Stuyts

    Demikian semoga bermanfaat, terus pantau blog ini

  • Artikel kali ini akan mencoba membandingkan hasil analisa Geostudio (software komersil) dan LEMSlope, contoh kasus pengaruh muka air tanah pada faktor aman lereng.

    Update 28 Mei 2022

    Sebelumnya, Saya mengucapkan terima kasih atas koreksi yang diberikan oleh Mr. Yong.

    Sekitar bulan lalu, Mr. Yong mengirim email pada Saya tentang koreksi kesalahan pada artikel/postingan ini LEMSlope: Muka Air Tanah.

    Email tersebut, kira-kira menyatakan bahwa perbandingan kedua software LEMSlope dan Geostudio untuk contoh kasus disini : Verification – Hand Calculations.pdf tidak dapat dibandingkan.

    Karena verifikasi Geostudio hanya menggunakan satu (1) bidang gelincir terpilih saja. Sedangkan hasil analisis LEMSlope yang Saya lakukan, menggunakan bidang gelincir dengan faktor aman terkecil.

    Sehingga hasil untuk kedua software ini tidak dapat dibandingkan. Kecuali, jika menggunakan bidang gelincir yang sama persis. Sayangnya, LEMSlope belum dapat menampilkan faktor aman untuk semua bidang gelincir.

    Dengan demikian, hasil analisis LEMSlope dalam artikel ini hanya bisa dilihat sebagai hasil faktor aman terendah untuk lereng sesuai soal tersebut.

    Berikut email Mr. Yong selengkapnya.


    Analisis LEMSlope kasus muka air tanah

    Berikut soal yang akan dianalisa sebagai berikut:

    Ditinjau dua metode yaitu: Metode Ordinary dan Bishop, dengan jumlah irisan 30 buah. Maka ditulis script pada LEMSlope sebagai berikut:

    #~units: m|kN|kPa|kN/m3|degree or ft|lbs|psf|pcf|degree
    
    import lem
    
    #~materials
    sand = lem.new_material_mohr_coulomb(
    	name = 'sand',
    	color = '#FFFBA9', 
    	unit_weight = 20,
    	c = 5, 
    	phi = 30)
    
    #~base
    base = lem.create_base()
    base.set_limits(
    	left = 0, 
    	right = 40, 
    	bottom = 0)
    base.add_hline(15)
    
    base.assign_material(sand, (1,1))
    
    #~analysis cases
    case1 = lem.new_case('Case 1')
    case1.cut_right_slope(
    	bottom_elevation = 5,
    	slope = '2:1',
    	x = 30,
    	is_top_x = False)
    
    ## input muka air tanah
    case1.assign_polyline_phreatic_surface(
    	polyline = [(0,12), (10,12), (30,5), (40,5)],
    	materials = [])
    	
    case1.set_entry_exit_limits(
    	left_limits = (0,10), 
    	left_points_number = 20, 
    	right_limits = (30, 40), 
    	right_points_number = 20,
    	radius_increment_number = 10, 
    	slice_number = 30, 
    	left_y_limits = [], 
    	right_y_limits = [])
    
    

    Hasil faktor aman yang diperoleh sebagai berikut:

    Metode Ordinary – Faktor Aman (FS) = 1,010
    Metode Bishop – Faktor Aman (FS) = 1,222

    Berikut hasil untuk kedua software tersebut:

    SoftwareMetode OrdinaryMetode Bishop
    LEMSlope1.0101.222
    Geostudio1.1701.249
    Hasil Faktor Aman

    Demikian semoga bermanfaat.

    Referensi: Verification – Hand Calculations.pdf

  • Program analisa stabilitas lereng, dapat digunakan untuk analisa faktor aman fondasi dangkal. Sebagai contoh Geostudio Slope/W menganalisa fondasi telapak di sini.

    Artikel kali ini, akan mencoba memakai aplikasi LEMSlope untuk analisa fondasi; kemudian dilakukan perbandingan dengan hasil analisis manual (analitik) dan hasil Geostudio.

    Soal berikut ditinjau dua (2) kondisi:

    1. Kondisi undrained
    2. Kondisi drained

    Lebar pondasi telapak B = 2,0 m. Adapun parameter tanah yang digunakan untuk dua (2) kondisi tersebut, dapat dilihat pada gambar berikut. Berdasarkan hasil manual/analitik diperoleh kapasitas dukung:

    Kondisi undrained, qu = NcBSu = 5,52 x 2,0 m x 100 kPa = 552 kPa

    Kondisi drained, qu = 0,5γBNγ = 0,5 x 20 kN/m3 x 2,0m x 15,1 =302 kPa


    Secara teori, apabila permukaan tanah diberi beban merata sebesar qu; maka akan diperoleh hasil faktor aman (FS) = 1,0.

    Strategi tinjauan kapasitas dukung, menggunakan setengah lebar fondasi B/2 = 1,0 m.

    Berikut hasil dari running Geostudio. Terlihat faktor aman mendekati 1,0 sesuai dengan asumsi. Namun dengan beberapa catatan.

    Analisis Menggunakan LEMSlope

    Untuk kondisi 1 – undrained, maka digunakan script sebagai berikut:

    #~units: m|kN|kPa|kN/m3|degree or ft|lbs|psf|pcf|degree
    
    # Kondisi 1 tanah undrained
    
    import lem
    
    # beban merata kPa
    q = 552
    
    #~materials
    tanah = lem.new_material_mohr_coulomb(
    	name = 'tanah',
    	color = '#ADFF2F', 
    	unit_weight = 20,
    	c = 100, 
    	phi = 0)
    
    #~base
    base = lem.create_base()
    base.set_limits(left = 0, right = 5, bottom = 0)
    base.add_hline(3)
    base.assign_material(tanah, (1,1))
    
    #~analysis cases
    case1 = lem.new_case('Case 1')
    case1.set_entry_exit_limits(
    	left_limits = (0, 0.01), 
    	left_points_number = 2, 
    	right_limits = (1.5, 2.25), 
    	right_points_number = 12, 
    	radius_increment_number = 5, 
    	slice_number = 30)
    case1.apply_distributed_load_on_surface(
    	load_pairs = [(0,q), (1,q)],
    	vertical_load = True)
    
    case1.set_analysis_method(
    	method = 'spencer')
    
    Hasil Kondisi 1 – Undrained

    Untuk kondisi 2 – drained, maka digunakan script sebagai berikut:

    #~units: m|kN|kPa|kN/m3|degree or ft|lbs|psf|pcf|degree
    # Kondisi 2 tanah drained
    
    import lem
    # beban merata kPa
    q = 302
    
    #~materials
    tanah = lem.new_material_mohr_coulomb(
    	name = 'tanah', 
    	color = '#FFFBA9', 
    	unit_weight = 20, 
    	c = 0, 
    	phi = 30)
    
    #~base
    base = lem.create_base()
    base.set_limits(left = 0, right = 5, bottom = 0)
    base.add_hline(3)
    base.assign_material(tanah, (1,1))
    
    #~analysis cases
    case1 = lem.new_case('Case 1')
    case1.set_entry_exit_limits(
    	left_limits = (0, 0.01), 
    	left_points_number = 2, 
    	right_limits = (2.5, 4.5), 
    	right_points_number = 50, 
    	radius_increment_number = 5, 
    	slice_number = 27)
    case1.apply_distributed_load_on_surface(
    	load_pairs = [(0,q), (1,q)],
    	vertical_load = True)
    
    case1.set_analysis_method(
    	method = 'janbu')
    
    Hasil Kondisi 2 – Drained

    Dari hasil analisis menggunakan LEMSlope diperoleh FS ≈ 1,0 untuk kedua kondisi baik drained maupun undrained.

    *Catatan:

    • Kondisi 1 menggunakan bidang gelincir lingkaran sesuai dengan teori bidang runtuh untuk tanah kohesif
    • Kondisi 2 seharusnya menggunakan bidang gelincir log-spiral; akan tetapi pada LEMSlope belum bisa dilakukan. Pada Geostudio dapat dilakukan dengan opsi passive angle pada pilihan entry-exit
    • Sehingga, untuk kondisi 2 dipilih bidang gelincir yang paling mendekati bentuk bidang gelincir dan faktor aman; digunakan metode janbu dengan 27 buah irisan
    • LEMSlope sudah dapat digunakan untuk analisa faktor aman fondasi dangkal

    Demikian semoga bermanfaat.

  • Mempelajari OpenSees memang susah-susah gampang. Bagi user yang belum terbiasa dengan finite element dan bahasa memrograman, pasti akan sedikit tersiksa. Itu pula kesan yang saya rasakan saat menggunakan OpenSees.

    Terlebih lagi tutorial yang ada banyak memperlihatkan script pemrograman yang rumit dan menjadi momok bagi user.

    Prof. Scott mengatakan bahwa OpenSees dan nonlinear analisis struktur secara umum adalah sederhana, tidak kompleks dan tidak perlu kompleks.

    Walaupun memang tujuan OpenSees dibuat adalah untuk simulasi performa struktur dan geoteknik terkait gempa, yang terlihat tidak sederhana.

    Mulai dari yang sederhana

    Seperti biasa, untuk mempelajari aplikasi baru biasanya saya lebih suka memulai dengan model yang sederhana.

    Menurut Minjie Zhu di sini, secara umum script OpenSees dapat dibagi menjadi 2 yaitu bagian domain dan analysis.

    1. Domain terkait pembuatan geometri seperti node, element, kondisi tumpuan dsb.
    2. Analysis berisi pengaturan algorithm, system, numberer, constraint, integrators, dsb.

    Sebagai tambahan, ada bagian ke 3 yaitu output dan postprocessing. Terkait merekam (record), menampilkan hasil (output) dan plot dalam grafik.


    Baiklah.. kali ini akan dicoba cek lendutan yang terjadi pada balok sederhana dengan data sebagai berikut.

    Menggunakan rumus praktis,

    lendutan = PL^3 / 48EI = 1,92 mm


    Berikut deskripsi tahapan pemodelan balok sederhana dengan OpenSeesPy.

    (1) Pertama, tahapan awal adalah meng-import modul OpenSeesPy, dan menulis data penampang, material, serta geometri struktur.

    # memasukkan modul opensees
    from openseespy.opensees import *
    # membersihkan model yang terdahulu
    wipe()
    # Unit mm, N, MPa
    P = 10000
    L = 6000
    b = 250
    h = 500
    A = b*h
    Iz = (b*h**3)/12
    E = 9000
    

    (2) Kedua, mengatur tinjauan dimensi dan derajat kebebasan. pada contoh ini struktur 2D, dengan derajat kebebasan 3 untuk balok.

    # model dimensi (-ndm) dan derajat kebebasan (-ndf)
    model('basic','-ndm', 2,'-ndf', 3)
    

    (3) Ketiga, memasukkan node dan kondisi tumpuan

    # membuat geometri dan tumpuan
    # format node(id, x, y)
    node(1, 0.0, 0.0) ; fix(1,1,1,0)
    node(2, L/2, 0.0)
    node(3, L, 0.0)   ; fix(3,0,1,0)
    

    (4) Keempat, memasukkan jenis transformasi dan elemen balok. Bentang balok dibagi menjadi dua elemen seperti gambar soal.

    # transformasi
    geomTransf('Linear',1)
    # memasukkan elemen
    element('elasticBeamColumn', 1, 1,2, A,E,Iz,1)
    element('elasticBeamColumn', 2, 2,3, A,E,Iz,1)
    

    (5) Kelima, masukkan time series, load pattern, dan beban. Digunakan timeSeries Linear, karena contoh ini menggunakan beban statik yang sama sepanjang waktu.

    # beban yang bekerja
    timeSeries('Linear',1)
    pattern('Plain',1,1)
    load(2,0,-P,0)
    
    

    (6) Keenam, pengaturan analisis dan running analisa

    # analisis
    system("BandSPD")
    numberer("RCM")
    constraints("Plain")
    integrator("LoadControl", 1.0)
    algorithm("Linear")
    analysis("Static")
    analyze(1)  #running analisa
    

    (7) Ketujuh, melihat hasil respon struktur. Pada contoh ini hasil lendutan di tengah bentang (node 2), arah sumbu y atau 2.

    # lendutan yang terjadi
    uy = nodeDisp(2,2)
    print(uy)
    

    Hasil lendutan = 1,92 mm, sama persis dengan rumus praktis. Dengan ini model dan script OpenSees dianggap sudah benar.


    Adapun analisa menggunakan OpenSeesPy secara keseluruhan dilakukan dengan script sebagai berikut. Penjelasan tahapan setiap perintah dapat dilihat di bawah ini.

    from openseespy.opensees import *
    wipe()
    P = 10000
    L = 6000
    b = 250
    h = 500
    A = b*h
    Iz = (b*h**3)/12
    E = 9000
    model('basic','-ndm',2,'-ndf',3)
    node(1, 0.0, 0.0) ; fix(1,1,1,0)
    node(2, L/2, 0.0)
    node(3, L, 0.0)   ; fix(3,0,1,0)
    geomTransf('Linear',1)
    element('elasticBeamColumn',1,1,2,A,E,Iz,1)
    element('elasticBeamColumn',2,2,3,A,E,Iz,1)
    timeSeries('Linear',1)
    pattern('Plain',1,1)
    load(2,0,-P,0)
    system("BandSPD")
    numberer("RCM")
    constraints("Plain")
    integrator("LoadControl", 1.0)
    algorithm("Linear")
    analysis("Static")
    analyze(1)
    uy = nodeDisp(2,2)
    print(uy)
    
    

    Untuk perintah pembuatan model material, elemen, tumpuan, dsb; secara lengkap dapat dilihat pada koleksi perintah model (Model Commands) disini. Sedangkan untuk opsi pengaturan analysis dapat dilihat di sini.

    Pada contoh ini, respons struktur yang dicek hanyalah lendutan. Berbagai jenis respons (reaksi, gaya, dsb) pada struktur (elemen dan node) dapat menggunakan perintah ouput (Output Command) di sini.

    * Tahapan di atas bukan tahapan baku yang harus diikuti. Tapi merupakan tahapan untuk penyederhanaan agar lebih mudah diikuti.

    Demikian semoga bermanfaat.

  • Setelah perkenalan dalam artikel sebelumnya mengenai LEMSLope di sini, maka artikel kali ini mau coba verifikasi/kontrol hasil tekanan tanah aktif.

    Apakah model dibuat sudah sesuai? apakah tekanan tanah hasil LEMSlope sama/sesuai dengan teori?

    Pertanyaan ini akan coba dijawab dalam artikel kali ini.

    Baik, berikut soal yang akan dianalisis.

    Soal

    Dinding tinggi h = 10 m; dengan parameter tanah sesuai gambar di atas.

    Berdasarkan teori Rankine, tekanan tanah pada dinding dapat dihitung secara sederhana berdasarkan rumus:

    Ka = tan(45 - phi/2)2 = 0.333
    Pa = 0,5 x g x h2 x Ka = 300.0 kN

    Tekanan tanah ini bekerja pada jarak y = h/3 = 3.333 m dari dasar dinding.

    Apabila dinding di atas kita beri gaya lawan; sebesar tekanan tanah Pa = 300.0 kN, pada jarak y = 3.33m; harusnya faktor aman yang diperoleh sama dengan FS=1.0 (kondisi seimbang).

    Maka, dibuat kode script pada LEMSlope menggunkanan bahasa Python sebagai berikut:

    import lem
    
    #~materials
    sand = lem.new_material_mohr_coulomb(
    	name = 'sand',
    	unit_weight = 18,
    	c = 0,
    	phi = 30,
    	color = '#FFFBA9')
    	
    #~base
    base = lem.create_base()
    base.set_limits(left = 0, right = 30, bottom = 0)
    base.add_hline(15)
    
    base.assign_material(sand, (1,1))
    
    #~analysis cases
    case1 = lem.new_case('Case 1')
    
    case1.cut_polyline(
    	polyline = [(20,15), (20.01,5), (30,5)])
    	
    case1.apply_concentrated_load(
    	location = (20,8.33),
    	load = 300,
    	direction = 180)
    	
    case1.set_entry_exit_limits(
    	left_limits = (11,16),
    	left_points_number = 22, 
    	right_limits = (20.01, 21),
    	right_points_number = 5,
    	radius_increment_number = 5, 
    	slice_number = 30)
    
    case1.set_analysis_method(method = "spencer")
    

    Dari hasil analisis awal ini, di faktor aman FS = 1,101. FS mendekati 1,0 sesuai dengan asumsi. Akan tetapi perbedaanya masih lumayan sebesar 0,101. Seperti yang terlihat pada gambar berikut.

    Hasil percobaan 1

    Perlu diperhatikan, dari gambar di atas terlihat bidang gelincir berupa lengkungan; berbeda dengan asumsi Rankine yang menganggap bidang gelincir berupa garis lurus/planar. Perbedaan ini merupakan akibat dari jumlah irisan yang dipilih sebesar slice_number = 30 irisan.

    Maka dicoba slice_number = 1 dan dilakukan running kembali.

    Setelah perubahan jumlah irisan menjadi 1 irisan saja. Diperoleh faktor aman sebesar FS = 1.044.

    Percobaan kedua ini menghasilkan selisih faktor aman 0.044. Faktor aman sudah mendekati 1, sesuai asumsi. Walaupun terdapat perbedaan, tapi tidak terlalu signifikan.

    Hasil percobaan 2

    Maka, dengan ini model yang dibuat dianggap sudah sesuai dan tekanan tanah aktif sama dengan teori.

    Kesimpulan:

    • Sangat penting untuk melihat asumsi teori dengan model yang digunakan
    • Perbedaan bentuk bidang gelincir sangat mempengaruhi hasil
    • LEMSlope menghasilkan tekanan tanah aktif dan FS yang sesuai

    Demikian semoga bermanfaat..

  • Setelah perkenalan dengan LEMSlope di sini. Maka, artikel kali ini mau nyoba bagaimana analisa stabilitas lereng menggunakan program ini.

    Perlu ditekankan, bahwa pembuatan model dan analisis dalam program ini adalah dengan cara menulis kode perintah (script) pada konsol, seperti pada gambar berikut.

    Oleh karena itu, dalam contoh ini akan dijelaskan lebih detail bagaimana perintah/kode yang digunakan sesuai soal yang ada.

    Bagi yang ingin coba, silahkan download installer aplikasinya disini. Cara install cukup mudah, yaitu cukup extract kemudian install file di dalamnya. Klik next.. next hingga selesai.

    Tampilan LEMSlope

    Sebagai pembanding, maka dicoba Contoh Soal 5.9 dalam buku Braja M. Das. Hasil faktor aman menurut Das adalah sebesar FS = 1,55.

    Adapun soalnya sebagai berikut:

    Gambar Soal

    Rincian soal:

    1. Parameter tanah seperti pada gambar di atas
    2. Tinggi lereng = 14 m
    3. Sudut lereng = 30 derajat
    4. Metode Ordinary/Fellenius
    5. Jumlah irisan = 7

    Adapun langkah-langkah pembuatan model pada LEMSlope adalah sebagai berikut:

    Pertama,

    Hal yang penting untuk diperhatikan adalah satuan. Dalam program ini dapat menggunakan satuan metric atau imperial sebagai berikut.

    #~units: m|kN|kPa|kN/m3|degree or ft|lbs|psf|pcf|degree
    

    Dalam contoh ini menggunakan satuan metric; yaitu meter, kN, kPa, kN/m3 dan derajat.

    Kedua,

    Input parameter tanah menggunakan model material Mohr-Coulomb dengan cara berikut:

    import lem
    
    #~materials
    tanah = lem.new_material_mohr_coulomb(
    	name = 'tanah',
    	unit_weight = 16,
    	c = 20,
    	phi = 20,
    	color= '#FFFBA9')
    

    Ketiga,

    Kemudian strategi pembuatan geometri/bentuk lereng. Berdasarkan Gambar di atas, kemudian dibuat geometri sebagai berikut,

    Gambar Geometri

    Terlebih dahulu dibuat base, yaitu daerah kotak bergaris kuning seperti yang terlihat pada gambar di atas. Batas kiri dan kanan daerah menggunakan perintah set_limits(), left untuk batas kiri, right untuk batas kanan, dan bottom untuk batas bawah dalam satuan meter.

    add_hline() untuk memasukkan tinggi daerah berwarna kuning dan assign_material untuk memasukkan material tanah yang sudah dibuat sebelumnya di tahap ke dua. Kode perintah adalah seperti berikut:

    #~base
    base = lem.create_base()
    base.set_limits(left = 0, right = 36, bottom = 0)
    base.add_hline(20)
    base.assign_material(tanah, (18,10))
    

    Keempat,

    Setelah itu masuk dalam tahap analisis. Membuat case atau kasus dengan cara,

    #~analysis cases
    case1 = lem.new_case('Case 1')
    

    Kelima,

    Memotong daerah/bidang lereng sesuai gambar geometri, dengan perintah

    case1.cut_left_slope(
    	bottom_elevation = 6,
    	slope = 30,
    	x = 5,
    	is_top_x = False)
    

    Keenam,

    Membuat entry exit untuk bidang gelincir, sama seperti opsi pada Geostudio. Jangan lupa untuk memasukkan jumlah irisan slice_number = 7; sesuai soal. Adapun perintahnya sebagai berikut

    case1.set_entry_exit_limits(
    	left_limits = (0, 6),
    	left_points_number = 12, 
    	right_limits = (30, 36),
    	right_points_number = 12, 
    	radius_increment_number = 5,
    	slice_number = 7)
    

    Ketujuh,

    Memilih metode analisis yang digunakan, dengan cara menuliskan

    case1.set_analysis_method(
    	method = 'ordinary')
    

    Kedelapan,

    Kode perintah/script yang digunakan secara keseluruhan jika digabungkan menjadi:

    #~units: m|kN|kPa|kN/m3|degree or ft|lbs|psf|pcf|degree
    
    import lem
    
    #~materials
    tanah = lem.new_material_mohr_coulomb(
    	name = 'tanah',
    	unit_weight = 16,
    	c = 20,
    	phi = 20,
    	color = '#FFFBA9')
    
    #~base
    base = lem.create_base()
    base.set_limits(
    	left = 0,
    	right = 36,
    	bottom = 0)
    base.add_hline(20)
    base.assign_material(tanah, (18,10))
    
    #~analysis cases
    case1 = lem.new_case('Case 1')
    case1.cut_left_slope(
    	bottom_elevation = 6,
    	slope = 30,
    	x = 5,
    	is_top_x = False)
    case1.set_entry_exit_limits(
    	left_limits = (0, 6),
    	left_points_number = 12, 
    	right_limits = (30, 36),
    	right_points_number = 12, 
    	radius_increment_number = 5,
    	slice_number = 7)
    case1.set_analysis_method(
    	method = 'ordinary')
    

    Kesembilan

    Running analisis dengan cara tekan tombol keyboard F5 atau Fn+F5. Atau dengan cara klik menu Analysis, kemudian Run All Case.


    Perbandingan LEMSLope dan Buku Braja

    Adapun hasil analisis stabilitas menggunakan LEMSlope ada sebesar FS = 1.513.

    Cukup mendekati faktor aman dari contoh perhitungan buku yaitu sebesar FS =1,55. Maka, pemodelan dianggap sudah benar.

    Walaupun ada perbedaan sebesar 0,037 masih dianggap kecil dan tidak begitu signifikan.

    Berikut gambar model dan faktor aman yang diperoleh.

    Hasil Analisis LEMSlope

    Demikian, semoga bermanfaat. Silahkan isi kolom komentar jika ada pertanyaan atau saran terkait contoh ini.

  • Kali ini mau perkenalan dulu dengan aplikasi gratis dari Yong Technology Inc (Canada); yang bernama LEMSlope.

    LEMSlope adalah program analisis stabilitas lereng menggunakan metode irisan atau konvensional yang sering di ajarkan di bangku kuliah.

    Aplikasi ini terbilang sangat baru. Rilis tanggal 06 Oktober 2021 (mengacu pada postingan artikel pertamanya di sini)

    Menurut si pembuat program; bahwa motivasi awal pembuatan LEMSlope adalah supaya pembuatan model geometri dengan cara deklaratif/script dan membebaskan engineer dari hitungan geometri yang membosankan.

    Selain itu, Pengguna tidak perlu mengisi banyak kolom/tampilan (fill in the blank) untuk melakukan analisis.

    Sepertinya blog ini akan terus update artikel mengenai topik ini, karena menurut Saya LEMSlope cukup unik dan menarik.

    Apa yang membedakan LEMSlope dengan program lain? misalnya: Geostudio

    1. Gratis
    2. Input data geometri, metode, gaya/beban dsb; hanya menggunakan konsol dengan cara menulis scipt.
    3. Script ditulis menggunakan bahasa Python (cukup sederhana)
    4. Saat ini, hanya menggunakan 5 metode kesetimbangan batas atau limit equilibrum method (LEM); sesuai singkatan namanya.
    5. Mungkin cukup ini dulu..

    Berikut tampilannya,

    LEMSlope tampilan awal

    Seperti yang terlihat pada gambar di atas. Tampilannya sangat sederhana, konsol (untuk nulis script) di sebelah kiri; di bawahnya (yang masih kosong) ada tampilan warning/peringatan jika ada error. Bagian kanan terdapat tampilan geometri lereng dan hasil faktor aman.

    Adapun metode analisis yang dapat digunakan adalah:

    1. Morgenstern-Price
    2. Spencer
    3. Bishop
    4. Janbu
    5. Ordinary/Fellenius

    Masalah kemampuan? jangan dianggap remeh. Aplikasi ini sudah mampu memodelkan beban gempa (seismik), pengaruh muka air tanah, beban titik dan merata, dan yang utama adalah kecepatan merevisi geometri.

    Bagaimana cara penggunaan dan fitur yang tersedia? akan dibahas dalam artikel selanjutnya. Berhubung saya juga masih awal memperlajari aplikasi ini. Selain itu, dokumen manual LEMSlope belum bisa di akses disini Panduan LEMSlope.

    Demikian, terus pantau blog ini untuk mendapatkan update informasi.

    Update 03 Desember 2021

    Mengenai ketersediaan panduan; setelah Saya menanyakan ke Mr. Yong di sini, ternyata panduan resmi LEMSLope memang belum ada sampai sekarang. Panduan yang ada hanya berupa vidio dan cheat sheet yang yang ada pada menu help.