ÉCOLE NATIONALE D’INGÉNIEURS DE TUNIS

Département Génie Industriel

Mini projet de calcul scientifique avancé

TD2 : Résolution numérique

d’équations hyperboliques
linéaires en 1D

Elaboré par :

Belhassen Med Aziz

2ème Année MIndS.M

Encadré par :

M. Saber Amdouni

Année universitaire : 2023/2024

Remerciements

Je tiens à exprimer ma profonde gratitude envers le Professeur Amdouni Saber

pour sa guidance précieuse et son soutien constant tout au long de ce travail
pratique. Ses conseils éclairés et son expertise ont été essentiels pour comprendre les
nuances complexes de la résolution numérique des équations aux dérivées partielles.
Je tiens également à le remercier pour son engagement envers l’excellence acadé-
mique, son enthousiasme pour l’enseignement et sa disponibilité pour répondre à
nos questions. Ces qualités ont grandement enrichi notre expérience d’apprentissage
et ont suscité un intérêt profond pour le domaine passionnant de la simulation
numérique.

2
Table des matières

1 SCHÉMAS EXPLICITES 2
1.1 Équation du transport . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Schémas explicites pour la résolution numérique . . . . . . . . . . . 3
1.2.1 Conditions de périodicité et Schéma Décentré . . . . . . . . 3

2 SCHÉMA IMPLICITE 19
2.1 Etude théorique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Introduction

Le présent travail pratique vise à explorer la résolution numérique de l’équation

de transport, une équation aux dérivées partielles (EDP) fondamentale dans le
domaine de la modélisation physique. L’équation de transport décrit l’évolution
d’une quantité transportée à travers l’espace en fonction du temps, influencée par
une vitesse variable.
Dans ce contexte, nous examinerons différentes approches numériques pour ré-
soudre cette équation, en mettant en œuvre des schémas explicites et implicites. Les
schémas explicites, tels que le schéma décentré et le schéma de Lax-Wendroff, seront
étudiés dans un premier temps. Ensuite, nous explorerons un schéma implicite,
approfondissant ainsi notre compréhension des méthodes numériques pour les EDP.
Les simulations seront réalisées en utilisant des conditions initiales variées, telles
que des distributions gaussiennes et en "chapeau", et en modifiant les paramètres
de discrétisation spatiale et temporelle (h et ∆t). L’objectif est de comprendre
l’influence de ces choix sur la qualité des approximations numériques et d’observer
comment les solutions approchées se comparent aux solutions exactes.
À travers ce travail pratique, nous développerons notre intuition sur la résolution
numérique des EDP, explorerons les caractéristiques des schémas explicites et impli-
cites, et analyserons l’impact des conditions initiales sur les résultats obtenus. Ce
travail constitue une étape importante dans l’acquisition de compétences pratiques
en simulation numérique et en résolution d’équations aux dérivées partielles.

1
Chapitre 1

SCHÉMAS EXPLICITES

1.1 Équation du transport

Nous nous intéressons à l’équation du transport suivante :
∂u ∂u
+ c(t) = 0, (x, t) ∈ R × R (1.1.1)
∂t ∂x
avec la condition initiale u(x, 0) = u0 (x), où u0 (·) est 1-périodique. La solution de
l’EDP sera également 1-périodique par rapport à sa variable x, et nous pouvons
restreindre notre étude à l’intervalle x ∈ [0, 1].
Nous étudierons deux expressions possibles pour la vitesse c(t) :
— Pour tout t > 0, c(t) = 0.8 (cas (i))
— c(t) = sin(10t) (cas (ii))
De même, nous utiliserons deux formes de conditions initiales :
— Pour tout x ∈ [0, 1],
!
(x − 1/2)2
u0 (x) = a exp − (gaussienne)
σ2

— Pour tout x ∈ [0, 1],


x

 si x ≤ 41
u0 (x) =  12 − x si 14 ≤ x ≤ 1
2
(chapeau)
si x ≥ 21


0

Nous nous intéressons ici à la résolution numérique du problème (1) à l’aide de

schémas aux différences finies, pour t ∈ [0, 1].

2
 1.2 Schémas explicites pour la résolution numé-
rique
Nous nous proposons tout d’abord de tester quelques schémas explicites pour
la résolution numérique du problème.
Pour la discrétisation de l’équation, nous divisons l’intervalle en temps [0, 1] en
Nt − 1 segments de taille ∆t, et nous notons tn = (n − 1)∆t pour n ∈ [1, Nt ].
De même, nous divisons l’intervalle en espace [0, 1] en Nx − 2 intervalles de
taille h, et nous notons xj = (j − 1)h pour j ∈ [1, Nx ].

1.2.1 Conditions de périodicité et Schéma Décentré

En considérant les conditions de périodicité, nous avons x1 = 0 et xNx −1 = 1,
ce qui implique u(x1 ) = u(xNx −1 ) selon les conditions aux limites périodiques. De
même, u(x2 ) = u(xNx ).
Par la suite, nous notons un,j la solution approchée du problème (1), définie
comme un,j ≈ u(xj , tn ). Cette solution est obtenue initialement en utilisant le
schéma décentré, puis en appliquant le schéma de Lax-Wendroff. Afin de prendre
en compte les conditions de périodicité, nous imposons dans les deux cas :

∀n ∈ [1, Nt ], un,1 = un,Nx −1 , un,2 = un,Nx .

