Transcript Merci, Jeeves. pdf free

TD Python
Graphes et équations différentielles
Le but de ce TD est de représenter graphiquement certaines fonctions
et de résoudre des équations différentielles.
MP*
• Si l’on veut effacer les instructions de tracé, on utilise pl.clf().
1) Tester les instructions précédentes sur diverses fonctions classiques.
I. Initialisation
Importer le module numpy sous l’appellation np.
Importer le module de tracé matplotlib.pyplot sous l’appellation pl.
• On définit l’ensemble des points abscisses sous forme d’un tableau
x=np.linspace(début, fin, nbre de points) ou par x=np.arange(début,
fin, pas).
• Les fonctions s’appliquent aux tableaux :
y1=sin(x)
def gauss(x) : return exp(-x**2)
y2=gauss(x)
• Si la fonction f ne peut s’appliquer sur les vecteurs (tableaux à une
dimension), on peut utiliser np.vectorize(f).
• Le tracé s’effectue avec l’instruction pl.plot :
2) Modifier les options de couleur, de style de trait, d’épaisseur :
pl.plot(x,y, ’g’) (en vert)
pl.plot(x, y, color = (1,0.5,0))
pl.plot(x, y, linestyle = ’-.’)
pl.plot(x, y, linewidth = 5.6)
pl.plot(x, y, marker = ’o’)
3) Légender les axes, ajouter un titre, tracer les axes horizontaux et
verticaux :
pl.title(’Mon titre’)
pl.xlabel(’abscisses’)
pl.ylabel(’ordonnée’)
pl.axhline()
pl.axvline()
Ajouter des valeurs d’abscisses et leur étiquette :
pl.xticks([0,np.pi, 2*np.pi, 3*np.pi,4*np.pi], [r’0’, r’π’, r’2π’, r’3π’,
r’4π’])
pl.plot(x,y1)
• On peut fixer les dimensions de la fenêtre de visualisation par
pl.axis([xmin,xmax,ymin,ymax]).
• La visualisation de l’ensemble des instructions plot s’obtient avec
l’instruction pl.show().
Ajouter un quadrillage :
pl.grid(True)
et des légendes des graphes :
pl.legend([r’f (x) = exp(−x2 )’, r’g(x) = sin(x)’])
1
TD Python
Graphes et équations différentielles
II. Tracé de fonctions
III. Équations différentielles
1. Tracer sur un même graphe les diverses densités de probabilité d’une
particules quantique confinée dans un puits de potentiel de profondeur infinie :
from scipy.integrate import odeint
1) Équations du premier ordre
2
nπx
ρn = sin2
.
a
a
MP*
Le principe d’utilisation de odeint (pour intégrer numériquement des
équations différentielles) est le suivant : pour avoir une estimation
numérique de la solution du problème de Cauchy




y 0 (t) = f (y(t), t)
,



y(t0 ) = y0
on donne comme argument la fonction f (qui doit avoir deux paramètres, même dans le cas automome, avec t (suivant les notations
précédentes) comme deuxième paramètre), la condition initiale y0 , et le
domaine de temps qui nous intéresse (qui commence à t0 ). Il nous est
retourné un tableau (même si t était une liste).
2. Tracer et interpréter les sommes partielles des séries de Fourier :
(a) d’un signal triangle
!
2π(2p + 1)t
cos
N
T
8E X
T rN (t) = 2
;
π p=0
(2p + 1)2
def f(y,t): return ...
t = np.linspace (0 ,1 ,3)
Y=odeint(f,1,t)
pl.plot(t,Y)
pl.show()
(b) d’un signal créneau
!
2π(2p + 1)t
N sin
X
T
4E
CrN (t) =
.
π p=0
2p + 1
Tester la procédure sur l’exemple de la charge d’un condensateur :
dU
U
E
+ = .
dt
τ
τ
2
TD Python
Graphes et équations différentielles
MP*
Par exemple, l’équation du pendule simple pesant s’écrit :
y 00 + ω02 sin y = 0,
qui est équivalent au système :
2) Équations du second ordre
On peut également traiter le cas où y est un k-uplet. Cela permet de
traiter le cas d’un système différentiel du type




y10 (t) = f1 (y1 (t), y2 (t), t)



y20 (t) = f2 (y1 (t), y2 (t), t)
ce qui inclut les équations différentielles d’ordre 2 : la résolution de
y 00 (t) = f (y 0 (t), y(t), t) passera par celle du système différentiel




y10 (t) = y2 (t)



y20 (t) = f (y1 (t), y2 (t), t).




y10 = y2



