Compte Rendu TP1 Problème de La Plaque 2D

GOSSELIN Aurélie
LAFFITTE Élodie
Compte rendu de TP 1
Grands Systèmes Matriciels
Marine 2A
Option Modélisation
12/04/2013
Sommaire
Introduction ........................................................................................................................................... 3
I) Méthode du gradient conjugué ...................................................................................................... 3
A) Rappels théoriques ..................................................................................................................... 3

B) Grandes étapes du code, difficultés rencontrées ....................................................................... 4
C) Analyse et validation .................................................................................................................. 6
II) Résolution d’une EDO par différences finies en 1D ........................................................................... 8
A) Enoncé et rappels théoriques sur les différences finies ............................................................. 8

B) Résolution numérique et validation ......................................................................................... 10
C) Erreur selon le pas .................................................................................................................... 13
III) Problème de la plaque 2D ............................................................................................................... 14
A) Rappels théoriques ................................................................................................................... 14

B) Résolution numérique et validation ......................................................................................... 17
Conclusion : .......................................................................................................................................... 19
Annexe ................................................................................................................................................. 20
2
Introduction
Lorsque l’on a un problème à résoudre, on le met en équation : c’est la première

étape, la modélisation. Ensuite, on étudie le problème continu : on vérifie l’existence d’une
solution, son unicité éventuelle, sa régularité, les conditions aux limites…. On peut alors
s’attaquer à la résolution à proprement parler, et donc à la discrétisation du problème. On
transforme l’équation continue en un système linéaire décrivant le comportement d’un
nombre fini de points. On peut choisir différents modes de discrétisation : le maillage carré
des différences finies, ou une approche plus générale par les éléments finis… IL y aura
convergence de notre solution approchée vers la solution exacte du problème continu
quand le pas de discrétisation, noté h, tendra vers zéro. Pour la résolution du système, selon
les différentes natures du système (matrice creuse ou pleine notamment), on utilisera des
méthodes directes (Gauss par factorisation LU par exemple) ou, comme ce sera le cas dans
ce TP, des méthodes itératives : Jacobi, Gauss-Seidel, ou celle qui va nous intéresser en
particulier : la méthode du gradient conjugué. Une fois la programmation mise en place, il
restera à analyser les résultats pour valider ou non la méthode choisie.
I) Méthode du gradient conjugué
A) Rappels théoriques
La méthode du gradient conjugué est une méthode itérative : on construit une suite xn pour
approcher la solution x d’une équation simple. Plus précisément, pour résoudre un système
Ax=b de taille n, où A est symétrique définie positive (toutes les valeurs propres de A sont
positives), la méthode du gradient conjugué aura un coût de calcul approximativement égal
à θ(n2) et se déroulera selon les étapes suivantes :
D’après le cours, on sait qu’il y a équivalence entre
( )
On va donc essayer de résoudre ② en supposant connue une base d 0,d1… , dn-1 orthogonale
pour le produit scalaire <x,y> = <Ax,y>.
On se donne et on va minimiser : ( ∑ )
( ∑ ) ∑ ∑ ∑
Et on développe, sachant que le produit scalaire est symétrique :
3
∑ ∑
( ) ∑ ∑
Puis on applique l’identité remarquable :
( ) ∑( )
Pour minimiser, il faut que tous les termes dans la somme carrée soient nuls :
Donc
Et le minimum vaut alors initialement :
∑ ∑ ( )
De manière analogue, on peut chercher le minimum à partir de x k dans la direction dk. Cela
revient à minimiser J(xk+αk dk). On trouve :
On va choisir de façon à ce que dk+1 et dk soient orthogonaux, donc
B) Grandes étapes du code, difficultés rencontrées
4
- Construction du système Ax=b et première itération:
Pour construire une matrice A symétrique définie positive, on choisit une matrice B
quelconque, et on pose . Ensuite on choisit une solution exacte et on détermine
le second membre :
On a donc les deux composantes de notre système. On choisit un .
Ainsi, le résidu initial est : et la direction initiale est :
Alors
- Algorithme :
On choisit de travailler sur le deuxième algorithme du cours. Alors, le résidu de l’étape k est
Et la direction de l’étape k est :
Et on calcule :
On définit ensuite pour l’itération suivante :
La direction : où
Et on recommence…
- Difficultés et remarques :
Il a fallu construire des subroutines pour alléger le programme principal en calcul : une pour
calculer le produit matrice*vecteur, une pour le produit scalaire entre 2 vecteurs, une pour
l’addition de 2 vecteurs, une pour le produit vecteur*scalaire, et une pour calculer la norme
‖ ‖ √
Pour arrêter le calcul, on a d’abord choisi de pratiquer sur une boucle simple de 10
itérations. Ensuite, on a défini un test d’arrêt sur la norme du résidu : on poursuit tant que
‖ ‖
Le coût principal de cette méthode est approximativement égal à θ(n2) , mais il dépend de
.
5
En effet, sa convergence dépend du conditionnement de la matrice A :
| |
( ) ‖ ‖‖ ‖
| |
Et donc par rapport à notre variable d’arrêt :
√ ( )
‖ ‖ ( )
√ ( )
Alors si ( ) la convergence est rapide, si ( ) , la convergence est lente.
Il est donc possible de faire un pré conditionnement pour converger plus rapidement, au lieu
de résoudre Ax=b, on résoudrait :
Cependant, au vu de nos résultats déjà rapides, nous n’avons pas estimé cette étape
nécessaire.
C) Analyse et validation
Nous avons choisi de valider notre programme en regardant la résolution d’une équation
Ax=b où A est de taille 4, programme dans lequel nous avons fixé l’erreur à 10 -6. La matrice
était la suivante :
1 2 2 5
4 5 1 2
3 2 1 1
1 2 3 4
Alors que nous attendions une solution exacte telle que :
1
2
3
4
Nous avons obtenue exactement celle que nous attendions ! Ce qui nous a confirmé que le
déroulement était cohérent. Cependant, nous avons testé notre programmation sur une
matrice relativement « simple », nous en sommes donc venues à regarder la résolution de
l’équation (on garde la même solution exacte) dont la matrice A est la suivante :
DO i=1,n
DO j=1,n
B(i,j)=i+j+3.d0*dcos(i*1.d0)
6
ENDDO
ENDDO
Nous avons fixé le pas n valant 4 puis 10 (nous n’avons pas pris de pas plus grand car la
précision pour n=4 était déjà amplement suffisante comme on peut le voir juste en dessous).
Grâce à la routine Matlab placée en annexe, nous avons obtenu les graphiques suivants :
 n=4 :
