Tensor-Komponenten

Videos

../../../_images/stress.png

Beispiel-Aufgabe: M.3.A

Symbole

Winkel

zählt pos. um

zeigt Winkelpos. von

relativ zu

\(\varphi\)

\(z=\bar z\)

\((\bar x, \bar y)\)

\((x, y)\)

\(\alpha\)

\(z=\bar z\)

\(\boldsymbol T'\)

\(\boldsymbol T\)

Tensor

\((x,y)\)-Komp.

\((\bar x, \bar y)\)-Komp.

\(\boldsymbol T\)

\(\begin{bmatrix} T_{xx} & T_{xy} \\ \mathsf{sym} & T_{yy} \end{bmatrix}\)

\(\begin{bmatrix} T_{\bar x \bar x} & T_{\bar x\bar y} \\ \mathsf{sym} & T_{\bar y\bar y} \end{bmatrix}\)

\(\boldsymbol T'\)

\(\begin{bmatrix} T'_{xx} & T'_{xy} \\ \mathsf{sym} & T'_{yy} \end{bmatrix}\)

nicht definiert

Passive und aktive Transformation

Für einen Tensor gegeben durch seine \((x,y)\)-Komponenten sind folgende Transformationen definiert:

Passive Transformation

1 Tensor & 2 Bezugssysteme: Die \((\bar x, \bar y)\)-Komponenten desselben Tensors werden berechnet. Diese beziehen sich auf ein zweites Bezugssystem. Dieses zweite Bezugssystem ist das \((\bar x, \bar y)\)-System, welches relativ zum gegebenen \((x, y)\)-System gedreht ist.

\[\begin{split}:nowrap: \begin{align} \label{eq-trafo_tensor_formulae-1} \begin{bmatrix} T_{\bar x \bar x} & T_{\bar x\bar y} \\ \mathsf{sym} & T_{\bar y\bar y} \end{bmatrix} = R_\varphi \begin{bmatrix} T_{xx} & T_{xy} \\ \mathsf{sym} & T_{yy} \end{bmatrix} R_\varphi^{\mathsf T} \tag{1} \end{align}\end{split}\]

mit \(R_\varphi = \begin{bmatrix}c_\varphi & s_\varphi \\-s_\varphi & c_\varphi\end{bmatrix}\) und \(R_\varphi^{\mathsf T}\) als Transponierte von \(R_\varphi\). Eigenschaften der Transformation siehe hier.

Aktive Transformation

2 Tensoren & 1 Bezugssystem: Berechnet werden die \((x, y)\)-Komponenten eines zweiten Tensors, der relativ zum ersten Tensor gedreht ist.

\[\begin{split}\begin{bmatrix} T'_{xx} & T'_{xy} \\ \mathsf{sym} & T'_{yy} \end{bmatrix} = R_\alpha^{\mathsf T} \begin{bmatrix} T_{xx} & T_{xy} \\ \mathsf{sym} & T_{yy} \end{bmatrix} R_\alpha\end{split}\]

mit \(R_\alpha = \begin{bmatrix}c_\alpha & s_\alpha \\-s_\alpha & c_\alpha\end{bmatrix}\) und \(R_\alpha^{\mathsf T}\) als Transponierte von \(R_\alpha\).

Zusammenhang zwischen Aktiver und Passiver Transformation

Passive Transformation mit Winkel \(\varphi\) und aktive Transformation mit Winkel \(\alpha=-\varphi\) führen zu denselben transformierten Komponenten. Mit anderen Worten: Drehung des Bezugssystems nach links ergibt zahlenmäßig dieselben transformierten Komponenten wie Drehung des Tensors nach rechts.

Nur wird im einen Fall das Bezugssystem gedreht - und im anderen Fall der Tensor. Und darum unterscheidet man die Transformationen namentlich als Passive und Aktive Transformation. Und darum werden auch die transformierten Komponenten unterschiedlich genannt.

Tensor-Komponente

Eine skalarwertige Tensor-Komponente \(T_{ef}\) ist der Anteil eines Tensors \(\boldsymbol T\) in einer bestimmten „Richtung“. Diese „Richtung“ wird mit zwei Einheitsvektoren \(\boldsymbol e\) und \(\boldsymbol f\) beschrieben. Und es gilt:

\[T_{ef} = \boldsymbol e \cdot \boldsymbol T \cdot \boldsymbol f\]

Durch die zuvor definierte Passive Transformation ist \(T_{ef}\) unabhängig vom dem zur Berechnung von \(T_{ef}\) verwendeten Bezugssystem. Mit Matrix-Multiplikation gilt:

\[\begin{split}T_{ef} &= \begin{bmatrix} e_x & e_y \end{bmatrix} \begin{bmatrix} T_{xx} & T_{xy} \\ \mathsf{sym} & T_{yy} \end{bmatrix} \begin{bmatrix} f_x \\ f_y \end{bmatrix} \\ &= \begin{bmatrix} e_{\bar x} & e_{\bar y} \end{bmatrix} \begin{bmatrix} T_{\bar x \bar x} & T_{\bar x\bar y} \\ \mathsf{sym} & T_{\bar y\bar y} \end{bmatrix} \begin{bmatrix} f_{\bar x} \\ f_{\bar y} \end{bmatrix}\end{split}\]

mit \((e_x, e_y)\)-Komponenten von \(\boldsymbol e\) und \((e_{\bar x}, e_{\bar y})\) als \((\bar x,\bar y)\)-Komponenten von \(\boldsymbol e\) sowie mit \((f_x, f_y)\) als \((x,y)\)-Komponenten von \(\boldsymbol f\) und \((f_{\bar x}, f_{\bar y})\) als \((\bar x,\bar y)\)-Komponenten von \(\boldsymbol f\).

Zeigt \(\boldsymbol e\) z.B. in Richtung \(\bar x\) und zeigt \(\boldsymbol f\) z.B. in Richtung \(\bar y\) und sind \(\bar x\) bzw. \(\bar y\) wie oben um \(\varphi\) relativ zu \(x\) bzw. \(y\) gedreht: Dann gilt:

\[\begin{split}T_{ef} &= \begin{bmatrix} c_\varphi & s_\varphi \end{bmatrix} \begin{bmatrix} T_{xx} & T_{xy} \\ \mathsf{sym} & T_{yy} \end{bmatrix} \begin{bmatrix} -s_\varphi \\ c_\varphi \end{bmatrix} \\ &= \begin{bmatrix} 1 & 0 \end{bmatrix} \begin{bmatrix} T_{\bar x \bar x} & T_{\bar x\bar y} \\ \mathsf{sym} & T_{\bar y\bar y} \end{bmatrix} \begin{bmatrix} 0 \\ 1 \end{bmatrix} \\ &= T_{\bar x\bar y}\end{split}\]

Web-App 1

Tensor Transformation

Andere Ebenen

Ensprechende Formeln lassen sich auch für die anderen Ebenen aufstellen. Hierbei wird zyklisch vertauscht.

Ebene

\(\varphi\) zählt pos. um

\((x,y)\)

\(z\)

\((y,z)\)

\(x\)

\((z,x)\)

\(y\)

Beispiel \((y,z)\)-Ebene

Passive und aktive Transformation:

\[\begin{split}\begin{bmatrix} T_{\bar y \bar y} & T_{\bar y\bar z} \\ \mathsf{sym} & T_{\bar z\bar z} \end{bmatrix} \! &= R_\varphi \begin{bmatrix} T_{yy} & T_{yz} \\ \mathsf{sym} & T_{zz} \end{bmatrix} R_\varphi^{\mathsf T} \\ \begin{bmatrix} T'_{yy} & T'_{yz} \\ \mathsf{sym} & T'_{zz} \end{bmatrix} &= R_\alpha^{\mathsf T} \begin{bmatrix} T_{yy} & T_{yz} \\ \mathsf{sym} & T_{zz} \end{bmatrix} R_\alpha\end{split}\]
Tensor Transformation

3D: Beispiele

\[\begin{split}\begin{bmatrix} T_{\bar x \bar x} & T_{\bar x\bar y} & T_{\bar x\bar z} \\ & T_{\bar y\bar y} & T_{\bar y\bar z} \\ \mathsf{sym} & & T_{\bar z\bar z} \end{bmatrix} \! = R_\varphi \begin{bmatrix} T_{x x} & T_{xy} & T_{xz} \\ & T_{yy} & T_{yz} \\ \mathsf{sym} & & T_{zz} \end{bmatrix} R_\varphi^{\mathsf T}\end{split}\]

Drehachse z = z̄

  • \(\varphi=10^\circ\)

  • vgl. 2D

\[\begin{split}\begin{bmatrix} 0{,}55 & 4{,}78 & 0{,}0\\ 4{,}78 & 3{,}45 & 0{,}0\\ 0{,}0 & 0{,}0 & 6{,}0 \end{bmatrix} \stackrel{0{,}01}{\approx} R_\varphi \begin{bmatrix} -1 & 4 & 0\\ 4 & 5 & 0\\ 0 & 0 & 6 \end{bmatrix} R_\varphi^{\mathsf T}\end{split}\]

Drehachse x = x̄

  • \(\varphi=10^\circ\)

  • vgl. 2D

\[\begin{split}\begin{bmatrix} 666{,}0 & 0{,}0 & 0{,}0\\ 0{,}0 & 844{,}46 & -110{,}81\\ 0{,}0 & -110{,}81 & 235{,}54 \end{bmatrix} \stackrel{0{,}01}{\approx} R_\varphi \begin{bmatrix} 666 & 0 & 0\\ 0 & 864 & 0\\ 0 & 0 & 216 \end{bmatrix} R_\varphi^{\mathsf T}\end{split}\]

Programme

Passive Transformation (in 2D), Eigenwerte und -richtungen

Lösung mit Python: Copy - Paste - Play

  • Copy: Source Code (siehe unten) aufklappen und kopieren.

  • Paste: Einfügen als Python-Notebook auf:

  • Play: Ausführen.

Source Code

# -*- coding: utf-8 -*-
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

# ---

# LateX:
kwargs = {}
kwargs["mat_str"] = "bmatrix"
kwargs["mat_delim"] = ""

"""
    Input:

    * (x,y)-Components of Symm. Tensor.
    * Angular Position phi.
    * Output Precision prec.

    Output:
    * (\bar x, \bar y)`-Components for given phi.
    * Principal values and resp. angles.

"""


# User input starts here.
prec = "0.01"

# Tensor components in their resp. unit:

# Txx, Txy, Tyy = var("Txx, Txy, Tyy")
# (Txx, Txy, Tyy)  = ( -1,  4,  5)
# (Txx, Txy, Tyy)  = (-12, -6,  0)
# (Txx, Txy, Tyy)  = ( -2, -6,  9)
# (Txx, Txy, Tyy)  = ( 13,  -4,  7)
# (Txx, Txy, Tyy)  = (-1.2, -0.6,  0)
# (Txx, Txy, Tyy)  = (864, 0,  216)
(Txx, Txy, Tyy)  = ( 2,  1,  4)

# Angle in deg:
phi = 15

# User input ends here.

f = lambda x: iso_round(x,prec)

pprint("\nφ / °:")
tmp = phi
pprint(tmp)

print(u'\nComponents wrt (x, y):')
T = Matrix([ [Txx, Txy], [Txy, Tyy] ])
tmp = T
tmp = tmp.applyfunc(f)
pprint(tmp)

pprint("\nR:")
phi *= pi/180
c, s = cos(phi), sin(phi)
R = Matrix([ [c, s] , [-s, c] ])
tmp = R
tmp = tmp.applyfunc(f)
pprint(tmp)

pprint(u"\nComponents wrt (x\u0304, y\u0304):")

Rt = R.transpose()
tmp = R*T*Rt
tmp = tmp.applyfunc(simplify)
tmp = tmp.applyfunc(f)
pprint(tmp)
# tmp = latex(tmp,**kwargs)
# tmp = tmp.replace(".","{,}")
# pprint(tmp)
# exit()

pprint("\n(λ₁, λ₂):")
ev = T.eigenvals()
tmp = Matrix([max(ev), min(ev)])
tmp = tmp.applyfunc(f)
pprint(tmp)

pprint("\n(φ₁, φ₂) / °:")
t1 = Txy
t2 = (Txx - min(ev))
if (t1==0 and Txx < Tyy):
    p1 = pi/2
else:
    p1 = atan(t1/t2)
p1 /= deg
p2 = p1 + 90
p = Matrix([iso_round(p1,prec), iso_round(p2,prec)])
pprint(p)

pprint("\n(ψ₁, ψ₂) / °:")
q1 = p1 - 45
q2 = p1 + 45
q = Matrix([iso_round(q1,prec), iso_round(q2,prec)])
pprint(q)

Tensor-Komponente in vorgegebener Richtung (in 2D)

Lösung mit Python: Copy - Paste - Play

  • Copy: Source Code (siehe unten) aufklappen und kopieren.

  • Paste: Einfügen als Python-Notebook auf:

  • Play: Ausführen.

Source Code

# -*- coding: utf-8 -*-
from sympy.physics.units import *
from sympy import *

pprint("\nTensor Components:")
T = Matrix([
    [-1, 4],
    [ 4, 5]
    ])
pprint(T)

pprint("\nUnit Vector Components:")
d = Matrix([0, 1])
tmp = d.norm()
assert(tmp==1)
pprint(d)

pprint("\nTensor Component in Unit Vector Direction:")
tmp = d.transpose()*T*d
pprint(tmp)

Berechnung Komponente in versch. Bezugssystemen

Lösung mit Python: Copy - Paste - Play

  • Copy: Source Code (siehe unten) aufklappen und kopieren.

  • Paste: Einfügen als Python-Notebook auf:

  • Play: Ausführen.

Source Code

# -*- coding: utf-8 -*-
from sympy.physics.units import *
from sympy import *

"""
    Find normal stress using quantities wrt two different frames:

    1) (x,y)-frame and
    2) (xbar, ybar)-frame, with the (xbar, ybar)-placement specified by an angle.

    This program shows, that:

    * The stress tensor is a bilinear form.
    * The stress is found by applying this form to vectors.
    * The result is independent on which frame is used.

"""

# Shortcuts for cos(phi) and sin(phi):
C, S = var("C, S")

sxx, syy, txy = var("sigma_{xx}, sigma_{yy}, tau_{xy}")
vx, vy = var("vx, vy")

T = Matrix([[sxx, txy],[txy, syy]])

prec = 2
phi_deg = 90

sub_list=[
    (C, cos(phi_deg*pi/180)),
    (S, sin(phi_deg*pi/180)),
    (sxx, -1 *Pa),
    (syy,  5 *Pa),
    (txy, 4 *Pa),
    ]

# Rotation matrix:
R = Matrix([[C, S],[-S, C]])

pprint("\nphi in deg:")
tmp = phi_deg
pprint(tmp)


pprint("\n\nComponents wrt (x,y):")

pprint("\nStress tensor in Pa:")
tmp = T
tmp = tmp.subs(sub_list)
tmp /= Pa
pprint(tmp)

n = Matrix([C,S])
t = Matrix([-S,C])
nt = n.transpose()
tt = t.transpose()

pprint("\nNormal vector n:")
tmp = n
pprint(tmp)
pprint("\nTangent vector t:")
tmp = t
pprint(tmp)
pprint("\nTranspose n' of n:")
tmp = nt
pprint(tmp)
pprint("\nTranspose t' of t:")
tmp = tt
pprint(tmp)

pprint(u"\nσ = n' T n in Pa:")
tmp = nt*(T*n)
tmp = tmp[0]
tmp = tmp.subs(sub_list)
tmp /= Pa
pprint(N(tmp,prec))

pprint("\nτ = t' T n in Pa:")
tmp = tt*T*n
tmp = tmp[0]
tmp = tmp.subs(sub_list)
tmp /= Pa
pprint(N(tmp,prec))

# unicode utf overbar xbar ybar is \u0304:
pprint("\nComponents wrt (x\u0304,y\u0304):")

n = Matrix([1,0])
nt = n.transpose()
t = Matrix([0,1])
tt = t.transpose()
T = R*T*R.transpose()

pprint("\nStress tensor in Pa:")
tmp = T
tmp = tmp.subs(sub_list)
tmp /= Pa
pprint(tmp)

pprint("\nNormal vector n:")
tmp = n
pprint(tmp)
pprint("\nTranspose n' of n:")
tmp = nt
pprint(tmp)
pprint("\nTangent vector t:")
tmp = t
pprint(tmp)
pprint("\nTranspose t' of t:")
tmp = tt
pprint(tmp)

pprint(u"\nσ = n' T n in Pa:")
tmp = nt*(T*n)
tmp = tmp[0]
tmp = tmp.subs(sub_list)
tmp /= Pa
pprint(N(tmp,prec))

pprint("\nτ = t' T n in Pa:")
tmp = tt*T*n
tmp = tmp[0]
tmp = tmp.subs(sub_list)
tmp /= Pa
pprint(N(tmp,prec))

3D

Lösung mit Python: Copy - Paste - Play

  • Copy: Source Code (siehe unten) aufklappen und kopieren.

  • Paste: Einfügen als Python-Notebook auf:

  • Play: Ausführen.

Source Code

# -*- coding: utf-8 -*-
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

# ---
# LateX:
kwargs = {}
kwargs["mat_str"] = "bmatrix"
kwargs["mat_delim"] = ""

# Header ends here.

def get_R(phi, axis):
    c, s = cos(phi), sin(phi)
    if axis == "z":
        R = Matrix([
        [ c, s, 0],
        [-s, c, 0],
        [ 0, 0, 1],
        ])
    elif axis == "x":
        R = Matrix([
        [ 1, 0, 0],
        [ 0, c, s],
        [ 0,-s, c],
        ])
    elif axis == "y":
        R = Matrix([
        [ c, 0,-s],
        [ 0, 1, 0],
        [ s, 0, c],
        ])
    return R

phi = 10 *deg

pprint("\nTensor-Components:")

pprint("\n(x,y,z)-Comp.:")
# Txx, Txy, Txz =  -1,   4,  0
# Txy, Tyy, Tyz = Txy,   5,  0
# Txz, Tyz, Tzz = Txz, Tyz,  6
# R = get_R(phi,"z")

Txx, Txy, Txz = 666,   0,    0
Txy, Tyy, Tyz = Txy, 864,    0
Txz, Tyz, Tzz = Txz, Tyz,  216
R = get_R(phi,"x")

T = Matrix([
    [Txx, Txy, Txz],
    [Txy, Tyy, Tyz],
    [Txz, Tyz, Tzz]
    ])
pprint(T)

pprint("\n(x̄,ȳ,z̄)-Comp.:")
 = R*T*R.transpose()
tmp = 
tmp = iso_round(tmp, "0.01")
pprint(tmp)

Fußnoten:

1

Einheitenlose Größen: Die verwendeten einheitenlosen Größen sind definiert als die tatsächlichen Größen dividiert durch deren Einheit: Falls gegeben wäre eine Größe mit Einheit „Pascal“. Dann wäre die verwendete einheitenlose Größe gleich dieser gegebenen Größe dividiert durch „Pascal“.