Vektor-Komponenten
Die Temperatur eines Teilchens auf einer Linealkante kann man beschreiben mit der Aussage: Die Teilchen-Temperatur ist gleich \(300 \, \mathrm{K}\) (Kelvin). Man verwendet eine Zahl mit Einheit. Mehr braucht man nicht.
Die Geschwindigkeit eines Teilchens auf einer Linealkante zu beschreiben, ist aufwändiger. Eine Zahl mit Einheit reicht nicht aus. Aber an kann sagen: Die Teilchen-Geschwindigkeit nach rechts ist gleich \(2 \tfrac{\mathrm{cm}}{\mathrm s}\) (Zentimeter pro Sekunde). Dazu äquivalent ist die Aussage: Die Teilchen-Geschwindigkeit nach links ist gleich \(-2 \tfrac{\mathrm{cm}}{\mathrm s}\).
Weil die Teilchen-Geschwindigkeit vektorwertig ist, braucht man eine Richtungsangabe. Um die Geschwindigkeit eines Teilchens auf einem Tisch (2D statt 1D) zu beschreiben, muss man zwei Bezugsrichtungen festlegen. Als erste Bezugsrichtung kann man z.B. „nach rechts“ festlegen. Und als zweite Bezugsrichtung kann man „nach oben“ festlegen. Die beiden Bezugsrichtungen bilden zusammen ein Bezugssystem.
Wenn sich ein Teilchen von links unten nach rechts oben bewegt, dann gilt für die Komponenten der Teilchen-Geschwindigkeit: Die Komponente „nach rechts“ ist positiv. Und die Komponente „nach oben“ ist auch positiv. Dies gilt aber nur für dieses Bezugssystem. Jemand, der ein anderes Bezugssystem verwendet, misst für dieselbe Teilchen-Geschwindigkeit andere Komponenten.
Vektor-Komponenten sind abhängig vom Bezugssystem. Und wenn man die Komponenten in einem Bezugssystem kennt, kann man daraus die Komponenten desselben Vektors in einem anderen Bezugssystem berechnen.
Die Umrechnung zwischen Komponenten in verschiedenen Bezugssystemen nennt man die Passive Transformation von Vektor-Komponenten. Und darum geht es hier. Und eine Passive Transformation gibt es auch für Tensor-Komponenten, denn um einen Tensor zahlenmäßig zu beschreiben, braucht man auch ein Bezugssystem - genau wie bei einem Vektor.
Videos
Passive Transformation (links) und Aktive Transformation (rechts).
Passive Transformation
Es gibt: das \(\left(x, y\right)\)-System, das \(\left(\bar x, \bar y\right)\)-System den Winkel \(\varphi\), um den das \(\left(\bar x, \bar y\right)\)-System relativ zum \((x, y)\)-System gedreht ist \(\begin{bmatrix} v_x \\ v_y \end{bmatrix}\): Die \(\left(x, y\right)\)-Komponenten des Vektors \(\begin{bmatrix} v_{\bar x} \\ v_{\bar y} \end{bmatrix}\): Die \((\bar x, \bar y)\)-Komponenten des Vektors die Umrechnungs-Formel = die „Passive Transformation“:Passive Transformation = 2 Bezugssysteme und 1 Vektor
Sei wie üblich \(x\) nach rechts und \(y\) nach oben, so dass die pos. Zählrichtung für \(\varphi\) entgegen dem Uhrzeigersinn ist. \((v_x, v_y)=(3, 0)\): Der rote Vektor zeigt nach rechts und hat Länge 3. \(\varphi=90^\circ\): Das blaue System ist relativ zum grünen um \(90^\circ\) entgegen dem Uhrzeigersinn gedreht. Die blaue \(\bar x\)-Achse liegt auf der grünen \(y\)-Achse und zeigt nach oben. Die blaue \(\bar y\)-Achse zeigt nach links.Beispiel 1
Sei wie üblich \(x\) nach rechts und \(y\) nach oben. \((v_x, v_y)=(0, 4)\) \(\varphi=180^\circ\) Die blaue \(\bar x\)-Achse zeigt nach links. Die blaue \(\bar y\)-Achse zeigt nach unten.Beispiel 2
\((v_x, v_y)=(3, 4)\) \(\varphi=10^\circ\)Beispiel 3
Aktive Transformation
Es gibt: das \(\left(x, y\right)\)-System den Vektor \(\boldsymbol v\) und den Vektor \(\boldsymbol v'\) den Winkel \(\alpha\), um den \(\boldsymbol v'\) relativ zu \(\boldsymbol v\) gedreht ist \(\begin{bmatrix} v_x \\ v_y \end{bmatrix}\): Die \(\left(x, y\right)\)-Komponenten des Vektors \(\begin{bmatrix} v'_x \\ v'_y \end{bmatrix}\): Die \((x, y)\)-Komponenten des gedrehten Vektors die Umrechnungs-Formel = die „Aktive Transformation“:Aktive Transformation = 1 Bezugssystem und 2 Vektoren
Sei wie üblich \(x\) nach rechts und \(y\) nach oben, so dass die pos. Zählrichtung für \(\alpha\) entgegen dem Uhrzeigersinn ist. \((v_x, v_y)=(0, 4)\) \(\alpha=90^\circ\) Der rote Vektor \(\boldsymbol v\) zeigt nach oben. Der blaue Vektor \(\boldsymbol v'\) ist um \(90^\circ\) entgegen dem Uhrzeigersinn relativ zum roten Vektor gedreht und zeigt darum nach links.Beispiel 1
Sei \(x\) und \(y\) wie üblich. \((v_x, v_y)=(0, 4)\) \(\alpha=-90^\circ\) Der rote Vektor \(\boldsymbol v\) zeigt nach oben. Der blaue Vektor ist um \(\alpha=-90^\circ\) entgegen dem Uhrzeigersinn relativ zum roten Vektor gedreht - also um \(90^\circ\) im Uhrzeigersinn. Er zeigt darum nach rechts.Beispiel 2
Sei \(x\) und \(y\) wie üblich. \((v_x, v_y)=(3, 4)\) \(-\alpha=10^\circ\) bzw. gleichbedeutend \(\alpha=-10^\circ\) Der blaue Vektor ist um \(10^\circ\) im Uhrzeigersinn relativ zum roten Vektor gedreht.Beispiel 3
Passive vs. Aktive Transformation
Gleiche Komponenten, aber andere Bedeutung
Für \(\alpha=-\varphi\) bzw. gleichbedeutend \(\varphi = - \alpha\) gilt:
Eine passive Transformation mit \(\varphi=30^\circ\) führt auf dieselben transformierten Komponenten wie eine aktive Transformation (desselben Vektors) mit \(\alpha = -30^\circ\).
Das Bezugssystem um 30 Grad entgegen dem Uhrzeigersinn zu drehen führt auf dieselben transformierten Komponenten wie den Vektor um 30 Grad im Uhrzeigersinn zu drehen.
Die transformierten Komponenten sind hierbei zahlenmäßig gleich - haben aber verschiedene Bedeutungen.
Web-App
Für Passive Transformation: Oben die Komponenten \((v_x, v_y)\) eintragen als einheitenlose Größen. Falls z.B. ein Vektor untersucht werden soll mit den Komponenten \(\left(3\,\tfrac{\mathrm{m}}{\mathrm{s}}, 4 \,\tfrac{\mathrm{m}}{\mathrm{s}}\right)\): Dann würde man oben eintragen: \((v_x, v_y) = (3, 4).\) Unten am Schieberegler den Winkel \(\varphi\) einstellen. Im Diagramm die transformierten Komponenten \((v_{\bar x}, v_{\bar y})\) ablesen. 360-Grad-Periodizität: Die Passive Transformation ist definiert für jeden beliebigen Winkel \(\varphi\). Es gilt für jedes beliebige \(n\in\mathbb{N}:\)Anleitung
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.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:
vbx, vby = var("vx\u0304, vy\u0304")
vpx, vpy = var("v'x, v'y")
vb = Matrix([vbx, vby])
vp = Matrix([vpx, vpy])
# 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()
pprint("\nv:")
v = Matrix([3 ,4])
pprint(v)
phi = 10 * deg
R = get_R(phi, passive=True)
pprint(vb)
tmp = R*v
tmp = iso_round(tmp,prec)
pprint(tmp)
alpha = 20 * deg
R = get_R(alpha, passive=False)
pprint(vp)
tmp = R*v
tmp = iso_round(tmp,prec)
pprint(tmp)
v:
⎡3⎤
⎢ ⎥
⎣4⎦
Passive Transformation
Angle / deg:
10.00
⎡vx̄⎤
⎢ ⎥
⎣vȳ⎦
⎡3.65⎤
⎢ ⎥
⎣3.42⎦
Active Transformation
Angle / deg:
20.00
⎡v'x⎤
⎢ ⎥
⎣v'y⎦
⎡1.45⎤
⎢ ⎥
⎣4.78⎦
3D Elementar-Drehungen
Es geht um Drehungen in 3D für den Spezialfall, dass um eine der 3 Achsen des Bezugssystems gedreht wird.
Viele Drehungen in der Technik lassen sich durch solche Drehungen oder die Hintereinanderschaltung solcher Drehungen beschreiben.
Weitere Infos zur Beschreibung von Drehungen siehe hier.
Weitere Infos zu Drehmatrizen siehe Wikipedia.
Drehachse \(z = \bar z\)
Drehachse \(x = \bar x\)
Zyklisches Vertauschen \((x,y,z)\mapsto(y, z, x)\) in (z) liefert:Details
Drehachse \(y = \bar y\)
Zyklisches Vertauschen \((x,y,z)\mapsto(z, x, y)\) in (z) liefert:Details
Programm
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 *
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
# Header ends here.
# https://en.wikipedia.org/wiki/Rotation_formalisms_in_three_dimensions
# https://en.wikipedia.org/wiki/Rotation_matrix
# https://en.wikipedia.org/wiki/Rodrigues%27_rotation_formula
def get_R(axis, angle):
c, s = cos(angle), sin(angle)
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],
])
else:
axis /= axis.norm()
e1, e2, e3 = axis[0], axis[1], axis[2]
K = Matrix([
[ 0, -e3, e2],
[ e3, 0, -e1],
[ -e2, e1, 0],
])
R = eye(3) - s*K + (1 - c)*K*K
return R
pprint("\nInput:")
pprint("\nRotation angle:")
angle = 30 *deg
pprint(angle)
pprint("\nRotation axis:")
axis = "y"
# axis = Matrix([0,4,0])
pprint(axis)
pprint("\n(x,y,z)-Comp. of Vector:")
v = Matrix([3,4,5])
pprint(v)
pprint("\n(x,y,z)-Comp. of Tensor:")
Txx, Txy, Txz = 666, 0, 0
Tyy, Tyz = 864, 0
Tzz = 216
T = Matrix([
[Txx, Txy, Txz],
[Txy, Tyy, Tyz],
[Txz, Tyz, Tzz]
])
pprint(T)
pprint("\nOutput:")
pprint("\nRotation-Matrix:")
R = get_R(axis, angle)
pprint(R)
pprint("\n(x̄,ȳ,z̄)-Comp. of Vector:")
v̄ = R*v
tmp = v̄
tmp = iso_round(tmp, "0.01")
pprint(tmp)
pprint("\n(x̄,ȳ,z̄)-Comp. of Tensor:")
Tbar = R*T*R.transpose()
tmp = Tbar
tmp = iso_round(tmp, "0.01")
pprint(tmp)
Input:
Rotation angle:
π
─
6
Rotation Matrix:
⎡√3 ⎤
⎢── 0 -1/2⎥
⎢2 ⎥
⎢ ⎥
⎢ 0 1 0 ⎥
⎢ ⎥
⎢ √3 ⎥
⎢1/2 0 ── ⎥
⎣ 2 ⎦
⎡√3 ⎤
⎢── 0 -1/2⎥
⎢2 ⎥
⎢ ⎥
⎢ 0 1 0 ⎥
⎢ ⎥
⎢ √3 ⎥
⎢1/2 0 ── ⎥
⎣ 2 ⎦
(x,y,z)-Comp. of Vector:
⎡3⎤
⎢ ⎥
⎢4⎥
⎢ ⎥
⎣5⎦
(x,y,z)-Comp. of Tensor:
⎡666 0 0 ⎤
⎢ ⎥
⎢ 0 864 0 ⎥
⎢ ⎥
⎣ 0 0 216⎦
Output:
(x̄,ȳ,z̄)-Comp. of Vector:
⎡0.1 ⎤
⎢ ⎥
⎢4.0 ⎥
⎢ ⎥
⎣5.83⎦
(x̄,ȳ,z̄)-Comp. of Tensor:
⎡553.5 0 194.86⎤
⎢ ⎥
⎢ 0 864.0 0 ⎥
⎢ ⎥
⎣194.86 0 328.5 ⎦
Infinitesimale Drehung
Falls gilt:
entstehen keine großen Fehler, wenn die Kosinusfunktion bzw. die Sinusfunktion ersetzt durch deren Linearisierungen (bei \(\varphi=0\)):
Wenn man diese Näherungen in einer Drehmatrix verwendet, spricht man einer Infinitesimalen Drehung.
Inverse Matrix
In den o.g. Beispielen sind die grünen Komponenten gegeben. Und die blauen Komponenten werden berechnet. Beispiel:
Wenn die blauen Komponenten gegeben sind und die grünen daraus berechnet werden, muss diese Gleichung von links mit \(R_\varphi^{-1}\) (nämlich mit der Inversen von \(R_\varphi\)) multipliziert werden:
Bei Drehmatrizen ist die Inverse gleich der Transponierten, so dass:
Vertauschen der Seiten und Einsetzen der Transponierten liefert:
Vektor-Komponente
Eine Vektor-Komponente ist der Anteil eines Vektors in einer bestimmten Richtung.
Diese Richtung wird definiert mit einem Einheitsvektor (entlang dieser Richtung).
Um eine Vektor-Komponenten zu berechnen, braucht man:
ein Bezugssystem, z.B. das \((x,y,z)\)-System.
die Komponenten des Vektors (bezüglich Bezugssystem): \(v_x, v_y, v_z\).
die Komponenten des Einheitsvektors (bezüglich Bezugssystem).
\(x\)- und \(y\)-Komponente
Sei die Richtung die \(x\)-Achse des Bezugssystems mit den \((x,y,z)\)-Komponenten \((1, 0, 0)\). Dann gilt für die Vektor-Komponente \(v_x\) in dieser Richtung:
\[\begin{split}v_x &= \begin{bmatrix}1 & 0 & 0 \end{bmatrix} \begin{bmatrix} v_x \\ v_y \\ v_z \end{bmatrix} \\ &= 1 v_x + 0 v_y + 0 v_z\end{split}\]
2D
In 2D z.B. in der \((x,y)\)-Ebene:
Sei die Richtung die \(y\)-Achse des Bezugssystems mit den \((x,y,z)\)-Komponenten \((0, 1, 0)\). Dann gilt für die Vektor-Komponente \(v_y\) in dieser Richtung:
\(\bar x\)- und \(\bar y\)-Komponente
Sei die Richtung die \(\bar x\)-Richtung. Weil \(\bar x\) um den Winkel \(\varphi\) relativ zu \(x\) gedreht ist, hat ein Einheitsvektor in \(\bar x\)-Richtung die \((x,y,z)\)-Komponenten \((c_\varphi, s_\varphi, 0)\). Und für die Vektor-Komponente \(v_{\bar x}\) in dieser Richtung gilt:
2D
In 2D z.B. in der \((x,y)\)-Ebene:
Sei die Richtung die \(\bar y\)-Richtung. Weil \(\bar y\) um den Winkel \(\varphi\) relativ zu \(y\) gedreht ist, hat ein Einheitsvektor in \(\bar y\)-Richtung die \((x,y,z)\)-Komponenten \((-s_\varphi, c_\varphi, 0)\). Und für die Vektor-Komponente \(v_{\bar y}\) in dieser Richtung gilt:
2D
In 2D z.B. in der \((x,y)\)-Ebene:
Dieselben Formeln werden in der Passiven Transformation verwendet.