Tensor-Komponenten

Videos

../../../_images/tensor-trafo_all.png

Passive Transformation (links) und aktive Transformation (rechts).

Symbole

\(\boldsymbol{a}\)

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

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{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}

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\).

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}\]

Eigenschaften der Passiven 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

Falls die Komponenten eines Tensors sowohl passiv wie auch aktiv transformiert werden, und falls hierbei gilt: \(\alpha=-\varphi\) bzw. gleichbedeutend \(\varphi = - \alpha\): Dann gilt:

\[\begin{split}\begin{bmatrix} T_{\bar x \bar x} & T_{\bar x\bar y} \\ \mathsf{sym} & T_{\bar y\bar y} \end{bmatrix} = \begin{bmatrix} T'_{xx} & T'_{xy} \\ \mathsf{sym} & T'_{yy} \end{bmatrix}\end{split}\]

Die transformierten Komponenten sind in diesem Fall also zahlenmäßig gleich - haben dabei aber verschiedene Bedeutungen.

SymPy

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

  2. Paste: Einfügen als Python-Notebook z.B. auf JupyterLite oder JupyterLab oder Colab.

  3. Play: Ausführen.

Source Code

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

deg  =  pi/180

# 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

# ---


# For output only:
Tbxx, Tbxy, Tbyy = var("Tx\u0304x\u0304, Tx\u0304y\u0304, Ty\u0304y\u0304")
Tpxx, Tpxy, Tpyy = var("T'xx, T'xy, T'yy")
Tb = Matrix([[Tbxx, Tbxy],[Tbxy, Tbyy]])
Tp = Matrix([[Tpxx, Tpxy],[Tpxy, Tpyy]])

# Output precision:
prec = "0.01"

def print_angle(angle):
    pprint("Angle / deg:")
    tmp = angle
    tmp /= deg
    tmp = iso_round(tmp,prec)
    pprint(tmp)
    

def get_R(angle, passive=True):
    c, s = cos(angle), sin(angle)
    R = Matrix([[c, s],[-s, c]])
    if passive == True:
        pprint("\nPassive Transformation")
        print_angle(angle)
        return R
    else:
        pprint("\nActive Transformation")
        print_angle(angle)
        return R.transpose()

Txx, Txy, Tyy = 1, 2, 3

pprint("\nT:")
T = Matrix([
    [Txx, Txy],
    [Txy ,Tyy]
    ])
pprint(T)

phi = 57 * deg
R = get_R(phi, passive=True)
pprint(Tb)
tmp = R*T*R.transpose()
tmp = iso_round(tmp,prec)
pprint(tmp)

alpha = 40 * deg
R = get_R(alpha, passive=False)
pprint(Tp)
tmp = R*T*R.transpose()
tmp = iso_round(tmp,prec)
pprint(tmp)

  • Lieber mit eigenem SymPy und offline? Es gibt z.B. Anaconda und Miniconda.

  • Statt SymPy lieber anderes CAS? Auswahl hier.

Web-App

Anleitung

  • Oben die Komponenten \((T_{xx}, T_{xy}, T_{yy})\) eintragen.

  • Unten am Schieberegler den Winkel \(\varphi\) einstellen.

  • Im Diagramm die transformierten Komponenten \((T_{\bar x \bar x}, T_{\bar x\bar y})\) ablesen.

180-Grad-Periodizität

Die Transformation ist definiert für jeden beliebigen gegebenen Winkel \(\varphi\). Aber in der Web-App ist \(-90^\circ \le \varphi \le 90^\circ\). Ist der gegebene Winkel außerhalb dieses Intervalls, dann addiert oder subtrahiert man ein Vielfaches von \(180^\circ\). Denn es gilt für jedes beliebige \(n\in\mathbb{N}:\)

\[\begin{split}T_{\bar x \bar x}(\varphi\pm n \cdot 180^\circ) &= T_{\bar x \bar x}(\varphi) \\ T_{\bar x \bar y}(\varphi\pm n \cdot 180^\circ) &= T_{\bar x \bar y}(\varphi)\end{split}\]

Beispiel:

\[\begin{split}T_{\bar x \bar x}(100^\circ) &= T_{\bar x \bar x}(-80^\circ) \\ T_{\bar x \bar y}(100^\circ) &= T_{\bar x \bar y}(-80^\circ) \\\end{split}\]

Tȳȳ ablesen als Tx̄x̄ für einen um 90 Grad größeren (oder kleineren) Winkel

Es gilt:

\[T_{\bar y \bar y}(\varphi) = T_{\bar x \bar x}(\varphi \pm 90^\circ)\]

Beispiel:

\[\begin{split}T_{\bar y \bar y}(10^\circ) &= T_{\bar x \bar x}(10^\circ \pm 90^\circ) \\ &= T_{\bar x \bar x}(-80^\circ)\end{split}\]

Für Aktive Transformation einstellen: φ = - α

Für \(\varphi = -\alpha\) gilt:

\[\begin{split}\begin{bmatrix} c_\alpha & -s_\alpha \\ s_\alpha & c_\alpha \end{bmatrix} &= \begin{bmatrix} c_\varphi & s_\varphi \\ -s_\varphi & c_\varphi \end{bmatrix} \\ R_\alpha &= R_\varphi\end{split}\]

Und damit:

\[\begin{split}\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}\end{split}\]

Beispiel:

\[\begin{split}T'_{xx}(\alpha = 20^\circ) &= T_{\bar x \bar x} (\varphi = -20^\circ) \\ T'_{xy}(\alpha = 20^\circ) &= T_{\bar x \bar y} (\varphi = -20^\circ)\end{split}\]

Einheitenlose Größen

Die verwendeten einheitenlosen Größen werden 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“.

Andere Ebenen

Entsprechende 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}\]

3D

  • In 2D können die Lagen zweier Bezugssystem sich nur unterscheiden in ihrer Winkelposition. Man braucht daher nur eine Zahl, um die Lage des einen Bezugssystems relativ zum anderen zu beschreiben.

  • In 3D braucht man hierfür drei Zahlen. Und es gibt viele Möglichkeiten, um die Lage des einen Bezugssystems relativ zum anderen zu beschreiben, siehe hier.

  • Drehungen in 3D lassen sich beschreiben als Hintereinanderschaltung von Drehungen in 2D - jeweils um eine Achse, die sich die Bezugssysteme „teilen“.

    Die Gesamt-Drehung lässt sich - wie in 2D - mit einer Drehmatrix \(R\) beschreiben.

\[\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}\]

Beispiele

  • Drehachse \(z = \bar z\)

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

\[\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 = \bar x\)

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

\[\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}\]

SymPy

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

  2. Paste: Einfügen als Python-Notebook z.B. auf JupyterLite oder JupyterLab oder Colab.

  3. 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
Tyy, Tyz = 864, 0
Tzz = 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)

  • Lieber mit eigenem SymPy und offline? Es gibt z.B. Anaconda und Miniconda.

  • Statt SymPy lieber anderes CAS? Auswahl hier.