R2B2.B

Verwenden Sie die Bezeichnungen aus Stab-Element R2 und Balken-Element B2.

Berechnen Sie:

die Verschiebung \(w_1\) von Knoten 1
die Wärmedehnung \(\epsilon\), so dass \(w_1=0\).

Lösung "Freischneiden"

../../../_images/R2B2.B_1.png — Ein Balken-Element B2 sowie ein Stab mit Elastizität \(S = \tfrac{EA}{a} \Delta l - EA \epsilon\). Beide Strukturen zusammengeführt über gemeinsame Kraft \(S\) und gemeinsame Verschiebung \(\Delta l = -w_1\).

Lösung "Gemeinsame Freiheitsgrade"

../../../_images/R2B2.B_2.png — Ein 1D Stab-Element R2 und ein Balken-Element B2. Gemeinsamer Freiheitsgrad: \(w_1 = u_1\).

SymPy

Nachfolgend ein Programm, dass Sie ausführen können:

Auf dem PC z.B. mit Anaconda.
Im Browser (online) in drei Schritten:
1. Copy: Source Code in die Zwischenablage kopieren.
2. Paste: Source Code als Python-Notebook einfügen z.B. auf:
  - JupyterLite oder
  - JupyterLab oder
  - Colab.
3. Play: Ausführen.

from sympy.physics.units import *
from sympy import *

# 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

# 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

# ---

a, q, A, I, E, eT = var("a, q, A, I, E, ϵ")
EA, EI = E*A, E*I
a2 = a*a
a3 = a*a*a

pprint("Using \"FBD\":")
S, psi1, w1 = var("S, psi1, w1")
eq1 = Eq(S, - EA/a * w1 - EA * eT  )

K11 = 4*a2
K12 = -6*a
K21 = K12
K22 = 12

K = Matrix([
    [K11, K12 ],
    [K21, K22 ],
    ])
K *= EI/a3

u = Matrix([psi1, w1])
f = Matrix([0, S]) + q*Matrix([-a2/12, a/2])

eq2 = Eq(K*u, f)

eqns = [eq1, eq2]
unks = [S, psi1, w1]
sol = solve(eqns,unks)

psi1, w1 = sol[psi1], sol[w1]
pprint("\nψ₁:")
pprint(psi1)
pprint("\nw₁:")
pprint(w1)


pprint("\neT:")
sol = solve( Eq(w1,0), eT)
tmp = sol[0]
pprint(tmp)

pprint("\nUsing \"Shared Dofs\":")
psi1, w1 = var("psi1, w1")

K11 = 4*I
K12 = -6*I/a
K21 = K12
K22 = 12*I/a2 + A

K = Matrix([
    [K11, K12 ],
    [K21, K22 ],
    ])
K *= E/a

u = Matrix([psi1, w1])
f = Matrix([0, -EA*eT]) + q*Matrix([-a2/12, a/2])


eq = Eq(K*u, f)
unks = [psi1, w1]
sol = solve(eq,unks)

psi1, w1 = sol[psi1], sol[w1]
pprint("\nψ₁:")
pprint(psi1)
pprint("\nw₁:")
pprint(w1)

Using "FBD":
   
ψ₁:
            2        5           3  
- 72⋅A⋅E⋅I⋅a ⋅ϵ - A⋅a ⋅q + 24⋅I⋅a ⋅q
────────────────────────────────────
                 2          2       
       48⋅A⋅E⋅I⋅a  + 144⋅E⋅I        
   
w₁:
         3        4  
- 8⋅A⋅E⋅a ⋅ϵ + 3⋅a ⋅q
─────────────────────
         2           
  8⋅A⋅E⋅a  + 24⋅E⋅I  
   
eT:
3⋅a⋅q
─────
8⋅A⋅E
                    
Using "Shared Dofs":
   
ψ₁:
            2        5           3  
- 72⋅A⋅E⋅I⋅a ⋅ϵ - A⋅a ⋅q + 24⋅I⋅a ⋅q
────────────────────────────────────
                 2          2       
       48⋅A⋅E⋅I⋅a  + 144⋅E⋅I        
   
w₁:
         3        4  
- 8⋅A⋅E⋅a ⋅ϵ + 3⋅a ⋅q
─────────────────────
         2           
  8⋅A⋅E⋅a  + 24⋅E⋅I  

Statt SymPy lieber anderes CAS (Computeralgebrasystem) verwenden? Eine Auswahl verschiedener CAS gibt es hier.