Cantine de Langon Du 23 au 27 Mars 2015

TD 5 : Simulation num´erique
PC - Lyc´ee Thiers
2014/2015
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 1 : Enonc´
e
Correction
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Enonc´
e
Corrig´
e
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Enonc´
e
Correction
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Correction
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Exercice 1 : Enonc´
e
Correction
Exercice 1 : Enonc´e
Exercice 1. Circuit RLC en s´
erie.
On consid`
ere un circuit ´
electrique constitu´
e d’une source de tension V , d’une r´
esistance R, d’une
bobine L et d’une capacit´
e C mont´
es en s´
erie.
1. D´
eterminer une ´
equation diff´
erentielle satisfaite par la tension aux bornes de la bobine.
2. Tracer la courbe de la tension aux bornes de la bobine pour V (t) = sin(2πft) sur un
intervalle de temps de 1 seconde (on prendra 10000 points) pour f = 100 Hz, R = 10 Ω,
L = 870 mH, C = 650 mF. A l’instant initial aux bornes de la bobine la tension est nulle ainsi
que sa d´
eriv´
ee.
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Exercice 1 : Enonc´
e
Correction
Exercice 1 : Correction.
1) Equation diff´
erentielle v´
erifi´
ee par uL .
● Soit i l’intensit´
e (en fonction du temps t). Les tensions aux bornes de la r´
esistance uR , de la
bobine uL , et du condensateur uC v´
erifient :
uR = Ri,
uL = L
di
,
dt
i =C
duC
dt
● Loi des mailles : uR + uL + uC = V .
On la d´
erive une premi`
ere fois :
Ô⇒
Ô⇒
duR
+
dt
di
+
R
dt
R
uL +
L
duL
duC
dV
+
=
dt
dt
dt
duL
i
dV
+
=
dt
C
dt
duL
i
dV
+
=
dt
C
dt
On encore d´
erive une seconde fois :
R duL
d 2 uL
1 di
d 2V
+
+
=
2
L dt
dt
C dt
dt 2
PC - Lyc´
ee Thiers
Ô⇒
d 2 uL
R duL
1
d 2V
+
+
uL =
2
dt
L dt
LC
dt 2
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Exercice 1 : Enonc´
e
Correction
Exercice 1 : Correction.
● uL satisfait l’´
equation diff´
erentielle :
d 2 uL
1
d 2V
R duL
.
+
uL =
+
dt 2
L dt
LC
dt 2
C’est une ´
equation diff´
erentielle lin´
eaire du second ordre `
a coefficient constant, avec second
membre :
′′
y +
R ′
1
d 2V
2 2
y +
y = −4π f sin(2πft) =
L
LC
dt 2
et un probl`
eme de Cauchy avec les conditions initiales y (0) = y ′ (0) = 0.
● On l’´
ecrit comme un syst`
eme de deux ´
equations diff´
erentielles :
⎧
dy
⎪
′
⎪
⎪
⎪
⎪ dt = y
en posant Y = (
⎨
′
d 2V
R
1
dy
⎪
⎪
⎪
=
− y′ −
y
⎪
⎪
2
⎩ dt
dt
L
LC
y′
⎛
⎞
d
d
y
⎟ et Y (0) = (
Ô⇒
Y =
( ′ ) = ⎜ d 2V
R ′
1
y
dt
dt
− y −
y ⎠
⎝
dt 2
L
LC
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
y
)
y′
0
)
0
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Exercice 1 : Enonc´
e
Correction
Exercice 1 : Correction.
2) R´
esolution.
#
R
L
C
f
Constantes du probl`
eme :
= 10
# R = 10 Ohms
= 0.870
# L = 870 mH
= 0.650
# C = 650 mF
= 100
# f = 100 Hz
# Import des fonctions n´
ecessaires des modules numpy, scipy
from numpy import linspace, array, sin, pi
from scipy import integrate
# Fonction second membre
omega = 2 * pi * f
phi = lambda Y,t: array([Y[1], -omega**2 *sin(omega*t)-R/L*Y[1]-Y[0]/(L*C)])
# R´
esolution
N = 10000
# Nbre d’´
echantillons
t = linspace(0,1,10000)
y0 = array([0,0])
result = integrate.odeint(phi,y0,t)
uL = [ result[i][0] for i in range(N) ]
# On r´
ecup`
ere la 1`
ere colonne
# ou plus simplement par slicing : uL = result[: , 0]
# Trac´
e
plot(t,uL)
title(’Tension aux bornes de la bobine’)
xlabel(’Temps (s)’); ylabel(’Tension (V)’)
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Exercice 1 : Enonc´
e
Correction
Exercice 1 : Correction.
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Corrig´
e
Exercice 2 : Fonction d´efinie de mani`ere r´ecursive
Exercice 2. Fonction d´
efinie de mani`
ere r´
ecursive
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Corrig´
e
Exercice 2 : Fonction d´efinie de mani`ere r´ecursive
1)
def g(x):
assert 0 <= x < 2
if x<1:
return x
else:
return 1
● La fonction ´
etant d´
efinie par disjonction de cas, il est utile de la ”vectoriser” (`
a l’aide de
np.vectorize() afin de pouvoir l’appliquer `
a un tableau numpy en vue du trac´
e.
g v = np.vectorize(g)
X = np.arange(0,2,0.01)
plt.figure("Exercice 2.1 : Courbe de $g$")
plt.clf()
Y = g v(X)
plt.plot(X,Y)
plt.axis([0,2,0,1.5])
plt.title(’Courbe repr´
esentative de $g$’)
plt.show()
● Aussi le graphe de la fonction ´
etant ”par pallier”, mieux vaut d´
efinir la fenˆ
etre `
a afficher `
a l’aide
de plt.axis() pour une bonne lisibilit´
e.
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Corrig´
e
Exercice 2 : Fonction d´efinie de mani`ere r´ecursive
Ce qui produit :
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Corrig´
e
Exercice 2 : Fonction d´efinie de mani`ere r´ecursive
2) D´
efinition de f de mani`
ere r´
ecursive :
def f(x):
assert x >= 0
if x < 2:
return g(x)
return x**0.5 * f(x-2)
3) Ici encore pour faciliter l’obtention de l’´
echantillonnage de l’image de f on ”vectorise” la
fonction :
f v = np.vectorize(f)
X = np.linspace(0,6,1000)
Y = f v(X)
plt.figure("Exercice 2.2 : Courbe de $f$")
plt.title(’Courbe repr´
esentative de $f$ sur $[0,6]$’)
plt.plot(X,Y)
plt.show()
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Corrig´
e
Exercice 2 : Fonction d´efinie de mani`ere r´ecursive
Ce qui produit :
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Corrig´
e
Exercice 2 : Fonction d´efinie de mani`ere r´ecursive
On remarque que la fonction f est continue et croissante sur [4.5; 5.5] avec f (4.5) < 4 et
f (5.5) > 4. On applique donc une recherche par dichotomie `
a f − 4 et l’on retournera un
encadrement `
a 10−2 pr`
es d’une racine. Le majorant dans l’encadrement nous donnera donc une
−2
valeur approch´
ee `
a 10 pr`
es (par exc`
es) du plus entier r´
eel x pour lequel f (x) > 4.
def dichotomie(f,a,b,e):
assert f(a)*f(b) <=0
if (b-a) <= e:
return a,b
m = (a+b)/2
if f(a)*f(m) < 0:
return dichotomie(f,a,m,e)
else:
return dichotomie(f,m,b,e)
a,b = dichotomie(lambda x:f(x)-4, 4.5, 5.5, 0.01)
In[1] : print(b)
Out[1] : 5.125
In[3] : f(5.125)
Out[3] : 4.001952648395531
In[4] : f(5.12)
Out[4] : 3.9967987189749747
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Correction
Exercice 3 : M´ethode des Trap`ezes
Exercice 3. M´
ethode des Trap`
ezes appliqu´
ee `
a un ´
echantillonnage
● Le fichier `
a utiliser est ”ex 001.txt” et non ”ex 001.csv”.
● Indication pour le (1) : la m´
ethode chaine.split(’;’) appliqu´
ee `
a la chaine de caract`
ere
chaine retourne la liste des sous-chaˆ
nes d´
elimit´
ees par des caract`
eres ’;’. La fonction
float() convertit son argument en nombre `
a virgule flottante.
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Correction
Exercice 3 : M´ethode des Trap`ezes
1) Utiliser split(’;’) avant de convertir en float :
LX, LY = [], []
file = open(’ex 001.txt’, ’r’)
for ligne in file:
x, y = ligne.split(’;’)
LX.append(float(x))
LY.append(float(y))
file.close()
2) On trace les points et des lignes bris´
ees les reliant (motif : ’o-’ de plot()).
plt.figure(’Exercice 3’)
plt.clf()
plt.title(’Exercice 3.2’)
plt.plot(LX,LY,’o-’)
plt.show()
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Correction
Exercice 3 : M´ethode des Trap`ezes
Ce qui donne :
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Correction
Exercice 3 : M´ethode des Trap`ezes
3) M´
ethode des trap`
ezes :
def trapeze(x,y):
n = len(x)
trapz = 0
for i in range(n-1):
trapz += (x[i+1]-x[i]) * (y[i+1]+y[i]) /2
return trapz
On obtient ainsi :
In[1] : trapeze(LX,LY)
Out[1] : 1.3187761047555
4) Avec la fonction trapz() : il faut remarquer d’abord que l’´
ecart entre abscisses cons´
ecutives est
constant ´
egale `
a 0.1 !
In[2] : from scipy import integrate
In[3] : integrate.trapz(LY, dx=0.1)
Out[3] : 1.31877610476
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Correction
Exercice 4 : Valeurs propres d’une matrice carr´ee
Exercice 4. Calcul des Valeurs propres d’une matrice carr´
ee
● Indication pour le (2) : la fonction shape() de numpy renvoie le type de la matrice sous forme
d’un couple.
● Indication pour le (3) : le fichier contient des lignes constitu´
ees de chaines repr´
esentant des listes.
La fonction eval() prend en param`
etre une chaine de caract`
ere et la convertit en la donn´
ee (ou
l’instruction) qu’elle repr´
esente : eval(’[1,2]’) retourne la liste [1,2] ;
eval("print(’bonjour’)") ´
ecrit bonjour.
● Indication pour le (4) : la fonction eig() de numpy.linalg retourne un couple dont le premier
´
el´
ement est le tableau des valeurs propres, et le deuxi`
eme la matrice des vecteurs propres dans Cn
(matrice de passage).
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Correction
Exercice 4 : Valeurs propres d’une matrice carr´ee
1)
R = np.matrix(’1 2 3; 4 5 6’)
# ou np.array([[1,2,3],[4,5,6]])
S = np.matrix(’1 2 3; 4 5 6; 7 8 9’)
print("R=\n",R)
print("S=\n",S)
2)
def test(M):
(n,p) = np.shape(M)
if n==p:
return n
else:
return False
In[1] : test(R)
Out[1] : False
In[2] : test(S)
Out[2] : 3
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Correction
Exercice 4 : Valeurs propres d’une matrice carr´ee
3)
fichier = open(’ex 009.txt’, ’r’)
liste = fichier.readlines()
fichier.close()
M = []
for x in liste:
M.append(eval(x))
M1 = np.array(M)
print("M1 = ",M1)
print("test sur M1 : ",test(M))
Produit :
M1 = [[ 0.33333333 0.16666667 0.16666667 0.16666667 0.16666667]
[ 0.16666667 0.33333333 0.16666667 0.16666667 0.16666667]
[ 0.16666667 0.16666667 0.33333333 0.16666667 0.16666667]
[ 0.16666667 0.16666667 0.16666667 0.33333333 0.16666667]
[ 0.16666667 0.16666667 0.16666667 0.16666667 0.33333333]]
test sur M1 : 5
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique
Exercice 1 : Etude d’un Circuit RLC avec la fonction odeint()
Exercice 2 : Fonction d´
efinie de mani`
ere r´
ecursive
Exercice 3 : M´
ethode des trap`
ezes appliqu´
ee `
a un ´
echantillonnage
Exercice 4 : Valeurs propres d’une matrice carr´
ee
Enonc´
e
Correction
Exercice 4 : Valeurs propres d’une matrice carr´ee
4)
from numpy.linalg import eig
val p, vec p = eig(M1)
print(’Valeurs propres de M1 : ’, val p)
Produit :
Valeurs propres de M1 : [ 0.16666667 1. 0.16666667 0.16666667 0.16666667]
5)
def dansIntervalle(L,a,b):
for x in L:
if x<a or x>b:
return False
return True
In[1] : print(’Valeurs propres toutes dans [0,1] ? ’, dansIntervalle(val p,0,1))
Out[1] : Valeurs propres toutes dans [0,1] ? True
PC - Lyc´
ee Thiers
TD 5 : Simulation num´
erique

Download Report