Tags: Moodle-Aufgabe

2.4.4.L

Gegeben

../../../../_images/img4.png

Berechnen Sie die Schubspannung auf der türkisfarbenen Faser eines Trapez-Querschnitts.

Gegebene Größen:

  • \(Q = 20 \, \mathrm{kN}\): Querkraft

  • \(s = 2 \, \mathrm{cm}\): Position (ab Oberkante) der Faser.

Verwendete Bezeichnungen / Abkürzungen:

  • \(\bar z\): Position (ab Oberkante) des Flächenmittelpunkts S.

  • \(t\): Länge der Faser.

  • \(I_{yy}\): Flächenträgheitsmoment.

  • \(s_R\): Position (ab Oberkante) des Flächenmittelpunkts der lila Restfläche.

  • \(z_R\): Position (ab S) des Flächenmittelpunkts der Restfläche.

  • \(A_R\): Flächeninhalt der Restfläche.

  • \(S_y = z_R A_R\): Statisches Moment der Restfläche.

a) \(\bar z, t, I_{yy}, s_R\)

Berechnen Sie wie üblich \(\bar z, t, I_{yy}, s_R\). Zeigen Sie, dass:

\[\begin{split}\tfrac{\bar z}{\mathrm{cm}} &= \tfrac{10}{3} \\ \tfrac{t}{\mathrm{cm}} &= 4 \\ \tfrac{I_{yy}}{\mathrm{cm}^4} &= 78 \\ \tfrac{s_R}{\mathrm{cm}}&= \tfrac{22}{21} \\\end{split}\]

Lösung

Berechnung geschieht wie üblich und ist hier nicht gezeigt.

b) \(z_R\) und \(A_R\)

Berechnen Sie \(z_R\) und \(A_R\) Zeigen Sie, dass:

\[\begin{split}\tfrac{z_R}{\mathrm{cm}} &= - \tfrac{16}{7} \\ \tfrac{A_R}{\mathrm{cm}^2} &= 7\end{split}\]

Lösung

\(z_R\) ist die Position des lila Flächenmittelpunkts. Und zwar gezählt ab S und nach unten positiv gezählt.

Um \(z_R\) zu bestimmen, fragt man sich zum Beispiel eine der folgenden Fragen:

  1. Wie weit muss man nach unten gehen, um von S zum lila Flächenmittelpunkt zu kommen?. Dies ist der gesuchte Anteil.

  2. Welchen Anteil nach unten hat ein Pfeil von S zum lila Flächenmittelpunkt? Dies ist der gesuchte Anteil.

  3. Welchen Anteil nach unten hat ein Pfeil in umgekehrter Richtung, also vom lila Flächenmittelpunkt nach S? Dies ist das Negative des gesuchten Anteils.

Antwort auf die 3. Frage: Ein Pfeil vom lila Flächenmittelpunkt nach S hat den Anteil \(\bar z - s_R\) nach unten. Also ist:

\[\begin{split}z_R &= s_r - \bar z \\ \\ \tfrac{z_R}{\mathrm{cm}} &= \tfrac{22}{21} - \tfrac{10}{3} \\ &= \tfrac{22}{21} - \tfrac{70}{21} \\ &= - \tfrac{48}{21} \\ &= - \tfrac{16}{7}\end{split}\]

\(A_R\) wurde schon vorher berechnet. Und es gilt wie behauptet:

\[\tfrac{A_R}{\mathrm{cm}^2} = 7\]

c) \(S_y\)

Berechnen Sie \(S_y\). Zeigen Sie, dass:

\[\tfrac{S_y}{\mathrm{cm}^3} = -16\]

Lösung

Einsetzen von \(z_R\) und \(A_R\) liefert die Behauptung:

\[\begin{split}S_y &= z_R A_R \\ \\ &= - \tfrac{16}{7}\cdot 7 \\ &= -16\end{split}\]

d) \(\tau\)

Berechnen Sie die Schubspannung \(\tau_{xs} = \tau_{sx}\) bzw. kurz:

\[\tau = - \tfrac{Q S_y}{I_{yy} t}\]

Zeigen Sie, dass:

\[\begin{split}\tfrac{\tau}{\mathrm{MPa}} &= \tfrac{400}{39} \\ &\stackrel{\scriptscriptstyle{0{,}01}}{\approx} 10{,}26\end{split}\]