Le schéma décentré est défini par les équations suivantes pour tout n ∈ [1, Nt ]
et j ∈ [1, Nx ] :
un+1,j − un,j un,j+1 − un,j
+ c(tn ) = 0, si c(tn ) < 0.
∆t h
un+1,j − un,j un,j − un,j−1
+ c(tn ) = 0, si c(tn ) ≥ 0.
∆t h

Question 1 : Code python

1 # R s o l u t i o n n u m r i q u e de l ’ quation de transport
2 # u,t + c u,x = 0
3 # avec des s c h m a s explicites
4 # ##########################################
5 # ##########################################
6 # ##########################################
7 # Load packages
8 import numpy as np
9 import matplotlib . pyplot as plt
10 import matplotlib
11 import pylab

3
12 import scipy as sp
13 from scipy import sparse
14 from scipy . sparse import linalg
15
16 # ##########################################
17
18 # P a r a m t r e s du probleme
19

20 # Parametres de discretisation
21
22
23 h = 0.001
24 dt = 0.001
25

26 # Condition initiale
27 # 0 = > gaussienne
28 # 1 = > chapeau
29 cond_ini =1
30
31 # % Vitesse
32 # % 0 = > constante ( cas i )
33 # % 1 = > variable ( cas ii )
34 vitesse = 0
35
36 # % Type de s c h m a s
37 # % 1 => s c h m a d c e n t r
38 # % 2 = > s c h m a Lax - Wendroff ,
39 typsch =1
40
41
42 # Creation des maillages
43 x = np . arange (0 ,1+2* h , h ) ; # Le point d ’ indice Nx -1 correspond a
x =1 , identique a x =0 d ’ apres les CL
44 Nx = np . size ( x ) ; # Le point d ’ indice Nx correspond a x
=1+ h , identique a x = h d ’ apres les CL
45
46
47 t = np . arange (0 ,1+ dt , dt ) ;
48 Nt = np . size ( t ) ;
49
50
51 # Initialisation
52
53 U = np . zeros ([ Nt , Nx ]) ;
54
55
56 def gaussienne ( x ) :
57 ’’’% ( avec 0 <= x <= 1)
58 Fonction permettant de construire une solution initiale en

4
 gaussienne :
59 ’’’
60 sigma2 = 0.01;
61 a =0.1
62
63
64 # TODO
65 # ------
66 return a * np . exp ( -(x -(1/2) ) **2/ sigma2 )
67 return
68
69 def chapeau ( x ) :
70 ’’’ Fonction permettant de construire une solution initiale en
" chapeau ":
71 ( avec 0 <= x <= 1)
72 ’’’
73 N = np . size ( x )
74 y = np . zeros ( N )
75
76 if N > 1:
77 for j in range ( N ) :
78 if x [ j ] <= 0.25:
79 y[j] = x[j]
80 elif 0.25 < x [ j ] <= 0.5:
81 y [ j ] = 0.5 - x [ j ]
82 else :
83 y[j] = 0
84 else :
85 if x <= 0.25:
86 y = x
87 elif 0.25 < x < 0.5:
88 y = 0.5 - x
89 else :
90 y = 0
91
92 return y
93
94

95
96
97 if cond_ini ==0:
98 U [0 ,:]= gaussienne ( x ) ;
99 else :
100 U [0 ,:]= chapeau ( x ) ;
101
102 # -----------------------------------
103 # Boucle en temps
104 # ----------------------------------
105

5
106 for n in np . arange (0 , Nt -1) :
107 if vitesse == 0:
108 c = 0.8 # cas ( i )
109 else :
110 c = np . sin (10 * t [ n ]) # cas ( ii )
111
112 alpha = c * dt / h
113 if typsch == 1:
114 # TODO : ecrire les schemas sous la forme
115 # U [ n +1 , j ] = ...
116 if c < 0:
117 for j in np . arange (0 , Nx -2) :
118 U [ n +1 , j ] = (1 + alpha ) * U [n , j ] - alpha * U [n , j
+1]
119 U [ n +1 , Nx -2] = U [ n +1 , 0]
120 U [ n +1 , Nx -1] = U [ n +1 , 1]
121 else :
122 for j in np . arange (0 , Nx -1) :
123 U [ n +1 , j ] = (1 - alpha ) * U [n , j ] + alpha * U [n , j
-1]
124 U [ n +1 , 0] = U [ n +1 , Nx -2]
125 U [ n +1 , Nx -1] = U [ n +1 , 1]
126
127 # TODO : Traitement des conditions aux limites periodiques
128
129 elif typsch == 2:
130 # TODO : ecrire les schemas sous la forme
131 for j in np . arange (1 , Nx -1) :
132 U [ n +1 , j ] = (1 - alpha **2) * U [n , j ] + 0.5 * ( alpha **2
- alpha ) * U [n , j +1] + 0.5 * ( alpha **2 + alpha ) * U [n , j -1]
133 U [ n +1 , 0] = U [ n +1 , Nx -2]
134 U [ n +1 , Nx -1] = U [ n +1 , 1]
135
136 # TODO : Traitement des conditions aux limites periodiques
137
138 %----------------------------------------------
139 # % Le code qui suit ne doit pas etre modifier dans le cadre du TP
140

141 # % Solution exacte

142 # %
143 # % Uex (t , X ( t ) ) = U0 ( X (0) ) = U0 (x - d )
144 # %
145 # % avec
146 # % d = X ( t ) - X (0) = \ int_0 ^ t c ( t ) dt
147
148
149
150
151 Uex = np . zeros ([ Nt , Nx ]) ;

