See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/332705378

Simulation numérique en FreeFem++ de quelques équations de la physique

mathématiques

Preprint · April 2019

CITATIONS READS

0 2,343

1 author:

Allaoua Mehri
University of El-Tarf
12 PUBLICATIONS   12 CITATIONS   

SEE PROFILE

Some of the authors of this publication are also working on these related projects:

SCHWARZ ALGORITHM FOR ELLIPTIC VARIATIONAL INEQUALITIES View project

Numerical Analysis View project

All content following this page was uploaded by Allaoua Mehri on 27 April 2019.

The user has requested enhancement of the downloaded file.

 Simulation numérique en FreeFem++ de quelques équations
de la physique mathématiques
Mehri Allaoua
Département de Mathématiques, Université 08 Mai 1945,
Guelma, Algérie, E-mail : mehri.allaoua@univ-guelma.dz

1 Introduction
FreeFem++ est un logiciel libre développé au laboratoire Jacques-Louis Lions de l’université Pierre
et Marie Curie, didié à la résolution des équations aux dérivées partielles par la méthode de type
éléments finis. On se limite dans cette partie à l’équation de Poisson, équation de la chaleur, équation
des ondes, et équation non linéaire.

2 Algorithme de programmation de la méthode des éléments

finis
1. Déclaration des variables
2. Définition du domaine
3. Définition du maillage
4. Définition de l’ensemble d’éléments finis
5. Définition du problème variationnel + conditions aux limites
6. Résolution du problème variationnel
7. Figuration (traçage) de la solution
8. Enregistrement des résultats

3 Equation de Poisson


−∆u = f dans Ω
(1)
u = g sur Γ

1
où f est une fonction dans L2(Ω) et g|Γ ∈ L2(Γ).
Problème variationnel
Z Z
∇u∇vdx = f vdx ∀v ∈ H01(Ω), u − g ∈ H01(Ω)
Ω Ω

Estimation d’erreur
ku − uhkL2(Ω) ≤ ch1+k , k = 1, 2

3.1 Exemple 1

Ω = [0, 1]2 , f = 5 ∗ π 2 ∗ sin(2 ∗ π ∗ x) ∗ sin(π ∗ y)

// equation de Poisson en 2D, -delta(u)=f in (0,1)*(0,1)

