a. seghir, département de génie civil, université a. … · a. seghir, département de génie...

A. Seghir, Département de Génie Civil, Université A. Mira de Béjaia

Cours : Méthode des éléments finis

1

Sommaire

Chapitre 1 Présentation de MATLAB ...................................................................... 1

1.1 Introduction .................................................................................................. 1

1.2 Introduction des matrices ............................................................................. 3

1.3 Opérations sur les matrices .......................................................................... 5

1.4 Opérations sur les vecteurs .......................................................................... 7

1.5 Fonctions de matrices .................................................................................. 8

1.6 Accès aux éléments des matrices ............................................................... 10

1.7 Les testes logiques ..................................................................................... 11

1.8 Les boucles ................................................................................................ 12

1.8.1 La boucle for ................................................................................. 12

1.8.2 La boucle while ............................................................................. 15

1.9 Le graphisme .............................................................................................. 17

1.9.1 Les courbes ................................................................................... 17

1.9.2 Les surfaces 3D ............................................................................. 23

1.9.3 Les fonctions à deux variables ...................................................... 25

1.9.4 Les champs vectoriels ................................................................... 27

1.9.5 Animation ..................................................................................... 29

1.9.6 Autres fonctions graphiques ......................................................... 32

1.10 Les Fichiers fonctions ................................................................................ 33

1.11 Calcul symbolique ..................................................................................... 34

1.12 Les Fichiers texte ....................................................................................... 35

1.13 Application 1 .............................................................................................. 36

1.14 Exercice ..................................................................................................... 37

1.15 Devoir - TP ................................................................................................ 37

Chapitre 2 Présentation générale de la Méthode des Eléments Finis ...................... 39

2.1 Introduction ................................................................................................ 39

2.2 Historique ................................................................................................... 40



2

2.3 Les grandes lignes de la méthode .............................................................. 41

2.4 Formulation variationnelle ......................................................................... 43

2.4.1 Forme forte ................................................................................... 43

2.4.2 Forme faible .................................................................................. 44

2.5 Discrétisation du domaine .......................................................................... 46

2.6 Approximation sur l'élément ...................................................................... 47

2.6.1 Approximation polynomiale et approximation nodale ................. 47

Chapitre 3 Equation différentielles ................................ Erreur ! Signet non défini.

3.1 Introduction ....................................................... Erreur ! Signet non défini.



1

MATLAB (MATrix LABoratory) est un logiciel interactif basé sur le calcul matriciel. Il est utilisé dans les calculs scientifiques et les problèmes d’ingénierie parce qu’il permet de résoudre des problèmes numériques complexes en moins de temps requis par les langages de programmation courant, et ce grâce à une multitude de fonctions intégrées et à plusieurs programmes outils testés et regroupés selon usage dans des dossiers appelés boites à outils ou "toolbox".

Au démarrage de MATLAB sur un PC, l’interface se présente comme suit :

Figure 1.2 : fenêtre principale de MATALB (version 7.0)


Cours : Méthode des éléments finis Chapitre 1 : Présentation de MATLAB

2

La fenêtre principale de MATLAB contient deux fenêtres secondaires pouvant être déplacées ou fermées. A droite la fenêtre des commandes permet à la fois d’afficher les résultats et d’introduire les commandes ligne par ligne. Le symbole (>>) indique l’attente d’une commande. A gauche, sont imbriquées en volets les fenêtres Workspace, Current Directory et parfois Command History.

- Workspace permet d’afficher les variables utilisées avec leurs tailles.

- Current Directory affiche le chemin d’accès ou le répertoire en cours avec tous les fichiers et les sous répertoires.

- Command History affiche les commandes ayant été saisies.

Les déclarations et les commandes peuvent aussi être introduites sous forme d’un script dans un fichier texte d’extension ".m". MATLAB est équipé d’un éditeur de texte permettant de saisir les fichiers script. La commande edit prog1 ouvre l’éditeur et charge le fichier prog1.m s’il existe, sinon l’éditeur s’ouvre sur un fichier vide. La figure suivante montre l’éditeur de MATALB ouvert sur le fichier prog1.m en cours de création.

L’exécution du script (les commandes une après une) se fait à l’aide du bouton Save and Run (sélectionné dans la figure) ou avec le menu debug/Save and Run ou bien, simplement, en appuyant sur la touche fonction F5. Les résultats sont affichés dans la fenêtre des commandes.

Figure 1.2 : Editeur de MATLAB



3

Remarques : Une ligne de commande peut contenir plusieurs instructions séparées par des virgules (,) ou par des points-virgules (;). Le résultat d’une instruction suivie par un point-virgule ne sera pas affiché. Le caractère pourcent (%) est utilisé pour les commentaires.

MATLAB fonctionne essentiellement avec des matrices multidimensionnelles. Les composantes peuvent être réelles, complexes ou symboliques. Ainsi, les scalaires

sont représentés par des matrices 1×1 et les vecteurs à n composantes par des

matrices 1×n pour les vecteurs lignes et n×1 pour les vecteurs colonnes.

Il possible d’introduire une matrice dans MATLAB en saisissant explicitement la liste de ses éléments dans la fenêtre des commandes ou en la chargeant à partir d’un fichier. Les colonnes sont séparées par des virgules (,) ou des espaces et les lignes par des points-virgules (;) ou des sauts de ligne (RETURN).

>> A = [ 1.1 1.2

2.1 2.2 ]

>> A = [ 1.1, 1.2 ; 2.1, 2.2 ] % les deux commandes affichent

A =

1.1 1.2

2.1 2.2

Pour la lecture à partir d’un fichier, on peut charger et exécuter le script à l’aide de l’éditeur de MATLAB ou bien taper le nom du fichier dans la fenêtre des commandes comme s’il s’agit d’une commande.

>> prog1 % prog1.m est enregistré dans le répertoire en cours

Si le fichier est un fichier de données texte, il faut utiliser la commande load

>> load matrice.txt % on peut aussi utiliser la commande

>> A = load('matrice.txt') % en l’assignant à une variable A



4

Le fichier matrice.txt contient des valeurs numériques disposées en tableau. La première commande charge les valeurs de la matrice et affecte le nom matrice au résultat par contre la seconde permet de choisir un nom (A) pour la matrice chargée.

La structure du fichier matrice.txt ressemble à :

1.1 1.2 1.3

2.1 2.2 2.3

3.1 3.2 3.3

Les espacements entre les composantes peuvent être irréguliers. Des virgules ou points-virgules peuvent aussi être utilisés pour séparer les colonnes et les lignes et une ligne incomplète ou à nombre de colonnes différent de celui des autres lignes provoque une erreur d’exécution.

En outre, il existe dans MATLAB quelques fonctions qui génèrent des matrices. On donne quelques unes d’elles.

>> A = eye(3) % matrice identité

A =

1 0 0

0 1 0

0 0 1

>> B = ones(3) % matrice carrée contenant des 1

B =

1 1 1

1 1 1

1 1 1

>> C = zeros(2,3) % matrice rectangulaire nulle

C =

0 0 0

0 0 0

>> D = diag([1:3]) % matrice dont la diagonale varie de 1 à 3

D =

1 0 0

0 2 0

0 0 3



5

La plus part des fonctions MATLAB s’appliquent sur des matrices comme sur des scalaires. Il suffit de voir la démonstration dans l’aide ou de taper demo en ligne de commande pour obtenir plus de détails.

Les opérations arithmétiques suivantes s’opèrent sur les matrices

+ Addition C = A + B

− Soustraction C = A - B

* Multiplication C = A * B

^ Puissance C = A^2 ou C = A * A

' Transposée C = A' ou C = transpose(A)

\ division gauche x = A\b

/ division droite x = b/A

Une erreur est provoquée dans le cas où les rangs des matrices sont incompatibles.

Remarque 1

La division matricielle implique la résolution de systèmes d’équations linéaires. Si A est une matrice carrée inversible :

x = A\b donne la solution du système A*x = b, avec x et b des vecteurs colonnes.

x = b/A bonne la solution du système x*A = b, avec x et b des vecteurs lignes

>> A = [3 2; 4 7] % exemple de système linaire (2x2)

A =

3 2

4 7

>> b = [2 ; 3] % vecteur colonne de second membre

b =

2

3

>> x = A\b % solution de A * x = b



6

x =

0.6154

0.0769

>> A * x % vérification

ans =

2

3

>> y = b’ % transposé du vecteur b (vecteur ligne)

y =

2 3

>> z = y/A % solution de z * A = y

z =

0.1538 0.3846

>> z * A % vérification

ans =

2 3

Remarque 2

Si un point est ajouté à gauche des opérateurs * ^ \ et / ils seront appliqués sur les composantes des matrices avec correspondance d’indices :

>> A * A % équivalent à A ^ 2

ans =

17 20

40 57

>> A .* A % équivalent à A .^ 2

ans =

9 4

16 49



7

