TP variation de vitesse

Lien vers notebook Colab

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

Vecteurs déplacement

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)

Vecteurs vitesse

Traçons ensuite les vecteurs vitesse à partir des vecteurs déplacement.

  1. Complétez le code permettant de calculer 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)

Vecteurs variation de vitesse

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.

  1. Complétez le code permettant de calculer 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)

  1. Que peut-on dire de la résultante des forces dans l’expérience ? Donner son expression.
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)
  1. À quoi correspondent les éléments de 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

  1. Qu’est calculé dans la cellule précédente. Que cela permet-il de confirmer ?

Théoriquement, nous aurions dû obtenir la figure suivante :

  1. Pourquoi n’est-ce pas tout à fait le cas selon vous ?