Example #1
0
    def test_cs_collector(self):
        defaults.optimize_for_cost_only = True
        defaults.optimize_for_spec_ei = False
        defaults.optimize_for_target_function = False
        cs1 = crosssection.crosssection(0, 0, 0)
        cs1.cost = 4
        data.cs_collection.append(cs1)

        cs2 = crosssection.crosssection(0, 0, 0)
        cs2.cost = 2
        data.cs_collection.append(cs2)

        cs3 = crosssection.crosssection(0, 0, 0)
        cs3.cost = 2
        data.cs_collection.append(cs3)

        cs4 = crosssection.crosssection(0, 0, 0)
        cs4.cost = 2
        data.cs_collection.append(cs4)

        best = cs_collector.get_best_cost()

        self.assertEqual(best[0].cost, 2)
        self.assertEqual(best[1].cost, 2)
        self.assertEqual(best[2].cost, 2)
Example #2
0
def create_deck_stiffener_local(b_sup, b_inf, h, t, t_deck):
    assert b_sup >= b_inf, "width out of bound or wrong way around"

    #assumption: b_sup is equal to distance between stiffeners
    #create points
    a = point.point(b_sup,0)
    b = point.point(-b_sup, 0)
    c = point.point(0.5*b_sup, 0)
    d = point.point(-0.5*b_sup, 0)
    e = point.point(-0.5*b_inf, h)
    f = point.point(0.5*b_inf, h)

    #create plates
    code_1 = plate_code.plate_code(1,0,0,0,0)
    line_1 = line.line(code_1, a, b, t_deck)
    code_2 = plate_code.plate_code(2,0,0,0,0)
    line_2 = line.line(code_2, d, e, t)
    code_3 = plate_code.plate_code(3,0,0,0,0)
    line_3 = line.line(code_3, e, f, t)
    code_4 = plate_code.plate_code(4,0,0,0,0)
    line_4 = line.line(code_4, f, c, t)

    deck_stiffener = crosssection.crosssection(b_sup, b_inf, h)
    #add the lines to itself
    deck_stiffener.addline(line_1)
    deck_stiffener.addline(line_2)
    deck_stiffener.addline(line_3)
    deck_stiffener.addline(line_4)

    return deck_stiffener
Example #3
0
def create_stiffener_local(b_sup, b_inf, h, t):
    #assert b_sup >= b_inf, "width out of bound or wrong way around"
    half_width_diff = b_sup - b_inf
    length_side = math.sqrt(half_width_diff**2 + h**2)
    own_angle = math.atan(half_width_diff / h)

    #create plate 2
    a2 = point.point(-b_sup / 2, 0)
    b2 = point.point(a2.y + math.sin(own_angle) * length_side,
                     math.cos(own_angle) * length_side)
    code2 = plate_code.plate_code(0, 1, 0, 0, 2)
    line2 = line.line(code2, a2, b2, t)

    #create plate 3
    a3 = b2
    b3 = point.point(a3.y + b_inf, a3.z)
    code3 = plate_code.plate_code(0, 1, 0, 0, 3)
    line3 = line.line(code3, a3, b3, t)

    #create plate 4
    a4 = b3
    b4 = point.point(b_sup / 2, 0)
    code4 = plate_code.plate_code(0, 1, 0, 0, 4)
    line4 = line.line(code4, a4, b4, t)

    stiffener_local = crosssection.crosssection(b_sup, b_inf, h)
    #add the lines to itself
    stiffener_local.addline(line2)
    stiffener_local.addline(line3)
    stiffener_local.addline(line4)
    return stiffener_local
Example #4
0
def create_stiffener_global(pl_position, st_number, center_y, center_z, angle,
                            b_sup, b_inf, h, t):
    y_corr = center_y - math.cos(angle) * b_sup * 0.5
    z_corr = center_z - math.sin(angle) * b_sup * 0.5
    assert b_sup >= b_inf, "width out of bound or wrong way around"
    half_width_diff = (b_sup - b_inf) / 2
    length_side = math.sqrt(half_width_diff**2 + h**2)
    if half_width_diff > 0:
        own_angle = math.atan(h / half_width_diff)
    else:
        own_angle = math.pi / 2

    #create plate 2
    a2 = point.point(y_corr, z_corr)
    b2 = point.point(y_corr + math.cos(own_angle + angle) * length_side,
                     z_corr + math.sin(own_angle + angle) * length_side)
    code2 = plate_code.plate_code(pl_position, 1, 0, st_number, 2)
    line2 = line.line(code2, a2, b2, t)

    #create plate 3
    a3 = point.point(y_corr + math.cos(own_angle + angle) * length_side,
                     z_corr + math.sin(own_angle + angle) * length_side)
    b3 = point.point(a3.y + math.cos(angle) * b_inf,
                     a3.z + math.sin(angle) * b_inf)
    code3 = plate_code.plate_code(pl_position, 1, 0, st_number, 3)
    line3 = line.line(code3, a3, b3, t)

    #create plate 4
    a4 = point.point(a3.y + math.cos(angle) * b_inf,
                     a3.z + math.sin(angle) * b_inf)
    b4 = point.point(y_corr + math.cos(angle) * b_sup,
                     z_corr + math.sin(angle) * b_sup)
    code4 = plate_code.plate_code(pl_position, 1, 0, st_number, 4)
    line4 = line.line(code4, a4, b4, t)

    stiffener_global = crosssection.crosssection(b_sup, b_inf, h)
    #add the lines to itself
    stiffener_global.addline(line2)
    stiffener_global.addline(line3)
    stiffener_global.addline(line4)
    return stiffener_global
Example #5
0
def interaction_flange(total_cs, flange_plate, eta_3):
    string = "\n   7.1 Interaction between shear force, bending moment and axial force"
    string += "\n   Flange -> comment (5)"
    printing.printing(string)

    #choose correct shear stresses for calculation
    if eta_3 <= 0.5:
        #no interaction needed
        #what is a resonable return value, -1?
        utilisation = -1
        string = "\n      eta_3 <= 0.5; no interaction needed"
        string += "      utilisation: -1"
        printing.printing(string)
    else:
        eta_1_bar = abs(
            data.input_data.get("M_Ed") / total_cs.get_m_rd_el_eff())
        utilisation = eta_1_bar + (1 - m_f_rd / m_pl_rd) * (2 * eta_3 - 1)**2
        string = "\n      eta_3 > 0.5; interaction needed"
        string += "\n      eta_1_bar: " + str(
            math.floor(1000 * eta_1_bar) / 1000)
        string += "      utilisation: " + str(
            math.floor(1000 * utilisation) / 1000)
        printing.printing(string)

    #prove shear resistance for each subpanel
    string = "\n   Proofing Resistance to shear for each subpanel"
    printing.printing(string)
    for plate in flange_plate.lines:
        if plate.code.tpl_number != 0:
            v_ed_panel = stress_cal.get_tau_int_subpanel(total_cs, plate, data.input_data.get("V_Ed"),\
            data.input_data.get("T_Ed"))
            panel_cs = crosssection.crosssection(0, 0, 0)
            panel_cs.addline(plate)
            eta_3_panel = resistance_to_shear.resistance_to_shear(
                panel_cs, v_ed_panel)
            if eta_3_panel > 1:
                utilisation = 10
            else:
                assert True, "This is not possible"
    return utilisation