6
152 err = np . zeros ([ Nt , Nx ]) ; # Une matrice qui stocke l ’ erreur
ponctuelle entre la solution exacte et approcher en tous points
de calcules
153 err2 = np . zeros ([ Nt , 1]) ; # Un vecteur qui stocke l ’ erreur en
norme 2 entre la solution exacte et approcher chaque instant
154 for n in np . arange (0 , Nt ) :
155 for j in np . arange (0 , Nx ) :
156 if vitesse == 0:
157 d=c*t[n]
158 else :
159 d =0.1*(1. - np . cos (10* t [ n ]) )
160
161 if cond_ini == 0:
162 Uex [n , j ]= gaussienne ( np . mod ( x [ j ] -d ,1) ) ;
163 else :
164 Uex [n , j ]= chapeau ( np . mod ( x [ j ] -d ,1) ) ;
165
166
167 err [n , j ] = U [n , j ] - Uex [n , j ];
168 err2 [ n ] = np . linalg . norm ( err [n ,:] , 2) ;
169
170 err_inf_2 = np . max ( err2 )
171
172
173 plt . figure (1)
174 # matplotlib . rcParams . update ({ ’ font . size ’: 11 , ’ font . family ’: ’
serif ’})
175
176 for n in np . arange (0 , Nt ) :
177 if n %20 == 0:
178 plt . plot (x , U [n ,:] , ’b * - ’ ,x , Uex [n ,:] , ’ro - ’)
179 plt . xlabel ( ’ $x$ ’ , fontsize =11)
180 plt . title ( ’ Schema explicite centre , $t = $ % s ’ %( t [ n ]) ,
fontsize =11)
181 plt . legend ([ ’ Solution a p p r o c h e ’ , ’ Solution exacte ’] , loc =
’ best ’ , fontsize =11)
182 plt . pause (0.1)
183 plt . show ()
184
185 XX , tt = np . meshgrid (x , t )
186 fig = plt . figure ( figsize =(18 ,6) )
187 ax = fig . add_subplot (1 ,1 ,1 , projection = ’3 d ’)
188 contour = ax . plot_surface ( XX , tt ,U , rstride =4 , cstride =4 , alpha =1)
189 # contour = ax . plot_trisurf ( XX , tt , U )
190 # contour = ax . contourf ( XX , tt , U )
191
192 # fig . tight_layout ()
193 ax . view_init (45 , 45)
194 fig . colorbar ( contour )

7
195 fig . tight_layout ()
196

197 fig . show ()

198 # plt . show ()
199
200
201 fig1 = plt . figure ( figsize =(18 ,6) )
202 ax1 = fig1 . add_subplot (1 ,1 ,1)
203
204 # contour = ax . plot_surface ( XX , tt , U )
205 level = np . arange ( U . min () ,U . max () ,0.005)
206 contour1 = ax1 . contour ( XX , tt ,U , level )
207 # contour1 = ax1 . contour ( XX , tt ,U , cmap = matplotlib . cm . RdBu , vmin = U . min ()
, vmax = U . max () )
208
209 # ax1 . title ([ ’ Courbes caracteristiques ’])
210
211 # ax1 . xlabel ( ’ x ’)
212 # ax1 . ylabel ( ’ t ’)
213 # fig . tight_layout ()
214 # ax1 . view_init (45 , 45)
215 fig1 . colorbar ( contour1 )
216 fig1 . tight_layout ()
217 ax1 . set_xlabel ( ’x ’ , fontsize =24)
218 ax1 . set_ylabel ( ’t ’ , fontsize =24)
219 plt . title ( ’ Courbes caracteristiques ’ , fontsize =24)
220 fig1 . show ()
Listing 1.1 – SCHÉMAS EXPLICITES

8
Résultats

Figure 1.1 – Condition initiale : gaussienne

Interprétations
Les simulations numériques ont été réalisées en utilisant un schéma explicite
pour résoudre l’équation de transport avec une condition initiale gaussienne. Les
résultats sont illustrés par la superposition des courbes représentant la solution
exacte (en rouge) et la solution approchée (en bleu).
La courbe rouge représente la solution exacte, déterminée par la gaussienne initiale
se propageant dans le domaine spatio-temporel. La forme caractéristique de la gaus-
sienne reste inchangée, mais elle se déplace dans le temps, illustrant la propagation
du phénomène physique sous-jacent.
La courbe bleue, quant à elle, représente la solution approchée obtenue par le
schéma explicite. On observe une bonne concordance entre la solution exacte et la
solution numérique, indiquant une approximation correcte du phénomène de trans-
port. Cependant, des différences peuvent apparaître en raison de la discrétisation
spatiale et temporelle.

9
 Figure 1.2 – Condition initiale : chapeau

Interprétations
Les simulations numériques ont été réalisées en utilisant un schéma explicite pour
résoudre l’équation de transport avec une condition initiale en forme de "chapeau".
Les résultats sont présentés à travers la superposition des courbes représentant la
solution exacte (en rouge) et la solution approchée (en bleu).
La courbe rouge représente la solution exacte, caractérisée par un "chapeau" initial
se propageant dans le domaine spatio-temporel. La forme distinctive du chapeau
reste inchangée, mais il se déplace dans le temps, illustrant la propagation du
phénomène physique sous-jacent.
La courbe bleue, quant à elle, dépeint la solution approchée obtenue par le schéma
explicite. Une correspondance satisfaisante entre la solution exacte et la solution
numérique est observée, indiquant une approximation adéquate du phénomène de
transport.

Question 1)c :
Le schéma décentré utilisé dans la résolution numérique de l’équation de trans-
port est caractérisé par son ordre de consistance. En termes de précision, ce schéma

