TangenteX.com

La chute d'un corps

Quelques généralités d'abord

Nous voulons simuler le mouvement d'un corps solide, une balle de tennis par exemple, dans le champ de gravité terrestre. En d'autres termes, voir comment se comporte une balle qui tombe ! Pour corser le problème et le rendre plus réaliste, nous allons supposer que la balle est lancée horizontalement, avec une certaine vitesse. On ne s'occupera pas de détails comme la résistance de l'air, la poussée d'Archimède ou autres joyeusetés du genre...
Un corps en mouvement dans l'espace change de position au cours du temps. On appelle "trajectoire" le lieu de l'ensemble des positions dans l'espace en fonction du temps. Pour simuler le mouvement de la balle de tennis, nous allons donc construire sa trajectoire. Et pour ce faire, nous devons déterminer deux objets :

  • un repère, qui nous permettra de noter la position de la balle par ses coordonnées. En principe, la balle bouge dans un espace à 3 dimensions, mais pour simplifier, on se contentera des 2 dimensions du plan. Notre repère sera donc le repère Oxy que vous connaissez.
  • une horloge. Pour calculer chaque point de la trajectoire, il faut mesurer le temps qui passe ! Et donc posséder une horloge que l'on déclenchera au début du mouvement.

Mais on a un problème ! Dans une simulation, le temps et l'espace ne sont pas continus. Cela veut dire qu'entre l'instant t1 et l'instant t2, il n'y a RIEN. De même, entre l'abscisse x1 et l'abscisse x2, il n'y a rien non plus !
Pour faire savant, on dit que l'on "discrétise" le temps et l'espace: ils ne sont plus continus, ils sont discrets! Vous verrez plus tard que c'est un aspect très important de la simulation numérique...
En ayant présent à l'esprit ces quelques points, voyons comment construire cette simulation.

Le modèle

Définissons d'abord un repère orthonormé, muni de deux vecteurs unitaires \( \overrightarrow{u} \) et  \( \overrightarrow{v} \).
A l'origine du mouvement, les coordonnées de la balle sont (x0,y0). x0 vaut 0 et y0 est un paramètre du modèle : je pourrais le faire varier comme je veux.
Je lance la balle à une vitesse \( \overrightarrow{v_0} \),horizontalement.

 

Je vais maintenant observer ce qui se passe peu de temps après l'instant où j'ai lancé la balle (le t0). C'est là qu'intervient notre horloge. Je vais fixer un intervalle de temps petit, que j'appelle \( \Delta t \), et je vais observer ce qui se passe à \( t_0 + \Delta t \).

Les nouvelles coordonnées de la balle sont (x,y). Et notre problème est de déterminer, à l'instant \( t_0 + \Delta t \), les valeurs de x et y.

Faisons le bilan des forces qui s'exercent sur la balle:

1 - son poids.

2 - la vitesse horizontale. Elle ne varie pas.

La balle subit une accélération qu'il faut décomposer en une:

  • accélération verticale, qui est égale à \( \overrightarrow{g} \). Vous savez en effet que le poids est proportionnel à \( \overrightarrow{g} \), selon la célèbre formule \( \overrightarrow{p} = m\overrightarrow{g} \),
  • accélération horizontale, qui est nulle. En effet, la vitesse horizontale est constante, ce qui implique d'après la première loi de Newton, que l'accélération est nulle.

Voilà le bilan. Mais quoi faire de ces données pour évaluer le mouvement de la balle dans un court intervalle de temps ?
Il faut se souvenir de plusieurs choses, qui découlent des définitions de l'accélération et de la vitesse:

  • sur un court intervalle de temps, l'augmentation (ou la diminution) de la vitesse est égale au produit de l'accélération par l'intervalle de temps. Par exemple, une voiture qui accélère à 5 m.s-1 par seconde voit sa vitesse augmenter de 5 m.s-1 au bout d'une seconde.
  • sur un court intervalle de temps, la distance parcourue est égale au produit de la vitesse par le temps. Par exemple, la même voiture qui roule à 30 m.s-1 parcoure 30 m en 1 seconde.