Example #6
0
import sys
#just add the directory where the BA folder is on your computer
sys.path.append('C:/Users/Nino/Google Drive/Studium/FS 2021/Bachelorarbeit/BA')

#imports
import matplotlib.pyplot as plt
import numpy as np
import initial_cs as ics
from classes import crosssection as cs
from classes import point
from classes import line as ln
from output import geometry_output as go

test_cs = ics.create_initial_cs(1000, 500, 400)
stiffener = cs.crosssection()

code = (0, 0, 0, 0, 0)

a = point.point(100, 0)
b = point.point(50, 50)
c = point.point(-50, 50)
d = point.point(-100, 0)
e = point.point(100, 400)
f = point.point(50, 350)
g = point.point(-50, 350)
h = point.point(-100, 400)

stiffener.addline(ln.line(code, a, b, 1))
stiffener.addline(ln.line(code, b, c, 1))
stiffener.addline(ln.line(code, c, d, 1))
Example #7
0
def global_plate_buckling(total_cs, plate_glob):
    string = "\n      4.5.2 Plate type behaviour"
    printing.printing(string)

    stiffened_plate = copy.deepcopy(plate_glob)

    #identify the border plates a and b and numbers of end stiffeners
    plate_a = None
    plate_b = None
    min_tpl = -1
    max_tpl = -1
    max_stn = 0
    min_stn = 1000

    for plate in stiffened_plate.lines:
        if plate.code.pl_type == 0:
            if min_tpl == -1 and max_tpl == -1:
                min_tpl = plate.code.tpl_number
                max_tpl = plate.code.tpl_number
            if plate.code.tpl_number <= min_tpl:
                plate_a = plate
            if plate.code.tpl_number >= max_tpl:
                plate_b = plate
        else:
            if plate.code.st_number <= min_stn and plate.code.st_number != 0:
                min_stn = plate.code.st_number
            if plate.code.st_number >= max_stn and plate.code.st_number != 0:
                max_stn = plate.code.st_number

    assert plate_a != None and plate_b != None, "For-Loop failed."

    ### Get Stresses ###
    sigma_a = stress_cal.get_sigma_a_red(total_cs, plate_a,
                                         data.input_data.get("M_Ed"))
    sigma_b = stress_cal.get_sigma_b_red(total_cs, plate_b,
                                         data.input_data.get("M_Ed"))
    if abs(sigma_a) <= 0.1:
        sigma_a = sigma_a / abs(sigma_a) * 0.1
    if abs(sigma_b) <= 0.1:
        sigma_b = sigma_b / abs(sigma_b) * 0.1
    if abs(sigma_a) > 1000:
        sigma_a = sigma_a / abs(sigma_a) * 1000
    if abs(sigma_b) > 1000:
        sigma_b = sigma_b / abs(sigma_b) * 1000

    psi = min(sigma_a, sigma_b) / max(sigma_a, sigma_b)

    if sigma_a <= 0 and sigma_b <= 0:
        rho_glob = 1
        sigma_cr_p = 10**10
    ### Get Plate Geometry ###
    else:
        h = 0
        for plate in stiffened_plate.lines:
            if plate.code.pl_type == 0:
                h += plate.get_length_tot()
        t = plate_a.t
        b = data.input_data.get("a")

        #find borders of compression zone
        comp = None
        if sigma_a > 0 and sigma_b > 0:
            comp = (0, h)
        elif sigma_a > 0 and sigma_b <= 0:
            h_red = h * sigma_a / (sigma_a - sigma_b)
            comp = (0, h_red)
        elif sigma_b > 0 and sigma_a <= 0:
            h_red = h * -sigma_a / (sigma_b - sigma_a)
            comp = (h_red, h)
        else:
            assert True, "This should never happen!"

        #coordinate transformation (a+b)/2 is the new origin and baseplate is horizontal
        #set new origin
        move_z = 0.5 * (plate_a.a.z + plate_b.b.z)
        move_y = 0.5 * (plate_a.a.y + plate_b.b.y)

        for plate in stiffened_plate.lines:
            plate.a.y -= move_y
            plate.a.z -= move_z
            plate.b.y -= move_y
            plate.b.z -= move_z
            plate.p1.y -= move_y
            plate.p1.z -= move_z
            plate.p2.y -= move_y
            plate.p2.z -= move_z

        #find rotation angle
        if plate_a.a.z == plate_b.b.z:
            #horizontal plate
            angle = 0
        if plate_a.a.y == plate_b.b.y:
            #vertical plate
            angle = math.pi / 2
        else:
            #inclined plate
            angle = -math.atan(
                (plate_b.b.z - plate_a.a.z) / (plate_b.b.y - plate_a.a.y))

        #perform rotation
        for plate in stiffened_plate.lines:
            ay = plate.a.y
            az = plate.a.z
            by = plate.b.y
            bz = plate.b.z
            p1y = plate.p1.y
            p1z = plate.p1.z
            p2y = plate.p2.y
            p2z = plate.p2.z
            plate.a.y = math.cos(angle) * ay - math.sin(angle) * az
            plate.a.z = math.sin(angle) * ay + math.cos(angle) * az
            plate.b.y = math.cos(angle) * by - math.sin(angle) * bz
            plate.b.z = math.sin(angle) * by + math.cos(angle) * bz
            plate.p1.y = math.cos(angle) * p1y - math.sin(angle) * p1z
            plate.p1.z = math.sin(angle) * p1y + math.cos(angle) * p1z
            plate.p2.y = math.cos(angle) * p2y - math.sin(angle) * p2z
            plate.p2.z = math.sin(angle) * p2y + math.cos(angle) * p2z

        #claculate A of stiffened plate
        A_tot = h * t

        #create a list of all stiffeners
        stiffener_list = []
        plate_num_list = []
        corresp_tpl = -2
        for st_number in range(min_stn, max_stn + 1, 1):
            stiffener_list.insert(st_number - min_stn,
                                  crosssection.crosssection(0, 0, 0))
            #find three plates of stiffener
            for plate in stiffened_plate.lines:
                if plate.code.st_number == st_number:
                    stiffener_list[st_number - min_stn].addline(plate)
                    #find middle part of the trapezoid
                    if plate.code.tpl_number != 0:
                        corresp_tpl = plate.code.tpl_number
                        plate_num_list.insert(st_number - min_stn, corresp_tpl)
                    else:
                        corresp_tpl = -2
            #find adjacent parts of the trapezoid
            for plate in stiffened_plate.lines:
                if plate.code.tpl_number == corresp_tpl - 1 or plate.code.tpl_number == corresp_tpl + 1:
                    stiffener_list[st_number - min_stn].addline(plate)

        ###calculate adimensional parameters for each stiffener###
        stiffeners_ebp = []
        compression_stiffener = False
        for i in range(len(stiffener_list)):
            #extract the useful plates
            stiffener = stiffener_list[i]
            corresp_tpl = plate_num_list[i]
            center_plate = None
            top_plate = None
            top_plate_tpl = 0
            bottom_plate = None
            for plate in stiffened_plate.lines:
                if plate.code.tpl_number == corresp_tpl and plate.code.pl_type == 0:
                    center_plate = plate
                if plate.code.tpl_number == corresp_tpl + 1:
                    bottom_plate = plate
                    bottom_plate_tpl = plate.code.tpl_number
                elif plate.code.tpl_number == corresp_tpl - 1:
                    top_plate = plate
                    top_plate_tpl = plate.code.tpl_number
            #find distance to point a
            delta_z = center_plate.get_center_z_tot() - plate_a.a.z
            delta_y = center_plate.get_center_y_tot() - plate_a.a.y
            distance = math.sqrt(delta_z**2 + delta_y**2)

            #calculate theta
            b_sup_st = stiffener.get_line(st_pl_position=1).get_length_tot()
            b_inf_st = stiffener.get_line(st_pl_position=3).get_length_tot()
            t_st = stiffener.get_line(st_pl_position=3).t
            diag = stiffener.get_line(st_pl_position=2).get_length_tot()
            diff = (b_sup_st - b_inf_st) / 2
            h_st = math.sqrt(diag**2 - diff**2)
            A_0 = 0.5 * (b_sup_st + b_inf_st) * h_st
            integral = b_sup_st / t + (2 * diag + b_inf_st) / t_st
            J_T = 4 * A_0**2 / integral
            J_T_ref = 1 / 3 * h * t**3
            theta = J_T / J_T_ref

            #calculate delta
            unit_vec_to_a = (top_plate.a.y -
                             top_plate.b.y) / top_plate.get_length_tot()
            unit_vec_to_b = (bottom_plate.b.y -
                             bottom_plate.a.y) / bottom_plate.get_length_tot()
            #find additional parts of top plate
            top_original = total_cs.get_line(tpl_number=top_plate_tpl)
            sigma_a_top = stress_cal.get_sigma_a(total_cs, top_original,
                                                 data.input_data.get("M_Ed"))
            sigma_b_top = stress_cal.get_sigma_b(total_cs, top_original,
                                                 data.input_data.get("M_Ed"))
            psi_top = min(sigma_a_top, sigma_b_top) / max(
                sigma_a_top, sigma_b_top)
            length_top = 0
            if sigma_b_top > 0:
                if sigma_a_top > 0:
                    if sigma_a_top < sigma_b_top:
                        #high stress side
                        length_top = top_plate.get_length_tot() * 2 / (5 -
                                                                       psi_top)
                    else:
                        #low stress side
                        length_top = top_plate.get_length_tot() * (
                            3 - psi_top) / (5 - psi_top)
                else:
                    #point a in tension zone
                    b_comp = top_plate.get_length_tot() / (1 - psi_top)
                    length_top = 0.4 * b_comp
            else:
                #tension zone
                pass

            #find additional parts of bottom plate
            bottom_original = total_cs.get_line(tpl_number=bottom_plate_tpl)
            sigma_a_bottom = stress_cal.get_sigma_a(
                total_cs, bottom_original, data.input_data.get("M_Ed"))
            sigma_b_bottom = stress_cal.get_sigma_b(
                total_cs, bottom_original, data.input_data.get("M_Ed"))
            psi_bottom = min(sigma_a_bottom, sigma_b_bottom) / max(
                sigma_a_bottom, sigma_b_bottom)
            length_bottom = 0
            if sigma_a_bottom > 0:
                if sigma_b_bottom > 0:
                    if sigma_b_bottom < sigma_a_bottom:
                        #high stress side
                        length_bottom = bottom_plate.get_length_tot() * 2 / (
                            5 - psi_bottom)
                    else:
                        #low stress side
                        length_bottom = bottom_plate.get_length_tot() * (
                            3 - psi_bottom) / (5 - psi_bottom)
                else:
                    #point a in tension zone
                    b_comp = bottom_plate.get_length_tot() / (1 - psi_bottom)
                    length_bottom = 0.4 * b_comp

            else:
                #tension zone
                pass

            #add additional parts of plate to stiffener
            new_top_point = point.point(
                top_plate.b.y + unit_vec_to_a * length_top, top_plate.b.z)
            new_top_plate = line.line(top_plate.code, new_top_point,
                                      top_plate.b, top_plate.t)
            new_bottom_point = point.point(
                bottom_plate.a.y + unit_vec_to_b * length_bottom,
                bottom_plate.a.z)
            new_bottom_plate = line.line(bottom_plate.code, bottom_plate.a,
                                         new_bottom_point, top_plate.t)
            stiffener.lines.append(new_top_plate)
            stiffener.lines.append(new_bottom_plate)

            delta = stiffener.get_area_tot() / A_tot

            #calculate gamma
            length_gamma = defaults.effective_width_parameter * center_plate.t
            if length_gamma > 0.5 * center_plate.get_length_tot():
                new_top_plate.a = point.point(
                    new_top_plate.b.y + unit_vec_to_a * length_gamma,
                    new_top_plate.b.z)
                new_bottom_plate.b = point.point(
                    new_bottom_plate.a.y + unit_vec_to_b * length_gamma,
                    new_bottom_plate.a.z)
            else:
                stiffener.lines.remove(center_plate)
                new_top_plate.a = point.point(
                    new_top_plate.b.y + unit_vec_to_a * length_gamma,
                    new_top_plate.b.z)
                new_top_plate.b = point.point(
                    new_top_plate.b.y + unit_vec_to_b * length_gamma,
                    new_top_plate.b.z)
                new_bottom_plate.b = point.point(
                    new_bottom_plate.a.y + unit_vec_to_b * length_gamma,
                    new_bottom_plate.a.z)
                new_bottom_plate.a = point.point(
                    new_bottom_plate.a.y + unit_vec_to_a * length_gamma,
                    new_bottom_plate.a.z)
            gamma = stiffener.get_i_y_tot() * 12 * (1 - 0.3**2) / (h * t**3)

            ### USE EBPlate ###
            #assure that there is at least on stiffener in compression zone
            if distance > comp[0] and distance < comp[1]:
                compression_stiffener = True

            if gamma > 1000:
                gamma = 1000
            if theta > 1000:
                theta = 1000
            if delta > 1000:
                delta = 1000
            assert gamma <= 1000 and gamma >= 0, "gamma too high or low"
            assert theta <= 1000 and theta >= 0, "theta too high or low"
            assert delta <= 1000 and delta >= 0, "theta too high or low"
            stiffeners_ebp.insert(i, (distance, gamma, theta, delta))

        assert t >= 3, "\nError: Plate too thin."
        if 100 > b:
            b = 100
        if 100 > h:
            h = 100
        #finding critical buckling load
        phi_cr_p = 0
        if compression_stiffener == True and abs(sigma_a) >= 0.1 and abs(
                sigma_a) <= 1000 and abs(sigma_b) >= 0.1 and abs(
                    sigma_b) <= 1000 and 3 <= t and 100 <= b and 100 <= h:
            phi_cr_p = ebplate.ebplate(b, h, t, sigma_a, sigma_b,
                                       stiffeners_ebp)

        elif compression_stiffener == False:
            string = "\nno compression stiffener"
            printing.printing(string)
            return 1, 0
        else:
            assert True, "Error: Calculation of phi_cr_p not possible."
        sigma_max = max(sigma_a, sigma_b)
        sigma_cr_p = sigma_max * phi_cr_p
        string = "\n         sigma_cr_plate = " + str(
            math.floor(1000 * sigma_cr_p) / 1000)
        printing.printing(string)

        ### Calculation according to EC3, 1-5, 4.5.2 ###
        #calculating plate slenderness
        beta_a_c = get_beta_ac(plate_glob)
        lambda_p_glob_bar = math.sqrt(beta_a_c * data.constants.get("f_y") /
                                      sigma_cr_p)
        string = "\n         Lambda: " + str(
            math.floor(1000 * lambda_p_glob_bar) / 1000)
        printing.printing(string)

        #calculate rho_glob for plate buckling
        #assumption: cross section parts always supported on both sides
        rho_glob = 0
        #held on both sides
        if lambda_p_glob_bar <= 0.673:
            rho_glob = 1.0
        elif lambda_p_glob_bar > 0.673 and (3 + psi) >= 0:
            rho_glob = (lambda_p_glob_bar - 0.055 *
                        (3 + psi)) / lambda_p_glob_bar**2
            if rho_glob > 1.0:
                rho_glob = 1.0
        else:
            string = "\n         plate slenderness or stress ratio out of range"
            printing.printing(string)
            pass

        string = "      Rho_Global: " + str(math.floor(1000 * rho_glob) / 1000)
        printing.printing(string)

    return rho_glob, sigma_cr_p