superposition des solutions exacte et approchée n=4

5
4
solution
3 Xex
Xapp
2
1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
-11
x 10 différence entre les deux solutions
-2
-4
-6
-8
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
 n=10 :
7
15
10
solution
5 Xex
Xapp
0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
-12
x 10 différence entre les deux solutions
0
-0.5
-1
-1.5
-2
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Analyse :
Nous avons représenté sur chacune de ces deux fenêtres graphiques la superposition de la
solution exacte avec la solution approchée calculée grâce à notre programme sous Fortran,
puis tracé une la différence entre ces deux solutions.
Nous voyons d’abord sur le premier graphique que les solutions sont très proches, ce qui est
confirmé par le second graphique par une différence de l’ordre de 10 -11.
Augmenter n n’apporte pas beaucoup, la différence est divisée par 10, mais elle nous
convenait déjà amplement, il n’est donc pas nécessaire de consommer du temps de calcul
pour cela.
Nous pouvons donc conclure que notre programmation reste cohérente même sur des
systèmes plus compliqués que le premier testé.
A présent, sachant notre programme capable de résoudre des systèmes et donner une
valeur approchée de la solution, passons à la résolution de cas concrets.
II) Résolution d’une EDO par différences finies en 1D
A) Enoncé et rappels théoriques sur les différences finies
- Enoncé du problème :
8
On doit mettre en œuvre la méthode des Différences Finies sur l’EDO suivante :
( ) ( ) ( ) ( ) ( ) ( )
La solution exacte nous est donnée : ( )
- Méthode des différences finies :
On va approcher les éléments de l’EDO par différences finies à l’ordre 2 :
( ) ( ) ( )
( )
Alors
( ) ( ) ( )
( ) ( ) ( )
( ) ( )( ) ( )
Or on applique la notation () donc
( )
On applique alors les conditions de Dirichlet :
( )
( )
( )
( )
Les termes en rouge sont ceux, constants, que l’on rebasculera dans le second terme.
On doit donc résoudre le système :
( )
( )
( )
Mis sous forme matricielle, on obtient : où
9
Et
Avec cette nouvelle matrice définie par DF, on applique donc la méthode du gradient
conjugué sur ce système pour approcher la solution.
B) Résolution numérique et validation
Pour ce qui est du code, on a juste changé les éléments du système : second membre et
matrice A.
On dispose de la solution exacte, la fonction exponentielle : on peut donc comparer

l’efficacité de notre résolution numérique.
Après modification du programme et résolution numérique, voici ce que l’on observe si l’on
trace les solutions exactes et approchées pour n=20 et 600 :
10
3
2.5
solution
2
Xex
1.5
Xapp
1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

3
2.5
solution
1.5
1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Analyse :
Dans le cas où n=600 nous ne sommes pas en mesure sur ce graphique de distinguer la
solution exacte de la solution approchée. En revanche, si l’on effectue un zoom, on voit bien
que ces deux solutions se superposent très bien ! Cela se confirme lorsque l’on regarde le
fichier : Xexacte = Xapprochée ! On voit néanmoins que le cas n=20 donne déjà des résultats
très satisfaisants.
Nous nous sommes alors demandées s’il était nécessaire de prendre une discrétisation si
grande étant donné que les résultats obtenus pour n=20 sont déjà bien précis. Outre le gain
de calcul que l’on gagne en prenant un n plus petit, nous avons observé le temps que cela
prenait grâce à la routine « cpu_time ». Dans le cas n=20, la routine renvoie « 0 » alors que
dans le cas n=600, elle renvoie « 2.43298883 » secondes. Compte tenu du nombre
d’itérations effectuées et de la précision obtenue, ce temps est faible !
Remarque :
Dans la méthode du gradient conjugué codée la première fois, on considérait une matrice A
pleine. Or ici, elle est creuse, tridiagonale pour être précises. On pourrait donc s’éviter
beaucoup de calculs inutiles (multiplications par zéro) et ainsi gagner un précieux temps.
Pour cela, au lieu de considérer la matrice A dans son ensemble, on va la décomposer en
seulement 3 vecteurs :
11
( )
( )
( )
( )
( )
Si on pose le vecteur « solution approchée » à déterminer
Alors on obtient les équations :
Après modification du programme et résolution numérique, voici ce que l’on observe si l’on
trace les solutions exactes et approchées pour n=10 et 600 :

2.5
2
solution
Xex
1.5 Xapp
1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

3
2.5
solution
1.5
1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
12
Analyse :
Ces graphiques sont comparables aux graphiques précédents et montrent à nouveau la