Les vecteurs sont considérés comme des matrices rectangulaires d’une ligne ou d’une colonne. Toutes les opérations matricielles s’appliquent sur les vecteurs mais il faut faire attention à la correspondance des tailles. Les opérateurs précédés d’un point sont particulièrement utiles dans les calculs vectoriels et dans les représentations graphiques.

Exemples de manipulation de vecteurs :

>> a = [2 1 3] % vecteur ligne

a =

2 1 3

>> b = [1;3;2] % vecteur colonne

b =

1

3

2

>> a * b % produit scalaire

ans =

11

>> a .* b' % produit de composantes (noter b')

ans =

2 3 6

>> x = 0:0.2:1 % vecteur à pas fixe

x =

0 0.2000 0.4000 0.6000 0.8000 1.0000

>> y = x .^ 2 .* cos(x) % y = x2 cos(x) (noter les points)

y =

0 0.0392 0.1474 0.2971 0.4459 0.5403

>> plot(x,y) % affiche une fenêtre du graphe y(x)



8

! "

MATLAB contient plusieurs fonctions prédéfinies (built in) qui s’appliquent sur les matrices, elles sont optimisées et plus rapides que les scripts. Celles qui peuvent nous intéresser actuellement sont les suivantes :

det déterminant d’une matrice carrée

>> d = det(A)

diag extrait la diagonale d’une matrice ou forme une

matrice diagonale. Si A : matrice et d : vecteur

>> d = diag(A) % extrait la diagonale de A

>> A = diag(d) % matrice de diagonale d

inv inverse d’une matrice carrée

>> B = inv(A) % I = B * A

transpose

>> B = A' % ou bien : >> B = transpose(A)

eig valeurs et vecteurs propres

>> [Phi,w2] = eig(K) % (K – w2 * I) * Phi = 0

>> [Phi,w2] = eig(K,M) % (K – w2 * M) * Phi = 0

chol décomposition de Cholesky

>> C = chol(A) % A = C' * C

lu décomposition LU

>> [L,U] = lu(A) % A = L *U

qr décomposition QR

>> [Q,R] = qr(A) % A = Q *R

svd décomposition en valeurs singulières

>> [U,S,V] = svd(A) A = U*S*V'

norm norme

Plusieurs définitions (taper help norm)

kron produit tensoriel de Kronecker

>> C = kron(A,B) % C = [ A(1,1)*B A(1,2)*B ...

A(2,1)*B A(2,2)*B ...

... ...

A(n,1)*B A(n,2)*B ...

]

Les fonctions scalaires telles que cos, sin, exp, log … etc. s’appliquent sur les éléments des matrices et renvoient des matrices comme résultat.

Le script suivant donne quelques exemples.



9

>> A = [5 2 1; 2 7 3; 1 3 8]

A =

5 2 1

2 7 3

1 3 8

>> [vects,vals] = eig(A) % valeurs et vecteurs propres

vects =

0.7040 0.6349 0.3182

-0.6521 0.4005 0.6437

0.2812 -0.6607 0.6959

vals =

3.5470 0 0

0 5.2209 0

0 0 11.2322

>> vects' * A * vects % vérification de diagonalisation

ans =

3.5470 0.0000 0.0000

0.0000 5.2209 0.0000

0.0000 0.0000 11.2322

>> C = cos(A) % cosinus des composantes de A

C =

0.2836 -0.4161 0.5403

-0.4161 0.7539 -0.9899

0.5403 -0.9899 -0.1455

>> K = kron(A,[1 -1]) % produit tensoriel de Kronecker

K =

5 -5 2 -2 1 -1

2 -2 7 -7 3 -3

1 -1 3 -3 8 -8

>> diag(A)' % diagonale transposée

ans =

5 7 8



10

# $ %

L’accès aux éléments d’une matrice se fait à l’aide de leurs indices ligne et colonne mis entre parenthèses après le nom de la matrice : A(i,j) est l’élément de ligne i et de colonne j. Il est possible d’obtenir une sous matrice en spécifiant une liste d’indices à la place d’un seul indice. Deux points à la place d’un indice sont interprétés selon leur position comme ligne ou colonne entière. Exemple :

>> A = [1.1 1.2 1.3 1.4

2.1 2.2 2.3 2.4

3.1 3.2 3.3 3.4

4.1 4.2 4.3 4.4]

>> A(2,2:4) % ligne 2, colonnes 2, 3 et 4

ans =

2.2000 2.3000 2.4000

>> A(3,:) % toute la ligne 3

ans =

3.1000 3.2000 3.3000 3.4000

>> A(:,3) % toute la colonne 3

ans =

1.3000

2.3000

3.3000

4.3000

>> t = [1,4] % vecteur ligne

t =

1 4

>> A(t,t) % Cette écriture est utile en MEF pour l’assemblage

ans =

1.1000 1.4000

4.1000 4.4000



11

& '(

Les testes logiques dans MATLAB se font à l’aide des mots clés if, else et end. Les opérateurs utilisés dans les instructions logiques sont :

< inférieur c = a < b c = lt(a,b)

<= inférieur ou égal c = a <= b c = le(a,b)

> supérieur c = a > b c = ge(a,b)

>= supérieur ou égal c = a >= b c = ge(a,b)

== égal c = a == b c = eq(a,b)

~= non égal (différent) c = a ~= b c = ne(a,b)

& et c = a & b c = and(a,b)

| ou c = a | b c = or(a,b)

~ non c =~a c = not(a)

Les variables a et b peuvent être des scalaires ou des matrices, c prends des valeurs 0 ou 1 selon l’expression vraie ou fausse. Ces opérateurs s’appliquent sur les toutes les composantes dans le cas des matrices.

Exemple de teste if if a < b % ce script est équivalent à la fonction m = min(a,b)

m = a

else

m = b

end

Si le teste comprends plusieurs cas à inspecter, il est préférable d’utiliser l’instruction switch avec des case comme suit :

switch expr % expression ou variable à examiner

case cas1 % cas 1

instruction1 % commandes à exécuter si cas1 est vrai

instruction2

...

case cas2 % cas 2

... % commandes à exécuter si cas2 est vrai

case casn % cas n

...

otherwise % autrement : autres cas non recensés

instruction

end % fin de switch



12

Exemple : nne = input(' nombre de noeuds par élément = ');

switch nne

case 3

disp('Elément triangulaire à 3 noeuds')

case 4

disp('Elément quadrilatèral à 4 noeuds')

otherwise

disp('Element non disponible')

end

Il est possible d’utiliser des chaînes de caractères à la place des valeurs numériques pour les choix d’options, de nom de méthode à utiliser, …

) *

La structure des boucles dans MATLAB ne diffère pas de celle utilisée dans d’autres langages de programmation. Il existe principalement deux types de boucles. Une boucle for utilisant un compteur et une boucle while utilisant une condition

) *+

La boucle for fait varier une variable d’une valeur initiale à une valeur finale avec un pas d’incrémentation constant qui est pris égale à un s’il est omis. Les instructions à l’intérieur de la boucle sont exécutées à chaque valeur de la variable.

for compteur = valeur_initiale : increment : valeur_finale

instructions

. . . . . . .

end

Généralement, le compteur, la valeur initiale et la valeur finale sont des nombres entiers et l’incrément est égal à 1. Toutefois ce n’est pas une règle, dans certains cas des nombres réels ou même des caractères sont utilisés. En réalité, ce qui est à droite du signe égale n’est autre qu’un vecteur ligne qui est parcouru par compteur.



13

Dans où c’est une matrice, alors elle est parcourue colonne par colonne. Les exemples suivants illustrent ces cas.

1) Calcul des termes et de la somme d’une suite sn = na /an

a = 10; % valeur du paramètre a

N = 15; % nombre de terme

for n = 1:N % début de boucle d’entiers

s(n) = n^a/a^n; % calcul des termes

end % fin de boucle

[s(N), sum(s)] % affichage du dernier terme

% et de la somme. Noter l’absence de ;

ans =

0.00057665 376.18

2) Double boucle pour les variations de la somme en fonction de a. N = 15; % nombre de termes

A = []; % initialisation de A pour stocker a et S

for a = 1:1.5:10; % variation de a avec un par de 1.5

S = 0; % initialisation de la somme pour chaque a

for n = 1:N % boucle sur les termes de la série

S = S + n^a/a^n; % remarquer la différence ici

end

A = [A, [a; S]]; % stockage de a et S dans A.

% noter l’utilisation des sous matrices

end % fin de boucle

A % affichage de A (sans ;)

Le résultat est une matrice à deux lignes. La première contient les valeurs de a et la seconde, celles de S. La boucle du précédent script est modifiée pour ne sauvegarder que les valeurs de la somme. La dernière ligne affiche la matrice A

A =

1 2.5 4 5.5 7 8.5 10

120 4.5157 4.6913 8.9813 24.514 86.61 376.18

Remarque

