====== Variables ======

This chapter is describing the available variables and their basis.

===== material properties =====

moment of inertia
$$ Iy = pi \frac{(Do^4 - Di^4)}{64} $$
$$ Iz = Iy $$

torsional constant in cm⁴
$$ J = pi \frac{(Do^4 - Di^4)}{32} $$

cross-sectional area in cm²
$$ A = ((pi * (Do*0.5)^2) - (pi * (Di*0.5)^2)) $$

weight of profile in kg/m
$$ kg_A =  A*d * 0.1 $$

$$ ir = sqrt(\frac{Iy}{A}) $$


===== derived from PyNite =====

<code python [enable_line_numbers="true"]>
L = truss_member.L()
T = truss_member.T()
</code>

This basic forces are evaluated at 11 positions within each member for every calculated frame.

<code python [enable_line_numbers="true"]>

axial = []
moment_y = []
moment_z = []
shear_y = []
shear_z = []
torque = []

for i in range(11): # get the forces at 11 positions and
    x = L/10*i

    axial_pos = truss_member.axial(x) * (-1) # Druckkraft minus
    axial.append(axial_pos)

    moment_y_pos = truss_member.moment("My", x)
    moment_y.append(moment_y_pos)

    moment_z_pos = truss_member.moment("Mz", x)
    moment_z.append(moment_z_pos)

    shear_y_pos = truss_member.shear("Fy", x)
    shear_y.append(shear_y_pos)

    shear_z_pos = truss_member.shear("Fz", x)
    shear_z.append(shear_z_pos)

    torque_pos = truss_member.torque(x)
    torque.append(torque_pos)

member["axial"][frame] = axial
member["moment_y"][frame] = moment_y
member["moment_z"][frame] = moment_z
member["shear_y"][frame] = shear_y
member["shear_z"][frame] = shear_z
member["torque"][frame] = torque
</code>

===== buckling =====

<code python [enable_line_numbers="true"]>
# for round sections
member["ir"][frame] = sqrt(J/A)

# modulus from the moments of area
member["Wy"][frame] = member["Iy"][frame]/(Do/2)

# polar modulus of torsion
member["WJ"][frame] = J/(Do/2)
</code>

calculation of the longitudinal stresses
<code python [enable_line_numbers="true"]>
long_stress = []
for i in range(11): # get the stresses at 11 positions and
    moment_h = sqrt(moment_y[i]**2+moment_z[i]**2)
    if axial[i] > 0:
        s = axial[i]/A + moment_h/member["Wy"][frame]
    else:
        s = axial[i]/A - moment_h/member["Wy"][frame]
    long_stress.append(s)

# get max stress of the beam
# (can be positive or negative)
member["long_stress"][frame] = long_stress
member["max_long_stress"][frame] = basics.return_max_diff_to_zero(long_stress)
</code>

calculation of the shear stresses from shear force
(always positive)
<code python [enable_line_numbers="true"]>
tau_shear = []
shear_h = []
for i in range(11): # get the stresses at 11 positions and
    # shear_h
    s_h = sqrt(shear_y[i]**2+shear_z[i]**2)
    shear_h.append(s_h)

    tau = 1.333 * s_h/A # for pipes
    tau_shear.append(tau)

member["shear_h"][frame] = shear_h

# get max shear stress of shear force of the beam
# shear stress is mostly small compared to longitudinal
# in common architectural usage and only importand with short beam lenght
member["tau_shear"][frame] = tau_shear
member["max_tau_shear"][frame] = max(tau_shear)
</code>

Calculation of the torsion stresses
(always positiv)
<code python [enable_line_numbers="true"]>
tau_torsion = []
for i in range(11): # get the stresses at 11 positions and
    tau = abs(torque[i]/member["WJ"][frame])
    tau_torsion.append(tau)

# get max torsion stress of the beam
member["tau_torsion"][frame] = tau_torsion
member["max_tau_torsion"][frame] = max(tau_torsion)

# torsion stress is mostly small compared to longitudinal
# in common architectural usage

# calculation of the shear stresses form shear force and torsion
# (always positiv)
sum_tau = []
for i in range(11): # get the stresses at 11 positions and
    tau = tau_shear[i] + tau_torsion[i]
    sum_tau.append(tau)
   
member["sum_tau"][frame] = sum_tau
member["max_sum_tau"][frame] = max(sum_tau)
</code>

combine shear and torque
<code python [enable_line_numbers="true"]>
sigmav = []
for i in range(11): # get the stresses at 11 positions and
    sv = sqrt(long_stress[i]**2 + 3*sum_tau[i]**2)
    sigmav.append(sv)

member["sigmav"][frame] = sigmav
</code>

<code python [enable_line_numbers="true"]>
member["max_sigmav"][frame] = max(sigmav)
</code>

check out: http://www.bs-wiki.de/mediawiki/index.php?title=Festigkeitsberechnung

<code python [enable_line_numbers="true"]>
member["sigma"][frame] = member["long_stress"][frame]
member["max_sigma"][frame] = member["max_long_stress"][frame]
</code>

===== overstress =====

<code python [enable_line_numbers="true"]>
member["overstress"][frame] = False

# check overstress and add 1.05 savety factor
safety_factor = 1.05
if abs(member["max_tau_shear"][frame]) > safety_factor*member["acceptable_shear"]:
    member["overstress"][frame] = True