Example #8
0
from proofs import resistance_to_shear as rts
from classes import crosssection as cs
from classes import stiffener as st
from classes import merge
import deck
import data
import initial_cs as ics


data.input_data.update({"b_inf": 3000})
data.input_data.update({"b_sup": 4000})
data.input_data.update({"h": 1500})
data.input_data.update({"M_Ed": 50*10**9})
data.input_data.update({"Q_Ed": 100*10**3})
data.input_data.update({"T_Ed": 3*10**9})
data.input_data.update({"a": 1000})
data.input_data.update({"L_e": 1000})
data.input_data.update({"bending type": 1000})
data.input_data.update({"cs position": 1000})

initial_cs = ics.create_initial_cs(4000, 3000, 1500, 4, 4, 4)
deck_stiffeners = deck.deck(4000)
stiffened_cs = merge.merge(initial_cs, deck_stiffeners)
plate_glob = cs.crosssection(0,0,0)
for line in stiffened_cs.lines:
    if line.code.pl_position == 1:
        plate_glob.addline(line)

eta_3 = rts.resistance_to_shear(stiffened_cs, plate_glob)
print("eta3 = " + str(eta_3))
Example #9
0
h = 1500
M_Ed = -100000000
data.input_data["M_Ed"] = M_Ed
data.input_data["h"] = h
data.input_data["b_inf"] = b_inf
data.input_data["b_sup"] = b_sup