Avec MATLAB, il est souvent possible de s’en passer des boucles au prix d’un grand espace mémoire. Les boucles demandent plus de temps d’exécution puisqu’elles sont interprétées commande par commande. Le script suivant peut



14

remplacer les deux boucles de l’exemple 2 mais avec 3 matrices de 15×7 au lieux

d’une unique matrice de 2×7.

N = 15; % nombre de termes

a = 1:1.5:10; % a est initialisé à un vecteur ligne

n = 1:N; % de même pour n

% duplication de n en 7 colonnes. noter n'

n = kron(n',ones(1,length(a)));

% duplication de a en 15 colonnes. noter ones(N,1)

a = kron(a,ones(N,1));

% calcul des termes de la suite. noter les points

s = (n.^a) ./(a.^n);

sum(s) % la somme s’applique sur les colonnes

% l’affichage donne uniquement les sommes sans a

3) Boucle utilisant les matrices

% matrice A carrée 3×4 A = [ 1.1 1.2 1.3 1.4; 2.1 2.2 2.3 2.4; 3.1 3.2 3.3 3.4];

B = []; % initialisation de B

for c = A % boucle sur les colonnes de A

B = [B, c']; % concaténation des colonnes de A en lignes

end

B

A chaque itération une colonne de la matrice A est extraite dans c puis elle est transposée (c') et ajoutée à B, ce qui donne un vecteur ligne constitué de colonnes de A. L’affichage donne :

B =

1.1 2.1 3.1 1.2 2.2 3.2 1.3 2.3 3.3 1.4 2.4 3.4

Remarque

La fonction MATLAB reshape(A,n,m) permet de réécrire A en une matrice n×m sans toutefois changer sa taille (n×m = 12). Le même vecteur B peut donc être obtenu en une seule commande : reshape(A,1,12).



15

4) Boucle utilisant les caractères ch = ''; % initialisation de la chaîne ch

% faire attention à ch = [] ;

for c = 'a':'z' % boucle sur l’alphabet en minuscules

ch = [ch,c]; % concaténation

end

ch % affichage

ch = abcdefghijklmnopqrstuvwxyz

Il faut faire attention au type de ch au moment de son initialisation MATLAB déclare la variable en réelle double ou en chaîne de caractères. Si ch est de type double, la commande ch = [ch,c] change d’abord c en double puis fait la concaténation. Le transtypage dans MATLAB est automatique. L’utilisation de la commande ch = [] pour l’initialisation donne le résultat :

ch = 97 98 99 ... 121 122

Enfin, la commande ch=[ch,' ',c]; force dans les deux cas le résultat suivant : ch = a b c d e f g h i j k l m n o p q r s t u v w x y z

Il reste encore plusieurs autres types de données pour lesquelles, la boucle for peut s’appliquer. On s’en tient à ces exemples tout en soulignant que dans la plupart des cas en MATLAB, les boucles peuvent être évitées au profit d’un gain en temps d’exécution mais aussi au prix d’espace mémoire plus grand. Le choix d’utiliser ou d’éviter les boucles dépend aussi de la lisibilité des programmes.

) *,

La boucle while s’exécute tant qu’une expression logique est vraie. Elle est plus utile lorsque la valeur finale de la boucle for n’est pas connue à priori. Sa structure est : initialisations

while expression logique

instructions

. . . . . . .

end



16

La boucle while nécessite souvent des initialisations avant d’être lancée et peut se dérouler indéfiniment si l’expression logique de contrôle reste toujours vraie. Les deux boucles peuvent être rompues par la commande break. On insère généralement break avec un teste de condition if.

Le script suivant permet de calculer la même somme du premier exemple de la boucle for.

N = 100 ; % fixer le nombre maximale de termes

petit = 1e-4; % fixer la plus petite valeur à considérer

a = 10; % paramètre a

terme = 1; S = 0; n = 0; % initialisations

while (terme > petit & n < N)

n = n+1; % compteur des termes

terme = n^a/a^n; % calcul des termes

S = S + terme; % calcul de la somme

end

[n terme S] % affichage

Le résultat affiché comprend le nombre de termes utilisés n, le denier terme terme et la somme recherchée S. L’exécution du script donne :

ans =

17 2.016e-005 376.18

On voit que dans ce cas les itérations sont contrôlées par les valeurs des termes de la suite et non par le nombre de termes. Le nombre N ne sert ici que de grade fous si jamais la suite ne converge pas. La boucle se déroule tant que les termes sont significatifs et tant que le nombre maximal n’est pas atteint.

L’xemple suivant, montre l’utilisation de while pour réaliser une boucle infinie qui elle se déroule tant l’utilisateur ne saisie n’est pas une valeur nulle. while 1

disp('Entrer une valeur entre 32 et 255 (0 pour terminer) ')

c = input(' c = '); % saisie d’une valeur

if c == 0, break, end % brise la boucle si c = 0

disp(['le caracter correspondant est : ' char(c)])

end



17

- '

MATLAB permet de réaliser avec beaucoup de facilités aussi bien les tracés de courbes planes (2D) et des courbes tridimensionnelles (3D) que la représentation des surfaces et des fonctions à deux variables. Il existe plusieurs fonctions MATLAB dédiées à la création et à la manipulation d’objets graphiques, la section Contents/MATLAB/Graphics de l’aide fournie beaucoup de détails sur ces fonctions et les démonstrations de demo/MATLAB/Graphics montrent comment les utilisées. Pour lancer les démonstrations on peut taper demo en ligne de commandes et chercher la section Graphics ou bien lancer directement les sections qui nous intéressent comme par exemples :

>> playshow graf2d tracés à 2 variables XY

>> playshow graf2d2 tracés à 3 variables XYZ

>> playshow cplxdemo tracés de fonctions complexes

>> graf3d propriétés des surfaces

>> hndlgraf propriétés des courbes

>> hndlaxis propriétés des axes

>> vibes animation des vibrations

Il existe plusieurs autres démonstrations, nous nous limiterons à celles-ci et nous ne pouvons que constater la puissance graphique de MATLAB.

- *

La commande la plus importante dans les fonctions graphiques de MATLAB est sans doute la fonction plot(x,x). Elle permet de tracer les courbes de variations de y en fonction de x. Les variables x et y sont des matrices rectangulaires de tailles identiques. Chaque colonne de y est tracée en fonction de la colonne correspondante de x. Dans la cas où x et y sont des vecteurs alors, ils doivent uniquement avoir la même longueur ; qu’ils soient lignes ou colonnes n’a pas d’importance.

La fonction plot permet aussi de tracer les composantes d’une matrice Y en fonction de leurs indices, la commande s’écrie simplement : plot(Y).



18

Le script suivant ouvre une fenêtre graphique et trace la fonction xey x sin2.0−=

pour des valeurs de x variant de 0 à 5π avec un pas de 0.1.

>> x = 0:0.1:5*pi; % valeurs de x

>> y = sin(x) .* exp(-0.2*x); % noter .*

>> plot(x,y) % ouvre la fenêtre graphique

>> grid on % ajoute la grille aux axes

La fenêtre est appelée par défaut Figure 1, elle est mise en avant plan et modifiée pour le présent graphique si elle est déjà ouverte par un autre script.

La commande figure permet d’ouvrir une nouvelle fenêtre et la rendre active pour recevoir les instructions graphiques qui vont suivre. Un menu et une barre d’outils sont par défaut ajoutés par MATLAB à la fenêtre afin de pouvoir manipuler et modifier les objets graphiques. Il est possible de changer les propriétés des lignes, des axes, de l’arrière plan … On peut aussi exporter, copier ou imprimer le graphe.

La fonction plot permet de tracer en une seule commande, plusieurs courbes à la fois et de spécifier leurs propriétés telles que l’épaisseur des lignes, la couleur, la police, la taille des caractères, … etc. Si on ajoute, les commandes suivantes aux

script précédent, on ajoute à la figure les courbes xef ±= .

Figure 1.3 : Fenêtre graphique



19

>> f = exp(-0.2*x);

>> plot(x,y,'-k', x,f,'--k',x,-f,'-.k'), grid on

Noter la succession des paires de valeurs suivies chacune par le mode de tracé et la couleur des lignes. L’option '-k' est utilisée pour une ligne noire continue, '--k' pour une ligne noire discontinue en double traits, et '-.k' pour une ligne noire continue en trait–point.

Une couleur peut être spécifiée avec son nom ou en utilisant uniquement une lettre lorsque elle est une couleur courante. Un triplet RGB [Red Green Blue] combinant les trois valeurs entre 0 et 1 du rouge, du vert et du bleu, permet d’avoir toutes les couleurs de windows. Le tableau suivant donne les couleurs usuelles avec la correspondance aux triplets RGB.

RGB Lettre Nom

RGB Lettre Nom

[1 0 0] r red [1 1 1] w white [0 1 0] g green [1 1 0] y yellow [0 0 1] b blue [1 0 1] m magenta [0 0 0] k black [0 1 1] c cyan