Lösung

Einsetzen liefert:

\[\begin{split}\tau &= - \tfrac{Q S_y}{I_{yy} t} \\ \\ \tfrac{\tau}{\mathrm{kN}\, / \, \mathrm{cm}^2} &= - \tfrac{20\cdot (-16)}{78 \cdot 4} \\ &= \tfrac{20\cdot 16}{78 \cdot 4} \\ &= \tfrac{5\cdot 8}{39 \cdot 1} \\ &= \tfrac{40}{39}\end{split}\]

Außerdem gilt:

\[\begin{split}1 \tfrac{\mathrm{kN}}{\mathrm{cm}^2} &= \tfrac{ 1000 \, \mathrm{N}}{100 \, \mathrm{mm}^2} \\ &= \tfrac{ 10 \, \mathrm{N}}{\mathrm{mm}^2} \\ &= 10 \, \mathrm{MPa}\end{split}\]

Damit ist wie behauptet:

\[\tfrac{\tau}{\mathrm{MPa}} = \tfrac{400}{39}\]

Folgendes Diagramm zeigt die Schubspannung für jede Position \(s\):

../../../../_images/tau.png

Der Extremwert von \(S_y\) ist auf Höhe des Flächenmittelpunkts S, also auf Höhe von \(z=0\). Der Extremwert von \(\tau\) ist etwas darüber.

SymPy

Source Code eines Programms dazu:

import pickle

from sympy.physics.units import kg, m, s
from sympy import pi, S, pprint, symbols, cos, sin, Matrix, Eq, solve, sqrt, exp, simplify
from sympy import diff, roots

from numpy import linspace, array

import matplotlib
matplotlib.set_loglevel("critical")
import matplotlib.pyplot as plt

# Set to German locale to get comma decimal separator
import locale
locale.setlocale(locale.LC_NUMERIC, "de_DE.UTF-8")
plt.rcParams['axes.formatter.use_locale'] = True

# Units:
N = kg * m / s**2
k, M, G = 10**3, 10**6, 10**9
kN = k * N
Pa = N / m**2
MPa, GPa = M * Pa, G * Pa
deg = pi / 180
half = S(1) / 2
# cm        =  m/100
mm = m / 1000

# Rounding:
def iso_round(x, pv):
    try:
        x = float(x)
        tmp = round(x, pv)
    except TypeError:
        x = x.evalf()
        from functools import partial
        func = partial(round, ndigits=pv)
        tmp = x.applyfunc(func)
    return tmp

# Printing:
def printout(x, unit=1, prec="nil", sub_list=[]):
    x = x.subs(sub_list)
    x /= unit
    try:
        x = x.applyfunc(simplify)
    except:
        tmp = x.simplify()
        if tmp != None:
            x = tmp
    if prec != "nil":
        x = iso_round(x, prec)
    pprint(x)
    return

# --- Edit Source = A.3.3. ---
def A_CG(y, z):
    """
    Input: 
        Polygon corners.
    Output:
        Polygon Area: A
        Polygon CG coords: dy, dz
    Ref:
        https://en.wikipedia.org/wiki/Polygon
    """
    L = len(y)
    A = 0
    dy, dz = 0, 0
    for i in range(L):
        k = i + 1
        if k >= L:
            k -= L
        f = y[i] * z[k] - y[k] * z[i]
        A += f
        dy += (y[i] + y[k]) * f
        dz += (z[i] + z[k]) * f
    A /= 2
    dy /= 6 * A
    dz /= 6 * A
    return (A, dy, dz)


# --- Edit Source = A.3.3. ---
def second_moments_of_area(y, z, wrt=None):
    """
    Input: 
        Polygon corners.
    Output:
        Second Moments of Area (Iyy, Iyz, Izz).
    Ref:
        https://en.wikipedia.org/wiki/Second_moment_of_area#Any_polygon
    Bib:
        Excluded/TM-Themen/TM-2/... 
    """
    L = len(y)
    Iyy, Iyz, Izz = 0, 0, 0
    for i in range(L):
        k = i + 1
        if k >= L:
            k -= L
        yi, yk = y[i], y[k]
        zi, zk = z[i], z[k]
        f = yi * zk - yk * zi
        fz = zi * zi + zi * zk + zk * zk
        fy = yi * yi + yi * yk + yk * yk
        fyz = yi * zk + 2 * yi * zi + 2 * yk * zk + yk * zi
        Iyy += f * fz
        Iyz += f * fyz
        Izz += f * fy
    Iyy /= 12
    Iyz /= -24
    Izz /= 12

    if wrt == "CG":
        # Parallel Axis Theorem:
        (A, dy, dz) = A_CG(y, z)
        Iyy -= dz * dz * A
        Iyz -= -dy * dz * A
        Izz -= dy * dy * A
        Iyy = Iyy.simplify()
        Iyz = Iyz.simplify()
        Izz = Izz.simplify()
    return (Iyy, Iyz, Izz)