précision de la solution approchée calculée cette fois-ci de manière optimale car adaptée à
la matrice A considérée.
Nous avons vu précédemment que le temps de calcul pour n=600 avec le programme non
modifié était de 2.43298883 secondes. A présent, en tenant compte du fait que la matrice
est creuse dans le programme, ce temps de calcul est réduit à 0.0459999 secondes ! Le gain
de temps constaté est d’environ 98.2%.
C) Erreur selon le pas
On s’attend à une erreur selon h2. Pour le vérifier, traçons la courbe log(erreur) selon log(h)
(h=0.4, 0.2, 0.1), où erreur correspond à la moyenne de l’erreur sur toute la grille. Plus
exactement :
La méthode étant d’ordre 2, on est censées observer une pente d’au moins 2.
Voici ce que l’on observe :
-3
evolution de l'erreur en fonction du pas
10
log erreur
-4
10 element1
element2
element3
-5
element4
10 element5
-1
10 log h
Evolution du rapport log(erreur)/log(h)

2.1
rapport log(erreur)/log(h)
2.05
1.95
1.9
1 1.5 2 2.5 3 3.5 4 4.5 5
element du vecteur erreur
Analyse :
13
Nous sommes censées observer des droites de pente 2. En effet :
( ) ( )
Donc en faisant le rapport :
( )
On remarque que l’on obtient en effet des droites de pente positives, mais aussi et surtout
que pour tous les éléments du vecteur erreur, la pente est très proche de la valeur prévue
théoriquement : à 0.05 près ! Notre méthode présente donc bien une erreur de l’ordre de
h2.
Voyons à présent une résolution avec la méthode du gradient conjugué en 2 dimensions

avec le problème de la plaque plane.
III) Problème de la plaque 2D
A) Rappels théoriques
On va utiliser la méthode des différences finies pour résoudre l’équation de Poisson en 2D

(sur une plaque carrée) :
( )
Remarque :
La méthode multigrille est aussi itérative mais elle est plus difficile à appliquer et coûte en
calculs θ(N logN)
14
- Définition du maillage, DF et numérotation:
On pose N le nombre de points selon l’horizontale, M le nombre de points selon la verticale

et N=M=3. De même, soient h le pas selon l’horizontale, k le pas selon la verticale alors
L’équation est ( ) ( ) ( ) et on va approcher ces termes par

différences finies.
( ) ( ) ( )
( ) ( )
( ) ( ) ( )
( ) ( )
Alors en sommant les deux :
( ) ( ) ( ) ( ) ( )
( )
( ) ( ( ) ( )) ( ) ( ( ) ( ))
On cherche la solution aux points ( ) on a donc :
[ ]
Il y a N2=9 points intérieurs et 16 points du bord.
Numérotation :
On a posé ( ) ( ) ( ) on peut maintenant réécrire ① pour

chaque point intérieur :
Au point (1,1) :
Au point (1,2) :
Au point (1,3) :
15
Au point (2,1) :
Au point (2,2) :
Au point (2,3) :
Au point (3,1) :
Au point (3,2) :
Au point (3,3) :
On aboutit donc au système matriciel suivant :
16
On résout ce système par la méthode du gradient conjugué.
La solution exacte nous est donnée dans le cours :
(( ) ) (( ) )
( ) ∑
( ) (( ) )
B) Résolution numérique et validation
Après avoir adapté notre problème à une notation qui permettait de résoudre celui-ci avec
la méthode du gradient conjugué programmée précédemment, nous avons obtenu les
graphiques suivantes :
 Cas n=3 :
champs de température sur la plaque
80
60
40
20
solution approchée n=3

60
40
solution
20
0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
 Cas n=10 :
17
80
60
40
20

100
solution
50
0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
 Cas n=30 :
80
60
40
20

100
solution
50
0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
18
Analyse :
Nous avons la solution théorique, mais nous n’avons pas réussi à la coder, nous ne pouvons
donc pas vérifier nos résultats. Cependant, ils nous semblent assez corrects, ils
correspondent avec la réalité physique. Dans tous les cas on remarque que la chaleur se
dissipe au fur et à mesure que l’on descend dans la plaque. Les zones les plus chaudes sont
linéaires, très proches du bord de la plaque, alors qu’ensuite la chaleur se dissipe en arc de
cercle, elle se répand plus à l’intérieur de la plaque que sur les bords droite et gauche.
En augmentant le pas, on constate une distribution plus fine, plus lissée : les courbes
isothermes sont moins anguleuses et donc plus naturelles. Pour la solution elle-même, on
observe une évolution en pics, ce qui paraît normal. En effet, en se déplaçant vers la droite
sur l’axe des abscisses, on « monte » sur la plaque vers le haut, donc on se rapproche de la
zone la plus chaude : la température augmente. Une fois au plus haut, on change de colonne
donc on redescend à l’extrémité opposée (la plus froide) de la plaque : T chute brutalement.
Puis on remonte le long de j, la température ré-augmente… et ainsi de suite. L’évolution de
la valeur des pics se fait en arc de cercle : les pics les plus à droite et à gauche ont des valeurs
plus faibles, en effet, on voit sur les schémas que la chaleur s’est beaucoup moins répandue
sur les extrémités droite et gauche du côté haut. On observe de plus qu’en augmentant le
nombre n (le nombre de points intérieurs), on rapproche les pics et on intensifie l’évolution
en arc de cercle des valeurs maximales. En effet, si on augmente n, on augmente autant le
nombre de lignes que de colonnes, donc on fera beaucoup plus de « montées-descentes »
sur des intervalles toujours de même longueur totale.
Une petite remarque sur la composition de la grille : comme valeurs des points du bord (que
nous n’avions pas fixées au début), nous avons choisi 0 pour les deux points du bas, 100 pour
les deux points du haut, pour rester en accord avec le problème général.
Conclusion :
Dans ce TP, nous avons implémenté la méthode de résolution du gradient conjugué et nous
l’avons appliqué à des problèmes de différentes natures : équations aux dérivées partielles,
puis phénomène physique en 2D… .Dans le premier cas, la méthode fonctionne très bien et
nous permet d’approcher de très près et en très peu de temps la solution exacte. Pour le
second cas, là encore le modèle colle de près à la réalité physique. Parmi les différents
modèles de résolution numérique, le gradient conjugué nous donne donc satisfaction.
Cependant, elle n’est pas la seule à s’appliquer aux problèmes que nous avons traités : nous
pourrions envisager des méthodes spectrales et approcher la solution exacte avec un seul
polynôme, de grands degré, ou encore une méthode intégrale de frontière.
19
Annexe
- Programme FORTRAN avec subroutines pour la question 1 de l’énoncé
C=======================================================================
C TP 1 : ALGORITHME GRADIENT CONJUGUE GENERAL
C=======================================================================
PROGRAM TP1
C Declaration des variables