if abs(member["max_tau_torsion"][frame]) > safety_factor*member["acceptable_torsion"]:
    member["overstress"][frame] = True

if abs(member["max_sigmav"][frame]) > safety_factor*member["acceptable_sigmav"]:
    member["overstress"][frame] = True

# buckling
if member["axial"][frame][0] < 0: # nur für Druckstäbe, axial kann nicht flippen?
    member["lamda"][frame] = L*0.5/member["ir"][frame] # für eingespannte Stäbe ist die Knicklänge 0.5 der Stablänge L, Stablänge muss in cm sein !
    if member["lamda"][frame] > 20: # für lamda < 20 (kurze Träger) gelten die default-Werte)
        kn = member["knick_model"]
        function_to_run = poly1d(polyfit(material.kn_lamda, kn, 6))
        member["acceptable_sigma_buckling"][frame] = function_to_run(member["lamda"][frame])
        if member["lamda"][frame] > 250: # Schlankheit zu schlank
            member["overstress"][frame] = True
        if safety_factor*abs(member["acceptable_sigma_buckling"][frame]) > abs(member["max_sigma"][frame]): # Sigma
            member["overstress"][frame] = True

    else:
        member["acceptable_sigma_buckling"][frame] = member["acceptable_sigma"]

# without buckling
else:
    member["acceptable_sigma_buckling"][frame] = member["acceptable_sigma"]
    member["lamda"][frame] = None # to avoid missing KeyError


if abs(member["max_sigma"][frame]) > safety_factor*member["acceptable_sigma"]:
    member["overstress"][frame] = True

===== lever arm =====

lever_arm = []
moment_h = []
for i in range(11):
    # moment_h
    m_h = sqrt(moment_y[i]**2+moment_z[i]**2)
    moment_h.append(m_h)

    # to avoid division by zero
    if member["axial"][frame][i] < 0.1:
        lv = m_h / 0.1
    else:
        lv = m_h / member["axial"][frame][i]

    lv = abs(lv) # absolute highest value within member
    lever_arm.append(lv)

member["moment_h"][frame] = moment_h
member["lever_arm"][frame] = lever_arm
member["max_lever_arm"][frame] = max(lever_arm)
</code>

===== utilization =====

<code python [enable_line_numbers="true"]>
member["utilization"][frame] = abs(member["max_long_stress"][frame] / member["acceptable_sigma_buckling"][frame])

# Einführung in die Technische Mechanik - Festigkeitslehre, H.Balke, Springer 2010
normalkraft_energie=[]
moment_energie=[]
strain_energy = []

for i in range(10): # get the energie at 10 positions for 10 section
    # Berechnung der strain_energy für Normalkraft
    ne = (axial[i]**2)*(L/10)/(2*member["E"]*A)
    normalkraft_energie.append(ne)

    # Berechnung der strain_energy für Moment
    moment_hq = moment_y[i]**2+moment_z[i]**2
    me = (moment_hq * L/10) / (member["E"] * member["Wy"][frame] * Do)
    moment_energie.append(me)

    # Summe von Normalkraft und Moment-Verzerrunsenergie
    value = ne + me
    strain_energy.append(value)

member["strain_energy"][frame] = strain_energy
member["normal_energy"][frame] = normalkraft_energie
member["moment_energy"][frame] = moment_energie
</code>

===== deflection =====

<code python [enable_line_numbers="true"]>
deflection = []

# --> taken from pyNite VisDeformedMember: https://github.com/JWock82/PyNite
scale_factor = 10.0

cos_x = array([T[0,0:3]]) # Direction cosines of local x-axis
cos_y = array([T[1,0:3]]) # Direction cosines of local y-axis
cos_z = array([T[2,0:3]]) # Direction cosines of local z-axis

DY_plot = empty((0, 3))
DZ_plot = empty((0, 3))

for i in range(11):
    # Calculate the local y-direction displacement
    dy_tot = truss_member.deflection('dy', L/10*i)

    # Calculate the scaled displacement in global coordinates
    DY_plot = append(DY_plot, dy_tot*cos_y*scale_factor, axis=0)

    # Calculate the local z-direction displacement
    dz_tot = truss_member.deflection('dz', L/10*i)

    # Calculate the scaled displacement in global coordinates
    DZ_plot = append(DZ_plot, dz_tot*cos_z*scale_factor, axis=0)

# Calculate the local x-axis displacements at 20 points along the member's length
DX_plot = empty((0, 3))

Xi = truss_member.i_node.X
Yi = truss_member.i_node.Y
Zi = truss_member.i_node.Z

for i in range(11):
    # Displacements in local coordinates
    dx_tot = [[Xi, Yi, Zi]] + (L/10*i + truss_member.deflection('dx', L/10*i)*scale_factor)*cos_x

    # Magnified displacements in global coordinates
    DX_plot = append(DX_plot, dx_tot, axis=0)

# Sum the component displacements to obtain overall displacement
D_plot = DY_plot + DZ_plot + DX_plot

# <-- taken from pyNite VisDeformedMember: https://github.com/JWock82/PyNite

# add to results
for i in range(11):
    x = D_plot[i, 0] * 0.01
    y = D_plot[i, 1] * 0.01
    z = D_plot[i, 2] * 0.01

    deflection.append([x,y,z])

member["deflection"][frame] = deflection
</code>