print(data.input_data)
print(data.constants)

cs = initial_cs.create_initial_cs(b_sup, b_inf, h, 20, 20, 20)
geometry_output.print_cs_red(cs)
#deck_stiffeners = deck.deck(b_sup)
#cs = merge.merge(cs, deck_stiffeners)

#prop_list = stiffeners_proposition.stiffeners_proposition()
#
#prop_1 = proposed_stiffener.proposed_stiffener(2, 1, 0.5, 10**7)
#prop_list.add(prop_1)
#prop_3 = proposed_stiffener.proposed_stiffener(3, 2, -0.7, 10**7)
#prop_list.add(prop_3)
#prop_4 = proposed_stiffener.proposed_stiffener(3, 3, 0.7, 10**7)
#prop_list.add(prop_4)
#prop_5 = proposed_stiffener.proposed_stiffener(4, 4, 0.5, 10**7)
#prop_list.add(prop_5)

line = cs.get_line(pl_position=1)

new_cs = crosssection.crosssection(0, 0, 0)
geometry_output.print_cs_red(new_cs)
Example #10
0
import sys
sys.path.append('C:/Users/Vinzenz Müller/Dropbox/ETH/6. Semester/BA')
from classes import crosssection
import cs_collector

cs1 = crosssection.crosssection(0, 0, 0)
cs1.cost = 4
cs_collector.into_collector(cs1)

cs2 = crosssection.crosssection(0, 0, 0)
cs2.cost = 2
cs_collector.into_collector(cs2)

cs3 = crosssection.crosssection(0, 0, 0)
cs3.cost = 2
cs_collector.into_collector(cs3)

cs4 = crosssection.crosssection(0, 0, 0)
cs4.cost = 2
cs_collector.into_collector(cs4)

best = cs_collector.get_best()
for i in best:
    print(i.cost)
