Vektor-Komponenten

Videos

Symbole

Winkel

zählt pos.

zeigt Winkelpos. von

relativ zu

\(\varphi\)

um \(z=\bar z\)

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

\((x, y)\)

\(\alpha\)

um \(z=\bar z\)

\(\boldsymbol v'\)

\(\boldsymbol v\)

Vektor

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

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

\(\boldsymbol v\)

\(\begin{bmatrix} v_{x}\\ v_{y} \end{bmatrix}\)

\(\begin{bmatrix} v_{\bar x} \\ v_{\bar y} \end{bmatrix}\)

\(\boldsymbol v'\)

\(\begin{bmatrix} v'_{x} \\ v'_{y} \end{bmatrix}\)

nicht definiert

Passive und aktive Transformation

../../../_images/M.2.F_all.png

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

Passive Transformation

1 Vektor & 2 Bezugssysteme: Die \((\bar x, \bar y)\)-Komponenten desselben Vektors 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}\begin{bmatrix} v_{\bar x} \\ v_{\bar y} \end{bmatrix}= \underbrace{ \begin{bmatrix} c_\varphi & s_\varphi \\ -s_\varphi & c_\varphi \end{bmatrix} }_{R_\varphi} \begin{bmatrix} v_x \\ v_y \end{bmatrix}\end{split}\]

Beispiel 1

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.

\[\begin{split}\begin{bmatrix} v_{\bar x} \\ v_{\bar y} \end{bmatrix} &= \begin{bmatrix} c_{90^\circ} & s_{90^\circ} \\ -s_{90^\circ} & c_{90^\circ} \end{bmatrix} \begin{bmatrix} 3 \\ 0 \end{bmatrix} \\ &= \begin{bmatrix} 0 & 1 \\ -1 & 0 \end{bmatrix} \begin{bmatrix} 3 \\ 0 \end{bmatrix} \\ &= \begin{bmatrix} 0 \\ -3 \end{bmatrix}\end{split}\]

Beispiel 2

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.

\[\begin{split}\begin{bmatrix} v_{\bar x} \\ v_{\bar y} \end{bmatrix} &= \begin{bmatrix} c_{180^\circ} & s_{180^\circ} \\ -s_{180^\circ} & c_{180^\circ} \end{bmatrix} \begin{bmatrix} 0 \\ 4 \end{bmatrix} \\ &= \begin{bmatrix} -1 & 0 \\ 0 & -1 \end{bmatrix} \begin{bmatrix} 0 \\ 4 \end{bmatrix} \\ &= \begin{bmatrix} 0 \\ -4 \end{bmatrix}\end{split}\]

Beispiel 3

  • \((v_x, v_y)=(3, 4)\)

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

\[\begin{split}\begin{bmatrix} v_{\bar x} \\ v_{\bar y} \end{bmatrix} &= \begin{bmatrix} c_{10^\circ} & s_{10^\circ} \\ -s_{10^\circ} & c_{10^\circ} \end{bmatrix} \begin{bmatrix} 3 \\ 4 \end{bmatrix} \\ &\stackrel{0{,}01}{\approx} \begin{bmatrix} 3{,}65 \\ 3{,}42 \end{bmatrix}\end{split}\]

Vektor-Komponente

Der Anteil eines Vektors in einer bestimmten Richtung (Einheitsvektor \(\boldsymbol e\)) heißt Vektor-Komponente in dieser Richtung:

  • Die skalarwertige Vektor-Komponente \(v_e\) in Richtung \(\boldsymbol e\) ist:

    \[v_e = \boldsymbol e \cdot \boldsymbol v\]
  • Die vektorwertige Vektor-Komponente \(\boldsymbol v_e\) in Richtung \(\boldsymbol e\) ist:

    \[\boldsymbol v_e = v_e \boldsymbol e\]

Zeigt der Einheitsvektor \(\boldsymbol e\) z.B. in Richtung \(\bar x\) und ist \(\bar x\) wie oben um \(\varphi\) relativ zu \(x\) gedreht: Dann gilt:

\[\begin{split}v_e &= \begin{bmatrix} c_\varphi & s_\varphi \end{bmatrix} \begin{bmatrix} v_x \\ v_y \end{bmatrix} \\ &= \begin{bmatrix} 1 & 0 \end{bmatrix} \begin{bmatrix} v_{\bar x} \\ v_{\bar y} \end{bmatrix} \\ &= v_{\bar x}\end{split}\]
  • \(v_{\bar x}\) ist die skalarwertige Vektor-Komponente in Richtung \(\bar x\).

  • \(v_{\bar y}\) ist die skalarwertige Vektor-Komponente in Richtung \(\bar y\).

  • \(v_{e}\) ist die skalarwertige Vektor-Komponente in Richtung des Vektors \(\boldsymbol e\).

Aktive Transformation

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

\[\begin{split}\begin{bmatrix} v'_{x} \\ v'_{y} \end{bmatrix} = \begin{bmatrix} c_\alpha & -s_\alpha \\ s_\alpha & c_\alpha \end{bmatrix} \begin{bmatrix} v_x \\ v_y \end{bmatrix}\end{split}\]

Beispiel 1

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.

\[\begin{split}\begin{bmatrix} v'_{x} \\ v'_{y} \end{bmatrix} &= \begin{bmatrix} c_{90^\circ} & -s_{90^\circ} \\ s_{90^\circ} & c_{90^\circ} \end{bmatrix} \begin{bmatrix} 0 \\ 4 \end{bmatrix} \\ &= \begin{bmatrix} 0 & -1 \\ 1 & 0 \end{bmatrix} \begin{bmatrix} 0 \\ 4 \end{bmatrix} \\ &= \begin{bmatrix} -4 \\ 0 \end{bmatrix}\end{split}\]

Beispiel 2

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.

\[\begin{split}\begin{bmatrix} v'_{x} \\ v'_{y} \end{bmatrix} &= \begin{bmatrix} c_{-90^\circ} & -s_{-90^\circ} \\ s_{-90^\circ} & c_{-90^\circ} \end{bmatrix} \begin{bmatrix} 0 \\ 4 \end{bmatrix} \\ &= \begin{bmatrix} 0 & 1 \\ -1 & 0 \end{bmatrix} \begin{bmatrix} 0 \\ 4 \end{bmatrix} \\ &= \begin{bmatrix} 4 \\ 0 \end{bmatrix}\end{split}\]

Beispiel 3

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.

\[\begin{split}\begin{bmatrix} v'_{x} \\ v'_{y} \end{bmatrix} &= \begin{bmatrix} c_{-10^\circ} & -s_{-10^\circ} \\ s_{-10^\circ} & c_{-10^\circ} \end{bmatrix} \begin{bmatrix} 3 \\ 4 \end{bmatrix} \\ &\stackrel{0{,}01}{\approx} \begin{bmatrix} 3{,}65 \\ 3{,}42 \end{bmatrix}\end{split}\]

Zusammenhang zwischen Aktiver und Passiver Transformation

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

\[\begin{split}\begin{bmatrix} v_{\bar x} \\ v_{\bar y} \end{bmatrix} = \begin{bmatrix} v'_{x} \\ v'_{y} \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:
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)

  • 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 \((v_x, v_y)\) eintragen.

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

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

360-Grad-Periodizität

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

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

Beispiel:

\[\begin{split}v_{\bar x}(200^\circ) &= v_{\bar x}(-160^\circ) \\ v_{\bar y}(200^\circ) &= v_{\bar y}(-160^\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} v'_{x} \\ v'_{y} \\ \end{bmatrix} = \begin{bmatrix} v_{\bar x} \\ v_{\bar y} \\ \end{bmatrix}\end{split}\]

Beispiel:

\[\begin{split}v'_{x}(\alpha = 20^\circ) &= v_{\bar x} (\varphi = -20^\circ) \\ v'_{y}(\alpha = 20^\circ) &= v_{\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 „Meter pro Sekunde“. Dann wäre die verwendete einheitenlose Größe gleich dieser gegebenen Größe dividiert durch „Meter pro Sekunde“.

3D: Beispiele

Es geht um:

  • zwei Bezugssysteme: Das grüne \((x,y,z)\)-System und das blaue \((\bar x, \bar y,\bar z)\)-System.

  • die Drehung des \((\bar x, \bar y, \bar z)\)-Systems relativ zum \((x, y, z)\)-System um \(z = \bar z\) oder \(x=\bar x\) oder \(y=\bar y\).

  • die Umrechnung von Vektor- und Tensorkomponenten unter diesem Wechsel des Bezugssystems.

  • die Passive Transformation in 3D für den Spezialfall, dass um eine der 3 Achsen des Bezugssystems gedreht wird.

Drehachse z = z̄

../../../_images/trafo_vector_3D_z.png

Drehachse x = x̄

../../../_images/trafo_vector_3D_x.png

Details

Zyklisches Vertauschen \((x,y,z)\mapsto(y, z, x)\) in (z) liefert:

\[\begin{split}\begin{bmatrix} v_{\bar y} \\ v_{\bar z} \\ v_{\bar x} \\ \end{bmatrix} &= \begin{bmatrix} c_\varphi & s_\varphi & 0 \\ -s_\varphi & c_\varphi& 0 \\ 0 & 0 & 1 \\ \end{bmatrix} \begin{bmatrix} v_y \\ v_z \\ v_x \\ \end{bmatrix} \\ \leadsto \begin{bmatrix} v_{\bar x} \\ v_{\bar y} \\ v_{\bar z} \\ \end{bmatrix} &= \begin{bmatrix} 0 & 0 & 1 \\ c_\varphi & s_\varphi & 0 \\ -s_\varphi & c_\varphi& 0 \\ \end{bmatrix} \begin{bmatrix} v_y \\ v_z \\ v_x \\ \end{bmatrix} \\ &= \begin{bmatrix} 1 & 0 & 0 \\ 0 & c_\varphi & s_\varphi \\ 0 & -s_\varphi & c_\varphi \\ \end{bmatrix} \begin{bmatrix} v_x \\ v_y \\ v_z \\ \end{bmatrix}\end{split}\]

Drehachse y = ȳ

../../../_images/trafo_vector_3D_y.png

Details

Zyklisches Vertauschen \((x,y,z)\mapsto(z, x, y)\) in (z) liefert:

\[\begin{split}\begin{bmatrix} v_{\bar z} \\ v_{\bar x} \\ v_{\bar y} \\ \end{bmatrix} &= \begin{bmatrix} c_\varphi & s_\varphi & 0 \\ -s_\varphi & c_\varphi& 0 \\ 0 & 0 & 1 \\ \end{bmatrix} \begin{bmatrix} v_z \\ v_x \\ v_y \\ \end{bmatrix} \\ \leadsto \begin{bmatrix} v_{\bar x} \\ v_{\bar y} \\ v_{\bar z} \\ \end{bmatrix} &= \begin{bmatrix} -s_\varphi & c_\varphi& 0 \\ 0 & 0 & 1 \\ c_\varphi & s_\varphi & 0 \\ \end{bmatrix} \begin{bmatrix} v_z \\ v_x \\ v_y \\ \end{bmatrix} \\ &= \begin{bmatrix} c_\varphi & 0 & -s_\varphi\\ 0 & 1 & 0 \\ s_\varphi & 0 & c_\varphi \\ \end{bmatrix} \begin{bmatrix} v_x \\ v_y \\ v_z \\ \end{bmatrix}\end{split}\]

Für Drehung um um beliebige Achsen siehe hier.

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("\n(x,y,z)-Comp.:")
v = Matrix([3,4,5])
R = get_R(phi,"z")
pprint(v)

# v = Matrix([5,3,4])
# R = get_R(phi,"x")
# pprint(v)

# v = Matrix([4,5,3])
# R = get_R(phi,"y")
# pprint(v)

pprint("\n(x̄,ȳ,z̄)-Comp.:")
 = R*v
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.