Essayons de traduire ces informations sous forme d'équations.

  • Je sais que la vitesse horizontale est constante et égale à \( \overrightarrow{v_0}\)
  • Si j'appelle vi la vitesse verticale de la balle à l'instant ti, et vi+1 la vitesse verticale de la balle à l'instant ti+1, je peux écrire \( v_{i+1} - v_i = -g \Delta t \),  \( \Delta t \) étant l'intervalle de temps (0,1 seconde par exemple). Vous noterez le signe moins qui affecte g. Vous avez remarqué que le poids est orienté vers le bas, et donc que g est aussi orienté vers le bas : la balle tombe, n'est-ce pas! Plus mathématiquement, le vecteur \( \overrightarrow{p} \) s'écrit \( \overrightarrow{p} = -mg\overrightarrow{v} \), puisque le vecteur \( \overrightarrow{p} \) et le vecteur unitaire \( \overrightarrow{v} \) sont de sens opposé. Et donc la norme du vecteur \( \overrightarrow{p} \) est égale à -mg.
  • Si j'appelle xi l'abscisse de la balle à l'instant ti, et xi+1 l'abscisse de la balle à l'instant ti+1, je peux écrire \( x_{i+1} - x_i = -v_0 \Delta t \),
  • Si j'appelle yi l'ordonnée de la balle à l'instant ti, et yi+1 l'ordonnée de la balle à l'instant ti+1, je peux écrire \( y_{i+1} - y_i = v \Delta t \), où v est la vitesse verticale de la balle.

Voilà tous les éléments pour établir l'algorithme de simulation.

L'algorithme

Je veux calculer la trajectoire de la balle depuis sa position d'origine jusqu'à ce qu'elle atteigne le sol. Pour cela, je vais calculer les coordonnées (x,y) de chaque point de la trajectoire de proche en proche en partant de l'origine (x0,y0) à t0, par petits intervalles de temps, jusqu'à ce que l'abscisse de la balle soit nulle.
Voyons le structure globale de l'algorithme, qui reprend toutes les données exposées ci-dessus:

x(1) = 0
y(1) = y0
VitesseVerticale(1) = 0
TantQue y(i-1) > 0 Faire
  VitesseVerticale(i) = VitesseVerticale(i-1) - g*deltat
  x(i) = x(i-1) + v0*deltat
  y(i) = y(i-1) + VitesseVerticale(i)*deltat
  Plotter (x,y)
FinFaire

Cet algorithme, même simple, mérite quelques explications:

  • Chaque fois qu'une donnée est calculée, elle est conservée dans un tableau. C'est le cas de la vitesse verticale, qui évolue dans le temps ainsi que les coordonnées x et y. La raison de ce stockage est simple. Au temps i, la vitesse et la position sont calculées à partir des données calculées au temps i-1. Les conditions initiales sont stockées dans la premier case du tableau correspondant.
  • La boucle TantQue s'achève lorsque y devient nul ou négatif.
  • Plotter(x,y) signifie tracer le point (x,y) dans le repère.
  • Pour la petite histoire, les habitués auront reconnu l'utilisation de la méthode des différences finies, au premier ordre (ou méthode d'Euler). Cette méthode donne des résultats acceptables si le pas de temps est petit. On le verra en faisant les manip. plus loin.

Le programme

Le programme ChuteCorpsXY.sce implémente l'algorithme ci-dessus :

// *********************************
// Etude de la chute d'un corps
// Dominique LEFEBVRE
// 26 février 2007
// *********************************
clear; // Initialisation de toutes les variables
// Initialisation des paramètres de simulation
deltaT = 0.01;  // base de temps = 0,01 seconde
// Initialsation des paramètres du mouvement
g = 9.81;       // accélération de la pesanteur 9,81 N.m-2 (ou N.kg)
v0 = 2 ;        // vitesse initiale du corps (en m.s-1)
y0 = 10;        // ordonnée initiale du corps (en m)
// Initialisation des variables de calcul
x(1) = 0;       // abscisse initiale du corps = 0;
y(1) = y0;      // ordonnée initiale = y0, paramètre de la simulation
vX = v0;        // vitesse horizontale initiale du corps - cette vitesse est constante
vY(1) = 0;      // vitesse verticale initiale du corps
// Initialisation graphique
xbasc();
// Calcul du mouvement
i = 2; // indice de boucle
while (y(i-1) > 0) // la boucle est exécutée tant que le corps n'est pas sur le sol
  vY(i) = vY(i-1) - g*deltaT;
  x(i) = x(i-1) + vX*deltaT;
  y(i) = y(i-1) + vY(i)*deltaT;
  i = i + 1;         // on passe à l'indice de tableau suivant
end
// Affichage du mouvement dans le repère choisi
plot2d(x,y,rect=[0,0,3,y0],style = 5);
xtitle('Chute d''un corps','X','Y');

