1.5.C

Gegeben

Symbole:

\[0^\circ<\alpha<90^\circ, a, b, q\]

Berechnen Sie die Lagerreaktionen. Gehen Sie wie folgt vor.

a) Resultierende

Verwenden Sie die gegebenen Symbole: Berechnen Sie damit die Resultierende \(R\) der verteilten Kraft und die Position ihrer Wirkungslinie.

Lösung

Siehe Freischnitt im nächsten Aufgabenteil.

b) Lagerreaktionen

Berechnen Sie sämtliche Lagerreaktionen für die gegebenen Symbole.

Lösung: Variante 1

Lösung:

\[\begin{split}A_{h} &= - \tfrac{b q t_{\alpha}}{3} \\ B_{v} &= \tfrac{4 b q}{3} \\ C_{h} &= - \tfrac{b q t_{\alpha}}{3} \\ C_{v} &= - \tfrac{b q}{3} \\ D_{h} &= - \tfrac{b q t_{\alpha}}{3} \\ D_{v} &= - \tfrac{b q}{3}\end{split}\]

Lösung: Variante 2

Lösung:

\[\begin{split}A_{h} &= - \tfrac{b q t_{\alpha}}{3} \\ B_{v} &= \tfrac{4 b q}{3} \\ D &= - \tfrac{b q}{3 c_{\alpha}}\end{split}\]

Das liefert dieselben Anteile horizontal/vertikal wie bei Variante 1, nämlich:

\[\begin{split}D_h &= D s_\alpha \\ &= - \tfrac{b q t_{\alpha}}{3} \\ D_v &= D c_\alpha \\ &= - \tfrac{b q}{3}\end{split}\]

c) Ergebnisse für Größen

Berechnen Sie die Lagerreaktionen bei A und B für die folgenden gegebenen Größen, und zwar in \(\mathrm{N}\) (Newton) und gerundet auf Rundestellenwert \(1\).

\[\begin{split}\alpha &= 30^\circ \\ a &= 1{,}5 \,\mathrm{m} \\ b &= 1 \,\mathrm{m} \\ q &= 500 \tfrac{\mathrm{N}}{\mathrm{m}}\end{split}\]

Lösung

Einsetzen liefert:

\[\begin{split}A_{h} &\stackrel{\scriptscriptstyle{1{,}0}}{\approx}-96 \,\mathrm{N} \\ B_{v} &\stackrel{\scriptscriptstyle{1{,}0}}{\approx}667 \,\mathrm{N}\end{split}\]

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, integrate, simplify
from sympy import python
import pickle

# 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

# 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)
    # old:
    # except:
    # new:
    except AttributeError:
        tmp = x.simplify()
        if tmp is not None:
            x = tmp
    if prec != "nil":
        x = iso_round(x, prec)
    pprint(x)
    return


# ---

fac, alpha, a, b, q = symbols("fac, alpha, a, b, q")

# # Parameters:
# sub_list=[
#     ( alpha,  30  *deg      ),
#     ( a,      S(3)/2   *m   ),
#     ( b,      1   *m        ),
#     ( q,      600 *N/m      ),
#     ]


# # 1:
# fac = S(1)
# # 2:
# fac = S(2)/3
# # 3:
# fac = S(1)/3
# # 4:
# fac = S(1)/2

# # HA:
# sub_list=[
#     ( alpha,  45  *deg      ),
#     ( a,      S(3)/2   *m   ),
#     ( b,      1   *m        ),
#     ( q,      600 *N/m      ),
#     ]
# fac = S(1)/4

# 1
sub_list=[
    ( fac,     S(1)         ),
    ( alpha,  30  *deg      ),
    ( a,      S(3)/2   *m   ),
    ( b,      1   *m        ),
    ( q,      600 *N/m      ),
    ]
# 2
sub_list=[
    ( fac,     S(2)/3       ),
    ( alpha,  30  *deg      ),
    ( a,      S(3)/2   *m   ),
    ( b,      1   *m        ),
    ( q,      600 *N/m      ),
    ]
# 3
sub_list=[
    ( fac,     S(1)/3       ),
    ( alpha,  30  *deg      ),
    ( a,      S(3)/2   *m   ),
    ( b,      1   *m        ),
    ( q,      600 *N/m      ),
    ]
# 4
sub_list=[
    ( fac,     S(1)/2       ),
    ( alpha,  30  *deg      ),
    ( a,      S(1)/2   *m   ),
    ( b,      1   *m        ),
    ( q,      600 *N/m      ),
    ]
# Exam:
sub_list=[
    ( fac,    S(3)/4        ),
    ( alpha,  45  *deg      ),
    ( a,      S(3)/2   *m   ),
    ( b,      1   *m        ),
    ( q,      100 *N/m      ),
    ]

qL = fac*q
qR = (1-fac)*q

x = symbols("x")
qx = qL + (qR - qL)*x/(2*b)
R = integrate(qx, (x, 0, 2*b))
xR = integrate(x*qx/R, (x, 0, 2*b))

pprint("\nR / N, xR / m:")
printout(R, unit=N, prec="nil", sub_list=sub_list)
printout(xR, unit=m, prec="nil", sub_list=sub_list)

Ah, Bv, Ch, Cv, Dh, Dv = symbols("Ah, Bv, Ch, Cv, Dh, Dv")

pprint("\nVar. 1:")
ca, sa = cos(alpha), sin(alpha)

# Equilibrium conditions:
eq1 = Eq( 0, Ah - Ch             )
eq2 = Eq( 0, Bv + Cv - R         )
eq3 = Eq( 0, xR*R - b*Bv -2*b*Cv )

eq4 = Eq( 0, Ch - Dh             )
eq5 = Eq( 0, Cv - Dv             )
eq6 = Eq( 0, - Dh*ca + Dv*sa     )

eqns = [eq1,eq2,eq3,eq4,eq5,eq6]
unknowns = [Ah, Bv, Ch, Cv, Dh, Dv]
sol = solve(eqns, unknowns)
pprint(sol)

pprint("\nVar. 2:")
D = symbols('D')
eq1 = Eq( 0, Ah - D*sa          )
eq2 = Eq( 0, R - Bv - D*ca      )
eq3 = Eq( 0, -b*Bv + (2*b-xR)*R ) 

eqns = [eq1, eq2, eq3]
unknowns = [Ah, Bv, D]
sol = solve(eqns, unknowns)

Ah = sol[Ah]
Bv = sol[Bv]
printout(Ah, unit=1, prec="nil")
printout(Bv, unit=1, prec="nil")

printout(Ah, unit=N, prec=20, sub_list=sub_list)
printout(Bv, unit=N, prec=20, 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.