implicit double precision (a-h,o-z)
DIMENSION A(100,100),Xexact(100),B(100,100),transpB(100,100)
DIMENSION Xo(100),R(100),F(100), Xapp(100),C(100)
DIMENSION temp_r(100), Y(100), vec1(100),vec(100)
C D2finition de la taille de la matrice initiale

n=4
C call cpu_time(t1)
C Creation de la matrice B
C B(1,1)=1.d0
C B(1,2)=2.d0
C B(1,3)=2.d0
C B(1,4)=5.d0
C B(2,1)=4.d0
C B(2,2)=5.d0
C B(2,3)=1.d0
C B(2,4)=2.d0
C B(3,1)=3.d0
C B(3,2)=2.d0
C B(3,3)=1.d0
C B(3,4)=1.d0
C B(4,1)=1.d0
C B(4,3)=2.d0
C B(4,3)=3.d0
C B(4,4)=4.d0
DO i=1,n
DO j=1,n
B(i,j)=i+j+3.d0*dcos(i*1.d0)
ENDDO
ENDDO
C Calcul de la transpos‚e de B
CALL transpose(B,transpB,n)
20
C Calcul de la matrice sym‚trique d‚finie positive A
CALL sym_mat(A,B,transpB,n)
C Affichage des matrices

C CALL affich_mat(B,n)
C CALL affich_mat(transpB,n)
CALL affich_mat(A,n)
C D‚termination du second membre b … partir de la solution finale voulue

C Xexact(1)=8.d0
C Xexact(2)=8.d0
C Xexact(3)=8.d0
C Xexact(4)=8.d0
DO i=1,n
Xexact(i)=i
ENDDO
C CALL affich_vec(Xexact,n)
CALL prod_matvec (A,Xexact,C,n)

C CALL affich_vec(C,n)
C Initialisation des variables de l'algorithme

DO i=1,n
Xo(i)=1.0d0
ENDDO
C CALL affich_vec(Xo,n)
DO i=1,n
Xapp(i)=Xo(i)
ENDDO
C CALL affich_vec(Xapp,n)
C Calcul de R0 et de D0
CALL prod_matvec (A,Xo,Y,n)
C CALL affich_vec(Y,n)
CALL diff_vecvec (C,Y,n,R)
C CALL affich_vec(R,n)
DO i=1,n
F(i)=R(i)
ENDDO
C CALL affich_vec(F,n)
C Algorithme
C Initialisation pour la boucle d'arret

erreur= 0.00000001d0
res3=10000.d0
21
DOWHILE (sqrt(res3).GT. erreur)
DO i=1,n
temp_r(i)=R(i)
ENDDO
C CALL affich_vec(temp_r,n)
C Calcul de Xk+1
CALL prod_vecvec (temp_r,temp_r,n,res1)
C print*,res1
CALL prod_matvec (A,F,vec,n)
C CALL affich_vec(vec,n)
CALL prod_vecvec (vec,F,n,res2)
C print*,res2
DO i=1,n
Xapp(i)=Xapp(i)+(res1/res2)* F(i)
ENDDO
C Calcul de Rk
CALL prod_matvec (A,Xapp,vec1,n)
C CALL affich_vec(vec1,n)
CALL diff_vecvec (C,vec1,n,R)
C CAlcul de Dk+1
CALL prod_vecvec (R,R,n,res3)
C print*,res3
C print*,res4
D=res3/res4
C print*,D
DO i=1,n
F(i)=R(i)+D*F(i)
ENDDO
ENDDO
C Affichage de la solution approch‚e

CALL affich_vec(Xapp,n)
C Stockage dans le fichier

C CALL ecrire(n,Xexact,Xapp)
22
C call cpu_time(t2)
C print*,'temps calcul'
C print*,t2-t1
END PROGRAM
C=======================================================================
SUBROUTINE affich_mat(A,n)

DIMENSION A(100,100)
C Affichage des matrices :

write(*,*) 'Matrice :'
DO i=1,n
write(*,*)(A(i,j),j=1,n)
ENDDO
return
end
C=======================================================================
SUBROUTINE affich_vec(X,n)

DIMENSION X(100)
C Affichage du vecteur :
write(*,*) 'Vecteur :'
DO i=1,n
write(*,*)X(i)
ENDDO
return
end
C=======================================================================
SUBROUTINE transpose(B,transpB,n)

DIMENSION B(100,100), transpB(100,100)
C calcul de la transpos‚e
23
DO i=1,n
DO j=1,n
transpB(i,j)=B(j,i)
ENDDO
ENDDO
end
C=======================================================================
SUBROUTINE sym_mat(A,B,transpB,n)

DIMENSION B(100,100), transpB(100,100) , A(100,100)
C Calcul de la matrice sym‚trique d‚finie positive A

DO i=1,n
DO j=1,n
A(i,j)=B(i,j)*transpB(i,j)
ENDDO
ENDDO
END
C=======================================================================
SUBROUTINE prod_matvec (A,X,Y,n)

DIMENSION A(100,100), X(100),Y(100)
C Calcul du produit entre la matrice A et le vecteur X