// condition au bord u=g on gamma
verbosity=0. ;
func f = (5.*pi^2)*sin(2.*pi*x)*sin(pi*y) ; // second membre
func g= sin(2.*pi*x)*sin(pi*y) ; ; // condition de Dirichlet
func ue=sin(2.*pi*x)*sin(pi*y) ;// solution exacte
// déclaration des variables
// resolution du problème variationnel
real[int] L2error(2) ;
for(int n=0 ;n<2 ;n++)
{
mesh Th=square(40*(n+1),40*(n+1)) ; // définition du maillage
fespace Vh(Th,P1) ; // définition de l’espace d’éléments finis
Vh uh,vh ; // fonctions éléments finis
Vh h = hTriangle ;
real nbt=Th.nt, nbv=Th.nv, hmax =h[].max,hmin=h[].min ;

2
cout<<"nbt="<<nbt<<","<<"nbv="<<nbv<<","<<"hmax="<<h[].max
macro Grad(uh)[dx(uh),dy(uh)]//
solve Poisson(uh,vh) = int2d(Th)(Grad(uh)’*Grad(vh))
- int2d(Th)( f*vh) + on(1,2,3,4,uh=g) ;
plot(Th,cmm="Nbre de noeuds : "+nbv) ; // traçage du maillage, T : tri-
angles,N : noeuds
//visualusation de la solution
plot(uh,dim=3,fill=false,value=true,ps="Poisson.jpg",boundary=true,cm
plot(uh,dim=2,fill=false,value=true,cmm="surface de uh",boundary=tru
plot(uh,dim=3,fill=true,value=true,boundary=true) ;
L2error[n]= sqrt(int2d(Th)((uh-ue)^2)) ;
}
for(int n=0 ;n<2 ;n++)
{+++
cout << " L2error " << n << " = "<< L2error[n] <<endl ;
}
cout <<" convergence rate = "<< log(L2error[0]/L2error[1])/log(2.) <<endl ;
//savemesh(Th,"Th.msh") ; // sauvegarde des coordonnées du maillage
//cout<<"uh="<<uh[]<<endl ;

3
Figure 1 – maillage, pash = 1/80, nbT riangles = 12800, nbN oeuds = 6561

Figure 2 – Solution du problème en dim3

4
 Figure 3 – Projection de la solution ds Z=0

Figure 4 – Solution en dim3 , uh.max = 0.999794, uh.min = −0.999178

5
 nombres de noeuds erreur en norme L2 ordre de convergence
121 0.300768e − 01 /
441 0.769230e − 02 1.9671
1681 0.193424e − 02 1.9916
6561 0.484264e − 03 1.9979

Table 1 – Tableau récapitulatif, Vh=Vh(Th,P1)

On remarque que la valeur de l’erreur décroit dès qu’on raffine le maillage,

ce qui nous garantie la stabilité et la convergence de la méthode. De plus
l’ordre de convergence est égal à 2, ce qui prouve que les résultats numé-
riques sont perfermants.

6
3.2 Exemple 2

Ω = [0, 1]2 − [1/2, 1]2 , f = 1

// adaptation du maillage, domaine L-Shape

// equation de Poisson en 2D, -delta(u)=f dans (0,1)^2-]1/2,1[^2
// condition au bord u=g1 sur gamma
// f=1, g1=-1./4.*(x^2+y^2), g2=0
// solution exacte ue=-1./4.*(x^2+y^2) ;
verbosity=0. ;
border ba(t=0,1.0){x=t ; y=0 ; label=1 ;} ;
border bb(t=0,0.5){x=1 ; y=t ; label=2 ;} ;
border bc(t=0,0.5){x=1-t ; y=0.5 ;label=3 ;} ;
border bd(t=0.5,1){x=0.5 ; y=t ; label=4 ;} ;
border be(t=0.5,1){x=1-t ; y=1 ; label=5 ;} ;
border bf(t=0.0,1){x=0 ; y=1-t ;label=6 ;} ;
int m=5 ;
mesh Th = buildmesh ( ba(3*m)+bb(2*m)+bc(2*m)+bd(2*m)+be(2*m)+
bf(3*m) ) ; // definition du maillage
plot(Th) ;
fespace Vh(Th,P1) ; // ensemble d’éléments finis
Vh uh,vh ; // fonction inconnue et fonction test
func f = 1. ;
func g1= -1./4.*(x^2+y^2) ;
func ue=-1./4.*(x^2+y^2) ;
real error=0.001 ; // niveau de l’erreur
real[int] L2error(3) ; // un tableau àă 3 elements
//problème variationnel

7
problem Poisson(uh,vh,solver=CG,eps=1.0e-6) =
int2d(Th)(dx(uh)*dx(vh) + dy(uh)*dy(vh) )- int2d(Th)(f*vh)
+ on(1,2,3,4,5,6,uh=g1) ;
for (int i=0 ;i< 3 ;i++)
{
Poisson ;
Th=adaptmesh(Th,uh,err=error) ; // adaptation du maillage
uh=uh ; error = error/2. ;
plot(Th,wait=1,cmm="L-Shape") ;
L2error[i]= sqrt(int2d(Th)((uh-ue)^2)) ; // calcul de L2 error
cout.scientific<< " L2error " << i << " = "<< L2error[i] <<endl ;
string legende="L2error="+L2error[i] ;
plot(uh,dim=2,value=1,boundary=1,cmm=legende) ;
// visualisation de la solution
}
plot(uh,dim=3,value=1,boundary=1,cmm="surface uh en D3") ;

8
Figure 5 – L-Shape,nbTriangles=2724, nbNoeuds=1440, hmax=0.0952, hmin=0.0439

Figure 6 – solution dans Z=0, uh.max = 0, uh.min = −0.31250

9
Figure 7 – L-Shape, nbTriangles=10920, nbNoeuds=5621, hmax=2.8525e-02, hmin=1.4854e-02

Figure 8 – solution dans Z=0, uh.max = 0, uh.min = −0.31250

10
 nombres de noeuds erreur en norme L2
1440 2.62050e − 04
2659 5.01579e − 05
5621 2.50832e − 05

Table 2 – Tableau récapitulatif, Vh=Vh(Th,P1)

On remarque que la valeur de l’erreur décroit avec le pas de discréti-

sation, ce qui nous garantie la stabilité et la convergence de la solution
discrète.

11
3.3 Exemple 3

Ω = (x, y) ∈ R2/ x2 + y 2 < 1 , f = 1



// Equation de Poisson
// le domaine est un disque unité
border a(t=0,2*pi){ x = cos(t) ; y = sin(t) ;label=1 ;} ;
mesh Th = buildmesh(a(50)) ; // definition du maillage
plot(Th) ; // visualisation du maillage
fespace Vh(Th,P1) ; // definition de l’ensemble d’elements finis
Vh uh,vh ;
func f = 1 ; // second membre
problem laplace(uh,vh) =int2d(Th)( dx(uh)*dx(vh) +
dy(uh)*dy(vh) ) // forme bilineaire
- int2d(Th)( f*vh ) // forme lineaire
+ on(1,uh=0) ; // condition au bord
func ue = (1-x^2-y^2)/4 ; // ue : solution exacte
laplace ;
Vh error = uh - ue ;
plot (uh,ps="aTutorial.eps",value=true,wait=true) ;
//plot(error,value=true,wait=true) ;
cout.scientific << "error L2=" << sqrt(int2d(Th)( error^2) )<< endl ;
cout.scientific << "error H10=" << sqrt( int2d(Th)((dx(uh)-x/2)^2)
+ int2d(Th)((dy(uh)-y/2)^2))<< endl ;
Th = adaptmesh(Th,uh,err=0.01) ;
plot(Th,wait=1) ;
laplace ;
error = uh - ue ; // erreur de la solution

12
//plot(error,value=true,wait=true) ;
cout.scientific << "error L2=" << sqrt(int2d(Th)( error^2) )<< endl ;
cout.scientific << "error H10=" << sqrt(int2d(Th)((dx(uh)-x/2)^2)
+ int2d(Th)((dy(uh)-y/2)^2))<< endl ;
real legende=sqrt(int2d(Th)((dx(uh)-x/2)^2)+
int2d(Th)((dy(uh)-y/2)^2)) ;
plot (uh,value=true,wait=true, cmm="error L2="
+sqrt(int2d(Th)( error^2))
+" error H10="+legende) ;

13
Figure 9 – maillage, nbTriangles=444, nbNoeuds=248, hmax=0.1965, hmin=0.9693e-01

Figure 10 – solution uh, uh.max = 0.250339, uh.min = 0

14
Figure 11 – maillage, nbTriangles=1552, nbNoeuds=822, hmax=1.0973e-01, hmin=4.8221e-02

Figure 12 – solution uh, uh.max = 0.2498205, uh.min = 0

15
 nombres de noeuds erreur en norme L2 erreur en norme H01
248 4.25000e − 04 3.75440e − 02
822 1.10390e − 04 1.88390e − 02
7222 1.05386e − 05 6.08005e − 03

Table 3 – Tableau récapitulatif, Vh=Vh(Th,P1)

On remarque que la valeur de l’erreur décroit si la taille de la matrice

d’éléments finis croit, ce qui nous garantie la stabilité et la convergence de
la méthode.

16
4 Equation de la chaleur

4.1 Exemple 4


∂u
∂t − µ∆u = f dans Ω × ]0, T [


∂u

µ ∂n + α(u − ue) = 0 sur Γ2 ∪ Γ3

(2)

 u = ue sur Γ1 ∪ Γ4

 u(x, y, 0) = u0 dans Ω
Problème variationnel
Z Z Z Z Z
∂u
vdx + µ ∇u∇vdx + α uvdσ = f vdx + α uevdσ
Ω ∂t Ω Γ2 ∪Γ3 Ω Γ2 ∪Γ3

v ∈ V = v ∈ H 1(Ω)/ v = 0 sur Γ1 ∪ Γ4 , u − ue ∈ V


Schéma implicite

un − un−1
Z Z Z Z Z
vdx+µ ∇un∇vdx+α unvdσ = f vdx+α uevdσ
Ω dt Ω Γ2 ∪Γ3 Ω Γ2 ∪Γ3

v ∈ V = v ∈ H (Ω)/ v = 0 sur Γ1 ∪ Γ4 , un−ue ∈ V, u0 = u0, n = 1, 2, ....

1


On pose

α = 0.001, µ = 1, ue = 4, u0 = 10, f = 20 ∗ 1{0.6≤x≤0.8} ∗ 1{0.4≤y≤0.6}

17
// Equation de la chaleur, omega=[0,1]*[0,1]
// du/dt-mu.delta(u)=f in omega*(0,T), u(x,y,0)=u0 on omega
// mu.du/dn +alpha.(u-ue)=0 on gamma2+gamma3
// u=ue on gamma1+gamma4
// Schema implicite
//verbosity=0. ;
real Dx=.02,Dy=.02 ; //declaration des variables
real t,ue = 4., mu = 1., alpha=.001, dt=0.1, Tf=10 ;
mesh Th=square(floor(1./Dx),floor(1./Dy)) ; //definition du maillage
plot(Th,ps="square.jpg",cmm="maillage") ; // visualisation du maillage
fespace Vh(Th,P1) ; // ensemble d’elements finis
Vh uh,vh,uh0=10. ;
func f=20.*(.6<=x & x<=.8)*(.4<=y & y<=.6) ; // second membre
// resolution du problème variationnel
macro Grad(u)[dx(u),dy(u)]//
problem chaleur(uh,vh) = int2d(Th)(uh*vh/dt + Grad(uh)’*Grad(vh)*mu
- int2d(Th)(uh0*vh/dt + f*vh)+ int1d(Th,2,3)(uh*vh*alpha)
- int1d(Th,2,3)(ue*vh*alpha) +on(1,4,uh=ue) ;
int kk=0 ;
for (real t=0. ;t<Tf ;t+=dt) // boucle du temps t
{
chaleur ;
uh0=uh ;
if ( !(kk % 20)) // kk%20= le reste de la division kk/20
// !(kk%20)=0 si le reste de la division n’est pas nul, =1 si le reste est nul
// !(kk%20)= true or false
{ plot(uh,cmm="t="+t+"[sec]",dim=3,fill=true,value=true,wait=1) ;
plot(uh,cmm="t="+t+"[sec]",dim=2,fill=true,value=true,wait=1) ;}
18
kk+=1 ;
}
//cout<<"uh[]="<<uh[]<<endl ;
cout<<"Taille.uh="<<uh[].n<<endl ; // La taille du tableau
cout<<"Max.uh="<<uh[].max<<" ; Min.uh="<<uh[].min<<endl ; // Max
cout<<"Norme.uh l1="<<uh[].l1<<endl ; // Norme l1
cout<<"Norme.uh l2="<<uh[].l2<<endl ; // Norme l2
cout<<"Norme.uh sup="<<uh[].linfty<<endl ; // Norme sup
cout<<"Somme des termes="<<uh[].sum<<endl ; // Somme
cout<<"uh[](10)="<<uh[](10)<<endl ;

19
Figure 13 – Solution uh, uh.max = 9.20629, uh.min = 4, taille.uh = 2601

Figure 14 – Projection de la solution uh

20
Figure 15 – Solution uh, uh.max = 4.43037, uh.min = 4, taille.uh = 2601

Figure 16 – Projection de la solution uh

21
Figure 17 – Solution uh, max.uh = 4.42837, min.uh = 4, taille.uh = 2601

Figure 18 – la solution uh est formée par des contours

22
4.2 Exemple 5

Ω est un disque avec un trou.


∂u
 − ∆u = f dans Ω × ]0, T [
 ∂t


u = 20 sur C0
(3)

 u = 60 sur C1

 u(x, y, 0) = u0 dans Ω
Schéma implicite.

// Equation de la chaleur, omega=disque avec un trou

// du/dt-delta(u)=f dans omega*(0,T), u(x,y,0)=u0 dans omega
// u=60 sur C1, u=20 sur C0
// Schéma implicite
//verbosity=0. ;
int C1=1, C2=2 ;
border C0(t=0,2*pi){x=5*cos(t) ; y=5*sin(t) ;label=C2 ;}
border C11(t=0,1){ x=-1+2*t ; y=3 ; label=C1 ;}
border C12(t=0,1){ x=1 ; y=3-6*t ; label=C1 ;}
border C13(t=0,1){ x=1-2*t ; y=-3 ; label=C1 ;}
border C14(t=0,1){ x=-1 ; y=-3+6*t ; label=C1 ;}
//plot(C0(50)+ C11(5)+C12(20)+C13(5)+C14(20)) ;
mesh Th=buildmesh(C0(50)+ C11(5)+C12(20)+C13(5)+C14(20)) ;
plot(Th,ps="circle.jpg",cmm="maillage") ; // visualisation du maillage
fespace Vh(Th,P1) ;
Vh uh,vh,uh0=10. ;
real dt=0.1, Tf=10 ;
func f=20.*(.6<=x & x<=.8)*(.4<=y & y<=.6) ;
macro Grad(u)[dx(u),dy(u)]//

23
problem chaleur(uh,vh) = int2d(Th)(uh*vh/dt + Grad(uh)’*Grad(vh))
- int2d(Th)(uh0*vh/dt + f*vh) +on(C1,uh=60)+on(C2,uh=20) ;

int kk=0 ;
for (real t=0. ;t<Tf ;t+=dt)
{
chaleur ;
uh0=uh ;
if ( !(kk % 20)) // kk%20= le reste de la division kk/20
// !(kk%20)=0 si le reste de la division n’est pas nul, =1 si le reste est nul
// !(kk%20)= true or false
{
plot(uh,cmm="t="+t+"[sec]",dim=3,fill=true,value=true,wait=1) ;
plot(uh,cmm="t="+t+"[sec]",dim=2,fill=true,value=true,wait=1) ;
}
kk+=1 ;
}
cout<<"uh[]="<<uh[]<<endl ;
cout<<"Taille.uh="<<uh[].n<<endl ; // La taille du tableau
cout<<"Max.uh="<<uh[].max<<" ; Min.uh="<<uh[].min<<endl ; // Max
cout<<"Norme.uh l1="<<uh[].l1<<endl ; // Norme l1
cout<<"Norme.uh l2="<<uh[].l2<<endl ; // Norme l2
cout<<"Norme.uh sup="<<uh[].linfty<<endl ; // Norme sup
cout<<"Somme des termes="<<uh[].sum<<endl ; // Somme
cout<<"uh[](10)="<<uh[](10)<<endl ;

24
Figure 19 – Maillage, nbTriangles=660, nbNoeuds=380, h.max=0.92531 ,h.min=0.298787

Figure 20 – Solution uh, uh.max = 60, uh.min = 10.0332, taille.uh = 380

25
Figure 21 – Solution uh, uh.max = 60, uh.min = 20, taille.uh = 380

Figure 22 – Projection de la solution uh

26
Figure 23 – Solution uh, uh.max = 60, uh.min = 20, taille.uh = 380

Figure 24 – Projection de la solution uh

27
5 Equation des ondes

5.1 Exemple 6


∂ 2u


 ∂t2
− c2∆u = f dans Ω × ]0, T [
u = 0 sur Γ

(4)

 u(x, y, 0) = u0 dans Ω
 ∂u
∂t (x, y, 0) = 0 dans Ω

Problème variationnel
Z 2 Z Z
∂ u
2
vdx + c2 ∇u∇vdx = f vdx, ∀v ∈ H01(Ω), u ∈ H01(Ω)
Ω ∂t Ω Ω
θ-Schéma (θ = 1/2), Schéma implicite
Z n+1
− 2un + un−1
Z Z
u 2 1 n+1 n−1
2
vdx + c ∇(u + u )∇vdx = f vdx,
Ω dt 2 Ω Ω
1 0
∀v ∈ H0 (Ω), u = u0, n = 1, 2, ......

// equation des ondes, d^2(u)/dt^2 -c^2(delta(u))=0 dans omega*]0,T[

// u(x,y,0)=sin(pi*x)*sin(pi*y), du/dt(x,y,0)=0, u(x,y,t)=0 sur gamma
// θ-Schema, θ = 1/2
verbosity=0 ;
load "medit"
load "msh3"
real Dx=.02,Dy=.02 ;
mesh Th=square(floor(1./Dx),floor(1./Dy)) ;
plot(Th) ;
fespace Vh(Th,P1) ;
func g=0. ;
28
real c=1.,dt=.1,Tf=10. ;
Vh uh,vh,uh0=sin(pi*x)*sin(pi*y),uh1=uh0+dt*g ;
macro Grad(u)[dx(u),dy(u)]//
problem tambour(uh,vh) = int2d(Th)(uh*vh +
Grad(uh)’*Grad(vh)*(c*dt)^2*.5 )
+ int2d(Th)(Grad(uh0)’*Grad(vh)*(c*dt)^2*.5 )
- int2d(Th)(2.*uh1*vh - uh0*vh)
+ on(1,2,3,4,uh=0) ;
int kk=0 ;//, k=0 ;
for (real t=0. ;t<Tf ;t+=dt)
{
tambour ;
uh0 = uh1 ;
uh1 = uh ;
if ( !(kk %20)) // plot chaque 20 iteration
{
plot(uh,cmm="t="+t+"[sec]",fill=true,value=true,wait=1,dim=3,bounda
plot(uh,cmm="t="+t+"[sec]",fill=true,value=true,wait=1,dim=2,bounda
// pour visualiser la solution avec Medit
mesh3 TK=movemesh23(Th,transfo=[x,y,uh/2.]) ;
//movemesh23 : A simple method to construct a surface is to place a two di-
mensional
// domain in a three dimensional space. This corresponding to move the do-
main by a
// displacement vector of this form phi(x, y) = (phi1(x, y), phi2(x, y), phi3(x, y)).
medit("Solution",TK) ;
// savemesh(TK,"Ondes2D."+(100000+kk)+".mesh") ;
savemesh(TK,"Solution.mesh") ;
exec("ffmedit Ondes2D."+(100000+kk)+"") ;
29
//k++ ;
//exec("ffmedit Ondes2D."+(100000+k)+"") ;
//kk++ ;
}
kk++ ;

30
Figure 25 – Solution uh, max.uh = 0.82017, min.uh = 0.00, taille.uh = 2601

Figure 26 – Projection de uh

31
Figure 27 – Solution uh , max.uh = 0.00, min.uh = −0.99444, taille.uh = 2601

Figure 28 – Projection de uh

32
Figure 29 – Solution uh , max.uh = 0.83775, min.uh = 0.00, taille.uh = 2601

Figure 30 – Projection de uh

33
6 Problème non linéaire


−∆u + uq(u) = f dans Ω
(5)
u = g sur Γ
où f est une fonction dans L2(Ω) et g|Γ ∈ L2(Γ), q : R −→ R, q ∈
C 0(R) nondécroissante avec q(0) = 0
Problème variationnel non linéaire
Z Z Z
∇u∇vdx + uq(u)vdx = f vdx ∀v ∈ H01(Ω), u − g ∈ H01(Ω),
Ω Ω Ω

q(u) ∈ L1(Ω) ∩ H −1(Ω)

Problème variationnel linéaire
Z Z Z
∇un+1∇vdx + un+1q(un)vdx = f vdx ∀v ∈ H01(Ω),
Ω Ω Ω

un+1 − g ∈ H01(Ω), u0 donnée , n = 0, 1, .....

Théorème de convergence
lim ku − unhkL2(Ω) = 0
h→0,n→∞

Théorème d’estimation d’erreur

Il existe une constante c indépendente de n et h telle que
ku − unhkL2(Ω) ≤ ch1+k , k = 1, 2
Exemple 1
2 2
 2 2 2
2 2


Ω = x + y < R , f = 4 + R − x − y , g = 0, q(u) = u
Solution exacte : ue = R2 − x2 − y 2

34
//problème nonlinéaire
//-delta(u)+u.q(u)=f(x,y) dans omega
//u=g sur gamma
//verbosity=0. ;
real Dx=.02, R=1. ;
border C(t=0.,2.*pi){x=R*cos(t) ;y=R*sin(t) ;label=1 ;} ;
real[int] L2error(4) ;
for(int n=0 ;n<4 ;n++) {
mesh Th=buildmesh(C(30*2^n)) ;
//mesh Th=buildmesh(C(floor(2.*pi*R/Dx))) ;
fespace Vh(Th,P1) ;
Vh uh, uh0=0., V=uh0, vh ;
func ue = R^2 - x^2 - y^2 ;
func f = 4. + (R^2 - x^2 - y^2)^2 ;//sin(pi*x)*sin(pi*y) ;
macro Grad(u)[dx(u),dy(u)]//
real N=2000. ;
problem nonlinear(uh,vh) = int2d(Th)(Grad(uh)’*Grad(vh))
+ int2d(Th) ( uh*V*vh ) - int2d(Th) (f*vh ) + on(1,uh=0.) ;
for (int i=0 ;i<=100 ;i++) {
nonlinear ;
V=uh ;
if (i%10==0)
plot(uh,cmm="iter="+i+" ; min="+uh[].min+
" ; max="+uh[].max, fill=true,value=true,dim=3,
wait=1,boundary=false) ;
}
L2error[n]= sqrt(int2d(Th)((uh-ue)^2)) ;
}
35
for(int n=0 ;n<4 ;n++) {
cout << " L2error " << n << " = "<< L2error[n] <<endl ;
}
for (int n=0 ;n<3 ;n++){
cout <<" convergence rate = "<< log(L2error[n]/L2error[n+1])/log(2.) <<en
}

36
Figure 31 – maillage, nb.T riangles = 2270, nb.N oeuds = 1206, h.max = 0.45246, h.min =
0.14561

Figure 32 – Solution uh , max.uh = 0.9999, min.uh = 0.00, taille.uh = 5124

37
Figure 33 – Projection de la solution dans le plan Z=0

Figure 34 – Solution uh en dim3

38
 Nombres de noeuds Erreur en norme L2 Ordre de convergence
97 0.205855e − 01 /
353 0.507805e − 02 2.01929
1340 0.128046e − 02 1.98761
5124 0.321059e − 03 1.99575

Table 4 – Tableau récapitulatif, Vh=Vh(Th,P1)

On remarque que la valeur de l’erreur décroit dès qu’on raffine le maillage,

ce qui nous garantie la stabilité et la convergence de la méthode. De plus
l’ordre de convergence est égal à 2, ce qui prouve que les résultats numé-
riques sont perfermants.

39
Références

[1] http ://www.freefem.org/ff++/ doc.pdf

[2] M.Kallel, LAMSIN, Introduction à FreeFem++ (1ere partie) 2008,
www.lamsin.rnu.tn.
[3] M.Kallel, LAMSIN, Introduction à FreeFem++ (2eme partie) 2008,
www.lamsin.rnu.tn.
[4] O. Pantz, An Introduction to FreeFem++, UPMC, September 2010.

40

View publication stats