R2.A
Video
Klassische Lösung
siehe 2.1.Q

Gegebene Symbole: \(F, l, E, A.\)
Untersuchen Sie die Struktur aus drei Stäben mit E-Modul \(E\) und Querschnittsfläche \(A\). Verwenden Sie die Bezeichnungen aus Stab-Element R2. Gehen Sie wie folgt vor:
1. Elemente und Knoten
Das System besteht aus den drei Stab-Elementen 1, 2 und 3 mit Einheitsvektoren \(\boldsymbol e_1, \boldsymbol e_2, \boldsymbol e_3.\) Füllen Sie folgende Tabelle aus:
Element |
Länge |
Knoten |
Winkelposition |
---|---|---|---|
1 |
|||
2 |
|||
3 |
2. Erweiterte Matrizen
Berechnen Sie:
die erweiterten Element-Steifigkeitsmatrizen im „Element-Format“ \(k_1^|, k_2^|, k_3^|\).
die erweiterten Element-Steifigkeitsmatrizen im „System-Format“ \(K^|_1, K^|_2, K^|_3\) mit dem Faktor \(\tfrac{EA}{\sqrt 2 l}\) vor jeder der drei Matrizen.
3. Erweiterte System-Steifigkeitsmatrix
Berechnen Sie die erweiterte System-Steifigkeitsmatrix \(K^|\).
Lösung
4. Randbedingungen und Lineares System
Seien die Knoten-Verschiebungen und die Knoten-Kräfte in den folgenden Spaltenmatrizen \(u\) und \(f\) zusammengefasst:
Passen Sie die Spaltenmatrizen \(u\) und \(f\) an die geometrischen und physikalischen Randbedingungen an. Und notieren Sie die folgende Gleichung mit den angepassten Spaltenmatrizen.
Lösung
5. Verschiebungen
Berechnen Sie:
Für folgende Größen:
Berechnen Sie außerdem \(u_{4y}\) in \(\mathrm{mm}\) (Millimeter) und gerundet auf Rundestellenwert \(0{,}0001\):
Die 7. und 8. Gleichung des Gleichungssystems liefern:Lösung
6. Lagerreaktionen

