Stab-Element R2
Video

2-Knoten-Stab-Element: Prinzip der virtuellen Verschiebungen. Äußere Lasten: Einzelkräfte \(F_1\) und \(F_2\) an den Knoten, Einzelkraft \(F\) zwischen den Knoten, verteilte Kraft \(n\) und Wärmedehnung (Verzerrung aufgrund Temperaturzuwachs) \(\epsilon\) . Lineares System in 1D und in 2D. Verwendung von \((x,y)\)-Bezugssystem bzw. von \((x_1, y_1)\)- und \((x_2, y_2)\)-Bezugssystem.
Ab hier nur zum Nachlesen
Ab hier Herleitungen, falls Sie etwas nachlesen möchten. Ansonsten einfach nicht davon stören lassen .
Herleitung mit PdvV
Interpolation
Als Ansatzfunktionen, also zur Interpolation, werden folgende Lagrange-Polynome mit der Abkürzung \(\xi = \tfrac{\bar{x}}{l}\) verwendet, nämlich:
Ableitungen:
Funktionswerte an den Knoten:
Verschiebung und virt. Verschiebung
Verschiebung und virtuelle Verschiebung werden interpoliert:
Elastische Verzerrung und virt. Verz.
Virtuelle Arbeit
Virt. äußere Arbeit
Mit einer linear verteile äußere Last \(n = n_1 + (n_2 - n_1) \xi\) ist die virtuelle äußere Arbeit:
Umschreiben, so dass die virtuellen Größen faktorisiert sind:
Virt. innere Arbeit
Ergebnis
1D
Beispiele:
Knotenlasten berechnen
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 import *
half = S(1)/2
l = var("l")
n1, n2 = var("n1, n2")
e1, e2 = var("e1, e2")
xi = var("xi")
xi2 = xi*xi
pprint("[ N1 , N2 ]:")
N1 = 1 - xi
N2 = xi
pprint(N1)
pprint(N2)
pprint("\n[ N1' , N2' ]:")
# xi = x/l
# d/dx = d/dxi dxi/dx
# = d/dxi 1/l
# dx = l dxi
N1p = diff(N1, xi) / l
N2p = diff(N2, xi) / l
tmp = Matrix([N1p, N2p])
pprint(tmp)
pprint("\n\n2x2-Matrix with entries ∫ Ni' Nj' dξ:")
t11 = integrate( N1p*N1p, (xi, 0, 1))
t12 = integrate( N1p*N2p, (xi, 0, 1))
t22 = integrate( N2p*N2p, (xi, 0, 1))
tmp = Matrix([[t11, t12],[t12, t22]])
pprint(tmp)
pprint("\nNodal Forces due to n and:")
pprint("\nn:")
# linear:
n = n1 + (n2 - n1)*xi
# quadratic:
# a, b, c = var("a, b, c")
# n = a + b*xi + c*xi**2
# eq1 = Eq(n.subs(xi,0), 0)
# eq2 = Eq(n.subs(xi,half), n1)
# eq3 = Eq(n.subs(xi,1), 0)
# sol = solve([eq1, eq2, eq3],[a, b, c])
# sub_list = [
# (a, sol[a]),
# (b, sol[b]),
# (c, sol[c]),
# ]
# n = n.subs(sub_list)
pprint(n)
pprint("\n\n[ ∫ n N1 dξ , ∫ n N2 dξ ]:")
I1 = integrate( n * N1, (xi, 0, 1))
I2 = integrate( n * N2, (xi, 0, 1))
tmp = Matrix([I1, I2])
pprint(tmp)
pprint("\n\ne:")
# https://fem.tm-tutor.de/A/FEM/R2/
e = e1 + (e2 - e1)*xi
# https://fem.tm-tutor.de/FEM/R2/R2.J/
e = e1*(1 - 2*xi + xi*xi)
# FEMT01 ESA-4 Parabola:
a, b, c = var("a, b, c")
e = a + b*xi + c*xi**2
eq1 = Eq(e.subs(xi,0), 0)
eq2 = Eq(e.subs(xi,half), e1)
eq3 = Eq(e.subs(xi,1), 0)
sol = solve([eq1, eq2, eq3],[a, b, c])
sub_list = [
(a, sol[a]),
(b, sol[b]),
(c, sol[c]),
]
e = e.subs(sub_list)
pprint(e)
pprint("\n\n∫ e dξ:")
tmp = integrate( e, (xi, 0, 1))
tmp = tmp.simplify()
pprint(tmp)
[ N1 , N2 ]:
1 - ξ
ξ
[ N1' , N2' ]:
⎡-1 ⎤
⎢───⎥
⎢ l ⎥
⎢ ⎥
⎢ 1 ⎥
⎢ ─ ⎥
⎣ l ⎦
2x2-Matrix with entries ∫ Ni' Nj' dξ:
⎡1 -1 ⎤
⎢── ───⎥
⎢ 2 2⎥
⎢l l ⎥
⎢ ⎥
⎢-1 1 ⎥
⎢─── ── ⎥
⎢ 2 2 ⎥
⎣ l l ⎦
Nodal Forces due to n and:
n:
n₁ + ξ⋅(-n₁ + n₂)
[ ∫ n N1 dξ , ∫ n N2 dξ ]:
⎡n₁ n₂⎤
⎢── + ──⎥
⎢3 6 ⎥
⎢ ⎥
⎢n₁ n₂⎥
⎢── + ──⎥
⎣6 3 ⎦
e:
2
- 4⋅e₁⋅ξ + 4⋅e₁⋅ξ
∫ e dξ:
2⋅e₁
────
3
2D
Der 1D-Fall wurde notiert bezüglich dem blauen \((\bar x, \bar y)\)-Bezugssystem und für den Spezialfall, dass es Kräfte und Verschiebungen nur in der \(\bar x\)-Richtung gibt.
Dieser Spezialfall wird jetzt notiert bezogen auf andere Bezugssysteme.
Gegenüber Verschiebungen der Knoten senkrecht zur Stabrichtung hat das Stab-Element keinerlei Steifigkeit.
Übergang zum grünen globalen \((x, y)\)-Bezugssystem liefert:
Passive Transformation von Vektor-Komponenten im um den Winkel \(\varphi\) gedrehten System mit den Abkürzungen \((c, s) = \left(\cos\varphi, \sin\varphi\right)\): Invertiert: Dies einsetzen in das Lineare System in 1D liefert:Details
Übergang zu den grünen lokalen Bezugssystemen \((x_1, y_1)\) am Knoten 1 sowie \((x_2, y_2)\) am Knoten 2 liefert:
Vorgehensweise ansonsten wie oben.
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.Details
SymPy
from sympy import *
pprint("\n\nPassive Transformation:")
c, s = var("c, s")
C = Matrix([
[1, 0,-1,0],
[0,0,0,0],
[-1,0,1,0],
[0,0,0,0]]
)
pprint(C)
R = Matrix([
[c,s,0,0],
[-s,c,0,0],
[0, 0,c,s],
[0,0,-s,c]]
)
Rt = R.transpose()
tmp = Rt*C*R
pprint(tmp)
# Local Frames:
c1, s1 = var("c1, s1")
c2, s2 = var("c2, s2")
C = Matrix([
[1, 0,-1,0],
[0,0,0,0],
[-1,0,1,0],
[0,0,0,0]]
)
pprint(C)
R = Matrix([
[c1,s1,0,0],
[-s1,c1,0,0],
[0, 0,c2,s2],
[0,0,-s2,c2]]
)
Rt = R.transpose()
tmp = Rt*C*R
pprint(tmp)
Passive Transformation:
⎡1 0 -1 0⎤
⎢ ⎥
⎢0 0 0 0⎥
⎢ ⎥
⎢-1 0 1 0⎥
⎢ ⎥
⎣0 0 0 0⎦
⎡ 2 2 ⎤
⎢ c c⋅s -c -c⋅s⎥
⎢ ⎥
⎢ 2 2 ⎥
⎢c⋅s s -c⋅s -s ⎥
⎢ ⎥
⎢ 2 2 ⎥
⎢-c -c⋅s c c⋅s ⎥
⎢ ⎥
⎢ 2 2 ⎥
⎣-c⋅s -s c⋅s s ⎦
⎡1 0 -1 0⎤
⎢ ⎥
⎢0 0 0 0⎥
⎢ ⎥
⎢-1 0 1 0⎥
⎢ ⎥
⎣0 0 0 0⎦
⎡ 2 ⎤
⎢ c₁ c₁⋅s₁ -c₁⋅c₂ -c₁⋅s₂⎥
⎢ ⎥
⎢ 2 ⎥
⎢c₁⋅s₁ s₁ -c₂⋅s₁ -s₁⋅s₂⎥
⎢ ⎥
⎢ 2 ⎥
⎢-c₁⋅c₂ -c₂⋅s₁ c₂ c₂⋅s₂ ⎥
⎢ ⎥
⎢ 2 ⎥
⎣-c₁⋅s₂ -s₁⋅s₂ c₂⋅s₂ s₂ ⎦
Herleitung klassisch
Bezugssystem, Kräfte, Verschiebungen
\((x,y,z)\): Rechtssystem.
\((\boldsymbol u_1, \boldsymbol u_2)\): Knotenverschiebungen.
\(S\): Stabkraft: Wie üblich so definiert, dass die Stabkraft für einen Zugstab positiv ist.
\((\boldsymbol F_1, \boldsymbol F_2)\): Resultierende der - abgesehen von \(S\) - an den Knoten wirkenden Kräfte. Denn jeder Fachwerkstab ist nur in Stabrichtung belastet.
Einheitsvektor \(\boldsymbol e\) und Winkel \(0^\circ \le \varphi < 360^\circ\)
Richtung von \(\boldsymbol e\): Vom ersten Knoten 1 zum zweiten Knoten 2.
Zählrichtung von \(\varphi\): Positiv um die in den ersten Knoten verschobene \(z\)-Achse.
Nullpunkt von \(\varphi\): Die in den ersten Knoten verschobene \(x\)-Achse.
Geometrie und Material
\((l, \Delta l)\): (Stablänge undeformiert, Stabverlängerung).
\((E, A)\): (Elastiztätsmodul des Stab-Materials, Querschnittsfläche).
Gleichgewicht
Die \((x,y)\)-Komponenten von \(F_1\) und \(F_2\) abhängig von \(S\) sind:
mit den Abkürzungen \((c, s) = \left(\cos\varphi, \sin\varphi\right)\).
Elastizität
Hookesches Gesetz:
Kinematik
Wie gezeigt ist in Stab-Kinematik und -Elastizität, gilt näherungsweise:
Bemerkung
Skalarprodukt berechnet mit Matrix-Multiplikation.
Lineares System
Einsetzen von \(\Delta l\) aus (3) in (2) und danach Einsetzen von \(S\) aus (2) in (1) liefert den Zusammenhang zwischen den äußeren Knoten-Lasten und den Knoten-Verschiebungen:
Linearer Zusammenhang zwischen Kräften und Verschiebungen:
Postprocessing
Stabkraft
Zur Berechnung der Stabkraft gibt es zwei Möglichkeiten:
Verwendung der berechneten Lagerreaktionen und der äußeren Kräfte. Damit berechnen der Stabkräfte z.B. mit Knotenschnitt-Verfahren oder mit Ritterschnitt-Verfahren. Dieser Weg ist hier nicht gezeigt, sondern ist Thema in TM 1 und TM 2.
Verwendung von Stab-Kinematik und -Elastizität
Stabverlängerung:
\[\Delta l = \left(\boldsymbol u_2 - \boldsymbol u_1 \right) \cdot \boldsymbol e\]Stab-Elastizität = Hookesches Gesetz:
\[S = EA\tfrac{\Delta l}{l}\]