10
 est d’ordre 1 en temps et en espace. Cela signifie que la convergence vers la solu-
tion exacte s’effectue linéairement par rapport au pas de temps et au pas spatial
utilisés dans la discrétisation. Bien que le schéma décentré offre une approximation
raisonnable de l’évolution temporelle et spatiale du phénomène de transport, des
ordres de consistance plus élevés peuvent être recherchés pour obtenir une précision
accrue, aux dépens parfois d’une complexité accrue.

Question 1)d :
Les conditions de stabilité du schéma décentré sont dictées par la Courant-
Friedrichs-Lewy (CFL) condition. Pour assurer la stabilité numérique, il est néces-
saire que la relation suivante soit respectée :
∆t
c ≤1
h
où c : représente la vitesse du phénomène de transport, ∆t est le pas de temps,
et h est le pas spatial. Cette condition exprime la nécessité d’avoir une discréti-
sation temporelle suffisamment fine par rapport à la discrétisation spatiale pour
éviter des instabilités numériques. En cas de non-conformité à cette condition, des
comportements indésirables peuvent se produire, compromettant la précision et la
stabilité de la solution obtenue par le schéma décentré. En variant les paramètres
de discrétisation, tels que le pas spatial (h) et le pas de temps (dt), on peut observer
l’influence de ces choix sur la qualité de l’approximation. Des valeurs inappropriées
de h et dt peuvent entraîner une dissipation de l’énergie de la solution approchée,
la conduisant à perdre progressivement son amplitude. De plus, une dispersion peut
se produire, altérant la forme et la propagation de la solution approchée.

Question 2)a :

1 # R s o l u t i o n n u m r i q u e de l ’ quation de transport
2 # u,t + c u,x = 0
3 # avec des s c h m a s explicites
4 # ##########################################
5 # ##########################################
6 # ##########################################
7 # Load packages
8 import numpy as np
9 import matplotlib . pyplot as plt
10 import matplotlib
11 import pylab
12 import scipy as sp
13 from scipy import sparse
14 from scipy . sparse import linalg

11
15
16 # ##########################################
17
18 # P a r a m t r e s du probleme
19
20 # Parametres de discretisation
21
22

23 h = 0.001
24 dt = 0.001
25
26 # Condition initiale
27 # 0 = > gaussienne
28 # 1 = > chapeau
29 cond_ini =1
30
31 # % Vitesse
32 # % 0 = > constante ( cas i )
33 # % 1 = > variable ( cas ii )
34 vitesse = 0
35
36 # % Type de s c h m a s
37 # % 1 => s c h m a d c e n t r
38 # % 2 = > s c h m a Lax - Wendroff ,
39 typsch =2
40

41
42 # Creation des maillages
43 x = np . arange (0 ,1+2* h , h ) ; # Le point d ’ indice Nx -1 correspond a
x =1 , identique a x =0 d ’ apres les CL
44 Nx = np . size ( x ) ; # Le point d ’ indice Nx correspond a x
=1+ h , identique a x = h d ’ apres les CL
45
46
47 t = np . arange (0 ,1+ dt , dt ) ;
48 Nt = np . size ( t ) ;
49
50

51 # Initialisation
52
53 U = np . zeros ([ Nt , Nx ]) ;
54
55
56 def gaussienne ( x ) :
57 ’’’% ( avec 0 <= x <= 1)
58 Fonction permettant de construire une solution initiale en
gaussienne :
59 ’’’
60 sigma2 = 0.01;

12
 61 a =0.1
62

63
64 # TODO
65 # ------
66 return a * np . exp ( -(x -(1/2) ) **2/ sigma2 )
67 return
68

69 def chapeau ( x ) :
70 ’’’ Fonction permettant de construire une solution initiale en
" chapeau ":
71 ( avec 0 <= x <= 1)
72 ’’’
73 N = np . size ( x )
74 y = np . zeros ( N )
75
76 if N > 1:
77 for j in range ( N ) :
78 if x [ j ] <= 0.25:
79 y[j] = x[j]
80 elif 0.25 < x [ j ] <= 0.5:
81 y [ j ] = 0.5 - x [ j ]
82 else :
83 y[j] = 0
84 else :
85 if x <= 0.25:
86 y = x
87 elif 0.25 < x < 0.5:
88 y = 0.5 - x
89 else :
90 y = 0
91

92 return y
93
94
95
96
97 if cond_ini ==0:
98 U [0 ,:]= gaussienne ( x ) ;
99 else :
100 U [0 ,:]= chapeau ( x ) ;
101
102 # -----------------------------------
103 # Boucle en temps
104 # ----------------------------------
105
106 for n in np . arange (0 , Nt -1) :
107 if vitesse == 0:
108 c = 0.8 # cas ( i )

13
109 else :
110 c = np . sin (10 * t [ n ]) # cas ( ii )
111
112 alpha = c * dt / h
113 if typsch == 1:
114 # TODO : ecrire les schemas sous la forme
115 # U [ n +1 , j ] = ...
116 if c < 0:
117 for j in np . arange (0 , Nx -2) :
118 U [ n +1 , j ] = (1 + alpha ) * U [n , j ] - alpha * U [n , j
+1]
119 U [ n +1 , Nx -2] = U [ n +1 , 0]
120 U [ n +1 , Nx -1] = U [ n +1 , 1]
121 else :
122 for j in np . arange (0 , Nx -1) :
123 U [ n +1 , j ] = (1 - alpha ) * U [n , j ] + alpha * U [n , j
-1]
124 U [ n +1 , 0] = U [ n +1 , Nx -2]
125 U [ n +1 , Nx -1] = U [ n +1 , 1]
126