DO i=1,n
Y(i)=0
DO j=1,n
Y(i)=Y(i)+ A(i,j)*X(j)
ENDDO
ENDDO
end
C=======================================================================
SUBROUTINE prod_vecvec (X,Y,n,res)

DIMENSION X(100),Y(100)
24
C Calcul du produit des deux vecteurs X et Y
res=0
DO i=1,n
res=res+X(i)*Y(i)
ENDDO
end
C=======================================================================
SUBROUTINE add_vecvec (X,Y,n,Z)

DIMENSION X(100),Y(100), Z(100)
C Calcul de l'addition de deux vecteurs X et Y

DO i=1,n
Z(i)=X(i)+Y(i)
ENDDO
end
C=======================================================================
SUBROUTINE diff_vecvec (X,Y,n,Z)

DIMENSION X(100),Y(100), Z(100)
C Calcul de l'addition de deux vecteurs X et Y

DO i=1,n
Z(i)=X(i)-Y(i)
ENDDO
end
C=======================================================================
SUBROUTINE prod_vecscal (X,scal,n,Y)

C Calcul du produit d'un vecteur par un scalaire

DO i=1,n
Y(i)=scal*X(i)
ENDDO
25
end
C=======================================================================
SUBROUTINE ecrire(n,X,Y)
C D‚claration des variables

C Cr‚ation et ouverture d'un fichier stockage.dat

OPEN (UNIT=50,FILE='stockage.dat', STATUS='new')
C Ecriture du fichier
WRITE(50,10)
10 FORMAT (1X,I3)
DO I=1,n
WRITE(50,20)X(I),Y(I)
ENDDO
20 FORMAT(1X,E18.7,5X,E18.7)
C Fermeture du fichier
CLOSE (UNIT=50)
RETURN
END
- Programme FORTRAN sans subroutine (identiques au programme précédent) pour la

question 2 sur la résolution de l’EDO :
C=======================================================================
C TP 1 : RESOLUTION SANS MODIFICATION
C=======================================================================
PROGRAM TP1a

DIMENSION Xexact(1000),B(1000,1000),transpB(1000,1000)
DIMENSION temp_r(1000),Y(1000),vec1(1000),vec(1000),A(1000,1000)
C D2finition de la taille de la matrice initiale et du pas

n=600
h=1.d0/(n+1)
26
call cpu_time(t1)
C Creation de la matrice B , membre de gauche

DO i=1,n
DO j=1,n
B(i,j)=0.d0
ENDDO
ENDDO
DO i=1,n
B(i,i)=(2*(1+h**2))/(h**2)
B(i,i+1)=-1.d0/(h*h)
B(i+1,i)=-1.d0/(h*h)
ENDDO
C Cr‚ation de la matrice C, membre de droite

DO i=2,n-1
C(i)=exp(i*h)
ENDDO
C(1)=exp(h)+1/(h**2)
C(n)=exp(n*h)+exp(1.d0)/(h**2)

DO i=1,n
Xo(i)=5.0d0
ENDDO
DO i=1,n
Xapp(i)=Xo(i)
ENDDO
CALL prod_matvec (B,Xo,Y,n)
DO i=1,n
F(i)=R(i)
ENDDO
C Algorithme
27
erreur= 0.00000001d0
res3=10000.d0
DO i=1,n
temp_r(i)=R(i)
ENDDO
C Calcul de Xk+1
C print*,res1
CALL prod_matvec (B,F,vec,n)
C print*,res2
DO i=1,n
ENDDO
C Calcul de Rk
CALL prod_matvec (B,Xapp,vec1,n)
C CAlcul de Dk+1
C print*,res3
C print*,res4
D=res3/res4
C print*,D
DO i=1,n
F(i)=R(i)+D*F(i)
ENDDO
ENDDO
28
CALL affich_vec(Xapp,n)
C Cr‚ation de la solution exacte

DO i=1,n
Xexact(i)=exp(i*h)
ENDDO
CALL affich_vec(Xexact,n)

CALL ecrire(n,Xexact,Xapp)
call cpu_time(t2)
print*,'temps calcul'
print*,t2-t1
END PROGRAM
- Programme FORTRAN avec les routines modifiées pour la résolution de l’EDO si l’on
tient compte du fait que la matrice soit creuse :
C=======================================================================
C TP 1 : RESOLUTION AVEC MODIFICATION
C=======================================================================
PROGRAM TP1b

DIMENSION Xexact(1000),u(1000),v(1000),w(1000)
DIMENSION temp_r(1000),Y(1000),vec1(1000),vec(1000)

n=600
h=1.d0/(n+1)
call cpu_time(t1)
DO i=1,n
u(i)=(2*(1+h**2))/(h**2)
v(i)=-1.d0/(h*h)
w(i)= -1.d0/(h*h)
ENDDO
w(1)=0.d0
29
v(n)=0.d0
C CALL affich_vec(u,n)
C CALL affich_vec(v,n)
C CALL affich_vec(w,n)

DO i=2,n-1
C(i)=exp(i*h)
ENDDO
C(1)=exp(h)+1/(h**2)
C(n)=exp(n*h)+exp(1.d0)/(h**2)

DO i=1,n
Xo(i)=5.0d0
ENDDO
DO i=1,n
Xapp(i)=Xo(i)
ENDDO
CALL prod_matDvec (u,v,w,Xo,Y,n)
DO i=1,n
F(i)=R(i)
ENDDO
C Algorithme

erreur= 0.0001d0
res3=10000.d0
DO i=1,n
temp_r(i)=R(i)
ENDDO
30
C Calcul de Xk+1
C print*,res1
CALL prod_matDvec (u,v,w,F,vec,n)
C print*,res2
DO i=1,n
ENDDO
C Calcul de Rk
CALL prod_matDvec (u,v,w,Xapp,vec1,n)
C CAlcul de Dk+1
C print*,res3
C print*,res4
D=res3/res4
C print*,D
DO i=1,n
F(i)=R(i)+D*F(i)
ENDDO
ENDDO