Example #11
0
def get_m_rd_pl_eff(total_cs):
    #remove side stiffeners
    cs = crosssection.crosssection(total_cs.b_sup, total_cs.b_inf, total_cs.h)
    for plate in total_cs.lines:
        if (plate.code.pl_position == 2
                or plate.code.pl_position == 4) and plate.code.pl_type == 1:
            pass
        else:
            cs.addline(plate)
    total_area = cs.get_area_red(stress=True)
    convergence = defaults.convergence_limit_m_rd_pl_eff * total_area
    continue_iteration = True
    area_top = 10**12
    area_btm = 0
    start = True
    z_min = 0
    z = cs.h / 2
    z_max = cs.h
    code = plate_code.plate_code(-1, -1, -1, -1, -1)
    counter = 0
    #interation loop to find position of plastic zero line
    while abs(area_top -
              area_btm) > convergence and continue_iteration == True:
        counter += 1
        start = False
        top_part = crosssection.crosssection(0, 0, 0)
        bottom_part = crosssection.crosssection(0, 0, 0)
        for plate in cs.lines:
            #plate is entirely below assumed plastic zero line
            if plate.a.z >= z and plate.b.z >= z:
                bottom_part.addline(plate)
            #plate is entirely above plastic zero line
            elif plate.a.z <= z and plate.b.z <= z:
                top_part.addline(plate)
            #plate crosses plastic zero line, a on top
            elif plate.a.z <= z and plate.b.z >= z:
                #case 1: pzl crosses a-p1
                if plate.a.z < z and plate.p1.z > z:
                    share = (z - plate.a.z) / (plate.p1.z - plate.a.z)
                    y = plate.a.y + share * (plate.p1.y - plate.a.y)
                    point_middle = point.point(y, z)
                    line_a = line.line(code, plate.a, point_middle, plate.t)
                    top_part.addline(line_a)
                    line_b1 = line.line(code, point_middle, plate.p1, plate.t)
                    bottom_part.addline(line_b1)
                    line_b2 = line.line(code, plate.p2, plate.b, plate.t)
                    bottom_part.addline(line_b2)
                #case 2: pzl crosses p2-b
                elif plate.p2.z < z and plate.b.z > z:
                    share = (z - plate.p2.z) / (plate.b.z - plate.p2.z)
                    y = plate.p2.y + share * (plate.b.y - plate.p2.y)
                    point_middle = point.point(y, z)
                    line_a1 = line.line(code, plate.a, plate.p1, plate.t)
                    top_part.addline(line_a1)
                    line_a2 = line.line(code, plate.p2, point_middle, plate.t)
                    top_part.addline(line_a2)
                    line_b = line.line(code, point_middle, plate.b, plate.t)
                    bottom_part.addline(line_b)
                #case 3 pzl crosses p1-p2
                else:
                    line_a = line.line(code, plate.a, plate.p1, plate.t)
                    top_part.addline(line_a)
                    line_b = line.line(code, plate.p1, plate.b, plate.t)
                    bottom_part.addline(line_b)
            elif plate.a.z >= z and plate.b.z <= z:
                #case 1: pzl crosses b-p2
                if plate.b.z < z and plate.p2.z > z:
                    share = (z - plate.b.z) / (plate.p2.z - plate.b.z)
                    y = plate.b.y + share * (plate.p2.y - plate.b.y)
                    point_middle = point.point(y, z)
                    line_b = line.line(code, plate.b, point_middle, plate.t)
                    top_part.addline(line_b)
                    line_a1 = line.line(code, point_middle, plate.p2, plate.t)
                    bottom_part.addline(line_a1)
                    line_a2 = line.line(code, plate.p1, plate.a, plate.t)
                    bottom_part.addline(line_a2)
                #case 2: pzl crosses p1-a
                elif plate.p1.z < z and plate.a.z > z:
                    share = (z - plate.p1.z) / (plate.a.z - plate.p1.z)
                    y = plate.p1.y + share * (plate.a.y - plate.p1.y)
                    point_middle = point.point(y, z)
                    line_b1 = line.line(code, plate.b, plate.p2, plate.t)
                    top_part.addline(line_b1)
                    line_b2 = line.line(code, plate.p1, point_middle, plate.t)
                    top_part.addline(line_b2)
                    line_a = line.line(code, point_middle, plate.a, plate.t)
                    bottom_part.addline(line_a)
                #case 3 pzl crosses p1-p2
                else:
                    line_b = line.line(code, plate.b, plate.p2, plate.t)
                    top_part.addline(line_b)
                    line_a = line.line(code, plate.p2, plate.a, plate.t)
                    bottom_part.addline(line_a)
        area_top = top_part.get_area_red(stress=True)
        area_btm = bottom_part.get_area_red(stress=True)
        if area_top > area_btm:
            z_max = z
            z = 0.5 * (z + z_min)
        else:
            z_min = z
            z = 0.5 * (z + z_max)
        counter += 1
        if counter > 10:
            continue_iteration = False
    z_s_top = abs(z - top_part.get_center_z_red(stress=True))
    z_s_btm = abs(z - bottom_part.get_center_z_red(stress=True))
    m_pl_rd_eff = (z_s_top * area_top +
                   z_s_btm * area_btm) * data.constants.get(
                       "f_y") / data.constants.get("gamma_M1")
    return m_pl_rd_eff
