RÉSOLUTION NUMÉRIQUE D`UNE ÉQUATION DIFFÉRENTIELLE

Informatique pour tous
Résolution numérique d’une équation différentielle
RÉSOLUTION NUMÉRIQUE D’UNE
ÉQUATION DIFFÉRENTIELLE
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
RÉSOLUTION NUMÉRIQUE D’UNE
ÉQUATION DIFFÉRENTIELLE
I-Équation différentielle du premier ordre
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
RÉSOLUTION NUMÉRIQUE D’UNE
ÉQUATION DIFFÉRENTIELLE
I-Équation différentielle du premier ordre
1) Méthode d’Euler
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
Rappel de l’algorithme d’Euler :
def euler(f, t0, tf, y0, h):
t = t0
y = y0
liste_t = [t]
liste_y = [y]
liste_v = [f(t, y)]
while t <= tf :
y = y + h * f(t, y)
liste_y.append(y)
t = t + h
liste_t.append(t)
liste_v.append(f(t , y))
return numpy.array([liste_t, liste_y, liste_v])
Travail demandé : Documenter chaque
ligne
du
programme
de
manière
compréhensible pour un lecteur connaissant la
mathématique sous-jacente et le langage Python
mais ne connaissant pas l’algorithme. (Rappel :
commentaire = touche #)
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
Rappel de l’algorithme d’Euler :
def euler(f, t0, tf, y0, h):
t = t0
y = y0
liste_t = [t]
liste_y = [y]
liste_v = [f(t, y)]
while t <= tf :
y = y + h * f(t, y)
liste_y.append(y)
t = t + h
liste_t.append(t)
liste_v.append(f(t , y))
return numpy.array([liste_t, liste_y, liste_v])
Travail demandé : On considère l'unique solution u de l’équation différentielle y’ = −y/ττ qui
vaut 1 en t = 0.
Expliciter la solution analytique.
Superposer sur un même graphique, la courbe représentative de la solution analytique avec
celle d'une de la solution numérique obtenue par la méthode d’Euler.
Faire varier h et observer la précision du résultat numérique.
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
RÉSOLUTION NUMÉRIQUE D’UNE
ÉQUATION DIFFÉRENTIELLE
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
La fonction odeint() est importée de la librairie scipy.integrate
Pour résoudre l’équation y’(t) = f (y(t) , t) sur l’intervalle [t0, tf], l’instruction est : odeint(f,
odeint(f,
liste_y0
liste_y0, liste_t)
liste_t) où :
¤ f est une fonction ayant pour paramètre (dans l’ordre) liste_y et liste_t qui sont des
numpy.array (liste-y est crée par odeint, liste_t est défini par l’utilisateur);
¤ liste_t est un numpy.array défini préalablement et contenant les bornes t0 et tf ;
¤ liste_y0 est un numpy.array contenant les conditions initiales [y0 (y0’,…)] correspondant à
la première valeur de liste_t .
¤ l’objet listeliste-y retourné par la fonction odeint est un numpy.array de nombre de lignes égal à
liste_t et de nombre de colonnes égal à len(liste_y0) contenant la liste des valeurs du vecteur y
(y’,…) pour chaque valeur t du tableau liste_t.
Travail demandé : Rajouter au graphe obtenu précédemment la solution calculée avec odeint.
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
Voici par exemple le graphe obtenue pour τ = 1, y0 = 1, t0 = 0, tf = 5 et le même nombre de points de
calcul pour les deux méthodes numériques.
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
Travail demandé : Effectuer la même étude (résolution analytique, méthode d’Euler, fonction odeint)
pour les équations :
y ' = y2
y (0) = 1
t ∈ [ 0, 0.8]
proposition de solution
y ' = 3 y cos ( t )
y (1) = 10
t ∈ [ 0, 10]
500 pts
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
Résolution numérique d’une équation différentielle
II-Au-delà
RÉSOLUTION NUMÉRIQUE D’UNE
ÉQUATION DIFFÉRENTIELLE
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
Résolution numérique d’une équation différentielle
II-Au-delà
1) Ordre supérieur à 1
RÉSOLUTION NUMÉRIQUE D’UNE
ÉQUATION DIFFÉRENTIELLE
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Équation différentielle d’un ordre supérieur à 1
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
Résolution numérique d’une équation différentielle
II-Au-delà
1) Ordre supérieur à 1
Une équation différentielle d’ordre supérieur à un contient d’autres dérivées qu’une dérivée
première, par exemple une équation du deuxième ordre peut s ’écrire y’’ = f(t, y, y’) .
Mais elle se ramène au schéma du premier ordre en considérant le vecteur Y = [y(t) , y’(t)].
Il est alors tel que Y’ = F(t , Y) avec F définie par :
Y → F(t , Y) = [y’(t) , f(t, y, y’) ]
Exemples :
équation différentielle
y ''+ y = 0
d 2θ ( t )
+ k sin ( θ ( t ) ) = 0
dt 2
d 2 x (t )
dx ( t )
2
m
+
h
+
ω
x (t ) = 0
0
2
dt
dt
fonction F
F (t,Y ) = [ y ' , − y]
 d θ (t )

F (t, Y ) = 
, − k sin ( θ ( t ) ) 
 dt

 dx ( t )

h dx ( t ) ω0 2
F (t, Y ) = 
,−
x ( t )
−
m dt
m
 dt

Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Ordre supérieur à 1
Travail demandé : Pour mettre en place les méthodes, on cherche à résoudre l’équation z’’(t) = g
sur l’intervalle [0, 2] à l’aide de la méthode d’Euler et de la fonction odeint.
Étudier de près les programmes suivants avant de les transcrire sur la machine pour obtenir un
résultat voisin de celui-ci :
proposition de solution
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
Résolution numérique d’une équation différentielle
II-Au-delà
1) Ordre supérieur à 1
A priori, l’algorithme d’Euler fonctionne toujours mais Y est un numpy.array ainsi que F(t, Y)
def euler(F, t0, tf, CI_tab, h):
y_tab = np.array([CI_tab[0],CI_tab[1]]) #y_tab est le tableau [y(t), v(t)]
t = t0
liste_y = [y_tab]
# liste_y est la liste des [y(t), v(t)]
liste_t = [t]
# liste_t est la liste des instants t
while t + h <= b:
y_tab = y_tab + h * F(t, y_tab) # pour que l’opération * marche
comme il faut, y_tab doit être un np.array
liste_y.append(list(y_tab)) # mais pour la suite, il vaut mieux que
liste_y soit une liste de listes plutôt que de np.array
t += h
liste_t.append(t)
return liste_t, np.array(liste_y) # par contre, pour le slicing , il vaut
mieux renvoyer un np.array qu’une liste !
Exemple : équation z’’(t) = g sur l’intervalle [0, 2]
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Ordre supérieur à 1
Utilisation de odeint
import numpy as np
from scipy.integrate import odeint
def f_ode(syst, t):
g = -9.81
v = syst[1]
return [v, g]
# la fonction qui retourne le vecteur syst=[y’,y’’]
# conditions initiales
CI_tableau = np.zeros(2)
CI_tableau[0] = 10
CI_tableau[1] = 0.
# Paramètres d'intégration
debut = 0
fin = 2.
nb_points = 100
liste_t = np.linspace(debut,fin,nb_points)
# résolution du système
sol_ode = odeint(equadiff, syst_CI, t_vec)
#récupération des valeurs de y
y_ode = sol_ode[:, 0]
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
Résolution numérique d’une équation différentielle
II-Au-delà
1) Ordre supérieur à 1
Travail demandé : Étude d’un oscillateur de pulsation ω0.
¤ Oscillations libres amorties : résoudre l’équation
d 2 x (t )
dt
2
+
ω0 dx ( t )
+ ω0 2 x ( t ) = 0
Q dt
à l’aide de la méthode
d’Euler et de la fonction odeint sur l’intervalle [0, 10] avec les valeurs numériques suivantes :
ω0 = 2*pi ; Q = 10 ; x0=1 ; v0=0
¤ Oscillations forcées : étudier la solution complète en changeant la pulsation ω de l’excitateur (on
pourra n’utiliser que la fonction odeint) . Tracer le portrait de phase.
¤ Oscillations libres d’un pendule pesant :
θ0’ non nul.
d 2θ ( t )
dt 2
+ ω0 2 sin ( θ ( t ) ) = 0
sur l’intervalle [0, 3] pour θ0= π et
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Ordre supérieur à 1
Pour faire envie, le livre d’images à feuilleter :
proposition de solution
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Ordre supérieur à 1
Pour faire envie, le livre d’images à feuilleter :
proposition de solution
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Ordre supérieur à 1
Pour faire envie, le livre d’images à feuilleter :
proposition de solution
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Ordre supérieur à 1
Pour faire envie, le livre d’images à feuilleter :
proposition de solution
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Ordre supérieur à 1
Pour faire envie, le livre d’images à feuilleter :
d 2 x (t )
dt 2
  x  2 ω0  dx ( t )
+   −
+ ω0 2 x ( t ) = 0

 a 
Q
dt


proposition de solution
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
Résolution numérique d’une équation différentielle
II-Au-delà
1) Ordre supérieur à 1
2) Système d’équations différentielles
RÉSOLUTION NUMÉRIQUE D’UNE
ÉQUATION DIFFÉRENTIELLE
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Équation différentielle d’un ordre supérieur à 1
2) Système d’équations différentielles
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
Résolution numérique d’une équation différentielle
II-Au-delà
1) Ordre supérieur à 1
2) Système d’équations différentielles
Quand différentes populations
(issues
d’espèces
différentes)
interagissent, la dynamique de
chacune est affectée par les effectifs
des autres. Elles forment une
cascade
de
populations
en
interaction qui constitue une
communauté, appelée « chaîne
trophique ».
Les relations possibles entre
espèces d’une même chaîne
trophique se classent en trois
catégories principales : la relation proie-prédateur, la relation de symbiose mutualiste et la relation de
compétition.
Le plus célèbre des modèles de dynamique de deux populations en interaction est celui de LotkaVolterra. Il fut proposé indépendamment par Alfred James Lotka (mathématicien et statisticien américain)
en 1925 et Vito Volterra (mathématicien et physicien italien) en 1926. Dans ce modèle, les prédateurs
prospèrent lorsque les proies sont nombreuses, mais finissent par épuiser leurs ressources et commencent à
décliner. Lorsque la population de prédateurs a suffisamment diminué, les proies se reproduisent et leur
population augmente à nouveau.
Ainsi, les variations cycliques des populations de lièvres des neiges et de lynx suivies au Canada
depuis 1825 ont été modélisées à l’aide du modèle de Lotka-Volterra.
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Ordre supérieur à 1
2) Système d’équations différentielles
On note x(t) l'effectif des proies et y(t) celui des prédateurs en fonction du temps.
Les proies sont supposées avoir une source illimitée de nourriture et se reproduire exponentiellement
si elles ne sont soumises à aucune prédation ; cette croissance est donc représentée par le terme
 dx 
= a x (t )
 
 dt CROISSANCE
(a est constant, indépendant du nombre de prédateurs) .
Le taux de prédation des proies est supposé proportionnel aux rencontres entre les prédateurs et les
proies ; il est décrit par le terme −p x(t) y(t) (p est une constante).
Le taux de croissance de la population des proies est similaire au taux de prédation ; cependant, une
constante différente est utilisée car la vitesse à laquelle la population des prédateurs augmente n'est pas
nécessairement égale à celle à laquelle ils consomment les proies. Ce terme s’écrit q x(t) y(t) .
Le taux de disparition naturelle des proies est proportionnel à leur population selon
 dy 
= − b x (t )
 
 dt MORTALITE
Finalement, x(t) et y(t) vérifient le système d’équations :
 dx
 dt = a x ( t ) − px ( t ) y ( t )

 dy = − b x ( t ) + qx ( t ) y ( t )
 dt
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Ordre supérieur à 1
Travail demandé : Résoudre le système d’équations de Volterra avec la fonction odeint (on pourra
vérifier que la méthode d’Euler n’est pas adaptée ici). Représenter les courbes x(t) et y(t) puis le
diagramme de phase y(x) dans le cas a = 2 , p = 1, b = 1.1 et q = 1.
proposition de solution
Informatique pour tous
Résolution numérique d’une équation différentielle
Informatique pour tous
I-Méthode de Newton
Représentations graphiques
II-Plotons un peu
III-Escargot
IV-Bouquet final
Résolution numérique d’une équation différentielle
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
import numpy as np
from scipy.integrate import odeint
II-Au-delà
1) Ordre supérieur à 1
# Exemples
def f_ana(t) :
y0 = CI_1()
return y0/(1 - y0*(t))
return
def euler(f, a, b, h) :
y = CI_1()[0]
t=a
liste_y=[y]
liste_t=[t]
def f_euler(t,y):
liste_v = [f(t, y)]
return y**2
while t+h <= b:
y += h * f(t, y)
liste_y.append(y)
def f_ode(syst, t):
t += h
return [syst[0]**2]
liste_t.append(t)
liste_v.append(f(t, y))
return np.array([liste_t,liste_y, liste_v])
#renvoie le tableau des valeurs
# Paramètres des calculs
debut = 0
fin = 0.8
nb_points = 50
t = np.linspace(debut,fin,nb_points)
# Conditions initiales
def CI_1():
y0 = 1
return np.array([y0])
#résolution
sol_ode = odeint(f_ode,CI_1(),t)
# Résolution
numérique de l'équation différentielle avec odeint
sol_euler = euler(f_euler, debut, fin,(fin-debut)/nb_points)
# Récupération des listes des abscisses ou ordonnées
y_ana=[f_ana(x) for x in t]
y_ode = sol_ode[:, 0]
y_euler = sol_euler[1]
t_euler = sol_euler[0]
# Graphiques des solutions
import matplotlib.pyplot as pl
pl.plot(t, y_ana, '-b', lw=1.5, label=u"Sol. analytique")
# Solution analytique
pl.plot(t, y_ode, 'o', ms=6, mfc='w',
mec='b',label=u"Sol.ode") # Solution numérique
pl.plot(t_euler, y_euler, 'o', ms=6, mfc='w',
mec='red',label=u"Sol.euler")
pl.xlabel(r"$t $", fontsize=16) # Label de l'axe des
abscisses
pl.ylabel(r"$y/y_{0}$", fontsize=16) # Label de l'axe des
ordonnées
pl.legend()
pl.show()
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
import numpy as np
from scipy.integrate import odeint
def euler(F, a, b,CI_tab, h):
y_tab = np.array([CI_tab[0],CI_tab[1]])
#y_tab est le tableau [y(t), v(t)]
t=a
liste_y = [y_tab] # la liste des valeurs de
y renvoyées
liste_t = [a]
while t+h <= b:
y_tab = y_tab + h * F(t, y_tab)
liste_y.append(list(y_tab))
t += h
liste_t.append(t)
return liste_t, np.array(liste_y)
# la fonction qui retourne le vecteur
Y=[y’,y’’]
def f_euler(t,syst):
g = 9.81
v = syst[1]
return np.array([v, -g])
II-Au-delà
1) Ordre supérieur à 1
def f_ode(syst, t):
g = 9.81
v = syst[1]
return [v, -g]
# conditions initiales
CI_tableau = np.zeros(2)
CI_tableau[0] = 10
CI_tableau[1] = 0.
# Paramètres d'intégration
debut = 0
fin = 2.
nb_points = 100
liste_t = np.linspace(debut,fin,nb_points)
# résolution du système
sol_ode = odeint(f_ode, CI_tableau,
liste_t)
sol_euler = euler(f_euler, debut,fin,
CI_tableau,(abs(debut-fin))/nb_points)
#récupération des résultats
y_ode = sol_ode[:, 0]
v_ode = sol_ode[:, 1]
y_euler = sol_euler[1][:,0]
t_euler = sol_euler[0]
# Graphiques des solutions
import matplotlib.pyplot as pl
pl.plot(liste_t, y_ode,label=u"Sol.odeint") #
Solution numérique
pl.plot(t_euler, y_euler, 'o', ms=4, mfc='w',
mec='red',label=u"Sol.euler")
pl.xlabel(r"$t $", fontsize=16)
des abscisses
pl.ylabel(r"$z$", fontsize=16)
des ordonnées
pl.legend()
pl.show()
# Label de l'axe
# Label de l'axe
# Appel de la légende
Résolution numérique d’une équation différentielle
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
import numpy as np
from scipy.integrate import odeint
# les constantes globales
omega0 = 2*np.pi
Q = 10
II-Au-delà
1) Ordre supérieur à 1
# Paramètres d'intégration et résolution
debut= 0
fin=30
nb_points = 40000
liste_t = np.linspace(debut,fin,nb_points)
sol_ode = odeint(f_ode,CI_tableau,liste_t)
def f_ode(syst, t):
#récupération des résultats
x = syst[0]
# Variable1 x
y_ode = sol_ode[:, 0]
v = syst[1]
# Variable2 v
v_ode = sol_ode[:, 1]
dxdt = v
# Equation différentielle 1
dvdt = -omega0/Q*v-omega0**2*x # Equation différentielle 2
return [dxdt,dvdt] # Dérivées des variables
# conditions initiales
CI_tableau = np.zeros(2)
CI_tableau[0] = 1
CI_tableau[1] = 0.
# Graphiques des solutions
import matplotlib.pyplot as pl
pl.suptitle(r"$osillateur \ harmonique\
amorti $",fontsize=16)
pl.subplot(1,2,1)
pl.plot(liste_t, y_ode) # Solution
numérique odeint
pl.xlabel(r"$t $") # Label de l'axe des
abscisses
pl.ylabel(r"$x$") # Label de l'axe des
ordonnées
pl.subplot(1,2,2)
pl.plot(y_ode, v_ode) # Solution
numérique
pl.xlabel(r"$x $") # Label de l'axe des
abscisses
pl.ylabel(r"$x'$") # Label de l'axe des
ordonnées
pl.legend()
pl.show()
# Appel de la légende
Informatique pour tous
Résolution numérique d’une équation différentielle
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
import matplotlib.pyplot as pl
import numpy as np
from scipy.integrate import odeint
# les constantes globales
omega0 = 2*np.pi
omega = np.sqrt(2)*np.pi
Q = 10
II-Au-delà
1) Ordre supérieur à 1
prefixe =r'$\omega =\omega _0‘
omegastr_liste =[prefixe + "/3$",]
omegastr_liste.append(prefixe + "/2$",)
omegastr_liste.append(prefixe +"$",)
omegastr_liste.append(prefixe + "\cdot2$",)
omegastr_liste.append(prefixe + "\cdot3$",)
pl.suptitle(r"$osillateur \ harmonique\ (puls\ \omega _0)\ forc\'e \ (puls\ \omega) $",fontsize=16)
for omega in omega_tup :
def f_ode(syst, t,omega):
sol_ode = odeint(f_ode,CI_tableau,liste_t,(omega,))
x = syst[0]
# Variable1 x
#récupération des résultats
v = syst[1]
# Variable2 v
y_ode = sol_ode[:, 0]
dxdt = v
# Equation différentielle 1
dvdt = 2*np.sin(omega*t) -omega0/Q*v-omega0**2*x # Equation différentielle 2 v_ode = sol_ode[:, 1]
return [dxdt,dvdt] # Dérivées des variables
# Graphiques des solutions
omegastr=omegastr_liste[omega_liste.index(omega)]
# conditions initiales
pl.plot(liste_t, y_ode,label=omegastr) # Solution
CI_tableau = np.zeros(2)
numérique
CI_tableau[0] = 1
pl.xlabel(r"$t $", fontsize=16) # Label de l'axe
CI_tableau[1] = 0.
des abscisses
pl.ylabel(r"$x$", fontsize=16) # Label de l'axe
# Paramètres d'intégration et résolution
des
ordonnées
debut= 0
#fin de la boucle sur les omega
fin= 30
pl.legend()
# Appel de la légende
nb_points = 40000
pl.show()
liste_t = np.linspace(debut,fin,nb_points)
omega_tup =(omega0/3,omega0/2,omega0,2*omega0,3*omega0)
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
import matplotlib.pyplot as pl
import numpy as np
from scipy.integrate import odeint
# les constantes globales
omega0 = 2*np.pi
omega = np.sqrt(2)*np.pi
Q = 10
def f_ode(syst, t):
x = syst[0]
# Variable1 x
v = syst[1]
# Variable2 v
dxdt = v
# Equation différentielle 1
dvdt = 2*np.sin(omega0*t) -omega0/Q*v-omega0**2*x
# Equation différentielle 2
return [dxdt,dvdt] # Dérivées des variables
# conditions initiales
CI_tableau = np.zeros(2)
CI_tableau[0] = 1
CI_tableau[1] = 0.
# Paramètres d'intégration et résolution
debut= 0
fin= 30
nb_points = 40000
liste_t = np.linspace(debut,fin,nb_points)
sol_ode = odeint(f_ode,CI_tableau,liste_t)
Résolution numérique d’une équation différentielle
II-Au-delà
1) Ordre supérieur à 1
#récupération des résultats
y_ode = sol_ode[:, 0]
v_ode = sol_ode[:, 1]
liste_t_fin = liste_t[-1000:]
y_ode_fin = y_ode[-2000:]
v_ode_fin = v_ode[-2000:]
# Graphiques des solutions
pl.suptitle(r"$osillateur \ harmonique\ forc\'e$",fontsize=16)
pl.subplot(1,2,1)
# sous-dessin 1
pl.plot(liste_t, y_ode) # Solution numérique
pl.xlabel(r"$t $") # Label de l'axe des abscisses
pl.ylabel(r"$x$") # Label de l'axe des ordonnées
pl.title(r"$x = f(t)$")
pl.subplot(1,2,2)
# sous-dessin 2
pl.plot(y_ode, v_ode) # Solution numérique
pl.plot(y_ode_fin, v_ode_fin,color = "red",label=r"$traj\
finale$",linewidth= 2) # Solution numérique
pl.xlabel(r"$x $") # Label de l'axe des abscisses
pl.ylabel(r"$dx/dt$") # Label de l'axe des ordonnées
pl.legend() # Appel de la légende
pl.title(r"$portrait\ de\ phase$")
pl.show()
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
Résolution numérique d’une équation différentielle
II-Au-delà
1) Ordre supérieur à 1
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as pl
pl.suptitle(r"$pendule pesant $",fontsize=16)
pl.title(r"$\theta_0\ = \pi/4\ et\ \theta'_0\ non\ nul$« )
# les constantes globales
omega0 = 2*np.pi
Q =10
def f_ode(syst, t):
x = syst[0]
# Variable1 x
v = syst[1]
# Variable2 v
dxdt = v
# Equation différentielle 1
dvdt = -omega0**2*np.sin(x) # Equation différentielle 2
return [dxdt,dvdt] # Dérivées des variables
for i in np.linspace(1,11.6,10) :
CI_tableau[1]=i
sol_ode = odeint(f_ode,CI_tableau,liste_t)
#récupération des résultats
y_ode = sol_ode[:, 0]
v_ode = sol_ode[:, 1]
y_ode_debut = y_ode[:100]
v_ode_debut = v_ode[:100]
# conditions initiales
CI_tableau = np.zeros(2)
CI_tableau[0] = np.pi/4
CI_tableau[1] = 11.7
# Paramètres d'intégration et résolution
debut= 0
fin=3
nb_points = 4000
liste_t = np.linspace(debut,fin,nb_points)
# Graphiques des solutions
#pl.subplot(3,2,Q_liste.index(Q)+1)
pl.plot(y_ode[0], v_ode[0],"ro")
pl.plot(y_ode, v_ode) # Solution numérique
pl.plot(y_ode_debut, v_ode_debut,color="red") # Solution numérique
pl.xlabel(r"$\theta $", fontsize=16) # Label de l'axe des abscisses
pl.ylabel(r"$\theta'$", fontsize=16) ) # Label de l'axe des ordonnées
pl.show()
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as pl
# les constantes globales
omega0 = 2*np.pi
Q =10
def f_ode(syst, t) :
# Variable1 x
x = syst[0]
v = syst[1]
# Variable2 v
dxdt = v
# Equation différentielle 1
dvdt = -(x**2-omega0/Q)*v-omega0**2*x # Equation
différentielle 2
return [dxdt,dvdt] # Dérivées des variables
# conditions initiales
CI_tableau = np.zeros(2)
CI_tableau[0] = 1
CI_tableau[1] = 0.
# Paramètres d'intégration et résolution
debut= 0
fin=300
nb_points = 40000
liste_t = np.linspace(debut,fin,nb_points)
Résolution numérique d’une équation différentielle
II-Au-delà
1) Ordre supérieur à 1
Q_liste=( 0.1,1,6,10,20,30)
pl.suptitle(r"$osillateur \ Van\ der\ Pol $",fontsize=16)
for Q in Q_liste :
sol_ode = odeint(f_ode,CI_tableau,liste_t)
#récupération des résultats
y_ode = sol_ode[:, 0]
v_ode = sol_ode[:, 1]
y_ode_debut = y_ode[:100]
v_ode_debut = v_ode[:100]
# Graphiques des solutions
pl.subplot(3,2,Q_liste.index(Q)+1)
pl.plot(y_ode[0], v_ode[0],"ro")
pl.plot(y_ode, v_ode) # Solution numérique
pl.plot(y_ode_debut, v_ode_debut,color="red") # Solution numérique
e = Q/omega0
x=(np.max(y_ode) + np.min(y_ode))/2
y=np.min(v_ode)
pl.text(x+1,y,r"$\omega _0/Q =$"+"{0:.3f}.".format(e)) # Appel de la
légende
pl.show()
Informatique pour tous
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as pl
def Volterra(syst,t) :
(a,b,p,q) = param()
x = syst[0]
y = syst[1]
der_x = x*(a - p*y)
der_y = y*(-b + q*x)
return [der_x,der_y]
def param() :
a=2
p=1
b = 1.1
q=1
return (a,b,p,q)
def CI() :
syst_CI = np.zeros(2)
syst_CI[0] = 2
syst_CI[1] = 1
return syst_CI
Résolution numérique d’une équation différentielle
II-Au-delà
1) Ordre supérieur à 1
def t() :
debut = 0
fin = 10
nb_points = 1000
return np.linspace(debut, fin, nb_points
soluce = odeint(Volterra,CI(),t())
pl.suptitle(r"$Mod\`ele\ de\ Lotka-Volterra$",fontsize=16)
pl.subplot(1,2,1)
pl.plot(t(),soluce)
pl.legend(["proie","predateurs"],"upper left")
pl.xlabel(r'$t$')
pl.subplot(1,2,2)
x_list = soluce[:,0]
y_list = soluce[:,1]
pl.plot(x_list,y_list)
pl.xlabel(r'$proies$')
pl.ylabel(r'$predateurs$')
pl.show()