C Cr‚ation de la solution exacte

DO i=1,n
Xexact(i)=exp(i*h)
ENDDO
C CALL affich_vec(Xexact,n)

CALL ecrire(n,Xexact,Xapp)
31
call cpu_time(t2)
print*,t2-t1
END PROGRAM
C=======================================================================
SUBROUTINE prod_matDvec (u,v,w,X,Y,n)

DIMENSION X(1000),Y(1000),u(1000),v(1000),w(1000)
C Calcul du produit entre la matrice A et le vecteur X

DO i=2,n-1
Y(i)=w(i)*X(i-1)+ u(i)*X(i) +v(i)*X(i+1)
ENDDO
Y(1)=u(1)*X(1)+v(1)*X(2)
Y(n)=w(n)*X(n-1)+u(n)*X(n)
end
C=======================================================================
- Programme FORTRAN (sans routine car identiques) pour la résolution en 2D du

problème de la plaque :
C=======================================================================
C TP 1 : RESOLUTION SANS MODIFICATION
C=======================================================================
PROGRAM TP1c

DIMENSION Xexact(1000) ,A(1000,1000)
DIMENSION Xo(1000),R(1000),F(1000), Xapp(1000),C(1000),s(1000)
DIMENSION temp_r(1000),Y(1000),vec1(1000),vec(1000), T(1000)

n=30
m=n*n
h=1.d0/(n+1)
call cpu_time(t1)
32
C Construction de la matrice A, du membre de gauche :
DO i=1,m
DO j=1,m
A(i,j)=0.d0
ENDDO
ENDDO
C CALL affich_mat(A,m)
DO i=1,m
DO j=1,m
A(i,i)=-4.d0
A(i,i+1)=1.d0
A(i+1,i)=1.d0
A(i,i+n)=1.d0
A(i+n,i)=1.d0
IF (mod(i,n).EQ. 0) THEN
A(i,i+1)=0.d0
A(i+1,i)=0.d0
ENDIF
ENDDO
ENDDO
C CALL affich_mat(A,m)

DO i=1,m
C(i)=0.d0
IF (mod(i,n).EQ. 0) THEN
C(i)=-100
ENDIF
ENDDO
C CALL affich_vec(C,m)
C Calcul de la solution exacte

PI=4.d0*datan(1.d0)
DO i=1,m
s(i)=0.d0
T(i)=0.d0
ENDDO
DO k=1,m
T(k)=k
ENDDO
C CALL affich_vec(T,m)
C DO k=1,100
C DO i=1,n
C DO j=1,n
C DO l=1,m
33
C s(k)=s(k)+ (dsin(2.d0*k+1.d0)*(((T-j)/n) +1.d0)*h*PI*
C & dsinh(2.d0*k+1.d0)*(T-n*(i-1.d0))*h*PI)/((2.d0*k+1.d0)
C & *dsinh((2.d0*k+1.d0)*PI))
C Xexact(l)=(400.d0/PI)*s(l)
C ENDDO
C ENDDO
C ENDDO
C ENDDO
C CALL affich_vec(Xexact,m)

DO i=1,m
Xo(i)=5.0d0
ENDDO
DO i=1,m
Xapp(i)=Xo(i)
ENDDO
CALL prod_matvec (A,Xo,Y,m)
CALL diff_vecvec (C,Y,m,R)
DO i=1,m
F(i)=R(i)
ENDDO
C Algorithme

erreur= 0.0000000001d0
res3=10000.d0
DO i=1,m
temp_r(i)=R(i)
ENDDO
C Calcul de Xk+1
CALL prod_vecvec (temp_r,temp_r,m,res1)
C print*,res1
34
CALL prod_matvec (A,F,vec,m)
CALL prod_vecvec (vec,F,m,res2)
C print*,res2
DO i=1,m
ENDDO
C Calcul de Rk
CALL prod_matvec (A,Xapp,vec1,m)
CALL diff_vecvec (C,vec1,m,R)
C CAlcul de Dk+1
CALL prod_vecvec (R,R,m,res3)
C print*,res3
CALL prod_vecvec (temp_r,temp_r,m,res4)
C print*,res4
D=res3/res4
C print*,D
DO i=1,m
F(i)=R(i)+D*F(i)
ENDDO
ENDDO

CALL affich_vec(Xapp,m)
C V‚rification
p=0
DO i=1,m
p=p+Xapp(i)
ENDDO
p=p/m
write(*,*) 'Resultat pour verification :'
print*,p

CALL ecrire(m,Xapp)
35
call cpu_time(t2)
print*,t2-t1
END PROGRAM
- Programme Matlab permettant le traitement des données préalablement obtenues