Example #12
0
def column_buckling(plate_glob, side, height_zero_pressure,
                    height_max_pressure):
    string = "\n      4.5.3 Column type buckling behaviour"
    printing.printing(string)

    #add the lines to the right list
    stiffener_lines = []
    tpl_lines_list = []
    stiffeners_list = []
    #points of max pressure and zero pressure; needed for extrapolation
    point_max = None
    sigma_max = 0
    for plate in plate_glob.lines:
        if plate.code.tpl_number == 0:
            stiffener_lines.append(plate)
        elif plate.code.pl_type == 0:
            tpl_lines_list.append(plate)
        #for extrapolation b_c and the positions will be required
        if plate.sigma_a_red >= sigma_max:
            point_max = copy.deepcopy(plate.a)
            sigma_max = plate.sigma_a_red
        elif plate.sigma_b_red >= sigma_max:
            point_max = copy.deepcopy(plate.b)
            sigma_max = plate.sigma_b_red

    #case 1: stiffened plate
    if stiffener_lines != []:
        st_number_min = stiffener_lines[0].code.st_number
        st_number_max = stiffener_lines[0].code.st_number
        for plate in stiffener_lines:
            if plate.code.st_number < st_number_min:
                st_number_min = plate.code.st_number
            elif plate.code.st_number > st_number_max:
                st_number_max = plate.code.st_number
        number_of_stiffeners = int(len(stiffener_lines) / 3)

        for i in range(number_of_stiffeners):
            stiffeners_list.append(crosssection.crosssection(0, 0, 0))
            for plate in stiffener_lines:
                if plate.code.st_number == i + st_number_min:
                    stiffeners_list[i].lines.append(plate)

        #sort the lists
        tpl_lines_list = sorted(tpl_lines_list,
                                key=lambda plate: plate.code.tpl_number)
        stiffeners_list = sorted(
            stiffeners_list,
            key=lambda stiffener: stiffener.lines[0].code.st_number)

        #create sets
        tpl_st_lines_set = {}
        tpl_betw_lines_set = {}

        j = 1
        for plate in tpl_lines_list:
            #is the tpl_number even, (or odd, see correction)
            #meaning included in a stiffener
            if j % 2 == 0:
                st_number = st_number_min + int(j / 2) - 1
                tpl_st_lines_set.update({st_number: plate})
            else:
                st_number_before = st_number_min + int(j / 2) - 1
                tpl_betw_lines_set.update({st_number_before: plate})
            j += 1

        stiffeners_set = {}
        stiffeners_set_length = 0
        for stiffener in stiffeners_list:
            st_number = stiffener.lines[0].code.st_number
            stiffeners_set.update({st_number: stiffener})
            stiffeners_set_length += 1

        columns = {}
        i = st_number_min
        #a set of all columns (stiffener + carrying widths) is created -> see column_class
        #they carry the number of the stiffener and they have the stiffener number as a key
        while i < st_number_max + 1:
            stiffener_i = copy.deepcopy(stiffeners_set.get(i))
            plate_before = copy.deepcopy(tpl_betw_lines_set.get(i - 1))
            plate_between = copy.deepcopy(tpl_st_lines_set.get(i))
            plate_after = copy.deepcopy(tpl_betw_lines_set.get(i))
            code_before = plate_before.code
            code_between = plate_between.code
            code_after = plate_after.code
            plate_between_A_tot = plate_between.get_area_tot()
            plate_between_A_red = plate_between.get_area_red()
            plate_between_I_tot = plate_between.get_i_along_tot()

            #plate_before
            plate_before_gross_len = figure_Aone(plate_before, False, True)
            factor = plate_before_gross_len / plate_before.get_length_tot()
            point_a_y = plate_before.b.y + factor * (plate_before.a.y -
                                                     plate_before.b.y)
            point_a_z = plate_before.b.z + factor * (plate_before.a.z -
                                                     plate_before.b.z)
            border_before_gross = point.point(point_a_y, point_a_z)
            plate_before_gross = line.line(code_before, border_before_gross,
                                           plate_before.b, plate_before.t)
            plate_before_gross_I = plate_before_gross.get_i_along_tot()
            plate_before_gross_A = plate_before_gross.get_area_tot()
            sigma_border_before_gross = plate_before.sigma_b_red + factor * (
                plate_before.sigma_a_red - plate_before.sigma_b_red)
            plate_before_gross.sigma_a_red = sigma_border_before_gross
            plate_before_gross.sigma_b_red = plate_before.sigma_b_red

            plate_before_eff_len = figure_Aone(plate_before, False, False)
            factor = plate_before_eff_len / plate_before.get_length_tot()
            point_a_y = plate_before.b.y + factor * (plate_before.a.y -
                                                     plate_before.b.y)
            point_a_z = plate_before.b.z + factor * (plate_before.a.z -
                                                     plate_before.b.z)
            border_before_eff = point.point(point_a_y, point_a_z)
            plate_before_eff = line.line(code_before, border_before_eff,
                                         plate_before.b, plate_before.t)
            plate_before_eff_I = plate_before_eff.get_i_along_tot()
            plate_before_eff_A = plate_before_eff.get_area_tot()
            sigma_border_before_eff = plate_before.sigma_b_red + factor * (
                plate_before.sigma_a_red - plate_before.sigma_b_red)
            plate_before_eff.sigma_a_red = sigma_border_before_eff
            plate_before_eff.sigma_b_red = plate_before.sigma_b_red

            #plate_after
            plate_after_gross_len = figure_Aone(plate_after, True, True)
            factor = plate_after_gross_len / plate_after.get_length_tot()
            point_b_y = plate_after.a.y + factor * (plate_after.b.y -
                                                    plate_after.a.y)
            point_b_z = plate_after.a.z + factor * (plate_after.b.z -
                                                    plate_after.a.z)
            border_after_gross = point.point(point_b_y, point_b_z)
            plate_after_gross = line.line(code_after, plate_after.a,
                                          border_after_gross, plate_after.t)
            plate_after_gross_I = plate_after_gross.get_i_along_tot()
            plate_after_gross_A = plate_after_gross.get_area_tot()
            sigma_border_after_gross = plate_after.sigma_b_red + factor * (
                plate_after.sigma_a_red - plate_after.sigma_b_red)
            plate_after_gross.sigma_a_red = plate_after.sigma_a_red
            plate_after_gross.sigma_b_red = sigma_border_after_gross

            plate_after_eff_len = figure_Aone(plate_after, True, False)
            factor = plate_after_eff_len / plate_after.get_length_tot()
            point_b_y = plate_after.a.y + factor * (plate_after.b.y -
                                                    plate_after.a.y)
            point_b_z = plate_after.a.z + factor * (plate_after.b.z -
                                                    plate_after.a.z)
            border_after_eff = point.point(point_b_y, point_b_z)
            plate_after_eff = line.line(code_after, plate_after.a,
                                        border_after_eff, plate_after.t)
            plate_after_eff_I = plate_after_eff.get_i_along_tot()
            plate_after_eff_A = plate_after_eff.get_area_tot()
            sigma_border_after_eff = plate_after.sigma_b_red + factor * (
                plate_after.sigma_a_red - plate_after.sigma_b_red)
            plate_after_eff.sigma_a_red = plate_after.sigma_a_red
            plate_after_eff.sigma_b_red = sigma_border_after_eff

            #EC 1993 1-5 4.5.3 (3)
            A_sl = stiffener_i.get_area_tot(
            ) + plate_before_gross_A + plate_after_gross_A + plate_between_A_tot
            A_sl_eff = stiffener_i.get_area_red(
            ) + plate_before_eff_A + plate_after_eff_A + plate_between_A_red
            I_sl = stiffener_i.get_i_along_tot(
                plate_between
            ) + plate_before_gross_I + plate_after_gross_I + plate_between_I_tot
            sigma_cr_sl = (math.pi**2 * data.constants.get("E") *
                           I_sl) / (A_sl * data.input_data.get("a")**2)

            ######calculation of sigma_cr_c################
            #span of column
            b = dis_points(border_before_gross, border_after_gross)
            #stress ratio across the whole cross-section of the column
            stress_ratio = min(
                sigma_border_before_gross, sigma_border_after_gross) / max(
                    sigma_border_before_gross, sigma_border_after_gross)

            column_as_cs = copy.deepcopy(stiffener_i)
            column_as_cs.addline(plate_before_gross)
            column_as_cs.addline(plate_after_gross)
            column_as_cs.addline(plate_between)

            #calculating stiffener center
            tpl_st_center = point.point(
                tpl_st_lines_set.get(i).get_center_y_tot(),
                tpl_st_lines_set.get(i).get_center_z_tot())
            height_stiffener_center = tpl_st_center.z

            #calculating b_c and sigma_cr_c
            all_tension = False
            if sigma_border_before_gross < 0 and sigma_border_after_gross < 0:
                #all tension
                b_c = 0
                sigma_cr_c = 10**8
                all_tension = True
            elif abs(sigma_border_before_gross -
                     sigma_border_after_gross) < 0.5:
                #same pressure; bottom stiffener; no extrapolation required
                b_c = b
                sigma_cr_c = sigma_cr_sl
                all_tension = False
            #different pressure; side stiffener; extrapolation required
            else:
                b_sl_1 = height_stiffener_center - height_zero_pressure
                b_c = height_max_pressure - height_zero_pressure
                if b_sl_1 == 0:
                    sigma_cr_c = 10**8
                    all_tension = True
                factor = b_c / b_sl_1
                if factor > 0:
                    #stiffener in compression zone --> extrapolation
                    sigma_cr_c = sigma_cr_sl * factor
                else:
                    #stiffener in tension zone --> no proof required
                    b_c = 0
                    sigma_cr_c = 10**8
                    all_tension = True

            #excentricities
            st_center = point.point(stiffener_i.get_center_y_tot(),
                                    stiffener_i.get_center_z_tot())

            sl_cs = crosssection.crosssection(0, 0, 0)
            for plate in stiffener_i.lines:
                sl_cs.addline(plate)
            sl_cs.addline(plate_before_gross)
            sl_cs.addline(plate_after_gross)
            sl_cs.addline(plate_between)

            #center of the whole column
            sl_center = point.point(sl_cs.get_center_y_tot(),
                                    sl_cs.get_center_z_tot())

            e2 = dis_plate_point(tpl_st_lines_set.get(i), sl_center)
            e1 = dis_plate_point(tpl_st_lines_set.get(i), st_center) - e2

            column = column_class(i, A_sl, A_sl_eff, I_sl, sigma_cr_c, e1, e2,
                                  all_tension, column_as_cs)

            columns.update({i: column})

            printing.printing(str(column))

            i += 1
        #all columns created

        Chi_c = 10**8
        sigma_cr_c = 1

        #searches for the single column buckling mechanism with the smallest Chi_c
        #this one will be the defining column mechanism
        #as not all our stiffeners will be the same, we can not conclude that it is one at a border (highest pressure)
        for key in columns:
            Chi_c_column = column_buckling_Chi_c(columns.get(key))
            if Chi_c_column < Chi_c:
                Chi_c = Chi_c_column
                sigma_cr_c = columns.get(key).sigma_cr_c

    #case 2: unstiffened plate
    else:
        t_plate = tpl_lines_list[0].t
        sigma_cr_c = math.pi**2 * data.constants.get("E") * t_plate**2 / \
        (12 * (1-data.constants.get("nu")**2)*data.input_data.get("a")**2)
        lambda_c_bar = math.sqrt(data.constants.get("f_y") / sigma_cr_c)
        alpha = 0.21
        Phi_c = 0.5 * (1 + alpha * (lambda_c_bar - 0.2) + lambda_c_bar**2)

        Chi_c = 1 / (Phi_c + math.sqrt(Phi_c**2 - lambda_c_bar**2))
        if Chi_c > 1:
            Chi_c = 1

        string = "\n         Unstiffened Plate"
        string += "\n            sigma_cr_c: " + str(
            math.floor(1000 * sigma_cr_c) / 1000)
        #string += "\n            lambda_c_bar ="+str(lambda_c_bar)
        #string += "\n            Phi_c: "+str(Phi_c)
        string += "\n            Chi_c: " + str(
            math.floor(1000 * Chi_c) / 1000)
        printing.printing(string)

    string = "\n         Critical buckling values"
    string += "      sigma_cr_c: " + str(math.floor(1000 * sigma_cr_c) / 1000)
    string += "      Chi_c: " + str(math.floor(1000 * Chi_c) / 1000)
    printing.printing(string)

    return Chi_c, sigma_cr_c