Tableau 1.1 : Couleurs standard de MATLAB

Les styles de ligne disponibles sont : ligne continue '-', ligne discontinue en double traits '--', ligne en pointillés ':', ligne discontinue trait–point '-.', et aucun 'none' (ligne invisuble). Le style de ligne none est généralement utilisé avec un symbole marker ('+' 'x' '^' 'v' '>' '<' …) qui montre uniquement les positions des valeurs dans le graphe.

Remarque

Pour spécifier le style, la couleur et l’épaisseur de ligne ainsi que le type et les propriétés des marks d’une manière explicite dans commande plot, on utilise la syntaxe suivante :



20

plot(x,y, ...

'Color' , 'k' ,... % couleur de ligne

'Marker' , 'o' ,... % type de marque

'MarkerEdgeColor', 'b' ,... % couleur du bord de marque

'MarkerFaceColor', 'r' ,... % couleur de remplissage

'LineWidth' , 1 ,... % epaisseur de ligne

'MarkerSize' , 2) % taille de marque

Les trois points successifs (...) indiquent que la commande continue sur la ligne suivante. Enfin, le graphique produit par le script peut être copié à l’aide du menu Edit/Copy de la fenêtre graphique pour ensuite le coller à ce texte.

Une autre manière d’ajouter les deux courbes de f au tracé de y consiste à utiliser la commande hold on qui permet de garder les objets graphiques tracés et d’ajouter au mêmes axes les graphes créés à la suite de la commande. Le script serait :

x = 0:0.1:5*pi; % valeurs de x

f = exp(-0.2*x); % valeurs de f

y = f .* sin(x); % produit de f par sin

plot(x,y,'k') % crée la fenêtre et le courbe y(x)

hold on % permet d’ajouter

plot(x,f,'--k') % ajoute la courbe positive

plot(x,-f,'-.k') % ajoute la courbe négative

grid on % ajoute une grille

hold off % désactive le mode ajout

Figure 1.4 : Graphe à plusieurs courbes



21

MATALB fourni d’autres fonctions de graphisme 2D adaptées à des cas de tracés spécifiques. On reporte ici quelques unes d’elles :

semilogx échelle logarithmique pour l’axe des x

semilogy échelle logarithmique pour l’axe des y

loglog échelle logarithmique pour les deux axes

area trace la courbe avec une aire au dessous

errorbar trace la courbe avec des barres d’erreurs

line trace une ligne dans les axes courants (2D & 3D)

bar trace les valeurs en barres vert. ou horiz.

hist pour les histogrammes

pie pour les tracés en secteurs (portions)

stairs tracé en escalier pour les fonctions discrètes

Pour la représentation des courbes tridimensionnelles, la fonction plot3 constitue

l’extension de plot. Le tracé de la fonction z = (2 − x2 ) (2 − y2 ) sur la diagonale du

carré [−2, 2] s’obtient par :

x = [-2:0.1:2]; y = x; % définie la diagonale

z = (2-x.^2).*(2-y.^2); % évalue la fonction

plot3(x, y, zeros(1,length(x)), ... % trace la diagonale

x, y, z, ... % trace la courbe

'LineWidth',1.5) % spécifie l’épaisseur

grid on % ajoute une grille

Avec ajout des titres aux axes, la figure est copiée puis collée ci-dessous :

-2

-1

0

1

2 -2-1

01

2

0

0.5

1

1.5

2

2.5

3

3.5

4

YX

Z

Figure 1.5 : plot3d d’une courbe



22

Le script suivant permet de réaliser le tracé paramétré d’une sphère de rayon R en

faisant varier z de −R à +R et à chaque niveau, un cercle de rayon 22 zRr −= est

calculé. Les coordonnées sont stockées dans les matrices x et y, le vecteur z est ensuite transformé en une matrice par duplication. Les transposés des matrices permettent ensuite d’ajouter des cercles verticaux.

R = 5; % rayon de la sphère

n = 15; % nombre de cercles

z = linspace(-R,R,n); % vecteur z entre –R et +R

r = sqrt(R^2 - z.^2); % petit rayon des cercles. noter .^

t = linspace(-pi,pi,n); % angle pour le calcul des cercles

x = r' * cos(t); % coordonnées x et y des cercles

y = r' * sin(t); % noter la transposée de r (r’)

z = z' *ones(1,n); % duplication des coordonnées z

plot3(x , y , z ,'k','LineWidth',1.5) % cercles horizontaux

hold on % pour un autre plot3

