Python - Wykreślanie wektorów prędkości i przyspieszenia w pewnych punktach

Question

Tutaj mam równanie parametryczne.

import matplotlib.pyplot as plt 
import numpy as np 
from mpl_toolkits.mplot3d import Axes3D 

t = np.linspace(0,2*np.pi, 40) 

# Position Equation 
def rx(t): 
    return t * np.cos(t) 
def ry(t): 
    return t * np.sin(t) 

# Velocity Vectors 
def vx(t): 
    return np.cos(t) - t*np.sin(t) 
def vy(t): 
    return np.sin(t) + t*np.cos(t) 

# Acceleration Vectors 
def ax(t): 
    return -2*np.sin(t) - t*np.cos(t) 

def ay(t): 
    return 2*np.cos(t) - t*np.sin(t) 

fig = plt.figure() 
ax1 = fig.gca(projection='3d') 

z = t 
ax1.plot(rx(z), r(z), z) 
plt.xlim(-2*np.pi,2*np.pi) 
plt.ylim(-6,6) 
ax.legend() 

Więc mam to równanie parametryczne, które tworzy ten wykres.

Mam zdefiniowane moje prędkości i przyspieszenia parametryczne równania powyżej w moim kodu.

Co chcę zrobić, to wykreślić wektory przyspieszenia i prędkości na powyższym wykresie pozycji w określonych punktach. (Id est, t = pi/2, 3pi/2, 2pi)

coś takiego:

Python/matplotlib : plotting a 3d cube, a sphere and a vector?

ale chcę zrobić coś więcej proste, ponieważ mam do definiowania każdy punkt t w dwa równania.

Czy coś takiego jest możliwe? Mogę tylko znaleźć pola wektorowe, a co nie.

Coś takiego.

Dziękuję.

Edit Pytanie

# t = pi/4 

t_val_start_pi4 = np.pi/4 
vel_start_pi4 = [rx(t_val_start_pi4), ry(t_val_start_pi4), t_val_start_pi4] 

vel_end_pi4 = [rx(t_val_start_pi4) + vx(t_val_start_pi4), ry(t_val_start_pi4)+vy(t_val_start_pi4), t_val_start_pi4 ] 

vel_vecs_pi4 = (t_val_start_pi4 , vel_end_pi4) 

vel_arrow_pi4 = Arrow3D(vel_vecs_pi4[0],vel_vecs_pi4[1], vel_vecs_pi4[2], mutation_scale=20, lw=1, arrowstyle="-|>", color="b") 

axes.add_artist(vel_arrow_pi4) 

To da mi błąd mówiąc Tuple out of index

Answer 1

czuję się jak to jest blisko ... Nawet dostał kolory, aby dopasować obraz próbki :)

Nie jestem jednak zbyt doświadczony w wykreślaniu współrzędnych biegunowych (głównie w pomiarze na współrzędnej trzeciego wymiaru t).

Mam nadzieję, że to pomoże i można dowiedzieć się, jak rozszerzyć to

Wziąłem co miałeś dodał klasę Arrow3D z this answer i dodał prosty dla pętli nad jakimiś wartościami próbek z t.

#draw a vector 
from matplotlib.patches import FancyArrowPatch 
from mpl_toolkits.mplot3d import proj3d 

class Arrow3D(FancyArrowPatch): 
    def __init__(self, xs, ys, zs, *args, **kwargs): 
     FancyArrowPatch.__init__(self, (0,0), (0,0), *args, **kwargs) 
     self._verts3d = xs, ys, zs 

    def draw(self, renderer): 
     xs3d, ys3d, zs3d = self._verts3d 
     xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, renderer.M) 
     self.set_positions((xs[0],ys[0]),(xs[1],ys[1])) 
     FancyArrowPatch.draw(self, renderer) 

---

axes = fig.gca(projection='3d') 

t_step = 8 
for t_pos in range(0, len(t)-1, t_step): 
    t_val_start = t[t_pos] 
#  t_val_end = t[t_pos+1] 

    vel_start = [rx(t_val_start), ry(t_val_start), t_val_start] 
    vel_end = [rx(t_val_start)+vx(t_val_start), ry(t_val_start)+vy(t_val_start), t_val_start] 
    vel_vecs = list(zip(vel_start, vel_end)) 
    vel_arrow = Arrow3D(vel_vecs[0],vel_vecs[1],vel_vecs[2], mutation_scale=20, lw=1, arrowstyle="-|>", color="g") 
    axes.add_artist(vel_arrow) 

    acc_start = [rx(t_val_start), ry(t_val_start), t_val_start] 
    acc_end = [rx(t_val_start)+ax(t_val_start), ry(t_val_start)+ay(t_val_start), t_val_start] 
    acc_vecs = list(zip(acc_start, acc_end)) 
    acc_arrow = Arrow3D(acc_vecs[0],acc_vecs[1],acc_vecs[2], mutation_scale=20, lw=1, arrowstyle="-|>", color="m") 
    axes.add_artist(acc_arrow) 

axes.plot(rx(t), ry(t), t) 
plt.xlim(-2*np.pi,2*np.pi) 
plt.ylim(-6,6)