Tags: Moodle-Aufgabe Web-App Video

2.4.4.J

Video

Gegeben

Am dargestellten Querschnitt wirkt das Moment \(M_y=10^4\,\mathrm{Ncm}.\) Außerdem ist \(M_z=0 \, \mathrm{Ncm}.\)

Lösung auf einer Seite

Mohr'scher Kreis

Tensor Transformation

a) Flächenträgheitstensor

Berechnen Sie die \((x,y)\)-Komponenten des Flächenträgheitstensors. Zeigen Sie, dass:

\[\begin{split}I_{yy} &= 1{,}1125\bar 3 \, \mathrm{cm}^4\\ I_{yz} &= -0{,}54 \, \mathrm{cm}^4\\ I_{zz} &= 1{,}7205\bar 3 \, \mathrm{cm}^4\\\end{split}\]

Programm zur Berechnung der Komponenten des Flächenträgheitstensors

Siehe Polygon und Dreieck für Lösung ohne Integration.

b) Hauptachsen

Berechnen Sie den Winkel \(\varphi_1\), um den das blaue Hauptachsen-System relativ zum grünen System gedreht ist. Und berechnen Sie die zu diesem Winkel gehörenden Flächenträgheitsmomente. Zeigen Sie, dass:

\[\begin{split}\varphi_1 &\stackrel{\scriptscriptstyle{1{,}0}}{\approx}-60^\circ \\ I_{\bar y \bar y1} &= \max I_{\bar y \bar y} &\stackrel{\scriptscriptstyle{0{,}01}}{\approx} 2{,}04 \, \mathrm{cm}^4 \\ I_{\bar z \bar z1} &= \min I_{\bar y \bar y} &\stackrel{\scriptscriptstyle{0{,}01}}{\approx} 0{,}80 \, \mathrm{cm}^4\end{split}\]

c) Spannungsnulllinie

Zeigen Sie, dass die Funktionsgleichung der Spannungsnulllinie ist:

\[z(y) \stackrel{\scriptscriptstyle{0{,}001}}{\approx}0{,}314\,y\]

d) Spannungen

Berechnen Sie die Spannung \(\sigma\) für Teilchen bei A, B und C. Zeigen Sie, dass:

bei A: \(\quad \sigma \stackrel{\scriptscriptstyle{0{,}1}}{\approx} 139{,}3 \,\mathrm{MPa}\)
bei B: \(\quad \sigma \stackrel{\scriptscriptstyle{0{,}1}}{\approx} 51{,}6 \,\mathrm{MPa}\)
bei C: \(\quad \sigma \stackrel{\scriptscriptstyle{0{,}1}}{\approx}-139{,}3 \,\mathrm{MPa}\)

SymPy

Source Code eines Programms dazu:

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 atan

# 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

# ---

prec = 3

b, B, H, t, My, Mz = symbols("b, B, H, t, My, Mz") 

sub_list = [
    ( b,     1 *cm       ),
    ( B,     2 *cm       ),
    ( H,     2 *cm       ), # 19
    ( t,     2 *mm       ),
    ( My,  10**4 *N*cm   ),
    ( Mz,    0           ),
    ]

def sigma(My, Mz, Iyy, Iyz, Izz, P):
    y, z = P[0], P[1]
    return (beta*z - gama*y)/Delta

def iso(My, Mz, Iyy, Iyz, Izz, s):
    m = gama / beta
    b = s*Delta / beta
    return (m, b)

y2 = B/2 + b/2
z2 = -t/2
A2 = b*(H-t)

pprint("\nIyy / cm⁴:")
Iyy1 = (B+2*b)*H**3/12
Iyy2 = b*(H-t)**3/12
Iyy2 += z2**2*A2
Iyy3 = (B-2*t)*(H-2*t)**3/12
Iyy4 = Iyy2
Iyy = Iyy1 - Iyy2 - Iyy3 - Iyy4
printout(Iyy, unit=cm**4, prec=prec, sub_list=sub_list)

pprint("\nIyz / cm⁴:")
Iyz2 = -y2*z2*A2
Iyz4 =  y2*(-z2)*A2
Iyz = -Iyz2 - Iyz4
printout(Iyz, unit=cm**4, prec=prec, sub_list=sub_list)

