```python
from sympy.physics.mechanics import ReferenceFrame,Point,dynamicsymbols
from sympy.physics.mechanics import Point
from sympy import latex,pprint,symbols,init_printing
from sympy.algebras.quaternion import Quaternion
import numpy as np
init_printing() # Para visualizar símbolos
```

## 2.1 Representación de la orientación de cuerpos

## 2.1.1 Matrices de rotación


```python
q1,q2=dynamicsymbols('q1,q2')
a=ReferenceFrame('A')
e=a.orientnew('E','Axis',(q1,a.y))
b=e.orientnew('B','Axis',(q2,e.z))

r1,r2,r3=symbols('r1,r2,r3')
r=r1*b.x+r2*b.y+r3*b.z
# Se define r por sus componentes en b
r
```


```python
# Recuerde que puede obtener las matrices de cosenos directores con el método dcm
# Por ejemplo ^A R^b
a.dcm(b) 
```




$\displaystyle \left[\begin{matrix}\cos{\left(\operatorname{q_{1}}{\left(t \right)} \right)} \cos{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & - \sin{\left(\operatorname{q_{2}}{\left(t \right)} \right)} \cos{\left(\operatorname{q_{1}}{\left(t \right)} \right)} & \sin{\left(\operatorname{q_{1}}{\left(t \right)} \right)}\\\sin{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & \cos{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & 0\\- \sin{\left(\operatorname{q_{1}}{\left(t \right)} \right)} \cos{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & \sin{\left(\operatorname{q_{1}}{\left(t \right)} \right)} \sin{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & \cos{\left(\operatorname{q_{1}}{\left(t \right)} \right)}\end{matrix}\right]$




```python
# ^A R^e
a.dcm(e)
```




$\displaystyle \left[\begin{matrix}\cos{\left(\operatorname{q_{1}}{\left(t \right)} \right)} & 0 & \sin{\left(\operatorname{q_{1}}{\left(t \right)} \right)}\\0 & 1 & 0\\- \sin{\left(\operatorname{q_{1}}{\left(t \right)} \right)} & 0 & \cos{\left(\operatorname{q_{1}}{\left(t \right)} \right)}\end{matrix}\right]$




```python
# Ahora calcule el producto de las dos rotaciones
a.dcm(e)*e.dcm(b)
```




$\displaystyle \left[\begin{matrix}\cos{\left(\operatorname{q_{1}}{\left(t \right)} \right)} \cos{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & - \sin{\left(\operatorname{q_{2}}{\left(t \right)} \right)} \cos{\left(\operatorname{q_{1}}{\left(t \right)} \right)} & \sin{\left(\operatorname{q_{1}}{\left(t \right)} \right)}\\\sin{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & \cos{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & 0\\- \sin{\left(\operatorname{q_{1}}{\left(t \right)} \right)} \cos{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & \sin{\left(\operatorname{q_{1}}{\left(t \right)} \right)} \sin{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & \cos{\left(\operatorname{q_{1}}{\left(t \right)} \right)}\end{matrix}\right]$




```python
# Obteniendo el mismo resultado con
a.dcm(b)
```




$\displaystyle \left[\begin{matrix}\cos{\left(\operatorname{q_{1}}{\left(t \right)} \right)} \cos{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & - \sin{\left(\operatorname{q_{2}}{\left(t \right)} \right)} \cos{\left(\operatorname{q_{1}}{\left(t \right)} \right)} & \sin{\left(\operatorname{q_{1}}{\left(t \right)} \right)}\\\sin{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & \cos{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & 0\\- \sin{\left(\operatorname{q_{1}}{\left(t \right)} \right)} \cos{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & \sin{\left(\operatorname{q_{1}}{\left(t \right)} \right)} \sin{\left(\operatorname{q_{2}}{\left(t \right)} \right)} & \cos{\left(\operatorname{q_{1}}{\left(t \right)} \right)}\end{matrix}\right]$




```python
# Usando el sistema simbólico puede verificar la igualdad de dos expresiones
a.dcm(e)*e.dcm(b)==a.dcm(b)
```




    True




```python
# Observe que el producto no es conmutativo
e.dcm(b)*a.dcm(e)==a.dcm(b)
```




    False



## Angulos de Euler


```python
a=ReferenceFrame('A')
phi,theta,psi=symbols('phi,theta,psi')
# Defina el marco de referencia D con rotaciones sucesivas XYZ
d=a.orientnew('D','Body',(phi,theta,psi),'XYZ')
# Esto es equivalente a tres rotaciones con marcos intermedios
e1=a.orientnew('E1','Axis',(phi,a.x))
e2=e1.orientnew('E2','Axis',(theta,e1.y))
e3=e2.orientnew('E3','Axis',(psi,e2.z))

print('rotx (^AR^E1):')
pprint(a.dcm(e1))
print('roty (^E1R^E2):')
pprint(e1.dcm(e2))
print('rotz (^E2R^E3):')
pprint(e2.dcm(e3))
```

    rotx (^AR^E1):
    ⎡1    0        0   ⎤
    ⎢                  ⎥
    ⎢0  cos(φ)  -sin(φ)⎥
    ⎢                  ⎥
    ⎣0  sin(φ)  cos(φ) ⎦
    roty (^E1R^E2):
    ⎡cos(θ)   0  sin(θ)⎤
    ⎢                  ⎥
    ⎢   0     1    0   ⎥
    ⎢                  ⎥
    ⎣-sin(θ)  0  cos(θ)⎦
    rotz (^E2R^E3):
    ⎡cos(ψ)  -sin(ψ)  0⎤
    ⎢                  ⎥
    ⎢sin(ψ)  cos(ψ)   0⎥
    ⎢                  ⎥
    ⎣  0        0     1⎦



```python
#El producto de estas rotaciones corresponde a ^AR^D
a.dcm(e1)*e1.dcm(e2)*e2.dcm(e3)
#a.dcm(e3)
```




$\displaystyle \left[\begin{matrix}\cos{\left(\psi \right)} \cos{\left(\theta \right)} & - \sin{\left(\psi \right)} \cos{\left(\theta \right)} & \sin{\left(\theta \right)}\\\sin{\left(\phi \right)} \sin{\left(\theta \right)} \cos{\left(\psi \right)} + \sin{\left(\psi \right)} \cos{\left(\phi \right)} & - \sin{\left(\phi \right)} \sin{\left(\psi \right)} \sin{\left(\theta \right)} + \cos{\left(\phi \right)} \cos{\left(\psi \right)} & - \sin{\left(\phi \right)} \cos{\left(\theta \right)}\\\sin{\left(\phi \right)} \sin{\left(\psi \right)} - \sin{\left(\theta \right)} \cos{\left(\phi \right)} \cos{\left(\psi \right)} & \sin{\left(\phi \right)} \cos{\left(\psi \right)} + \sin{\left(\psi \right)} \sin{\left(\theta \right)} \cos{\left(\phi \right)} & \cos{\left(\phi \right)} \cos{\left(\theta \right)}\end{matrix}\right]$



## 2.1.3 Rotaciones respecto a ejes fijos


```python
a=ReferenceFrame('A')
phi,theta,psi=symbols('phi,theta,psi')
# Defina el marco de referencia D con rotaciones en ejes fijos
# En el orden psi (en ax), theta (en ay), phi (en az)
b=a.orientnew('B','Space',(psi,theta,phi),'XYZ')
a.dcm(b)
```




$\displaystyle \left[\begin{matrix}\cos{\left(\phi \right)} \cos{\left(\theta \right)} & - \sin{\left(\phi \right)} \cos{\left(\psi \right)} + \sin{\left(\psi \right)} \sin{\left(\theta \right)} \cos{\left(\phi \right)} & \sin{\left(\phi \right)} \sin{\left(\psi \right)} + \sin{\left(\theta \right)} \cos{\left(\phi \right)} \cos{\left(\psi \right)}\\\sin{\left(\phi \right)} \cos{\left(\theta \right)} & \sin{\left(\phi \right)} \sin{\left(\psi \right)} \sin{\left(\theta \right)} + \cos{\left(\phi \right)} \cos{\left(\psi \right)} & \sin{\left(\phi \right)} \sin{\left(\theta \right)} \cos{\left(\psi \right)} - \sin{\left(\psi \right)} \cos{\left(\phi \right)}\\- \sin{\left(\theta \right)} & \sin{\left(\psi \right)} \cos{\left(\theta \right)} & \cos{\left(\psi \right)} \cos{\left(\theta \right)}\end{matrix}\right]$



## 2.1.4 Representación eje-angulo


```python
a=ReferenceFrame('A')
phi,nx,ny,nz=symbols('Phi,nx,ny,nz')
# Defina el vector n con componentes en A
n=nx*a.x+ny*a.y+nz*a.z
b=a.orientnew('B','Axis',(phi,n))
# Se utiliza el metodo subs para sustituir la norma L2 del vector como unitaria.
a.dcm(b).simplify().subs(nx**2+ny**2+nz**2,1)
```




$\displaystyle \left[\begin{matrix}nx^{2} + \left(ny^{2} + nz^{2}\right) \cos{\left(\Phi \right)} & nx ny \left(1 - \cos{\left(\Phi \right)}\right) - nz \sin{\left(\Phi \right)} & nx nz \left(1 - \cos{\left(\Phi \right)}\right) + ny \sin{\left(\Phi \right)}\\nx ny \left(1 - \cos{\left(\Phi \right)}\right) + nz \sin{\left(\Phi \right)} & ny^{2} + \left(nx^{2} + nz^{2}\right) \cos{\left(\Phi \right)} & - nx \sin{\left(\Phi \right)} + ny nz \left(1 - \cos{\left(\Phi \right)}\right)\\nx nz \left(1 - \cos{\left(\Phi \right)}\right) - ny \sin{\left(\Phi \right)} & nx \sin{\left(\Phi \right)} + ny nz \left(1 - \cos{\left(\Phi \right)}\right) & nz^{2} + \left(nx^{2} + ny^{2}\right) \cos{\left(\Phi \right)}\end{matrix}\right]$



## 2.1.5 Representación usando cuaterniones


```python
a=ReferenceFrame('A')
e0,e1,e2,e3=symbols('e0,e1,e2,e3')
b=a.orientnew('B','quaternion',(e0,e1,e2,e3))
a.dcm(b)
```




$\displaystyle \left[\begin{matrix}e_{0}^{2} + e_{1}^{2} - e_{2}^{2} - e_{3}^{2} & - 2 e_{0} e_{3} + 2 e_{1} e_{2} & 2 e_{0} e_{2} + 2 e_{1} e_{3}\\2 e_{0} e_{3} + 2 e_{1} e_{2} & e_{0}^{2} - e_{1}^{2} + e_{2}^{2} - e_{3}^{2} & - 2 e_{0} e_{1} + 2 e_{2} e_{3}\\- 2 e_{0} e_{2} + 2 e_{1} e_{3} & 2 e_{0} e_{1} + 2 e_{2} e_{3} & e_{0}^{2} - e_{1}^{2} - e_{2}^{2} + e_{3}^{2}\end{matrix}\right]$




```python
#Puede aplicar rotaciones sucesivas con cuaterniones
# usando la clase Quaternion
a1,a2,b1,b2,c1,c2,d1,d2=symbols('a1,a2,b1,b2,c1,c2,d1,d2')
# Defina los cuaterniones q1 y q2
q1=Quaternion(a1,b1,c1,d1)
q2=Quaternion(a2,b2,c2,d2)
# q3 producto de q1*q2
q3=q1*q2

# Defina el marco B con q3
b=a.orientnew('B','quaternion',q3.args)

# Alternativamente puede definir los marcos E1 y E2 con q1 y q2 respectivamente
e1=a.orientnew('E1','quaternion',q1.args)
e2=e1.orientnew('E2','quaternion',q2.args)

# Observe que el resultado es el mismo
a.dcm(e2).expand()==a.dcm(b).expand()
```




    True



## 2.2 Velocidad angular


```python
q1,q2=dynamicsymbols('q1,q2')
a=ReferenceFrame('A')
e=a.orientnew('E','Axis',(q1,a.y))
b=e.orientnew('B','Axis',(q2,-e.z))
# Puede calcular la velocidad angular de B respecto a A 
# con el método ang_vel_in.
b.ang_vel_in(a).express(b)
```

## 2.3 Velocidad angular y derivadas de vectores

## 2.3.1 Derivada de un vector fijo a un marco


```python
theta,phi,psi=dynamicsymbols('theta,phi,psi')
r1,r2,r3=symbols('r1,r2,r3')
a=ReferenceFrame('A')
b=a.orientnew('B','Body',(theta,phi,psi),'XYZ')
#Defina el vector r
r=r1*b.x+r2*b.y+r3*b.z
# Puede calcular la derivada total del vector r en A
r.dt(a)
```


```python
# Para calcular velocidades relativas entre marcos de referencia
# es mas conveniente crear objectos de la clase Point.
# Primero defina O como origen estacionario desde el marco de referencia A
O=Point('O')
O.set_vel(a,0)
# Ahora defina el punto R
r=O.locatenew('R',r1*b.x+r2*b.y+r3*b.z)
# Calcule la velocidad respecto a A
r.vel(a)
```

## 2.3.2 Relación entre derivadas en marcos diferentes


```python
# El punto r podría tener una velocidad diferente a 0
# En este caso defina las variables r1,r2,r3 como símbolos dinámicos
# (i.e. r1(t),r2(t),r3(t))
r1,r2,r3=dynamicsymbols('r1,r2,r3')
theta,phi,psi=dynamicsymbols('theta,phi,psi')
a=ReferenceFrame('A')
b=a.orientnew('B','Body',(theta,phi,psi),'XYZ')
O=Point('O')
O.set_vel(a,0)
# Ahora defina el punto R
r=O.locatenew('R',r1*b.x+r2*b.y+r3*b.z)
# Calcule la velocidad respecto a A y observe que aparecen los términos
# dr_i/dt, que corresponden a la velocidad de r en el marco B.
r.vel(a)
```


```python
# Aplicando esto para el caso del modelo giro-péndulo
q1,q2=dynamicsymbols('q1,q2')
# Variables de distancia l1: longitud del péndulo, R: radio del disco
l1,R=symbols('l1,R') 

#Defina marcos de referencia
a=ReferenceFrame('A')
e=a.orientnew('E','Axis',(q1,a.y))
b=e.orientnew('B','Axis',(q2,-e.z))

#Defina el punto de origen
O=Point('O')
O.set_vel(a,0)
# Ahora defina el punto Q en el centro del disco
q=O.locatenew('Q',l1*e.z)
# Defina el punto P en la periferia del disco
p=q.locatenew('P',R*b.y)

# Calcule la velocidad del vector w, definido desde Q hasta P. 
w=p.pos_from(q)
w.dt(a)
```

## 2.4 Velocidad angular simple


```python
# Para el ejemplo del modelo giro-péndulo observe
# la velocidad angular de E en A y de B en E. 
a=ReferenceFrame('A')
e=a.orientnew('E','Axis',(q1,a.y))
b=e.orientnew('B','Axis',(q2,-e.z))
e.ang_vel_in(a).express(e)
#b.ang_vel_in(e).express(e)
```

## 2.5 Teorema de adicion de velocidades angulares


```python
# Para el ejemplo del modelo giro-péndulo observe
# la velocidad angular de E en A y de B en E. 
a=ReferenceFrame('A')
e=a.orientnew('E','Axis',(q1,a.y))
b=e.orientnew('B','Axis',(q2,-e.z))
# Observe que la suma de las velocidades angulares corresponde a la velocidad angular
# del cuerpo B en el marco A.
e.ang_vel_in(a).express(e)+b.ang_vel_in(e).express(e)==b.ang_vel_in(a).express(e)
```




    True



## 2.6 Relación entre la velocidad angular y las representaciones de orientacion

## 2.6.1 Relación entre la velocidad angular y las representaciones de orientación


```python
a=ReferenceFrame('A')
phi,theta,psi=dynamicsymbols('phi,theta,psi')
# Defina el marco de referencia B con rotaciones sucesivas XYZ
b=a.orientnew('B','Body',(phi,theta,psi),'XYZ')
b.ang_vel_in(a).simplify()
```

### 2.6.3 Velocidad angular y parámetros de Euler


```python
a=ReferenceFrame('A')
e0,e1,e2,e3=dynamicsymbols('e0,e1,e2,e3')
b=a.orientnew('B','quaternion',(e0,e1,e2,e3))
# Calcule la velocidad angular expresada en términos del cuaternión
# Aqui se obtiene un factor 2 adicional a las expresiones del libro.
# Omega representa la velocidad angular de B en el marco A.
# Y esta rotacion es producida por el doble producto q ⊗ r ⊗ q *. 
# Puede pensar en esto como si el quaternion q realmente captura "media" rotación.
# Para mas detalles puede consultar el capítulo "Exponential map" en https://arxiv.org/pdf/1711.02508.pdf
b.ang_vel_in(a).simplify()

```

### 2.7 Aceleración angular


```python
# Para el ejemplo del modelo giro-péndulo observe
# la aceleración angular de E en A y de B en E. 
a=ReferenceFrame('A')
q1,q2=dynamicsymbols('q1,q2')
e=a.orientnew('E','Axis',(q1,a.y))
b=e.orientnew('B','Axis',(q2,-e.z))

b.ang_acc_in(a)
```

55719b8e606fdd4406a55f080d0123899b9428ba
ipynb
Jupyter Notebook
Capitulo_2/Capitulo2.ipynb
JonathanCamargo/Dinamica_Mecanica_Material_Interactivo
58fd21f1efccd1eda88f03e39cf69d122d280fdd
MIT
Capitulo_2/Capitulo2.ipynb
JonathanCamargo/Dinamica_Mecanica_Material_Interactivo
58fd21f1efccd1eda88f03e39cf69d122d280fdd
MIT
Capitulo_2/Capitulo2.ipynb
JonathanCamargo/Dinamica_Mecanica_Material_Interactivo
58fd21f1efccd1eda88f03e39cf69d122d280fdd
MIT
Qwen/Qwen-72B
1. YES
2. YES