plot3(x', y', z','k','LineWidth',1.5) % cercles verticaux

grid on % grille

-10-5

05

10

-10

-5

0

5

10-10

-5

0

5

10

Figure 1.6 : sphère avec la fonction plot3



23

Remarquer l’épaisseur des lignes prise égale à 1.5 points, une épaisseur de 1 point peut donner une copie de la figure avec des lignes trop fines à l’impression, spécialement si la taille de la figure est réduite pour respecter la mise en page du texte. Une copie en format Bitmap prend une taille plus grande avec une résolution moins bonne. Le meilleur résultat s’obtient avec une copie en format Metafile qui peut être sélectionné dans les options copy options accessibles à partir du menu Edit de la fenêtre graphique ou du menu file/preferences de MATLAB.

Même si la figure 1.6 représente bien une sphère, il faut garder à l’esprit que ce n’est qu’un ensemble de cercles entrecroisés. MATLAB n’y reconnaît pas les faces cachées (d’arrière plan) qui doivent être effacées pour vue plus réaliste. C’est dans ce sens que les surfaces font l’objet d’une autre catégorie de fonctions.

- + .

Dans la représentation tridimensionnelle des surfaces, les fonctions mesh et surf sont les analogues de la fonction plot. Les surfaces sont définies dans MATLAB par trois matrices x,y,z dont les composantes sont des coordonnées dans l’espace des points appartenant à la surface. Des lignes sont utilisées pour connecter des points adjacents, chaque point (i,j) de coordonnées x(i,j), y(i,j) et z(i,j) est relié à quatre points (i+1,j), (i-1,j), (i,j+1) et (i,j-1), de coordonnées ayant les mêmes indices dans les trois matrices.

L’exemple suivant montre comment tracer la sphère précédente (fig. 1.6) avec les fonctions mesh et surf.

R = 10; n = 15;

t = linspace(-pi,pi,n);

z = linspace (-R,R,n);

r = sqrt(R^2 - z.^2);

x = r'*cos(t);

y = r'*sin(t);

z = z'*ones(1,n); % jusqu’ici, aucune modification

% du script précédent

mesh(x,y,z) % commande mesh (x,y,z) ou surf(x,y,z)

colormap gray(1) % spécifie les couleurs des lignes



24

Noter qu’avec les fonctions mesh, il n’est pas nécessaire d’utiliser grid on pour avoir la grille des axes. Par contre, la commande colormap gray(1) doit est ajoutée pour spécifier la couleur noir des lignes, autrement une répartition de plusieurs couleurs serait utilisée. La figure suivante montre la différence avec la figure 1.6. Les lignes cachées sont maintenant effacées du dessin, la représentation est plus réaliste, cependant, il est toujours possible de forcer le tracé des faces cachées en ajoutant la commande hidden off. L’utilisation de la commande surf à place de mesh permet de colorer les faces entre lignes, la commande colormap gray(1) est aussi remplacée par colormap gray(100) afin d’obtenir une répartition plus étendue des niveaux du gris.

(a) (b)

Figure 1.7 : sphère avec les fonctions mesh (a) et surf (b)

Remarque : Les couleurs utilisées par mesh et surf pour colorer les surfaces sont définies par colormap avec des matrices m×3 dont chaque ligne correspond à une couleur. Plusieurs dégradations de couleurs sont prédéfinies dans MATLAB, l’éditeur de couleurs colormapeditor permet de les utilisées tout en offrant la possibilité de les modifier ou d’en créer d’autres.

Enfin, avant de clore ce paragraphe, on doit noter qu’il existe dans MATLAB des fonctions spécifiques aux tracés des surfaces 3D et 2D courantes telles que les sphères, les cylindres, les polygones, … etc. La section de l’aide Contents/MATLAB/Functions --catégorical List/Graphics/specialized

Ploting regroupe toutes ces fonctions par catégorie selon leurs usages.



25

- + /% *

Les fonctions à deux variables z = f (x, y) sont simplement des équations de surfaces. Avant d’être tracées, elles doivent d’abord être évaluées sur un intervalle qui correspond à une grille de valeurs de x et y. Une grille est un ensemble de points (i,j) de coordonnées x(i,j) et y(i,j) dans le plan x-y et la fonction à deux variables z = f(x,y) est l’équation de la surface ; dans ce cas aussi, les variables x, y et z sont des matrices. La fonction meshgrid calcule les coordonnées x et y d’une grille rectangulaire à partir d’une subdivision initiale en vecteur d’un intervalle, son utilisation est quasi-incontournable dans le tracé tridimensionnel des fonctions à deux variables. Le script suivant montre comment tracer dans deux

fenêtres graphiques différentes, la fonction )cos(2225.0 xyez yx +−= pour x et y

variant de −3.5 à +3.5.

[x,y] = meshgrid(-3.5:0.25:3.5); % construit la grille

r = sqrt(x.^2 + y.^2); % calcul le rayon

z = 2*exp(-0.5*r).* cos(x.*y); % évalue la fonction

% ouvre une fenêtre avant chaque tracé

% noter la couleur dans mesh et les niveaux de gris dans surf

figure; mesh(x,y,z,'EdgeColor','k');

figure; surf(x,y,z);

g = gray(100); % matrice de niveaux de gris

colormap(g(50:100,:)); % utilise la partie claire

Figure 1.8 : mesh (gauche) et surf (droite) d’une fonction à deux variables

(a)

(b)



26

Une autre représentation des fonctions à deux variables, très courante et peut être plus intéressante que surf ou mesh, concerne le tracé des courbes de niveaux (topographie). Dans ce cas aussi MATLAB offre deux fonctions à savoir contour et pcolor. En combinant ces deux fonctions on réalise des tracés à courbes de niveaux et à dégradation de couleurs, le script suivant en donne l’exemple :

[x,y] = meshgrid(-3.5:0.25:3.5); % ces lignes ne changent pas

r = sqrt(x.^2 + y.^2);

z = 2*exp(-0.5*r).* cos(x.*y);

pcolor(x,y,z) % fonction pcolor

g = gray(100); % on utilise les niveaux du gris

colormap(g(40:100,:)) % les plus clairs

shading interp % interpolation de la couleur

hold on % mode ajout de graphiques

contour(x,y,z, ... % fonction contour avec options

'LineColor' , 'k' , ... % couleur des lignes

'LineStyle' , '-' , ... % style des lignes

'LevelStep' , 0.5 , ... % le pas des tracés des courbes

'TextStep' , 0.5 , ... % le pas des nombres

'ShowText' ,'on'); % les nombres sont visibles

colorbar % ajoute la barre des niveaux à droite

Figure 1.9 : coutour et pcolor pour une fonction à deux variables



27

Il exite plusieurs autres fonctions MATLAB permettant de réaliser différentes représentations dans l’espace de fonctions à deux variables ou de surfaces 3D, celles que nous venons de voir sont des fonctions de base. Pour plus de détails, il faut se référer à la documentation ou à l’aide de MATLAB. Toutefois une attention particulière doit être prêtée ici à celles qui prennent en arguments un pointeur ou une expression d’une fonction à deux variables. Elles portent les mêmes noms que les fonctions de base précédés de ez comme Easy to use. L’exemple suivant

montre comment tracer la fonction précédente )cos(2225.0 xye yx +− sans se soucier

des détails que demandent surf et mesh.

% adresse de fonction (function handle fh)

fh = @(x,y) 2*exp(-0.5*sqrt(x.^2 + y.^2)).* cos(x.*y);

% tracé du graphe avec : ezmesh, ezsurf, ... etc.

% les arguments sont la fonction et l’intervalle

ezmesh(fh,[-3.5 3.5 -3.5 3.5])

% Il est possible d’utiliser uniquement une ligne de commande

% si on n’a pas besoin de la fonction pour autres choses

mesh('2*exp(-0.5*sqrt(x.^2 + y.^2)).*cos(x.*y)', ...

[-3.5 3.5 -3.5 3.5])

Remarque

Les fonctions à variable complexes sont prises en compte à l’aide des fonctions cplxgrid et cplxmap. Exemple : z = 2*cplxgrid(10); cplxmap(z,z.^2)

-

Les champs vectoriels tels que les champs de vitesses sont pris en charge dans MATLAB avec la fonction quiver. Les composantes u et v d’un champ de vecteurs bidimensionnel évaluées en un ensemble de points (i,j) de coordonnées x(i,j) et y(i,j) sont représentées par des flèches dans un système d’axes plan.

La fonction quiver prend quatre arguments et elle est généralement utilisée avec la syntaxe suivante : quiver(x,y,u,v, propriété, valeur, ...).



28

L’ensemble des propriétés et des valeurs concerne la couleur des flèches, leurs épaisseurs, le facteur d’échelle, … etc.

Comme exemple d’illustration on considère, encore une fois de plus, la fonction

des exemples précédents : )cos(2),(225.0 xyeyxf yx +−= . On supposant quelle

représente des lignes de courant d’un écoulement plan à potentiel des vitesses, les composantes du champ de vitesse seraient données par les expressions :

yyxf

u∂

∂= ),( et

xyxf

v∂

∂−= ),(

Soit sous forme vectorielle : )( fgradu

v=

−

avec

=∂

∂∂

∂

y

xgrad est le gradient.

Cette forme s’évalue facilement à l’aide des deux commandes :

[v,u] = gradient (f,0.5);

v = -v;

La fonction gradient évalue numériquement les dérivés de f par des différences, la seconde commande prenant la valeur négative de la deuxième dérivé n’est pas nécessaire si on n’oublie pas d’utiliser -v en argument pour la fonction quiver.

Le script suivant trace sur un même graphe les lignes de courant et le champ de vitesses

[x,y] = meshgrid([-3:0.25:3]); % évaluer la fonction

r = sqrt(x.^2 + y.^2);

f = 2*exp(-0.5*r).* cos(x.*y);

[v,u] = gradient(f,0.5); v = -v; % calculer les vitesses

figure % ouvrir une fenêtre

hold on % activer le mode ajout de graphique

% tracer les lignes de courant avec contour

contour(y,x,f,'k','LineWidth',1.5,'LevelStep',0.3);

% ajouter les flèches représentant le champ de vitesses

quiver(x,y,u,v,'k','AutoScaleFactor',1,'LineWidth',1.25);

hold off % désactiver le mode ajout de graphiques

axis([-3 3 0 3]); % montrer uniquement une partie du graphe



29

La figure obtenue par ce script est modifiée dans la fenêtre graphique puis collée ci-après :

-3 -2 -1 0 1 2 30.0

0.5

1.0

1.5

2.0

2.5

3.0

Figure 1.9 : coutour et cuiver pour les lignes de courant et le champ de vitesses

-!

On distingue deux types d’animations dans MATLAB :

- La visualisation des objets sous différentes positions ou angles de vision

- Changement de position ou de forme des objets.

Dans le premier type les objets ne sont pas tout à fait animés mais leur apparence change grâce au mouvement du point de vision défini comme camera. En effet MATLAB s’appui sur la notion de prise de scènes par une caméra pour dessiner les objets, il fourni ainsi plusieurs fonctionnalités analogues à celles d’une caméra réelle telles que :

campose : position de la caméra

camdolly : déplacer la caméra avec la cible (scène)

camlookat : visionner un point ou un objet spécifique

camorbit : tourne la caméra en orbite autour de la cible

camroll : tourne la caméra sur l’axe de vision

campan : tourne la cible autour de la position de la caméra

camproj : type de projection (orthographique ou perspective)

camtarget : renvoie ou spécifie la position de la cible

camup : direction de l’axe vertical de la caméra

camva : angle de vision de la caméra

camzoom : agrandissement des objets (zoom in ou zoom out)

De plus la commande cameratoolbar permet de manipuler avec la programmation la barre d’outils de toutes les fonctions relatives à l’objet caméra.



30

L’exemple suivant montre comment faire tourner autour de son axe vertical la sphère de la figure 1.7 à l’aide de la fonction camorbit.

% Cette partie permet de tracer la sphère de la figure 1.7b

R = 10; n = 20;

t = linspace(-pi,pi,n); z = linspace (-R,R,n);

r = sqrt(R^2 - z.^2);

x = r'*cos(t); y = r'*sin(t); z = z'*ones(1,n);

surf(x,y,z); g = gray(100); colormap(g([50:100],:))

view(-30,30);

% partie ajoutée pour effectuer la rotation

axis off % cacher les axes

axis vis3d % figer 'aspect ratio' pour la rotation 3d

while 1; % boucles infinie tant que la figure est ouverte

h = get(0,'CurrentFigure'); % casse la boucle si la figure

if isempty(h), break, end; % est fermée

%change de position de la caméra pour faire tourner la sphère

camorbit(3,0,'data',[0 0 1])

drawnow ; % impose le dessin maintenant

end

L’animation proprement dite nécessite la création et la sauvegarde de plusieurs images une à une comme dans les séquences vidéo du cinéma. La fonction getframe est la plus importante dans un script d’animation, elle permet de récupérer le contenu d’une figure graphique (ou d’une partie de la figure) dans une structure de donnée qui peut être sauvegardée dans une liste (vecteur) ou ajoutée à un fichier vidéo .avi à l’aide de la fonction addframe. Il est aussi possible d’enregistrer le contenu de la liste d’image en utilisant la fonction movie2avi.

Comme exemple, on simule le rebondissement sur un plan horizontal d’une balle de tennis qui tombe d’une certaine hauteur. La trajectoire de forme sinusoïdale amortie est calculée en un nombre de points suffisamment grand pour avoir un mouvement continu mais pas trop grand pour limiter la taille de la séquence vidéo et du fichier de sauvegarde. Le script doit comporter une boucle parcourant les



31

points de la trajectoire et dans laquelle la balle est dessinée sur un fond noir puis effacée après avoir enregistrer le contenu de la figure.

n = 50; % nombre de points

x = linspace(0,5*pi,n); % points de la trajectoire

y = 10*abs(exp(-0.25*x).*cos(x));

axis([0,max(x), 0, max(y)]) % limites des axes imposées

daspect([1,1,1]) % rapport d’échelle

% fond de couleur noire et axes sans graduations

set(gca,'Color','k','XTickLabel',[], 'YTickLabel',[])

% boucle dur les points de la trajectoire

for i = 1:n

% dessine un cercle au point i de la trajectoire

% cercle = rectangle de courbure (1,1)

c = rectangle('Position' , [x(i),y(i),1,1], ...

'Curvature' , [1,1], ...

'FaceColor' , 'cyan');

F(i) = getframe(gca); % capture uniquement le contenu des

% axes est suffisant

delete(c); % efface le cercle

end

movie(F,0,15) % rejouer la séquence

close % ferme la fenêtre graphique

movie2avi(F,'balle.avi') % sauvegarde dans un fichier



32

-# + '(

Il exite dans MATLAB beaucoup d’autres fonctions graphiques, il n’est pas possible de les traiter toutes ici. Le graphisme sous MATLAB pourrait constituer à lui seul le sujet d’un ouvrage. On conseil le lecteur de se familiariser avec les fonctions traitant les axes, le texte et la création des fenêtre utilisateur.

Les fenêtres utilisateurs permettent de personnaliser les visualisations en leurs ajoutant des boutons. Elles sont aussi très utiles dans les interfaces et facilitent la saisie des données et aident à la préparation et l’organisation des fichiers de données des codes de calcul. L’exemple suivant montre comment ajouter trois boutons à un graphique 3D.

mesh(peaks); % peaks est une fonction à 2 variables

axis vis3d ; % fournie par MATLAB

axis off;

% premier bouton : zoom in

func = 'if camva <= 1; return; else;camva(camva-1);end';

uicontrol('Style' , 'pushbutton' ,...

'String' , 'Zoom In' ,...

'Position' , [20 20 60 20] ,...

'Callback' ,func);

% deuxième bouton : zoom out

func = 'if camva >= 179;return;else;camva(camva+1);end';


'String' , 'Zoom Out' ,...

'Position' , [100 20 60 20] ,...

'Callback' , func);

