R2.A
Video
Klassische Lösung
siehe 2.1.Q
a) 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 |
b) 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.
c) Erweiterte System-Steifigkeitsmatrix
Berechnen Sie die erweiterte System-Steifigkeitsmatrix \(K^|\).
Lösung
d) 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
e) 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
f) 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: Details zur Berechnung der Lagerreaktionen an Knoten 1: 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
g) 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
h) Symmetrie
Zeigen Sie, dass Sie bei Ausnutzung der Symmetrie dieselbe Lösung erhalten.
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
Details
Python Source Code eines Programms dazu: Programm ausführen? Dazu: Copy: Source Code in die Zwischenablage kopieren. Paste: Source Code ins Eingabefeld hinter Play: Knopf SymPy
from sympy.physics.units import kg, m, s
from sympy import pi, S, pprint, symbols, sqrt, \
cos, sin, Matrix, zeros, simplify, Eq, solve
# 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
mm = m/1000
# Rounding:
def iso_round(x, pv):
try:
x = float(x)
tmp = round(x, pv)
except TypeError:
from functools import partial
func = partial(round, ndigits = pv)
tmp = x.applyfunc(func)
return tmp
def printout(x, unit=1, prec=None, sub_list=[]):
x = x.subs(sub_list)
x /= unit
try:
x = x.applyfunc(simplify)
except:
x = x.simplify()
if prec:
x = iso_round(x, prec)
pprint(x)
return
# 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 = symbols("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:
print("\nNot Using Symmetry:")
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=\
symbols('u1x u1y u2x u2y u3x u3y u4x u4y')
F1x,F1y,F2x,F2y,F3x,F3y,F4x,F4y=\
symbols("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):")
u4 = Matrix([u4x, u4y])
printout(u4, F*l/EA, prec=None, sub_list=[])
pprint("\nu4y / mm:")
printout(u4y, unit=mm, prec=4, sub_list=sub_list)
pprint("\n(F1x, F1y) / F:")
rf = Matrix([F1x, F1y])
printout(rf, F, prec=None, sub_list=[])
pprint("\n(F1x, F1y) / N:")
printout(rf, unit=N, prec=1, sub_list=sub_list)
pprint("\n(F2x, F2y) / F:")
rf = Matrix([F2x, F2y])
printout(rf, F, prec=None, sub_list=[])
pprint("\n(F2x, F2y) / N:")
printout(rf, unit=N, prec=1, sub_list=sub_list)
pprint("\n(F3x, F3y) / F:")
rf = Matrix([F3x, F3y])
printout(rf, F, prec=None, sub_list=[])
pprint("\n(F3x, F3y) / N:")
printout(rf, unit=N, prec=1, sub_list=sub_list)
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]:
printout(S, unit=N, prec=1, sub_list=sub_list)
elif symm:
print("\nUsing Symmetry:")
k2 = EA/2/l2 * k(p2)
K1 = assemble(3,k1,3,1)
K2 = assemble(3,k2,3,2)
pprint("\nK1 / ( EA / (√2 l) ):")
printout(K1, EA/(r*l), prec=None, sub_list=[])
pprint("\nK2 / ( EA / (√2 l) ):")
printout(K2, EA/(r*l), prec=None, sub_list=[])
# System stiffness matrix:
pprint("\nK / ( EA / (√2 l) ):")
K = K1 + K2
printout(K, EA/(r*l), prec=None, sub_list=[])
u1x,u1y, u2x, u2y,u4x,u4y = symbols('u1x u1y u2x u2y u4x u4y')
F1x,F1y,F2px,F2py,F4x,F4y = symbols("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)
u4y,F1x,F1y,F2px,F2py,F4x = \
sol[u4y],sol[F1x],sol[F1y],sol[F2px],sol[F2py],sol[F4x]
pprint("\nu4y / ( Fl / (EA) ):")
printout(u4y, F*l/EA, prec=None, sub_list=[])
pprint("\n(F2'x, F2'y) / F:")
printout(Matrix([F2px, F2py]), F, prec=None, sub_list=[])
[ ]:
einfügen.▶
drücken.