C10 - 3.

Trajectoire parabolique - comparaison de la variation

du vecteur vitesse entre deux instants voisins et forces
L’étude du mouvement d’une balle de golf à partir d’une chronophotographie permet de tracer
les variations du vecteur vitesse au cours du temps. Cette construction permet d’estimer la valeur de g.
Capacité numérique mise en œuvre :
Utiliser un langage de programmation pour étudier la relation approchée entre :
la variation du vecteur vitesse d’un système modélisé par un point matériel entre deux instants voisins
et la somme des forces appliquées sur celui-ci.Les abscisses et ordonnées obtenues par pointage vidéo
sont entrées dans le fichier python.
import numpy as np
import matplotlib.pyplot as plt

x=np.array([0.01,0.41,0.91,1.39,1.86,2.33,2.81,3.33,3.79,4.31,4.83,5.36,5.86,6.34,6.77])
y=np.array([0.01,0.52,1.01,1.42,1.77,2.02,2.16,2.19,2.13,1.96,1.71,1.38,0.97,0.50,0])
#on génère automatiquement la liste contenant les instants associés t en utilisant l’intervalle de temps entre
deux images (0,10 s) et le nombre d’images (len(x))
t=0.1*np.arange(len(x)) #aux N valeurs de x et y on associe une valeur de t

1. affichage des positions enregistrées

#######################################################
import numpy as np
import matplotlib.pyplot as plt

x=np.array([0.01,0.41,0.91,1.39,1.86,2.33,2.81,3.33,3.79,4.31,4.83,5.36,5.86,6.34,6.77])
y=np.array([0.01,0.52,1.01,1.42,1.77,2.02,2.16,2.19,2.13,1.96,1.71,1.38,0.97,0.50,0])
t=0.1*np.arange(len(x))

#######################################################
###placer les positions dans le repère (x,y), elles sont représentées par des ronds rouges
plt.plot(x,y,"ro") #tracé du nuage de points
######################################################
### Finalisation de la représentation graphique
plt.axis([0, 8, -1, 3]) #graduations des axes
plt.xlabel("abscisse en m (ligne horizontale)") #écriture des légendes sur les axes
plt.ylabel("ordonnée en m (ligne verticale)")
plt.title("mouvement d'une balle lancée en chute libre : positions enregistrées") #écriture du titre du
document
plt.grid() #tracé d’une grille
#####################################################
plt.show() #affichage

2. Construction de la liste des vecteurs vitesse et tracé des vecteurs vitesse

Le script utilise deux listes : - l’une contenant les valeurs successives de la vitesse horizontale vx,
- l’autre, celles de la vitesse verticale vy.
Ces valeurs sont calculées une à une au moyen d’une boucle for puis ajoutées aux listes grâce à la
fonction append. Le script débute l’initialisation de la liste : la ligne vxl=[] crée une liste vide.
Puis pour chaque élément d’une liste redimensionnée (il est impossible de calculer x[i] pour i=0 et i=N),
#################################################
### Calcul des coordonnées et tracé des vecteurs vitesse
vx=[] ; vy=[] # on crée 2 listes vides
for i in range(1,len(x)-1): # on lance la boucle qui fait varier i de 1 à N-1
vx.append((x[i+1]-x[i-1])/(t[i+1]-t[i-1])) #valeur de la vitesse horizontale
vy.append( à compléter ) #valeur de la vitesse verticale
plt.quiver(x[i], y[i], vx[i-1], vy[i-1], color="purple",angles="xy",scale_units="xy",scale=5, width=0.003)
#on trace le vecteur vitesse de coordonnées {vx(i-1) ; vy(i-1)} au point de coordonnées {x(i) ; y(i)}
3. Construction de la liste des vecteurs variation de vitesse par unité de temps
Représentation de ces vecteurs
Avec exactement la même démarche, il est possible de faire calculer les variations des vitesses horizontales
et verticales par unité de temps. Il faut simplement, là encore, prendre garde à redimensionner les listes.

#####################################################
### Calcul des coordonnées et tracé de ces vecteurs
ax=[] ; ay=[]
for i in range( à compléter ):
ax.append((vx[i+1]-vx[i-1])/(t[i+1]-t[i-1]))
ay.append( à compléter ) #
plt.quiver(x[i+1],y[i+1],ax[i-1],ay[i-1], color="c",angles="xy",scale_units="xy",scale=15, width=0.003)
#on trace le vecteur de coordonnées {ax(i-1) ; ay(i-1)} au point de coordonnées {x(i+1) ; y(i+1)}
Il est alors possible de tracer les vecteurs variation de vitesse par unité de temps pour les diverses positions,
en prenant garde à l’affectation des points. En effet, la construction de la liste des valeurs de vitesse décale,
comme celle de l’accélération, de 1, la ième valeur de la liste ax, axl[i], correspond en fait à l’accélération
horizontale pour le point i+2.
On superpose un ensemble de vecteurs verticaux dont la norme est celle d’un champ de pesanteur
g = 9.8 m.s-2 et de coordonnées (0,-9.8)

for i in range( à compléter ):

plt.quiver( à compléter , color="y",angles="xy",scale_units="xy",scale=15, width=0.003)

4. Comparaison des valeurs

Pour préciser la comparaison, les valeurs successives de l’accélération verticale sont extraites,
puis tracées en fonction de la position.
Sur ce même graphe, sont ajoutées :
• une droite horizontale d’ordonnée constante égale à - 9,8 m.s-2 ;
• une droite horizontale dont l’ordonnée correspond à la moyenne des valeurs
de l’accélération verticale de la balle de golf.
De manière plus quantitative, on peut évaluer la pertinence d’une modélisation fondée sur l’utilisation
de la loi et considérant l’action unique du poids dans un champ de pesanteur supposé uniforme.

####################################################
###comparaison entre les valeurs de ay, de aymoyenne et-g
m=np.arange(0,len(t)-4) #variable ou abscisse des courbes à tracer et sa variation
ath=0*m-9.8 #accélération théorique ath égale à 9.8m.s-²
mod=np.polyfit(m,ay,0) #calcule la moyenne des toutes les accélérations réelles ay
moda=0*m+mod[0] #valeur de la moyenne obtenue
plt.plot(m,ay,'bo-',label= "ayréelle") #tracé de l’accélération réelle ay en bleu
plt.grid() #tracé d’un quadrillage
plt.ylim(-20,0) #limites des graduations de l’axe verticale
plt.plot(m,ath,'r-',label= "-g") #tracé de l’accélération théorique –g en rouge
plt.plot(m,moda,'g-',label= "aymoyenne") #tracé de l’accélération aymoyenne en vert
plt.xlabel("points de la trajectoire") #légende axe des abscisses
plt.ylabel("accélération verticale réelle") #légende axe des ordonnées
plt.title("Comparaison entre l’accélération et le champ de pesanteur") #titre du graphique
plt.legend()
plt.grid()
print(round(mod[0],1)) #écrit la valeur de mod, la moyenne de ay

#####################################################
plt.show()