% troisième bouton : rotation

func = ' camorbit(5,0,''data'',[0 0 1])'


'String' , 'Z-Rotate' ,...

'Position' , [180 20 60 20] ,...

'Callback' , func);

Le module GUI de MATALB permet de construire des fenêtres utilisateur plus élaborées comportant des menus et des barres d’outils.



33

0 " +

Les fichiers scripts permettent d’écrire et de sauvegarder un ensemble de commandes dans un fichier disque. Les fichiers fonctions ont plus d’importance, ils offrent une extensibilité à MATLAB. On peut créer une fonction spécifique à un problème donné et l’utiliser de la même manière que les autres fonctions offertes par MATLAB. Un fichier fonction possède la structure suivante :

function [res1, res2, ...] = nomfonction(var1, var2, ...)

% mettre ici les lignes commentaires à afficher

% dans la fenêtre de commandes suite à une demande d’aide

% avec help nomfonction

instruction1

instruction2

...

Le mot clé function est indispensable, var1, var2 ... sont des variables d’entrée et res1, res2, ... sont les résultats renvoyés par la fonction. Autant de variables et de résultas que nécessaire peut être utilisé. Le fichier doit être sauvegardé sous le nom nomfonction.m et peut contenir plus d’une fonction, la première d’entre elles est la fonction principale et l’unique qui soit accessible de l’extérieure. Un mot clé return peut être ajouté en fin de chaque fonction. L’exemple suivant montre une fonction qui renvoie la matrice de rotation 3D autour de l’axe z.

function R = rot3dz(theta)

% R = rot3dz(theta)

% retourne une matrice de rotation 3d

% d'un angle autour theta de l'axe z

% theta en degrés mesuré à partir de l’axe x

theta = theta * pi/180; % transformation de theta en radian

c = cos(theta); % cos et sin pour éviter les calculs

s = sin(theta); % doublés dans la matrice R

R = [ c s 0

-s c 0

0 0 1 ];

return % return n’est pas nécessaire



34

Pour avoir une rotation de 30° autour de z, on peut appeler la fonction comme suit : >> r = rot3dz(30)

r =

0.8660 0.5000 0

-0.5000 0.8660 0

0 0 1.0000

1*(

Les calculs symboliques sont introduits dans l’environnement MATLAB avec une deux toolbox : basic math toolbox et extanded math tolbox. La première est une collection d’une centaine de fonctions donnant accès au noyau de MAPLE avec la syntaxe et le style de programmation de MATLAB. La seconde est une extension pour inclure les fonctionnalités non graphiques et le langage de programmation de MAPLE.

Pour déclarer une variable symbolique on utilise l’une des syntaxes suivantes :

x = sym('x') % x est une variable symbolique

% représentée par la lettre x

y = sym('y', 'real') % on spécifie que y est réelle

syms x y real % plusieurs variables en même temps

La fonction sym permet aussi de convertir une valeur numérique en une forme symbolique. Dans ce cas elle s’emploi comme suit : vs = syms(vn,c) avec vs variable symbolique résultant vn valeur numérique et c est un caractère indiquant quel type de conversion à faire. Les valeurs possibles sont 'f' pour virgule flottante, 'd' pour double, 'r' pour rationnel et 'e' ajoute une estimation d’erreur. Exemple : x = sym(3.14,'r') donne x = 157/50.

Une fois les variables symboliques sont déclarées, elles peuvent être utilisées comme arguments de fonctions de la même manière que les variables numériques. Parmi les fonctions les plus utilisées pour la manipulation de variables et d’expressions symboliques on cite : int et diff pour l’interaction et la différentiation de fonctions, simple et simplify pour la simplification des expressions, compose pour les fonctions composées, solve et dsolve pour la solution des équations algébriques et des équations différentielles …



35

L’exemple suivant permet de calculer les polynômes d’interpolation de Lagrange, leurs dérivées et deux matrices élémentaires formée par intégration des polynômes.

syms x real;

xi = [-1 1]; n = 2;

for i = 1:n

p = sym(1.0);

q = sym(1.0);

for j = [1:i-1 i+1:n];

p = p * (x - xi(j));

q = q * (xi(i) - xi(j));

end

f(i) = p/q;

hold on

ezplot(f(i),[-1,1])

end

disp(f)

S = simple(sum(f))

df = simple(diff(f,x))

K = simple(int(df'*df, x, -1, 1))

M = simple(int(f'*f, x, -1, 1))

" %

Tout langage de programmation doit fournir toutes les fonctions nécessaires à la création et à la manipulation des fichiers. Les fonctions qu’offre MATLAB sont similaires à celles du langage C. Toute utilisation d’un fichier nécessite son ouverture (fonction fopen) et en fin d’écriture ou de lecture il est toujours recommandé de le fermer (fonction fclose). Parmi la multitude de fonctions permettant de lire ou d’écrire les données, nous retenons fscanf, textscan et getl pour la lecture et fprintf pour l’écriture. Ces lignes montre un exemple : fid = fopen('fich.txt','w'); % ouverture en ecriture : 'w'

a = 3.14159; % valeur réelle a

fprintf(fid,'a = %5.4f',a); % écriture de a avec un format

fclose(fid); % fermeture du fichier

fid = fopen('fich.txt','r'); % réouverture en lecture : 'r'

b = fscanf(fid,'a = %f',1) % lecture d’une valeur (même format)

fclose(fid); % fermeture du feichier



36

Ouvrir MATLAB

Créer deux matrices A et B de 3×3 dans la fenêtre de commande

Créer un vecteur colonne a et un vecteur ligne b de longueur 3

Calculer les transposées des matrices A, B et des vecteurs a, b.

Calculer A + B et A – B.

Calculer A * B et A .* B, commenter

Calculer les vecteurs x = A \ b et r = A * x.

Calculer les vecteurs x = a / A et r = x * A.

Calculer les matrices X = A/B et X = A\B, vérifier A*X, X*A, B*X et X*B

Calculer les matrices X = A./B et X = A.\B (mêmes vérifications en 9)

Calculer les matrices R = A^2, R = A.^2 et R = A.^B, commenter

Calculer (A’\a’)’ et R = (b’\A’)’, commenter

Calculer inv(A)*b et a*inv(A) , commenter

Calculer a*b , b*a, b’*a, a’*b, b’*a’, commenter

Calculer a.*b , b.*a, b’.*a, a’.*b, b’.* a’, commenter

Créer trois fonctions pour les trois rotations 3D autour des axes x, y et z. Calculer une matrice de rotation R composée d’une rotation de 30° autour de x de 60° autour de y et de 45° autour de z. Calculer ensuite Ar = R’*A*R.

Comparer trace(A), trace(Ar), et eig(A), eig(Ar). Commenter

Créer un fichier de commandes à l’aide de l’éditeur MATLAB et refaire 2 à 10.

Créer un fichier texte contenant les éléments d’une matrices 3×3 et charger la matrice à l’aide d’une ligne de commande.



37

2%

Créer la matrice A en utilisant la fonction diag et un vecteur b avec un pas fixe A =

1 1 0

1 2 2

0 2 3

b =

1

2

3

Résoudre le système d’équations A x = b en utilisant :

1) L’opérateur de division,

2) La décomposition LU,

3) La décomposition QR.

Utiliser help pour les fonctions diag, LU et QR. Exemple help lu.

! . 3

Ecrire des scripts MATLAB qui permettent de :

1) Calculer le tenseur des déformations en fonction du tenseur des contraintes

en utilisant la relation ε = (1 + ν)/E σ − ν/E s I.

2) Calculer le tenseur des contraintes en fonction du tenseur de déformation

