Cette page reprend le contenu du notebook (+ quelques petites vidéos illustratives) avec les sorties des codes affichées pour les listes de données ci-dessous (qui peuvent servir de listes de secours).
Les données sont issue du pointage de la vidéo “parabolique” de l’application fizziq.
À l’éxécution de la première cellule (voir image ci-dessous), Colab vous demandera de vous connecter à un compte Google.
T = [0.000,0.033,0.066,0.099,0.132,0.165,0.198,0.231,0.264,0.297,0.330,0.363,0.396,0.429,0.462,0.495,0.528,0.561,0.594,0.627,0.660,0.693,0.726,0.759,0.792,0.825,0.858,0.891]
X = [0.776,0.743,0.713,0.680,0.651,0.618,0.588,0.553,0.523,0.486,0.459,0.430,0.396,0.363,0.332,0.298,0.265,0.233,0.209,0.174,0.145,0.115,0.094,0.069,0.037,0.011,-0.014,-0.036]
Y = [0.498,0.632,0.760,0.879,0.980,1.073,1.162,1.233,1.293,1.349,1.384,1.412,1.430,1.434,1.426,1.409,1.376,1.334,1.283,1.217,1.141,1.061,0.971,0.874,0.759,0.643,0.514,0.381]
Une fois vos propres mesures copiées, pensez à exécuter la cellule les contenant. Les cellules de code devront être exécutées les unes après les autres (ce ne sont pas des programmes indépendants ; une fois qu’une liste est en mémoire, elles l’est pour toutes les cellules exécutées ultérieurement).
Pour améliorer les résultats et les rendre plus visbles, on ne prend qu’un point sur deux.
t = T[::2]
x = X[::2]
y = Y[::2]
N = len(t)
Dt = t[1]-t[0]
print(N,Dt)
14 0.066
Dans la cellule suivante, on va tracer les positions de la balle ainsi que les vecteurs déplacement entre chaque point.
Le vecteur déplacement $\overrightarrow{MM’}$ entre $M$ et $M’$ est ici décomposé en un vecteur déplacement horizontal $\overrightarrow{{MM’}_x}$ et un vecteur déplacement vertical $\overrightarrow{{MM’}_y}$ (avec $\overrightarrow{MM’} = \overrightarrow{{MM’}_x} + \overrightarrow{{MM’}_y}$).
On ne veut pas qu’un seul vecteur déplacement mais plutôt les vecteurs déplacements entre chaque paire de points consécutifs.
Pour ça, on crée d’abord deux listes de $N-1$ éléments remplis de zéros ($N-1$ car on a $N$ points et donc $N-1$ déplacements entre ces points) appelées MMprime_x
et MMprime_y
.
Puis, à l’aide d’une boucle où la variable i
va aller de $0$ à $N-1$, on va remplacer chaque élément MMprime_x[i]
(valant jusqu’ici $0$) de la liste MMprime_x
par X[i+1]-X[i]
et chaque élément MMprime_y[i]
par Y[i+1]-Y[i]
.
import matplotlib.pyplot as plt
plt.style.use("seaborn-v0_8")
### Calcul de tous les vecteurs déplacement entre deux points consécutifs :
MMprime_x = [0 for i in range(N-1)]
MMprime_y = [0 for i in range(N-1)]
for i in range(N-1): # on s'arrête à l'avant-dernier point
MMprime_x[i] = x[i+1]-x[i]
MMprime_y[i] = y[i+1]-y[i]
### Tracés :
plt.figure(figsize=(12, 6),dpi=150)
plt.scatter(x, y, zorder=2)
for i in range(N-1):
plt.annotate('', xy=(x[i] + MMprime_x[i], y[i] + MMprime_y[i]), xytext=(x[i], y[i]), arrowprops=dict(facecolor='#00AB8E',edgecolor='none'), zorder=1)
plt.title('Représentation des positions de la balle et des vecteurs déplacement')
plt.xlabel('x (m)')
plt.ylabel('y (m)')
#plt.axis('equal')
plt.xlim(min(x)-0.1, max(x)+0.1)
plt.ylim(min(y)-0.1, max(y)+0.1)
Traçons ensuite les vecteurs vitesse à partir des vecteurs déplacement.
Vx[i]
et Vy[i]
à partir de MMprime_x[i]
et MMprime_y[i]
et de dt
(qui est défini dans la 1re cellule).Aide : il suffit d’appliquer la définition de la vitesse pour un déplacement $\overrightarrow{MM’}$ pendant une durée $dt$, mais comme on a décomposé le vecteur déplacement en une composante horizontale et une composante verticale, on se retrouve avec une vitesse horizontale $\vec{v_x}$ et une vitesse verticale $\vec{v_y}$.
# Calcul des vecteurs vitesse :
Vx = [0 for i in range(N-1)]
Vy = [0 for i in range(N-1)]
############ PARTIE À COMPLÉTER ############
for i in range(N-1):
Vx[i] =
Vy[i] =
############################################
# Positions des extrémités des vecteurs :
echelle = 1/10 # permet d'ajuster la taille des vecteurs
finVx = [0 for i in range(N-1)]
finVy = [0 for i in range(N-1)]
for i in range(N-1):
finVx[i] = x[i] + Vx[i]*echelle
finVy[i] = y[i] + Vy[i]*echelle
# Tracés :
plt.figure(figsize=(12, 8),dpi=150)
plt.scatter(x, y, zorder=2)
for i in range(N-1):
plt.annotate('', xy=(finVx[i], finVy[i]), xytext=(x[i], y[i]), arrowprops=dict(facecolor='#FFD932',edgecolor='#FEAE00'), zorder=1)
plt.text(x[i] + Vx[i]*echelle/2, y[i] + Vy[i]*echelle/1.5, f'{(Vx[i]**2+Vy[i]**2)**0.5:.1f} m/s', fontsize=9, color='#FEAE00')
plt.title('Représentation des positions de la balle et des vecteurs vitesses')
plt.xlabel('x (m)')
plt.ylabel('y (m)')
#plt.axis('equal')
plt.xlim(min(x+finVx)-0.1, max(x+finVx)+0.1)
plt.ylim(min(y+finVy)-0.1, max(y+finVy)+0.1)
On va maintenant étudier et tracer le vecteur “variation de vitesse” (différence entre le vecteur vitesse du point suivant et celui du point considéré). L’idée est d’étudier comment varie le vecteur vitesse puisque cette variation témoigne directement de l’action subie :
une force modifie le vecteur vitesse dans sa direction et son sens.
DVx[i]
et DVy[i]
.Aide : inspirez-vous du code ayant permis d’obtenire les vecteurs déplacements horizontaux et verticaux à partir des listes X
et Y
.
# Calcul des vecteurs "variation de la vitesse" :
DVx = [0 for i in range(N-2)]
DVy = [0 for i in range(N-2)]
############ PARTIE À COMPLÉTER ############
for i in range(N-2):
DVx[i] =
DVy[i] =
############################################
# Positions des extrémités des vecteurs :
echelle = 1/3
finDVx = [0 for i in range(N-2)]
finDVy = [0 for i in range(N-2)]
for i in range(N-2):
finDVx[i] = x[i] + DVx[i]*echelle
finDVy[i] = y[i] + DVy[i]*echelle
# Tracés :
plt.figure(figsize=(12, 6),dpi=150)
plt.scatter(x, y, zorder=2)
for i in range(N-2):
plt.annotate('', xy=(finDVx[i], finDVy[i]), xytext=(x[i], y[i]), arrowprops=dict(facecolor='#1DB100',edgecolor='none'), zorder=1)
plt.title('Représentation des positions de la balle et des vecteurs "variation de la vitesse"')
plt.xlabel('x (m)')
plt.ylabel('y (m)')
plt.xlim(min(x+finDVx)-0.1, max(x+finDVx)+0.1)
plt.ylim(min(y+finDVy)-0.1, max(y+finDVy)+0.1)
import math
liste_g = [0 for i in range(N-2)]
for i in range(N-2):
liste_g[i] = math.sqrt(DVx[i]**2+DVy[i]**2)/(Dt)
print(liste_g)
liste_g
? Donner leur expression générale.M = 0
for i in range(N-2):
M += G[i]
print(M/(N-2))
9.543053320035659
Théoriquement, nous aurions dû obtenir la figure suivante :