Cours3 IngNumSimul

Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Chapitre 3
Résolution approchée d’équations différentielles
Module 2: Ingénierie numérique et simulation
MPSI1/PCSI2
Texte
Texte
Texte
[email protected]
17 juin 2015
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
1/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Plan
1
Les équations scalaires d’ordre 1
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
2
Les équations différentielles d’ordre 2
3
Utilisation de la fonction odeint du module scipy.integrate
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
2/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
Principe général
Soit n ∈ N∗ et U un ouvert de RxR . Une équation différentielle
d’ordre 1 (résolue) est une équation de la forme :
y 0 (t) = F (y (t), t)
où F est une application continue sur U à valeurs dans Rn et où la
fonction inconnue y est de classe C 1 sur un certain intervalle de R
, à valeurs dans Rn .
Dans le cas où n = 1, on parle d’une équation différentielle
scalaire ; dans le cas général, on obtient un système différentiel.
Si (t0, y 0) ∈ U, résoudre le problème de Cauchy en (t0, y 0), c’est
trouver un couple (I , y ) où I est un intervalle de R et où y est une
fonction de classe C 1 de I dans Rn tels que
y (t0) = y 0 et ∀t ∈ Iy 0 (t) = F (y (t), t)
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
3/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
La méthode d’Euler
Principe
On cherche à résoudre sur [a, b] l’équation de la forme :
y 0 (t) = F (y (t), t) avec y (t0) = y 0
Si y (t) est de classe C 1 alors, connaissant y (ti ), on peut évaluer de façon
approché, y (ti+1 ) par son développement de Taylor à l’ordre 1 :
y (ti+1 ) = y (ti ) + y 0 (ti )x(ti+1 − ti )
Soit en posant h = ti+1 − ti et avec y (ti ) = f (y (ti ), ti ) :
y (ti+1 ) = y (ti ) + f (y (ti ), ti )xh
Connaissant y (a), on évalue par itérations successives les valeurs approchées de
la fonction y (t) :
[y (a), y (a + h), y (a + 2h), y (a + 3h)...y (b − h), y (b)]
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
4/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
Interprétation géométrique
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
5/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
Implémentation de la méthode d’Euler en Python
Code en utilisant les listes
############Solution 1############
def Euler(f,a,b,y0,h) :
y=y0
t=a
les y =[y0]
les t =[a]
while t+h <= b :
y =y+ h * f(t,y)
t=t+h
les y.append(y)#On peut faire les y=les y+[y]
les t.append(t)
return les t, les y
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
6/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
Implémentation de la méthode d’Euler en Python
Code en utilisant les listes
############Solution 2############
def Euler(f,a,b,y0,h) :
y=y0
t=a
les y=[y0]
les t =[a]
n=(b-a)/h
for i in range(1,n+1) :
y =y+ h * f(t,y)
t=t+h
les y.append(y)
les t.append(t)
return les t, les y
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
7/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
Implémentation de la méthode d’Euler en Python
Code en utilisant le module numpy
############Solution 3############
def Euler(f,a,b,y0,n) :
y=np.array([0]*(n+1),dtype=float) #générer un vecteur de n+1 valeurs
t=np.linspace(a,b,n+1) #générer le vecteur t=[t0,t1,...,tn]
y[0]=x0
for i in range(1,n+1) :
y[i]=y[i-1]+h*f(t[i-1],y[i-1])
return y
############Solution 4############
def Euler(f,y0,t) :
”””Entrée : une fonction f, la condition initiale y0 et un vecteur t=[t0,t1,..,tn]
Sortie : y un vecteur qui contient la solution de l’équation”””
n=len(t)
y=np.array([y0]*n,dtype=’f’)
for i in range(n-1) :
y[i+1]=y[i]+(t[i+1]-t[i] )*f(y[i],t[i])
return y
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
8/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
Exemple 1 : d’uilisation de la méthode d’Euler
Considérons l’équation différentielle du premier ordre
(
y0 = y
y (0) = 1
import numpy as np
import matplotlib.pyplot as pl
######Définir la fonction F
def F(y,t) :
return y
t= np.linspace(0, 5, 50)
h=(5-0)/50
y0=1
#La fonction Euler proposée dans Solution 3
y= Euler(F,0,5,y0,h)
pl.plot(t,y)
pl.xlabel(’temps’)
pl.ylabel(’y(t)’)
pl.show()
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
9/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
Exemple 2 : d’uilisation de la méthode d’Euler
Considérons l’équation différentielle du premier ordre relative à la charge d’un
condensateur
(
DU
+ τu = Eτ
dt
U(0) = 0
import matplotlib.pyplot as pl
C=1e-6
R=1e3
tau=R*C
E=6
u0=0
######Définir l’équation
def equation(u,t) :
y=-u/tau+E/tau
return y
t= np.linspace(0,5*tau,1000)
#La fonction Euler donnée dans sol 4
y=Euler(equation,u0,t)
pl.plot(t,y)
pl.show()
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
10/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
La méthode de Heun, ou RK2
Implémentation de la méthode RK2
#########Solution en utilisant les listes#########
def Heun(F, a, b, y0, n) :
pas = (b - a)/n
X = [a]
t=a
Y = [y0]
y = y0
for k in range(0, n) :
alpha = y + pas * F(t, y) / 2
y = y + pas * F(t+ pas / 2, alpha)
t = t + pas
X.append(t)
Y.append(y)
return X, Y
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
11/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
La méthode de Heun, ou RK2
Implémentation de la méthode RK2
#########Solution en utilisant le module numpy#########
import numpy as np
def Heun(f,y0,t) :
n = len(t)
y = np.array( [ y0 ] * n )
for i in range(n-1) :
h=t[i+1] - t[i]
k1=h * f( y[i],t[i])
k2 = h * f( y[i] + k1,t[i+1])
y[i+1] = y[i] + ( k1 + k2 ) / 2.0
return y
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
12/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
La méthode de Runge-Kutta (ou RK4)
Implémentation de la méthode RK4
#########Solution en utilisant les listes#########
def RK4(F, a, b, y0, n) :
pas = (b - a) / n
pasSur2 = pas / 2
X = [a]
t=a
Y = [y0]
y = y0
for k in range(0, n) :
C1 = F(t, y)
C2 = F(t + pasSur2, y + pasSur2 * C1)
C3 = F(t + pasSur2, y + pasSur2 * C2)
y = y + pas * ( C1 + 2 * C2 + 2 * C3 + F( t + pas, y + pas * C3)) / 6
t = t + pas
X.append(t)
Y.append(y)
return X, Y
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
13/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode d’Euler
La méthode de Heun, ou RK2
La méthode de Runge-Kutta (ou RK4)
La méthode de Runge-Kutta (ou RK4)
Implémentation de la méthode RK4
#########Solution en utilisant le module numpy#########
import numpy as np
def RK4(f,y0, t ) :
n = len( t )
y = np.array( [ y0 ] * n )
for i in range( n - 1 ) :
h = t[i+1] - t[i]
k1 = h * f(y[i], t[i] )
k2 = h * f( y[i] + 0.5 * k1, t[i] + 0.5 * h )
k3 = h * f( y[i] + 0.5 * k2, t[i] + 0.5 * h )
k4 = h * f( y[i] + k3, t[i+1] )
y[i+1] = y[i] + ( k1 + 2.0 * ( k2 + k3 ) + k4 ) / 6.0
return y
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
14/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Principe de l’équation différentielle d’ordre 2
Considérons une équation différentielle du second ordre, de la
forme :
x 00 = f (x 0 (t)), x(t), t)
m
00
0
x = a(t)x + b(t)x + c(t)
où a, b et c sont des fonctions continues de I dans R
En posant le vecteur Y tel que Y (t) = [x(t), x 0 (t)],
On a Y 0 (t) = [x 0 (t), x 00 (t)]
Donc, l’équation différentielle à résoudre peut se mettre sous
la forme :
Y 0 (t) = [x 0 (t), f (x 0 (t)), x(t), t)] = F (t, Y (t)) (eq1)
Pour résoudre l’équation eq1, on pourra là encore utiliser les
programmes vus précédemment.
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
15/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Principe de l’équation différentielle d’ordre 2
⇒Ecriture matricielle de l’équation : x 00 = a(t)x 0 + b(t)x + c(t)
Matriciellement, cette équation peut s’écrire :
„ 0 « „
« „
« „
«
x (t)
0
1
x(t)
0
=
x
+
00
0
x (t)
b(t) a(t)
x (t)
c(t)
Soit
Y 0 = AY + B
Avec
„
Y (t) =
«
„
x 0 (t)
0
, A(t) =
x 00 (t)
b(t)
«
„
«
1
0
et B(t) =
a(t)
c(t)
Pour tout t, l’application Y 7→ A(t).Y + B(t) est de classe C1 , donc le théorème de
Cauchy-Lipschitz s’applique
⇒Exemples :
équation différentielle
fonction F
y 00 + y = 0
F (t, Y ) = [y 0 , −y ]
h
i
dθ(t)
F (t, Y ) =
, −ksin(θ(t))
dt
d 2 θ(t)
dt 2
m
+ ksin(θ(t)) = 0
d 2 x(t)
dx 2
+h
dx(t)
dt
+ ω02 x(t) = 0
Module 2: Ingénierie numérique et simulation
»
F (t, Y ) =
2
ω
dx(t)
h dx(t)
,−m
, − m0
dt
dt
CPGE GSR 2014-2015
–
x(t)
16/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode Euler d’une équation différentielle d’ordre 2
L’objectif est de résoudre l’équation différentielle du second ordre
(
Y 0 = F (Y (t), t)
Y (t0) = [x(t0), x 0 (t0)]
Implémentation de la méthode Euler avec numpy
import numpy as np
#########Définir la fonction F sachant que f est deja donnée
def F(Y,t) :
return np.array([Y[1],f(Y[1],Y[0],t)])
#######Défintion de la fonction Euler
def EulerExplicite(F,a,b,Y0,pas) :
n=(b-a)/pas
t=np.arange(a,b+pas,b)
#On génére une matrice SY de n lignes et 2 colonnes contenant les solutions
SY=np.array([[0,0] for i in range(n)],dtype=’f’)
SY[0]=Y0
for i in range(1,n) :
SY[i]=SY[i-1]+ pas*F(SY[i-1],t[i-1])
return SY
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
17/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode Euler d’une équation différentielle d’ordre 2
Exemple Considérons l’équation différentielle du second ordre
8
00
2 0
>
<x = 0.5(1 − x )x − x
0
x (0) = 0.1
>
:
x(0) = 0
Implémentation de la méthode Euler avec numpy
import numpy as np
#########Définir la fonction G sachant que F est deja donnée
def F(Y,t) :
return np.array([Y[1],0.5*(1-Y[0]*Y[0])*Y[1]-Y[0]])
#######Défintion de la fonction Euler
def EulerExplicite(F,a,b,Y0,pas) :
n=(b-a)/pas
t=np.arange(a,b+pas,b)
#On génére une matrice SY de n lignes et 2 colonnes contenant les solutions
SY=np.array([[0,0] for i in range(n)],dtype=’f’)
SY[0]=Y0
for i in range(1,n) :
SY[i]=SY[i-1]+ pas*F(SY[i-1],t[i-1])
return SY
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
18/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La méthode Euler d’une équation différentielle d’ordre 2
Implémentation de la méthode Euler avec une liste
import numpy as np
#########Définir la fonction F sachant que f est deja donnée
def F(Y,t) :
return np.array([Y[1],f(Y[1],Y[0],t)])
#######Défintion de la fonction Euler
def euler(F, a, b, Y INI, h) :
Yi = np.array([Y INI[0],Y INI[1]]) #Yi est le tableau [x(t), x’(t)]
t=a
liste y = [Yi] # liste y est la liste des [x(t), x’(t)]
liste t = [a] # liste t est la liste des instants t
while t + h <= b :
Yi = Yi + h * F(t, Yi) # l’opération * marche car Yi est un np.array
liste y.append(list(Yi))
t =t+ h
liste t.append(t)
return liste t, np.array(liste y)
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
19/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
La fonction odeint
Défintion
Le module scipy.integrate fournit la fonction odeint qui est un ”mix” de Runge
Kutta d’ordre 4 avec des méthodes à pas adaptatif.
La fonction odeint permet de résoudre les équations différentielles du premier
odre et du deuxième ordre.
Syntaxe et utilisation
from scipy.integrate import odeint
Ys=odeint(f,CondInit,t)
1
f pointe sur la fonction CONNUE f dans y’(t)=f(y(t),t). Attention : le premier
argument de f est la fonction vectorielle inconnue y.
2
CondInit pointe sur le vecteur des conditions initiales.
y(t0)= [y1 (t0), y2 (t0), ....yn (t0)]
3
t pointe sur les points définissant le découpage de l’intervalle de résolution
I = [t0 ; t0 + T]
→ La solution Ys contient les valeurs des solutions approchées sur les différents
points indiqués de I
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
20/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Exemple 1 d’uilisation de la fonction odeint
Considérons l’équation différentielle du premier ordre
(
y0 = y
y (0) = 1
Code en python
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as pl
######Définir la fonction F
def F(y,t) :
return y
t= np.linspace(0, 5, 50)
y= odeint(F, 1, t)
pl.plot(t,y)
pl.show()
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
21/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Exemple 1 d’uilisation de la fonction odeint
Considérons l’équation différentielle du premier ordre
(
y0 = y
y (0) = 1
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
22/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Exemple 2 d’uilisation de la fonction odeint
Considérons l’équation différentielle du second ordre

00
2 0

y = 0.5(1 − y )y − y
y 0 (0) = 0.1


y (0) = 0
Code en python
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as pl
######Définir la fonction F
def F(Y,t) :
return [Y[1],0.5*(1-Y[0]**2)*Y[1]-Y[0]]
init=[0,0.1]
t=np.linspace(0,100,10000)
y=odeint(F,init,t)
pl.plot(t,y)
pl.show()
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
23/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Exemple 2 d’uilisation de la fonction odeint
Considérons l’équation différentielle du second ordre

00
2 0

y = 0.5(1 − y )y − y
y 0 (0) = 0.1


y (0) = 0
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
24/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Exemple 3 Mouvement d’un pendule
Un pendule de masse m soumis à un champ de pesanteur constant
se déplace dans un plan vertical ; il est situé au bout d’une tige
rigide de longueur l et de masse non nulle m tournant avec
frottement autour de son extrémité fixe.
Considérons l’équation différentielle du second ordre satisfaite par
ce pendule

k
0
Θ00 = −g

l sin(Θ(t)) − ml 2 Θ
Θ0 (0) = 0


Θ(0) = 0.1
Avec
• l=1
• k=0.2
• m=1
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
25/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Exemple 3 Mouvement d’un pendule
Comparaison de la solution 1 et odeint
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as pl
######Définir la fonction f
def f(t,x,dx) :
return (-1*(g/l)*sin(x)-(k/(m*l*l))*dx)
######Définir la fonction F en uitlisant changement de variable
def F(Y,t) :
return np.array([Y[1],f(t,Y[0],Y[1])],dtype=’f’)
###Euler Sol1 :c’est la solution 1 qui utilise le pas (arange)
def Euler Sol1(F,a,b,Y0,pas) :
t=np.arange(a,b+pas,pas)
n=len(t)
SY=np.array([[0,0] for i in range(n)],dtype=float)
SY[0]=Y0
for i in range(1,n) :
SY[i]=SY[i-1]+pas*F(SY[i-1],t[i-1])
return t,SY
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
26/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Exemple 3 Mouvement d’un pendule
Comparaison de la solution 1 et odeint
###Programme principal###
g=9.81
l=1
k=0.2
m=1
Y0=np.array([0.1,0],dtype=’f’)
n=10000
pas=30./n
t,SY=Euler Sol1(F,0,30,Y0,pas)
#Solution avec odeint
SY3=odeint(F,Y0,t)
#Pour extraire la colonne x(t)
SY I0=[SY[i][0] for i in range(len(SY))]
SY3 I0=[SY3[i][0] for i in range(len(SY3))]
pl.plot(t,SY I0)
pl.plot(t,SY3 I0)
pl.legend((’x(t) avec odeint’,’x(t) avec
solution1’))#afficher couleur
pl.show()
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
27/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Exemple 3 Mouvement d’un pendule
Comparaison de la solution 2 et odeint
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as pl
######Définir la fonction f
def f(t,x,dx) :
return (-1*(g/l)*sin(x)-(k/(m*l*l))*dx)
######Définir la fonction F en uitlisant changement de variable
def F(Y,t) :
return np.array([Y[1],f(t,Y[0],Y[1])],dtype=’f’)
###Euler Sol2 :c’est la solution 2 qui utilise le nombre de subdivisions (linspace)
def Euler Sol2(F,a,b,Y0,n) :
t=np.linspace(a,b,n+1) # tableau des instants de n+1 valeurs.
pas=(b-a)/n# le pas de discretisation
SY=np.array([[0,0] for i in range(n+1)],dtype=float)
SY[0]=Y0
for i in range(1,n+1) :
SY[i]=SY[i-1]+pas*F(SY[i-1],t[i-1])
return t,SY
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
28/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Exemple 3 Mouvement d’un pendule
Comparaison de la solution 2 et odeint
###Programme principal###
pi=3.14
g=9.81
l=1
k=0.2
m=1
Y0=np.array([0.1,0],dtype=’f’)
n=10000
t1,SY1=Euler Sol2(F,0,30,Y0,n)
#Solution avec odeint
SY3=odeint(F,Y0,t1)
SY1 I0=[SY1[i][0] for i in range(len(SY1))]
SY3 I0=[SY3[i][0] for i in range(len(SY3))]
pl.plot(t1,SY1 I0)
pl.plot(t1,SY3 I0)
pl.legend((’x(t) avec odeint’,’x(t) avec
solution2’))#afficher couleur
pl.show()
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
29/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Exemple 3 Mouvement d’un pendule
Comparaison de la solution 3 et odeint
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as pl
######Définir la fonction f
def f(t,x,dx) :
return (-1*(g/l)*sin(x)-(k/(m*l*l))*dx)
######Définir la fonction F en uitlisant changement de variable
def F(Y,t) :
return np.array([Y[1],f(t,Y[0],Y[1])],dtype=’f’)
###Euler Sol2 :c’est la solution 2 qui utilise le nombre de subdivisions (linspace)
def Euler Sol3((F,y0,t) :
n=len(t)
y=np.array([y0]*n,dtype=’f’)
for i in range(n-1) :
y[i+1]=y[i]+(t[i+1]-t[i])*F(y[i],t[i])
return y
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
30/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Exemple 3 Mouvement d’un pendule
Comparaison de la solution 3 et odeint
###Programme principal###
g=9.81
l=1
k=0.2
m=1
Y0=np.array([0.1,0],dtype=’f’)
n=10000
T=np.linspace(0,30,n+1)
#Appel de la fonction Euler Sol3
SY2=Euler Sol3(F,Y0,T)
#Solution avec odeint
SY3=odeint(F,Y0,T)
SY2 I0=[SY2[i][0] for i in range(len(SY2))]
SY3 I0=[SY3[i][0] for i in range(len(SY3))]
pl.plot(T,SY2 I0)
pl.plot(T,SY3 I0)
pl.legend((’x(t) avec odeint’,’x(t) avec
solution3’))
pl.show()
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
31/ 32
Les équations scalaires d’ordre 1
Les équations différentielles d’ordre 2
Utilisation de la fonction odeint du module scipy.integrate
Exemple 3 Mouvement d’un pendule
On affiche θ(t) et dθ(t)/dt avec odeint
###Programme principal###
g=9.81
l=1
k=0.2
m=1
Y0=np.array([0.1,0],dtype=’f’)
n=10000
T=np.linspace(0,30,n+1)
SY3=odeint(F,Y0,T)
#On extrait la 1ere colonne θ(t)
SY3 C1=[SY3[i][0] for i in range(len(SY3))]
#On extrait la 2eme colonne θ0 (t)
SY3 C2=[SY3[i][1] for i in range(len(SY3))]
pl.plot(T,SY3 C1)
pl.plot(T,SY3 C2)
pl.legend((’theta(t)’,’d theta(t)/ dt’))
pl.show()
Module 2: Ingénierie numérique et simulation
CPGE GSR 2014-2015
32/ 32