en utilisant la relation σ = 2 µ ε + λ e I .

3) Calculer les relations σ = D ε et ε = C σ en utilisant l’écriture vectorielle et

la matrice d’élasticité D, vérifier que C −1 = D

4) Calculer les contraintes et directions principales

5) Vérifier qu’une rotation de 60° autour de y donne les directions principales

du tenseur des contraintes σ pris en exemple ci-dessous

6) Vérifier les invariants des contraintes et les invariants des déformations



38

7) Calculer le vecteur contrainte et le vecteur déformation sur une normale n.

8) Calculer la contrainte normale et la dilatation unitaire suivant la normale n.

9) Proposer une structure de plusieurs fichiers fonctions pour ce type de problème

Prendre comme exemple, le tenseur des contraintes :

−

−=σ

130330250

3307

MPa ,

Le module d’élasticité : E = 200 000 MPa, Le module de Young : ν = 0.25 et

Le vecteur normale : n = [ 1/√3 1/√3 1/√3 ]T

Rappel :

µµ

µµ+λ

λµ+λλλµ+λ

=

202002000200020002

Sym

D ;

ν+ν+

ν+

ν−ν−ν−

=

101001000100010001

1

SymE

C

I1 = σii = σI + σII + σIII ;

I2 = ½(σii σjj − σij σji) = σIσII + σIIσIII + σIIIσI ;

I3 = det(σ) = σIσIIσIII.

λ = νE /(1−2ν)(1+ν) ; 2µ = E/(1+ν)



39

'

2 "

Pour analyser un phénomène naturel en générale ou un problème d’ingénierie en particulier, on est souvent amené à développer un modèle mathématique pouvant décrire d’une manière aussi fiable que possible le problème en question. Le développement d’un modèle mathématique s’appuis généralement sur quelques postulats de base et plusieurs hypothèses simplificatrices pour aboutir à des équations gouvernantes qui sont souvent des équations différentielles auxquelles sont ajoutées des conditions aux limites. Exemple, la théorie d’élasticité s’appuis sur le postula fondamental de l’existence du vecteur contrainte et les équations générales d’élasticité linéaire isotrope sont obtenues avec les hypothèses de petites déformations, d’homogénéité et d’isotropie des matériaux ainsi que la linéarité des relations liants les contraintes et les déformations.

La résolution analytique d’équations différentielles pose parfois des difficultés insurmontables, et une solution exacte décrivant bien le problème étudié n’est pas toujours facile à trouver. Le recours aux modèles physiques et à la simulation expérimentale pour la recherche d’une solution analogue à la solution recherchée peut s’avérer coûteux en temps et en moyens. Cependant, avec les progrès enregistrés dans le domaine de l’informatique et les performances des ordinateurs de plus en plus grandes, il est devenu possible de résoudre des systèmes d’équations différentielles très complexes. Plusieurs techniques de résolution


Cours : Méthode des éléments finis Chapitre 2 : Présentation de la méthode

40

numérique ont été ainsi développées et appliquées avec succès pour avoir des solutions satisfaisantes à des problèmes d’ingénierie très variés.

La méthode des éléments finis est l’une des techniques numériques les plus puissantes. L’un des avantages majeurs de cette méthode est le fait qu’elle offre la possibilité de développer un programme permettant de résoudre, avec peu de modifications, plusieurs types de problèmes. En particulier, toute forme complexe d’un domaine géométrique où un problème est bien posé avec toutes les conditions aux limites, peut être facilement traité par la méthode des éléments finis.

Cette méthode consiste à diviser le domaine physique à traiter en plusieurs sous domaines appelés éléments finis à dimensions non infinitésimales. La solution recherchée est remplacée dans chaque élément par une approximation avec des polynômes simples et le domaine peut ensuite être reconstitué avec l’assemblage ou sommation de tous les éléments.