Berechnen Sie für dieselben Größen die \((x,y)\)-Komponenten der Lagerreaktionen. Und zwar in \(\mathrm{N}\) (Newton) und gerundet auf Rundestellenwert \(0{,}1\):
Einsetzen der berechneten Verschiebungen in das Gleichungssystem liefert: Die ersten beiden Gleichungen des Gleichungssystems lauten: Dies ist äquivalent zu den folgenden beiden Gleichungen: Einsetzen der zuvor berechneten Verschiebungen liefert: Dasselbe neu aufgeschrieben ist: Vertauschen der Seiten und Umformen liefert: Die Einheit der Lagerreaktionen ist korrekt. Denn die Lagerreaktionen sind Kräfte. Die x-Komponenten ist genauso groß ist wie die y-Komponente. Und das erwartet man auch. Denn die Resultierende muss genau in Richtung des Stabs 1 zeigen. Das Vorzeichen der Komponenten ist plausibel. Denn man erwartet, dass das Lager für positives \(F\) eine Kraft wirkt die „nach rechts oben“ wirkt. Die Lagerreaktionen an den Knoten 2 und 3 werden ganz ähnlich berechnet. Einsetzen der gegebenen Größen liefert:Lösung
Details zur Berechnung der Lagerreaktionen an Knoten 1
7. Stabkräfte
Berechnen Sie für dieselben Größen die Stabkräfte. Und zwar in \(\mathrm{N}\) (Newton) und gerundet auf Rundestellenwert \(0{,}1\):
Freischneiden und Auswertung der Gleichgewichtsbedingungen liefert Gleichungen, aus denen die Stabkräfte berechnet werden können. Einsetzen der gegebenen ‚Größen‘ liefert: Eine andere Methode zur Stabkraft-Berechnung siehe hier.Lösung
8. Symmetrie
Zeigen Sie, dass Sie bei Ausnutzung der Symmetrie dieselbe Lösung erhalten.
Symmetrie Achsensymmetrie und Betrachtung der linken Hälfte. Kraft oben: \(\tfrac 12 F\). Querschnitt Stab 2: \(\tfrac 12 EA\) Zugkraft in Stab 2: \(S_2'\). Loslager bei Knoten 4 erzwingt: \(u_{4x}=0\). Steifigkeitsmatrizen: Lineares System: Ergebnisse: Dies ist dieselbe Lösung wie vorher. Weil Stab 2 halbiert wurde, sind die Lagerreaktionen bei Knoten 2 nur halb so groß wie beim Modell ohne Ausnutzung der Symmetrie.Lösung
Nachfolgend ein Programm, dass Sie ausführen können: Auf dem PC z.B. mit Anaconda. Im Browser (online) in drei Schritten: Copy: Source Code in die Zwischenablage kopieren. Paste: Source Code als Python-Notebook einfügen z.B. auf: JupyterLite oder JupyterLab oder Play: Ausführen. Statt SymPy lieber anderes CAS (Computeralgebrasystem) verwenden? Eine Auswahl verschiedener CAS gibt es hier.SymPy
from sympy.physics.units import *
from sympy import *
# Units:
(mm, cm) = ( m/1000, m/100 )
kN = 10**3*newton
Pa = newton/m**2
MPa = 10**6*Pa
GPa = 10**9*Pa
deg = pi/180
half = S(1)/2
# Rounding:
import decimal
from decimal import Decimal as DX
from copy import deepcopy
def iso_round(obj, pv,
rounding=decimal.ROUND_HALF_EVEN):
import sympy
"""
Rounding acc. to DIN EN ISO 80000-1:2013-08
place value = Rundestellenwert
"""
assert pv in set([
# place value # round to:
"1", # round to integer
"0.1", # 1st digit after decimal
"0.01", # 2nd
"0.001", # 3rd
"0.0001", # 4th
"0.00001", # 5th
"0.000001", # 6th
"0.0000001", # 7th
"0.00000001", # 8th
"0.000000001", # 9th
"0.0000000001", # 10th
])
objc = deepcopy(obj)
try:
tmp = DX(str(float(objc)))
objc = tmp.quantize(DX(pv), rounding=rounding)
except:
for i in range(len(objc)):
tmp = DX(str(float(objc[i])))
objc[i] = tmp.quantize(DX(pv), rounding=rounding)
return objc
# Header ends here.
# ---
def k(phi):
""" computes entries inside stiffness matrix """
# Input: phi:
# - measured at first element node
# - counted positively about z-axis
# - starts at x-axis
# - ends at rod axis between first
# and second element node
(c, s) = ( cos(phi), sin(phi) )
(cc, ss, sc) = ( c*c, s*s, s*c)
return Matrix(
[
[ cc, sc, -cc, -sc],
[ sc, ss, -sc, -ss],
[-cc, -sc, cc, sc],
[-sc, -ss, sc, ss],
])
def assemble(n,k,i,j):
""" Add Element Stiffness Matrix
into System Stiffness Matrix"""
# n: Number of Nodes
# k: Element Stiffness Matrix
# (i, j): Node Number of (First, Second) Element Node
assert i in range(1,10)
assert j in range(1,10)
K = zeros(2*n,2*n)
# swap if necessary:
if (i < j):
I, J = (i-1)*2, (j-1)*2
else:
I, J = (j-1)*2, (i-1)*2
K[I:I+2, I:I+2]+=k[0:2,0:2]
K[I:I+2, J:J+2]+=k[0:2,2:4]
K[J:J+2, I:I+2]+=k[2:4,0:2]
K[J:J+2, J:J+2]+=k[2:4,2:4]
return K
F, l, E, A = var("F, l, E, A")
EA = E*A
r = sqrt(2)
sub_list = [
( F, 5 *kN ),
( E, 200 *GPa ),
( A, 25 *mm**2 ),
( l, 1707 *mm ),
]
# Element stiffness matrices:
p1, p2, p3 = 45 *deg, 90 *deg, 135 *deg
l1, l2, l3 = r*l, l, r*l
k1 = EA/l1 * k(p1)
# k2 see below
k3 = EA/l3 * k(p3)
symm = True
symm = False
if not symm:
k2 = EA/l2 * k(p2)
K1 = assemble(4, k1,4,1)
K2 = assemble(4, k2,4,2)
K3 = assemble(4, k3,4,3)
pprint("\nK1 / (EA / √2 l):")
pprint( K1 / (EA/(r*l)) )
pprint("\nK2 / (EA / √2 l):")
pprint( K2 / (EA/(r*l)) )
pprint("\nK3 / (EA / √2 l):")
pprint( K3 / (EA/(r*l)) )
# System stiffness matrix:
pprint("\nK / (EA / √2 l):")
K = K1 + K2 + K3
tmp = K
tmp /= EA / (r*l)
tmp = tmp.applyfunc(simplify)
pprint(tmp)
u1x,u1y,u2x,u2y,u3x,u3y,u4x,u4y=var('u1x,u1y,u2x,u2y,u3x,u3y,u4x,u4y')
F1x,F1y,F2x,F2y,F3x,F3y,F4x,F4y=var("F1x,F1y,F2x,F2y,F3x,F3y,F4x,F4y")
u = Matrix([ 0 , 0 , 0 , 0 , 0 , 0 ,u4x,u4y])
f = Matrix([F1x,F1y,F2x,F2y,F3x,F3y, 0 ,-F ])
unks = [u4x,u4y,F1x,F1y,F2x,F2y,F3x,F3y]
eq = Eq(K*u, f)
sol = solve(eq,unks)
u4x,u4y,F1x,F1y,F2x,F2y,F3x,F3y = \
sol[u4x],sol[u4y],sol[F1x],sol[F1y],sol[F2x],sol[F2y],sol[F3x],sol[F3y]
pprint("\n(u4x, u4y) / (Fl / EA):")
tmp = Matrix([u4x, u4y])
tmp /= F*l/EA
tmp = tmp.applyfunc(simplify)
pprint(tmp)
pprint("\nu4y / mm:")
tmp = u4y
tmp = tmp.subs(sub_list)
tmp /= mm
tmp = iso_round(tmp,"0.0001")
pprint(tmp)
pprint("\n(F1x, F1y) / F:")
rf = Matrix([F1x, F1y])
tmp = rf / F
tmp = tmp.applyfunc(simplify)
pprint(tmp)
pprint("\n(F1x, F1y) / N:")
tmp = rf.subs(sub_list)
tmp /= newton
tmp = iso_round(tmp, "0.1")
pprint(tmp)
pprint("\n(F2x, F2y) / F:")
rf = Matrix([F2x, F2y])
tmp = rf / F
tmp = tmp.applyfunc(simplify)
pprint(tmp)
pprint("\n(F2x, F2y) / N:")
tmp = rf.subs(sub_list)
tmp /= newton
tmp = iso_round(tmp, "0.1")
pprint(tmp)
pprint("\n(F3x, F3y) / F:")
rf = Matrix([F3x, F3y])
tmp = rf / F
tmp = tmp.applyfunc(simplify)
pprint(tmp)
pprint("\n(F3x, F3y) / N:")
tmp = rf.subs(sub_list)
tmp /= newton
tmp = iso_round(tmp, "0.1")
pprint(tmp)
# Section Forces
pprint("\n(S1, S2, S3) / N:")
tmp = "("
c1, c3 = cos(p1), cos(p3)
S1, S2, S3 = - F1x / c1, - F2y, - F3x / c3
for S in [S1, S2, S3]:
tmp = S
tmp = tmp.subs(sub_list)
tmp /= newton
tmp = iso_round(tmp, "0.1")
pprint(tmp)
elif symm:
k2 = EA/2/l2 * k(p2)
K1 = assemble(3,k1,3,1)
K2 = assemble(3,k2,3,2)
pprint("\nK1 / (EA / √2 l):")
tmp = K1 / (EA/(r*l))
tmp = tmp.applyfunc(simplify)
pprint(tmp)
pprint("\nK2 / (EA / √2 l):")
tmp = K2 / (EA/(r*l))
tmp = tmp.applyfunc(simplify)
pprint(tmp)
# System stiffness matrix:
pprint("\nK / (EA / √2 l):")
K = K1 + K2
tmp = K
tmp /= EA / (r*l)
tmp = tmp.applyfunc(simplify)
pprint(tmp)
u1x,u1y, u2x, u2y,u4x,u4y = var('u1x,u1y, u2x, u2y,u4x,u4y')
F1x,F1y,F2px,F2py,F4x,F4y = var("F1x,F1y,F2px,F2py,F4x,F4y")
u = Matrix([ 0 , 0 , 0 , 0 , 0 , u4y])
f = Matrix([F1x,F1y, F2px,F2py, F4x ,-F/2])
unks = [u4y,F1x,F1y,F2px,F2py,F4x]
eq = Eq(K*u, f)
sol = solve(eq,unks)
pprint(sol)
u4y,F1x,F1y,F2px,F2py,F4x = \
sol[u4y],sol[F1x],sol[F1y],sol[F2px],sol[F2py],sol[F4x]
pprint("\nu4y / (Fl / EA):")
tmp = u4y
tmp /= F*l/EA
tmp = tmp.simplify()
pprint(tmp)
pprint("\n(F2'x, F2'y) / F:")
tmp = Matrix([F2px, F2py])
tmp /= F
tmp = tmp.applyfunc(simplify)
pprint(tmp)
K1 / (EA / √2 l):
⎡1/2 1/2 0 0 0 0 -1/2 -1/2⎤
⎢ ⎥
⎢1/2 1/2 0 0 0 0 -1/2 -1/2⎥
⎢ ⎥
⎢ 0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎢ 0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎢ 0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎢ 0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎢-1/2 -1/2 0 0 0 0 1/2 1/2 ⎥
⎢ ⎥
⎣-1/2 -1/2 0 0 0 0 1/2 1/2 ⎦
K2 / (EA / √2 l):
⎡0 0 0 0 0 0 0 0 ⎤
⎢ ⎥
⎢0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎢0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎢0 0 0 √2 0 0 0 -√2⎥
⎢ ⎥
⎢0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎢0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎢0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎣0 0 0 -√2 0 0 0 √2 ⎦
K3 / (EA / √2 l):
⎡0 0 0 0 0 0 0 0 ⎤
⎢ ⎥
⎢0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎢0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎢0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎢0 0 0 0 1/2 -1/2 -1/2 1/2 ⎥
⎢ ⎥
⎢0 0 0 0 -1/2 1/2 1/2 -1/2⎥
⎢ ⎥
⎢0 0 0 0 -1/2 1/2 1/2 -1/2⎥
⎢ ⎥
⎣0 0 0 0 1/2 -1/2 -1/2 1/2 ⎦
K / (EA / √2 l):
⎡1/2 1/2 0 0 0 0 -1/2 -1/2 ⎤
⎢ ⎥
⎢1/2 1/2 0 0 0 0 -1/2 -1/2 ⎥
⎢ ⎥
⎢ 0 0 0 0 0 0 0 0 ⎥
⎢ ⎥
⎢ 0 0 0 √2 0 0 0 -√2 ⎥
⎢ ⎥
⎢ 0 0 0 0 1/2 -1/2 -1/2 1/2 ⎥
⎢ ⎥
⎢ 0 0 0 0 -1/2 1/2 1/2 -1/2 ⎥
⎢ ⎥
⎢-1/2 -1/2 0 0 -1/2 1/2 1 0 ⎥
⎢ ⎥
⎣-1/2 -1/2 0 -√2 1/2 -1/2 0 1 + √2⎦
(u4x, u4y) / (Fl / EA):
⎡ 0 ⎤
⎢ ⎥
⎣-2 + √2⎦
u4y / mm:
-0.9999
(F1x, F1y) / F:
⎡ 1 √2⎤
⎢- ─ + ──⎥
⎢ 2 2 ⎥
⎢ ⎥
⎢ 1 √2⎥
⎢- ─ + ──⎥
⎣ 2 2 ⎦
(F1x, F1y) / N:
⎡1035.5⎤
⎢ ⎥
⎣1035.5⎦
(F2x, F2y) / F:
⎡ 0 ⎤
⎢ ⎥
⎣2 - √2⎦
(F2x, F2y) / N:
⎡ 0 ⎤
⎢ ⎥
⎣2928.9⎦
(F3x, F3y) / F:
⎡ 1 √2 ⎤
⎢ ─ - ── ⎥
⎢ 2 2 ⎥
⎢ ⎥
⎢ 1 √2⎥
⎢- ─ + ──⎥
⎣ 2 2 ⎦
(F3x, F3y) / N:
⎡-1035.5⎤
⎢ ⎥
⎣1035.5 ⎦
(S1, S2, S3) / N:
-1464.5
-2928.9
-1464.5