Quelques expériences

Nous pouvons maintenant passer à la dernière étape, la plus intéressante : l'exploitation du programme. J'ai donc fait tourner le programme avec différentes valeurs de v0 et de pas de temps pour apprécier la précision de mon modèle.
Nous avons ici la chance de connaitre la solution exacte du calcul. La portée est donnée par \( x_{max} = v_0 \sqrt{\dfrac{2y_0}{g}}\).

Tracer la courbe y = f(x)

Dans le programme, je fixe la valeur de  \( \Delta t \) = 0.1s et v0= 2 m.s-1. Voilà la courbe calculée par le programme :

J'obtiens une portée de 2,8 m. Pour information, dans les conditions initiales du calcul, la valeur exacte de la portée est 2,856 m.
Pour  \( \Delta t \) = 0.01s v0= 2 m.s-1

Comme vous le constatez, avec un pas de temps de 0,01s, on obtient 2,86 m: pratiquement le résultat exact !
Pour  \( \Delta t \) = 0.1s v0= 10 m.s-1

Pour information, dans les conditions initiales du calcul, la porté exacte est 14,28 m.
\( \Delta t \) = 0.01s v0= 10 m.s-1

On est très près là aussi du résultat exact.

Tracer la courbe z = f(t)

Autre facette du problème : on peut chercher à visualiser l'altitude de la balle en fonction du temps. Il suffit d'adapter un peu le programme, qui devient ChuteCorpsZ.sce :

// *********************************
// Etude de la chute d'un corps
// Tracé de la courbe z = f(t)
// Dominique LEFEBVRE
// 26 février 2007
// *********************************
clear; // Initialisation de toutes les variables
// Initialisation des paramètres de simulation
deltaT = 0.01; // base de temps = 0,1 seconde
// Initialsation des paramètres du mouvement
g = 9.81; // accélération de la pesanteur 9,81 N.m-2 (ou N.kg)
v0 = 2 ; // vitesse initiale du corps (en m.s-1)
z0 = 10; // ordonnée initiale du corps (en m)
// Initialisation des variables de calcul
z(1) = z0; // ordonnée initiale = y0, paramètre de la simulation
vZ(1) = 0; // vitesse verticale initiale du corps
t(1) = 0;
// Initialisation graphique
xbasc();
// Calcul du mouvement
i = 2; // indice de boucle
while (z(i-1) > 0) // la boucle est exécutée tant que le corps n'est pas sur le sol
  vZ(i) = vZ(i-1) - g*deltaT;
  z(i) = z(i-1) + vZ(i)*deltaT;
  t(i) = t(i-1) + deltaT;v i = i + 1; // on passe à l'indice de tableau suivant
end
// Affichage du mouvement dans le repère choisi
plot2d(t,z,rect=[0,0,3,z0],style = 5);
xtitle('Chute d''un corps - Pas de temp: 0.01 ','Temps','Altitude');

Si je le fait tourner avec les conditions initiales \( \Delta t \)= 0,01 s et v0= 2m.s-1, j'obtient la courbe :

Le temps exact est donné par \( t = \sqrt{\dfrac{2y_0}{g}} \) soit 1,428 s. Le programme nous donne 1,42 s.

Les code sources des programmes utilisés dans cette page sont disponibles dans la bibliothèque de codes de TangenteX.

Quelques remarques physiciennes

1 - le mouvement est uniformément accéléré: on constate que la vitesse de la balle augmente à chaque intervalle de temps.

2 - le temps de chute ne dépend pas de la vitesse initiale horizontale. Pour vous en convaincre, regardez le calcul de z en fonction de t: la vitesse horizontale n'intervient pas.

3 - le temps de chute ne dépend pas de la masse de la balle ! Elle n'intervient pas dans le calcul: regardez le programme... Galilée avait donc raison : si l'on néglige les frottements et autres (dans le vide, par exemple) la bille de plomb et la plume atteignent le sol simultanément.

4 - la portée dépend uniquement de la vitesse initiale. Faites varier v0 dans le programme ChuteCorpsXY, vous verrez varier la portée du tir. Là encore, la masse de la balle n'intervient pas !

5 - la forme de la courbe dépend de la vitesse initiale. Si elle est nulle, la courbe est une droite (qui se confond d'ailleurs avec l'axe Oy car x0 = 0). Si elle est non nulle, c'est une parabole.

Contenu et design par Dominique Lefebvre - www.tangenteX.com mars 2008    Licence Creative Commons    Contact :