Simulateur de mécanique – Méthode de calcul

Équations. Calculs. Quand je parle de mon projet, ce sont les questions que l’on me pose toujours :

Mais tu as les équations ? Tu as tout calculé ?

Alors je vais détailler dans cet article comment j’avais prévu de faire mes calculs et quelles sont les difficultés que je rencontre finalement.

Pour commencer : la théorie

Tout d’abord, je l’ai sûrement déjà mentionné dans un précédent article, mais je me restreint à la mécanique du point. Ajoutons à cela que l’on se restreint aux référentiels supposés galiléens, on pourra alors utiliser la deuxième loi de Newton ou le principe fondamental de la dynamique. On s’en servira pour redéfinir l’accélération à chaque instant.

La deuxième loi de Newton ou le principe fondamental de la dynamique

Il s’agit d’une relation très pratique qui permet de retrouver l’accélération d’un point mobile dans un référentiel galiléen et soumis à des forces extérieures. Je pense qu’on peut l’exprimer comme ceci :

Soit un point mobile M de masse m, soumis à un ensemble de forces \overrightarrow{F_{\text{ext}}} dans un référentiel supposé galiléen, on a :

m \cdot \overrightarrow{\Gamma_{\mathcal{R}_{0}}}(M) = \overrightarrow{F_{\text{ext}}}

Ainsi, si on peut avoir l’accélération, on peut « remonter par intégration » à la vitesse puis à la position.

Un exemple : un mobile soumis à son poids et à une force de frottement

Soit un point matériel mobile M de masse m, soumis à son poids \vec{P} = -m\vec{g} et à une force de frottement \vec{f} = - \lambda \vec{v}_x, on a :

 \left\{\begin{array}{r c l}\Gamma_{x} &=& \dfrac{1}{m}\sum F_{\text{ext},x}\\ \\ \Gamma_{y} &=& \dfrac{1}{m}\sum F_{\text{ext},y}\end{array}\right.

Il est alors aisé de retrouver la vitesse par une simple intégration. On serait alors tenté d’établir le système suivant :

 \left\{\begin{array}{r c l}V_{x} &=& \Gamma_{x} \cdot t + V_{0,x}\\ \\V_{y} &=& \Gamma_{y} \cdot t + V_{0,y}\end{array}\right.

Puis

 \left\{\begin{array}{r c l}x &=& \dfrac{1}{2} \Gamma_{x} \cdot t^2 + V_{x} \cdot t + x_0\\ \\y &=& \dfrac{1}{2} \Gamma_{y} \cdot t^2 + V_{y} \cdot t + y_0\end{array}\right.

Et bien tout ceci est faux ! En effet, on a décrit la force de frottement comme \vec{f} = -\lambda \vec{V_x}.

Il faut donc recalculer l’accélération, la vitesse puis la position numériquement à chaque instant t+\Delta t. De cette manière, les forces qui dépendent de la vitesse évoluent bien numériquement avec la vitesse. Sans trop rentrer dans les détails, il s’agit d’une équation différentielle. Sauf erreur, cette méthode de discrétisation du temps est appelée Méthode d’Euler.

Maintenant, la pratique avec une application en Python

Préambule : Description de l’application

Ce que j’ai cherché à faire avec ce script Python, c’était de voir si la méthode était satisfaisante pour approximer numériquement la trajectoire. Le principe du script est de récupérer les informations de la simulation afin de calculer toutes les nouvelles positions du mobile séparées temporellement du même pas de temps \Delta t.

Le code !

J’ai, par souci d’utilisation rapide du script, fixé toutes les informations directement dans le script. Si vous souhaitez l’adapter, il est assez simple d’ajouter des lignes de codes. Les forces sont regroupées dans une liste et la force de frottement n’a qu’un coefficient de frottement en paramètre (que vous pouvez modifier à votre guise). Voici donc ce fameux script :

import matplotlib.pyplot as plt

def display(x,y):
    plt.xlabel('Position horizontale')
    plt.ylabel('Position verticale')
    plt.plot(x,y)
    plt.show()

def integrate(x, x0, delta):
    return x*delta + x0

mass = 10
forces, X, Y = list(), list(), list()
weight = (0, -9.81*mass)
friction = (0,0) #A redéfinir à chaque tour de boucle car dépend de la vitesse (eqt diff), mais bien nulle car vitesse nulle à l'instant initial
elapsedTime = 0
duration = 10
delta = 0.0001
forces.append(weight)
forces.append(friction)

initialPos = (0, 10)
initialVelocity = (10, 40)

X.append(initialPos[0])
Y.append(initialPos[1])

while elapsedTime < duration:
    elapsedTime += delta
    
    forcesX = 0;
    forcesY = 0;
    
    for force in forces:
        forcesX += force[0]
        forcesY += force[1]
    
    aX = forcesX / mass
    aY = forcesY / mass
    
    vX = integrate(aX, initialVelocity[0], elapsedTime)
    vY = integrate(aY, initialVelocity[1], elapsedTime)
    
    X.append(integrate(vX, initialPos[0], elapsedTime))
    Y.append(integrate(vY, initialPos[1], elapsedTime))
    
    forces[1] = (-.2*vX, 0)
    
display(X, Y)
Simulation numérique d'un lancer

Attention, afin de pouvoir exécuter ce code, il vous faut avoir au préalable avoir installé la bibliothèque matplotlib. Elle est nécessaire à l’affichage du graphique.

Avis critique sur ce code

Si vous lancez le script avec différentes valeurs, vous devriez obtenir quelque chose comme moi :Tracé de différentes trajectoires selon les conditions initialesOn observe plusieurs courbes « propres » puis une dernière (celle qui est tout à gauche) qui devient vite un gros pâté. En fait, si on zoom, on s’aperçoit vite qu’il s’agit d’allers et de retours à une fréquence tellement élevée qu’on ne peut plus les distinguer à l’échelle des courbes.

Ça me gêne de ne pas réussir à repousser cette aberration, même en améliorant la précision du calcul (en donnant une valeur encore plus petite au delta). En effet, les valeurs numériques pour cette simulation ne sont pas forcément très réalistes :

v_{0,x} = 10 mètres par seconde et \lambda \in \left[ 0.2 ; 1.0 \right] (kilogramme par seconde ?).

Dans le cas présent, ça semble quand même satisfaisant : l’aberration n’apparaît « qu’à 600 » mètres sous le sol apparemment. Mais dans le cadre de mon projet de simulateur numérique, n’ai-je pas ici atteint une limite de résolution numérique de problèmes complexes ?

Conclusion

Il est temps pour moi de conclure cet article. J’ai commencé par appliquer la méthode la plus intuitive pour calculer la position du mobile à partir des données dont on dispose. Cette méthode semble satisfaisante pour des expériences courtes. Il existe certainement des méthodes d’intégration numérique plus adaptées ou bien une autre approche du problème pour pouvoir traiter de problèmes plus complexes.

Il faudrait voir du côté de la résolution des équations différentielles car il semble bien (je vous laisse jouer avec les valeurs du script) que les aberrations viennent de là.

Laisser un commentaire