pprint("\nIzz / cm⁴:")
Izz1 = H*(B+2*b)**3/12
Izz2 = (H-t)*b**3/12
Izz2 += y2**2*A2
Izz3 = (H-2*t)*(B-2*t)**3/12
Izz4 = Izz2
Izz = Izz1 - Izz2 - Izz3 - Izz4
printout(Izz, unit=cm**4, prec=prec, sub_list=sub_list)

Tyy = Iyy.subs(sub_list)/cm**4
Tyz = Iyz.subs(sub_list)/cm**4
Tzz = Izz.subs(sub_list)/cm**4

pprint("\nTm:")
Tm = (Tyy + Tzz)/2
tmp = Tm
tmp = iso_round(tmp,prec)
pprint(tmp)

pprint("\nTt:")
Tt = (Tyy - Tzz)/2
tmp = Tt
tmp = iso_round(tmp,prec)
pprint(tmp)

pprint("\nr:")
r = sqrt(Tt**2 + Tyz**2)
tmp = r
tmp = iso_round(tmp,prec)
pprint(tmp)

pprint("\nmax Tȳȳ:")
maxT = Tm + r
tmp = maxT
tmp = iso_round(tmp,prec)
pprint(tmp)

pprint("\nmin Tȳȳ:")
minT = Tm - r
tmp = minT
tmp = iso_round(tmp,prec)
pprint(tmp)

pprint("\nφ₁ / deg:")
p1 = atan(Tyz/(Tyy - minT))
tmp = p1
tmp /= deg
tmp = iso_round(tmp,prec)
pprint(tmp)

pprint("\n(vy, vz):")
M = Matrix([My, Mz])
v = M / (N*mm)
c1 = cos(p1)
s1 = sin(p1)
R = Matrix([[c1, s1],[-s1, c1]])
printout(v, unit=1, prec=prec, sub_list=sub_list)

pprint("\n(vȳ, vz̄):")
vb = R*v
printout(vb, unit=1, prec=prec, sub_list=sub_list)

pprint("\n(ȳA, z̄A) / mm:")
r = Matrix([-B/2, H/2])/mm
rb = R*r
printout(rb, unit=1, prec=prec, sub_list=sub_list)

Tyy1 = maxT 
Tzz1 = minT

pprint("\nβ / (Nmm · mm⁴):")
beta = My*Izz - Mz*Iyz
printout(beta, unit=N*mm*mm**4, prec=prec, sub_list=sub_list)

pprint("\nγ / (Nmm · mm⁴):")
gama = Mz*Iyy - My*Iyz
printout(gama, unit=N*mm*mm**4, prec=prec, sub_list=sub_list)

pprint("\nΔ / mm⁸:")
Delta = Iyy*Izz-Iyz*Iyz
printout(Delta, unit=mm**8, prec=prec, sub_list=sub_list)

pprint("\nm = z/y:")
(m, b) = iso(My, Mz, Iyy, Iyz, Izz, 0)
printout(m, unit=1, prec=prec, sub_list=sub_list)

pprint("\nSchiefe Biegung: A, B, C:")
pprint("σ / MPa:")
A = Matrix([-10*mm,  10*mm])
B = Matrix([ 10*mm,   8*mm])
C = Matrix([ 10*mm, -10*mm])

for P in [A, B, C]:
    s = sigma(My, Mz, Iyy, Iyz, Izz, P)
    printout(s, unit=MPa, prec=prec, sub_list=sub_list)

pprint("\nGerade Biegung: A:")
pprint("σ / MPa:")
s = vb[0]/Tyy1*rb[1] - vb[1]/Tzz1 * rb[0]
printout(s, unit=10**4, prec=prec, sub_list=sub_list)

pprint("\nz = m y + b for σ = 50 MPa:")
(m, b) = iso(My, Mz, Iyy, Iyz, Izz, 50*MPa)

pprint("\nm:")
printout(m, unit=1, prec=prec, sub_list=sub_list)

pprint("\nb / mm:")
printout(b, unit=mm, prec=prec, sub_list=sub_list)

Programm ausführen? Dazu:

Copy: Source Code in die Zwischenablage kopieren.
Paste: Source Code ins Eingabefeld hinter [ ]: einfügen.
Play: Knopf ▶ drücken.