127 # TODO : Traitement des conditions aux limites periodiques

128
129 elif typsch == 2:
130 # TODO : ecrire les schemas sous la forme
131 for j in np . arange (1 , Nx -1) :
132 U [ n +1 , j ] = (1 - alpha **2) * U [n , j ] + 0.5 * ( alpha **2
- alpha ) * U [n , j +1] + 0.5 * ( alpha **2 + alpha ) * U [n , j -1]
133 U [ n +1 , 0] = U [ n +1 , Nx -2]
134 U [ n +1 , Nx -1] = U [ n +1 , 1]
135
136 # TODO : Traitement des conditions aux limites periodiques
137

138 %----------------------------------------------
139 # % Le code qui suit ne doit pas etre modifier dans le cadre du TP
140
141 # % Solution exacte
142 # %
143 # % Uex (t , X ( t ) ) = U0 ( X (0) ) = U0 (x - d )
144 # %
145 # % avec
146 # % d = X ( t ) - X (0) = \ int_0 ^ t c ( t ) dt
147
148
149

150
151 Uex = np . zeros ([ Nt , Nx ]) ;
152 err = np . zeros ([ Nt , Nx ]) ; # Une matrice qui stocke l ’ erreur
ponctuelle entre la solution exacte et approcher en tous points
de calcules

14
153 err2 = np . zeros ([ Nt , 1]) ; # Un vecteur qui stocke l ’ erreur en
norme 2 entre la solution exacte et approcher chaque instant
154 for n in np . arange (0 , Nt ) :
155 for j in np . arange (0 , Nx ) :
156 if vitesse == 0:
157 d=c*t[n]
158 else :
159 d =0.1*(1. - np . cos (10* t [ n ]) )
160
161 if cond_ini == 0:
162 Uex [n , j ]= gaussienne ( np . mod ( x [ j ] -d ,1) ) ;
163 else :
164 Uex [n , j ]= chapeau ( np . mod ( x [ j ] -d ,1) ) ;
165

166
167 err [n , j ] = U [n , j ] - Uex [n , j ];
168 err2 [ n ] = np . linalg . norm ( err [n ,:] , 2) ;
169
170 err_inf_2 = np . max ( err2 )
171

172
173 plt . figure (1)
174 # matplotlib . rcParams . update ({ ’ font . size ’: 11 , ’ font . family ’: ’
serif ’})
175
176 for n in np . arange (0 , Nt ) :
177 if n %20 == 0:
178 plt . plot (x , U [n ,:] , ’b * - ’ ,x , Uex [n ,:] , ’ro - ’)
179 plt . xlabel ( ’ $x$ ’ , fontsize =11)
180 plt . title ( ’ Schema explicite centre , $t = $ % s ’ %( t [ n ]) ,
fontsize =11)
181 plt . legend ([ ’ Solution a p p r o c h e ’ , ’ Solution exacte ’] , loc =
’ best ’ , fontsize =11)
182 plt . pause (0.1)
183 plt . show ()
184
185 XX , tt = np . meshgrid (x , t )
186 fig = plt . figure ( figsize =(18 ,6) )
187 ax = fig . add_subplot (1 ,1 ,1 , projection = ’3 d ’)
188 contour = ax . plot_surface ( XX , tt ,U , rstride =4 , cstride =4 , alpha =1)
189 # contour = ax . plot_trisurf ( XX , tt , U )
190 # contour = ax . contourf ( XX , tt , U )
191
192 # fig . tight_layout ()
193 ax . view_init (45 , 45)
194 fig . colorbar ( contour )
195 fig . tight_layout ()
196
197 fig . show ()

15
198 # plt . show ()
199

200
201 fig1 = plt . figure ( figsize =(18 ,6) )
202 ax1 = fig1 . add_subplot (1 ,1 ,1)
203
204 # contour = ax . plot_surface ( XX , tt , U )
205 level = np . arange ( U . min () ,U . max () ,0.005)
206 contour1 = ax1 . contour ( XX , tt ,U , level )
207 # contour1 = ax1 . contour ( XX , tt ,U , cmap = matplotlib . cm . RdBu , vmin = U . min ()
, vmax = U . max () )
208
209 # ax1 . title ([ ’ Courbes caracteristiques ’])
210

211 # ax1 . xlabel ( ’ x ’)

212 # ax1 . ylabel ( ’ t ’)
213 # fig . tight_layout ()
214 # ax1 . view_init (45 , 45)
215 fig1 . colorbar ( contour1 )
216 fig1 . tight_layout ()
217 ax1 . set_xlabel ( ’x ’ , fontsize =24)
218 ax1 . set_ylabel ( ’t ’ , fontsize =24)
219 plt . title ( ’ Courbes caracteristiques ’ , fontsize =24)
220 fig1 . show ()
Listing 1.2 – SCHÉMAS EXPLICITES

Question 2)b :
Les différences de comportement entre le schéma décentré et le schéma de Lax-
Wendroff résident dans leurs formulations spécifiques et leurs propriétés numériques
respectives.
1. Propagation de l’onde :
— Schéma Décentré : Méthode d’ordre 1, non dissipative, mais peut
introduire de la diffusion numérique.
— Lax-Wendroff : Méthode d’ordre 2, propage mieux l’onde avec moins
de diffusion numérique.
2. Conservation de la forme :
— Schéma Décentré : Peut altérer la forme de l’onde au fil du temps.
— Lax-Wendroff : Généralement, conserve mieux la forme de l’onde.
3. Dispersion et dissipation :
— Schéma Décentré : Peut présenter de la dissipation et de la dispersion
numériques.