b, c, h, s, sh = symbols("b, c, h, s, ŝ", positive=True)
cm = symbols("cm", positive=True)

prec = 2

Q = symbols("Q")

(param_b, param_sh_fib, number) = (3 *cm, 2, "001")
# (param_b, param_sh_fib, number) = (3 *cm, 5, "002")
# (param_b, param_sh_fib, number) = (3 *cm, 3.333, "003")
# (param_b, param_sh_fib, number) = (3 *cm, 2.8, "004")
# (param_b, param_sh_fib, number) = (4 *cm, 2, "005")
# (param_b, param_sh_fib, number) = (2 *cm, 2, "006")

b_sub_list = param_b
sh_fib = param_sh_fib

sub_list = [
    ( b, b_sub_list),
    ( c, 6 * cm    ),
    ( h, 6 * cm    ),
    ( Q, 20 * kN   ),
]

# Neuenhofer TH Köln:
# sub_list = [
#     (b, 20 * cm),
#     (c, 40 * cm),
#     (h, 60 * cm),
#     (Q, 1000 * kN),
# ]

# W. Lenz:
# sub_list = [
#     (b, 1 * cm),
#     (c, 2 * cm),
#     (h, 10 * cm),
#     (Q, 10 * kN),
# ]

pprint("\nt(ŝ) / cm:")
t = b + (c - b) * s / h
t = t.subs(s, sh * cm)
printout(t, unit=cm, prec="nil", sub_list=sub_list)
t = t.subs(sub_list)

pts_R = [
    (0, 0),
    (b / 2, 0),
    (t / 2, s),
    (-t / 2, s),
    (-b / 2, 0),
    (0, 0),
]

y_R = [y for y, z in pts_R]
z_R = [z for y, z in pts_R]

pprint("\nsR(ŝ) / cm:")
sR = A_CG(y_R, z_R)[2]
sR = sR.subs(s, sh * cm)
printout(sR, unit=cm, prec="nil", sub_list=sub_list)
sR = sR.subs(sub_list)
sR = sR.simplify()

pts = [
    (0, 0),
    (b / 2, 0),
    (c / 2, h),
    (-c / 2, h),
    (-b / 2, 0),
    (0, 0),
]

y = [y for y, z in pts]
z = [z for y, z in pts]

pprint("\nz̄ / cm:")
zb = A_CG(y, z)[2]
printout(zb, unit=cm, prec="nil", sub_list=sub_list)
zb = zb.subs(sub_list)

pprint("\nIyy / cm⁴:")
Iyy = second_moments_of_area(y, z, wrt="CG")[0]
printout(Iyy, unit=cm**4, prec="nil", sub_list=sub_list)
Iyy = Iyy.subs(sub_list)

pprint("\nzR(ŝ) / cm:")
zR = - zb + sR
printout(zR, unit=cm, prec="nil", sub_list=sub_list)
zR = zR.subs(sub_list)

pprint("\nAR(ŝ) / cm²:")
AR = A_CG(y_R, z_R)[0]
AR = AR.subs(s, sh * cm)
printout(AR, unit=cm**2, prec="nil", sub_list=sub_list)
AR = AR.subs(sub_list)

pprint("\nSy(ŝ) / cm³:")
Sy = zR * AR
printout(Sy, unit=cm**3, prec="nil", sub_list=sub_list)
Sy = Sy.subs(sub_list)
Sy = Sy.simplify()
pprint("\nτ(ŝ) / MPa:")
tau = - Q * Sy / (Iyy * t)
tau = tau.subs(sub_list)
tau /= MPa
tau = tau.subs(m, 100*cm) #  1 m = 100 cm
tau = tau.simplify()
pprint(tau)