Example #13
0
def resistance_to_shear(plate_glob, V_Ed_plate):
    string = "\n   5. Resistance to shear"
    printing.printing(string)

    #get values of constants
    f_y = data.constants.get("f_y")
    gamma_M1 = data.constants.get("gamma_M1")
    eta = defaults.eta
    side = plate_glob.lines[0].code.pl_position
    a = data.input_data.get("a")

    #import important geometry parameters
    #calculate lambda_w_bar for subpanels
    h_w = 0
    lambda_w_bar_3 = 0
    for plate in plate_glob.lines:
        if plate.code.pl_type == 0:
            k_tau_loc = 0
            h_w_i = plate.get_length_tot()
            if a / h_w_i >= 1:
                k_tau_loc = 5.34 + 4*(h_w_i/a)**2
            else:
                k_tau_loc = 4.0 + 5.34 * (h_w_i/a)**2
            lambda_w_bar_loc = h_w_i / (37.4*plate.t*math.sqrt(235/f_y)*math.sqrt(k_tau_loc))
            #if plate.code.pl_type == 0:
            #    string = "\n         lambda_w_bar_loc of the trapezoid line nr. "+str(plate.code.tpl_number)+": "+str(math.floor(lambda_w_bar_loc*1000)/1000)
            #else:
            #    string = "\n         lambda_w_bar_loc of the stiffener line nr. "+str(plate.code.st_number)+": "+str(math.floor(lambda_w_bar_loc*1000)/1000)
            #printing.printing(string)
            if lambda_w_bar_loc > lambda_w_bar_3:
                lambda_w_bar_3 = lambda_w_bar_loc
            h_w += plate.get_length_tot()
    t = plate_glob.get_line(pl_type = 0).t


    stiffened = True
    if len(plate_glob.lines) == 1:
        stiffened = False

    #calculate k_tau
    k_tau = 0
    if stiffened == False:
        string = "\n      unstiffened plate; (A.5)"
        if a / h_w >= 1:
            k_tau = 5.34 + 4*(h_w/a)**2

            string  += "      k_tau: "+str(math.floor(1000*k_tau)/1000)
        else:
            k_tau = 4.0 + 5.34 * (h_w/a)**2
            string  += "      k_tau: "+str(math.floor(1000*k_tau)/1000)
        printing.printing(string)

    else:
        string = "\n      stiffened plate; EBPlate"
        plate_a = None
        plate_b = None
        min_tpl = -1
        max_tpl = -1
        max_stn = 0
        min_stn = 1000
        stiffened_plate = copy.deepcopy(plate_glob)
        for plate in stiffened_plate.lines:
            if plate.code.pl_type == 0:
                if min_tpl == -1 and max_tpl == -1:
                    min_tpl = plate.code.tpl_number
                    max_tpl = plate.code.tpl_number
                if plate.code.tpl_number <= min_tpl:
                    plate_a = plate
                if plate.code.tpl_number >= max_tpl:
                    plate_b = plate
            else:
                if plate.code.st_number <= min_stn and plate.code.st_number != 0:
                    min_stn = plate.code.st_number
                if plate.code.st_number >= max_stn and plate.code.st_number != 0:
                    max_stn = plate.code.st_number

        assert plate_a != None and plate_b != None, "For-Loop failed."

        move_z = 0.5*(plate_a.a.z + plate_b.b.z)
        move_y = 0.5*(plate_a.a.y + plate_b.b.y)

        for plate in stiffened_plate.lines:
            plate.a.y -= move_y
            plate.a.z -= move_z
            plate.b.y -= move_y
            plate.b.z -= move_z

        #find rotation angle
        if plate_a.a.z == plate_b.b.z:
            #horizontal plate
            angle = 0
        if plate_a.a.y == plate_b.b.y:
            #vertical plate
            angle = math.pi/2
        else:
            #inclined plate
            angle = - math.atan((plate_b.b.z-plate_a.a.z)/(plate_b.b.y-plate_a.a.y))

        #perform rotation
        for plate in stiffened_plate.lines:
            ay = plate.a.y
            az = plate.a.z
            by = plate.b.y
            bz = plate.b.z
            plate.a.y = math.cos(angle)*ay - math.sin(angle)*az
            plate.a.z = math.sin(angle)*ay + math.cos(angle)*az
            plate.b.y = math.cos(angle)*by - math.sin(angle)*bz
            plate.b.z = math.sin(angle)*by + math.cos(angle)*bz

        stiffener_list = []
        stiffeners_ebp = []
        for st_number in range(min_stn, max_stn+1, 1):
            i = st_number - min_stn
            stiffener_list.insert(i, crosssection.crosssection(0,0,0))
            #find three plates of stiffener
            for plate in stiffened_plate.lines:
                if plate.code.st_number == st_number:
                    stiffener_list[st_number - min_stn].addline(plate)
            b_inf = stiffener_list[i].get_line(st_pl_position = 3).get_length_tot()
            b_sup = stiffener_list[i].get_line(st_pl_position = 1).get_length_tot()
            diff = (0.5*(b_sup - b_inf))
            diag = stiffener_list[i].get_line(st_pl_position = 2).get_length_tot()
            h = math.sqrt(diag**2-diff**2)
            t_stiff = stiffener_list[i].get_line(st_pl_position = 3).t
            center_y = stiffener_list[i].get_center_y_tot()
            distance = abs(center_y-plate_a.a.y)
            stiffeners_ebp.insert(i, (distance, h, b_sup, b_inf, t_stiff))
        tau = V_Ed_plate / (t*h_w)
        sigma_E = 190000*(t/h_w)**2
        if abs(tau) > 0.1 and 3 <= t:
            k_tau = ebplate.ebplate_shear(a, h_w, t, tau, stiffeners_ebp) * tau / sigma_E
            string += "\n      k_tau: "+str(math.floor(1000*k_tau)/1000)

        elif t<3:
            eta_3 = 10**2
            string += "\n      plate too thin; eta_3: "+ str(math.floor(1000*eta_3)/1000)
            return eta_3
        else:
            eta_3 = 0
            string += "\n      tau too small; eta_3: "+ str(0)
            return eta_3
        printing.printing(string)


    #pre_evaluation
    proof_required = True
    if stiffened == False:
        eval = 72 / eta * math.sqrt(235/f_y)
        if h_w/t < eval:
            proof_required = False
    else:
        eval = 31 / eta * math.sqrt(235 *k_tau/f_y)
        if h_w/t < eval:
            proof_required = False

    V_Rd = f_y*h_w*t/(math.sqrt(3)*gamma_M1)
    #calculate reduction factor chi_w if required
    if proof_required == True:
        #calculate tau_cr
        sigma_E = 190000*(t/h_w)**2
        tau_cr = k_tau * sigma_E
        lambda_w_bar_1 = 0.76 * math.sqrt(f_y / tau_cr) # formula 5.3
        lambda_w_bar_2 = h_w /(37.4*t*math.sqrt(235/f_y)*math.sqrt(k_tau)) #formula 5.6
        lambda_w_bar = min(lambda_w_bar_1, lambda_w_bar_2)
        lambda_w_bar = max(lambda_w_bar, lambda_w_bar_3)

        #string = "\n         (5.3) lambda_w_bar_1= "+str(math.floor(lambda_w_bar_1*1000)/1000)
        #string += "\n         (5.6) lambda_w_bar_2= "+str(math.floor(lambda_w_bar_2*1000)/1000)
        #string += "\n         (5.7) lambda_w_bar_3= "+str(math.floor(lambda_w_bar_3*1000)/1000)+" max single plate slenderness"
        #string = "      lambda_w_bar= "+str(math.floor(lambda_w_bar*1000)/1000)
        #printing.printing(string)

        assert lambda_w_bar > 0, "Strange value for lambda_w_bar"
        #assume a deformable support stiffener
        #no resistance due to plastic hinges in flanges
        chi_w = 0
        if lambda_w_bar < 0.83/eta:
            chi_w = eta
        else:
            chi_w = 0.83/lambda_w_bar

        assert chi_w <= eta, "value for chi_w too high"
        #calculate resistance
        V_Rd = chi_w*f_y*h_w*t/(math.sqrt(3)*gamma_M1)

    eta_3 = V_Ed_plate / V_Rd
    #string = "\n      V_Ed_plate: "+str(math.floor(V_Ed_plate*1000)/1000)
    #string += "\n      V_Rd: "+str(math.floor(V_Rd*1000)/1000)
    string = "      eta_3: "+str(math.floor(1000*eta_3)/1000)
    printing.printing(string)

    return eta_3