16
 — Lax-Wendroff : Minimise ces effets avec un ordre 2.
4. Adaptation aux caractéristiques locales :
— Schéma Décentré : Plus adapté à la résolution de discontinuités, mais
peut introduire des oscillations non physiques.
— Lax-Wendroff : Mieux adapté aux caractéristiques locales sans autant
d’oscillations que le schéma décentré.
En résumé, bien que le schéma décentré soit simple et adapté à certaines
situations, le schéma de Lax-Wendroff offre généralement une meilleure conservation
des caractéristiques de l’onde et une réduction des erreurs numériques.

Question 2)c :
L’ordre de consistance du schéma de Lax-Wendroff est de deuxième ordre en
temps (∆t) et en espace (∆x). Cela signifie que la méthode est capable de repro-
duire les termes de dérivées partielles de manière précise jusqu’au terme d’ordre
O(∆t2 , ∆x2 ). En d’autres termes, lorsque les pas de temps et spatial tendent vers
zéro, l’erreur de la méthode converge vers zéro au moins aussi rapidement que le
carré de ces pas.
La formulation du schéma de Lax-Wendroff offre une précision accrue par rapport
aux schémas d’ordre inférieur, en faisant un choix attractif pour la résolution numé-
rique d’équations aux dérivées partielles, particulièrement lorsque la conservation
des caractéristiques de l’onde est cruciale.

Question 2)d :
Les conditions de stabilité du schéma de Lax-Wendroff sont déterminées par la
condition CFL (Courant-Friedrichs-Lewy). Pour assurer la stabilité numérique de
la méthode, la condition CFL doit être respectée, et elle est définie comme suit :
c · ∆t
≤1
∆x
où :
— c est la vitesse du transporteur,
— ∆t est le pas de temps,
— ∆x est le pas spatial.
Cette condition garantit que l’information ne se propage pas trop rapidement à
travers le maillage numérique, évitant ainsi des instabilités numériques telles que
des oscillations non physiques. En respectant la condition CFL, on assure une
progression temporelle appropriée par rapport à la discrétisation spatiale, assurant

17
ainsi la stabilité du schéma de Lax-Wendroff.
En ajustant les paramètres de discrétisation tels que le pas spatial (h) et le pas
de temps (dt), on peut observer l’influence de ces choix sur la qualité de l’approxi-
mation. Des valeurs inappropriées de h et dt peuvent entraîner une dissipation de
l’énergie de la solution approchée, conduisant ainsi à une diminution progressive
de son amplitude. De plus, une dispersion peut se produire, altérant la forme
et la propagation de la solution approchée. Il est crucial de trouver un équilibre
optimal dans le choix de ces paramètres pour assurer une représentation précise du
phénomène physique sous-jacent, évitant ainsi des distorsions indésirables dans la
solution numérique.

18
 Chapitre 2

SCHÉMA IMPLICITE

2.1 Etude théorique

On se propose maintenant d’étudier un schéma implicite. Pour la discrétisation,
nous divisons l’intervalle en temps [0, 1] en Nt − 1 segments de taille ∆t, et on
note encore tn = (n − 1)∆t pour n ∈ [1; Nt ]. De même, nous divisons l’intervalle en
espace [0, 1] en Nx intervalles de taille h, où xj = (j − 1)h pour j ∈ [1; Nx ]. Il en
résulte que x1 = 0 et xNx = 1 − h. Comme dans le cas des schémas explicites, on
note un,j la solution approchée du problème (1), définie par le schéma suivant :

1 un+1,j+1 − un,j+1 un+1,j − un,j c(tn ) un+1,j+1 − un+1,j un,j+1 − un,j

   
+ + + =0
2 ∆t ∆t 2 h h

Question 1 :

1 # R s o l u t i o n n u m r i q u e de l ’ quation de transport
2 # u,t + c u,x = 0
3 # avec des s c h m a s implicite
4 # #######################################################
5

6 # #######################################################
7 # Load packages
8 import numpy as np
9 import matplotlib . pyplot as plt
10 import matplotlib
11 import pylab
12 import scipy as sp
13 from scipy import sparse
14 from scipy . sparse import linalg
15 from scipy . sparse import csc_matrix
16 from scipy . sparse . linalg import spsolve

19
17
18

19 # #######################################################
20
21 # P a r a m t r e s du probleme
22
23 # Parametres de discretisation
24 h = 0.001
25 dt = 0.001
26
27 # Condition initiale
28 # 0 = > gaussienne
29 # 1 = > chapeau
30 cond_ini =0
31
32 # % Vitesse
33 # % 0 = > constante ( cas i )
34 # % 1 = > variable ( cas ii )
35 vitesse = 1
36

37
38
39 # Creation des maillages
40 # TO DO
41
42 x = np . arange (0 ,1 , h ) ; # Le point d ’ indice Nx -1 correspond a x =1 -
h , identique a x = h d ’ apres les CL
43 Nx = len ( x ) ; # Le point d ’ indice Nx correspond a x =1 , identique a
x =0 d ’ apres les CL
44
45
46 t = np . arange (0 ,1+ dt , dt ) ;
47 Nt = len ( t ) ;
48
49 # Initialisation
50
51 U = np . zeros ([ Nt , Nx ]) ;
52