pprint("\ns* / cm:")
fun = Sy/t / cm**2
dt = diff(tau, sh)
dt = dt.simplify()
ss = solve(dt, sh)[2]
pprint(iso_round(ss, 2))

pprint("\nz* / cm:")
zs = ss - zb.subs(sub_list) / cm
pprint(iso_round(zs, 2))

pprint("\nτ(ŝ) / MPa:")
pprint("\nfor s=0:")
printout(tau.subs(sh, 0), unit=1, prec=prec, sub_list=sub_list)

pprint("\nfor s=h:")
printout(tau.subs(sh, h / cm), unit=1, prec=prec, sub_list=sub_list)

pprint("\nfor s=z̄:")
printout(tau.subs(sh, zb / cm), unit=1, prec=prec, sub_list=sub_list)

pprint("\nfor s=s*:")
printout(tau.subs(sh, ss), unit=1, prec=prec, sub_list=sub_list)

# Save to database:
# Given:
b_cm = b.subs(sub_list) / cm
b_cm = float(b_cm)

c_cm = c.subs(sub_list) / cm
c_cm = float(c_cm)

h_cm = h.subs(sub_list) / cm
h_cm = float(h_cm)

Q_kN = Q.subs(sub_list) / kN
Q_kN = float(Q_kN)

# Calculated:
zb_cm = zb.subs(sub_list) / cm
zb_cm = float(zb_cm)

ts_cm = b_cm + (c_cm - b_cm) * sh_fib / h_cm
ts_cm = float(ts_cm)

sR_cm = sR.subs(sh, sh_fib) / cm
sR_cm = float(sR_cm)

zR_cm = zR.subs(sh, sh_fib) / cm
zR_cm = float(zR_cm)

AR_cm2 = AR.subs(sh, sh_fib) / cm**2
AR_cm2 = float(AR_cm2)



pprint("\nfor given ŝ = "+str(sh_fib)+":")
tau_MPa = tau.subs(sh, sh_fib)
pprint(iso_round(tau_MPa, prec))
tau_MPa = float(tau_MPa)

db = {
    "b_cm":   b_cm,
    "c_cm":   c_cm,
    "h_cm":   h_cm,
    "Q_kN":   Q_kN,
    "sh_fib":  float(sh_fib),
    #
    "zb_cm":    zb_cm,
    "Iyy_cm4":  float(Iyy/cm**4),
    "ts_cm":    ts_cm,
    "sR_cm":    sR_cm,
    "zR_cm":    zR_cm,
    "AR_cm2":   AR_cm2,
    "tau_MPa":  tau_MPa,
    "ss_cm":    float(ss),
}

pickle.dump(db, open("db.pickle_" + number, "wb"))

pprint("\nPlotting:")
s_space = linspace(0, float(h_cm), 50)
z_space = s_space - zb_cm
t_space = []
mSy_space = []
for si in s_space:
    t = tau.subs(sh, si)
    t = t.subs(sub_list)
    t_space.append(t)
    Syi = Sy.subs(sh, si)
    Syi /= cm**3
    mSy_space.append(-Syi)
    
mSymax = float(max(mSy_space))
fig, ax1 = plt.subplots()

ax1.minorticks_on()
ax1.grid(visible=True)
ax1.set_ylabel("z / cm")
ax1.set_ylim(h_cm - zb_cm, -zb_cm)
ax1.set_xlim(0, mSymax)

ax2 = ax1.twinx()
ax2.grid(visible=True, color="#00e4e4", axis="y")
ax2.set_ylabel("s / cm")
ax2.set_ylim(h_cm, 0)

ax1.plot(array( t_space),z_space, color="#f01111", label="$\\tau \\,  /  \\, \\mathrm{MPa}$")
ax1.plot(array(mSy_space),z_space, color="#0032ff", label="$- S_y \\,  /  \\, \\mathrm{cm}^3$")
ax1.legend()
plt.savefig("tau.svg", transparent=True)
plt.show()

Programm ausführen? Dazu:

  1. Copy: Source Code in die Zwischenablage kopieren.

  2. Paste: Source Code ins Eingabefeld hinter [ ]: einfügen.

  3. Play: Knopf ▶ drücken.