Example #14
0
def reduction_global_buckling(cs, side):
    string = "\n   Side " + str(side)
    printing.printing(string)

    #extract the respective plate
    plate_glob = crosssection.crosssection(0, 0, 0)
    line_min = cs.get_line(pl_position=side, pl_type=0)
    line_max = line_min
    for plate in cs.lines:
        if plate.code.pl_position == side:
            plate_glob.addline(plate)
            if plate.code.tpl_number != 0 and plate.code.tpl_number < line_min.code.tpl_number:
                line_min = plate
            if plate.code.tpl_number != 0 and plate.code.tpl_number > line_max.code.tpl_number:
                line_max = plate

    #initialize buckling factors
    chi_c = 1
    rho_p = 1
    sigma_cr_c = 1
    sigma_cr_p = 1
    all_tension = False
    plate_stiffened = True

    #case 1: the whole plate is under tension
    if line_min.sigma_a_red < 0 and line_max.sigma_b_red < 0:
        rho_c = 1
        all_tension = True

    #case 2: unstiffened plate
    elif len(plate_glob.lines) == 1:
        rho_c = 1
        plate_stiffened = False

    #case 3: stiffened plate partly compressed
    else:
        #perform global buckling proof, EC3 1-5, 4.5.2
        if defaults.do_global_plate_buckling == True:
            rho_p, sigma_cr_p = global_plate_buckling.global_plate_buckling(
                cs, plate_glob)
        else:
            rho_p = 1
            sigma_cr_p = 0

        #perform column buckling proof, EC3 1-5, 4.5.3
        if defaults.do_column_plate_buckling == True:
            height_zero_pressure = cs.get_center_z_red(stress=True)
            if data.input_data.get("M_Ed") < 0:
                height_max_pressure = data.input_data.get("h")
            else:
                height_max_pressure = 0

            chi_c, sigma_cr_c = column_buckling.column_buckling(
                plate_glob, side, height_zero_pressure, height_max_pressure)
        else:
            chi_c = 1
            sigma_cr_c = 1

        #interaction according to EC3, 1-5, 4.5.4
        if defaults.do_column_plate_buckling == True and defaults.do_column_plate_buckling == True:
            eta = sigma_cr_p / sigma_cr_c - 1
            if eta > 1:
                eta = 1
            elif eta < 0:
                eta = 0
        elif defaults.do_column_plate_buckling == True and defaults.do_column_plate_buckling == False:
            eta = 0
        elif defaults.do_column_plate_buckling == False and defaults.do_column_plate_buckling == True:
            eta = 1
        else:
            eta = 1

        rho_c = (rho_p - chi_c) * eta * (2 - eta) + chi_c

    string = "\n      4.5.4 Interaction between plate and column buckling"
    string += "\n           all_tension: " + str(all_tension)
    string += "     rho_c = " + str(math.floor(1000 * rho_c) / 1000)
    printing.printing(string)

    #EC 1-5 (4.5) edge plates not reduced by rho_c
    plate_a = cs.get_plate_a(side)
    plate_b = cs.get_plate_b(side)

    #set values to the cross section
    for plate in cs.lines:
        if plate.code.pl_position == side:
            plate.chi_c = chi_c
            plate.sigma_cr_c = sigma_cr_c
            plate.rho_p = rho_p
            plate.sigma_cr_p = sigma_cr_p
            plate.rho_c_a = rho_c
            plate.rho_c_b = rho_c
            if plate == plate_a:
                plate.rho_c_a = 1
            if plate == plate_b:
                plate.rho_c_b = 1

    return cs