53
54 def gaussienne ( x ) :
55 ’’’% ( avec 0 <= x <= 1)
56 Fonction permettant de construire une solution initiale en
gaussienne :
57 ’’’
58 sigma2 = 0.01;
59 a =0.1
60
61
62 # TODO

20
 63 # ------
64 return a * np . exp ( -(x -0.5) **2/ sigma2 )
65 return
66
67 def chapeau ( x ) :
68 ’’’ Fonction permettant de construire une solution initiale en
" chapeau ":
69 ( avec 0 <= x <= 1)
70 ’’’
71 N = np . size ( x )
72 y = np . zeros ( N )
73
74 if N > 1:
75 for j in range ( N ) :
76 if x [ j ] <= 0.25:
77 y[j] = x[j]
78 elif 0.25 < x [ j ] <= 0.5:
79 y [ j ] = 0.5 - x [ j ]
80 else :
81 y[j] = 0
82 else :
83 if x <= 0.25:
84 y = x
85 elif 0.25 < x < 0.5:
86 y = 0.5 - x
87 else :
88 y = 0
89
90 return y
91
92
93

94
95
96
97
98
99 # condinitiale = gaussienne
100 # for j in np . arange (0 , Nx ) :
101 # print ( j )
102 if cond_ini ==0:
103 U [0 ,:]= gaussienne ( x ) ;
104
105 else :
106
107 U [0 ,:]= chapeau ( x ) ;
108
109 # -----------------------------------
110 # Boucle en temps

21
111 # ----------------------------------
112

113
114
115 for n in np . arange (0 , Nt -1) :
116 if vitesse == 0:
117 c =0.8 # cas ( i )
118 else :
119 c = np . sin (10* t [ n +1]) # cas ( ii )
120
121
122 alpha = c *( dt / h ) ;
123
124 # To DO
125 # apres un calcul la main on a d e t e r m i n
126
127 #A=-------------
128 #B=---------------
129 # Construction des matrices A et B
130 A = np . diag ( np . full ( Nx , 1 - alpha ) ) + np . diag ( np . full ( Nx -1 , 1 +
alpha ) , k =1)
131 B = np . diag ( np . full ( Nx , 1 + alpha ) ) + np . diag ( np . full ( Nx -1 , 1 -
alpha ) , k =1)
132
133 # Conditions aux limites
134 A [ Nx -1 , 0] = 1 + alpha
135 B [ Nx -1 , 0] = 1 - alpha
136
137 U [ n +1 , :] = np . linalg . solve (A , B . dot ( U [n , :]) )
138
139
140

141
142
143 #
%--------------------------------------------------------------------------

144 # % Le code qui suit ne doit pas etre modifier dans le cadre du TP
145
146
147 # % Solution exacte
148 # %
149 # % Uex (t , X ( t ) ) = U0 ( X (0) ) = U0 (x - d )
150 # %
151 # % avec
152 # % d = X ( t ) - X (0) = \ int_0 ^ t c ( t ) dt
153
154
155

22
156
157 Uex = np . zeros ([ Nt , Nx ]) ;
158 err = np . zeros ([ Nt , Nx ]) ;
159 err2 = np . zeros ([ Nt , 1]) ;
160 for n in np . arange (0 , Nt ) :
161 for j in np . arange (0 , Nx ) :
162 if vitesse == 0:
163 d=c*t[n]
164 else :
165 d =0.1*(1. - np . cos (10* t [ n ]) )
166
167 if cond_ini == 0:
168 Uex [n , j ]= gaussienne ( np . mod ( x [ j ] -d ,1) ) ;
169 else :
170 Uex [n , j ]= chapeau ( np . mod ( x [ j ] -d ,1) ) ;
171
172
173 err [n , j ] = U [n , j ] - Uex [n , j ];
174 err2 [ n ] = np . linalg . norm ( err [n ,:] , 2) ;
175

176 err_inf_2 = np . max ( err2 )

177
178
179 plt . figure (1)
180 # matplotlib . rcParams . update ({ ’ font . size ’: 11 , ’ font . family ’: ’
serif ’})
181
182 for n in np . arange (0 , Nt ) :
183 if n %1 == 0:
184 plt . plot (x , U [n ,:] , ’b * - ’ ,x , Uex [n ,:] , ’ro - ’)
185 plt . xlabel ( ’ $x$ ’ , fontsize =11)
186 plt . title ( ’ Schema explicite centre , $t = $ % s ’ %( t [ n ]) ,
fontsize =11)
187 plt . legend ([ ’ Solution approcher ’ , ’ Solution exacte ’] , loc = ’
best ’ , fontsize =11)
188 plt . pause (0.1)
189 plt . show ()
190

191 XX , tt = np . meshgrid (x , t )
192 fig = plt . figure ( figsize =(18 ,6) )
193 ax = fig . add_subplot (1 ,1 ,1 , projection = ’3 d ’)
194 contour = ax . plot_surface ( XX , tt ,U , rstride =4 , cstride =4 , alpha =1)
195 # contour = ax . plot_trisurf ( XX , tt , U )
196 # contour = ax . contourf ( XX , tt , U )
197
198 # fig . tight_layout ()
199 ax . view_init (45 , 45)
200 fig . colorbar ( contour )
201 fig . tight_layout ()

23
202
203 fig . show ()
204 # plt . show ()
205
206
207 fig1 = plt . figure ( figsize =(18 ,6) )
208 ax1 = fig1 . add_subplot (1 ,1 ,1)
209

210 # contour = ax . plot_surface ( XX , tt , U )