y20 = −ω02 sin(y1 ).
def pendule (couple,t):
[y1,y2] = couple
return [y2 ,-np.sin(y1)]
t = np.linspace (0 ,10 ,1000)
Y1 = odeint( pendule ,[0 ,1] ,t)
Y2 = odeint( pendule ,[0 ,2.2] ,t)
pl.plot(t,Y1[:,0])
pl.plot(t,Y2[:,0])
pl.grid()
pl.show()
Dans le résultat (qui est une liste de couple, notons-la res), les premières
composantes (que l’on récupère à la numpy via res[ :,0]) représentent
les valeurs prises par y, et la seconde composante représentera celles
de y 0 . Cela permettra de représenter au choix le graphe de y (y(t) en
fonction de t) ou bien le portrait de phase (les couples (y(t), y 0 (t))).
3
TD Python
Graphes et équations différentielles
1) Tracer les portraits de phase du pendule non amorti :
MP*
3) Implémenter le tracé de l’oscillateur amorti par frottements fluides.
4) Tracer quelques courbes temporelles et les portraits de phase associés pour diverses valeurs du facteur de qualité.
2) On montre que la période T des oscillations est une fonction de
l’amplitude maximale des oscillations donnée par :
√
dθ
2 T0 Z θmax
√
T (θmax ) =
.
π
0
cos θ − cos θmax
On peut évaluer une intégrale numérique par l’instruction quad.
5) Tracer l’amplitude et le portrait de phase d’un oscillateur amorti
par frottements solides. Le signe d’un réel a s’obtient par np.sign(a)
from scipy.integrate import quad
L’instruction quad retourne un couple de valeurs, (résultat,erreur).
Elle s’applique à une fonction dont on peut fixer un paramètre a par
l’option args(a,). Tracer la fonction T (θmax ) pour plusieurs valeurs
de θmax comprise dans un intervalle [0, π − ε].
IV. Contours
On peut tracer les courbes d’équation f (x, y) = cte grâce à l’instruction
pl.contour.
La fonction f est définie sur un domaine rectangulaire formé de deux
listes :
x=np.linspace(-2,2,100)
y=np.linspace(-2,2,100)
Ces deux listes forment un réseau à deux dimensions grâce à l’instruction
np.meshgrid :
X,Y=np.meshgrid(x,y)
4
TD Python
Graphes et équations différentielles
MP*
Observer le contenu des variables X et Y.
V. Animations
1) Définir la fonction f puis représenter les courbes f (X, Y ) = cte. On
choisit les constantes dans un tableau (np.linspace).
2) Observer les équipotentielles d’un doublet de charges opposées.
On peut animer certaines représentation grâce au module animation.
from matplotlib import animation
Il faut définir :
• une liste d’abscisses x=np.linspace(...) ;
• un pas temporel dt.
fig = figure() # initialise la figure
line, = plot([],[])
xlim(xmin, xmax) # intervalle en x
ylim(ymin,ymax) # intervalle en y
3) Observer les équipotentielles d’un dipôle électrostatique.
# crée l’arrière de l’animation qui sera présent
sur chaque image
def init():
line.set_data([],[])
return line,
# l’animation proprement dite
def animate(i):
t = i * dt
y = cos(2*np.pi*(x - t))
line.set_data(x, y)
return line,
ani = animation.FuncAnimation(fig, animate, init_func=init,
frames=100, blit=True, interval=20, repeat=True)
show()
5
TD Python
Graphes et équations différentielles
Superposer et animer deux états confinés d’une particule quantique dans
un puits infini.
Problèmes
MP*
II) Oscillateur mécanique non-linéaire amorti
1. Ajouter une force de frottement de la forme f = −4x˙ (en unités
arbitraires).
Vérifier, sur le portrait de phase, que l’on a plusieurs attracteurs
possibles selon les conditions initiales. On pourra prendre :
a. Position initiale : x0 = 11 et vitesse initiale : v0 = −100.
b. Position initiale : x0 = 11 et vitesse initiale : v0 = −150.
I) Oscillateur mécanique non amorti
1. On considère maintenant un point matériel se mouvant dans un
double puits de potentiel (donc dans un potentiel non linéaire).
On prendra, par exemple, une énergie potentielle Ep = −80x2 + x4 .
a. Tracer le profil de l’énergie potentielle.
b. Tracer le portrait de phase de l’oscillateur pour plusieurs conditions initiales différentes.
Interpréter ces deux portraits de phase.
2. On souhaite voir les oscillations forcées du système et observer la
transition vers le chaos (imaginer une bille sur un support, ayant la
forme du potentiel décrit précédemment, soumis à des oscillations
périodiques).
a. Choisir des conditions initiales telles que, sans force excitatrice,
le système reste dans un seul puits.
b. Imposer une force sinusoïdale extérieure d’amplitude F de pulsation 21.
c. Faire croître l’amplitude des oscillations jusqu’à observer un seuil
de dédoublement de la trajectoire dans l’espace des phases.
d. Continuer à faire croître l’amplitude pour montrer d’autres dédoublements jusqu’à l’apparition du chaos.
6