R2B2.A

Gegeben

../../../../_images/R2B2.A.png

Symbole:

\[a, F, A_1, A_2, E, I\]

E-Modul \(E\) ist für Stab und Balken gleich.

Berechnen Sie die Verschiebung von Knoten 1.

0. Lösung "Standard"

siehe R2B2-Element

../../../../_images/R2B2.A_0.png

1 = R2-Element, 2 = R2B2-Element. Die 5 letzten Freiheitsgrade sind gleich null, sodass die 5 letzten Spalten irrelevant sind. Die ersten 3 Zeilen ausgewertet sind drei Gleichungen zur Berechnung von \(u_{1x}, u_{1y}, \psi_1.\) Lösung dieselbe wie mit den anderen Methoden.

1. Lösung "Freischneiden"

../../../../_images/R2B2.A_1.png

Ein Stab-Element R2 sowie ein Balken-Element B2 sowie Berücksichtigung der Längs-Elastizität des Balkens über \(u_{1x} = - \tfrac{2 H a}{EA_2}\). Beide Strukturen zusammengeführt über gemeinsame Kräfte \(H\) und \(V\) und gemeinsame Verschiebungen \(u_{1x}\) und \(u_{1y}=-w_1\).

Die sechs Unbekannten \(u_{1x}, u_{1y}, \psi_1, w_1\) sowie \(H, V\) lassen sich durch die Zeilen 1, 2, 5, 6 und durch die zwei Zusatzgleichungen berechnen. Man könnte aber auch alle zehn Unbekannten berechnen durch Auswertung aller zehn Gleichungen.

Die Zeilen 1, 2, 5, 6 und die zwei Zusatzgleichungen lauten:

\begin{align*} \tfrac{E}{a} \begin{bmatrix} \frac{\sqrt{2} A_1}{4} & \frac{\sqrt{2} A_1}{4} & 0 & 0 \\ \frac{\sqrt{2} A_1}{4} & \frac{\sqrt{2} A_1}{4} & 0 & 0 \\ 0 & 0 & 2 I & - \frac{3 I}{2 a}\\ 0 & 0 & - \frac{3 I}{2 a} & \frac{3 I}{2 a^{2}} \\ \end{bmatrix} \begin{bmatrix} u_{1x} \\ u_{1y} \\ \psi_1\\ w_1 \\ \end{bmatrix} &= \begin{bmatrix} H \\ -F + V \\ 0 \\ V \\ \end{bmatrix} \\ u_{1x} &= - \tfrac{2 H a}{EA_2} \\ u_{1y} &= - w_1 \\ \end{align*}

Eliminieren von \(w_1\) durch Einsetzen von \(w_1\) aus der zweiten Zusatzgleichung in die vierte Zeile liefert:

\begin{align*} \tfrac{E}{a} \begin{bmatrix} \frac{\sqrt{2} A_1}{4} & \frac{\sqrt{2} A_1}{4} & 0 & 0 \\ \frac{\sqrt{2} A_1}{4} & \frac{\sqrt{2} A_1}{4} & 0 & 0 \\ 0 & 0 & 2 I & +\frac{3 I}{2 a}\\ 0 & 0 & - \frac{3 I}{2 a} & -\frac{3 I}{2 a^{2}} \\ \end{bmatrix} \begin{bmatrix} u_{1x} \\ u_{1y} \\ \psi_1\\ +u_{1y} \\ \end{bmatrix} &= \begin{bmatrix} H \\ -F + V \\ 0 \\ V \\ \end{bmatrix} \\ u_{1x} &= - \tfrac{2 H a}{EA_2} \\ \end{align*}

Eliminieren von \(V\) durch Subtrahieren der vierten Zeile von der zweiten Zeile liefert:

\begin{align*} \tfrac{E}{a} \begin{bmatrix} \frac{\sqrt{2} A_1}{4} & \frac{\sqrt{2} A_1}{4} & 0 \\ \frac{\sqrt{2} A_1}{4} & \frac{\sqrt{2} A_1}{4} + \frac{3 I}{2 a^{2}}& \frac{3 I}{2 a} \\ 0 & \frac{3 I}{2 a} & 2 I \\ \end{bmatrix} \begin{bmatrix} u_{1x} \\ u_{1y} \\ \psi_1\\ \end{bmatrix} &= \begin{bmatrix} H \\ -F \\ 0 \\ \end{bmatrix} \\ u_{1x} &= - \tfrac{2 H a}{EA_2} \\ \end{align*}