4 (

La méthode des éléments finis est le fruit de deux domaines de recherche : Les mathématiques et les sciences de l'ingénieur. Les outils mathématiques remontent jusqu'aux résidus pondérés de Gauss (1775), Galerkin (1915) et Biezenokoch (1923), ainsi qu'aux méthodes variationnelles de Rayleigh (1870) et Ritz (1909). La contribution des sciences de l'ingénieur a débuté dans les années quarante avec Hrenikoff (1941), Henry (1943) et Newmark (1949) qui touchèrent pour la première fois aux structures continues, en faisant une approximation sur des portions de petites dimensions dans un problème continue d'une barre longue. D'où l'idée de base des éléments finis. Par suite, Argyris (1955), Turner (1956), Glough (1956) et Martin (1956) ont fait une analogie directe en adoptant un comportement simplifié pour des petites portions : ils représentent un milieu continu élastique à deux dimensions par un assemblage de panneaux triangulaires, sur lesquels les déplacements sont supposés variés linéairement comme pour chaque barre ou poutre du système discret : chaque panneau est décrit par une matrice de rigidité et l'assemblage donnait la rigidité globale du milieu continu. D'où la naissance d'éléments finis avec "panneaux" comme nom.



41

Argyris et Kelsy (1960) utilisent la notion d'énergie dans l'analyse des structures et font appel à des méthodes mathématiques (résidus pondérés, principes variationnels ...). Le terme " élément fini " est utilisé pour la première fois par Glough (1960), et dés lors, il y a un développement rapide de la méthode.

Dans les années soixante; Zienkiwicz (1965), De Arante (1968), Oliviera (1968), Green (1969), Tones (1969), Lay (1969), Storne (1969), et Finlayson (1975) ont reformulé la méthode à partir de considérations énergétiques et variationnelles sous forme générale de résidus pondérés, d'où le modèle mathématique de la MEF.

En 1969 la MEF est reconnue comme un outil général de résolution d'EDP, et utilisée pour résoudre des problèmes non linéaires et non stationnaires dans plusieurs domaines.

' '

Dans ce paragraphe, nous essayerons de présenter d'une manière simplifiée, les étapes d'application de la méthode des éléments finis et les outils nécessaires à sa mise en œuvre. La résolution d'un problème physique par éléments finis suit grosso modo les étapes suivantes (Fig. 2.1) :

Problème Physique

Modèle Mathématique

Formulation variationnelle

Discrétisation du domaine géométrique

Choix des fonctions d’interpolation

Ecriture des matrices élémentaires

Assemblage des matrices globales, Application des conditions aux limites

et Résolution du système globale

Figure 2.1 : Etapes générales de la méthode des éléments finis



42

Etape 1 : Formulation des équations gouvernantes et des conditions aux limites.

La majorité des problèmes d'ingénierie sont décrits par des équations différentielles aux dérivées partielles associées à des conditions aux limites définies sur un domaine et son contour. L'application de la MEF exige une réécriture de ces équations sous forme intégrale. La formulation faible est souvent utilisée pour inclure les conditions aux limites.

Etape 2 : Division du domaine en sous domaines.

Cette étape consiste à discrétiser le domaine en éléments et calculer les connectivités de chacun ainsi que les coordonnées de ses nœuds. Elle constitue ainsi la phase de préparation des données géométriques.

Etape 3 : Approximation sur un élément.

Dans chaque élément la variable tel que le déplacement, la pression, la température, est approximée par une simple fonction linéaire, polynomiale ou autres. Le degré du polynôme d'interpolation est relié au nombre de noeuds de l'élément. L'approximation nodale est appropriée. C'est dans cette étape que se fait la construction des matrices élémentaires.

Etape 4 : Assemblage et application des conditions aux limites.

Toutes les propriétés de l'élément (masse, rigidité,...) doivent être assemblées afin de former le système algébrique pour les valeurs nodales des variables physiques. C'est à ce niveau qu'on utilise les connectivités calculées à l'étape 2 pour construire les matrices globales à partir des matrices élémentaires.

Etape 5 : Résolution du système global :

Le système global peut être linéaire ou non linéaire. Il peut définir soit un problème d'équilibre, de valeurs critiques ou de propagation.

Le problème d’équilibre concerne les cas statiques et les cas stationnaires. Dans un problème de valeurs critiques, on s’intéresse aux fréquences et aux modes propres de vibrations du système physique étudié. Les problèmes de propagations,



43

concernent les cas transitoires dans lesquels sont déterminées les variations dans le temps des variables physiques. Les méthodes d'intégration pas à pas conviennent mieux pour ce type de problème. Les plus utilisées sont : méthode des différences finies centrales, méthode de Newmark, méthode de Wilson.

A ces méthodes doivent être associées des techniques d'itération pour traiter le cas non linéaire. La plus fréquente est la méthode de Newton Raphson.

"

Actuellement, le principe des travaux virtuels est bien connu et très répandu. Il est souvent formulé en termes d'égalité des travaux effectués par les forces extérieures et intérieures lors d'un déplacement virtuel quelconque. Ce concept est essentiel pour la résolution des équations aux dérivées partielles. En effet, les déplacements sont remplacés par une fonction arbitraire continue sur le domaine et l'équation est réécrite sous forme intégrale

"+

Un problème classique d’équations différentielles gouvernant un système physique s'énonce comme suit :

Trouver une fonction u ∈ V; V espace des fonctions, telle que :

A(u) = 0 | Ω ; B(u) = 0 | Γ (2.1)

où A(u) est l’ensemble d'équations gouvernantes définies sur le domaine Ω et B(u) est l'ensemble des conditions aux limites que les fonctions u doivent vérifier sur le contour Γ (fig.3.2). La fonction u peut être un scalaire tel que la température, la pression, … ou un vecteur tel que le déplacement, la vitesse, …

Ω

Γ

A(u) = 0

B(u) = 0

Figure 2.2 : domaine géométrique et contour



44

Le problème variationnel associé au système (2.1) s'écrit en prenant l’intégrale du système d’équations gouvernantes pondérées par des fonctions poids, l’énoncé devient :

Trouver u ∈ V tel que :

0)(: =Ω∈∀ ΩduAwVw (2.2)

Cette équation est appelée forme intégrale forte de l'équation différentielle (ou du système d’équations différentielles). Elle est analogue à l'expression des travaux virtuels. En fait la solution de (2.2) a encore plus de portée, on peut affirmer que si elle est satisfaite pour toute fonction poids w, alors l'équation différentielle (2.1) est

satisfaite en tout point du domaine Ω.

On considère l’équation différentielle du second ordre suivante :

01)( 2

2

=−+= xdx

uduA ; 0 ≤ x ≤ 1 (2.3)

Définie dans le domaine unidimensionnel Ω = [0, L] avec les conditions aux limites :

u( x = 0 ) = 0 et u( x = 1 ) = 0 (2.4)

Dans ce cas B(u) est l’ensemble des valeurs imposées aux deux bords du domaine.

En unidimensionnel, Γ se réduit à deux points. Le forme intégrale associée à l’équation A(u) s’écrit :

0)1( 2

2

=Ω−+ Ωdx

dxud

w ; −=1

0

1

0 2

2

)1( dxxwdxdx

udw (2.5)

Avec la forme des termes à intégrer, on voit que la recherche de solutions approximatives pour la fonction inconnue u, requiert l’utilisation de polynômes ou de fonctions d’interpolation dérivables au moins deux fois. De plus les conditions aux limites doivent être vérifiées à part puisqu’elles n’interviennent pas dans l’équation intégrale ci-dessus, d’où l’introduction de la forme intégrale faible.



45

"+*

Pour satisfaire les conditions aux limites nous avons deux manières de procéder; soit par le choix de la fonction de pondération, soit vérifier que :

0)( =Γ ΓduBw (2.6)

Dans la pratique, il est possible d'intégrer (2.2) par partie et de la remplacer par :

ΓΩ=Γ+Ω 0)()()()( duFwEduDwC (2.7)

Les opérateurs C, D, E et F contiennent des dérivées d'ordre moins élevé, d'où un choix de fonctions d’approximation de u plus large.

Cette équation est la formulation faible de l'équation différentielle, elle forme la base de l'approximation par éléments finis.

Remarque : Pour obtenir de telle formulation intégrales, nous disposons de deux procédés : le premier est la méthode des résidus pondérés connue sous le nom de la méthode de Galerkin, le deuxième est la détermination de fonctionnelles variationnelles que l'on cherche à rendre stationnaire.

Dans la pratique, il n'est pas toujours facile de trouver une fonctionnelle. Le

premier procédé est plus utilisé; il consiste à choisir w = δu fonction de Dirac (une perturbation de la fonction cherchée) et d'utiliser l'approximation nodale pour la discrétisation. w s'appelle aussi fonction poids d'où le mot : "pondéré".

Pour obtenir la forme variationnelle faible de l’exemple précédent (équation 2.5) on intègre par partie le premier terme.

−=

+−1

0

1

0

1

0)1( dxxw

dxdu

wdxdxdu

dxdw

(2.8)

On voit maintenant que les conditions aux limites notamment sur les dérivées sont explicitement prises en compte dans l’équation. Les valeurs imposées à la fonction elle-même seront traitées lors de la résolution des systèmes discrets.



46

! .

La méthode des éléments finis est une méthode d'approximation par sous domaines, donc avant toute application il faut diviser le domaine à étudier en éléments. Chaque élément est défini géométriquement par un nombre de noeuds bien déterminé qui constituent en général ses sommets. (Fig. 2.3)

La discrétisation géométrique doit respecter les règles suivantes :

1) Un nœud d'un élément ne doit pas être intérieur à un côté d'un autre du même type. (Fig. 2.4 a)

2) Aucun élément bidimensionnel ne doit être plat, éviter les angles proches de 180° ou de 0°. (Fig. 2.4 b)

3) Deux éléments distincts ne peuvent avoir en commun que des points situés dans leurs frontières communes ; le recouvrement est exclu. (Fig. 2.4 c)

4) L'ensemble de tous éléments doit constituer un domaine aussi proche que possible du domaine donné ; les trous entre éléments sont exclus. (Fig. 2.4 d)

Frontière du domaine

Nœud frontière

Élément

Nœud interne

Figure 2.3 : Discrétisation du domaine – éléments triangulaires

(a)

(b) (c)

(d)

Figure 2.4 : Règles de discrétisation



47

Le résultat du procédé de discrétisation doit contenir deux données essentielles qui sont les coordonnées des noeuds et les connectivités des éléments. On doit numéroter tous les noeuds et les éléments de façon à avoir des matrices globales à petite largeur de bande, pour cela, la numérotation se fait selon la plus petite largeur du domaine.

# % 5

Après avoir défini l'élément, on peut remplacer la fonction exacte par une approximative. On utilise souvent des polynômes ou des fonctions faciles à mettre en oeuvre sur ordinateur.

# %1%

La fonction approchée est exprimée, dans le cas unidimensionnel, par :

=

=n

i

ii xau

0

(3.9)

Qu’on peut écrire sous la forme matricielle suivante :

AxPa

a

xxu ><≡

>=< )(1 0

02

(3.10)

Cette forme d'approximation est appelée interpolation polynomiale. Si on exprime la fonction sur tous les noeuds on obtient pour chaque nœud i de coordonnée xi :

≡>=<j

jijii aPAxPu )( (3.11)

Soit pour tous les nœuds :

><><

><

=

.......

1

jjn

jj

aF

aP

U ≡ Un = Pn an (3.12)



48

Un : représente les valeurs aux nœuds de la fonction. Pn : valeurs des polynômes aux nœuds de coordonnées xi. an : variables généralisées qui sont les facteurs des polynômes.

L’inconvénient de cette interpolation réside dans l’utilisation des paramètres ai comme variable de base, des calculs supplémentaires sont nécessaires pour calculer la fonction recherchée u. Afin d’éviter ces calculs, on peut mettre les valeurs de la fonction u au nœuds comme variables de base en procédant comme suit :

A partir de l’équation (3.12), on peut tirer les an en fonction des un et on les remplace dans l’équation (3.10). Ce qui donne :

nnn UxNUPxPu ><≡>=< − )()( 1 (3.13)

C'est la forme la plus utilisée par le fait que ses variables sont les valeurs de la fonction aux noeuds, la résolution donne directement ces valeurs.

Ce type d’approximation est appelée interpolation nodale, les fonctions Ni sont appelées fonction de forme, elles sont fonction du type d’élément utilisé pour la discrétisation géométrique.

a. seghir, département de génie civil, université a. … · a. seghir, département de génie...

Documents