On s'intéresse ici à la résolution des équations différentielles du premier ordre.

La méthode d'Euler permet de déterminer les valeurs \(f(t_k)\) à différents instants \(t_k\) d'une fonction \(f\) vérifiant une équation différentielle donnée connaissant la valeur de la fonction à l'instant initial.

Exemples :
- en mécanique : \(m\displaystyle\frac{dv(t)}{dt} = mg - \alpha \, v(t)\)      (la fonction \(f\) est ici la vitesse \(v\)) ;
- en électricité : \(\displaystyle\frac{du(t)}{dt} + \frac{1}{\tau }u(t) = \frac{e(t)}{\tau }\)      (\(f\) est ici la tension \(u\)).

Ces deux équations différentielles peuvent être récrites sous la forme \(\displaystyle\frac{df}{dt} = g(t,f)\)      (dérivée de la fonction inconnue = \(g(t,f)\) = "second membre") :
\(\displaystyle\frac{dv(t)}{dt} = g - \frac{\alpha}{m} \, v(t)\) ;
\(\displaystyle\frac{du(t)}{dt} = - \frac{1}{\tau }u(t) + \frac{e(t)}{\tau }\).
Dans les deux cas, la dérivée de la fonction est donnée par le second membre où tous les termes sont des données du problème dès que les instants de calcul sont définis.

L'algorithme d'Euler consiste donc à construire :
- un tableau d'instants de calcul (discrétisation du temps) \(t = [t_0, t_1, ...t_k, ...]\) ;
- un tableau de valeurs \(f = [f_0, f_1, ...f_k, ...]\) ;
Par tableau, il faut comprendre une liste ou tableau (array) numpy.

On introduit pour cela un pas de discrétisation temporel noté \(h\) (durée entre deux instants successifs) défini, par exemple, par la durée totale \(T\) et le nombre total de points \(N\) : \(h = \displaystyle\frac{T}{N-1}\).
On a \(h=t_1-t_0\) et donc \(t_1 = h + t_0\) et d'une façon générale \(t_k = kh + t_0\).
Remarque : bien lire l'énoncé pour savoir si \(N\) est le nombre total de points ou le nombre de points calculés. Dans ce dernier cas on a \(N+1\) points au total et \(h = \displaystyle\frac{T}{N}\)).

Equation différentielle d'ordre 1 écrite sous la forme :\(\dfrac{df}{dt}=f^\prime(t)=g(t, f)\)
Mathématiques	Informatique
Le temps est une variable continue \(t\) désigne un instant	Le temps est discrétisé (pas \(h\)) t est un tableau : \(t[k]\) contient la valeur \(kh + t_0\) Récurrence : \(t[0] = t_0\) puis \(t[k+1] = t[k] + h\)
\(f(t)\) est une fonction continue de \(t\)	\(f\) est un tableau de valeurs discrètes : \(f[k]\) contient la valeur correspondant à \(t[k]\) calculé par récurrence (ci-dessous)
\(f^\prime(t)=\lim_{h\rightarrow 0}\displaystyle\frac{f(t+h)-f(t)}{h} \)	\(f^\prime[k]=\displaystyle\frac{f[k+1]-f[k]}{h}\)
\(f(t+h) = f(t) + h \times g(t, f)+ o(h)\)	Formule de récurrence \(f[0] = f_0\) puis \(f[k+1] = f[k] + h * g(t,f)\)

✏️ Il faut savoir retrouver cet algorithme (c'est à dire les deux formules de récurrence) : la méthode repose sur l'évaluation de la dérivée grâce au taux de variation.

📚 Il existe deux façons de construire les deux listes précedentes en python :
- en créant une liste initialisée avec la valeur initiale (L =[0] par exemple) puis en ajoutant des éléments grâce à la méthode append (L.append(valeur)) ;
- en créant une liste de la taille adéquate prélalablement remplie (L = [0]*N par exemple) puis en modifiant les éléments (L[k] = valeur).

✏️ Avant d'écrire l'algorithme, établir la relation de récurrence correspondant à l'équation différentielle utilisée.

Objectif ✔️

On souhaite écrire différentes versions d'un programme permettant de tracer la courbe \(v(t)\) (ce qui nécessite d'utiliser l'algorithme d'Euler).
On écrira des fonctions euler1, euler2 et euler3 de paramètres \(N\) et \(T\) et renvoyant les tableaux t (tableau des instants) et v (tableau des vitesses).

Utiliser des variables pour toutes les constantes physiques.

✏️ A partir de la deuxième loi de Newton projetée sur un axe vertical descendant, montrer que l'équation différentielle du mouvment est de la forme : \(\dfrac{dv}{dt}=-\dfrac{v}{\tau} + K\) avec \(\tau = \dfrac{m}{6 \pi \eta r}\) et \(K = g -\dfrac{\frac{4}{3}\pi r^3\rho_{gly} g}{m}\).
Estimer numériquement l'ordre de grandeur du temps caractéristique du problème sans résoudre l'équation et en déduire un ordre de grandeur de la durée totale \(T\) pour la modélisation.
Choisir également un nombre total de points \(N\).
Ces deux valeurs pourront être affinées par la suite, en fonction des résultats obtenus.

Remarque : l'expression de la force de frottement fournie est valable si le nombre de Reynolds défini par \(Re = \dfrac{\rho v_{limite} r}{\eta}\) est inférieur à 1. Cette condition est-elle vérifiée ?

Solution

Sur ce site, on pourra ajouter (avant un tracé) l'instruction plt.clf() qui efface de la mémoire les éventuels tracés précédents (après importation de matplotlib.pyplot sous l'alias plt).

1. Charger les bibliothèques nécessaires (math pour le nombre π et matplotlib.pyplot).
2. Initialiser les constantes physiques.
3. Initialiser les paramètres du schéma numérique (T, N, h).
4. Créer deux listes de longueur 1, une liste t pour les instants et une liste v pour les vitesses, initialisées avec les valeurs initiales.
5. Ecrire une boucle permettant de compléter ces listes au fur et à mesure en ajoutant des termes grâce aux relations de récurrence.
6. Créer le graphe \(v(t)\).

Solution

Remarque : dans la simulation ci-dessus, on constate que le nombre de points choisi N = 100 est un peu trop faible. Augmenter ce nombre de points.

Les trois premières étapes sont identiques.

4. Créer deux listes de longueur N, une pour les instants et une pour les vitesses.
5. Ecrire une boucle permettant de modifier ces listes au fur et à mesure en remplaçant/écrasant les termes v[k+1] grâce aux relations de récurrence.
6. Créer le graphe \(v(t)\).

Solution

Réviser les commandes Numpy.

Identique à la méthode précédente en remplaçant « liste » par « tableau ».

Solution