Eliminieren von \(H\) durch Einsetzen von \(H\) aus der verbleibenden Zusatzgleichung in Zeile 1 liefert:

\begin{align*} \tfrac{E}{a} \begin{bmatrix} \frac{\sqrt{2} A_1}{4} + \tfrac{A_2}{2} & \frac{\sqrt{2} A_1}{4} & 0 \\ \frac{\sqrt{2} A_1}{4} & \frac{\sqrt{2} A_1}{4} + \frac{3 I}{2 a^{2}}& \frac{3 I}{2 a} \\ 0 & \frac{3 I}{2 a} & 2 I \\ \end{bmatrix} \begin{bmatrix} u_{1x} \\ u_{1y} \\ \psi_1\\ \end{bmatrix} &= \begin{bmatrix} 0 \\ -F \\ 0 \\ \end{bmatrix} \end{align*}

Die Lösung ist unhandlich. Aber für folgende gegebenen Größen:

\begin{align*} a &= 1500\,\mathrm{mm} \\ A_1 &= 1000\,\mathrm{mm}^2 \\ A_2 &= 200\,\mathrm{cm}^2 \\ E &= 210\, \mathrm{GPa} \\ I &= \tfrac 2 3 (10\,\mathrm{cm})^4 \\ F &= 50\, \mathrm{kN} \\ \end{align*}

erhält man z.B.:

\begin{align*} \begin{bmatrix} u_{1x} \\ u_{1y} \\ \end{bmatrix} &\stackrel{\scriptscriptstyle{0{,}001}}{\approx} \begin{bmatrix} 0{,}035 \\ -1{,}013 \\ \end{bmatrix} \,\mathrm{mm} \end{align*}

2. Lösung "Gemeinsame Freiheitsgrade"

../../../../_images/R2B2.A_2.png

Der Balken wird modelliert einerseits als Balken-Element B2 mittels \(K_{2B}^|\), andererseits als Stab-Element R2 mittels \(K_{2R}^|\). Gemeinsame Freiheitsgrade: \(w_1 = -u_{1y}\) und \(u_{1x}\).

3. Lösung "Feder"

../../../../_images/a3.png

SymPy

Source Code eines Programms dazu:

from sympy.physics.units import kg, m, s
from sympy import pprint, Matrix, cos, sin, var, sqrt, zeros, Eq, solve, pi, S

# 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

# Units:
(mm, cm)  =  ( m/1000, m/100 )
Newton    =  kg*m/s**2
kN        =  10**3*Newton
Pa        =  Newton/m**2
MPa       =  10**6*Pa
GPa       =  10**9*Pa
deg       =  pi/180
half      =  S(1)/2


# ---

def K_1E(EI, l):
    # l = Element length
    l2, l3 = l*l, l*l*l
    K = EI/l3
    K *= Matrix([
        [  4*l2 ,  -6*l ,  2*l2 ,   6*l  ],
        [ -6*l  ,  12   , -6*l  , -12    ],
        [  2*l2 ,  -6*l ,  4*l2 ,   6*l  ],
        [  6*l  , -12   ,  6*l    , 12   ],
        ])
    return K