avec les programmes fortran.
close all
clear all
clc
%% Question 1
n1=4;
n2=10;
h=1/(n1-1);
k=1/(n2-1);
abs1=[0:h:1];
abs2=[0:k:1];
X=load('TP1_mat2.dat');
Xex1=X(:,1);
Xapp_4=[1.0000000000348546 ;2.0000000000320464 ;3.0000000000330878;
4.0000000000689644];
Xex2=zeros(n2,1)
for i=1:n2
Xex2(i)=i;
end
Xapp_10=[1.0000000000013562;2.0000000000015814;3.0000000000019695;4.0000000
000016369;5.0000000000002025;6.0000000000010489;7.0000000000011662;8.000000
0000003748;9.0000000000005080;10.0000000000001287];
diff1=Xex1-Xapp_4;
diff2=Xex2-Xapp_10;
%diff=abs(diff);
figure(1)
subplot(211)
plot (abs1,Xex1,'b+',abs1,Xapp_4,'ro')
title 'superposition des solutions exacte et approchée n=4'
ylabel 'solution'
legend ('Xex','Xapp ')
subplot(212)
plot (abs1,diff1,'k-')
title 'différence entre les deux solutions'
figure (2)
subplot(211)
plot (abs2,Xex2,'b+',abs2,Xapp_10,'ro')
ylabel 'solution'
legend ('Xex ','Xapp')
36
subplot(212)
plot (abs2,diff2,'k-')
title 'différence entre les deux solutions'
%% Question 2
%n1=5;
n2=20;
n3=600;
%h1=1/(n1-1);
h2=1/(n2-1);
h3=1/(n3-1);
n=[0:0.1:1.9];
h=1./(n-1);
%abs1=[0:h1:1];
abs2=[0:h2:1];
abs3=[0:h3:1];
%X=load('TP1a_mat1.dat');
%Xex1=X(:,1);
%Xapp1=X(:,2);
Y=load('TP1a_mat2.dat');
Xex2=Y(:,1);
Xapp2=Y(:,2);
Z=load('TP1a_mat3.dat');
Xex3=Z(:,1);
Xapp3=Z(:,2);
figure(3)
subplot(211)
plot (abs2,Xex2,'r+',abs2,Xapp2,'bo')
ylabel 'solution'
subplot(212)
plot (abs3,Xex3,'+r',abs3,Xapp3,'ob')
ylabel 'solution'
%% Question 2 suite
n1=5;
n2=10;
n3=600;
h1=1/(n1-1);
h2=1/(n2-1);
h3=1/(n3-1);
abs1=[0:h1:1];
abs2=[0:h2:1];
abs3=[0:h3:1];
X=load('TP1b_mat1.dat');
Xex1=X(:,1);
Xapp1=X(:,2);
Y=load('TP1b_mat2.dat');
37
Xex2=Y(:,1);
Xapp2=Y(:,2);
Z=load('TP1b_mat3.dat');
Xex3=Z(:,1);
Xapp3=Z(:,2);
for i=1:n1
diff1(i)=Xex1(i)-Xapp1(i);
end
for i=1:n1
prod1(i)=diff1(i)*diff1(i);
erreur1(i)=sqrt(prod1(i));
end
for i=1:n1
end
for i=1:n1
end
for i=1:n1
end
for i=1:n1
end
erreur1
erreur2
erreur3
E1=[erreur1(1) erreur2(1) erreur3(1)];
h=[h1 h2 h3]
coeff(1)=(log(E1(1))-log(E1(2)))/(log(h1)-log(h2));
coeff
figure(46)
subplot(211)
loglog(h,E1,h,E2,h,E3,h,E4,h,E5)
title 'evolution de l''erreur en fonction du pas'
xlabel ('log h')
ylabel ('log erreur')
legend ('element1','element2','element3','element4','element5')
axis([1*10^-1 3*10^-1 10^-5 10^-3])
subplot(212)
plot(coeff)
title 'Evolution du rapport log(erreur)/log(h)'
xlabel ('element du vecteur erreur')
38
ylabel ('rapport log(erreur)/log(h)')
figure(4)
subplot(211)
plot (abs2,Xex2,'r+',abs2,Xapp2,'bo')
ylabel 'solution'
subplot(212)
plot (abs3,Xex3,'+r',abs3,Xapp3,'ob')
ylabel 'solution'
%% Question 3
n1=3;
n2=10;
n3=30;
h1=1/(n1*n1-1);
h2=1/(n2*n2-1);
h3=1/(n3*n3-1);
abs1=[0:h1:1];
abs2=[0:h2:1];
abs3=[0:h3:1];
% Cas n1
Xapp1=[7.142857142857;18.750;42.8571428571;9.821428;25;52.142857142857;7.14
2857142857;18.750;42.8571428571];
V1=flipud(Xapp1(1:3));
A=zeros(n1+2);
for i=1:n1+2
A(1,i)=100;
end
for i=2:n1+1
A(i,2)=V1(i-1);
A(i,3)=V2(i-1);
A(i,4)=V3(i-1);
end
figure (4)
subplot(211)
contourf(A)
title ('champs de température sur la plaque');
set(gca,'xtick',[],'ytick',[])
colorbar
subplot(212)
plot (abs1,Xapp1,'bo-')
title ('solution approchée n=3');
ylabel 'solution'
%legend ('Xapp ')
% Cas n2
Y=load('TP1c_mat2.dat');
Xapp2=Y(:,1)
V4=flipud(Xapp2(1:n2))
V5=flipud(Xapp2(n2+1:2*n2))
V6=flipud(Xapp2(2*n2+1:3*n2))
39
B=zeros(n2+2);
for i=1:n2+2
B(1,i)=100;
end
for i=2:n2+1
B(i,2)=V4(i-1);
B(i,3)=V5(i-1);
B(i,4)=V6(i-1);
B(i,5)=V7(i-1);
B(i,6)=V8(i-1);
B(i,7)=V9(i-1);
B(i,8)=V10(i-1);
B(i,9)=V11(i-1);
B(i,10)=V12(i-1);
B(i,11)=V13(i-1);
end
B
figure (5)
subplot(211)
contourf(B)
colorbar
subplot(212)
ylabel 'solution'
%legend ('Xapp ')
% Cas n3
Z=load('TP1c_mat3.dat');
Xapp3=Z(:,1);
W1=flipud(Xapp3(1:n3));
W2=flipud(Xapp3(n3+1:2*n3));
W3=flipud(Xapp3(2*n3+1:3*n3));
W11=flipud(Xapp3(10*n3+1:11*n3));
W12=flipud(Xapp3(11*n3+1:12*n3));
W13=flipud(Xapp3(12*n3+1:13*n3));
W14=flipud(Xapp3(13*n3+1:14*n3));
W15=flipud(Xapp3(14*n3+1:15*n3));
W16=flipud(Xapp3(15*n3+1:16*n3));
W17=flipud(Xapp3(16*n3+1:17*n3));
W18=flipud(Xapp3(17*n3+1:18*n3));
W19=flipud(Xapp3(18*n3+1:19*n3));
W20=flipud(Xapp3(19*n3+1:20*n3));
40
W21=flipud(Xapp3(20*n3+1:21*n3));
W22=flipud(Xapp3(21*n3+1:22*n3));
W23=flipud(Xapp3(22*n3+1:23*n3));
W24=flipud(Xapp3(23*n3+1:24*n3));
W25=flipud(Xapp3(24*n3+1:25*n3));
W26=flipud(Xapp3(25*n3+1:26*n3));
W27=flipud(Xapp3(26*n3+1:27*n3));
W28=flipud(Xapp3(27*n3+1:28*n3));
W29=flipud(Xapp3(28*n3+1:29*n3));
W30=flipud(Xapp3(29*n3+1:30*n3));
C=zeros(n3+2);
for i=1:n3+2
C(1,i)=100;
end
for i=2:n3+1
C(i,2)=W1(i-1);
C(i,3)=W2(i-1);
C(i,4)=W3(i-1);
C(i,5)=W4(i-1);
C(i,6)=W5(i-1);
C(i,7)=W6(i-1);
C(i,8)=W7(i-1);
C(i,9)=W8(i-1);
C(i,10)=W9(i-1);
C(i,11)=W10(i-1);
C(i,12)=W11(i-1);
C(i,13)=W12(i-1);
C(i,14)=W13(i-1);
C(i,15)=W14(i-1);
C(i,16)=W15(i-1);
C(i,17)=W16(i-1);
C(i,18)=W17(i-1);
C(i,19)=W18(i-1);
C(i,20)=W19(i-1);
C(i,21)=W20(i-1);
C(i,22)=W21(i-1);
C(i,23)=W22(i-1);
C(i,24)=W23(i-1);
C(i,25)=W24(i-1);
C(i,26)=W25(i-1);
C(i,27)=W26(i-1);
C(i,28)=W27(i-1);
C(i,29)=W28(i-1);
C(i,30)=W29(i-1);
C(i,31)=W30(i-1);
end
C
figure (6)
subplot(211)
contourf(C)
colorbar
subplot(212)
ylabel 'solution'
%legend ('Xapp ')
41