211 level = np . arange ( U . min () ,U . max () ,0.005)
212 contour1 = ax1 . contour ( XX , tt ,U , level )
213 # contour1 = ax1 . contour ( XX , tt ,U , cmap = matplotlib . cm . RdBu , vmin = U . min ()
, vmax = U . max () )
214

215 # ax1 . title ([ ’ Courbes caracteristiques ’])

216
217 # ax1 . xlabel ( ’ x ’)
218 # ax1 . ylabel ( ’ t ’)
219 # fig . tight_layout ()
220 # ax1 . view_init (45 , 45)
221 fig1 . colorbar ( contour1 )
222 fig1 . tight_layout ()
223 ax1 . set_xlabel ( ’x ’ , fontsize =24)
224 ax1 . set_ylabel ( ’t ’ , fontsize =24)
225 plt . title ( ’ Courbes caracteristiques ’ , fontsize =24)
226 fig1 . show ()
Listing 2.1 – SCHÉMA IMPLICITE

24
Résultats

Figure 2.1 – Condition initiale : gaussienne

25
 Figure 2.2 – Condition initiale : chapeau

Question 2 :
Observons les résultats obtenus par rapport aux schémas explicites précédem-
ment étudiés. En utilisant un schéma implicite, nous constatons une différence
majeure dans la manière dont la solution numérique évolue au fil du temps. Contrai-
rement aux schémas explicites, le schéma implicite offre une stabilité accrue et
n’impose pas de restrictions strictes sur la taille des pas de temps et spatiaux pour
garantir la convergence.
L’approche implicite permet de traiter des pas de temps plus grands sans compro-
mettre la stabilité numérique, offrant ainsi une flexibilité accrue dans le choix des
paramètres de discrétisation. Cependant, il est essentiel de noter que l’implémenta-
tion du schéma implicite peut nécessiter la résolution d’un système d’équations,
ce qui peut entraîner un coût computationnel plus élevé par rapport aux schémas
explicites.

Question 3 :
Le schéma implicite présenté est d’ordre 1 en temps et d’ordre 1 en espace.
Cela signifie que l’erreur de troncature, mesurant la différence entre la solution

26
numérique obtenue à partir du schéma et la solution exacte de l’équation aux
dérivées partielles, est proportionnelle à la somme des erreurs de discrétisation en
temps et en espace, et cette proportionnalité est au moins linéaire.
Plus précisément, pour un schéma d’ordre 1 en temps, si l’on diminue le pas de temps
∆t d’un facteur r, l’erreur de troncature en temps diminuera proportionnellement
par r. De même, pour un schéma d’ordre 1 en espace, si l’on diminue le pas spatial
h d’un facteur r, l’erreur de troncature en espace diminuera proportionnellement
par r.
En conséquence, le schéma global est d’ordre 1 en temps et en espace, indiquant
une convergence linéaire de la solution numérique vers la solution exacte à mesure
que les pas de temps et d’espace tendent vers zéro.

Question 4 :
La condition de stabilité du schéma implicite est déterminée par la condition
CFL (Courant-Friedrichs-Lewy) qui s’exprime comme suit :

α≤1

où α = c∆t h
est le nombre de Courant. Respecter cette condition est crucial pour
éviter l’instabilité numérique du schéma implicite. En d’autres termes, le produit de
la vitesse c, du pas de temps ∆t, et de l’inverse du pas spatial h doit être inférieur
ou égal à 1 pour assurer la stabilité du schéma.
En faisant varier les pas spatial (h) et temporel (∆t), on peut observer l’influence
de ces paramètres sur le comportement de la solution approchée. Le choix de h et
∆t est crucial dans la résolution numérique des équations aux dérivées partielles,
car il impacte la précision et la stabilité du schéma numérique.
Lorsque h et ∆t sont trop grands, cela peut conduire à une approximation gros-
sière de la solution, entraînant des erreurs significatives. À l’inverse, des valeurs
trop petites peuvent augmenter le coût computationnel du calcul sans forcément
améliorer la précision.
Il est essentiel de trouver un équilibre entre la précision de l’approximation et
l’efficacité numérique en ajustant h et ∆t de manière appropriée. Une exploration
systématique de différentes combinaisons de h et ∆t permet d’observer comment la
solution approchée réagit aux variations de ces paramètres et de choisir des valeurs
optimales pour obtenir une approximation numérique précise et stable.

27
Conclusion

En conclusion, ce travail pratique nous a permis de plonger dans le monde de

la résolution numérique des équations aux dérivées partielles, en se concentrant
particulièrement sur l’équation de transport. Nous avons exploré différentes mé-
thodes, allant des schémas explicites, tels que le schéma décentré et le schéma de
Lax-Wendroff, au schéma implicite.
Les résultats obtenus à travers les simulations numériques ont mis en lumière
l’influence significative des choix de conditions initiales, ainsi que des paramètres de
discrétisation spatiale et temporelle, sur la qualité des approximations. Les schémas
explicites ont montré une bonne concordance avec les solutions exactes, mais des
variations dans la dispersion et la dissipation ont été observées.
L’utilisation d’un schéma implicite a ajouté une dimension supplémentaire à notre
compréhension, en permettant une approche différente de la résolution du problème.
Cependant, il est important de noter que chaque schéma a ses avantages et ses
limitations, et le choix entre eux dépend du problème spécifique et des conditions
aux limites.
En conclusion, ce travail a fourni des perspectives précieuses sur la manière dont
les méthodes numériques peuvent être appliquées à des problèmes complexes de
transport, et il ouvre la voie à des investigations plus approfondies dans le domaine
de la simulation numérique des EDP.

28