Objectif de la fiche : étudier la chute d'une bille dans un liquide visqueux pour proposer une expression modélisant la force de frottement exercée par le fluide sur la bille.
Cette fiche est autonome : tu n'as besoin d'aucun autre document, les valeurs de vitesse (déjà extraites d'une chronophotographie) sont recopiées directement dans le script. Chaque étape contient un script incomplet à compléter, puis à copier-coller dans Thonny (ou dans la console Basthon tout en bas de la page si tu n'as pas Thonny sous la main).
La chute dans le liquide visqueux
- Une bille est lâchée dans un liquide visqueux. Une chronophotographie de sa chute a déjà été exploitée (comme dans les toutes premières fiches de cette série) pour en extraire, à chaque position, la vitesse de la bille.
- Ces 18 valeurs de vitesse sont directement recopiées ci-dessous, avec les instants associés (espacés de 20 unités de temps).
- Le script ci-dessous est déjà complet : copie-le tel quel dans Thonny (ou dans Basthon) pour commencer.
import numpy as np
import matplotlib.pyplot as plt
t = 20 * np.arange(18)
v = np.array([0, 14, 23, 29, 34, 37, 39, 40, 41, 42, 43, 43, 43, 43, 43, 43, 43, 43])Tracer la vitesse au cours du temps
- Trace
ven fonction det, en points bleus ('bo'). - Ajoute une grille, les étiquettes
"temps"/"vitesse", et le titre"Vitesse de la bille en fonction du temps".
# TODO : trace v en fonction de t, points bleus
plt.plot(_, _, '__')
plt.grid()
plt.xlabel("______")
plt.ylabel("_______")
plt.title("________________________________________")
plt.show()Une courbe qui monte rapidement au début, puis dont la pente s'adoucit de plus en plus, jusqu'à devenir totalement plate à partir d'environ t = 200 : la vitesse se stabilise autour de 43.
Analyse qualitative
- Le plateau observé sur le graphe correspond à une vitesse limite : la situation dans laquelle toutes les forces qui s'exercent sur la bille se compensent exactement, si bien que son accélération s'annule.
- La deuxième loi de Newton s'écrit ici :
m · dv/dt = m·g − mf·g − Ff, oùm·gest le poids,mf·gla poussée d'Archimède (le fluide déplacé), etFfla force de frottement exercée par le fluide. - Le poids et la poussée d'Archimède restent constants pendant toute la chute. Si l'accélération diminue au cours du temps (la pente de la courbe
v(t)s'adoucit), c'est donc forcément la force de frottement qui varie — et elle ne peut varier que si elle dépend elle-même de la vitesse, puisque c'est la seule autre grandeur qui change. - Comme l'accélération diminue à mesure que la vitesse augmente, on peut en déduire que la norme de la force de frottement est une fonction croissante de la vitesse : plus la bille va vite, plus le fluide la freine.
Calculer l'accélération
- Comme dans les fiches précédentes, construis la liste
aldes accélérations successives par différence centrée :a = (v[i+2]-v[i]) / (t[i+2]-t[i]), pouriparcourantm = np.arange(len(t)-2).
al = []
m = np.arange(len(t) - _)
for i in m :
a = (v[i+_] - v[_]) / (t[i+_] - t[_])
al.append(_)Aucun affichage, mais al contient désormais 16 valeurs, décroissantes puis proches de 0 vers la fin — cohérent avec la vitesse limite observée à l'étape 1.
Modéliser la force de frottement
- Pour tester une loi de type
‖Ff(v)‖ = k·v, il faut tracer l'accélération en fonction de la vitesse (et non plus du temps). Une droite de pente négative confirmerait cette hypothèse ; une branche de parabole orienterait plutôt vers‖Ff(v)‖ = k·v². - Un souci se pose :
alcontient 16 valeurs, maisven contient 18. Il faut donc redimensionnervpour que les deux listes se correspondent :v0 = v[1:-1]retire le premier et le dernier terme dev, exactement les deux valeurs qui n'ont pas d'accélération associée avec la méthode des différences centrées. - Modélise
alen fonction dev0par une droite avecnp.polyfit(v0, al, 1)(degré 1, contrairement au degré 0 utilisé dans d'autres fiches), affiche le résultat, puis superpose le modèle aux points expérimentaux.
# TODO : redimensionne v pour qu'elle corresponde à al
v0 = v[_:__]
# TODO : modélise l'accélération par une droite en fonction de v0
mod = np.polyfit(__, __, _)
model = mod[_]*v0 + mod[_]
print(mod)
plt.plot(v0, al, '__')
plt.plot(v0, model, '__')
plt.grid()
plt.xlabel("_______")
plt.ylabel("____________")
plt.title("___________________________")
plt.show()Indice
np.polyfit(v0, al, 1) renvoie deux coefficients : mod[0], le coefficient directeur de la droite (sa pente), et mod[1], son ordonnée à l'origine — exactement comme dans l'équation y = a·x + b vue en mathématiques.
Un nuage de points qui s'aligne raisonnablement bien sur une droite de pente négative : l'accélération diminue linéairement quand la vitesse augmente. C'est la signature d'une force de frottement proportionnelle à la vitesse.
Conclusion
- La modélisation affine (une droite) de l'accélération en fonction de la vitesse est cohérente avec les données : cela permet de proposer une force de frottement linéaire avec la vitesse, du type
Ff = k·v— la forme caractéristique de la loi de Stokes, valable pour une petite bille sphérique se déplaçant lentement dans un fluide visqueux. - Si l'on connaît par ailleurs la masse et le rayon de la bille, la loi de Stokes permettrait d'aller plus loin encore : en déduire une estimation de la viscosité du liquide dans lequel elle est tombée.
Pense-bête — modéliser une force par sa pente
| v[1:-1] | retire le 1er et le dernier élément |
| np.polyfit(x,y,1) | modélise par une droite y = a·x + b |
| mod[0], mod[1] | pente puis ordonnée à l'origine |
| pente négative en v | indice d'une force en k·v (Stokes) |
| branche de parabole | indice d'une force en k·v² |
| vitesse limite | accélération nulle, forces compensées |
Pas de Thonny sous la main ? Utilise Basthon
Ouvrir dans un nouvel onglet ↗Ctrl+V ou Cmd+V) le code copié avec les boutons « Copier le code » ci-dessus, puis appuie sur Entrée pour l'exécuter.