Compte Rendu TP1 Problème de La Plaque 2D

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Compte Rendu TP1 Problème de La Plaque 2D

Загружено:

Авторское право:

Доступные форматы

GOSSELIN Aurélie

Grands Systèmes Matriciels

I) Méthode du gradient conjugué ...................................................................................................... 3

A) Rappels théoriques ..................................................................................................................... 3

II) Résolution d’une EDO par différences finies en 1D ........................................................................... 8

A) Enoncé et rappels théoriques sur les différences finies ............................................................. 8

III) Problème de la plaque 2D ............................................................................................................... 14

A) Rappels théoriques ................................................................................................................... 14

Lorsque l’on a un problème à résoudre, on le met en équation : c’est la première

I) Méthode du gradient conjugué

D’après le cours, on sait qu’il y a équivalence entre

Et on développe, sachant que le produit scalaire est symétrique :

Puis on applique l’identité remarquable :

Et le minimum vaut alors initialement :

On va choisir de façon à ce que dk+1 et dk soient orthogonaux, donc

B) Grandes étapes du code, difficultés rencontrées

On a donc les deux composantes de notre système. On choisit un .

Ainsi, le résidu initial est : et la direction initiale est :

Et la direction de l’étape k est :

On définit ensuite pour l’itération suivante :

Et donc par rapport à notre variable d’arrêt :

Alors si ( ) la convergence est rapide, si ( ) , la convergence est lente.

Alors que nous attendions une solution exacte telle que :

superposition des solutions exacte et approchée n=4

II) Résolution d’une EDO par différences finies en 1D

A) Enoncé et rappels théoriques sur les différences finies

La solution exacte nous est donnée : ( )

- Méthode des différences finies :

On va approcher les éléments de l’EDO par différences finies à l’ordre 2 :

Or on applique la notation () donc

On applique alors les conditions de Dirichlet :

On doit donc résoudre le système :

Mis sous forme matricielle, on obtient : où

B) Résolution numérique et validation

On dispose de la solution exacte, la fonction exponentielle : on peut donc comparer

superposition des solutions exacte et approchée n=600

Si on pose le vecteur « solution approchée » à déterminer

Alors on obtient les équations :

superposition des solutions exacte et approchée n=10

superposition des solutions exacte et approchée n=600

Ces graphiques sont comparables aux graphiques précédents et montrent à nouveau la

C) Erreur selon le pas

Voici ce que l’on observe :

Evolution du rapport log(erreur)/log(h)

Donc en faisant le rapport :

Voyons à présent une résolution avec la méthode du gradient conjugué en 2 dimensions

III) Problème de la plaque 2D

On va utiliser la méthode des différences finies pour résoudre l’équation de Poisson en 2D

On pose N le nombre de points selon l’horizontale, M le nombre de points selon la verticale

L’équation est ( ) ( ) ( ) et on va approcher ces termes par

Alors en sommant les deux :

On cherche la solution aux points ( ) on a donc :

Il y a N2=9 points intérieurs et 16 points du bord.

On a posé ( ) ( ) ( ) on peut maintenant réécrire ① pour

On aboutit donc au système matriciel suivant :

La solution exacte nous est donnée dans le cours :

B) Résolution numérique et validation

champs de température sur la plaque

solution approchée n=3

solution approchée n=10

champs de température sur la plaque

solution approchée n=30

- Programme FORTRAN avec subroutines pour la question 1 de l’énoncé