def k(phi):
    """
    Computes entries of stiffness matrix
    Input: φ
    - measured at first element node
    - counting positively about z-axis
    - counting from x-axis to rod-axis
    """
    (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):
    """ Adds element stiffness matrix to system stiffness matrix

    n: number of system nodes
    k: element stiffness matrix
    (i, j): Numbers 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

a, A1, A2, E, I, F = var("a, A1, A2, E, I, F")

u1x, u1y, p1, w1, H, V = var("u1x, u1y, psi1, w1, H, V")

sub_list = [
    (a, 1500*mm       ),
    (A1, 1000*mm**2   ),
    (A2,  200*cm**2   ),
    (E, 210*GPa       ),
    (I, 2*(10*cm)**4/3),
    (F,  50*kN        ),
    ]

EA1, EI = E*A1, E*I

s2 = sqrt(2)
l1 = a*s2

k1 = EA1/l1 * k(45*deg)
K1 = assemble(2, k1, 1,2)
K2 = K_1E(EI, 2*a)

# pprint("\n\nK1 / ( EA1 / (√2a) ):")
# tmp = K1
# tmp = tmp.applyfunc(expand)
# tmp = tmp.applyfunc(simplify)
# tmp /= EA1 / (s2*a)
# pprint(tmp)

# pprint("\n\nK1 / (E / a):")
# tmp = K1
# tmp /= ( E / a )
# pprint(tmp)

# pprint("\n\nK2 / ( EI / (2a)³ ):")
# tmp = K2
# tmp /= EI / ((2*a)**3)
# pprint(tmp)

# pprint("\n\nK2 / (E / a):")
# tmp = K2
# tmp /= ( E / a )
# pprint(tmp)

pprint("\n0. Standard:")

l = 2*a
l2 = l*l
l3 = l*l*l

alf = A2*l2 / I
bet = E*I / l3
gam = E*A1 / (2*sqrt(2) *a)

K = Matrix([
    [alf*bet + gam, gam, 0],
    [gam,  12*bet + gam, 6*l*bet],
    [0,  6*l*bet, 4*l2*bet]
    ])
u = Matrix([u1x, u1y, p1])
f = Matrix([0, -F, 0])

eq = Eq(K*u, f)
sol = solve(eq, [u1x, u1y, p1])
u1x_s = sol[u1x]
u1y_s = sol[u1y]

pprint("\nu1x / mm, u1y / mm:")
for tmp in [u1x_s, u1y_s]:
    printout(tmp, unit=mm, prec=3, sub_list=sub_list)

pprint("\n1. Using \"FBD\":")
u = Matrix([u1x, u1y, p1, w1])
f = Matrix([H, - F + V, 0, V])

K11 = s2 *A1/4
K33 = 2*I
K34 = -3*I/(2*a)
K44 = 3*I/(2*a**2)

K = Matrix([
    [K11, K11,    0, 0  ],
    [K11, K11,    0, 0  ],
    [  0,   0,  K33, K34],
    [  0,   0,  K34, K44],
    ])
K *= E/a

unks = [u1x, u1y, p1, w1, H, V]
eq1 = Eq(K*u, f)
eq2 = Eq(u1x, -2*H*a/(E*A2))
eq3 = Eq(u1y, -w1)

eqns = [eq1, eq2, eq3]

sol = solve(eqns,unks)
u1x, u1y, p1, w1, H, V = \
    sol[u1x], sol[u1y], sol[p1], sol[w1], sol[H], sol[V]

pprint("\nu1x / mm, u1y / mm:")
for tmp in [u1x, u1y]:
    printout(tmp, unit=mm, prec=3, sub_list=sub_list)

pprint("\n2. Using \"Shared Dofs\":")

K11 = s2 *A1/4 + A2/2
K12 = s2 *A1/4
K22 = s2 *A1/4 + 3*I/(2*a**2)
K23 = 3*I / (2*a)
K33 = 2*I

K = Matrix([
    [ K11, K12, 0   ],
    [ K12, K22, K23 ],
    [   0, K23, K33 ],
    ])
# pprint("\nK / (E/a):")
# pprint(K)
K *= E/a


u = Matrix([u1x, u1y, p1])
f = Matrix([0, -F, 0])

unks = [u1x, u1y, p1]
eq = Eq(K*u, f)
sol = solve(eq,unks)
# pprint(sol)
u1x, u1y, p1 = sol[u1x], sol[u1y], sol[p1],

pprint("\nu1x / mm, u1y / mm:")
for tmp in [u1x, u1y]:
    printout(tmp, unit=mm, prec=3, sub_list=sub_list)

pprint("\n3. Using \"Spring\":")
K, u, w = var("K, u, w")
blue = sqrt(2)/2*K
eq1 = Eq( K ,  E*A1/(2*a) * (u+w) )
eq2 = Eq( - blue , E*A2/(2*a) * u  )
eq3 = Eq( E*I*w , (F - blue) * 8*a**3 / 3 )

sol = solve([eq1, eq2, eq3], [K, u, w])
K_s = sol[K]
u_s = sol[u]
w_s = sol[w]

pprint("\nu / mm, w / mm:")
for tmp in [u_s, w_s]:
    printout(tmp, unit=mm, prec=3, sub_list=sub_list)

Programm ausführen? Dazu:

  1. Copy: Source Code in die Zwischenablage kopieren.

  2. Paste: Source Code ins Eingabefeld hinter [ ]: einfügen.

  3. Play: Knopf ▶ drücken.